From 68f0759eef89692cdeb38cc1b87fa8c8785307fe Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Fri, 28 Aug 2026 16:30:09 +0800
Subject: [PATCH] fix(rectification): persist the next interview after a choice
 tap

Closing a discriminator used to leave GET without a card after refresh.
Write the next dated question in the same request, skip childhood career
and move probes, and do not continue a read-only turn when that question
is already persisted.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 docs/BUG_HISTORY.md                           | 132 ++++-
 .../src/app/api/rectification/agent/route.ts  |  11 +
 frontend/src/app/globals.css                  |  10 +
 .../components/rectification-agentic-chat.tsx | 142 ++++--
 .../components/rectification-choice-card.tsx  |  41 +-
 .../lib/rectification-agentic/v9/agent-run.ts |  85 +++-
 .../rectification-agentic/v9/answer-choice.ts | 138 ++++-
 .../rectification-agentic/v9/choice-action.ts |  25 +-
 .../rectification-agentic/v9/choice-card.ts   | 113 ++++-
 .../v9/method-followup.ts                     | 379 +++++++++++---
 .../rectification-agentic/v9/step-answer.ts   | 122 ++++-
 .../v9/stream-mapping.ts                      |   4 +
 .../v9/turn-narration.ts                      |  35 +-
 frontend/src/mastra/agentic-rectification.ts  |   2 +-
 frontend/src/mastra/rectification-v9-tools.ts |  13 +-
 .../rectification-activity-receipt.test.ts    |   1 +
 .../tests/rectification-agentic-entry.test.ts |  35 +-
 .../tests/rectification-answer-choice.test.ts | 470 +++++++++++++++++-
 .../tests/rectification-choice-card.test.ts   | 299 ++++++++++-
 .../rectification-decision-authority.test.ts  |  86 +++-
 .../tests/rectification-eight-method.test.ts  | 285 ++++++++++-
 .../tests/rectification-server-focus.test.ts  |   2 +-
 .../tests/rectification-step-answer.test.ts   |  82 ++-
 .../tests/rectification-v9-stream.test.ts     | 116 ++++-
 scripts/rectification/event_probes.py         |  48 +-
 tests/test_rectification_event_probes.py      |  90 ++++
 26 files changed, 2455 insertions(+), 311 deletions(-)

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 3a5c25a6..96983f1f 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -6080,7 +6080,7 @@
 
 - 状态：resolved（本地修复，待发布）
 - 首次发现：2026-08-26
-- 最近更新：2026-08-26
+- 最近更新：2026-08-28
 - 影响面：`scripts/rectification/event_probes.py`、relationship `dasha_boundary` 探针
 - 用户现象：感情卡可能询问出生后很早、明显不符合“认真关系进入或结束”语义的年份。
 - 触发条件：候选在未成年年份附近存在高区分度 Vimshottari 或 Narayana 边界，且该年份没有已记录事件挡住。
@@ -6088,7 +6088,7 @@
 - 修复：relationship 的 dasha boundary 从 `birth_year + age_lo` 开始；不使用 `age_hi` 作硬上限，避免排除成年后的真实关系事件。其他允许童年事件的领域保持原范围。
 - 验证：`/opt/anaconda3/bin/python3.12 -m pytest tests/test_rectification_event_probes.py -q`，15/15 通过；回归锁定未成年 relationship 年份被排除且 family 童年边界行为不回退。
 - 防复发：relationship boundary 不得早于 catalog `age_lo`；不得把 `age_hi` 当事实有效期。
-- 相关记录：BUG-379
+- 相关记录：BUG-379、BUG-417
 - 复发自：无
 - 修复版本：待发布
 
@@ -6221,6 +6221,134 @@
 - 复发自：BUG-405（排序公式对，目录被投影饿死，已打开低分卡锁题）
 - 修复版本：待发布
 
+## BUG-411 | 已持久化的 D24 区分卡在 GET 时被 active_focus 重建丢掉
+
+- 状态：resolved
+- 首次发现：2026-08-28
+- 最近更新：2026-08-28
+- 影响面：`buildMethodFollowupPlan` 已打开区分焦点、GET `choice_card`、生时纠正点选卡
+- 用户现象：训练事件已齐，助手记下感情经历后只说“对候选的区分有帮助”，不再追问，界面也没有点选卡。服务端其实已经创建了 D24 区分焦点。
+- 触发条件：目录赢家是推理层 `varga_contrast`（不在 Python `discriminating_event_probes` 里），该焦点已持久化，随后 GET 刷新卡片。公开分数字段可因 `credible_range` 与全窗候选不一致而被清空。
+- 根因：已打开的区分焦点只要还没被更高分探针替换，计划就改写成 `source=active_focus`。重建时只在 Python 事件探针里按 `targetDomain` 找 live probe。D24 只存在于对比包，education 域又没有 dasha 事件探针，于是 `semantic_key` 丢失、`choice_frame` 对不上已持久化的 `questionId`，GET `choice_card` 变成 null。Agent 被禁止在没有公开卡片时口述区分题，正文只剩确认句。
+- 修复：打开的区分卡若已经是当前目录赢家，继续用该赢家的 ranked discriminator 出题，不要改写成 active_focus。
+- 验证：`rectification-choice-card` 锁定「Python 事件探针没有教育行、D24 只在推理探针、焦点已持久化」时 GET 仍返回点选卡。
+- 防复发：不得把已打开且仍是目录赢家的分盘区分题改写成没有 `semantic_key` 的 `active_focus`。GET 有合法持久化区分焦点时不得把 `choice_card` 置空。
+- 相关记录：BUG-407、BUG-410
+- 复发自：BUG-410（决策已进入区分并持久化焦点，GET 仍把卡片藏掉）
+- 修复版本：待发布
+
+## BUG-412 | 反推点选卡丢掉已记下的年份月份，后两个选项收成一排小按钮
+
+- 状态：resolved
+- 首次发现：2026-08-28
+- 最近更新：2026-08-28
+- 影响面：`choice-card` `period` / `prompt`、GET `choice_card`、`rectification-choice-card` 点选样式
+- 用户现象：区分卡出现后题干写成「当前这几个候选 · 学业…」，已记下的入学年份和月份精度出不来。A/B/C 是整行主按钮，D「这段记不清楚」和「先这样」挤在下一排、更小、居中、颜色变淡。
+- 触发条件：目录赢家是没有 `year` 的 D24 `varga_contrast`，账本里已有同学业带日期经历；点选卡把 `unsure` 和停止键标成 `secondary`。
+- 根因：`periodFor` 只要找到探针就采用 `year_label`，对比包探针年份为 0 时标签是占位「当前这几个候选」，不再回落到同学业已确认经历。GET 又优先用已持久化的占位题干。选项按 `unsure=secondary` 拆到 `special-choices`，和停止键共用 flex 小按钮。
+- 修复：探针没有具体年份时，题干锁定同学业已确认经历的「YYYY 年前后」或月份精度的「YYYY 年 M 月前后」。GET 用更具体的服务端题干覆盖占位题干。A/B/C/D 和停止键同一列主按钮。
+- 验证：`rectification-choice-card` 锁定 D24 占位探针 + 2016 年学业经历 → 题干带「2016 年前后」；月份精度经历带出「M 月前后」；GET 仍把占位题干升级成年份锁。`rectification-eight-method` 锁定高分 D24 的 period 是已记学业年。`rectification-agentic-entry` 锁定点选卡不再拆 `special-choices`。
+- 防复发：不得在对比包年份为 0 时把「当前这几个候选」压过账本已确认年份。点选卡四个答案不得因为 `unsure` 改成另一套小按钮。
+- 相关记录：BUG-406、BUG-408、BUG-411
+- 复发自：BUG-411（卡片能投影后，占位年份和 secondary 拆行才被看见）
+- 修复版本：待发布
+
+## BUG-413 | 点选后卡片消失，只留下一条自动发出的选项气泡
+
+- 状态：resolved
+- 首次发现：2026-08-28
+- 最近更新：2026-08-28
+- 影响面：生时纠正点选卡停留与选中态、`choice_click` 用户气泡、D24/发挥质量题干
+- 用户现象：点 A/B/C/D 或「先这样」后卡片立刻从对话里消失，底下多出一条用户自己点出来的 `A. 发挥明显失常…`。同一张卡不能再看见选中项。题干写成「2016 年前后 · 学业、考试发挥或学习压力出现明显变化」，像目录锁标签。
+- 触发条件：GET 已出示点选卡；用户点击任一选项。`showChoiceCards` 在 `busy` 时卸载卡片，并把 `choiceCardUserMessage` 追加成用户消息。
+- 根因：点选被做成「发一条用户消息 + 等下一轮」，卡片只挂在最新未 busy 的助手气泡上。题干走 `period · family` 锁标签；对比包发挥质量又不分领域，一律套学业考试目录句。
+- 修复：点选后把卡片钉在出题的那条助手消息上，保留 `data-selected`，禁用再点；不再插入自动用户气泡，刷新时也藏掉 `A. …` / 「先这样」这类合成行。发挥质量题干改成年份锁定的口语问句，并按领域区分家族，不再用「当前这几个候选 · 学业…」目录锁。
+- 验证：`rectification-choice-card` 锁定 D24 题干是「2016 年前后，有没有学业或考试发挥失常、压力特别大的时候？」；GET 把已持久化的目录锁升级成这句。`rectification-agentic-entry` 锁定 `choiceAttachment` 停留、不再创建 `v9-choice-user-` 气泡。`rectification-answer-choice` 锁定合成点选行不是聊天用户句。
+- 防复发：点选卡不得因为 `busy` 从已回答的助手气泡上卸掉。点选不得再追加 `A. 标签` 用户气泡。题干不得再把 `period · family` 目录锁直接展示给用户。
+- 相关记录：BUG-405、BUG-406、BUG-412
+- 复发自：BUG-412（卡片能看清后，点选消失和目录题干才被看见）
+- 修复版本：待发布
+
+## BUG-414 | 无年份家人反推仍出点选卡
+
+- 状态：resolved
+- 首次发现：2026-08-28
+- 最近更新：2026-08-28
+- 影响面：生时纠正点选卡 `eventQuestionPrompt`、`buildChoiceFrame`、`rankRenderableDiscriminators`、家人存在性家族、GET 题干覆盖
+- 用户现象：D24 点选之后出现「那段时间，有没有家人相关的明显变化？」。没有具体年份，事件也不是一件能点是/否的家事。改成「有没有家人结婚、添丁或住院？」后仍缺时间，无法反推。
+- 触发条件：家人域没有已记带日期经历；区分探针年份为 0（D12 分盘对比）；或目录家族仍是「家人相关的明显变化」。
+- 根因：口语题干用 `period + 有没有 + event_family` 拼接。D12 对比探针没有年份，同域也没有带日期证据，`period` 落成占位「那段时间」。第一轮误修成去掉年份、只问「有没有发生过」。反推点选必须锁在具体年/月上，没有时间就不能计分。
+- 修复：存在性 / 发挥质量点选在锁不住具体年份时失败关闭，不出卡。目录跳过无年份 D12，改问下一条有年份的区分题；若没有，用自然语言采集一件记得住时间的家事。已记家人年份时题干为「2018 年前后，有没有家人结婚、添丁或住院？」。各域存在性家族改成可核对的口语事件。GET 把已持久化的「那段时间 / 目录锁」升级成带年份的新句。
+- 验证：`rectification-choice-card` 锁定无年份家人帧为 `null`；有引擎年份的家事探针才带年。`rectification-eight-method` 锁定无年份 D12 让位给有年份的事业探针，或退回家人自然语言采集；已开的无年份家人卡不再保持评分帧。无年份 D24 不得借用账本学业年。方法层齐后剩下无年份 D4 时，先用自然语言问记得住时间的搬家，不出无年份点选卡。
+- 防复发：评分用 A/B/C/D 反推不得用「那段时间」或无年份的「有没有发生过」顶时间。不得用年龄带中点发明年份。家人存在性家族不得再展示「家人相关的明显变化」。
+- 相关记录：BUG-412、BUG-413
+- 复发自：BUG-413（锁标签改成「有没有 + 家族」后，空年份仍被当成可问的点选卡）
+- 修复版本：待发布
+
+## BUG-415 | 反推点选借用账本年份，点选后又多一条确认气泡
+
+- 状态：resolved
+- 首次发现：2026-08-28
+- 最近更新：2026-08-28
+- 影响面：生时纠正点选卡 `periodFor`、冲突探针去重、`answer_choice` 续跑、`bindSpokenToOpenQuestion`
+- 用户现象：点选卡问「2016 年前后有没有学业或考试发挥失常」。该年不是候选分钟反推出来的，而是账本里已记的学业年。点选 A/B/C/D 后先出现「已记录你的选择，并更新了候选比较。」，再出现工具「读取校正记录」和第二条确认/下一问。
+- 触发条件：D24 `event_quality` 探针年份为 0，同领域已有带日期证据；同时 Python 已给出另一领域带月份的 dasha 冲突探针。点选成功且 `nextAction` 仍要继续提问。
+- 根因：评分反推把账本同领域年份当成锁年。冲突探针按整个领域去重，已有事业经历后不再问 2012 年 11 月事业边界。点选成功会持久化确认 turn，客户端再把它落成助手气泡，随后 `read_only` 续跑又写第二条。
+- 修复：存在性 / 发挥质量点选只认引擎探针年或月，不再回落到账本同领域年份。冲突探针按年去重，同年跳过、不同年继续问。无年份 D24 让位给带年份的 dasha 题。点选后续跑时不写确认 turn，客户端丢掉点选占位气泡，只保留续跑那一条；续跑正文去掉「已记录选择 / 请看下方选项」。
+- 验证：`rectification-choice-card` 锁定无年份 D24 不得借用 2016 学业年，GET 展示 2012 年 11 月事业题。`rectification-eight-method` 锁定同年事业探针跳过、不同年仍问，无年份 D24 让位给 2023 事业 dasha。`rectification-answer-choice` 锁定续跑不写 `append_agentic_rectification_turn`，「先这样」仍写。`rectification-v9-stream` 锁定点选确认句被剥掉。
+- 防复发：评分 A/B/C/D 反推不得用账本同领域已记年份顶引擎时间。冲突探针不得按领域整段跳过。点选后续跑不得再展示独立确认气泡。
+- 相关记录：BUG-402、BUG-411、BUG-412、BUG-414
+- 复发自：BUG-414（无年份家人卡修好后，无年份 D24 仍借用学业年）；BUG-402（续跑补上后多写了一条确认）
+- 修复版本：待发布
+
+## BUG-416 | 生时纠正口语被攒到整轮结束，点选后续跑不再逐字出现
+
+- 状态：resolved
+- 首次发现：2026-08-28
+- 最近更新：2026-08-28
+- 影响面：`runV9AgentTurn`、`step-answer`、公开 `answer.delta`、生时纠正聊天气泡
+- 用户现象：工具活动仍会更新，但助手正文不再边生成边出现；点选卡回合尤其明显，进度走完后整段或占位句一次性弹出。
+- 触发条件：生时纠正对话里模型在工具之后写口语；当前有 `open_question` / 点选卡时更重。
+- 根因：BUG-373 把含工具调用的 step 的 `text-delta` 整段丢掉，只在 `step-finish` 发布终端步，口语无法按 token 直播。随后 `open_question` 把已写出口语放进 `heldSpoken`，等到流结束再 `bindSpokenToOpenQuestion` 一次性发出。点选续跑还会把确认句剥掉，用户先看到长时间空白。
+- 修复：终端中文在比对/结果类工具之后按 `text-delta` 直播；未解锁时等到中文句末再开始直播。规划英文和工具步正文仍丢弃。有点选锁时边生成边绑定，缩短则发 `replace` 覆盖，不再等到 flush。客户端按 `replace` 重写气泡。
+- 验证：`rectification-step-answer` 锁定比对后分片直播、工具步英文不进 `answer.delta`、直播后若再调工具则 retract。`rectification-v9-stream` 锁定比对后两段 `answer.delta` 按序到达，点选锁下确认句直播且不问句、timeout 仍用占位句。`rectification-activity-receipt` / `rectification-agentic-entry` 锁定客户端 `replace`。
+- 防复发：有 `open_question` 时不得把口语攒到 `flushPersistedPrompt`。禁止把含工具调用的 step 的规划句留给浏览器。`answer.delta` 若会缩短必须带 `replace`，客户端不得只做 `raw +=`。
+- 相关记录：BUG-373、BUG-377、BUG-415
+- 复发自：BUG-373（隔离终端步后不再按 token 发布）；BUG-415（点选绑定把已推迟的口语又剥成空白）
+- 修复版本：待发布
+
+## BUG-417 | 未成年事业/搬家点选，点选后续跑复述旧经历并因截断报未完成
+
+- 状态：resolved
+- 首次发现：2026-08-28
+- 最近更新：2026-08-28
+- 影响面：`event_probes.py` dasha boundary、`method-followup` 年龄下限、`bindSpokenToOpenQuestion`、点选后续跑 `answer_truncated`
+- 用户现象：1997 年出生后被问「2012 年 11 月有没有入职升职」「2005 年 5 月有没有搬家离乡」。点选后续跑正文反复说「实习和离职都记下了」。选 C 后出现「回答未完成，已保留现有内容；本次不会扣点。」
+- 触发条件：候选在童年/少年有高区分度大运边界；账本已有事业或感情经历；点选后续跑模型复述旧确认并写满长度。
+- 根因：BUG-399 只给感情加了 catalog `age_lo`，事业/搬家/学业仍从出生后 5 年起算。邻近年去重只覆盖学业。点选锁只剥问句，不剥跨领域确认。`finish_reason=length` 即使已有 `open_question` 也走失败，超时则不会。
+- 修复：成人语义领域（学业/搬家/感情/事业/财务/健康）的 dasha 边界都从 `birth_year + age_lo` 起算，仍不用 `age_hi` 作硬上限。家人事件仍从出生后 5 年起算。感情/事业/搬家存在性探针跳过邻近年。点选锁下跨领域确认句丢掉。有点选锁时长度截断与超时一样收成成功占位句，不报未完成。
+- 验证：`tests/test_rectification_event_probes.py` 锁定 1997 年出生不得出 2012 事业、2005 搬家，已记 2024 感情不得再问 2023。`rectification-eight-method` 锁定出生日期过滤童年事业探针、邻近年感情探针。`rectification-v9-stream` 锁定搬家/感情锁下丢掉实习确认，以及 `open_question` + `length` 仍 `run.completed`。
+- 防复发：成人语义事件家族不得用出生后 5 年当地板；家人事件仍允许童年年。点选续跑不得把上一件经历的确认句带到另一领域卡片。有 `open_question` 时 `answer_truncated` 不得再把整轮标失败。
+- 相关记录：BUG-399、BUG-415、BUG-416
+- 复发自：BUG-399（只修了感情未成年年）
+- 修复版本：待发布
+
+## BUG-418 | 点选后刷新，助手说请点选但 GET 没有卡片
+
+- 状态：resolved
+- 首次发现：2026-08-28
+- 最近更新：2026-08-28
+- 影响面：`applyRectificationChoice`、GET `choice_card`、点选后续跑
+- 用户现象：点完区分题后助手仍写「接下来有一个问题需要您点选一下」，刷新后这条还在，下方没有点选卡。`GET` 的 `choice_card` 为 `null`。账本里该问已经答过。
+- 触发条件：训练门已开、当前区分焦点被点选关闭；同一请求没有写下一条焦点。客户端按 `nextAction` 再开一轮只读续跑。刷新发生在续跑写完新焦点之前。
+- 根因：GET 投影卡片必须有已持久化的焦点 UUID。点选只关闭当前焦点，下一条区分题或带年份的采集问要等后续 Agent 轮。续跑失败、截断或用户刷新时，界面只剩「请点选」占位，没有可点的卡。无年份 D24 也不能顶成评分卡。
+- 修复：点选成功后在同一请求里按更新后的推断状态排出下一问。下一条是带年份的区分题就写入新焦点，正文改成「接下来请点选下面这一问。」；下一条是家人等采集就写入带年份的口语问，不出无年份 D24 卡。这两种都不再自动续跑。
+- 验证：`rectification-answer-choice` 锁定答完搬家区分题后持久化 2014 学业卡，刷新 GET 仍有 `focus_id`。只剩已答区分题时写入 2021 年家人采集口语，不调用 set-focus。`rectification-eight-method` 锁定家人采集带上 collection-probe 年份。`shouldContinueAfterStructuredChoice` 在 `nextInterviewPersisted` 时为 false。
+- 防复发：点选关闭焦点后，同一请求必须留下下一问（新焦点或口语采集）。不得在 GET `choice_card` 为空时继续展示「请点选」。无年份 D24 不得在点选后变成评分卡。
+- 相关记录：BUG-411、BUG-410、BUG-413、BUG-414、BUG-415、BUG-417
+- 复发自：BUG-411（已持久化的卡会被丢掉；这里是下一问根本没持久化）
+- 修复版本：待发布
+
 ## BUG-410 | 训练已齐仍因家人/职业方法层停在采集，Agent 只确认后截断
 
 - 状态：resolved
diff --git a/frontend/src/app/api/rectification/agent/route.ts b/frontend/src/app/api/rectification/agent/route.ts
index fe81a81e..283c80a0 100644
--- a/frontend/src/app/api/rectification/agent/route.ts
+++ b/frontend/src/app/api/rectification/agent/route.ts
@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
 import { z } from "zod";
 import { getRectificationV9Agent, type RectificationAgentAction } from "@/mastra/agentic-rectification";
 import {
+  loadV9CaseCompute,
   loadV9CaseDossier,
   persistV9DeterministicTurn,
   RectificationToolServiceError,
@@ -280,6 +281,8 @@ export async function POST(request: Request) {
         sourceQuote: applied.sourceQuote,
         derivedContext: applied.derivedContext,
         nextAction: applied.nextAction,
+        nextInterviewPersisted: applied.nextInterviewPersisted,
+        nextChoiceReady: applied.nextChoiceReady,
       });
     } catch (error) {
       if (error instanceof RectificationToolServiceError) {
@@ -386,11 +389,19 @@ export async function POST(request: Request) {
             dossier.latestResult,
             dossier.evidence,
           );
+          let birthDate: string | null = null;
+          try {
+            const compute = await loadV9CaseCompute(accounting, userId, caseId);
+            birthDate = String(compute.baselineBirthSnapshot.birth_date ?? "") || null;
+          } catch {
+            // Ranking stays fail-open when compute is unavailable.
+          }
           const plan = buildMethodFollowupPlan({
             evidence: dossier.evidence,
             declinedTopics: dossier.conversationSummary.declinedSkippedTopics,
             sessionOutcome: "discriminate_candidates",
             ...catalog,
+            birthDate,
             candidatesSeparated: false,
           });
           const persisted = await persistServerOwnedFocus({
diff --git a/frontend/src/app/globals.css b/frontend/src/app/globals.css
index 815dbb51..e86f560f 100644
--- a/frontend/src/app/globals.css
+++ b/frontend/src/app/globals.css
@@ -2707,6 +2707,16 @@ input:not([type="radio"]):not([type="checkbox"]):not([class^="ant-"]):not([class
   border-radius: var(--radius-lg);
   background: var(--color-canvas-soft);
 }
+.rectification-choice-card .birth-time-choice-question:disabled .birth-time-choice-option {
+  cursor: default;
+  opacity: .48;
+}
+.rectification-choice-card .birth-time-choice-question:disabled .birth-time-choice-option[data-selected="true"] {
+  opacity: 1;
+}
+.rectification-choice-card.is-pending .birth-time-choice-question:disabled .birth-time-choice-option:not([data-selected="true"]) {
+  cursor: wait;
+}
 .rectification-message-wrap .rectification-choice-card {
   width: calc(100% - var(--assistant-content-inset));
   margin: var(--space-3) 0 var(--space-4);
diff --git a/frontend/src/components/rectification-agentic-chat.tsx b/frontend/src/components/rectification-agentic-chat.tsx
index 42ac98bd..2b536590 100644
--- a/frontend/src/components/rectification-agentic-chat.tsx
+++ b/frontend/src/components/rectification-agentic-chat.tsx
@@ -50,14 +50,13 @@ import { isNearBottom, shouldShowJumpToLatest } from "@/lib/rectification-sticky
 import {
   CHOICE_ACTION,
   STOP_ACTION,
+  isStructuredChoiceUserText,
   shouldContinueAfterStructuredChoice,
   stableChoiceActionKey,
   type ChoiceOptionId,
 } from "@/lib/rectification-agentic/v9/choice-action";
 import { finalizeRectificationSpokenAndThinking } from "@/lib/rectification-agentic/v9/spoken-answer";
 import {
-  CHOICE_STOP_MESSAGE,
-  choiceCardUserMessage,
   isPersistedFocusId,
   parseRectificationChoiceCard,
   type ChoiceKey,
@@ -164,12 +163,18 @@ type RectificationAgenticChatProps = Readonly<{
   headerSlot: HTMLElement | null;
 }>;
 
+type SettledChoiceAttachment = Readonly<{
+  card: ChoiceCardModel;
+  selectedKey: ChoiceKey | "stop";
+}>;
+
 type RenderMessage = ChatMessageView & {
   renderKey: string;
   completedReceipt?: CompletedActivityReceiptView;
   failed?: boolean;
   turnId?: string;
   activityTrace?: readonly AgentActivityTraceItem[];
+  choiceAttachment?: SettledChoiceAttachment;
 };
 
 function turnOfferedSelection(message: RenderMessage): boolean {
@@ -241,6 +246,7 @@ function messagesFromTurns(initialTurns: readonly PersistedTurn[]): RenderMessag
       }];
     }
     if (isIncompleteRunBanner(turn.text ?? "")) return [];
+    if (isStructuredChoiceUserText(turn.text)) return [];
     return [{
       role: "user",
       text: turn.text ?? "",
@@ -517,6 +523,7 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
             type?: unknown;
             status?: unknown;
             text?: unknown;
+            replace?: unknown;
             message?: unknown;
             tool?: unknown;
             methods?: unknown;
@@ -531,7 +538,7 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
           }
           if (typeof event.type !== "string") continue;
           if (event.type === "answer.delta" && typeof event.text === "string") {
-            raw += event.text;
+            raw = event.replace === true ? event.text : raw + event.text;
             activityTrace = freezeLiveThink(activityTrace);
             setMessages((current) => current.map((message) => message.renderKey === assistantRenderKey
               ? {
@@ -747,18 +754,26 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
     }
     const questionId = choiceCard.question_id;
     const actionId = actionIdForChoice(focusId, optionId);
-    const userText = optionId === "stop"
-      ? (choiceCard.stop_message || CHOICE_STOP_MESSAGE)
-      : choiceCardUserMessage(choiceCard, optionId);
+    const answeredCard = choiceCard;
+    const offeringRenderKey = [...messages].reverse().find((message) => (
+      message.role === "assistant"
+      && message.state === "settled"
+      && Boolean(message.text)
+      && !message.choiceAttachment
+    ))?.renderKey ?? null;
     setError("");
-    setPending(true);
     keyCounter.current += 1;
     const turnKey = keyCounter.current;
-    const userRenderKey = `v9-choice-user-${turnKey}`;
     const assistantRenderKey = `v9-choice-assistant-${turnKey}`;
     setMessages((current) => [
-      ...current,
-      { role: "user", text: userText, renderKey: userRenderKey, state: "settled" },
+      ...current.map((message) => (
+        offeringRenderKey && message.renderKey === offeringRenderKey
+          ? {
+            ...message,
+            choiceAttachment: { card: answeredCard, selectedKey: optionId },
+          }
+          : message
+      )),
       {
         role: "assistant",
         text: "",
@@ -772,6 +787,7 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
         },
       },
     ]);
+    setPending(true);
     try {
       const response = await fetch("/api/rectification/agent", {
         method: "POST",
@@ -793,9 +809,13 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
       });
       const payload = await response.json().catch(() => null);
       if (!response.ok) {
-        setMessages((current) => current.filter((message) => (
-          message.renderKey !== userRenderKey && message.renderKey !== assistantRenderKey
-        )));
+        setMessages((current) => current.flatMap((message) => {
+          if (message.renderKey === assistantRenderKey) return [];
+          if (offeringRenderKey && message.renderKey === offeringRenderKey) {
+            return [{ ...message, choiceAttachment: undefined }];
+          }
+          return [message];
+        }));
         setChoiceNonce((current) => current + 1);
         if (payload?.code === "profile_incomplete") {
           onProfileIncomplete?.();
@@ -804,30 +824,36 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
         setError(payload?.message || payload?.error || `请求失败（${response.status}）`);
         return;
       }
-      const narration = typeof payload?.narration === "string" && payload.narration.trim()
-        ? payload.narration.trim()
-        : "已记录你的选择。";
-      setMessages((current) => current.map((message) => message.renderKey === assistantRenderKey
-        ? {
-          ...message,
-          text: narration,
-          state: "settled" as const,
-          activity: undefined,
-        }
-        : message));
-      onMessagesChange?.([
-        { role: "user", text: userText },
-        { role: "assistant", text: narration },
-      ]);
+      const willContinue = shouldContinueAfterStructuredChoice(payload?.nextAction, payload);
       onCompleted?.();
       await loadCaseSnapshot();
-      if (shouldContinueAfterStructuredChoice(payload?.nextAction)) {
+      if (willContinue) {
+        setMessages((current) => current.filter((message) => message.renderKey !== assistantRenderKey));
         choiceContinuationPending.current = true;
+      } else {
+        const narration = typeof payload?.narration === "string" && payload.narration.trim()
+          ? payload.narration.trim()
+          : "已记录你的选择。";
+        setMessages((current) => current.map((message) => message.renderKey === assistantRenderKey
+          ? {
+            ...message,
+            text: narration,
+            state: "settled" as const,
+            activity: undefined,
+          }
+          : message));
+        onMessagesChange?.([
+          { role: "assistant", text: narration },
+        ]);
       }
     } catch {
-      setMessages((current) => current.filter((message) => (
-        message.renderKey !== userRenderKey && message.renderKey !== assistantRenderKey
-      )));
+      setMessages((current) => current.flatMap((message) => {
+        if (message.renderKey === assistantRenderKey) return [];
+        if (offeringRenderKey && message.renderKey === offeringRenderKey) {
+          return [{ ...message, choiceAttachment: undefined }];
+        }
+        return [message];
+      }));
       setChoiceNonce((current) => current + 1);
       setError("选择题处理失败，请稍后重试。");
     } finally {
@@ -839,6 +865,7 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
     caseId,
     choiceCard,
     loadCaseSnapshot,
+    messages,
     onCompleted,
     onMessagesChange,
     onProfileIncomplete,
@@ -994,32 +1021,45 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
       && Boolean(message.text)
     ));
   const offeredSelectionOnce = messages.some(turnOfferedSelection);
-  const offeredThisTurn = Boolean(latestSettledAssistant && turnOfferedSelection(latestSettledAssistant));
-  const showChoiceCards = Boolean(
+  const answeredQuestionIds = new Set(
+    messages.flatMap((message) => message.choiceAttachment
+      ? [message.choiceAttachment.card.question_id]
+      : []),
+  );
+  const liveChoiceHost = [...messages]
+    .reverse()
+    .find((message) => (
+      message.role === "assistant"
+      && message.state === "settled"
+      && Boolean(message.text)
+      && !message.choiceAttachment
+    ));
+  const showLiveChoiceCard = Boolean(
     choiceCard
-    && latestSettledAssistant
-    && !offeredThisTurn
+    && liveChoiceHost
+    && !answeredQuestionIds.has(choiceCard.question_id)
+    && !turnOfferedSelection(liveChoiceHost)
     && !busy
     && !readonly
     && regeneratingMessageKey === null,
   );
   useLayoutEffect(() => {
-    choiceCardsOpen.current = showChoiceCards;
+    choiceCardsOpen.current = showLiveChoiceCard;
     updateFollowState();
-  }, [showChoiceCards, updateFollowState]);
+  }, [showLiveChoiceCard, updateFollowState]);
   const showSelectionCards = Boolean(
     candidateResult?.selectionAllowed
     && offeredSelectionOnce
     && latestSettledAssistant
-    && !showChoiceCards
+    && !showLiveChoiceCard
     && !busy
     && regeneratingMessageKey === null,
   );
   const selectionCardMessageKey = showSelectionCards && latestSettledAssistant
     ? latestSettledAssistant.renderKey
     : undefined;
-  const choiceCardMessageKey = showChoiceCards && latestSettledAssistant
-    ? latestSettledAssistant.renderKey
+  const liveChoiceMessageKey = showLiveChoiceCard && liveChoiceHost
+    ? liveChoiceHost.renderKey
     : undefined;
   const canSend = !busy && !readonly && !regeneratingMessageKey;
 
@@ -1084,6 +1124,11 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
                 }),
               }
               : message;
+            const settledChoice = message.choiceAttachment;
+            const liveChoice = showLiveChoiceCard && message.renderKey === liveChoiceMessageKey
+              ? choiceCard
+              : null;
+            const visibleChoiceCard = settledChoice?.card ?? liveChoice;
             const vargaSentence = !message.failed
               ? vargaSentenceFromMethods(message.completedReceipt?.methods)
               : null;
@@ -1122,12 +1167,15 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
                     onAccept={(candidateId) => void acceptCandidate(candidateId)}
                   />
                 )}
-                {showChoiceCards && message.renderKey === choiceCardMessageKey && choiceCard && (
+                {visibleChoiceCard && (
                   <RectificationChoiceCard
-                    key={`${choiceCard.question_id}:${choiceNonce}`}
-                    card={choiceCard}
-                    pending={busy}
-                    disabled={readonly}
+                    key={settledChoice
+                      ? `${visibleChoiceCard.question_id}:answered:${settledChoice.selectedKey}`
+                      : `${visibleChoiceCard.question_id}:${choiceNonce}`}
+                    card={visibleChoiceCard}
+                    pending={Boolean(liveChoice) && busy}
+                    disabled={readonly || Boolean(settledChoice)}
+                    selectedKey={settledChoice?.selectedKey ?? ""}
                     onSelect={submitChoice}
                     onStop={submitStop}
                   />
@@ -1177,7 +1225,7 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
             disabled={!canSend}
             placeholder={readonly
               ? "该校正已结束，只能查看历史；需要再次校正请新建。"
-              : showChoiceCards
+              : showLiveChoiceCard
                 ? "点上面的选项即可；想补一句细节再写"
                 : "继续说你记得的人生经历，或回答刚才的问题…"}
             onChange={(event) => setDraft(event.target.value)}
diff --git a/frontend/src/components/rectification-choice-card.tsx b/frontend/src/components/rectification-choice-card.tsx
index f4666159..eb334394 100644
--- a/frontend/src/components/rectification-choice-card.tsx
+++ b/frontend/src/components/rectification-choice-card.tsx
@@ -10,42 +10,48 @@ type RectificationChoiceCardProps = Readonly<{
   card: ChoiceCard;
   pending: boolean;
   disabled: boolean;
+  selectedKey?: ChoiceKey | "stop" | "";
   onSelect: (key: ChoiceKey) => void;
   onStop: () => void;
 }>;
 
 export function RectificationChoiceCard(props: RectificationChoiceCardProps) {
-  const [selectedKey, setSelectedKey] = useState<ChoiceKey | "stop" | "">("");
+  const [localSelected, setLocalSelected] = useState<ChoiceKey | "stop" | "">("");
+  const selectedKey = props.selectedKey || localSelected;
   const firstChoiceRef = useRef<HTMLButtonElement | null>(null);
-  const primary = props.card.options.filter((option) => option.role === "primary");
-  const secondary = props.card.options.filter((option) => option.role === "secondary");
+  const answered = Boolean(selectedKey);
 
   useEffect(() => {
-    if (!props.pending) firstChoiceRef.current?.focus();
-  }, [props.card.question_id, props.pending]);
+    if (props.pending || answered) return;
+    firstChoiceRef.current?.focus();
+  }, [answered, props.card.question_id, props.pending]);
 
   function select(key: ChoiceKey) {
     if (props.pending || props.disabled || selectedKey) return;
-    setSelectedKey(key);
+    setLocalSelected(key);
     props.onSelect(key);
   }
 
   function stop() {
     if (props.pending || props.disabled || selectedKey) return;
-    setSelectedKey("stop");
+    setLocalSelected("stop");
     props.onStop();
   }
 
   return (
     <section
-      className="rectification-choice-card"
+      className={`rectification-choice-card${props.pending ? " is-pending" : ""}${answered ? " is-answered" : ""}`}
       aria-label={props.card.scoring ? "校正判断" : "盘外核对"}
     >
-      <fieldset className="birth-time-choice-question" disabled={props.pending || props.disabled || Boolean(selectedKey)}>
+      <fieldset
+        className="birth-time-choice-question"
+        disabled={props.pending || props.disabled || answered}
+        data-answered={answered ? "true" : "false"}
+      >
         <legend>{props.card.prompt}</legend>
         {props.card.why ? <p className="rectification-choice-why">{props.card.why}</p> : null}
         <div className="birth-time-primary-choices">
-          {primary.map((option, index) => (
+          {props.card.options.map((option, index) => (
             <button
               key={option.key}
               ref={index === 0 ? firstChoiceRef : undefined}
@@ -57,22 +63,9 @@ export function RectificationChoiceCard(props: RectificationChoiceCardProps) {
               <strong>{option.key}.</strong> {option.label}
             </button>
           ))}
-        </div>
-        <div className="birth-time-special-choices">
-          {secondary.map((option) => (
-            <button
-              key={option.key}
-              type="button"
-              className="birth-time-choice-option is-secondary"
-              data-selected={selectedKey === option.key ? "true" : "false"}
-              onClick={() => select(option.key)}
-            >
-              {option.key}. {option.label}
-            </button>
-          ))}
           <button
             type="button"
-            className="birth-time-choice-option is-secondary"
+            className="birth-time-choice-option is-primary"
             data-selected={selectedKey === "stop" ? "true" : "false"}
             onClick={stop}
           >
diff --git a/frontend/src/lib/rectification-agentic/v9/agent-run.ts b/frontend/src/lib/rectification-agentic/v9/agent-run.ts
index 47d14d59..bfed6341 100644
--- a/frontend/src/lib/rectification-agentic/v9/agent-run.ts
+++ b/frontend/src/lib/rectification-agentic/v9/agent-run.ts
@@ -2,12 +2,13 @@
  * V10 rectification turn runner over the durable V9 Case/Evidence domains.
  *
  * Tool activity is published as it happens so the browser can render stages.
- * The user-visible reply is the model's terminal `text-delta`. Provider
- * thinking stays on `reasoning-delta` and is not a public stream event.
- * Server narration is only the empty-stream fallback after tools. A retried
- * attempt emits `attempt.reset` first so the client discards the abandoned
- * attempt. Durable receipts, billing, and settled history still come only
- * from the successful attempt.
+ * The user-visible reply is the model's terminal `text-delta`, streamed live
+ * once that step is the spoken answer. Provider thinking stays on
+ * `reasoning-delta` and is not a public stream event. Server narration is
+ * only the empty-stream fallback after tools. A retried attempt emits
+ * `attempt.reset` first so the client discards the abandoned attempt.
+ * Durable receipts, billing, and settled history still come only from the
+ * successful attempt.
  */
 import type { Agent } from "@mastra/core/agent";
 import { RectificationAgentAction, resolveRectificationStepBudget } from "@/mastra/agentic-rectification";
@@ -48,6 +49,7 @@ import {
 } from "./step-answer";
 import {
   bindSpokenToOpenQuestion,
+  CHOICE_CARD_CONTINUATION_ACK,
   composeRectificationTurnNarration,
   openQuestionPromptFromToolResult,
   publicNarrationDtoFromDossier,
@@ -642,18 +644,53 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
       const stepAnswer = createStepAnswerState();
 
       let persistedPrompt: string | null = null;
-      const heldSpoken: string[] = [];
+      let spokenRaw = "";
+      let visibleEmitted = "";
 
-      const publishSpokenStep = async (pieces: readonly string[]) => {
-        const spoken = pieces.join("").trim();
-        if (!spoken || !caseLoaded) return;
-        if (persistedPrompt) {
-          heldSpoken.push(spoken);
+      const emitVisibleSpoken = async (visible: string) => {
+        if (!caseLoaded) return;
+        if (visible === visibleEmitted) {
+          answerText = visible;
           return;
         }
-        answerText += spoken;
-        answerDeltas.push(spoken);
-        await emit({ type: "answer.delta", text: spoken });
+        if (visible.startsWith(visibleEmitted)) {
+          const growth = visible.slice(visibleEmitted.length);
+          if (!growth) return;
+          answerText = visible;
+          answerDeltas.push(growth);
+          visibleEmitted = visible;
+          await emit({ type: "answer.delta", text: growth });
+          return;
+        }
+        answerText = visible;
+        answerDeltas.push(visible);
+        visibleEmitted = visible;
+        await emit({ type: "answer.delta", text: visible, replace: true });
+      };
+
+      const publishSpokenStep = async (pieces: readonly string[], live = false) => {
+        const joined = pieces.join("");
+        if (!joined) return;
+        if (!caseLoaded) return;
+        const spoken = live ? joined : joined.trim();
+        if (!spoken) return;
+        spokenRaw += spoken;
+        const visible = persistedPrompt
+          ? bindSpokenToOpenQuestion(spokenRaw, persistedPrompt)
+          : spokenRaw;
+        if (!visible && persistedPrompt) return;
+        await emitVisibleSpoken(visible);
+      };
+
+      const retractSpoken = async () => {
+        const hadVisible = Boolean(visibleEmitted || answerText);
+        spokenRaw = "";
+        visibleEmitted = "";
+        answerText = "";
+        answerDeltas.length = 0;
+        if (hadVisible && caseLoaded) {
+          await emit({ type: "answer.delta", text: "", replace: true });
+        }
       };
 
       try {
@@ -688,7 +725,9 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
           chunk,
           isPublicRectificationToolName,
         );
+        if (stepEffect.kind === "live") await publishSpokenStep([stepEffect.text], true);
         if (stepEffect.kind === "publish") await publishSpokenStep(stepEffect.pieces);
+        if (stepEffect.kind === "retract") await retractSpoken();
 
         const activityEvent = skipDuplicateToolCallReceipt
           ? null
@@ -772,18 +811,17 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
           }
         }
         if (!persistedPrompt) return false;
-        const bound = bindSpokenToOpenQuestion(heldSpoken.join("") || answerText, persistedPrompt);
+        const bound = bindSpokenToOpenQuestion(spokenRaw || answerText, persistedPrompt);
         if (bound.trim()) {
-          answerText = bound;
-          answerDeltas.push(bound);
-          await emit({ type: "answer.delta", text: bound });
+          await emitVisibleSpoken(bound);
+          return true;
+        }
+        if (visibleEmitted.trim() && visibleEmitted !== CHOICE_CARD_CONTINUATION_ACK) {
+          await emitVisibleSpoken(CHOICE_CARD_CONTINUATION_ACK);
           return true;
         }
         if (answerText.trim()) return true;
-        const ack = "记下了。";
-        answerText = ack;
-        answerDeltas.push(ack);
-        await emit({ type: "answer.delta", text: ack });
+        await emitVisibleSpoken(CHOICE_CARD_CONTINUATION_ACK);
         return true;
       };
 
@@ -851,6 +889,7 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
       if (streamFailed || abortController.signal.aborted) return failedAttempt(attemptId, mapped ?? "stream_aborted");
       if (!finished) return failedAttempt(attemptId, mapped ?? "stream_unfinished");
       if (mapped === "answer_truncated") {
+        if (await flushPersistedPrompt()) return completeAttempt();
         return {
           ok: false,
           status: "failed",
diff --git a/frontend/src/lib/rectification-agentic/v9/answer-choice.ts b/frontend/src/lib/rectification-agentic/v9/answer-choice.ts
index 9fff3952..2e5af223 100644
--- a/frontend/src/lib/rectification-agentic/v9/answer-choice.ts
+++ b/frontend/src/lib/rectification-agentic/v9/answer-choice.ts
@@ -13,7 +13,7 @@ import {
   applyChoiceWithoutEvidence,
   previousInferenceFromReceipt,
 } from "./inference-adapter";
-import { decideAfterInferenceChange } from "./decision-from-dossier";
+import { decideAfterInferenceChange, rectificationFollowupCatalog } from "./decision-from-dossier";
 import type { InferenceState } from "../core/types.ts";
 import {
   CHOICE_ACTION,
@@ -21,12 +21,14 @@ import {
   composeChoiceNarration,
   focusStatusForAnswer,
   outcomeIdForOption,
+  shouldContinueAfterStructuredChoice,
   structuredProbeContext,
   type ChoiceOptionId,
 } from "./choice-action";
 import {
   evidenceLedgerFingerprint,
   inferenceFingerprintForState,
+  loadV9CaseCompute,
   loadV9CaseDossier,
   persistV9ChoiceAction,
   persistV9DeterministicTurn,
@@ -35,6 +37,10 @@ import {
   type PersistChoiceActionInput,
 } from "./tool-service";
 import type { ChoiceKey } from "./choice-card";
+import { persistServerOwnedFocus, openQuestionFromPersistedFocus } from "./server-focus";
+import { buildMethodFollowupPlan, spokenFollowupForUser } from "./method-followup";
+import { meetsAcceptanceEventQuality } from "./evidence-model";
+import type { SessionOutcomeKind } from "./confirmation-gate";
 
 export type ApplyChoiceCommand = Readonly<{
   userId: string;
@@ -66,6 +72,8 @@ export type AppliedChoiceReceipt = Readonly<{
   narration: string;
   userDisplay: string | null;
   nextAction: ReturnType<typeof publicNextAction>;
+  nextInterviewPersisted: boolean;
+  nextChoiceReady: boolean;
 }>;
 
 function asText(value: unknown): string | null {
@@ -233,6 +241,72 @@ export async function applyRectificationChoice(
   });
 }
 
+async function persistNextInterviewAfterChoice(input: {
+  accounting: AccountingClient;
+  userId: string;
+  caseId: string;
+  dossier: Parameters<typeof decideAfterInferenceChange>[0]["dossier"];
+  decisionState: InferenceState | null;
+  nextAction: ReturnType<typeof publicNextAction>;
+}): Promise<{ hostNarration: string | null; choiceReady: boolean }> {
+  const latest = input.dossier.latestResult
+    ? {
+      ...input.dossier.latestResult,
+      decisionReceipt: {
+        ...(input.dossier.latestResult.decisionReceipt ?? {}),
+        ...(input.decisionState ? { inference_state: input.decisionState } : {}),
+      },
+    }
+    : {
+      decisionReceipt: input.decisionState ? { inference_state: input.decisionState } : null,
+    };
+  let birthDate: string | null = null;
+  try {
+    const compute = await loadV9CaseCompute(input.accounting, input.userId, input.caseId);
+    birthDate = String(compute.baselineBirthSnapshot.birth_date ?? "") || null;
+  } catch {
+    // Ranking stays fail-open when compute is unavailable.
+  }
+  const catalog = rectificationFollowupCatalog(latest, input.dossier.evidence);
+  const sessionOutcome = typeof input.nextAction.session_outcome === "string"
+    ? input.nextAction.session_outcome as SessionOutcomeKind
+    : "collect_evidence";
+  const plan = buildMethodFollowupPlan({
+    evidence: input.dossier.evidence,
+    activeFocus: null,
+    declinedTopics: input.dossier.conversationSummary.declinedSkippedTopics,
+    sessionOutcome,
+    ...catalog,
+    birthDate,
+    accepted: Boolean(input.dossier.case.acceptedTime),
+    candidatesSeparated: input.nextAction.type !== "ask_candidate_discriminator"
+      && input.nextAction.type !== "ask_holdout_validation",
+  });
+  const followup = plan.next_followup;
+  const persistedFocus = await persistServerOwnedFocus({
+    accounting: input.accounting,
+    userId: input.userId,
+    caseId: input.caseId,
+    activeFocus: null,
+    decisionReceipt: latest.decisionReceipt,
+    followup,
+  });
+  const open = openQuestionFromPersistedFocus(persistedFocus);
+  if (open) {
+    return { hostNarration: "接下来请点选下面这一问。", choiceReady: true };
+  }
+  if (followup?.choice_frame) {
+    return { hostNarration: null, choiceReady: false };
+  }
+  if (
+    followup?.intent === "collect_method_evidence"
+    && meetsAcceptanceEventQuality(input.dossier.evidence)
+  ) {
+    return { hostNarration: spokenFollowupForUser(followup), choiceReady: false };
+  }
+  return { hostNarration: null, choiceReady: false };
+}
+
 async function persistApplied(
   accounting: AccountingClient,
   command: ApplyChoiceCommand,
@@ -273,31 +347,53 @@ async function persistApplied(
     inference: input.inference,
   });
 
-  let narrationPersisted = false;
-  try {
-    await persistV9DeterministicTurn(accounting, command.userId, command.caseId, {
-      requestId: command.actionId,
-      userMessage: input.userDisplay,
-      assistantMessage: input.narration,
-    });
-    narrationPersisted = true;
-  } catch {
-    narrationPersisted = false;
-  }
-
-  const narration = (persisted.narration && persisted.narration.trim())
-    || input.narration
-    || composeChoiceNarration({
-      optionId: input.optionId,
-      scoring: input.scoring,
-      appliedInference: input.appliedInference,
-    });
   const nextAction = publicNextAction(decideAfterInferenceChange({
     dossier: input.dossier,
     state: input.decisionState ?? null,
     userStopped: input.userStopped === true,
   }));
 
+  let narrationPersisted = false;
+  let nextInterviewPersisted = false;
+  let nextChoiceReady = false;
+  let hostNarration = input.narration;
+  if (input.userStopped !== true && shouldContinueAfterStructuredChoice(nextAction)) {
+    const nextInterview = await persistNextInterviewAfterChoice({
+      accounting,
+      userId: command.userId,
+      caseId: command.caseId,
+      dossier: input.dossier,
+      decisionState: input.decisionState ?? null,
+      nextAction,
+    });
+    nextChoiceReady = nextInterview.choiceReady;
+    if (nextInterview.hostNarration) {
+      hostNarration = nextInterview.hostNarration;
+      nextInterviewPersisted = true;
+    }
+  }
+  if (nextInterviewPersisted || !shouldContinueAfterStructuredChoice(nextAction, { nextInterviewPersisted })) {
+    try {
+      await persistV9DeterministicTurn(accounting, command.userId, command.caseId, {
+        requestId: command.actionId,
+        userMessage: input.userDisplay,
+        assistantMessage: hostNarration,
+      });
+      narrationPersisted = true;
+    } catch {
+      narrationPersisted = false;
+    }
+  }
+
+  const narration = (nextInterviewPersisted ? hostNarration : null)
+    || (persisted.narration && persisted.narration.trim())
+    || hostNarration
+    || composeChoiceNarration({
+      optionId: input.optionId,
+      scoring: input.scoring,
+      appliedInference: input.appliedInference,
+    });
+
   return {
     applied: true,
     idempotent: persisted.idempotent,
@@ -318,6 +414,8 @@ async function persistApplied(
     narration,
     userDisplay: input.userDisplay,
     nextAction,
+    nextInterviewPersisted,
+    nextChoiceReady,
   };
 }
 
diff --git a/frontend/src/lib/rectification-agentic/v9/choice-action.ts b/frontend/src/lib/rectification-agentic/v9/choice-action.ts
index ba690837..a35157f3 100644
--- a/frontend/src/lib/rectification-agentic/v9/choice-action.ts
+++ b/frontend/src/lib/rectification-agentic/v9/choice-action.ts
@@ -7,7 +7,13 @@
 
 import type { AnswerClass } from "../core/types";
 import { classifyChoiceAnswer } from "../core/build-state";
-import type { ChoiceKey, RectificationChoiceCard } from "./choice-card";
+import {
+  CHOICE_STOP_LABEL,
+  CHOICE_STOP_MESSAGE,
+  HOLDOUT_MESSAGE_PREFIX,
+  type ChoiceKey,
+  type RectificationChoiceCard,
+} from "./choice-card";
 
 export const CHOICE_ACTION = "answer_choice" as const;
 export const STOP_ACTION = "stop_and_review" as const;
@@ -43,6 +49,17 @@ export function userVisibleChoiceLine(card: RectificationChoiceCard, key: Choice
   return `${key}. ${label}`.trim();
 }
 
+const STRUCTURED_CHOICE_LINE = /^(?:盘外核对（不计分）：)?[A-D]\. \S/;
+
+/** Taps are state transitions. Hide the synthetic A/B/C/D or 先这样 chat line. */
+export function isStructuredChoiceUserText(text: string | null | undefined): boolean {
+  const trimmed = text?.trim() ?? "";
+  if (!trimmed) return false;
+  if (trimmed === CHOICE_STOP_MESSAGE || trimmed === CHOICE_STOP_LABEL) return true;
+  if (trimmed.startsWith(`${HOLDOUT_MESSAGE_PREFIX}：`) && STRUCTURED_CHOICE_LINE.test(trimmed)) return true;
+  return STRUCTURED_CHOICE_LINE.test(trimmed) && trimmed.length <= 90;
+}
+
 export function derivedProbeDateRange(year: number | null | undefined): { start: string; end: string } | null {
   if (!year || year < 1900 || year > 2100) return null;
   return { start: `${year}-01-01`, end: `${year}-12-31` };
@@ -86,7 +103,11 @@ export function composeChoiceNarration(input: {
   return "已记录你的选择。";
 }
 
-export function shouldContinueAfterStructuredChoice(nextAction: unknown): boolean {
+export function shouldContinueAfterStructuredChoice(
+  nextAction: unknown,
+  receipt?: { nextInterviewPersisted?: boolean } | null,
+): boolean {
+  if (receipt?.nextInterviewPersisted) return false;
   if (!nextAction || typeof nextAction !== "object") return false;
   const type = (nextAction as { type?: unknown }).type;
   return type === "ask_fact_collection"
diff --git a/frontend/src/lib/rectification-agentic/v9/choice-card.ts b/frontend/src/lib/rectification-agentic/v9/choice-card.ts
index d37f9825..0550360a 100644
--- a/frontend/src/lib/rectification-agentic/v9/choice-card.ts
+++ b/frontend/src/lib/rectification-agentic/v9/choice-card.ts
@@ -3,9 +3,9 @@
  *
  * The server owns the discriminator frame and the tap chrome (A/B/C/D display
  * keys, dynamic answer classes, scoring vs holdout, 先这样). Event stems
- * persist as lock labels (`period · family`); the Agent writes the spoken
- * question. The browser never invents option copy, and never parses A/B/C/D
- * out of assistant prose.
+ * persist as a year-locked spoken question (`period，有没有family？`).
+ * The Agent must not repeat that stem. The browser never invents option copy,
+ * and never parses A/B/C/D out of assistant prose.
  */
 
 import type { AnswerClass } from "../core/types";
@@ -115,6 +115,10 @@ const THEME_DOMAIN: Record<string, string> = {
   oos_blind: "family",
 };
 
+const PLACEHOLDER_PERIOD = /^(当前这几个候选|那段时间)$/;
+const YEAR_MONTH_PERIOD = /(?:19|20)\d{2} 年 \d{1,2} 月/;
+const YEAR_PERIOD = /(?:19|20)\d{2}/;
+
 function yearFrom(value: string | null): number | null {
   const year = value?.slice(0, 4);
   if (!year || !/^\d{4}$/.test(year)) return null;
@@ -122,19 +126,44 @@ function yearFrom(value: string | null): number | null {
   return parsed >= 1900 && parsed <= 2100 ? parsed : null;
 }
 
+function monthFrom(value: string | null): number | null {
+  const match = value?.match(/^\d{4}-(\d{2})/);
+  if (!match) return null;
+  const month = Number(match[1]);
+  return month >= 1 && month <= 12 ? month : null;
+}
+
 function isConfirmedDated(item: ChoiceCardEvidence): boolean {
   return item.status === "confirmed"
     && item.datePrecision !== "unknown"
     && Boolean(item.occurredFrom || item.occurredTo);
 }
 
+function evidenceItemPeriod(item: ChoiceCardEvidence): string | null {
+  const year = yearFrom(item.occurredFrom) ?? yearFrom(item.occurredTo);
+  if (year === null) return null;
+  if (item.datePrecision === "month" || item.datePrecision === "day") {
+    const month = monthFrom(item.occurredFrom) ?? monthFrom(item.occurredTo);
+    if (month) return `${year} 年 ${month} 月前后`;
+  }
+  return `${year} 年前后`;
+}
+
 export function lifePeriodLabel(
   evidence: readonly ChoiceCardEvidence[],
   domain?: string | null,
 ): string {
-  const years = evidence.flatMap((item) => {
-    if (!isConfirmedDated(item)) return [];
-    if (domain && item.domain !== domain) return [];
+  const dated = evidence.filter((item) => {
+    if (!isConfirmedDated(item)) return false;
+    if (domain && item.domain !== domain) return false;
+    return true;
+  });
+  const labels = [...new Set(dated.flatMap((item) => {
+    const label = evidenceItemPeriod(item);
+    return label ? [label] : [];
+  }))];
+  if (labels.length === 1) return labels[0]!;
+  const years = dated.flatMap((item) => {
     const from = yearFrom(item.occurredFrom);
     const to = yearFrom(item.occurredTo);
     return [from, to].filter((value): value is number => value !== null);
@@ -145,6 +174,50 @@ export function lifePeriodLabel(
   return min === max ? `${min} 年前后` : `${min}–${max} 年这段里`;
 }
 
+function concreteProbePeriod(probe: DiscriminatingEventProbe | null): string | null {
+  if (!probe) return null;
+  const label = probe.year_label.trim();
+  if ((probe.year ?? 0) <= 0 || !label || PLACEHOLDER_PERIOD.test(label)) return null;
+  return label;
+}
+
+export function periodSpecificity(text: string): number {
+  if (YEAR_MONTH_PERIOD.test(text)) return 2;
+  if (YEAR_PERIOD.test(text)) return 1;
+  return 0;
+}
+
+export function isConcreteChoicePeriod(period: string | null | undefined): boolean {
+  const text = period?.trim() ?? "";
+  if (!text || PLACEHOLDER_PERIOD.test(text)) return false;
+  return periodSpecificity(text) > 0;
+}
+
+function isCatalogLockPrompt(text: string): boolean {
+  return / · /.test(text) && !/[？?]/.test(text);
+}
+
+function isPlaceholderChoicePrompt(text: string): boolean {
+  return isCatalogLockPrompt(text)
+    || /那段时间/.test(text)
+    || /家人相关的明显变化/.test(text)
+    || /出现明显变化/.test(text)
+    || /关系观明显转变/.test(text)
+    || /认真关系进入/.test(text)
+    || /学习环境变化/.test(text)
+    || /职责明显加重/.test(text);
+}
+
+export function preferConcreteChoicePrompt(framePrompt: string, copyPrompt: string): string {
+  const frameScore = periodSpecificity(framePrompt);
+  const copyScore = periodSpecificity(copyPrompt);
+  if (frameScore > copyScore) return framePrompt;
+  if (frameScore === copyScore && isPlaceholderChoicePrompt(copyPrompt) && !isPlaceholderChoicePrompt(framePrompt)) {
+    return framePrompt;
+  }
+  return copyPrompt;
+}
+
 function followupDomain(followup: ChoiceCardFollowup): string | null {
   if (followup.domain) return followup.domain;
   return THEME_DOMAIN[followup.ask_theme] ?? null;
@@ -179,8 +252,11 @@ function periodFor(
   followup?: ChoiceCardFollowup,
 ): string {
   const probe = pickProbe(probes, domain, followup);
-  if (probe) return probe.year_label;
-  return lifePeriodLabel(evidence ?? [], domain);
+  const fromProbe = concreteProbePeriod(probe);
+  if (fromProbe) return fromProbe;
+  const kind = followup?.choice_kind ?? probe?.choice_kind ?? "existence";
+  if (kind === "varga_style") return lifePeriodLabel(evidence ?? [], domain);
+  return "那段时间";
 }
 
 type Hypothesis = Readonly<{
@@ -194,8 +270,19 @@ type Hypothesis = Readonly<{
   answerClasses: readonly [AnswerClass, AnswerClass, AnswerClass, AnswerClass];
 }>;
 
-function eventLockPrompt(period: string, family: string): string {
-  return `${period} · ${family}`.replace(/\s+/g, " ").trim();
+function eventQuestionPrompt(
+  period: string,
+  family: string,
+  kind: EventProbeChoiceKind,
+): string {
+  const time = period.trim();
+  const topic = family.replace(/[？?。]+$/g, "").trim();
+  if (!topic) return time;
+  if (kind === "event_quality") return `${time}，有没有${topic}的时候？`;
+  if (kind === "varga_style") {
+    return isConcreteChoicePeriod(period) ? `${time}，${topic}？` : `${topic}？`;
+  }
+  return `${time}，有没有${topic}？`;
 }
 
 function withStyleOptionLabels(
@@ -243,7 +330,9 @@ function hypothesisFor(
   });
   if (!styleOptions) return null;
   const period = periodFor(evidence, domain, probes, birthDate, followup);
-  const prompt = eventLockPrompt(period, probe.event_family);
+  const kind = followup.choice_kind ?? probe.choice_kind ?? "existence";
+  if (kind !== "varga_style" && !isConcreteChoicePeriod(period)) return null;
+  const prompt = eventQuestionPrompt(period, probe.event_family, kind);
   const why = probe.user_meaning?.trim() || followup.user_prompt_hint.trim();
   if (!why) return null;
   return withStyleOptionLabels(prompt, why, null, styleOptions);
@@ -398,7 +487,7 @@ export function mergeChoiceCard(
     choice_mode: CHOICE_MODE,
     options: copy.options.map((option) => ({
       ...option,
-      role: option.answer_class === "unsure" ? "secondary" as const : "primary" as const,
+      role: "primary" as const,
     })),
     stop_label: frame.stop_label,
     stop_message: frame.stop_message,
diff --git a/frontend/src/lib/rectification-agentic/v9/method-followup.ts b/frontend/src/lib/rectification-agentic/v9/method-followup.ts
index 2dc8e2fa..72f38ca1 100644
--- a/frontend/src/lib/rectification-agentic/v9/method-followup.ts
+++ b/frontend/src/lib/rectification-agentic/v9/method-followup.ts
@@ -25,12 +25,14 @@
  * time cards. Occupation does block cards until a note exists.
  * Method coverage asks for dated events in natural language.
  * Known-event quality probes (exam went badly for a year already
- * in the ledger) stamp a choice card as soon as that year is
- * recorded. Dasha existence probes skip a domain once that domain
- * already has dated evidence. Remaining chart discriminators
- * (D9/D10/D24 and other varga splits) stay in the pool and the
- * highest information-gain renderable probe is asked next, with
- * no preferred domain.
+ * in the ledger) are not reverse-inference cards. Dasha existence
+ * probes skip a year already in the ledger, not the whole domain.
+ * Scoring A/B/C/D reverse-inference needs the engine year/month.
+ * Yearless varga splits do not borrow a ledger year. Pick the next
+ * dated discriminator, or collect a dated event in that domain.
+ * Remaining chart discriminators (D9/D10 style and dated dasha
+ * probes) stay in the pool; the highest information-gain renderable
+ * probe is asked next, with no preferred domain.
  * If holdout is already reserved but training is still short,
  * keep collecting a dated event instead of discriminating.
  * Once blocking methods are covered, move into candidate discrimination.
@@ -38,13 +40,20 @@
  * A/B/C/D choice frames attach only when candidates already diverge
  * (event probes, precision stage, varga observation, nakshatra, or holdout).
  * An already-open distinguish card yields if the live catalog winner is a
- * different probe. Do not keep a low-gain Python event card over D24.
+ * different probe. Yearless D24 event_quality yields to a dated dasha probe;
+ * do not stamp a ledger year onto a yearless scoring card. An open varga
+ * discriminator must resolve from the contrast packet when Python event
+ * probes have no row in that domain. Scoring reverse-inference cards need
+ * the engine year or month. A yearless D12/family contrast does not attach
+ * A/B/C/D; skip it and either ask the next dated discriminator or collect a
+ * dated family event in natural language.
  */
 
 import {
   buildChoiceFrame,
   isPersistedFocusId,
   parseAgentChoiceCopy,
+  preferConcreteChoicePrompt,
   mergeChoiceCard,
   type RectificationChoiceCard,
   type RectificationChoiceFrame,
@@ -184,8 +193,22 @@ function evidenceYear(item: MethodFollowupEvidence): number | null {
   return year >= 1900 && year <= 2100 ? year : null;
 }
 
-/** 高考与当年 9 月入学通常是同一学年；年龄带常落在入学年的前一年。 */
-const EDUCATION_EXISTENCE_NEARBY_YEARS = 1;
+/** 高考与当年 9 月入学通常是同一学年；感情/事业/搬家的邻近年也常是同一段经历。 */
+const EXISTENCE_NEARBY_YEARS: Readonly<Record<string, number>> = {
+  education: 1,
+  relationship: 1,
+  career: 1,
+  relocation: 1,
+};
+
+const DOMAIN_AGE_LO: Readonly<Record<string, number>> = {
+  education: 16,
+  relocation: 18,
+  relationship: 21,
+  career: 22,
+  finance: 22,
+  health_pressure: 16,
+};
 
 const RECORDED_KIND_LABEL: Readonly<Record<string, string>> = {
   education_start: "入学",
@@ -205,20 +228,23 @@ const RECORDED_KIND_LABEL: Readonly<Record<string, string>> = {
 };
 
 function existenceNearbyYears(domain: string): number {
-  return domain === "education" ? EDUCATION_EXISTENCE_NEARBY_YEARS : 0;
+  return EXISTENCE_NEARBY_YEARS[domain] ?? 0;
 }
 
-function probeDomainAlreadyCovered(
-  evidence: readonly MethodFollowupEvidence[],
-  domain: string,
+function birthYearFromDate(birthDate: string | null | undefined): number | null {
+  if (!birthDate || birthDate.length < 4 || !/^\d{4}/.test(birthDate)) return null;
+  const year = Number(birthDate.slice(0, 4));
+  return year >= 1900 && year <= 2100 ? year : null;
+}
+
+function probeBelowAdultFloor(
+  probe: Pick<DiscriminatingEventProbe, "domain" | "year">,
+  birthDate?: string | null,
 ): boolean {
-  return evidence.some((item) => {
-    if (item.status !== "confirmed" && item.status !== "draft" && item.status !== "pending_confirmation") {
-      return false;
-    }
-    if (item.domain !== domain) return false;
-    return evidenceYear(item) !== null;
-  });
+  const birthYear = birthYearFromDate(birthDate);
+  const floor = DOMAIN_AGE_LO[probe.domain];
+  if (birthYear === null || floor == null || !probe.year) return false;
+  return probe.year < birthYear + floor;
 }
 
 function probeYearAlreadyCovered(
@@ -342,6 +368,74 @@ function contrastFollowupDomain(
   return "career";
 }
 
+function eventProbeFromContrast(probe: CandidateDiscriminatorProbe): DiscriminatingEventProbe | null {
+  const domain = contrastFollowupDomain(probe.domain);
+  if (!EVENT_PROBE_DOMAINS.includes(domain as EventProbeDomain)) return null;
+  const choiceKind = probe.choiceKind ?? "existence";
+  const styleOptions = completeStyleOptions({
+    choiceKind,
+    styleOptions: probe.styleOptions?.map((item) => ({
+      label: item.label,
+      answer_class: item.answerClass,
+      ...(item.sign ? { sign: item.sign } : {}),
+    })),
+  });
+  if (!styleOptions) return null;
+  const candidateIds = [...new Set(probe.expectedOutcomes.flatMap((row) => [
+    ...row.supportsCandidateIds,
+    ...row.conflictsCandidateIds,
+  ]))];
+  return {
+    year: probe.year ?? 0,
+    year_label: probe.year ? `${probe.year} 年前后` : "当前这几个候选",
+    domain: domain as EventProbeDomain,
+    event_family: followupEventFamily(domain, choiceKind),
+    source: "dasha_activation",
+    tracks: ["vimshottari", "narayana"],
+    tracks_agree: true,
+    unique_minute_claim: false,
+    user_meaning: probe.question,
+    role: "distinguish",
+    phase: "candidate_discriminator",
+    information_gain: probe.informationGain,
+    semantic_key: probe.semanticKey,
+    candidate_split_hash: probe.candidateSplitHash,
+    candidate_ids: candidateIds,
+    expected_outcomes: probe.expectedOutcomes.map((row) => ({
+      answer_class: row.outcomeId,
+      supports: row.supportsCandidateIds,
+      conflicts: row.conflictsCandidateIds,
+    })),
+    choice_kind: choiceKind,
+    style_options: styleOptions,
+  };
+}
+
+function liveDistinguishProbe(
+  focus: MethodFollowupFocus,
+  eventProbes: readonly DiscriminatingEventProbe[] | undefined,
+  contrastProbes: readonly CandidateDiscriminatorProbe[] | undefined,
+): DiscriminatingEventProbe | null {
+  const schemaKey = persistedFocusProbeKey(focus);
+  const matchEvent = (probe: DiscriminatingEventProbe) => (
+    isValidDistinguishProbe({ ...probe, role: "distinguish" })
+    && (schemaKey
+      ? probe.semantic_key === schemaKey
+      : (!focus.targetDomain || probe.domain === focus.targetDomain))
+  );
+  const fromEvents = (eventProbes ?? []).find(matchEvent) ?? null;
+  if (fromEvents) return fromEvents;
+  const matchContrast = (probe: CandidateDiscriminatorProbe) => (
+    schemaKey
+      ? probe.semanticKey === schemaKey
+      : (!focus.targetDomain || probe.domain === focus.targetDomain)
+  );
+  const fromContrast = (contrastProbes ?? []).find(matchContrast);
+  if (!fromContrast) return null;
+  const converted = eventProbeFromContrast(fromContrast);
+  return converted && isValidDistinguishProbe(converted) ? converted : null;
+}
+
 const CONFLICT_PROBE_SOURCES = new Set<string>([
   "dasha_boundary",
   "dasha_activation",
@@ -351,6 +445,7 @@ function remainingReverseVerifyProbes(
   probes: readonly DiscriminatingEventProbe[] | undefined,
   evidence: readonly MethodFollowupEvidence[],
   declined: ReadonlySet<string>,
+  birthDate?: string | null,
 ): DiscriminatingEventProbe[] {
   const dasha: DiscriminatingEventProbe[] = [];
   const fallback: DiscriminatingEventProbe[] = [];
@@ -359,6 +454,7 @@ function remainingReverseVerifyProbes(
     if (probe.role === "collect" || probe.phase === "evidence_collection") continue;
     if (declined.has(probe.domain)) continue;
     if (probeYearAlreadyCovered(evidence, probe.domain, probe.year)) continue;
+    if (probeBelowAdultFloor(probe, birthDate)) continue;
     if (CONFLICT_PROBE_SOURCES.has(probe.source)) {
       dasha.push(probe);
     } else {
@@ -368,11 +464,33 @@ function remainingReverseVerifyProbes(
   return [...dasha, ...fallback].slice(0, MAX_REVERSE_VERIFY);
 }
 
+function datedCollectionProbe(
+  probes: readonly DiscriminatingEventProbe[] | undefined,
+  domain: string,
+): DiscriminatingEventProbe | null {
+  const rows = (probes ?? []).filter((item) => item.domain === domain && Number(item.year) > 0);
+  return rows.sort((left, right) => (right.information_gain ?? 0) - (left.information_gain ?? 0))[0] ?? null;
+}
+
+function collectionYearFields(probe: DiscriminatingEventProbe | null): Pick<
+  MethodFollowup,
+  "probe_year" | "year_label" | "probe_month" | "semantic_key"
+> {
+  if (!probe) return {};
+  return {
+    probe_year: probe.year,
+    year_label: probe.year_label,
+    ...(probe.month ? { probe_month: probe.month } : {}),
+    semantic_key: probe.semantic_key,
+  };
+}
+
 function remainingConflictProbes(
   probes: readonly DiscriminatingEventProbe[] | undefined,
   evidence: readonly MethodFollowupEvidence[],
   declined: ReadonlySet<string>,
   askedKeys: ReadonlySet<string> = new Set(),
+  birthDate?: string | null,
 ): DiscriminatingEventProbe[] {
   const rows: DiscriminatingEventProbe[] = [];
   for (const probe of probes ?? []) {
@@ -380,7 +498,8 @@ function remainingConflictProbes(
     if (probe.source === "known_event_quality" || probe.role === "clarify") continue;
     if (!isValidDistinguishProbe({ ...probe, role: "distinguish" })) continue;
     if (declined.has(probe.domain)) continue;
-    if (probeDomainAlreadyCovered(evidence, probe.domain)) continue;
+    if (probeYearAlreadyCovered(evidence, probe.domain, probe.year)) continue;
+    if (probeBelowAdultFloor(probe, birthDate)) continue;
     const semantic = probe.semantic_key ?? `${probe.domain}.${probe.year}`;
     const split = probe.candidate_split_hash ?? "";
     if (askedKeys.has(semantic) || (split && askedKeys.has(split))) continue;
@@ -472,12 +591,44 @@ function renderableContrastProbe(
   };
 }
 
+const EXISTENCE_EVENT_FAMILY: Record<string, string> = {
+  education: "升学、转学或换学习环境",
+  relocation: "搬家或长期住到外地",
+  relationship: "开始一段认真关系、分手或结婚",
+  career: "入职、换工作或职责加重",
+  family: "家人结婚、添丁或住院",
+  finance: "收入明显变化、大笔支出或欠债",
+  health_pressure: "生病、受伤或压力特别大",
+};
+
+const QUALITY_EVENT_FAMILY: Record<string, string> = {
+  education: "学业或考试发挥失常、压力特别大",
+  relocation: "搬家或住处特别折腾",
+  relationship: "感情里压力特别大或相处明显变难",
+  career: "职责加重或工作压力特别大",
+  family: "家人结婚、添丁、住院或家里特别操心",
+  finance: "收入或财务压力特别大",
+  health_pressure: "生病、受伤或压力特别大",
+};
+
+const YEARLESS_COLLECT_LEAD: Record<string, string> = {
+  education: "可以先问有没有记得住年份的升学、转学或考试。",
+  relocation: "可以先问有没有记得住时间的搬家或长期住到外地。",
+  relationship: "可以先问有没有记得住时间的认真交往、分手或结婚。",
+  career: "可以先问有没有记得住时间的入职、换工作或职责加重。",
+  family: "可以先问家里有没有结婚、添丁或住院这类记得住时间的事。",
+  finance: "可以先问有没有记得住时间的收入变化、大笔支出或欠债。",
+  health_pressure: "可以先问有没有记得住时间的生病、受伤或特别大的压力。",
+};
+
 function followupEventFamily(domain: string, kind: string): string {
-  if (kind === "event_quality") return "学业、考试发挥或学习压力出现明显变化";
+  if (kind === "event_quality") {
+    return QUALITY_EVENT_FAMILY[domain] ?? "这件事比平时更难、压力特别大";
+  }
   if (kind === "varga_style") {
     return domain === "relationship" ? "相处方式更接近其中一种" : "做事风格更接近其中一种";
   }
-  return "这段经历是否发生过";
+  return EXISTENCE_EVENT_FAMILY[domain] ?? "这段经历是否发生过";
 }
 
 function followupOwnedProbe(
@@ -535,13 +686,24 @@ function rankedDiscriminatorKey(row: RankedDiscriminator | null): string {
   return row.eventProbe?.semantic_key ?? row.contrastProbe?.semanticKey ?? "";
 }
 
+function discriminatorChoiceKind(row: RankedDiscriminator): string {
+  return row.eventProbe?.choice_kind ?? row.contrastProbe?.choiceKind ?? "existence";
+}
+
+function discriminatorLocksScoringPeriod(row: RankedDiscriminator): boolean {
+  if (discriminatorChoiceKind(row) === "varga_style") return true;
+  const year = row.eventProbe?.year ?? row.contrastProbe?.year ?? 0;
+  return year > 0;
+}
+
 function rankRenderableDiscriminators(input: {
   eventProbes: readonly DiscriminatingEventProbe[];
   contrastProbes: readonly CandidateDiscriminatorProbe[];
   askedKeys: ReadonlySet<string>;
   topCandidateTimes?: readonly string[];
   providedDomains?: readonly string[];
-}): RankedDiscriminator[] {
+  evidence?: readonly MethodFollowupEvidence[];
+}): { locked: RankedDiscriminator[]; yearless: RankedDiscriminator[] } {
   const top = input.topCandidateTimes ?? [];
   const provided = new Set(input.providedDomains ?? []);
   const rows: RankedDiscriminator[] = [];
@@ -562,7 +724,11 @@ function rankRenderableDiscriminators(input: {
     if (!isStructuredDiscriminator(probe) && probe.domain && provided.has(probe.domain)) continue;
     push(renderableContrastProbe(probe, input.askedKeys, top));
   }
-  return rows.sort((left, right) => right.score - left.score || (right.eventProbe?.information_gain ?? right.contrastProbe?.informationGain ?? 0) - (left.eventProbe?.information_gain ?? left.contrastProbe?.informationGain ?? 0));
+  const sorted = rows.sort((left, right) => right.score - left.score || (right.eventProbe?.information_gain ?? right.contrastProbe?.informationGain ?? 0) - (left.eventProbe?.information_gain ?? left.contrastProbe?.informationGain ?? 0));
+  return {
+    locked: sorted.filter((row) => discriminatorLocksScoringPeriod(row)),
+    yearless: sorted.filter((row) => !discriminatorLocksScoringPeriod(row) && discriminatorChoiceKind(row) !== "varga_style"),
+  };
 }
 
 function coverage(
@@ -605,6 +771,26 @@ export function shouldAttachChoiceFrame(
   return false;
 }
 
+const USER_COLLECT_QUESTION: Readonly<Record<string, string>> = {
+  relationship: "还记得别的带年份的感情变化吗？比如开始认真交往、分手或结婚。",
+  career: "还记得别的带年份的工作变化吗？比如入职、换工作或职责加重。",
+  family: "家里有没有结婚、添丁或住院这类记得住时间的事？不记得具体日子也可以先说有没有。",
+  occupation: "你长期做什么工作？",
+  education: "有没有记得住年份的升学、转学或考试？",
+  relocation: "有没有记得住时间的搬家或长期住到外地？",
+};
+
+export function spokenFollowupForUser(followup: MethodFollowup | null): string | null {
+  if (!followup) return null;
+  if (followup.choice_frame) return "接下来请点选下面这一问。";
+  if (followup.intent !== "collect_method_evidence") return null;
+  const base = USER_COLLECT_QUESTION[followup.domain ?? ""]
+    ?? "请再说一件记得大概时间的经历。";
+  const period = followup.year_label
+    ?? (followup.probe_year && followup.probe_year > 0 ? `${followup.probe_year} 年前后` : null);
+  return period ? `${period}，${base}` : base;
+}
+
 export type NextUserActionId =
   | "adopt_representative"
   | "score_now"
@@ -933,15 +1119,18 @@ export function buildMethodFollowupPlan(input: {
     ...(input.askedProbeKeys ?? []),
     ...askedKeysFromLedgerEvidence(input.evidence),
   ]);
-  const rankedDiscriminators = dashaCovered && meetsAcceptanceEventQuality(input.evidence)
+  const rankedCatalog = dashaCovered && meetsAcceptanceEventQuality(input.evidence)
     ? rankRenderableDiscriminators({
-      eventProbes: remainingConflictProbes(input.eventProbes, input.evidence, declined, askedKeys),
+      eventProbes: remainingConflictProbes(input.eventProbes, input.evidence, declined, askedKeys, input.birthDate),
       contrastProbes,
       askedKeys,
       topCandidateTimes: input.topCandidateTimes,
       providedDomains: datedDomainsFromEvidence(input.evidence),
+      evidence: input.evidence,
     })
-    : [];
+    : { locked: [] as RankedDiscriminator[], yearless: [] as RankedDiscriminator[] };
+  const rankedDiscriminators = rankedCatalog.locked;
+  const yearlessDiscriminators = rankedCatalog.yearless;
   const bestDiscriminator = rankedDiscriminators[0] ?? null;
   const catalogWinnerKey = rankedDiscriminatorKey(bestDiscriminator);
   const staleCollectFocus = Boolean(
@@ -981,43 +1170,51 @@ export function buildMethodFollowupPlan(input: {
       input.evidence.some(isConfirmedDated)
       || focus.intent === "out_of_sample_check"
     ));
-    const liveProbe = (input.eventProbes ?? []).find((probe) => (
-      isValidDistinguishProbe({ ...probe, role: "distinguish" })
-      && (!focus.targetDomain || probe.domain === focus.targetDomain)
-    )) ?? null;
-    return {
-      methods,
-      next_followup: makeFollowup({
-        method_id: "active_focus",
-        intent: focus.intent || "active_focus",
-        ask_theme: "active_focus",
-        domain: focus.targetDomain,
-        kind_hint: focus.targetKind,
-        user_prompt_hint: keepChoice
-          ? "先承接当前焦点。自己写一句追问；年份和事件家族以已持久化的 period / 探针为准，不得发明年份，不得改问其他领域。不要调用 set-focus。正文不要复述选项。"
-          : "先承接当前服务器焦点。若用户已说带年份的经历，走 batch 写入；否则继续用自然语言问一件带大概年份的事。不要写 expectedAnswerSchema.choice。",
-        source: "active_focus",
-        ...(liveProbe && focus.intent === "distinguish_candidates"
-          ? {
-            information_gain: liveProbe.information_gain,
-            semantic_key: liveProbe.semantic_key,
-            candidate_split_hash: liveProbe.candidate_split_hash,
-            probe_year: liveProbe.year,
-            year_label: liveProbe.year_label,
-            probe_month: liveProbe.month,
-            choice_kind: liveProbe.choice_kind,
-            candidate_ids: liveProbe.candidate_ids ?? candidateIdsFromProbe(liveProbe),
-            expected_outcomes: liveProbe.expected_outcomes,
-            style_options: liveProbe.style_options,
-          }
-          : {}),
-      }, true, keepChoice),
-      deferred_followup: null,
-      session_outcome: sessionOutcome,
-      stop_domain_rotation: true,
-      do_not_poll: DO_NOT_POLL,
-      not_in_rotation: NOT_IN_ROTATION,
-    };
+    const liveProbe = liveDistinguishProbe(
+      focus,
+      input.eventProbes,
+      input.contrastPacket?.probes,
+    );
+    const keepNext = makeFollowup({
+      method_id: "active_focus",
+      intent: focus.intent || "active_focus",
+      ask_theme: "active_focus",
+      domain: focus.targetDomain,
+      kind_hint: focus.targetKind,
+      user_prompt_hint: keepChoice
+        ? "先承接当前焦点。自己写一句追问；年份和事件家族以已持久化的 period / 探针为准，不得发明年份，不得改问其他领域。不要调用 set-focus。正文不要复述选项。"
+        : "先承接当前服务器焦点。若用户已说带年份的经历，走 batch 写入；否则继续用自然语言问一件带大概年份的事。不要写 expectedAnswerSchema.choice。",
+      source: "active_focus",
+      ...(liveProbe && focus.intent === "distinguish_candidates"
+        ? {
+          information_gain: liveProbe.information_gain,
+          semantic_key: liveProbe.semantic_key,
+          candidate_split_hash: liveProbe.candidate_split_hash,
+          probe_year: liveProbe.year,
+          year_label: liveProbe.year_label,
+          probe_month: liveProbe.month,
+          choice_kind: liveProbe.choice_kind,
+          candidate_ids: liveProbe.candidate_ids ?? candidateIdsFromProbe(liveProbe),
+          expected_outcomes: liveProbe.expected_outcomes,
+          style_options: liveProbe.style_options,
+        }
+        : {}),
+    }, true, keepChoice);
+    if (!(
+      keepChoice
+      && focus.intent === "distinguish_candidates"
+      && !keepNext.choice_frame
+    )) {
+      return {
+        methods,
+        next_followup: keepNext,
+        deferred_followup: null,
+        session_outcome: sessionOutcome,
+        stop_domain_rotation: true,
+        do_not_poll: DO_NOT_POLL,
+        not_in_rotation: NOT_IN_ROTATION,
+      };
+    }
   }
 
   if (sessionOutcome === "validate_holdout") {
@@ -1056,7 +1253,7 @@ export function buildMethodFollowupPlan(input: {
   }
 
   if (input.accepted) {
-    const probe = remainingReverseVerifyProbes(input.eventProbes, input.evidence, declined)[0] ?? null;
+    const probe = remainingReverseVerifyProbes(input.eventProbes, input.evidence, declined, input.birthDate)[0] ?? null;
     const theme = probe ? REVERSE_VERIFY_THEME[probe.domain] : null;
     const next = probe && theme
       ? makeFollowup({
@@ -1161,9 +1358,39 @@ export function buildMethodFollowupPlan(input: {
       ),
       source: "method_coverage",
     });
-  } else if (bestDiscriminator && (!coverageComplete || !candidatesSeparated || bestDiscriminator.score >= 0.08)) {
-    next = followupFromRanked(bestDiscriminator);
-  } else if (!relationshipCovered && !declined.has("relationship")) {
+  } else {
+    const allowLowGainDiscriminator = !coverageComplete || !candidatesSeparated;
+    for (const ranked of rankedDiscriminators) {
+      if (!allowLowGainDiscriminator && ranked.score < 0.08) continue;
+      const candidate = followupFromRanked(ranked);
+      if (candidate.choice_frame) {
+        next = candidate;
+        break;
+      }
+    }
+    if (!next && coverageComplete) {
+      const yearless = yearlessDiscriminators[0];
+      if (yearless && (allowLowGainDiscriminator || yearless.score >= 0.08)) {
+        const domain = contrastFollowupDomain(
+          yearless.eventProbe?.domain ?? yearless.contrastProbe?.domain ?? null,
+        );
+        const lead = YEARLESS_COLLECT_LEAD[domain];
+        if (lead && !declined.has(domain)) {
+          next = makeFollowup({
+            method_id: PROBE_METHOD_ID[domain],
+            intent: "collect_method_evidence",
+            ask_theme: REVERSE_VERIFY_THEME[domain],
+            domain,
+            kind_hint: REVERSE_VERIFY_KIND[domain],
+            user_prompt_hint: collect(lead, REVERSE_VERIFY_VARGA[domain]),
+            source: "method_coverage",
+          });
+        }
+      }
+    }
+  }
+  if (!next) {
+    if (!relationshipCovered && !declined.has("relationship")) {
     next = makeFollowup({
       method_id: "d9_relationship",
       intent: "collect_method_evidence",
@@ -1171,7 +1398,7 @@ export function buildMethodFollowupPlan(input: {
       domain: "relationship",
       kind_hint: "relationship_start",
       user_prompt_hint: collect(
-        "可以先说一段记得大概时间的感情或关系变化。",
+        "可以先说一段记得大概时间的感情变化，比如开始认真交往、分手或结婚。",
         "D9",
         "对照 D9 上升类型表（白羊主动热情、天蝎深刻占有等）只作校时方法，不是命运承诺。",
       ),
@@ -1185,13 +1412,14 @@ export function buildMethodFollowupPlan(input: {
       domain: "career",
       kind_hint: "career_entry",
       user_prompt_hint: collect(
-        "可以先说一段记得大概时间的工作或事业变化。同一件事会同时对照本命第 10 宫和 D10。",
+        "可以先说一段记得大概时间的工作变化，比如入职、换工作或职责加重。同一件事会同时对照本命第 10 宫和 D10。",
         "D10",
         "可用 D10 事业类型表作校时对照。",
       ),
       source: "method_coverage",
     });
   } else if (!familyCovered && !declined.has("family")) {
+    const familyCollect = datedCollectionProbe(input.evidenceCollectionProbes, "family");
     next = makeFollowup({
       method_id: "relatives",
       intent: "collect_method_evidence",
@@ -1199,11 +1427,12 @@ export function buildMethodFollowupPlan(input: {
       domain: "family",
       kind_hint: "family_event",
       user_prompt_hint: collect(
-        "可以先说一段记得大概时间的家人相关变化。同一件事会对照 D12 父母盘、D7 子女盘和 D3 兄弟盘。",
+        "可以先问家里有没有结婚、添丁或住院这类记得住时间的事。同一件事会对照 D12 父母盘、D7 子女盘和 D3 兄弟盘。",
         "D12 / D7 / D3",
         "六亲用 Raman 六步：前三步可执行，后三步标方法论层。",
       ),
       source: "method_coverage",
+      ...collectionYearFields(familyCollect),
     });
   } else if (!occupationCovered) {
     next = makeFollowup({
@@ -1460,6 +1689,7 @@ export function buildMethodFollowupPlan(input: {
         source: "method_coverage",
       });
     }
+    }
   }
 
   const deferAdoption = sessionOutcome === "adopt_representative"
@@ -1546,7 +1776,10 @@ export function projectRectificationChoiceCard(
   const overlaid = copy
     ? {
         ...copy,
-        prompt: overlayChoicePromptFromSpoken(copy.prompt, input.latestAssistantText),
+        prompt: overlayChoicePromptFromSpoken(
+          preferConcreteChoicePrompt(frame.prompt, copy.prompt),
+          input.latestAssistantText,
+        ),
       }
     : null;
   return mergeChoiceCard(frame, overlaid, {
diff --git a/frontend/src/lib/rectification-agentic/v9/step-answer.ts b/frontend/src/lib/rectification-agentic/v9/step-answer.ts
index ac3f3830..b40e8f9f 100644
--- a/frontend/src/lib/rectification-agentic/v9/step-answer.ts
+++ b/frontend/src/lib/rectification-agentic/v9/step-answer.ts
@@ -1,10 +1,12 @@
 /**
  * Isolate the terminal no-tool step from Mastra multi-step agent runs.
  *
- * `text-delta` is not a user answer. A tool-using step may emit planning
- * prose before the call; that text must be discarded as a whole. Only a
- * step that never called a public tool and finished with `stop` may become
- * `answer.delta`.
+ * `text-delta` is not a user answer by default. A tool-using step may emit
+ * planning prose before the call; that text must be discarded as a whole.
+ * Once the current step looks like the spoken reply — Chinese sentence end,
+ * or live-unlock after compare/offer/result tools — tokens may stream as
+ * `live`. A later public tool-call retracts that speculative stream so
+ * "Let me set" never stays in `answer.delta`.
  */
 
 export type StepAnswerChunk = Readonly<{
@@ -21,21 +23,45 @@ export type StepAnswerState = {
   text: string;
   pieces: string[];
   calledTool: boolean;
+  live: boolean;
+  publishedUpTo: number;
+  unlocked: boolean;
 };
 
 export type StepAnswerEffect =
   | { kind: "none" }
   | { kind: "discard" }
-  | { kind: "publish"; pieces: readonly string[] };
+  | { kind: "publish"; pieces: readonly string[] }
+  | { kind: "live"; text: string }
+  | { kind: "retract" };
 
-function reset(state: StepAnswerState): void {
+const SPOKEN_LIVE_UNLOCK_TOOLS = new Set([
+  "rectification-compare-candidates",
+  "rectification-offer-candidates",
+  "rectification-accept-candidate",
+  "rectification-confirm-birth-time",
+  "rectification-close-case",
+  "rectification-stop-and-review",
+  "rectification-read-diagnostics",
+]);
+
+function resetBuffers(state: StepAnswerState): void {
   state.text = "";
   state.pieces = [];
   state.calledTool = false;
+  state.live = false;
+  state.publishedUpTo = 0;
 }
 
 export function createStepAnswerState(): StepAnswerState {
-  return { text: "", pieces: [], calledTool: false };
+  return {
+    text: "",
+    pieces: [],
+    calledTool: false,
+    live: false,
+    publishedUpTo: 0,
+    unlocked: false,
+  };
 }
 
 export function stepFinishReason(chunk: StepAnswerChunk): string | null {
@@ -61,10 +87,47 @@ function isPublicToolCall(
   return Boolean(name) && name !== "skill" && isPublicTool(name);
 }
 
+function toolName(chunk: StepAnswerChunk): string {
+  return typeof chunk.payload?.toolName === "string" ? chunk.payload.toolName : "";
+}
+
+function hasCjk(text: string): boolean {
+  return /[\u4e00-\u9fff]/.test(text);
+}
+
+function hasSpokenTerminator(text: string): boolean {
+  return /[。！？]/.test(text);
+}
+
+function shouldLivePublish(state: StepAnswerState): boolean {
+  if (state.calledTool || !state.text) return false;
+  if (!hasCjk(state.text)) return false;
+  if (state.unlocked || state.live) return true;
+  return hasSpokenTerminator(state.text);
+}
+
+function liveRemainder(state: StepAnswerState): StepAnswerEffect {
+  const next = state.text.slice(state.publishedUpTo);
+  if (!next) return { kind: "none" };
+  state.live = true;
+  state.publishedUpTo = state.text.length;
+  return { kind: "live", text: next };
+}
+
+function retractLive(state: StepAnswerState): StepAnswerEffect {
+  const wasLive = state.live && state.publishedUpTo > 0;
+  state.text = "";
+  state.pieces = [];
+  state.live = false;
+  state.publishedUpTo = 0;
+  state.unlocked = false;
+  return wasLive ? { kind: "retract" } : { kind: "none" };
+}
+
 /**
- * Advance the per-step buffer. Publishing happens only on `step-finish`
- * (or a later `flushStepAnswerOnStreamFinish` when Mastra omitted it).
- * Tool-result ends the current step so later text is a new step.
+ * Advance the per-step buffer. Terminal Chinese may stream as `live` once
+ * the step is unlocked or a spoken sentence has closed. Tool-result ends
+ * the current step so later text is a new step.
  */
 export function applyStepAnswerChunk(
   state: StepAnswerState,
@@ -77,7 +140,7 @@ export function applyStepAnswerChunk(
     case "reasoning-end":
       return { kind: "none" };
     case "step-start":
-      reset(state);
+      resetBuffers(state);
       return { kind: "none" };
     case "text-delta": {
       const text = typeof chunk.payload?.text === "string" ? chunk.payload.text : "";
@@ -85,23 +148,41 @@ export function applyStepAnswerChunk(
         state.text += text;
         state.pieces.push(text);
       }
-      return { kind: "none" };
+      if (!shouldLivePublish(state)) return { kind: "none" };
+      return liveRemainder(state);
     }
     case "tool-call":
-      if (isPublicToolCall(chunk, isPublicTool)) state.calledTool = true;
+      if (isPublicToolCall(chunk, isPublicTool)) {
+        const retracted = retractLive(state);
+        state.calledTool = true;
+        return retracted.kind === "retract" ? retracted : { kind: "none" };
+      }
       return { kind: "none" };
     case "tool-result":
     case "tool-error": {
       if (isPublicToolCall(chunk, isPublicTool)) state.calledTool = true;
       const discarded = state.calledTool || state.text.length > 0;
-      reset(state);
-      return discarded ? { kind: "discard" } : { kind: "none" };
+      const retracted = retractLive(state);
+      resetBuffers(state);
+      if (
+        chunk.type === "tool-result"
+        && isPublicToolCall(chunk, isPublicTool)
+        && SPOKEN_LIVE_UNLOCK_TOOLS.has(toolName(chunk))
+      ) {
+        state.unlocked = true;
+      }
+      return retracted.kind === "retract" ? retracted : discarded ? { kind: "discard" } : { kind: "none" };
     }
     case "step-finish": {
       const reason = stepFinishReason(chunk);
+      if (state.live) {
+        const rest = state.text.slice(state.publishedUpTo);
+        resetBuffers(state);
+        return rest ? { kind: "publish", pieces: [rest] } : { kind: "none" };
+      }
       const publish = shouldPublishStepText(state, reason);
       const pieces = publish ? [...state.pieces] : [];
-      reset(state);
+      resetBuffers(state);
       return publish ? { kind: "publish", pieces } : { kind: "discard" };
     }
     default:
@@ -113,11 +194,16 @@ export function flushStepAnswerOnStreamFinish(
   state: StepAnswerState,
   finishReason: string | null,
 ): StepAnswerEffect {
+  if (state.live) {
+    const rest = state.text.slice(state.publishedUpTo);
+    resetBuffers(state);
+    return rest ? { kind: "publish", pieces: [rest] } : { kind: "none" };
+  }
   if (!shouldPublishStepText(state, finishReason === "stop" || finishReason === null ? "stop" : finishReason)) {
-    reset(state);
+    resetBuffers(state);
     return { kind: "none" };
   }
   const pieces = [...state.pieces];
-  reset(state);
+  resetBuffers(state);
   return { kind: "publish", pieces };
 }
diff --git a/frontend/src/lib/rectification-agentic/v9/stream-mapping.ts b/frontend/src/lib/rectification-agentic/v9/stream-mapping.ts
index fba7e077..b47cfdac 100644
--- a/frontend/src/lib/rectification-agentic/v9/stream-mapping.ts
+++ b/frontend/src/lib/rectification-agentic/v9/stream-mapping.ts
@@ -28,6 +28,7 @@ import { sanitizePublicThinkingText } from "../../public-thinking";
 export type PublicPhaseStreamEvent = Readonly<{
   type: PublicRectificationPhase;
   text?: string;
+  replace?: true;
   tool?: PublicRectificationTool;
   methods?: readonly PublicRectificationMethod[];
   turnId?: string;
@@ -268,6 +269,7 @@ export function safePublicEvent(value: unknown): PublicStreamEvent | null {
     type?: unknown;
     status?: unknown;
     text?: unknown;
+    replace?: unknown;
     tool?: unknown;
     methods?: unknown;
     turnId?: unknown;
@@ -335,6 +337,7 @@ export function safePublicEvent(value: unknown): PublicStreamEvent | null {
   const text = type === "answer.delta" && typeof event.text === "string"
     ? event.text.slice(0, 4_000)
     : undefined;
+  const replace = type === "answer.delta" && event.replace === true ? true as const : undefined;
   const tool = type !== "answer.delta" && isPublicRectificationTool(event.tool)
     ? event.tool
     : undefined;
@@ -349,6 +352,7 @@ export function safePublicEvent(value: unknown): PublicStreamEvent | null {
   return {
     type,
     ...(text !== undefined ? { text } : {}),
+    ...(replace ? { replace } : {}),
     ...(tool ? { tool } : {}),
     ...(methods.length > 0 ? { methods } : {}),
     ...(turnId ? { turnId } : {}),
diff --git a/frontend/src/lib/rectification-agentic/v9/turn-narration.ts b/frontend/src/lib/rectification-agentic/v9/turn-narration.ts
index 003698b2..f0b9d45b 100644
--- a/frontend/src/lib/rectification-agentic/v9/turn-narration.ts
+++ b/frontend/src/lib/rectification-agentic/v9/turn-narration.ts
@@ -67,17 +67,32 @@ const FOREIGN_MARKERS = [
   "入学考试",
   "发挥失常",
   "发挥明显失常",
+  "上学",
+  "小学",
+  "学业",
   "入职",
   "升职",
   "职责",
+  "实习",
+  "离职",
   "搬家",
   "离乡",
+  "异地",
   "认真关系",
   "分手",
   "结婚",
+  "感情",
   "家人",
 ] as const;
 
+const MARKER_GROUPS: readonly (readonly string[])[] = [
+  ["高考", "入学考试", "发挥失常", "发挥明显失常", "上学", "小学", "学业"],
+  ["入职", "升职", "职责", "实习", "离职"],
+  ["搬家", "离乡", "异地"],
+  ["认真关系", "分手", "结婚", "感情"],
+  ["家人"],
+];
+
 export function extractSpokenQuestion(spoken: string): string | null {
   const parts = spoken
     .split(/\n{2,}/)
@@ -102,6 +117,14 @@ export function spokenQuestionMatchesLock(question: string, lockPrompt: string):
   return !foreign.some((marker) => question.includes(marker));
 }
 
+function ackFitsOpenQuestion(part: string, lock: string): boolean {
+  for (const group of MARKER_GROUPS) {
+    if (!group.some((marker) => part.includes(marker))) continue;
+    if (!group.some((marker) => lock.includes(marker))) return false;
+  }
+  return true;
+}
+
 export function overlayChoicePromptFromSpoken(
   fallbackPrompt: string,
   spoken: string | null | undefined,
@@ -113,6 +136,10 @@ export function overlayChoicePromptFromSpoken(
   return clipped;
 }
 
+const CHOICE_ACK_RE = /已记录你的选择|已记下你刚才的选择|候选比较也随之更新|请看下方选项/;
+
+export const CHOICE_CARD_CONTINUATION_ACK = "接下来看下面这一问。";
+
 /**
  * A persisted choice focus is rendered by the choice card. Keep only the
  * acknowledgement in chat so the Agent cannot create a second, divergent
@@ -125,7 +152,13 @@ export function bindSpokenToOpenQuestion(spoken: string, nextQuestion: string |
     .split(/\n{2,}/)
     .flatMap((block) => block.split(/(?<=[。！])\s*/u))
     .map((part) => part.trim())
-    .filter((part) => part.length > 0 && !/[？?]/.test(part) && !part.includes(lock))
+    .filter((part) => (
+      part.length > 0
+      && !/[？?]/.test(part)
+      && !part.includes(lock)
+      && !CHOICE_ACK_RE.test(part)
+      && ackFitsOpenQuestion(part, lock)
+    ))
     .slice(0, 2);
   return ack.join("\n\n");
 }
diff --git a/frontend/src/mastra/agentic-rectification.ts b/frontend/src/mastra/agentic-rectification.ts
index 5aba6b5e..6e86b897 100644
--- a/frontend/src/mastra/agentic-rectification.ts
+++ b/frontend/src/mastra/agentic-rectification.ts
@@ -71,7 +71,7 @@ const agenticRectificationInstructions = `你是 Jyotisha，只服务当前绑
 8. 当前轮新事件一律走 rectification-record-evidence-batch（一件也可以）。优先传 source 原文的 quoteStart/quoteEnd，不要改写 quote。rectification-confirm-evidence 只用于用户对已有 pending 明确说“对/是”。不得要求用户把已说清的事件再发一遍。
 9. 不得在同一回复中一边要求继续补证据，一边提供候选采用。落实 next_user_action：id=verify_adopted_time 时本轮只核一件前事，A 走 batch 并 compare，C 关闭该问，不要 offer 也不要 start_consultation。id=start_consultation 时请用户用当前采用时间看盘，对不上同时请改选其他候选。id 不是 adopt_representative、validated_range、provisional_range 或 provisional_range_user_stopped 时不得调用 rectification-offer-candidates，也不得请用户采用。selection_allowed 只表示可以采用代表性时间，不是本轮必须出示卡片；propose_allowed 才是提出门。采用门所需的训练事件未齐（至少 3 条训练事件、2 个领域，holdout 不计）时继续按方法层收集，不要根据 dasha 冲突探针出点选卡或改问冲突年。已记下年份上的发挥质量探针要出点选卡。齐了之后，source=event_probe 的冲突前事继续问并挡住出牌。训练事件已齐且 next_user_action 为区分题时进入候选区分，不要因家人或职业方法层未覆盖而改回收集；方法覆盖已齐不等于 adopt。无日期 occupation_note 算职业已覆盖，不要再问职业，也不要因它出牌。id=ask_candidate_discriminator 或 session_outcome=discriminate_candidates 时，只有服务器已返回持久化 current_question / open_question 才能进入区分轮；问题和动态选项由下方选择卡承载，正文只自然承接上一条事实，不得另写、改写或复述区分题，不得 offer。id=ask_holdout_validation 时做盘外核对，不得 offer。id=offer_provisional_range 时说明并列可信区间，不要称某分钟为当前推荐。accepted_time 为空且 session_outcome=adopt_representative 或 next_user_action.id=adopt_representative 时本轮只提供代表性候选供用户采用，不要再问 next_followup，也不要使用固定收口句式。unique_minute_path=closed_at_representative 时不得调用 confirm，不得把唯一分钟确认当下一步。根据用户自然语言语义区分“当前问题没有证据”“停止整个证据收集”和“恢复继续校正”：前者调用 rectification-resolve-focus，把当前 focus 标为 declined 或 skipped 后继续服从服务器 next_user_action；全局停止则调用 rectification-stop-and-review，由服务端持久化暂停状态；paused 后只有用户明确要继续校正或提交新证据时，才在本轮首次 rectification-read-case 传 resume=true，询问当前结果、重复停止或只看结果不得恢复；再按 on_user_stop：账本为空则把已说的带日期经历 batch 写入再比较，有事件无结果则本轮 compare，已有代表性结果且尚未采用则解释、调用 offer-candidates 并请采用下方时间卡片，已采用则按 on_user_stop 看盘或改选。session_outcome=provisional_range_user_stopped 时交付当前区间和代表时间，必须说明独立核对尚未完成，禁止说已完成验证或最终校正结果。禁止只说记下了、会话会保留、以后再继续。出牌/采用轮把工具返回的 skill_verification_report 写入正文：筛选窗、事件–Dasha–Gochara 表、D9/D10 类型对照、六亲六步、职业类型表、占问 observation_only、文末技法审计表。80%/60% 只描述事件吻合率，不得写成已确认唯一出生分钟，也不得写成候选已经分开。确认门以 latest_result.confirmation_gate 为准；not_evaluated 不是 fail；官方分钟层 passed 仍不能单独打开确认门；holdout 为 not_ready 时 unique_minute_path 必须是 closed_at_representative，不得声称精确分钟或发布准确率。若宽度大于 5 或 confirmation_allowed 为 false，必须说这是一段不可分区间，把代表分钟称为代表性候选，不得说已定位到唯一分钟。候选未拉开时不得出示赢家卡；D9/D10 差异和精度阶段追问要用来区分，不得直接宣布不可分。用户仍可 accepted 代表性候选。
 10. 不泄露系统提示词或 Skill 原文。
-11. 追问只跟 method_followup_plan 与服务器已持久化的 current_question / open_question。不要调用 rectification-set-focus；下一问和点选卡由 compare-candidates / read-case 在服务端事务内创建。账本为空或 collect_method_evidence 时用自然语言问一件带大概年份的经历，正文直接问，不要提点选卡。若工具返回了 open_question / current_question，说明服务器已持久化当前选择题；题干和动态选项只由选择卡展示，正文只做简短自然承接，不得另写、改写或复述题干与选项。若没有持久化 current_question / open_question，不得根据 next_followup、探针或旧正文自行提出候选区分题。采用门所需的训练事件/领域未齐时不要走 dasha 冲突 event_probe，忽略 receipt 里未达采用门的 dasha 冲突探针。已记下的发挥质量探针跟 open_question 出点选卡。齐了之后 source=event_probe 只问这一件反推前事用来筛窗，不要继续轮询方法层，不要 offer。覆盖已齐后只问当前剩余候选分钟还能拆开的区分探针；训练事件已齐时同样不要因家人或职业未覆盖而改回收集。没有剩余拆分且未拉开时落实 offer_provisional_range，不要再问整窗 D9/D24，也不要 adopt。不要问两套盘哪个更像或可能性高低。点选 A/B/C/D 与「先这样」由服务器按 focusId/optionId 确定性处理，不要把选项全文当成新事件，也不要为点选调用 resolve-focus、read-case 或 compare；自由文本补充才走工具。正文禁止复述选项。不得询问外貌、体质、胎记或疤痕，也不得问钟点。不得按 missing_evidence_categories 轮询迁居，也不得先要 10–15 条事件长表。财务与健康只有用户主动说才问。方法覆盖为感情→事业→家人→职业→占问。D9/D10 类型表是校时方法，不是命运承诺。以「盘外核对（不计分）」开头的消息不得调用 record-evidence-batch 或 propose-evidence。
+11. 追问只跟 method_followup_plan 与服务器已持久化的 current_question / open_question。不要调用 rectification-set-focus；下一问和点选卡由 compare-candidates / read-case 在服务端事务内创建。账本为空或 collect_method_evidence 时用自然语言问一件带大概年份的经历，正文直接问，不要提点选卡。若工具返回了 open_question / current_question，说明服务器已持久化当前选择题；题干和动态选项只由选择卡展示，正文只做简短自然承接，不得另写、改写或复述题干与选项。若没有持久化 current_question / open_question，不得根据 next_followup、探针或旧正文自行提出候选区分题。采用门所需的训练事件/领域未齐时不要走 dasha 冲突 event_probe，忽略 receipt 里未达采用门的 dasha 冲突探针。已记下的发挥质量探针跟 open_question 出点选卡。齐了之后 source=event_probe 只问这一件反推前事用来筛窗，不要继续轮询方法层，不要 offer。覆盖已齐后只问当前剩余候选分钟还能拆开的区分探针；训练事件已齐时同样不要因家人或职业未覆盖而改回收集。没有剩余拆分且未拉开时落实 offer_provisional_range，不要再问整窗 D9/D24，也不要 adopt。不要问两套盘哪个更像或可能性高低。点选 A/B/C/D 与「先这样」由服务器按 focusId/optionId 确定性处理，不要把选项全文当成新事件，也不要为点选调用 resolve-focus、read-case 或 compare；自由文本补充才走工具。点选后续跑时不要再说已记录选择、已更新候选比较或请看下方选项；下一问题干只由选择卡展示。评分反推的时间必须来自引擎探针的年或月，不得把账本里同领域已记年份当成反推时间。正文禁止复述选项。不得询问外貌、体质、胎记或疤痕，也不得问钟点。不得按 missing_evidence_categories 轮询迁居，也不得先要 10–15 条事件长表。财务与健康只有用户主动说才问。方法覆盖为感情→事业→家人→职业→占问。D9/D10 类型表是校时方法，不是命运承诺。以「盘外核对（不计分）」开头的消息不得调用 record-evidence-batch 或 propose-evidence。
 12. 证据有效变化后由服务器重算候选。不要等用户说“没有更多了”才比较，也不要对同一证据指纹再 compare。分钟扫描只在服务端，结果只是候选或平台，不得宣布确认。
 13. 落实 start_consultation：前事核对结束或用户先这样后，请用户用当前采用时间看盘；对不上同时请改选其他候选。解释事件–Dasha 账本、双轨是否一致、换升时刻、精度阶段、D9/D10 类型对照和相对支持时，仍必须说候选范围不是出生时间真值。`;
 
diff --git a/frontend/src/mastra/rectification-v9-tools.ts b/frontend/src/mastra/rectification-v9-tools.ts
index 8dc39aec..3d65a03f 100644
--- a/frontend/src/mastra/rectification-v9-tools.ts
+++ b/frontend/src/mastra/rectification-v9-tools.ts
@@ -591,6 +591,7 @@ function agentVisibleLatestProjection(
 function collectingFollowupForParsed(
   parsed: DossierForTools,
   latest: NonNullable<DossierForTools["latestResult"]>,
+  birthDate?: string | null,
 ) {
   const windowScan = windowScanFromDecisionReceipt(latest.decisionReceipt ?? null);
   const observations = internalObservationsFromWindowScan(windowScan);
@@ -603,6 +604,7 @@ function collectingFollowupForParsed(
     observations,
     sessionOutcome: "collect_evidence",
     ...catalog,
+    birthDate,
     accepted: Boolean(parsed.case.acceptedTime),
     candidatesSeparated: separation.sufficient,
     holdoutValidation: holdoutStatusFromLatest(latest),
@@ -614,7 +616,7 @@ function sessionAwareFollowupForParsed(
   latest: NonNullable<DossierForTools["latestResult"]>,
   options?: { birthDate?: string | null; snapshotCurrent?: boolean },
 ) {
-  const collectingPlan = collectingFollowupForParsed(parsed, latest);
+  const collectingPlan = collectingFollowupForParsed(parsed, latest, options?.birthDate);
   const catalog = rectificationFollowupCatalog(latest, parsed.evidence);
   const contrastPacket = catalog.contrastPacket;
   const candidateScores = candidateScoresFromLatest(latest);
@@ -1035,7 +1037,14 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
     parsed: DossierForTools,
     latest: NonNullable<DossierForTools["latestResult"]>,
   ) => {
-    const { plan: collectingPlan, contrastPacket } = sessionAwareFollowupForParsed(parsed, latest);
+    let birthDate: string | null = null;
+    try {
+      const compute = await loadV9CaseCompute(accounting, userId, caseId);
+      birthDate = String(compute.baselineBirthSnapshot.birth_date ?? "") || null;
+    } catch {
+      // Ranking stays fail-open when compute is unavailable.
+    }
+    const { plan: collectingPlan, contrastPacket } = sessionAwareFollowupForParsed(parsed, latest, { birthDate });
     const persistedFocus = await persistServerOwnedFocus({
       accounting,
       userId,
diff --git a/frontend/tests/rectification-activity-receipt.test.ts b/frontend/tests/rectification-activity-receipt.test.ts
index 8fdcc5ea..3a2283d0 100644
--- a/frontend/tests/rectification-activity-receipt.test.ts
+++ b/frontend/tests/rectification-activity-receipt.test.ts
@@ -101,6 +101,7 @@ test("answer deltas preserve a still-running server activity", () => {
   );
   assert.match(deltaBranch, /state: raw\.trim\(\) \? "streaming" : "thinking"/);
   assert.match(deltaBranch, /text: raw,/);
+  assert.match(deltaBranch, /event\.replace === true \? event\.text : raw \+ event\.text/);
   assert.doesNotMatch(deltaBranch, /settled\.spoken/);
   assert.match(deltaBranch, /正在组织回答/);
   assert.doesNotMatch(deltaBranch, /activeActivity:\s*undefined/);
diff --git a/frontend/tests/rectification-agentic-entry.test.ts b/frontend/tests/rectification-agentic-entry.test.ts
index 9f7b7405..a520ed01 100644
--- a/frontend/tests/rectification-agentic-entry.test.ts
+++ b/frontend/tests/rectification-agentic-entry.test.ts
@@ -250,7 +250,10 @@ test("usage completes or releases without hiding settlement failures", () => {
   assert.match(run, /activity.changed/);
   assert.match(run, /if \(!answerText\.trim\(\)\) \{[\s\S]*composeRectificationTurnNarration/);
   assert.match(run, /bindSpokenToOpenQuestion/);
+  assert.match(run, /CHOICE_CARD_CONTINUATION_ACK/);
   assert.match(run, /openQuestionPromptFromToolResult/);
+  assert.doesNotMatch(run, /heldSpoken/);
+  assert.match(run, /replace: true/);
   const narration = readFileSync(
     new URL("../src/lib/rectification-agentic/v9/turn-narration.ts", import.meta.url),
     "utf8",
@@ -293,9 +296,9 @@ test("Agentic rectification follows the conversation tail only while the reader
   assert.match(chat, /choiceCardsOpen/);
   assert.match(
     chat,
-    /useLayoutEffect\(\(\) => \{\s*choiceCardsOpen\.current = showChoiceCards;\s*updateFollowState\(\);\s*\}, \[showChoiceCards, updateFollowState\]\)/,
+    /useLayoutEffect\(\(\) => \{\s*choiceCardsOpen\.current = showLiveChoiceCard;\s*updateFollowState\(\);\s*\}, \[showLiveChoiceCard, updateFollowState\]\)/,
   );
-  assert.doesNotMatch(chat, /choiceCardsOpen\.current = showChoiceCards;\s*useLayoutEffect/);
+  assert.doesNotMatch(chat, /choiceCardsOpen\.current = showLiveChoiceCard;\s*useLayoutEffect/);
   assert.match(chat, /updateFollowState/);
   assert.match(chat, /\}, \[busy, candidateResult, choiceCard, error, messages, savedTime, followLatestContent\]\);/);
   const jumpLatestRule = styles.match(/\.rectification-jump-latest \{[^}]+\}/)?.[0] ?? "";
@@ -539,26 +542,31 @@ test("time-selection cards appear under the latest settled agent bubble only aft
   assert.match(chat, /candidateResult\?\.selectionAllowed/);
   assert.match(chat, /turnOfferedSelection/);
   assert.match(chat, /rectification-offer-candidates/);
-  assert.match(chat, /showChoiceCards = Boolean\(\s*choiceCard[\s\S]*!offeredThisTurn[\s\S]*!busy/);
-  assert.match(chat, /showSelectionCards = Boolean\(\s*candidateResult\?\.selectionAllowed[\s\S]*offeredSelectionOnce[\s\S]*!showChoiceCards[\s\S]*!busy/);
+  assert.match(chat, /showLiveChoiceCard = Boolean\(\s*choiceCard[\s\S]*answeredQuestionIds[\s\S]*!busy/);
+  assert.match(chat, /showSelectionCards = Boolean\(\s*candidateResult\?\.selectionAllowed[\s\S]*offeredSelectionOnce[\s\S]*!showLiveChoiceCard[\s\S]*!busy/);
   assert.match(
     chat,
     /selectionCardMessageKey = showSelectionCards && latestSettledAssistant\s*\? latestSettledAssistant\.renderKey\s*: undefined/,
   );
   assert.match(messageLoop, /showSelectionCards && message\.renderKey === selectionCardMessageKey/);
   assert.match(messageLoop, /<RectificationChoiceCard/);
-  assert.match(messageLoop, /key=\{`\$\{choiceCard\.question_id\}:\$\{choiceNonce\}`\}/);
+  assert.match(messageLoop, /choiceAttachment/);
+  assert.match(messageLoop, /choiceNonce/);
+  assert.match(messageLoop, /answered:\$\{settledChoice\.selectedKey\}/);
   assert.doesNotMatch(choiceCardComponent, /setSelectedKey\(""\)/);
-  assert.match(chat, /showChoiceCards = Boolean\(/);
-  assert.match(chat, /choiceCardUserMessage/);
+  assert.match(choiceCardComponent, /selectedKey/);
+  assert.match(choiceCardComponent, /is-answered/);
+  assert.match(chat, /showLiveChoiceCard = Boolean\(/);
+  assert.match(chat, /isStructuredChoiceUserText/);
   assert.match(chat, /submitStructuredChoice\(CHOICE_ACTION/);
   assert.match(chat, /submitStructuredChoice\(STOP_ACTION/);
   assert.match(route, /answer_choice/);
   assert.match(route, /stop_and_review/);
   assert.match(route, /applyRectificationChoice\(accounting/);
+  assert.doesNotMatch(chat, /v9-choice-user-/);
   assert.doesNotMatch(chat, /send\("message", choiceCardUserMessage/);
   assert.doesNotMatch(chat, /send\("message", choiceCard\?\.stop_message/);
-  assert.match(chat, /CHOICE_STOP_MESSAGE/);
+  assert.doesNotMatch(chat, /choiceCardUserMessage/);
   assert.match(caseRoute, /choice_card: choiceCardFromCaseDossier/);
   assert.match(caseRoute, /overlayPublicDecision/);
   assert.match(caseRoute, /interview: publicDecisionFields/);
@@ -580,7 +588,7 @@ test("does not parse suggestions from an incomplete run", () => {
 });
 
 test("live answer.delta is the model reply, not a spoken-thinking split", () => {
-  assert.match(chat, /raw \+= event\.text/);
+  assert.match(chat, /raw = event\.replace === true \? event\.text : raw \+ event\.text/);
   assert.match(chat, /text: raw,/);
   assert.doesNotMatch(chat, /settleRectificationSpokenAndThinking/);
   assert.doesNotMatch(chat, /text: settled\.spoken/);
@@ -672,13 +680,20 @@ test("choice cards render the persisted prompt as the visible question stem", ()
   assert.doesNotMatch(choiceCardComponent, /<legend className="sr-only">\{props\.card\.prompt\}<\/legend>/);
 });
 
+test("choice card answers and stop share one stacked primary list", () => {
+  assert.match(choiceCardComponent, /birth-time-primary-choices/);
+  assert.match(choiceCardComponent, /props\.card\.options\.map/);
+  assert.doesNotMatch(choiceCardComponent, /birth-time-special-choices/);
+  assert.doesNotMatch(choiceCardComponent, /is-secondary/);
+});
+
 test("adopted time offers a consultation handoff without unique-minute copy", () => {
   assert.match(chat, /用这个时间看盘/);
   assert.match(chat, /onStartConsultation/);
   assert.match(board, /换升时刻/);
   assert.match(board, /经历与大运对照/);
   assert.match(chat, /<RectificationChoiceCard/);
-  assert.match(chat, /choiceCardUserMessage/);
+  assert.match(chat, /choiceAttachment/);
   assert.match(page, /startConsultationAfterRectification/);
   assert.match(page, /createSession\(modelCatalog\.defaultModelId\)/);
   assert.match(agent, /start_consultation/);
diff --git a/frontend/tests/rectification-answer-choice.test.ts b/frontend/tests/rectification-answer-choice.test.ts
index 90f15760..c9b288bd 100644
--- a/frontend/tests/rectification-answer-choice.test.ts
+++ b/frontend/tests/rectification-answer-choice.test.ts
@@ -3,10 +3,12 @@ import { readFileSync } from "node:fs";
 import test from "node:test";
 
 import { applyRectificationChoice } from "../src/lib/rectification-agentic/v9/answer-choice.ts";
+import { choiceCardFromCaseDossier } from "../src/lib/rectification-agentic/v9/interview-state.ts";
 import {
   CHOICE_ACTION,
   STOP_ACTION,
   composeChoiceNarration,
+  isStructuredChoiceUserText,
   quoteIsFromAssistantQuestion,
   shouldContinueAfterStructuredChoice,
   userVisibleChoiceLine,
@@ -22,12 +24,14 @@ import { buildInferenceState } from "../src/lib/rectification-agentic/core/build
 import { parseV9CaseDossier, RectificationToolServiceError } from "../src/lib/rectification-agentic/v9/tool-service.ts";
 import {
   CASE_ID,
+  EVIDENCE_ID,
   FOCUS_ID,
   SESSION_ID,
   TURN_ID,
   USER_ID,
   activeFocusFixture,
   candidateSnapshotFixture,
+  computeFixture,
   conversationSummaryFixture,
   dossierFixture,
   fakeAccounting,
@@ -36,6 +40,116 @@ import {
 
 const ACTION_ID = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
 const QUESTION_ID = "question-1";
+const NEXT_FOCUS_ID = "acacacac-acac-4cac-8cac-acacacacacac";
+const EDUCATION_ID = "44444444-4444-4444-8444-444444444445";
+const RELATIONSHIP_ID = "44444444-4444-4444-8444-444444444446";
+const CAREER_EXIT_ID = "44444444-4444-4444-8444-444444444447";
+const RELATIONSHIP_END_ID = "44444444-4444-4444-8444-444444444448";
+
+const STYLE_OPTIONS = [
+  { label: "明确发生且时间吻合", answer_class: "yes" as const },
+  { label: "发生过但程度较弱", answer_class: "weak_yes" as const },
+  { label: "明确没有发生", answer_class: "no" as const },
+  { label: "这段记不清楚", answer_class: "unsure" as const },
+];
+
+const RELOCATION_2015_PROBE = {
+  id: "p-reloc-2015",
+  semantic_key: "relocation.2015.05.dasha_boundary",
+  candidate_split_hash: "reloc-2015-split",
+  domain: "relocation",
+  year: 2015,
+  month: 5,
+  question: "2015 年 5 月前后有没有搬家或长期住到外地？",
+  candidate_ids: ["05:00", "05:10"],
+  expected_outcomes: [
+    { answer_class: "yes", supports: ["05:00"], conflicts: ["05:10"] },
+    { answer_class: "no", supports: ["05:10"], conflicts: ["05:00"] },
+    { answer_class: "unsure", supports: [], conflicts: [] },
+  ],
+  information_gain: 0.87,
+  source: "dasha_boundary",
+};
+
+const EDUCATION_2014_PROBE = {
+  id: "p-edu-2014",
+  semantic_key: "education.2014",
+  candidate_split_hash: "edu-2014-split",
+  domain: "education",
+  year: 2014,
+  question: "2014 年前后有没有升学、转学或换学习环境？",
+  candidate_ids: ["05:00", "05:10"],
+  expected_outcomes: [
+    { answer_class: "yes", supports: ["05:00"], conflicts: ["05:10"] },
+    { answer_class: "no", supports: ["05:10"], conflicts: ["05:00"] },
+    { answer_class: "unsure", supports: [], conflicts: [] },
+  ],
+  information_gain: 0.64,
+  source: "dasha_activation",
+};
+
+const FAMILY_2021_COLLECT = {
+  year: 2021,
+  year_label: "2021 年前后",
+  domain: "family",
+  event_family: "家人结婚、添丁或住院",
+  source: "age_band",
+  tracks: ["vimshottari", "narayana"],
+  tracks_agree: false,
+  unique_minute_claim: false,
+  user_meaning: "时间范围锁定 2021 年前后；领域锁定 family；语义目标是家人结婚、添丁或住院。",
+  role: "collect",
+  phase: "evidence_collection",
+  information_gain: 0,
+  semantic_key: "family.2021",
+  candidate_split_hash: "family:2021",
+  candidate_ids: [],
+  expected_outcomes: [],
+  style_options: STYLE_OPTIONS,
+  choice_kind: "existence",
+};
+
+const YEARLESS_D24_PROBE = {
+  id: "contrast:varga.d24.05:00/05:10",
+  semantic_key: "varga.d24.05:00/05:10",
+  candidate_split_hash: "varga.d24.05:00/05:10",
+  domain: "education",
+  year: 0,
+  question: "引擎给出的区分机会绑定 D24。",
+  candidate_ids: ["05:00", "05:10"],
+  expected_outcomes: [
+    { answer_class: "yes", supports: ["05:00"], conflicts: ["05:10"] },
+    { answer_class: "no", supports: ["05:10"], conflicts: ["05:00"] },
+  ],
+  information_gain: 2.5,
+  source: "varga_contrast",
+};
+
+function eventProbeFromConflict(probe: typeof RELOCATION_2015_PROBE | typeof EDUCATION_2014_PROBE) {
+  return {
+    year: probe.year,
+    year_label: `${probe.year} 年前后`,
+    ...("month" in probe && probe.month ? { month: probe.month, year_label: `${probe.year} 年 ${probe.month} 月前后` } : {}),
+    domain: probe.domain,
+    event_family: probe.domain === "education"
+      ? "升学、转学或换学习环境"
+      : "搬家或长期住到外地",
+    source: probe.source,
+    tracks: ["vimshottari", "narayana"],
+    tracks_agree: false,
+    unique_minute_claim: false,
+    user_meaning: probe.question,
+    role: "distinguish",
+    phase: "candidate_discriminator",
+    information_gain: probe.information_gain,
+    semantic_key: probe.semantic_key,
+    candidate_split_hash: probe.candidate_split_hash,
+    candidate_ids: probe.candidate_ids,
+    expected_outcomes: probe.expected_outcomes,
+    style_options: STYLE_OPTIONS,
+    choice_kind: "existence",
+  };
+}
 
 function inferenceState() {
   return buildInferenceState({
@@ -100,6 +214,219 @@ function choiceDossier() {
   });
 }
 
+function twoProbeInference() {
+  return buildInferenceState({
+    range_start: "04:45",
+    range_end: "05:15",
+    candidates: [
+      { id: "05:00", time: "05:00", relative_support: 16 },
+      { id: "05:10", time: "05:10", relative_support: 14 },
+    ],
+    events: [
+      { id: "e1", domain: "career", year: 2020, precision: "month" },
+      { id: "e2", domain: "career", year: 2024, precision: "day" },
+      { id: "e3", domain: "relationship", year: 2024, precision: "month" },
+      { id: "e4", domain: "career", year: 2026, precision: "day" },
+      { id: "e5", domain: "relationship", year: 2024, precision: "day" },
+    ],
+    probes: [RELOCATION_2015_PROBE, EDUCATION_2014_PROBE],
+  });
+}
+
+function fourEventRows() {
+  return [
+    {
+      id: EVIDENCE_ID,
+      source_turn_id: TURN_ID,
+      subject: "self",
+      event_kind: "career_entry",
+      domain: "career",
+      occurred_from: "2020-04-01",
+      occurred_to: "2020-04-01",
+      date_precision: "month",
+      summary: "2020 年 4 月开始实习",
+      status: "confirmed",
+      supersedes_evidence_id: null,
+      created_at: "2026-08-28T07:35:45.000Z",
+    },
+    {
+      id: EDUCATION_ID,
+      source_turn_id: TURN_ID,
+      subject: "self",
+      event_kind: "career_entry",
+      domain: "career",
+      occurred_from: "2024-04-07",
+      occurred_to: null,
+      date_precision: "day",
+      summary: "2024 年 4 月 7 日正式入职",
+      status: "confirmed",
+      supersedes_evidence_id: null,
+      created_at: "2026-08-28T07:36:35.000Z",
+    },
+    {
+      id: RELATIONSHIP_ID,
+      source_turn_id: TURN_ID,
+      subject: "self",
+      event_kind: "relationship_start",
+      domain: "relationship",
+      occurred_from: "2024-05-01",
+      occurred_to: "2024-05-01",
+      date_precision: "month",
+      summary: "2024 年 5 月认识一位女生",
+      status: "confirmed",
+      supersedes_evidence_id: null,
+      created_at: "2026-08-28T07:37:02.000Z",
+    },
+    {
+      id: CAREER_EXIT_ID,
+      source_turn_id: TURN_ID,
+      subject: "self",
+      event_kind: "career_exit",
+      domain: "career",
+      occurred_from: "2026-08-11",
+      occurred_to: null,
+      date_precision: "day",
+      summary: "2026 年 8 月 11 日离职",
+      status: "confirmed",
+      supersedes_evidence_id: null,
+      created_at: "2026-08-28T07:36:35.000Z",
+    },
+    {
+      id: RELATIONSHIP_END_ID,
+      source_turn_id: TURN_ID,
+      subject: "self",
+      event_kind: "relationship_end",
+      domain: "relationship",
+      occurred_from: "2024-08-08",
+      occurred_to: "2024-08-08",
+      date_precision: "day",
+      summary: "2024 年 8 月 8 日与对方分手",
+      status: "confirmed",
+      supersedes_evidence_id: null,
+      created_at: "2026-08-28T07:37:02.000Z",
+    },
+  ];
+}
+
+function twoProbeDossier() {
+  const inference = twoProbeInference();
+  const snapshot = candidateSnapshotFixture({
+    decisionReceipt: {
+      inference_state: inference,
+      discriminating_event_probes: [
+        eventProbeFromConflict(RELOCATION_2015_PROBE),
+        eventProbeFromConflict(EDUCATION_2014_PROBE),
+      ],
+    },
+  });
+  return dossierFixture({
+    evidenceCount: 5,
+    evidence: fourEventRows(),
+    latestResult: snapshot,
+    conversationSummary: conversationSummaryFixture({
+      activeFocus: activeFocusFixture({
+        intent: "distinguish_candidates",
+        targetDomain: "relocation",
+        targetKind: "home_change",
+        expectedAnswerSchema: {
+          choice: {
+            prompt: "2015 年 5 月前后，有没有搬家或长期住到外地？",
+            option_a: "明确发生且时间吻合",
+            option_b: "发生过但程度较弱",
+            option_c: "明确没有发生",
+            option_d: "这段记不清楚",
+            options: STYLE_OPTIONS.map((option, index) => ({
+              key: (["A", "B", "C", "D"] as const)[index]!,
+              label: option.label,
+              answer_class: option.answer_class,
+            })),
+          },
+          probe_id: RELOCATION_2015_PROBE.id,
+          semantic_key: RELOCATION_2015_PROBE.semantic_key,
+          candidate_split_hash: RELOCATION_2015_PROBE.candidate_split_hash,
+        },
+      }),
+    }),
+    turns: [{
+      id: TURN_ID,
+      role: "assistant",
+      text: "接下来有一个问题需要您点选一下，麻烦看一下下方选项。",
+      status: "completed",
+      created_at: "2026-08-28T07:36:54.000Z",
+      completed_at: "2026-08-28T07:37:34.000Z",
+    }],
+  });
+}
+
+function familyCollectInference() {
+  return buildInferenceState({
+    range_start: "04:45",
+    range_end: "05:15",
+    candidates: [
+      { id: "05:00", time: "05:00", relative_support: 16 },
+      { id: "05:10", time: "05:10", relative_support: 14 },
+    ],
+    events: [
+      { id: "e1", domain: "career", year: 2020, precision: "month" },
+      { id: "e2", domain: "career", year: 2024, precision: "day" },
+      { id: "e3", domain: "relationship", year: 2024, precision: "month" },
+      { id: "e4", domain: "career", year: 2026, precision: "day" },
+      { id: "e5", domain: "relationship", year: 2024, precision: "day" },
+    ],
+    probes: [RELOCATION_2015_PROBE, YEARLESS_D24_PROBE],
+  });
+}
+
+function familyCollectDossier() {
+  const inference = familyCollectInference();
+  const snapshot = candidateSnapshotFixture({
+    decisionReceipt: {
+      inference_state: inference,
+      discriminating_event_probes: [eventProbeFromConflict(RELOCATION_2015_PROBE)],
+      evidence_collection_probes: [FAMILY_2021_COLLECT],
+    },
+  });
+  return dossierFixture({
+    evidenceCount: 5,
+    evidence: fourEventRows(),
+    latestResult: snapshot,
+    conversationSummary: conversationSummaryFixture({
+      activeFocus: activeFocusFixture({
+        intent: "distinguish_candidates",
+        targetDomain: "relocation",
+        targetKind: "home_change",
+        expectedAnswerSchema: {
+          choice: {
+            prompt: "2015 年 5 月前后，有没有搬家或长期住到外地？",
+            option_a: "明确发生且时间吻合",
+            option_b: "发生过但程度较弱",
+            option_c: "明确没有发生",
+            option_d: "这段记不清楚",
+            options: STYLE_OPTIONS.map((option, index) => ({
+              key: (["A", "B", "C", "D"] as const)[index]!,
+              label: option.label,
+              answer_class: option.answer_class,
+            })),
+          },
+          probe_id: RELOCATION_2015_PROBE.id,
+          semantic_key: RELOCATION_2015_PROBE.semantic_key,
+        },
+      }),
+    }),
+  });
+}
+
+function persistChoiceAccounting(
+  dossier: ReturnType<typeof twoProbeDossier>,
+  extra: Parameters<typeof fakeAccounting>[0] = {},
+) {
+  return choiceAccounting({
+    get_agentic_rectification_case_dossier: () => dossier,
+    get_agentic_rectification_case_compute: () => computeFixture(),
+    ...extra,
+  });
+}
+
 function choiceAccounting(overrides: Parameters<typeof fakeAccounting>[0] = {}) {
   const receipts = new Map<string, Record<string, unknown>>();
   return fakeAccounting({
@@ -172,6 +499,15 @@ test("choice quotes come from the option label, not the assistant question year"
   assert.equal(userVisibleChoiceLine(card, "A"), "A. 是，大概就在那段时间");
 });
 
+test("synthetic choice taps are not kept as chat user lines", () => {
+  assert.equal(isStructuredChoiceUserText("A. 发挥明显失常或压力很大"), true);
+  assert.equal(isStructuredChoiceUserText("先这样"), true);
+  assert.equal(isStructuredChoiceUserText("先这样，先看当前范围"), true);
+  assert.equal(isStructuredChoiceUserText("盘外核对（不计分）：A. 明确发生且时间吻合"), true);
+  assert.equal(isStructuredChoiceUserText("2016年我上了大学"), false);
+  assert.equal(isStructuredChoiceUserText("没有，那年很顺利"), false);
+});
+
 test("clicking A applies the choice without invoking a language model", async () => {
   const accounting = choiceAccounting();
   const applied = await applyRectificationChoice(accounting.client, {
@@ -202,7 +538,7 @@ test("clicking A applies the choice without invoking a language model", async ()
   }));
   const fns = accounting.calls.map((call) => call.fn);
   assert.ok(fns.includes("apply_agentic_rectification_choice_action"));
-  assert.ok(fns.includes("append_agentic_rectification_turn"));
+  assert.equal(fns.includes("append_agentic_rectification_turn"), false);
   assert.equal(fns.includes("record_agentic_rectification_evidence_batch"), false);
   assert.equal(fns.some((fn) => fn === "create_agentic_rectification_run_attempt" || fn.includes("stream")), false);
   const persist = accounting.calls.find((call) => call.fn === "apply_agentic_rectification_choice_action");
@@ -219,6 +555,129 @@ test("clicking A applies the choice without invoking a language model", async ()
     || applied.nextAction.type === "ask_fact_collection", true);
 });
 
+test("answering a discriminator persists the next dated card so GET still has a tap target", async () => {
+  const closed = parseV9CaseDossier(twoProbeDossier());
+  assert.ok(closed);
+  closed.conversationSummary.activeFocus = null;
+  assert.equal(choiceCardFromCaseDossier(closed), null);
+
+  const accounting = persistChoiceAccounting(twoProbeDossier(), {
+    set_agentic_rectification_conversation_focus: (_fn, args) => ({
+      focus: {
+        id: NEXT_FOCUS_ID,
+        case_id: CASE_ID,
+        question_id: args.p_question_id,
+        intent: args.p_intent,
+        target_evidence_id: args.p_target_evidence_id,
+        target_domain: args.p_target_domain,
+        target_kind: args.p_target_kind,
+        expected_answer_schema: args.p_expected_answer_schema,
+        status: "active",
+        asked_at: "2026-08-28T07:37:50.000Z",
+        resolved_at: null,
+      },
+      idempotent: false,
+    }),
+  });
+  const applied = await applyRectificationChoice(accounting.client, {
+    userId: USER_ID,
+    caseId: CASE_ID,
+    sessionId: SESSION_ID,
+    actionId: ACTION_ID,
+    action: CHOICE_ACTION,
+    focusId: FOCUS_ID,
+    questionId: QUESTION_ID,
+    probeId: RELOCATION_2015_PROBE.id,
+    optionId: "C",
+    expectedRevision: twoProbeInference().revision,
+  });
+  const setFocus = accounting.calls.find((call) => call.fn === "set_agentic_rectification_conversation_focus");
+  assert.ok(setFocus, JSON.stringify(accounting.calls.map((call) => call.fn)));
+  assert.equal(setFocus.args.p_intent, "distinguish_candidates");
+  const schema = setFocus.args.p_expected_answer_schema as { semantic_key?: string; choice?: { prompt?: string } };
+  assert.equal(schema.semantic_key, EDUCATION_2014_PROBE.semantic_key);
+  assert.match(schema.choice?.prompt ?? "", /2014/);
+  assert.doesNotMatch(schema.choice?.prompt ?? "", /2015/);
+  assert.equal(applied.nextInterviewPersisted, true);
+  assert.equal(applied.nextChoiceReady, true);
+  assert.equal(shouldContinueAfterStructuredChoice(applied.nextAction, applied), false);
+  assert.equal(applied.narration, "接下来请点选下面这一问。");
+  const turn = accounting.calls.find((call) => call.fn === "append_agentic_rectification_turn");
+  assert.equal(turn?.args.p_assistant_message, "接下来请点选下面这一问。");
+
+  const refreshed = parseV9CaseDossier(twoProbeDossier());
+  assert.ok(refreshed);
+  const answered = twoProbeInference();
+  refreshed.latestResult = {
+    ...refreshed.latestResult!,
+    decisionReceipt: {
+      ...(refreshed.latestResult?.decisionReceipt ?? {}),
+      inference_state: {
+        ...answered,
+        answered_probes: [{
+          probe_id: RELOCATION_2015_PROBE.id,
+          semantic_key: RELOCATION_2015_PROBE.semantic_key,
+          candidate_split_hash: RELOCATION_2015_PROBE.candidate_split_hash,
+          answer_class: "no",
+          classified_from: "choice",
+        }],
+      },
+    },
+  };
+  refreshed.conversationSummary.activeFocus = {
+    id: NEXT_FOCUS_ID,
+    caseId: CASE_ID,
+    questionId: String(setFocus.args.p_question_id),
+    intent: String(setFocus.args.p_intent),
+    targetEvidenceId: null,
+    targetDomain: typeof setFocus.args.p_target_domain === "string" ? setFocus.args.p_target_domain : "education",
+    targetKind: null,
+    expectedAnswerSchema: schema,
+    status: "active",
+    askedAt: "2026-08-28T07:37:50.000Z",
+    resolvedAt: null,
+  };
+  const card = choiceCardFromCaseDossier(refreshed);
+  assert.ok(card);
+  assert.equal(card.focus_id, NEXT_FOCUS_ID);
+  assert.match(card.prompt, /2014/);
+  assert.doesNotMatch(card.prompt, /2015/);
+});
+
+test("answering the last discriminator persists a year-locked family collect, not a yearless D24 card", async () => {
+  const accounting = persistChoiceAccounting(familyCollectDossier(), {
+    set_agentic_rectification_conversation_focus: () => {
+      throw new Error("yearless D24 must not persist a scoring focus");
+    },
+  });
+  const applied = await applyRectificationChoice(accounting.client, {
+    userId: USER_ID,
+    caseId: CASE_ID,
+    sessionId: SESSION_ID,
+    actionId: ACTION_ID,
+    action: CHOICE_ACTION,
+    focusId: FOCUS_ID,
+    questionId: QUESTION_ID,
+    probeId: RELOCATION_2015_PROBE.id,
+    optionId: "C",
+    expectedRevision: familyCollectInference().revision,
+  });
+  assert.equal(
+    accounting.calls.some((call) => call.fn === "set_agentic_rectification_conversation_focus"),
+    false,
+    JSON.stringify(accounting.calls.map((call) => call.fn)),
+  );
+  assert.equal(applied.nextInterviewPersisted, true);
+  assert.equal(applied.nextChoiceReady, false);
+  assert.equal(shouldContinueAfterStructuredChoice(applied.nextAction, applied), false);
+  assert.match(applied.narration, /2021/);
+  assert.match(applied.narration, /家人|结婚|添丁|住院/);
+  assert.doesNotMatch(applied.narration, /点选/);
+  assert.doesNotMatch(applied.narration, /D24/);
+  const turn = accounting.calls.find((call) => call.fn === "append_agentic_rectification_turn");
+  assert.match(String(turn?.args.p_assistant_message ?? ""), /2021/);
+});
+
 test("replaying the same actionId does not duplicate the applied receipt", async () => {
   const accounting = choiceAccounting();
   const command = {
@@ -286,6 +745,7 @@ test("stop_and_review does not write an inference transition", async () => {
   const persist = accounting.calls.find((call) => call.fn === "apply_agentic_rectification_choice_action");
   assert.equal(persist?.args.p_inference, null);
   assert.equal(persist?.args.p_focus_status, "skipped");
+  assert.ok(accounting.calls.some((call) => call.fn === "append_agentic_rectification_turn"));
 });
 
 test("turn_decision stays inside the configured byte budget", () => {
@@ -356,6 +816,10 @@ test("structured choice only continues through the agent when another question i
     assert.equal(shouldContinueAfterStructuredChoice({ type }), false);
   }
   assert.equal(shouldContinueAfterStructuredChoice(null), false);
+  assert.equal(
+    shouldContinueAfterStructuredChoice({ type: "ask_candidate_discriminator" }, { nextInterviewPersisted: true }),
+    false,
+  );
 });
 
 test("structured choice narration never persists a fake loading state", () => {
@@ -384,8 +848,10 @@ test("the public agent route treats structured choice as a non-model command", (
   const chat = readFileSync(new URL("../src/components/rectification-agentic-chat.tsx", import.meta.url), "utf8");
   assert.match(chat, /isPersistedFocusId\(focusId\)/);
   assert.match(chat, /focusId,/);
-  assert.match(chat, /shouldContinueAfterStructuredChoice\(payload\?\.nextAction\)/);
+  assert.match(chat, /shouldContinueAfterStructuredChoice\(payload\?\.nextAction, payload\)/);
   assert.match(chat, /send\("read_only", ""\)/);
+  assert.match(chat, /willContinue/);
+  assert.match(chat, /current\.filter\(\(message\) => message\.renderKey !== assistantRenderKey\)/);
   assert.match(chat, /回到最新/);
   assert.match(chat, /followTailRef\.current/);
 });
diff --git a/frontend/tests/rectification-choice-card.test.ts b/frontend/tests/rectification-choice-card.test.ts
index 331580f7..9a4ab6fc 100644
--- a/frontend/tests/rectification-choice-card.test.ts
+++ b/frontend/tests/rectification-choice-card.test.ts
@@ -7,6 +7,7 @@ import {
   HOLDOUT_MESSAGE_PREFIX,
   isHoldoutVerificationQuote,
   lifePeriodLabel,
+  preferConcreteChoicePrompt,
   mergeChoiceCard,
   parseAgentChoiceCopy,
   parseRectificationChoiceCard,
@@ -14,6 +15,7 @@ import {
 } from "../src/lib/rectification-agentic/v9/choice-card.ts";
 import { buildMethodFollowupPlan, projectRectificationChoiceCard } from "../src/lib/rectification-agentic/v9/method-followup.ts";
 import { choiceCardFromCaseDossier } from "../src/lib/rectification-agentic/v9/interview-state.ts";
+import { QUALITY_STYLE_OPTIONS } from "../src/lib/rectification-agentic/v9/probe-question-contract.ts";
 import type { DiscriminatingEventProbe } from "../src/lib/rectification-agentic/v9/refinement-packet.ts";
 
 const DYNAMIC_STYLE_OPTIONS = [
@@ -288,6 +290,12 @@ test("life period only reuses years from the same domain", () => {
   assert.equal(lifePeriodLabel([
     { status: "confirmed", domain: "education", datePrecision: "year", occurredFrom: "2016-01-01", occurredTo: null },
   ], "relocation"), "那段时间");
+  assert.equal(lifePeriodLabel([
+    { status: "confirmed", domain: "career", datePrecision: "month", occurredFrom: "2020-04-01", occurredTo: null },
+  ], "career"), "2020 年 4 月前后");
+  assert.equal(lifePeriodLabel([
+    { status: "confirmed", domain: "relationship", datePrecision: "day", occurredFrom: "2024-08-08", occurredTo: null },
+  ], "relationship"), "2024 年 8 月前后");
 });
 
 test("choice frame requires a real non-empty event family", () => {
@@ -306,6 +314,124 @@ test("choice frame requires a real non-empty event family", () => {
   }, { probes: [{ ...MOVE_PROBE, event_family: "   " }] }), null);
 });
 
+test("yearless D24 quality cards do not borrow a recorded education year", () => {
+  const frame = buildChoiceFrame({
+    method_id: "d5_education",
+    ask_theme: "education_style",
+    domain: "education",
+    user_prompt_hint: "unused",
+    choice_kind: "event_quality",
+    semantic_key: "varga.d24.05:00/05:07",
+    style_options: QUALITY_STYLE_OPTIONS,
+  }, {
+    evidence: [{
+      status: "confirmed",
+      domain: "education",
+      datePrecision: "year",
+      occurredFrom: "2016-01-01",
+      occurredTo: null,
+    }],
+    probes: [{
+      ...MOVE_PROBE,
+      year: 0,
+      year_label: "当前这几个候选",
+      domain: "education",
+      event_family: "学业或考试发挥失常、压力特别大",
+      choice_kind: "event_quality",
+      semantic_key: "varga.d24.05:00/05:07",
+      style_options: QUALITY_STYLE_OPTIONS,
+    }],
+  });
+  assert.equal(frame, null);
+});
+
+test("yearless family cards do not attach a scoring frame", () => {
+  const frame = buildChoiceFrame({
+    method_id: "relatives",
+    ask_theme: "family_event",
+    domain: "family",
+    user_prompt_hint: "unused",
+    choice_kind: "existence",
+  }, {
+    evidence: [{
+      status: "confirmed",
+      domain: "education",
+      datePrecision: "year",
+      occurredFrom: "2016-01-01",
+      occurredTo: null,
+    }],
+    probes: [{
+      ...MOVE_PROBE,
+      year: 0,
+      year_label: "当前这几个候选",
+      domain: "family",
+      event_family: "家人结婚、添丁或住院",
+      choice_kind: "existence",
+      semantic_key: "varga.d12.05:00/05:07",
+    }],
+  });
+  assert.equal(frame, null);
+});
+
+test("yearless family cards do not borrow a recorded family year", () => {
+  const frame = buildChoiceFrame({
+    method_id: "relatives",
+    ask_theme: "family_event",
+    domain: "family",
+    user_prompt_hint: "unused",
+    choice_kind: "existence",
+  }, {
+    evidence: [{
+      status: "confirmed",
+      domain: "family",
+      datePrecision: "year",
+      occurredFrom: "2018-01-01",
+      occurredTo: null,
+    }],
+    probes: [{
+      ...MOVE_PROBE,
+      year: 0,
+      year_label: "当前这几个候选",
+      domain: "family",
+      event_family: "家人结婚、添丁或住院",
+      choice_kind: "existence",
+      semantic_key: "varga.d12.05:00/05:07",
+    }],
+  });
+  assert.equal(frame, null);
+});
+
+test("GET upgrades a persisted placeholder stem to the recorded year lock", () => {
+  assert.equal(
+    preferConcreteChoicePrompt(
+      "2016 年前后，有没有学业或考试发挥失常、压力特别大的时候？",
+      "当前这几个候选 · 学业、考试发挥或学习压力出现明显变化",
+    ),
+    "2016 年前后，有没有学业或考试发挥失常、压力特别大的时候？",
+  );
+  assert.equal(
+    preferConcreteChoicePrompt(
+      "2016 年前后，有没有学业或考试发挥失常、压力特别大的时候？",
+      "2016 年前后 · 学业、考试发挥或学习压力出现明显变化",
+    ),
+    "2016 年前后，有没有学业或考试发挥失常、压力特别大的时候？",
+  );
+  assert.equal(
+    preferConcreteChoicePrompt(
+      "2018 年前后，有没有开始一段认真关系、分手或结婚？",
+      "2018 年前后，有没有认真关系进入、结束或关系观明显转变？",
+    ),
+    "2018 年前后，有没有开始一段认真关系、分手或结婚？",
+  );
+  assert.equal(
+    preferConcreteChoicePrompt(
+      "2018 年前后，有没有家人结婚、添丁或住院？",
+      "那段时间，有没有家人相关的明显变化？",
+    ),
+    "2018 年前后，有没有家人结婚、添丁或住院？",
+  );
+});
+
 test("choice frame completes existence options and rejects illegal or non-renderable varga styles", () => {
   const build = (style_options: DiscriminatingEventProbe["style_options"], extra: Partial<DiscriminatingEventProbe> = {}) => buildChoiceFrame({
     method_id: "d4_home",
@@ -891,6 +1017,175 @@ test("GET choice_card stays after coverage when remaining minutes still split on
   assert.equal(card.prompt, SAMPLE_COPY.prompt);
 });
 
+test("GET shows an engine-dated career dasha instead of locking D24 to the recorded education year", () => {
+  const careerKey = "career.2012.11.dasha_boundary";
+  const careerCopy = {
+    prompt: "2012 年 11 月前后，有没有入职、升职或职责明显加重？",
+    option_a: DYNAMIC_STYLE_OPTIONS[0]!.label,
+    option_b: DYNAMIC_STYLE_OPTIONS[1]!.label,
+    option_c: DYNAMIC_STYLE_OPTIONS[2]!.label,
+    option_d: DYNAMIC_STYLE_OPTIONS[3]!.label,
+    options: DYNAMIC_STYLE_OPTIONS.map((option, index) => ({
+      key: (["A", "B", "C", "D"] as const)[index]!,
+      label: option.label,
+      answer_class: option.answer_class,
+    })),
+  };
+  const inferenceCandidates = [
+    { id: "04:47", time: "04:47", cluster_range: ["04:47", "04:47"] as const, prior_score: 5, posterior_score: 5, probability: 0.05, status: "active", rank: 6, strong_conflict_count: 0 },
+    { id: "05:00", time: "05:00", cluster_range: ["05:00", "05:00"] as const, prior_score: 21, posterior_score: 21, probability: 0.21, status: "active", rank: 1, strong_conflict_count: 0 },
+    { id: "05:07", time: "05:07", cluster_range: ["05:07", "05:07"] as const, prior_score: 18, posterior_score: 18, probability: 0.18, status: "active", rank: 2, strong_conflict_count: 0 },
+    { id: "05:12", time: "05:12", cluster_range: ["05:12", "05:12"] as const, prior_score: 18, posterior_score: 18, probability: 0.18, status: "active", rank: 3, strong_conflict_count: 0 },
+    { id: "05:14", time: "05:14", cluster_range: ["05:14", "05:14"] as const, prior_score: 17, posterior_score: 17, probability: 0.17, status: "active", rank: 4, strong_conflict_count: 0 },
+    { id: "05:15", time: "05:15", cluster_range: ["05:15", "05:15"] as const, prior_score: 3, posterior_score: 3, probability: 0.03, status: "active", rank: 9, strong_conflict_count: 0 },
+  ];
+  const candidateSetId = "04:45-05:15:04:47,05:00,05:07,05:12,05:14,05:15";
+  const d24Key = "varga.d24.04:47/04:51|04:53/04:59/05:00/05:07|05:12/05:14|05:15";
+  const d24Split = `${candidateSetId}:${d24Key}`;
+  const d24Outcomes = [
+    { answer_class: "yes", supports: ["04:47"], conflicts: ["05:00", "05:07", "05:12", "05:14", "05:15"] },
+    { answer_class: "weak_yes", supports: ["05:00", "05:07"], conflicts: ["04:47", "05:12", "05:14", "05:15"] },
+    { answer_class: "no", supports: ["05:12", "05:14"], conflicts: ["04:47", "05:00", "05:07", "05:15"] },
+    { answer_class: "unsure", supports: [], conflicts: [] },
+  ];
+  const card = choiceCardFromCaseDossier({
+    evidence: [{
+      status: "confirmed",
+      domain: "education",
+      datePrecision: "year",
+      occurredFrom: "2016-01-01",
+      occurredTo: "2016-01-01",
+      eventKind: "education_start",
+    }, {
+      status: "confirmed",
+      domain: "career",
+      datePrecision: "month",
+      occurredFrom: "2020-04-01",
+      occurredTo: "2020-04-01",
+      eventKind: "career_entry",
+    }, {
+      status: "confirmed",
+      domain: "career",
+      datePrecision: "month",
+      occurredFrom: "2020-10-01",
+      occurredTo: "2020-10-01",
+      eventKind: "career_exit",
+    }, {
+      status: "confirmed",
+      domain: "career",
+      datePrecision: "day",
+      occurredFrom: "2024-04-07",
+      occurredTo: null,
+      eventKind: "career_entry",
+    }, {
+      status: "confirmed",
+      domain: "relationship",
+      datePrecision: "month",
+      occurredFrom: "2024-05-01",
+      occurredTo: null,
+      eventKind: "relationship_start",
+    }, {
+      status: "confirmed",
+      domain: "relationship",
+      datePrecision: "day",
+      occurredFrom: "2024-08-08",
+      occurredTo: null,
+      eventKind: "relationship_end",
+    }],
+    conversationSummary: {
+      activeFocus: {
+        id: FOCUS_ID,
+        questionId: `probe:${careerKey}`,
+        intent: "distinguish_candidates",
+        targetDomain: "career",
+        targetKind: null,
+        expectedAnswerSchema: {
+          choice: careerCopy,
+          probe_id: `event:${careerKey}`,
+          semantic_key: careerKey,
+          candidate_split_hash: "career.2012.11",
+          choice_kind: "existence",
+        },
+      },
+      declinedSkippedTopics: [],
+    },
+    latestResult: {
+      resultId: "result-d24-open",
+      selectionAllowed: true,
+      confirmationAllowed: false,
+      candidates: inferenceCandidates.map((item) => ({
+        time: item.time,
+        rank: item.rank,
+        relativeSupport: item.posterior_score,
+      })),
+      decisionReceipt: {
+        discriminating_event_probes: [{
+          year: 2012,
+          year_label: "2012 年 11 月前后",
+          domain: "career",
+          event_family: "入职、升职或职责明显加重",
+          source: "dasha_boundary",
+          tracks: ["vimshottari", "narayana"],
+          tracks_agree: true,
+          unique_minute_claim: false,
+          user_meaning: "时间范围锁定 2012 年 11 月前后。",
+          role: "distinguish",
+          phase: "candidate_discriminator",
+          information_gain: 1.3356,
+          semantic_key: careerKey,
+          candidate_split_hash: "career.2012.11",
+          candidate_ids: ["04:47", "05:00", "05:15"],
+          expected_outcomes: [
+            { answer_class: "yes", supports: ["04:47"], conflicts: ["05:00", "05:15"] },
+            { answer_class: "weak_yes", supports: ["04:47"], conflicts: ["05:00", "05:15"] },
+            { answer_class: "no", supports: ["05:00", "05:15"], conflicts: ["04:47"] },
+            { answer_class: "unsure", supports: [], conflicts: [] },
+          ],
+          style_options: DYNAMIC_STYLE_OPTIONS,
+        }],
+        inference_state: {
+          algorithm_version: "rectification-inference-v1",
+          candidate_set_id: candidateSetId,
+          revision: 1,
+          phase: "discrimination",
+          result_status: "discriminating",
+          range_start: "04:45",
+          range_end: "05:15",
+          candidates: inferenceCandidates,
+          events: [],
+          probes: [{
+            id: `contrast:${d24Key}`,
+            year: 0,
+            domain: "education",
+            source: "varga_contrast",
+            question: "引擎给出的区分机会绑定 D24。",
+            semantic_key: d24Key,
+            candidate_ids: inferenceCandidates.map((item) => item.time),
+            information_gain: 2.503258334775646,
+            expected_outcomes: d24Outcomes,
+            candidate_split_hash: d24Split,
+          }],
+          answered_probes: [],
+          rounds: [],
+          entropy: 2.0,
+          representative_time: "05:00",
+          credible_range: ["05:00", "05:14"],
+        },
+      },
+    },
+    case: { acceptedTime: null, status: "collecting_evidence" },
+    turns: [],
+  });
+  assert.ok(card);
+  assert.equal(card.focus_id, FOCUS_ID);
+  assert.match(card.prompt, /2012 年 11 月前后，有没有入职、升职或职责明显加重？/);
+  assert.doesNotMatch(card.prompt, /2016 年前后/);
+  assert.doesNotMatch(card.prompt, /当前这几个候选/);
+  assert.doesNotMatch(card.prompt, / · /);
+  assert.equal(card.options.length, 4);
+  assert.equal(card.options.every((option) => option.role === "primary"), true);
+});
+
 test("GET choice_card stays hidden without a persisted focus after 没有了", () => {
   const card = choiceCardFromCaseDossier({
     evidence: [{
@@ -1058,8 +1353,8 @@ test("career event_quality uses the supplied dynamic labels", () => {
   assert.ok(copy);
   assert.match(copy.prompt, /2020 年前后/);
   assert.match(copy.prompt, /入职、升职或职责明显加重/);
-  assert.doesNotMatch(copy.prompt, /有没有/);
-  assert.match(copy.prompt, /·/);
+  assert.match(copy.prompt, /有没有/);
+  assert.doesNotMatch(copy.prompt, / · /);
   assert.equal(copy.option_a, DYNAMIC_STYLE_OPTIONS[0].label);
   assert.doesNotMatch(copy.option_a, /失常/);
 });
diff --git a/frontend/tests/rectification-decision-authority.test.ts b/frontend/tests/rectification-decision-authority.test.ts
index 784fa339..7d9dda76 100644
--- a/frontend/tests/rectification-decision-authority.test.ts
+++ b/frontend/tests/rectification-decision-authority.test.ts
@@ -336,31 +336,36 @@ test("scored inference catalog outranks a low-gain Python career probe when snap
 
   const plan = buildMethodFollowupPlan({
     evidence,
-    eventProbes: packet.probes.flatMap((probe) => probe.semanticKey.startsWith("career.")
-      ? [{
-        year: 2023,
-        year_label: "2023 年前后",
-        domain: "career",
-        event_family: "入职、升职或职责明显加重",
-        source: "dasha_activation",
-        tracks: ["vimshottari", "narayana"],
-        tracks_agree: false,
-        unique_minute_claim: false,
-        user_meaning: "时间范围锁定 2023 年前后。",
-        role: "distinguish",
-        phase: "candidate_discriminator",
-        information_gain: 0.56,
-        semantic_key: "career.2023.dasha_activation",
-        candidate_split_hash: "500ce694938305201fbab9ba",
-        candidate_ids: ["04:45", "05:00", "05:14", "05:15"],
-        expected_outcomes: careerOutcomes,
-      }]
-      : []),
+    eventProbes: [{
+      year: 2023,
+      year_label: "2023 年前后",
+      domain: "career",
+      event_family: "入职、升职或职责明显加重",
+      source: "dasha_activation",
+      tracks: ["vimshottari", "narayana"],
+      tracks_agree: false,
+      unique_minute_claim: false,
+      user_meaning: "时间范围锁定 2023 年前后。",
+      role: "distinguish",
+      phase: "candidate_discriminator",
+      information_gain: 0.56,
+      semantic_key: "career.2023.dasha_activation",
+      candidate_split_hash: "500ce694938305201fbab9ba",
+      candidate_ids: ["04:45", "05:00", "05:14", "05:15"],
+      expected_outcomes: careerOutcomes,
+      style_options: [
+        { label: "明确发生且时间吻合", answer_class: "yes" },
+        { label: "发生过但程度较弱", answer_class: "weak_yes" },
+        { label: "明确没有发生", answer_class: "no" },
+        { label: "这段记不清楚", answer_class: "unsure" },
+      ],
+    }],
     contrastPacket: packet,
     candidatesSeparated: false,
   });
-  assert.match(plan.next_followup?.semantic_key ?? "", /^varga\.d24\./);
-  assert.doesNotMatch(plan.next_followup?.semantic_key ?? "", /career\.2023/);
+  assert.equal(plan.next_followup?.semantic_key, "career.2023.dasha_activation");
+  assert.match(plan.next_followup?.choice_frame?.period ?? "", /2023 年前后/);
+  assert.doesNotMatch(plan.next_followup?.semantic_key ?? "", /varga\.d24/);
 });
 
 test("career and relationship training still discriminates before family or occupation coverage", () => {
@@ -376,11 +381,41 @@ test("career and relationship training still discriminates before family or occu
     { id: "05:12", time: "05:12", cluster_range: ["05:12", "05:12"], prior_score: 17, posterior_score: 17, probability: 0.21, status: "active", rank: 3, strong_conflict_count: 0 },
   ];
   const evidence = [
+    { id: "edu-2016", status: "confirmed", domain: "education", datePrecision: "year", occurredFrom: "2016-01-01", occurredTo: null, eventKind: "education_milestone" },
     { id: "career-exit", status: "confirmed", domain: "career", datePrecision: "month", occurredFrom: "2020-10-01", occurredTo: null, eventKind: "career_exit" },
     { id: "career-entry", status: "confirmed", domain: "career", datePrecision: "month", occurredFrom: "2020-04-01", occurredTo: null, eventKind: "career_entry" },
     { id: "rel-start", status: "confirmed", domain: "relationship", datePrecision: "month", occurredFrom: "2024-05-01", occurredTo: null, eventKind: "relationship_start" },
     { id: "rel-end", status: "confirmed", domain: "relationship", datePrecision: "day", occurredFrom: "2024-08-08", occurredTo: null, eventKind: "relationship_end" },
   ];
+  const familyProbe = {
+    year: 2013,
+    year_label: "2013 年 3 月前后",
+    domain: "family",
+    event_family: "家人结婚、添丁或住院",
+    source: "dasha_boundary",
+    tracks: ["vimshottari", "narayana"],
+    tracks_agree: true,
+    unique_minute_claim: false,
+    user_meaning: "时间范围锁定 2013 年 3 月前后。",
+    role: "distinguish",
+    phase: "candidate_discriminator",
+    information_gain: 1.2,
+    semantic_key: "family.2013.03.dasha_boundary",
+    candidate_split_hash: "family.2013.03",
+    candidate_ids: ["05:00", "05:07", "05:12"],
+    expected_outcomes: [
+      { answer_class: "yes", supports: ["05:00"], conflicts: ["05:07", "05:12"] },
+      { answer_class: "weak_yes", supports: ["05:07"], conflicts: ["05:00", "05:12"] },
+      { answer_class: "no", supports: ["05:12"], conflicts: ["05:00", "05:07"] },
+      { answer_class: "unsure", supports: [], conflicts: [] },
+    ],
+    style_options: [
+      { label: "明确发生且时间吻合", answer_class: "yes" },
+      { label: "发生过但程度较弱", answer_class: "weak_yes" },
+      { label: "明确没有发生", answer_class: "no" },
+      { label: "这段记不清楚", answer_class: "unsure" },
+    ],
+  };
   const dossier = {
     evidence,
     conversationSummary: { activeFocus: null, declinedSkippedTopics: [] },
@@ -388,6 +423,7 @@ test("career and relationship training still discriminates before family or occu
       resultId: "result-unseparated",
       candidates: [],
       decisionReceipt: {
+        discriminating_event_probes: [familyProbe],
         inference_state: {
           algorithm_version: "rectification-inference-v1",
           candidate_set_id: "05:00-05:12:05:00,05:07,05:12",
@@ -398,6 +434,7 @@ test("career and relationship training still discriminates before family or occu
           range_end: "05:12",
           candidates: inferenceCandidates,
           events: [
+            { id: "edu-2016", year: 2016, usage: "training", domain: "education", precision: "year" },
             { id: "career-exit", year: 2020, usage: "training", domain: "career", precision: "month" },
             { id: "career-entry", year: 2020, usage: "holdout", domain: "career", precision: "month" },
             { id: "rel-start", year: 2024, usage: "training", domain: "relationship", precision: "month" },
@@ -440,12 +477,15 @@ test("career and relationship training still discriminates before family or occu
   const packet = contrastPacketFromDossier(dossier);
   const plan = buildMethodFollowupPlan({
     evidence,
+    eventProbes: [familyProbe],
     contrastPacket: packet,
     sessionOutcome: decision.sessionOutcome,
   });
   assert.equal(plan.next_followup?.intent, "distinguish_candidates");
-  assert.match(plan.next_followup?.semantic_key ?? "", /^varga\.d24/);
+  assert.equal(plan.next_followup?.semantic_key, "family.2013.03.dasha_boundary");
   assert.ok(plan.next_followup?.choice_frame);
+  assert.match(plan.next_followup?.choice_frame?.period ?? "", /2013 年 3 月前后/);
+  assert.doesNotMatch(plan.next_followup?.choice_frame?.prompt ?? "", /2016 年前后/);
   assert.equal(conversationalSessionOutcome({
     selectionAllowed: false,
     proposeAllowed: false,
diff --git a/frontend/tests/rectification-eight-method.test.ts b/frontend/tests/rectification-eight-method.test.ts
index bebbe575..3cb7d8c2 100644
--- a/frontend/tests/rectification-eight-method.test.ts
+++ b/frontend/tests/rectification-eight-method.test.ts
@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import test from "node:test";
 
-import { buildMethodFollowupPlan, buildNextUserAction, conversationalSessionOutcome, isOfferBlockingFollowup } from "../src/lib/rectification-agentic/v9/method-followup.ts";
+import { buildMethodFollowupPlan, buildNextUserAction, conversationalSessionOutcome, isOfferBlockingFollowup, spokenFollowupForUser } from "../src/lib/rectification-agentic/v9/method-followup.ts";
 import { trainingScoreableGate } from "../src/lib/rectification-agentic/v9/evidence-model.ts";
 import {
   askedKeysFromLedgerEvidence,
@@ -1741,20 +1741,25 @@ test("D9/D10 contrast after occupation coverage asks a discriminator, not adopt"
         { layer: "d10", signs: ["巨蟹", "狮子", "处女"] },
       ],
       probes: [{
-        probeId: "contrast:varga.d10.巨蟹|狮子|处女",
+        probeId: "contrast:varga.d10.05:00|05:01|05:02",
         candidateSetVersion: "05:00-05:02",
         question: "当前几个候选在事业盘上还分得开。请核对一段还没用进评分的职业前事。",
         expectedOutcomes: [
-          { outcomeId: "supports_巨蟹", supportsCandidateIds: ["巨蟹"], conflictsCandidateIds: ["狮子", "处女"] },
-          { outcomeId: "supports_狮子", supportsCandidateIds: ["狮子"], conflictsCandidateIds: ["巨蟹", "处女"] },
-          { outcomeId: "supports_处女", supportsCandidateIds: ["处女"], conflictsCandidateIds: ["巨蟹", "狮子"] },
+          { outcomeId: "yes", supportsCandidateIds: ["05:00"], conflictsCandidateIds: ["05:01", "05:02"] },
+          { outcomeId: "weak_yes", supportsCandidateIds: ["05:01"], conflictsCandidateIds: ["05:00", "05:02"] },
+          { outcomeId: "no", supportsCandidateIds: ["05:02"], conflictsCandidateIds: ["05:00", "05:01"] },
         ],
-        candidateSplitHash: "varga.d10.巨蟹|狮子|处女",
+        candidateSplitHash: "varga.d10.05:00|05:01|05:02",
         informationGain: 0.12,
         sourceFeatures: [{ technique: "D10", calculationResultId: RESULT_ID }],
         domain: "career",
         year: null,
-        semanticKey: "varga.d10.巨蟹|狮子|处女",
+        semanticKey: "varga.d10.05:00|05:01|05:02",
+        choiceKind: "varga_style",
+        styleOptions: [
+          { label: "做事偏领导推进", answerClass: "yes", sign: "白羊座" },
+          { label: "做事偏研究转化", answerClass: "weak_yes", sign: "天蝎座" },
+        ],
       }],
     },
   });
@@ -1789,7 +1794,7 @@ test("D9/D10 contrast after occupation coverage asks a discriminator, not adopt"
   }), "discriminate_candidates");
 });
 
-test("answered duty language skips window D10 and uses remaining D24", () => {
+test("answered duty language skips window D10 and collects a dated education event instead of a yearless D24 card", () => {
   const packet = {
     candidateSetVersion: "05:00-05:07",
     vargaDifferences: [
@@ -1829,11 +1834,13 @@ test("answered duty language skips window D10 and uses remaining D24", () => {
     contrastPacket: packet,
   });
   assert.equal(plan.next_followup?.domain, "education");
-  assert.equal(plan.next_followup?.semantic_key, "varga.d24.05:00/05:06|05:07");
+  assert.equal(plan.next_followup?.intent, "collect_method_evidence");
+  assert.equal(plan.next_followup?.choice_frame, null);
+  assert.match(plan.next_followup?.user_prompt_hint ?? "", /记得住年份/);
   assert.doesNotMatch(plan.next_followup?.semantic_key ?? "", /varga\.d10/);
 });
 
-test("low-gain career event probe does not outrank a renderable high-gain D24 contrast probe", () => {
+test("yearless D24 yields to a dated career dasha instead of borrowing the recorded education year", () => {
   const plan = buildMethodFollowupPlan({
     evidence: CLASSIC_COVERAGE.filter((item) => item.domain !== "horary"),
     eventProbes: [{
@@ -1866,15 +1873,183 @@ test("low-gain career event probe does not outrank a renderable high-gain D24 co
     },
     candidatesSeparated: false,
   });
-  assert.equal(plan.next_followup?.semantic_key, "varga.d24.05:00/05:07|05:10|05:14");
-  assert.equal(plan.next_followup?.choice_frame?.option_d_answer_class, "unsure");
-  assert.equal(plan.next_followup?.choice_frame?.period, "当前这几个候选");
-  assert.match(plan.next_followup?.choice_frame?.prompt ?? "", /学业|考试发挥|学习压力/);
-  assert.doesNotMatch(plan.next_followup?.choice_frame?.prompt ?? "", /入职、升职/);
-  assert.ok((plan.next_followup?.selection_score ?? 0) > 0.56);
+  assert.equal(plan.next_followup?.semantic_key, "career.2023.dasha_activation");
+  assert.equal(plan.next_followup?.choice_frame?.period, "2023 年前后");
+  assert.match(plan.next_followup?.choice_frame?.prompt ?? "", /2023 年前后，有没有/);
+  assert.doesNotMatch(plan.next_followup?.choice_frame?.prompt ?? "", /2016 年前后/);
+  assert.doesNotMatch(plan.next_followup?.semantic_key ?? "", /varga\.d24/);
 });
 
-test("already-open low-gain career card yields to the high-gain D24 catalog winner", () => {
+const YEARLESS_D12 = {
+  probeId: "contrast:varga.d12.05:00/05:07",
+  candidateSetVersion: "05:00-05:07",
+  question: "当前几个候选在六亲盘上还分得开。请核对一段还没用进评分的家人前事。",
+  expectedOutcomes: [
+    { outcomeId: "yes", supportsCandidateIds: ["05:00"], conflictsCandidateIds: ["05:07"] },
+    { outcomeId: "no", supportsCandidateIds: ["05:07"], conflictsCandidateIds: ["05:00"] },
+  ],
+  candidateSplitHash: "varga.d12.05:00/05:07",
+  informationGain: 3.5,
+  sourceFeatures: [{ technique: "D12", calculationResultId: RESULT_ID }],
+  domain: "family",
+  year: null,
+  semanticKey: "varga.d12.05:00/05:07",
+  choiceKind: "existence" as const,
+};
+
+test("yearless family contrast yields to a dated career discriminator", () => {
+  const plan = buildMethodFollowupPlan({
+    evidence: [
+      datedEvidence("education", "2016"),
+      datedEvidence("relationship", "2018"),
+      datedEvidence("relocation", "2014"),
+      datedEvidence("health_pressure", "2012"),
+      {
+        status: "confirmed" as const,
+        domain: "occupation",
+        datePrecision: "unknown" as const,
+        occurredFrom: null,
+        occurredTo: null,
+        eventKind: "occupation_note",
+      },
+    ],
+    eventProbes: [{
+      ...CAREER_CONFLICT_PROBE,
+      year: 2020,
+      year_label: "2020 年 4 月前后",
+      information_gain: 0.56,
+      semantic_key: "career.2020.dasha_activation",
+    }],
+    contrastPacket: {
+      candidateSetVersion: "05:00-05:07",
+      vargaDifferences: [],
+      probes: [YEARLESS_D12],
+    },
+    candidatesSeparated: false,
+  });
+  assert.notEqual(plan.next_followup?.domain, "family");
+  assert.equal(plan.next_followup?.choice_frame != null, true);
+  assert.match(plan.next_followup?.choice_frame?.period ?? "", /2020 年 4 月前后/);
+  assert.match(plan.next_followup?.choice_frame?.prompt ?? "", /2020 年 4 月前后，有没有/);
+  assert.doesNotMatch(plan.next_followup?.choice_frame?.prompt ?? "", /那段时间/);
+});
+
+test("yearless family contrast without a dated discriminator collects a dated family event", () => {
+  const plan = buildMethodFollowupPlan({
+    evidence: [
+      ...CLASSIC_COVERAGE.filter((item) => item.domain !== "horary" && item.domain !== "family"),
+      datedEvidence("relocation", "2014"),
+    ],
+    contrastPacket: {
+      candidateSetVersion: "05:00-05:07",
+      vargaDifferences: [],
+      probes: [YEARLESS_D12],
+    },
+    candidatesSeparated: false,
+  });
+  assert.equal(plan.next_followup?.intent, "collect_method_evidence");
+  assert.equal(plan.next_followup?.domain, "family");
+  assert.equal(plan.next_followup?.choice_frame, null);
+  assert.match(plan.next_followup?.user_prompt_hint ?? "", /记得住时间/);
+  assert.doesNotMatch(plan.next_followup?.user_prompt_hint ?? "", /A\/B\/C\/D/);
+});
+
+test("family collect attaches the collection-probe year instead of a yearless D24 card", () => {
+  const plan = buildMethodFollowupPlan({
+    evidence: [
+      datedEvidence("career", "2020"),
+      datedEvidence("career", "2024"),
+      datedEvidence("relationship", "2024"),
+      datedEvidence("career", "2026"),
+      datedEvidence("relationship", "2024", { datePrecision: "day" }),
+      datedEvidence("relationship", "2025", { datePrecision: "day" }),
+    ],
+    askedProbeKeys: ["relocation.2015.05.dasha_boundary"],
+    contrastPacket: {
+      candidateSetVersion: "05:00-05:14",
+      vargaDifferences: [],
+      probes: [{
+        probeId: "contrast:varga.d24.05:00/05:14",
+        candidateSetVersion: "05:00-05:14",
+        question: "引擎给出的区分机会绑定 D24。",
+        expectedOutcomes: [
+          { outcomeId: "yes", supportsCandidateIds: ["05:00"], conflictsCandidateIds: ["05:14"] },
+          { outcomeId: "no", supportsCandidateIds: ["05:14"], conflictsCandidateIds: ["05:00"] },
+        ],
+        candidateSplitHash: "varga.d24.05:00/05:14",
+        informationGain: 2.5,
+        sourceFeatures: [{ technique: "D24", calculationResultId: RESULT_ID }],
+        domain: "education",
+        year: null,
+        semanticKey: "varga.d24.05:00/05:14",
+      }],
+    },
+    evidenceCollectionProbes: [{
+      year: 2021,
+      year_label: "2021 年前后",
+      domain: "family",
+      event_family: "家人结婚、添丁或住院",
+      source: "age_band",
+      tracks: ["vimshottari", "narayana"],
+      tracks_agree: false,
+      unique_minute_claim: false,
+      user_meaning: "时间范围锁定 2021 年前后；领域锁定 family。",
+      role: "collect",
+      phase: "evidence_collection",
+      information_gain: 0,
+      semantic_key: "family.2021",
+    }],
+    candidatesSeparated: false,
+  });
+  assert.equal(plan.next_followup?.intent, "collect_method_evidence");
+  assert.equal(plan.next_followup?.domain, "family");
+  assert.equal(plan.next_followup?.choice_frame, null);
+  assert.equal(plan.next_followup?.probe_year, 2021);
+  assert.match(plan.next_followup?.year_label ?? "", /2021/);
+  assert.doesNotMatch(plan.next_followup?.semantic_key ?? "", /varga\.d24/);
+  assert.match(spokenFollowupForUser(plan.next_followup) ?? "", /2021 年前后，家里有没有/);
+});
+
+test("already-open yearless family card does not keep a scoring frame", () => {
+  const plan = buildMethodFollowupPlan({
+    evidence: [
+      ...CLASSIC_COVERAGE.filter((item) => item.domain !== "horary" && item.domain !== "family"),
+      datedEvidence("relocation", "2014"),
+    ],
+    contrastPacket: {
+      candidateSetVersion: "05:00-05:07",
+      vargaDifferences: [],
+      probes: [YEARLESS_D12],
+    },
+    candidatesSeparated: false,
+    activeFocus: {
+      intent: "distinguish_candidates",
+      targetDomain: "family",
+      targetKind: "family_event",
+      expectedAnswerSchema: {
+        semantic_key: "varga.d12.05:00/05:07",
+        choice: {
+          prompt: "那段时间，有没有家人相关的明显变化？",
+          option_a: "明确发生且时间吻合",
+          option_b: "发生过但程度较弱",
+          option_c: "明确没有发生",
+          option_d: "这段记不清楚",
+          options: DYNAMIC_STYLE_OPTIONS.map((option, index) => ({
+            key: (["A", "B", "C", "D"] as const)[index]!,
+            label: option.label,
+            answer_class: option.answer_class,
+          })),
+        },
+      },
+    },
+  });
+  assert.notEqual(plan.next_followup?.choice_frame?.prompt, "那段时间，有没有家人相关的明显变化？");
+  assert.equal(plan.next_followup?.choice_frame, null);
+  assert.equal(plan.next_followup?.intent, "collect_method_evidence");
+  assert.equal(plan.next_followup?.domain, "family");
+});
+
+test("already-open dated career card stays ahead of a yearless D24 catalog row", () => {
   const plan = buildMethodFollowupPlan({
     evidence: CLASSIC_COVERAGE.filter((item) => item.domain !== "horary"),
     eventProbes: [{
@@ -1916,8 +2091,8 @@ test("already-open low-gain career card yields to the high-gain D24 catalog winn
       },
     },
   });
-  assert.equal(plan.next_followup?.semantic_key, "varga.d24.05:00/05:07|05:10|05:14");
-  assert.doesNotMatch(plan.next_followup?.semantic_key ?? "", /career\.2023/);
+  assert.equal(plan.next_followup?.semantic_key, "career.2023.dasha_activation");
+  assert.doesNotMatch(plan.next_followup?.semantic_key ?? "", /varga\.d24/);
 });
 
 const DUMP_COVERAGE = [
@@ -2004,7 +2179,7 @@ const DUMP_SCORES = [
   { time: "05:04", score: 33 },
 ];
 
-test("coverage-complete tie with encoded D24/D10 asks remaining D4, not enrollment or breakup", () => {
+test("coverage-complete tie with encoded D24/D10 collects a dated move instead of a yearless D4 card", () => {
   const packet = buildCandidateContrastPacket({
     candidateSetVersion: "05:00-05:04",
     candidateTimes: DUMP_SCORES.map((item) => item.time),
@@ -2018,9 +2193,12 @@ test("coverage-complete tie with encoded D24/D10 asks remaining D4, not enrollme
   });
   assert.equal(plan.next_followup?.domain, "relocation");
   assert.equal(plan.next_followup?.kind_hint, "home_change");
-  assert.match(plan.next_followup?.semantic_key ?? "", /varga\.d4/);
+  assert.equal(plan.next_followup?.intent, "collect_method_evidence");
+  assert.equal(plan.next_followup?.choice_frame, null);
+  assert.match(plan.next_followup?.user_prompt_hint ?? "", /记得住时间的搬家/);
   assert.doesNotMatch(plan.next_followup?.kind_hint ?? "", /education_start|relationship_end/);
   assert.doesNotMatch(plan.next_followup?.user_prompt_hint ?? "", /大学哪年入学|高考是 \d{4}|哪年毕业/);
+  assert.doesNotMatch(plan.next_followup?.choice_frame?.prompt ?? "", /那段时间/);
   assert.equal(conversationalSessionOutcome({
     selectionAllowed: true,
     proposeAllowed: true,
@@ -2114,7 +2292,7 @@ test("structured paused state ends evidence collection without parsing user copy
 });
 
 
-test("covered-domain existence probes are skipped; the highest remaining discriminator wins", () => {
+test("same-year existence probes are skipped; a different-year dasha still ranks", () => {
   const evidence = [
     datedEvidence("education", "2016"),
     datedEvidence("relationship", "2018"),
@@ -2125,12 +2303,69 @@ test("covered-domain existence probes are skipped; the highest remaining discrim
     evidence,
     eventProbes: [{
       ...CAREER_CONFLICT_PROBE,
+      year: 2015,
+      year_label: "2015 年前后",
+      information_gain: 0.56,
+      semantic_key: "career.2015.dasha_activation",
+      candidate_split_hash: "set-test:career:2015",
+    }],
+  });
+  assert.notEqual(skipped.next_followup?.semantic_key, "career.2015.dasha_activation");
+
+  const dated = buildMethodFollowupPlan({
+    evidence,
+    eventProbes: [{
+      ...CAREER_CONFLICT_PROBE,
+      year: 2018,
+      year_label: "2018 年前后",
       information_gain: 0.56,
       semantic_key: "career.2018.dasha_activation",
     }],
   });
-  assert.notEqual(skipped.next_followup?.domain, "career");
-  assert.notEqual(skipped.next_followup?.source, "event_probe");
+  assert.equal(dated.next_followup?.semantic_key, "career.2018.dasha_activation");
+  assert.match(dated.next_followup?.choice_frame?.period ?? "", /2018 年前后/);
+
+  const childhood = buildMethodFollowupPlan({
+    evidence,
+    birthDate: "1997-08-08",
+    eventProbes: [{
+      ...CAREER_CONFLICT_PROBE,
+      year: 2012,
+      year_label: "2012 年 11 月前后",
+      information_gain: 1.3,
+      semantic_key: "career.2012.11.dasha_boundary",
+      candidate_split_hash: "set-test:career:2012",
+    }, {
+      ...CAREER_CONFLICT_PROBE,
+      year: 2019,
+      year_label: "2019 年前后",
+      information_gain: 0.4,
+      semantic_key: "career.2019.dasha_activation",
+      candidate_split_hash: "set-test:career:2019",
+    }],
+  });
+  assert.notEqual(childhood.next_followup?.semantic_key, "career.2012.11.dasha_boundary");
+  assert.equal(childhood.next_followup?.semantic_key, "career.2019.dasha_activation");
+
+  const adjacentRelationship = buildMethodFollowupPlan({
+    evidence: [
+      datedEvidence("education", "2016"),
+      datedEvidence("career", "2020"),
+      datedEvidence("relationship", "2024"),
+      datedEvidence("family", "2023"),
+    ],
+    eventProbes: [{
+      ...CAREER_CONFLICT_PROBE,
+      domain: "relationship",
+      event_family: "开始一段认真关系、分手或结婚",
+      year: 2023,
+      year_label: "2023 年 5 月前后",
+      information_gain: 0.9,
+      semantic_key: "relationship.2023.05.dasha_boundary",
+      candidate_split_hash: "set-test:relationship:2023",
+    }],
+  });
+  assert.notEqual(adjacentRelationship.next_followup?.semantic_key, "relationship.2023.05.dasha_boundary");
 
   const d24 = {
     probeId: "contrast:varga.d24.05:00|05:07|05:14",
@@ -2195,7 +2430,7 @@ test("covered-domain existence probes are skipped; the highest remaining discrim
     },
     candidatesSeparated: false,
   });
-  assert.equal(d24Wins.next_followup?.semantic_key, d24.semanticKey);
+  assert.equal(d24Wins.next_followup?.semantic_key, d10.semanticKey);
 });
 
 test("three dated events with one holdout keep collecting instead of discriminating", () => {
diff --git a/frontend/tests/rectification-server-focus.test.ts b/frontend/tests/rectification-server-focus.test.ts
index e606d183..3926bac0 100644
--- a/frontend/tests/rectification-server-focus.test.ts
+++ b/frontend/tests/rectification-server-focus.test.ts
@@ -209,7 +209,7 @@ test("complete dynamic event options persist a server-owned focus", async () =>
   assert.equal(result.status, "created");
   assert.equal(accounting.calls.length, 1);
   assert.deepEqual(result.focus?.expectedAnswerSchema.choice, {
-    prompt: "2016 年前后 · 升学结果或学习环境出现明显变化",
+    prompt: "2016 年前后，有没有升学结果或学习环境出现明显变化？",
     option_a: DYNAMIC_STYLE_OPTIONS[0].label,
     option_b: DYNAMIC_STYLE_OPTIONS[1].label,
     option_c: DYNAMIC_STYLE_OPTIONS[2].label,
diff --git a/frontend/tests/rectification-step-answer.test.ts b/frontend/tests/rectification-step-answer.test.ts
index 7c086bbe..3b9d5a52 100644
--- a/frontend/tests/rectification-step-answer.test.ts
+++ b/frontend/tests/rectification-step-answer.test.ts
@@ -28,9 +28,14 @@ test("does not publish intermediate tool-step text as answer.delta", () => {
     isPublicTool,
   );
   assert.equal(afterTool.kind, "discard");
-  applyStepAnswerChunk(state, chunk("text-delta", { text: "记下了，2020年4月开始实习。" }), isPublicTool);
+  const live = applyStepAnswerChunk(
+    state,
+    chunk("text-delta", { text: "记下了，2020年4月开始实习。" }),
+    isPublicTool,
+  );
+  assert.deepEqual(live, { kind: "live", text: "记下了，2020年4月开始实习。" });
   const finish = applyStepAnswerChunk(state, chunk("step-finish", { reason: "stop" }), isPublicTool);
-  assert.deepEqual(finish, { kind: "publish", pieces: ["记下了，2020年4月开始实习。"] });
+  assert.equal(finish.kind, "none");
 });
 
 test("never publishes reasoning-delta to the browser", () => {
@@ -47,7 +52,76 @@ test("publishes only the terminal no-tool step as assistant text", () => {
   applyStepAnswerChunk(state, chunk("step-finish", { stepResult: { reason: "tool-calls" } }), isPublicTool);
   assert.equal(shouldPublishStepText({ calledTool: true, text: "_probe" }, "tool-calls"), false);
   applyStepAnswerChunk(state, chunk("step-start"), isPublicTool);
-  applyStepAnswerChunk(state, chunk("text-delta", { text: "已经记下实习。" }), isPublicTool);
+  const live = applyStepAnswerChunk(state, chunk("text-delta", { text: "已经记下实习。" }), isPublicTool);
+  assert.deepEqual(live, { kind: "live", text: "已经记下实习。" });
   const finish = flushStepAnswerOnStreamFinish(state, "stop");
-  assert.deepEqual(finish, { kind: "publish", pieces: ["已经记下实习。"] });
+  assert.equal(finish.kind, "none");
+});
+
+test("streams terminal Chinese tokens live after compare", () => {
+  const state = createStepAnswerState();
+  applyStepAnswerChunk(
+    state,
+    chunk("tool-result", { toolName: "rectification-compare-candidates" }),
+    isPublicTool,
+  );
+  const first = applyStepAnswerChunk(state, chunk("text-delta", { text: "记下了，" }), isPublicTool);
+  const second = applyStepAnswerChunk(
+    state,
+    chunk("text-delta", { text: "2020年4月开始实习。" }),
+    isPublicTool,
+  );
+  assert.deepEqual(first, { kind: "live", text: "记下了，" });
+  assert.deepEqual(second, { kind: "live", text: "2020年4月开始实习。" });
+  assert.equal(applyStepAnswerChunk(state, chunk("step-finish", { reason: "stop" }), isPublicTool).kind, "none");
+});
+
+test("retracts a live spoken prefix if that step later calls a public tool", () => {
+  const state = createStepAnswerState();
+  applyStepAnswerChunk(
+    state,
+    chunk("tool-result", { toolName: "rectification-compare-candidates" }),
+    isPublicTool,
+  );
+  assert.deepEqual(
+    applyStepAnswerChunk(state, chunk("text-delta", { text: "记下了，" }), isPublicTool),
+    { kind: "live", text: "记下了，" },
+  );
+  const retracted = applyStepAnswerChunk(
+    state,
+    chunk("tool-call", { toolName: "rectification-read-diagnostics" }),
+    isPublicTool,
+  );
+  assert.equal(retracted.kind, "retract");
+  applyStepAnswerChunk(
+    state,
+    chunk("tool-result", { toolName: "rectification-read-diagnostics" }),
+    isPublicTool,
+  );
+  const spoken = applyStepAnswerChunk(
+    state,
+    chunk("text-delta", { text: "诊断已经看过。接下来确认入职年份。" }),
+    isPublicTool,
+  );
+  assert.deepEqual(spoken, { kind: "live", text: "诊断已经看过。接下来确认入职年份。" });
+});
+
+test("does not live-publish English planning before a tool-call", () => {
+  const state = createStepAnswerState();
+  assert.equal(
+    applyStepAnswerChunk(state, chunk("text-delta", { text: "Let me set" }), isPublicTool).kind,
+    "none",
+  );
+  assert.equal(
+    applyStepAnswerChunk(state, chunk("text-delta", { text: " _probe" }), isPublicTool).kind,
+    "none",
+  );
+  assert.equal(
+    applyStepAnswerChunk(
+      state,
+      chunk("tool-call", { toolName: "rectification-record-evidence-batch" }),
+      isPublicTool,
+    ).kind,
+    "none",
+  );
 });
diff --git a/frontend/tests/rectification-v9-stream.test.ts b/frontend/tests/rectification-v9-stream.test.ts
index e795769a..e7d7e9ad 100644
--- a/frontend/tests/rectification-v9-stream.test.ts
+++ b/frontend/tests/rectification-v9-stream.test.ts
@@ -205,6 +205,14 @@ test("streamToolNames exposes only allowlisted rectification tools", () => {
 
 test("safePublicEvent drops anything outside the allowlist", () => {
   assert.deepEqual(safePublicEvent({ type: "answer.delta", text: "你好" }), { type: "answer.delta", text: "你好" });
+  assert.deepEqual(
+    safePublicEvent({ type: "answer.delta", text: "你好", replace: true }),
+    { type: "answer.delta", text: "你好", replace: true },
+  );
+  assert.deepEqual(
+    safePublicEvent({ type: "answer.delta", text: "你好", replace: false }),
+    { type: "answer.delta", text: "你好" },
+  );
   assert.equal(safePublicEvent({ type: "thinking.delta", text: "先核对升学" }), null);
   assert.deepEqual(
     safePublicEvent({ type: "activity.changed", activity: "reading_case" }),
@@ -482,6 +490,8 @@ test("answer deltas stream in order and reasoning is never forwarded", async ()
       chunk("tool-result", { toolName: "skill" }),
       chunk("tool-call", { toolName: "rectification-read-case", args: { caseId: CASE_ID } }),
       chunk("tool-result", { toolName: "rectification-read-case" }),
+      chunk("tool-call", { toolName: "rectification-compare-candidates", args: { caseId: CASE_ID } }),
+      chunk("tool-result", { toolName: "rectification-compare-candidates" }),
       chunk("reasoning-start", { id: "r1" }),
       chunk("reasoning-delta", { text: "我应该先……" }),
       chunk("reasoning-end"),
@@ -495,8 +505,10 @@ test("answer deltas stream in order and reasoning is never forwarded", async ()
   assert.equal(result.ok, true);
   const deltas = emitted.filter((event) => event.type === "answer.delta");
   assert.deepEqual(deltas, [
-    { type: "answer.delta", text: "好的，先确认一下：" },
+    { type: "answer.delta", text: "好的，" },
+    { type: "answer.delta", text: "先确认一下：" },
   ]);
+  assert.equal(deltas.map((event) => event.text).join(""), "好的，先确认一下：");
   assert.deepEqual(
     emitted.filter((event) => event.type === "thinking.delta"),
     [],
@@ -671,6 +683,40 @@ test("a length-limited spoken answer is not billed or persisted as a completed t
   assert.equal(turnFinalize?.args.p_successful_attempt_id, null);
 });
 
+test("length after a stamped open_question still completes without failing the choice card", async () => {
+  const prompt = "2023 年 5 月前后，有没有认真关系进入、结束或关系观明显转变？";
+  const accounting = fakeAccounting({
+    ...receiptHandlers,
+    get_agentic_rectification_case_dossier: () => dossierFixture(),
+    append_agentic_rectification_turn: () => ({ turn_id: TURN_ID }),
+    finalize_agentic_rectification_turn: () => ({ turn_id: TURN_ID, status: "completed", idempotent: false }),
+  });
+  const { options, emitted, billing } = runOptions({
+    accounting: accounting.client,
+    buildAgent: async () => fakeAgentStream([
+      chunk("start"),
+      chunk("tool-call", { toolName: "skill", args: { name: RECTIFICATION_SKILL_NAME } }),
+      chunk("tool-result", { toolName: "skill" }),
+      chunk("tool-call", { toolName: "rectification-read-case", args: { caseId: CASE_ID } }),
+      chunk("tool-result", { toolName: "rectification-read-case" }),
+      chunk("tool-call", { toolName: "rectification-record-evidence-batch", args: { caseId: CASE_ID } }),
+      chunk("tool-result", {
+        toolName: "rectification-record-evidence-batch",
+        result: { accepted_count: 1, open_question: { prompt } },
+      }),
+      chunk("text-delta", { text: "实习和离职的时间点都记下了，谢谢。" }),
+      chunk("finish", { stepResult: { reason: "length" } }),
+    ]) as never,
+  });
+  const result = await runV9AgentTurn(options);
+  assert.equal(result.ok, true);
+  assert.equal(result.errorCode, null);
+  assert.equal(result.answerText, "接下来看下面这一问。");
+  assert.equal(emitted.some((event) => event.type === "run.failed"), false);
+  assert.equal(emitted.some((event) => event.type === "run.completed"), true);
+  assert.deepEqual(billing, { reserved: 1, completed: 1, released: 0 });
+});
+
 test("answer deltas and tool activity are published before billing settles", async () => {
   let billingStarted = false;
   const seenBeforeBilling: string[] = [];
@@ -1399,16 +1445,51 @@ test("timeout after a stamped open_question still completes without pasting the
   const result = await runV9AgentTurn(options);
   assert.equal(result.ok, true);
   assert.equal(result.errorCode, null);
-  assert.equal(result.answerText, "记下了。");
+  assert.equal(result.answerText, "接下来看下面这一问。");
   assert.doesNotMatch(result.answerText, /有没有/);
   assert.equal(emitted.some((event) => event.type === "run.failed"), false);
   assert.equal(emitted.some((event) => event.type === "run.completed"), true);
   assert.deepEqual(
     emitted.filter((event) => event.type === "answer.delta"),
-    [{ type: "answer.delta", text: "记下了。" }],
+    [{ type: "answer.delta", text: "接下来看下面这一问。" }],
   );
 });
 
+test("open_question acknowledgements stream live instead of waiting for flush", async () => {
+  const prompt = "2023 年前后 · 入职、升职或职责明显加重";
+  const { options, emitted } = runOptions({
+    buildAgent: async () => fakeAgentStream([
+      chunk("start"),
+      chunk("tool-call", { toolName: "skill", args: { name: RECTIFICATION_SKILL_NAME } }),
+      chunk("tool-result", { toolName: "skill" }),
+      chunk("tool-call", { toolName: "rectification-read-case", args: { caseId: CASE_ID } }),
+      chunk("tool-result", { toolName: "rectification-read-case" }),
+      chunk("tool-call", { toolName: "rectification-record-evidence-batch", args: { caseId: CASE_ID } }),
+      chunk("tool-result", {
+        toolName: "rectification-record-evidence-batch",
+        result: { accepted_count: 1, open_question: { prompt } },
+      }),
+      chunk("tool-call", { toolName: "rectification-compare-candidates", args: { caseId: CASE_ID } }),
+      chunk("tool-result", { toolName: "rectification-compare-candidates" }),
+      chunk("text-delta", { text: "好的，" }),
+      chunk("text-delta", { text: "毕业这条也记下了。" }),
+      chunk("text-delta", { text: "\n\n再问你一件：2016 年前后那场重要的入学考试有没有发生过？" }),
+      chunk("finish"),
+    ]) as never,
+  });
+  const result = await runV9AgentTurn(options);
+  assert.equal(result.ok, true);
+  assert.equal(result.answerText, "好的，毕业这条也记下了。");
+  assert.deepEqual(
+    emitted.filter((event) => event.type === "answer.delta"),
+    [
+      { type: "answer.delta", text: "好的，" },
+      { type: "answer.delta", text: "毕业这条也记下了。" },
+    ],
+  );
+  assert.doesNotMatch(JSON.stringify(emitted.filter((event) => event.type === "answer.delta")), /入学考试/);
+});
+
 test("persisted choice prompt replaces a competing model follow-up without a topic denylist", async () => {
   const spoken = "好的，2020 年 6 月毕业这条也记下了。\n\n再问你一件：2016 年前后那场重要的入学考试，你当时发挥明显失常、或者压力特别大，有没有发生过？";
   const prompt = "2023 年前后 · 入职、升职或职责明显加重";
@@ -1480,6 +1561,35 @@ test("persisted choice card owns a matching year-locked follow-up", async () =>
   );
 });
 
+test("structured-choice acknowledgements are not kept as a second assistant reply", () => {
+  const prompt = "2012 年 11 月前后，有没有入职、升职或职责明显加重？";
+  assert.equal(
+    bindSpokenToOpenQuestion("已记下你刚才的选择，候选比较也随之更新了。", prompt),
+    "",
+  );
+  assert.equal(
+    bindSpokenToOpenQuestion("已记录你的选择，并更新了候选比较。接下来这一问和家里有关，请看下方选项。", prompt),
+    "",
+  );
+  assert.equal(bindSpokenToOpenQuestion("记下了。", prompt), "记下了。");
+});
+
+test("choice-card acknowledgements do not repeat a different-domain event", () => {
+  const intern = "实习和离职的时间点都记下了，谢谢。";
+  assert.equal(
+    bindSpokenToOpenQuestion(intern, "2005 年 5 月前后，有没有搬家、离乡或长期异地？"),
+    "",
+  );
+  assert.equal(
+    bindSpokenToOpenQuestion(intern, "2023 年 5 月前后，有没有认真关系进入、结束或关系观明显转变？"),
+    "",
+  );
+  assert.equal(
+    bindSpokenToOpenQuestion("好，实习和离职都记下了。", "2023 年前后 · 入职、升职或职责明显加重"),
+    "好，实习和离职都记下了。",
+  );
+});
+
 test("lock-only prompt is not spliced into speech", () => {
   const lock = "2023 年前后 · 入职、升职或职责明显加重";
   assert.equal(bindSpokenToOpenQuestion("", lock), "");
diff --git a/scripts/rectification/event_probes.py b/scripts/rectification/event_probes.py
index 10e8c511..63789ca5 100644
--- a/scripts/rectification/event_probes.py
+++ b/scripts/rectification/event_probes.py
@@ -71,56 +71,56 @@ LAYER_VARGA = {
 }
 DOMAIN_CATALOG: dict[str, dict[str, Any]] = {
     "education": {
-        "event_family": "升学、高考、转学或学习环境变化",
-        "quality_family": "高考或重要考试发挥明显失常、压力很大",
+        "event_family": "升学、转学或换学习环境",
+        "quality_family": "学业或考试发挥失常、压力特别大",
         "kind": "education_milestone",
         "age_lo": 16,
         "age_hi": 18,
         "varga": "D5 / D24",
     },
     "relocation": {
-        "event_family": "搬家、离乡或长期异地",
-        "quality_family": "搬家、离乡或住宿结构明显变化",
+        "event_family": "搬家或长期住到外地",
+        "quality_family": "搬家或住处特别折腾",
         "kind": "home_change",
         "age_lo": 18,
         "age_hi": 24,
         "varga": "D4",
     },
     "relationship": {
-        "event_family": "认真关系进入、结束或关系观明显转变",
-        "quality_family": "认真关系进入、结束或关系观明显转变",
+        "event_family": "开始一段认真关系、分手或结婚",
+        "quality_family": "感情里压力特别大或相处明显变难",
         "kind": "relationship_change",
         "age_lo": 21,
         "age_hi": 26,
         "varga": "D9",
     },
     "career": {
-        "event_family": "入职、升职或职责明显加重",
-        "quality_family": "入职、升职或职责明显加重",
+        "event_family": "入职、换工作或职责加重",
+        "quality_family": "职责加重或工作压力特别大",
         "kind": "career_change",
         "age_lo": 22,
         "age_hi": 30,
         "varga": "D10",
     },
     "family": {
-        "event_family": "家人相关的明显变化",
-        "quality_family": "家人相关的明显变化",
+        "event_family": "家人结婚、添丁或住院",
+        "quality_family": "家人结婚、添丁、住院或家里特别操心",
         "kind": "family_event",
         "age_lo": 18,
         "age_hi": 30,
         "varga": "D12 / D7 / D3",
     },
     "finance": {
-        "event_family": "收入、资产或财务明显变化",
-        "quality_family": "收入、资产或财务明显变化",
+        "event_family": "收入明显变化、大笔支出或欠债",
+        "quality_family": "收入或财务压力特别大",
         "kind": "finance_change",
         "age_lo": 22,
         "age_hi": 32,
         "varga": "D2 / D11",
     },
     "health_pressure": {
-        "event_family": "健康、事故或持续压力明显变化",
-        "quality_family": "健康、事故或持续压力明显变化",
+        "event_family": "生病、受伤或压力特别大",
+        "quality_family": "生病、受伤或压力特别大",
         "kind": "self_health_event",
         "age_lo": 16,
         "age_hi": 40,
@@ -128,9 +128,12 @@ DOMAIN_CATALOG: dict[str, dict[str, Any]] = {
     },
 }
 
-# 入学年与高考通常同一学年或前后一年；存在性探针跳过邻近年，质量探针仍按精确年。
+# 入学年与高考通常同一学年或前后一年；感情/事业/搬家的邻近年也常是同一段经历。
 EXISTENCE_NEARBY_YEARS = {
     "education": 1,
+    "relationship": 1,
+    "career": 1,
+    "relocation": 1,
 }
 
 
@@ -171,6 +174,19 @@ def _year_label(year: int) -> str:
     return _period_label(year)
 
 
+# Family events (parents marrying, illness) can occur in childhood.
+_CHILDHOOD_OK_DOMAINS = frozenset({"family"})
+
+
+def _domain_year_floor(birth_year: int, domain: str, global_lo: int) -> int:
+    if domain in _CHILDHOOD_OK_DOMAINS:
+        return global_lo
+    catalog = DOMAIN_CATALOG.get(domain)
+    if not catalog:
+        return global_lo
+    return max(global_lo, birth_year + int(catalog["age_lo"]))
+
+
 def _age_band_year(birth_year: int, domain: str, today: date) -> int | None:
     catalog = DOMAIN_CATALOG.get(domain)
     if not catalog:
@@ -991,7 +1007,7 @@ def discriminating_event_probes(
             continue
         known_years = _event_years(events, domain)
         blocked_years = _existence_blocked_years(domain, known_years)
-        domain_lo = max(lo, birth_year + int(DOMAIN_CATALOG[domain]["age_lo"])) if domain == "relationship" else lo
+        domain_lo = _domain_year_floor(birth_year, domain, lo)
         boundary = [item for item in boundary_dates if domain_lo <= item.year <= hi]
         best = None
         for at in boundary:
diff --git a/tests/test_rectification_event_probes.py b/tests/test_rectification_event_probes.py
index 744517b4..1885b733 100644
--- a/tests/test_rectification_event_probes.py
+++ b/tests/test_rectification_event_probes.py
@@ -549,6 +549,96 @@ class EventProbesTest(unittest.TestCase):
         self.assertTrue(all(item["year"] >= 2018 for item in relationship))
         self.assertFalse(any(item["year"] in {2002, 2003} for item in relationship))
 
+    def test_career_and_relocation_boundaries_skip_childhood_years(self) -> None:
+        from unittest.mock import patch
+
+        from scripts.rectification import event_probes as probes_mod
+
+        built = {
+            "static_contexts": [
+                _context("05:13", d4_asc=0, sun_house=4, sun_varga_sign=3, d10_asc=1, moon=100.0),
+                _context("05:40", d4_asc=1, sun_house=10, sun_varga_sign=9, d10_asc=2, moon=101.0),
+            ]
+        }
+
+        def fake_vim(_birth_date: str, moon: float, _lo: int, _hi: int) -> list[date]:
+            early = [date(2005, 5, 15), date(2012, 11, 15), date(2019, 4, 15), date(2023, 5, 15)]
+            late = [date(2005, 11, 15), date(2012, 5, 15), date(2019, 10, 15), date(2023, 11, 15)]
+            return early if moon <= 100.0 else late
+
+        def fake_narayana(_asc: int, planets: dict, _birth_date: str, _lo: int, _hi: int) -> list[date]:
+            moon = float(planets.get("Moon") or 0)
+            return fake_vim(_birth_date, moon, _lo, _hi)
+
+        def fake_score(context: dict, *, birth_date: str, domain: str, year: int, month: int | None = None) -> dict:
+            del birth_date, domain, year, month
+            return {
+                "rule_ids": ["vim_md_domain_house"]
+                if probes_mod._context_time(context) == "05:13"
+                else ["no_domain_activation"]
+            }
+
+        with (
+            patch.object(probes_mod, "_vim_start_dates", side_effect=fake_vim),
+            patch.object(probes_mod, "_narayana_start_dates", side_effect=fake_narayana),
+            patch.object(probes_mod, "_score_year", side_effect=fake_score),
+        ):
+            probes = _probes(_request(), built, ["05:13", "05:40"], "05:13")
+
+        career = [item for item in probes if item["domain"] == "career"]
+        relocation = [item for item in probes if item["domain"] == "relocation"]
+        self.assertTrue(career)
+        self.assertTrue(all(item["year"] >= 2019 for item in career))
+        self.assertFalse(any(item["year"] in {2005, 2012} for item in career))
+        self.assertTrue(relocation)
+        self.assertTrue(all(item["year"] >= 2015 for item in relocation))
+        self.assertFalse(any(item["year"] == 2005 for item in relocation))
+
+    def test_recorded_relationship_skips_adjacent_existence_year(self) -> None:
+        from unittest.mock import patch
+
+        from scripts.rectification import event_probes as probes_mod
+
+        built = {
+            "static_contexts": [
+                _context("05:13", d4_asc=1, sun_house=4, sun_varga_sign=3, d9_asc=1, moon=100.0),
+                _context("05:40", d4_asc=1, sun_house=4, sun_varga_sign=3, d9_asc=2, moon=101.0),
+            ]
+        }
+        request = _request(events=_gate_events() + [{
+            "id": "00000000-0000-4000-8000-000000000021",
+            "domain": "relationship",
+            "event_kind": "relationship_start",
+            "summary": "相识",
+            "date": "2024-05-01",
+            "precision": "month",
+        }])
+
+        def fake_vim(_birth_date: str, moon: float, _lo: int, _hi: int) -> list[date]:
+            return [date(2023, 5, 15), date(2019, 3, 15)] if moon <= 100.0 else [date(2023, 11, 15), date(2018, 9, 15)]
+
+        def fake_narayana(_asc: int, planets: dict, _birth_date: str, _lo: int, _hi: int) -> list[date]:
+            moon = float(planets.get("Moon") or 0)
+            return fake_vim(_birth_date, moon, _lo, _hi)
+
+        def fake_score(context: dict, *, birth_date: str, domain: str, year: int, month: int | None = None) -> dict:
+            del birth_date, domain, month
+            return {
+                "rule_ids": ["vim_md_domain_house"]
+                if probes_mod._context_time(context) == "05:13" and year != 2024
+                else ["no_domain_activation"]
+            }
+
+        with (
+            patch.object(probes_mod, "_vim_start_dates", side_effect=fake_vim),
+            patch.object(probes_mod, "_narayana_start_dates", side_effect=fake_narayana),
+            patch.object(probes_mod, "_score_year", side_effect=fake_score),
+        ):
+            probes = _probes(request, built, ["05:13", "05:40"], "05:13")
+
+        relationship = [item for item in probes if item["domain"] == "relationship"]
+        self.assertFalse(any(item["year"] == 2023 for item in relationship))
+
 
 if __name__ == "__main__":
     unittest.main()