fix(rectification): ask remaining split lines one card at a time (BUG-661~663)

Dated-pool empty now yields existence cards per remaining layer, leftover-candidate copy, and an optional D9/D10 tie-break on the range card. Skill 10.0.25.

Co-authored-by: Cursor <cursoragent@cursor.com>

CHANGELOG.md

@@ -1,5 +1,10 @@
 # 印度占星 Skill 更新日志
 
+## 2026-09-13 — 定向补事改成逐条点选；范围提示说剩余候选；卡下可再答参考题
+
+生时校正里，带年月选择题问完、引擎也没有新题时，会一条一条问还能切开剩余候选的线：先问有没有（有 / 没有 / 记不清），说「有」再问大概哪年几月。说「没有」只记下这条线近年无事，不计分。提示写「现在还剩某段时间里 N 个候选」，不再写「能把两端钟点分开」。四条线都问完才给出目前范围。卡片下面可以再点「再答两道参考题微调排序」，不点不出。Skill 10.0.25。
+
+
 ## 2026-09-12 — 记下经历后设置下一问不再连失败；兜底「记下了」不再把日期写两遍
 
 记下两件事后，系统已经写下「还有吗」时，助手再设置同一问会直接沿用，不再连失败六次。工具失败会留下可诊断的原因码和打码后的原文，不再只显示笼统失败。模型没写出正文时，兜底「记下了」若经历描述里已有年月，不再把 `2016-09` 再拼一遍。Skill 版本不变。

docs/BUG_HISTORY.md

@@ -10276,3 +10276,51 @@
 - 相关记录：BUG-633、BUG-650、BUG-659
 - 复发自：无
 - 修复版本：待发布
+
+## BUG-661 | 定向补事必须逐条点选，不得一道口述堆所有剩余线
+
+- 状态：resolved
+- 首次发现：2026-09-13
+- 最近更新：2026-09-13
+- 影响面：`targetedCollectPool`、`targetedCollectFollowup`、`answer-choice.ts` 存在题分支、`persistExhaustionCollect`
+- 用户现象：六道带年月题答完、引擎刷新无新题后，落下一条口述题把结婚、收入、搬家、添丁全堆在一句里，没有可点的选项。
+- 触发条件：训练门已开、带年月池空、刷新 `no_new_probes`、仍有未覆盖的剩余换升层。
+- 根因：`targetedCollectFollowup` 把剩余层合成一道口述题；「没有」被当成整池结束，而不是只关掉当前那条线。
+- 修复：按剩余层一次出一张存在题卡（有过这件事 / 没有发生过 / 记不太清楚 / 这条先跳过，`scoring:false`）。A 再问「大概哪年几月？」；B 该线 declined；C/D skipped。年月答完走既有 batch 写证据并重算。所有剩余线问完才出「目前范围」。
+- 验证：`frontend/tests/rectification-targeted-collect-cards-20260913.test.ts`；`rectification-probe-pool-exhausted-20260911.test.ts` 第六题后 `choiceReady` 且题干为「结过婚或订过婚吗？」；四条都 B 才出范围卡。
+- 防复发：定向补事存在题必须是 `choice_frame` 且 `scoring:false`；不得把多条剩余线合成一道口述题。性格题不得因此回到计分池（BUG-629）。
+- 相关记录：BUG-654、BUG-656、BUG-662、BUG-663
+- 复发自：BUG-654（交付前定向补事做成了一道开放口述）
+- 修复版本：待发布
+
+## BUG-662 | 定向补事与范围提示不得写范围两端钟点
+
+- 状态：resolved
+- 首次发现：2026-09-13
+- 最近更新：2026-09-13
+- 影响面：`remainingCandidatesLine`、`rangeNarrowHint`、`agent-voice-copy-contract`
+- 用户现象：提示写成「能把 04:51 和 05:06 分开」，读起来像在比较范围两端，而不是还剩几个候选。
+- 触发条件：定向补事或「目前范围」卡下提示需要说明还能切开剩余候选的线。
+- 根因：`rangeNarrowHint` 用 split 两端钟点当主语。
+- 修复：改写为「现在还剩 HH:MM–HH:MM 里 N 个候选，能把它们分开的是这几条线：…」；保留「还能再收窄：如果记得…」。合同加禁词「能把 HH:MM 和 HH:MM 分开」。
+- 验证：`frontend/tests/agent-voice-copy-contract.test.ts`；`rectification-targeted-collect-cards-20260913.test.ts` 剩余候选句。
+- 防复发：用户可见文案不得出现「能把两端钟点分开」句式；剩余候选句不得当作存在题题干。
+- 相关记录：BUG-654、BUG-661
+- 复发自：BUG-654（定向补事举例时带上了范围端点）
+- 修复版本：待发布
+
+## BUG-663 | 「目前范围」卡下可点「再答两道参考题微调排序」
+
+- 状态：resolved
+- 首次发现：2026-09-13
+- 最近更新：2026-09-13
+- 影响面：`rectification-range-delivery.tsx`、`tieBreakPersonalityFollowup`、`POST /api/rectification/cases/[caseId]/tie-break`
+- 用户现象：带年月题和定向补事问完后，用户没有入口去答 D9/D10 参考题微调排序；若自动出性格题又会挡住结果。
+- 触发条件：已交付「目前范围」卡，候选仍分不开，用户想微调头名排序。
+- 根因：BUG-629 把性格题移出计分池后，没有产品入口可选择再答；自动出牌会挡住结果卡。
+- 修复：卡下可选按钮「再答两道参考题微调排序」。点了才走 `tie_break` 落 D9/D10 `varga_style`（±1、不淘汰、不改 `can_adopt`）。不点不出。
+- 验证：`frontend/tests/rectification-targeted-collect-cards-20260913.test.ts` 不点不出；入口文案进 `listUserVisibleCopy()`。
+- 防复发：性格题不得在定向补事之前或未点入口时成为下一问；`SCORE_DELTA` 与淘汰阈值不得被这条路径改掉。
+- 相关记录：BUG-629、BUG-651、BUG-661
+- 复发自：BUG-629（性格题降权后没有可选入口）
+- 修复版本：待发布

docs/history/progress.md

@@ -1124,3 +1124,11 @@
   - 合计 **2427 ≥ 2424**。
 - 实测：无登录态，未做浏览器里断网保存、云端删除后刷新、双 profile 置顶一致性、localStorage 键审计。由合同测试覆盖。浅色/深色：新文案「保存失败，请重试」「未能存入历史」「星盘库暂时无法读取，请重试。」走既有 sonner，`失败`/`未能`/`无法` 命中 `failedNotice` 用 error 语气，颜色仍是 `--color-canvas` / `--color-ink`。
 - 未提交、未推送。
+## 2026-09-13 - TASK-rectification-targeted-collect-cards：定向补事逐条点选
+
+- 带年月池空且刷新无新题后，定向补事改为一次一条存在题卡（有 / 没有 / 记不清 / 先跳过，不计分）；答「有」再口述年月。
+- 提示写「现在还剩 HH:MM–HH:MM 里 N 个候选」，禁止「能把两端钟点分开」。全部线问完才出「目前范围」。
+- 「目前范围」卡下可选「再答两道参考题微调排序」，点了才出 D9/D10 `tie_break`。
+- Skill 10.0.24 → 10.0.25；旧包哈希 `f4267cb93b459a84ec0006b51501b174d5bbc809b571168307affbaede22e4e7` 保持 deprecated。
+- BUG-661 / BUG-662 / BUG-663。未 commit。
+- 本机：`tsc --noEmit` 0 错；`lint` 0 error；`next build --webpack` 后 `/` 仍 Static；定向补事与主链 TAP fail=0；数据库套件单独 7/7。未做登录态场景 0d。

docs/tasks/PROGRESS-rectification-targeted-collect-cards-20260913.md

@@ -0,0 +1,39 @@
+# 进度 · 定向补事改成逐条点选卡 + 文案 + 参考题入口（2026-09-13）
+
+## 范围
+
+- 分支：`codex/rectification-targeted-collect-cards-20260913`（快进含 `origin/staging` @ `b063c668` 研究测量；未混入 R3/R4 引擎放宽）
+- 任务单：`docs/tasks/TASK-rectification-targeted-collect-cards-20260913.md`
+- 产品决策：A + D，顺带 C；B 不混入（研究单另走）
+- BUG-661：定向补事一次一条存在题卡
+- BUG-662：文案写剩余范围 + 候选个数，禁「能把两端钟点分开」
+- BUG-663：范围卡下「再答两道参考题微调排序」
+- Skill 10.0.24 → 10.0.25
+- 不改 `SCORE_DELTA`、`MIN_ACCEPTANCE_*`、确认门；性格题不得回计分池
+
+## 完成
+
+- T1 按剩余换升层出存在题卡；A 口述年月，B declined，C/D skipped；全部问完出「目前范围」
+- T2 `remainingCandidatesLine` / `rangeNarrowHint`；合同加 `SPLIT_ENDPOINT_PHRASE`
+- T3 范围卡入口走独立 `tie-break` 路由，落 D9/D10 `varga_style` `tie_break`；`tie_break_available` 读 `parseWindowScan` 或原始 `d9/d10_candidates_differ`（不把 planner 打进客户端包）
+- T4 Skill 10.0.25、registry（10.0.24 哈希 `f4267cb93b459a84…e4e7` 不变）、BUG-661～663、CHANGELOG、场景 0d
+- 为让 `next build` typecheck 通过，GET 快照投影从 `cases/[caseId]/route.ts` 挪到 `case-dossier-response.ts`（Next App Router 不允许 route 导出非 HTTP handler）
+
+## 验收（本机，未部署）
+
+- `./node_modules/.bin/tsc --noEmit`：0 错
+- `npm run lint`：0 error（120 warning，既有）
+- `next build --webpack`：编译 + TypeScript 通过；路由表 `┌ ○ /`（Static）；新增 `ƒ /api/rectification/cases/[caseId]/tie-break`
+- TAP（fail=0）：
+  - 源切片 / 入口 / 定向补事：131
+  - Skill / 合同 / 采集主链：271
+  - 范围卡 / 门 / 交付：79（随后范围卡入口测 +1，该文件现 12 条全过）
+  - `rectification-v9-database.test.ts` 单独：7/7（与 webpack 并行时曾出现 migration status=1 竞态）
+- Skill 10.0.25 哈希 `263ab00d5a62ee38dde1e13474b50a5e194e412b742d1693acaa9974db9f02e8`；10.0.24 仍可 exact-resolve
+- 未做登录态真机场景 0d（无本地会话）
+
+## 未做
+
+- 未 commit / 未 push
+- 未把研究单 B 的 R3/R4 引擎放宽混进本分支；测量结论是定向补事仍要保留
+- 已快进含 `b063c668`

docs/tasks/README.md

@@ -176,8 +176,9 @@
 | `TASK-rectification-targeted-collect-persist-fix-20260911.md` | `PROGRESS-rectification-targeted-collect-persist-fix-20260911.md` | 修复单：BUG-656 采集焦点 kind 映射到 CHECK 枚举；BUG-657 引擎刷新按 `column_times` 取剩余候选；BUG-658 刷新尝试持久化 + 等待收窄以已问过判定（512be9b7 让无新题时 GET 永远等待且每轮重调引擎） | 已实现 `eae049d0` + `529fcc09`，已部署；静态验收通过，真机六题流程待走 | `codex/rectification-targeted-collect-persist-fix-20260911` |
 | `TASK-rectification-set-focus-tool-failed-20260912.md` | `PROGRESS-rectification-set-focus-tool-failed-20260912.md` | 09-12 真机：记完两件学业后 `rectification-set-focus` 连续六次 `tool_failed`（兜底码，原始错误无处记录；焦点其实已由 batch 工具落下）、宿主兜底正文日期重复（BUG-659/660） | 待验收 | `codex/rectification-set-focus-tool-failed-20260912` |
 | `TASK-rectification-after-pool-empty-decision-20260913.md` | — | 决策单草案：六道带年月题问完、引擎刷新无新题后，定向补事是开放式口述题，体感死板。给出 A 逐条点选 / B 放宽引擎出题（先离线量收益）/ C 参考题可选入口 / D 文案 四个方案，建议 A+D(+C) | 已拍板 2026-09-13：A+D+C 进 `TASK-rectification-targeted-collect-cards-20260913.md`，B 进研究单 | — |
-| `TASK-rectification-targeted-collect-cards-20260913.md` | `PROGRESS-rectification-targeted-collect-cards-20260913.md` | 定向补事改逐条点选卡（有/没有/记不清 → 有则口述年月；没有不计分只防复问；全没有出卡）+ 文案说清剩余候选与线 + 卡下「再答两道参考题」入口（BUG-661～663，Skill 10.0.25） | 待执行 | `codex/rectification-targeted-collect-cards-20260913` |
-| `TASK-rectification-probe-supply-research-20260913.md` | — | 研究单：六题后引擎在剩余候选上再出带年月题的四种放宽规则，20 例公开 AA 数据离线量收益，有收益才立实现单 | 待执行（离线，不改线上） | `codex/rectification-probe-supply-research-20260913` |
+| `TASK-rectification-targeted-collect-cards-20260913.md` | `PROGRESS-rectification-targeted-collect-cards-20260913.md` | 定向补事改逐条点选卡（有/没有/记不清 → 有则口述年月；没有不计分只防复问；全没有出卡）+ 文案说清剩余候选与线 + 卡下「再答两道参考题」入口（BUG-661～663，Skill 10.0.25） | 待验收 | `codex/rectification-targeted-collect-cards-20260913` |
+| `TASK-rectification-probe-supply-research-20260913.md` | — | 研究单：六题后引擎在剩余候选上再出带年月题的四种放宽规则，20 例公开 AA 数据离线量收益，有收益才立实现单 | 已合入（离线测量，不改线上） | `b063c668` |
+| `TASK-rectification-refresh-r3-r4-20260913.md` | — | 刷新阶段 R3（MIN_BOUNDARY_DAYS 45→30）+ R4（pratyantar 与 D9/D10 上升 Narayana）；首轮出题不变。即使放宽仍有 0 题例子，定向补事另线保留（BUG-664/665） | 待领取 | — |
 
 ## 命名与归档
 

docs/testing/rectification-scenarios-20260907.md

@@ -27,7 +27,7 @@
 
 期望：
 
-- 第六题答完不得直接出卡；先出现新的带年月题（家人 / 财务 / 迁居等换运边界），或一条定向补事口述题
+- 第六题答完不得直接出卡；先出现新的带年月题（家人 / 财务 / 迁居等换运边界），或一张定向补事点选卡（先问有没有）
 - 刷新后若引擎给出新的带年月题，下一张卡必须真正出现；不得只是决策选中了探针、落库被拒后停在「没有拿到下一个问题」
 - 答一件家人事后应重算并回到带年月题；答「没有了 / 就这些」后才出卡
 - 卡片标题为「目前范围 …（对照了 N 件经历）」，卡下有「还能再收窄：如果记得 …」
@@ -41,13 +41,27 @@
 
 期望：
 
-- 第六题答完必须看到定向补事口述题（例如「还有 N 条线能把两端分开」）；题干种类必须能写入焦点表，不得静默失败
+- 第六题答完必须看到定向补事点选卡（例如「结过婚或订过婚吗？」）；旁白写剩余范围和候选个数，不得写「能把两端钟点分开」；题干种类必须能写入焦点表，不得静默失败
 - 引擎若没有新的带年月题，界面走定向补事或已有载体；同一候选集、同一已答数下引擎刷新只调用一次，不得反复打约 20 秒的刷新
 - 引擎若有新题，下一问必须出现；不得「GET 已有探针、界面没有下一问」
 - 刷新不得把候选集改空或换成另一套 `candidate_set_id`
 - 说「没有了」后看到「目前范围」卡；定向题若写不进库，同一轮也必须出这张卡
 - 全程不出现「没有拿到下一个问题」
 
+## 0d. 定向补事逐条点选；范围卡下可再答参考题
+
+同一条虚构序列走到第六题之后。
+
+期望：
+
+- 第一张定向卡题干是「结过婚或订过婚吗？」；选项是有 / 没有 / 记不清 / 先跳过，不计分
+- 点「没有」后出现下一条线的存在题，不得停在「没有拿到下一个问题」
+- 点「有」后口述追问「大概哪年几月？」；答一个虚构年月后账本多一条对应领域经历，并重算出新的带年月题或范围变化
+- 题干与卡下提示写「现在还剩 HH:MM–HH:MM 里 N 个候选」，不得写「能把 04:51 和 05:06 分开」这类两端钟点
+- 四条线都点「没有」后出「目前范围」卡；卡下有「还能再收窄」
+- 不点「再答两道参考题微调排序」时不得出现 D9/D10 性格对照卡
+- 点了该入口后才出现性格对照卡；答完后头名可变，但 `can_adopt` 不变、没有淘汰
+- 全程不出现「这次给出」「最终」
 
 ## 1. 范围：家人说两点到四点
 

frontend/src/app/api/rectification/cases/[caseId]/repair-exit/route.ts

@@ -11,7 +11,7 @@ import {
   listV10ConversationFocuses,
 } from "@/lib/rectification-agentic/v9/tool-service";
 import { ensureNonTerminalTurnExit } from "@/lib/rectification-agentic/v9/answer-choice";
-import { dossierResponse } from "../route";
+import { dossierResponse } from "@/lib/rectification-agentic/v9/case-dossier-response";
 
 export const runtime = "nodejs";
 

frontend/src/app/api/rectification/cases/[caseId]/route.ts

@@ -4,26 +4,13 @@ import { jsonForSupabaseSetupFailure } from "@/lib/api/service-unavailable";
 import { createAdminSupabaseClient } from "@/lib/supabase/admin";
 import { createServerSupabaseClient } from "@/lib/supabase/server";
 import {
-  evidenceLedgerFingerprint,
   loadV9CaseDossier,
   loadV9CaseSkillIdentityStatus,
   loadV9TurnReceipt,
-  receiptStatusFromTurn,
   RectificationToolServiceError,
   listV10ConversationFocuses,
-  questionSourceFromFocusList,
-  type ConversationFocusList,
-  type V9CaseDossier,
 } from "@/lib/rectification-agentic/v9/tool-service";
-import { choiceCardFromCaseDossier, decideFromDossier, overlayPublicDecision, nextUserActionFromDossier, stepStateFromCaseDossier } from "@/lib/rectification-agentic/v9/interview-state";
-import { projectCurrentQuestion } from "@/lib/rectification-agentic/v9/turn-decision";
-import { attachQuestionsToTurns, attachOfferResultToTurns } from "@/lib/rectification-agentic/v9/turn-question";
-import { previousInferenceFromReceipt } from "@/lib/rectification-agentic/v9/inference-adapter";
-import { publicDecisionFields } from "@/lib/rectification-agentic/core/rectification-decision";
-import { collectionProgressFromReceipt } from "@/lib/rectification-agentic/v9/evidence-model";
-import { slimDecisionReceipt } from "@/lib/rectification-agentic/v9/case-receipt-projection";
-import { rangeDeliveryForSnapshot } from "@/lib/rectification-agentic/v9/divergence-panel";
-import { latestResultToolProjection } from "@/mastra/rectification-v9-tools";
+import { dossierResponse } from "@/lib/rectification-agentic/v9/case-dossier-response";
 
 export const runtime = "nodejs";
 
@@ -92,132 +79,3 @@ export async function GET(request: Request, context: RouteContext) {
     );
   }
 }
-
-export function dossierResponse(
-  dossier: V9CaseDossier,
-  receipts: Array<Awaited<ReturnType<typeof loadV9TurnReceipt>>>,
-  skillIdentity: Awaited<ReturnType<typeof loadV9CaseSkillIdentityStatus>>,
-  options: { fullDetail?: boolean; listed?: ConversationFocusList } = {},
-) {
-  const decision = decideFromDossier(dossier, {
-    currentEvidenceFingerprint: evidenceLedgerFingerprint(dossier.evidence),
-  });
-  const listed = options.listed ?? { focuses: [] as const, available: true };
-  const turnsWithQuestions = attachQuestionsToTurns(dossier.turns, listed.focuses);
-  const fields = publicDecisionFields(decision);
-  const overlaid = dossier.latestResult
-    ? overlayPublicDecision(dossier.latestResult, decision)
-    : fields;
-  const turns = attachOfferResultToTurns(turnsWithQuestions, {
-    resultId: dossier.latestResult?.resultId ?? null,
-    canAdopt: overlaid.can_adopt === true,
-    acceptedTime: dossier.case.acceptedTime,
-  });
-  return {
-    case: {
-      case_id: dossier.case.caseId,
-      session_id: dossier.case.sessionId,
-      status: dossier.case.status,
-      skill_name: dossier.case.skillName,
-      skill_version: dossier.case.skillVersion,
-      skill_identity_status: skillIdentity.status,
-      requires_skill_adoption: skillIdentity.requiresSkillAdoption,
-      candidate_range: dossier.case.candidateRange,
-      stage: dossier.case.stage,
-      accepted_time: dossier.case.acceptedTime,
-      confirmed_time: dossier.case.confirmedTime,
-      completed_at: dossier.case.completedAt,
-      closed_reason: dossier.case.closedReason,
-      last_activity_at: dossier.case.lastActivityAt,
-      case_revision: previousInferenceFromReceipt(dossier.latestResult?.decisionReceipt ?? null)?.revision ?? 0,
-    },
-    turns: turns.map((turn) => ({
-      id: turn.id,
-      role: turn.role,
-      text: turn.text,
-      status: turn.status,
-      created_at: turn.createdAt,
-      receipt: turnReceipt(turn.id, receipts),
-      question: turn.question,
-      offer_result_id: turn.offer_result_id,
-    })),
-    evidence: dossier.evidence,
-    latest_result: dossier.case.stage === "block_scan" || decision.sessionOutcome === "compare_blocks"
-      ? null
-      : dossier.latestResult
-      ? publicLatestResult(dossier.latestResult, decision, dossier, options.fullDetail === true)
-      : null,
-    interview: {
-      ...fields,
-      collection_progress: collectionProgressFromReceipt(dossier.latestResult?.decisionReceipt ?? null),
-    },
-    current_question: projectCurrentQuestion(dossier.conversationSummary.activeFocus),
-    choice_card: choiceCardFromCaseDossier(dossier),
-    step_state: stepStateFromCaseDossier(dossier),
-    next_user_action: nextUserActionFromDossier(dossier),
-    question_source: questionSourceFromFocusList(listed),
-  };
-}
-
-function publicLatestResult(
-  latest: V9CaseDossier["latestResult"],
-  decision: ReturnType<typeof decideFromDossier>,
-  dossier: V9CaseDossier,
-  fullDetail: boolean,
-) {
-  if (!latest) return null;
-  const projected = overlayPublicDecision(latest, decision);
-  const toolProjection = latestResultToolProjection(latest, decision);
-  const rangeDelivery = rangeDeliveryForSnapshot({
-    decisionReceipt: projected.decisionReceipt,
-    candidates: projected.candidates,
-    representativeTime: projected.representativeTime ?? decision.representativeTime,
-    representative_time: projected.representativeTime ?? decision.representativeTime,
-    credibleRange: projected.credible_range ?? decision.credibleRange,
-    credible_range: projected.credible_range ?? decision.credibleRange,
-    skill_verification_report: toolProjection.skill_verification_report,
-    evidence: dossier.evidence,
-    declinedTopics: dossier.conversationSummary.declinedSkippedTopics,
-  });
-  const withDelivery = {
-    ...projected,
-    range_delivery: rangeDelivery,
-    rangeDelivery,
-  };
-  if (fullDetail || !projected.decisionReceipt) return withDelivery;
-  return {
-    ...withDelivery,
-    decisionReceipt: slimDecisionReceipt(projected.decisionReceipt, dossier),
-  };
-}
-
-function turnReceipt(
-  turnId: string,
-  receipts: Array<Awaited<ReturnType<typeof loadV9TurnReceipt>>>,
-) {
-  const receipt = receipts.find((item) => item?.turnId === turnId) ?? null;
-  if (!receipt) return null;
-  return {
-    turn_id: receipt.turnId,
-    skill_name: receipt.skillName,
-    skill_version: receipt.skillVersion,
-    engine_version: receipt.engineVersion,
-    status: receiptStatusFromTurn(receipt.status),
-    phases: receipt.phases.map((phase) => phase.phase),
-    tool_activities: receipt.toolActivities.map((activity) => ({
-      tool: activity.tool,
-      status: activity.status,
-      methods: activity.methods,
-      started_at: activity.startedAt ?? null,
-      elapsed_ms: activity.elapsedMs ?? null,
-      detail: activity.detail ?? null,
-    })),
-    tools: receipt.tools,
-    methods: receipt.methods,
-    started_at: receipt.startedAt,
-    completed_at: receipt.completedAt,
-    ...(receipt.phases.some((phase) => phase.phase === "answer.host_fallback")
-      ? { answer_origin: "host_fallback" as const }
-      : {}),
-  };
-}

frontend/src/app/api/rectification/cases/[caseId]/tie-break/route.ts

@@ -0,0 +1,108 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { jsonForSupabaseSetupFailure } from "@/lib/api/service-unavailable";
+import { createAdminSupabaseClient } from "@/lib/supabase/admin";
+import { isProductEnabled } from "@/lib/product-access";
+import { createServerSupabaseClient } from "@/lib/supabase/server";
+import { RectificationToolServiceError } from "@/lib/rectification-agentic/v9/tool-service";
+
+export const runtime = "nodejs";
+
+type RouteContext = { params: Promise<{ caseId: string }> };
+
+const tieBreakSchema = z.object({
+  sessionId: z.string().uuid(),
+  requestId: z.string().uuid(),
+}).strict();
+
+/**
+ * POST /api/rectification/cases/[caseId]/tie-break
+ *
+ * Opt-in D9/D10 personality cards from the range card (BUG-663).
+ * Scoring stays on the existing tie_break path; this route only persists
+ * the next varga_style focus.
+ */
+export async function POST(request: Request, context: RouteContext) {
+  let supabase;
+  let accounting;
+  try {
+    supabase = await createServerSupabaseClient();
+    accounting = createAdminSupabaseClient();
+  } catch (error) {
+    return jsonForSupabaseSetupFailure(error, "POST /api/rectification/cases/[caseId]/tie-break");
+  }
+  const {
+    data: { user },
+    error: authError,
+  } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return NextResponse.json({ error: "请先登录" }, { status: 401 });
+  }
+
+  if (!await isProductEnabled("rectification")) {
+    return NextResponse.json(
+      { error: "生时校正服务暂未开放", code: "rectification_product_disabled" },
+      { status: 503 },
+    );
+  }
+
+  const { caseId } = await context.params;
+  if (!z.string().uuid().safeParse(caseId).success) {
+    return NextResponse.json({ error: "请求内容不正确", code: "invalid_case_id" }, { status: 400 });
+  }
+  const parsed = tieBreakSchema.safeParse(await request.json().catch(() => null));
+  if (!parsed.success) {
+    return NextResponse.json({ error: "请求内容不正确", code: "invalid_tie_break_request" }, { status: 400 });
+  }
+
+  const { data: caseRow, error: caseError } = await accounting.rpc(
+    "get_agentic_rectification_case",
+    { p_user_id: user.id, p_case_id: caseId },
+  );
+  if (caseError) {
+    const message = caseError.message ?? "";
+    if (message.includes("agentic_rectification_case_not_found")) {
+      return NextResponse.json({ error: "校正记录不存在或无权访问", code: "case_not_found" }, { status: 404 });
+    }
+    return NextResponse.json({ error: "暂时无法开始参考题", code: "tie_break_failed" }, { status: 503 });
+  }
+  const caseView = Array.isArray(caseRow) ? caseRow[0] : caseRow;
+  const boundSessionId = caseView && typeof caseView === "object"
+    ? (caseView as { session_id?: unknown }).session_id
+    : null;
+  if (typeof boundSessionId !== "string" || boundSessionId !== parsed.data.sessionId) {
+    return NextResponse.json({ error: "校正记录与会话绑定不一致", code: "case_session_mismatch" }, { status: 409 });
+  }
+
+  try {
+    const { requestTieBreakPersonality } = await import(
+      "@/lib/rectification-agentic/v9/answer-choice"
+    );
+    const result = await requestTieBreakPersonality({
+      accounting,
+      userId: user.id,
+      caseId,
+      requestId: parsed.data.requestId,
+    });
+    if (!result.choiceReady) {
+      return NextResponse.json(
+        { error: "现在没有可答的参考题", code: "tie_break_unavailable", ok: false },
+        { status: 409 },
+      );
+    }
+    return NextResponse.json({
+      ok: true,
+      choiceReady: true,
+      hostNarration: result.hostNarration,
+      focusId: result.focus?.id ?? null,
+    });
+  } catch (error) {
+    if (error instanceof RectificationToolServiceError) {
+      return NextResponse.json(
+        { error: "暂时无法开始参考题", code: error.code },
+        { status: 409 },
+      );
+    }
+    return NextResponse.json({ error: "暂时无法开始参考题", code: "tie_break_failed" }, { status: 503 });
+  }
+}

frontend/src/app/globals.css

@@ -3372,6 +3372,24 @@ input:not([type="radio"]):not([type="checkbox"]):not([class^="ant-"]):not([class
 .rectification-range-delivery__accept:disabled {
   cursor: default;
 }
+.rectification-range-delivery__tie-break {
+  justify-self: start;
+  min-height: 44px;
+  padding: 0 12px;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-lg);
+  color: var(--color-ink-secondary);
+  background: var(--color-canvas);
+  font: inherit;
+  cursor: pointer;
+}
+.rectification-range-delivery__tie-break:focus-visible {
+  outline: 2px solid var(--color-focus);
+  outline-offset: 2px;
+}
+.rectification-range-delivery__tie-break:disabled {
+  cursor: default;
+}
 .rectification-range-delivery__boundary {
   margin: 0;
   color: var(--color-ink-secondary);

frontend/src/components/rectification-agentic-chat.tsx

@@ -1368,6 +1368,35 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
     }
   }, [acceptingCandidateId, beginLiveRun, busy, candidateResult, caseId, loadCaseSnapshot, onCompleted, onSaved, readonly, send, sessionId, setPending]);
 
+  const requestTieBreak = useCallback(async () => {
+    if (!candidateResult || acceptingCandidateId || busy || readonly) return;
+    if (!candidateResult.rangeDelivery?.tie_break_available) return;
+    setError("");
+    setPending(true);
+    try {
+      const response = await fetch(
+        `/api/rectification/cases/${encodeURIComponent(caseId)}/tie-break`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            sessionId,
+            requestId: globalThis.crypto.randomUUID(),
+          }),
+        },
+      );
+      const payload = await response.json().catch(() => null);
+      if (!response.ok || payload?.ok !== true) {
+        throw new Error(payload?.error || payload?.message || "暂时无法开始参考题");
+      }
+      await loadCaseSnapshot();
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : "暂时无法开始参考题");
+    } finally {
+      setPending(false);
+    }
+  }, [acceptingCandidateId, busy, candidateResult, caseId, loadCaseSnapshot, readonly, sessionId, setPending]);
+
   async function copyMessage(message: RenderMessage) {
     try {
       await navigator.clipboard.writeText(copyTextForMessage(message.text, message.question));
@@ -1795,6 +1824,7 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
                       acceptingCandidateId={acceptingCandidateId}
                       readonly={readonly || regeneratingMessageKey !== null || (busy && !acceptingCandidateId)}
                       onAccept={(candidateId) => void acceptCandidate(candidateId)}
+                      onTieBreak={() => void requestTieBreak()}
                     />
                     {verifiedIdleCopy && (
                       <p className="rectification-pending-note" role="status">

frontend/src/components/rectification-range-delivery.tsx

@@ -18,11 +18,13 @@ export function RectificationRangeDelivery({
   acceptingCandidateId,
   readonly,
   onAccept,
+  onTieBreak,
 }: Readonly<{
   result: RectificationCandidateResult;
   acceptingCandidateId: string | null;
   readonly: boolean;
   onAccept: (candidateId: string) => void;
+  onTieBreak?: () => void;
 }>) {
   const delivery: RangeDeliveryProjection | null = result.rangeDelivery;
   const range = delivery?.range ?? result.credibleRange;
@@ -47,6 +49,16 @@ export function RectificationRangeDelivery({
       {delivery?.narrow_hint ? (
         <p className="rectification-range-delivery__narrow">{delivery.narrow_hint}</p>
       ) : null}
+      {delivery?.tie_break_available && onTieBreak && !readonly ? (
+        <button
+          type="button"
+          className="rectification-range-delivery__tie-break"
+          disabled={busy}
+          onClick={onTieBreak}
+        >
+          {RECTIFICATION_USER_COPY.rangeDeliveryTieBreakEntry}
+        </button>
+      ) : null}
       {sharedTraits.length > 0 ? (
         <ul className="rectification-range-delivery__shared">
           {sharedTraits.map((line) => (

frontend/src/lib/rectification-agentic/user-copy.ts

@@ -146,6 +146,8 @@ export const RECTIFICATION_USER_COPY = {
   rangeDeliveryNotCompared: "这一分钟还没对照",
   rangeDeliveryAdopting: "正在采用…",
   rangeDeliveryAdopted: "已采用",
+  rangeDeliveryTieBreakEntry: "再答两道参考题微调排序",
+  rangeDeliveryTieBreakAck: "只微调排序，不改目前范围。",
   verificationReportSummary: "查看验证报告",
 } as const;
 
@@ -497,6 +499,8 @@ export function listUserVisibleCopy(): string[] {
     RECTIFICATION_USER_COPY.rangeDeliveryNotCompared,
     RECTIFICATION_USER_COPY.rangeDeliveryAdopting,
     RECTIFICATION_USER_COPY.rangeDeliveryAdopted,
+    RECTIFICATION_USER_COPY.rangeDeliveryTieBreakEntry,
+    RECTIFICATION_USER_COPY.rangeDeliveryTieBreakAck,
     RECTIFICATION_USER_COPY.verificationReportSummary,
     postAdoptVerifyDoneCopy("04:53", false),
     rangeChangedAfterEvidence(["04:50", "04:57"], ["04:47", "05:15"]) ?? "",

frontend/src/lib/rectification-agentic/v9/answer-choice.ts

@@ -100,6 +100,7 @@ import {
   spokenCollectFallbackFollowup,
   spokenFollowupForUser,
   targetedCollectFollowup,
+  tieBreakPersonalityFollowup,
   collectQuestionDomain,
   ledgerHasConfirmedDatedEvent,
   type MethodCoverage,
@@ -428,6 +429,46 @@ function markVerifyProbeSkipped(
   };
 }
 
+function isTargetedCollectFocus(focus: {
+  questionId?: string | null;
+  targetKind?: string | null;
+  expectedAnswerSchema?: Readonly<Record<string, unknown>> | null;
+} | null | undefined): boolean {
+  if (!focus) return false;
+  const questionId = focus.questionId ?? "";
+  const kind = focus.targetKind ?? "";
+  const schemaKind = typeof focus.expectedAnswerSchema?.collect_kind === "string"
+    ? focus.expectedAnswerSchema.collect_kind
+    : "";
+  return questionId.startsWith("collect:targeted:")
+    || kind.startsWith("targeted:")
+    || schemaKind.startsWith("targeted:")
+    || focus.expectedAnswerSchema?.targeted_collect === true;
+}
+
+function isTargetedCollectExistenceSchema(schema: Readonly<Record<string, unknown>> | null | undefined): boolean {
+  if (!schema || schema.targeted_collect !== true) return false;
+  const choice = schema.choice;
+  return Boolean(choice && typeof choice === "object" && !Array.isArray(choice));
+}
+
+function targetedCollectExistenceAck(status: "resolved" | "declined" | "skipped"): string {
+  if (status === "resolved") return "记下了。";
+  if (status === "skipped") return RECTIFICATION_USER_COPY.collectSkippedAck;
+  return RECTIFICATION_USER_COPY.collectDeclinedAck;
+}
+
+function targetedCollectHostNarration(
+  followup: MethodFollowup | null | undefined,
+  fallback: string,
+): string {
+  if (followup && isTargetedCollectFollowup(followup) && followup.choice_frame) {
+    const remaining = followup.spoken_prompt?.trim();
+    if (remaining) return remaining;
+  }
+  return fallback;
+}
+
 function dossierWithClosedFocus<T extends {
   conversationSummary: {
     activeFocus: {
@@ -435,6 +476,7 @@ function dossierWithClosedFocus<T extends {
       intent?: string | null;
       questionId?: string | null;
       targetKind?: string | null;
+      expectedAnswerSchema?: Readonly<Record<string, unknown>> | null;
     } | null;
     declinedSkippedTopics: readonly Readonly<Record<string, unknown>>[];
   };
@@ -444,6 +486,7 @@ function dossierWithClosedFocus<T extends {
   const intent = focus?.intent ?? null;
   const rememberClosed = Boolean(
     ((status === "declined" || status === "skipped") && domain)
+    || (status === "resolved" && isTargetedCollectFocus(focus))
     || intent === "reverse_verify",
   );
   const declinedSkippedTopics = rememberClosed
@@ -455,6 +498,7 @@ function dossierWithClosedFocus<T extends {
         ...(intent ? { intent } : {}),
         ...(focus?.questionId ? { questionId: focus.questionId } : {}),
         ...(focus?.targetKind ? { target_kind: focus.targetKind } : {}),
+        ...(focus?.expectedAnswerSchema ? { expected_answer_schema: focus.expectedAnswerSchema } : {}),
       },
     ]
     : dossier.conversationSummary.declinedSkippedTopics;
@@ -618,6 +662,42 @@ export async function applyRectificationChoice(
     });
   }
 
+  if (isTargetedCollectExistenceSchema(schema) && optionId !== "stop") {
+    const declined = answerClass === "no";
+    const skipped = optionId === "skip_probe"
+      || answerClass === "unsure"
+      || answerClass === "weak_yes";
+    const focusStatus: "resolved" | "declined" | "skipped" = declined
+      ? "declined"
+      : skipped
+        ? "skipped"
+        : "resolved";
+    return persistApplied(accounting, command, {
+      focusId: focus.id,
+      questionId,
+      focusStatus,
+      probeId: null,
+      optionId,
+      scoring: false,
+      appliedInference: false,
+      answerClass: optionId === "skip_probe" ? null : answerClass,
+      sourceQuote: optionId === "A" || optionId === "B" || optionId === "C" || optionId === "D"
+        ? optionQuoteFromSchema(schema, optionId)
+        : null,
+      year: null,
+      expectedRevision: previous?.revision ?? command.expectedRevision,
+      inference: null,
+      narration: targetedCollectExistenceAck(focusStatus),
+      userDisplay: command.userDisplay
+        ?? (optionId === "skip_probe"
+          ? CHOICE_SKIP_QUESTION_LABEL
+          : userDisplayFromSchema(schema, optionId)),
+      decisionState: previous,
+      userStopped: false,
+      dossier,
+    });
+  }
+
   if (optionId === "skip_probe" || command.action === SKIP_PROBE_ACTION) {
     const skippedState = previous ? markVerifyProbeSkipped(previous, schema, schemaProbeId ?? command.probeId ?? null) : null;
     const probeId = schemaProbeId ?? command.probeId ?? asText(schema.semantic_key) ?? "skip_probe";
@@ -953,8 +1033,9 @@ export async function persistNextInterviewAfterChoice(input: {
   const open = openQuestionFromPersistedFocus(persistedFocus);
   if (isRenderableChoiceOpenQuestion(open) && open.prompt) {
     return {
-      hostNarration: open.prompt,
+      hostNarration: targetedCollectHostNarration(followup, open.prompt),
       choiceReady: true,
+      persisted: true,
       focusId: persistedFocus.focus?.id ?? null,
       focus: persistedFocus.focus,
       followup,
@@ -970,6 +1051,17 @@ export async function persistNextInterviewAfterChoice(input: {
       followup,
     };
   }
+  if (followup && isTargetedCollectFollowup(followup) && followup.choice_frame) {
+    return persistExhaustionCollect({
+      accounting: input.accounting,
+      userId: input.userId,
+      caseId: input.caseId,
+      dossier: liveDossier,
+      decision,
+      decisionReceipt: liveDossier.latestResult?.decisionReceipt,
+      askedTurnId: input.askedTurnId ?? null,
+    });
+  }
   if (followup?.intent === "collect_method_evidence" && followup.choice_frame) {
     const spokenFollowup = spokenCollectFallbackFollowup(followup);
     const spoken = spokenFollowupForUser(spokenFollowup, liveDossier.evidence);
@@ -1059,6 +1151,103 @@ export async function persistNextInterviewAfterChoice(input: {
   };
 }
 
+export async function requestTieBreakPersonality(input: {
+  accounting: AccountingClient;
+  userId: string;
+  caseId: string;
+  requestId: string;
+  askedTurnId?: string | null;
+}): Promise<{
+  persisted: boolean;
+  choiceReady: boolean;
+  hostNarration: string;
+  focus: ConversationFocus | null;
+}> {
+  const dossier = await loadV9CaseDossier(input.accounting, input.userId, input.caseId);
+  if (dossier.case.acceptedTime) {
+    return {
+      persisted: false,
+      choiceReady: false,
+      hostNarration: "",
+      focus: 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 {
+    birthDate = null;
+  }
+  const catalog = rectificationFollowupCatalog(dossier.latestResult, dossier.evidence);
+  const followup = tieBreakPersonalityFollowup({
+    evidence: dossier.evidence,
+    declinedTopics: dossier.conversationSummary.declinedSkippedTopics,
+    closedCollectFocuses: dossier.conversationSummary.declinedSkippedTopics,
+    sessionOutcome: "discriminate_candidates",
+    candidatesSeparated: false,
+    ...catalog,
+    birthDate,
+    accepted: Boolean(dossier.case.acceptedTime),
+    ...followupCaseArgs({
+      stage: dossier.case.stage,
+      blockScan: dossier.case.blockScan,
+      reportedBirthTime: dossier.case.reportedBirthTime,
+      candidateRange: dossier.case.candidateRange,
+    }),
+  });
+  if (!followup) {
+    return {
+      persisted: false,
+      choiceReady: false,
+      hostNarration: "",
+      focus: null,
+    };
+  }
+  const persistedFocus = await persistFocusAfterChoice({
+    accounting: input.accounting,
+    userId: input.userId,
+    caseId: input.caseId,
+    decisionReceipt: dossier.latestResult?.decisionReceipt,
+    followup,
+    askedTurnId: input.askedTurnId ?? null,
+  });
+  const open = openQuestionFromPersistedFocus(persistedFocus);
+  if (!isRenderableChoiceOpenQuestion(open) || !open.prompt) {
+    return {
+      persisted: false,
+      choiceReady: false,
+      hostNarration: "",
+      focus: persistedFocus.focus,
+    };
+  }
+  const hostNarration = RECTIFICATION_USER_COPY.rangeDeliveryTieBreakAck;
+  const turn = await persistV9DeterministicTurn(input.accounting, input.userId, input.caseId, {
+    requestId: input.requestId,
+    userMessage: RECTIFICATION_USER_COPY.rangeDeliveryTieBreakEntry,
+    assistantMessage: hostNarration,
+  });
+  if (persistedFocus.focus && turn.turnId) {
+    try {
+      await linkFocusAskedTurn({
+        accounting: input.accounting,
+        userId: input.userId,
+        caseId: input.caseId,
+        focus: persistedFocus.focus,
+        askedTurnId: turn.turnId,
+      });
+    } catch {
+      // Choice card can still render from the persisted focus.
+    }
+  }
+  return {
+    persisted: true,
+    choiceReady: true,
+    hostNarration,
+    focus: persistedFocus.focus,
+  };
+}
+
 async function persistFocusAfterChoice(input: {
   accounting: AccountingClient;
   userId: string;
@@ -1548,6 +1737,7 @@ async function persistExhaustionCollect(input: {
     dossier.evidence,
     dossier.conversationSummary.declinedSkippedTopics,
     catalog.remainingSplitTimes,
+    catalog.remainingCandidateCount,
   );
   const trainingGate = trainingScoreableGate(dossier.evidence);
   const ceiling = engineCapabilityCeilingFromReceipt(receipt);
@@ -1565,14 +1755,14 @@ async function persistExhaustionCollect(input: {
   };
   let persistStatus: string | null = null;
   let persistQuestionId: string | null = null;
-  if (followup) {
+  let targetedSkipCount = 0;
+  while (followup) {
     const range = nonConvergingRangeNarration({
       credibleRange: decision.credibleRange ?? input.decision.credibleRange,
       representativeTime: decision.representativeTime ?? input.decision.representativeTime,
       openingRange: openingRangeFromDossier(dossier),
       variant: "intermediate",
     });
-    const spoken = spokenFollowupForUser(followup);
     const persistedFocus = await persistFocusAfterChoice({
       accounting: input.accounting,
       userId: input.userId,
@@ -1606,18 +1796,28 @@ async function persistExhaustionCollect(input: {
       persist_status: persistStatus,
       question_id: persistQuestionId,
     }));
-    const persisted = Boolean(spoken) && (
-      persistedFocus.status === "created" || persistedFocus.status === "already_open"
-    );
-    if (persisted) {
+    const open = openQuestionFromPersistedFocus(persistedFocus);
+    const persistOk = persistedFocus.status === "created" || persistedFocus.status === "already_open";
+    if (persistOk && isRenderableChoiceOpenQuestion(open) && open.prompt) {
       return {
-        persisted,
-        choiceReady: false,
-        hostNarration: spoken ?? range,
+        persisted: true,
+        choiceReady: true,
+        hostNarration: targetedCollectHostNarration(followup, open.prompt),
         focus: persistedFocus.focus,
       };
     }
-    if (isTargetedCollectFollowup(followup)) {
+    const spoken = followup.choice_frame
+      ? (followup.spoken_prompt?.trim() || spokenFollowupForUser({ ...followup, choice_frame: null }))
+      : spokenFollowupForUser(followup);
+    if (persistOk && spoken && !followup.choice_frame) {
+      return {
+        persisted: true,
+        choiceReady: false,
+        hostNarration: spoken,
+        focus: persistedFocus.focus,
+      };
+    }
+    if (isTargetedCollectFollowup(followup) && targetedSkipCount < 8) {
       await persistSkippedCollectFocus({
         accounting: input.accounting,
         userId: input.userId,
@@ -1644,22 +1844,25 @@ async function persistExhaustionCollect(input: {
         dossier.evidence,
         dossier.conversationSummary.declinedSkippedTopics,
         catalog.remainingSplitTimes,
+        catalog.remainingCandidateCount,
       );
-      if (isTargetedCollectFollowup(followup)) followup = null;
-    } else {
-      // duplicate_focus is not "already asked". Keep the spoken collect or the
-      // intermediate range sentence instead of falling through to adopt.
-      const hostNarration = (spoken ?? "").trim() || (range ?? "").trim();
-      if (hostNarration) {
-        return {
-          persisted: false,
-          choiceReady: false,
-          hostNarration,
-          focus: persistedFocus.focus,
-        };
-      }
+      targetedSkipCount += 1;
+      continue;
     }
-  } else {
+    // duplicate_focus is not "already asked". Keep the spoken collect or the
+    // intermediate range sentence instead of falling through to adopt.
+    const hostNarration = (spoken ?? "").trim() || (range ?? "").trim();
+    if (hostNarration) {
+      return {
+        persisted: false,
+        choiceReady: false,
+        hostNarration,
+        focus: persistedFocus.focus,
+      };
+    }
+    break;
+  }
+  if (!followup) {
     console.warn(JSON.stringify({
       event: "rectification_exhaustion_collect",
       case_id: input.caseId,
@@ -1724,6 +1927,7 @@ async function persistExhaustionCollect(input: {
     dossier.evidence,
     dossier.conversationSummary.declinedSkippedTopics,
     catalog.remainingSplitTimes,
+    catalog.remainingCandidateCount,
   );
   const range = nonConvergingRangeNarration({
     credibleRange: decision.credibleRange ?? input.decision.credibleRange,
@@ -1836,7 +2040,14 @@ async function persistApplied(
     if (nextInterview.hostNarration) {
       if (accepted || skipThisProbe) {
         hostNarration = nextInterview.hostNarration;
-      } else if (skippedNextInterview) {
+      } else if (
+        skippedNextInterview
+        || (
+          nextInterview.choiceReady
+          && nextInterview.followup
+          && isTargetedCollectFollowup(nextInterview.followup)
+        )
+      ) {
         hostNarration = `${input.narration}
 
 ${nextInterview.hostNarration}`;

frontend/src/lib/rectification-agentic/v9/case-dossier-response.ts

@@ -0,0 +1,147 @@
+import {
+  evidenceLedgerFingerprint,
+  loadV9CaseSkillIdentityStatus,
+  loadV9TurnReceipt,
+  questionSourceFromFocusList,
+  receiptStatusFromTurn,
+  type ConversationFocusList,
+  type V9CaseDossier,
+} from "@/lib/rectification-agentic/v9/tool-service";
+import { choiceCardFromCaseDossier, decideFromDossier, overlayPublicDecision, nextUserActionFromDossier, stepStateFromCaseDossier } from "@/lib/rectification-agentic/v9/interview-state";
+import { projectCurrentQuestion } from "@/lib/rectification-agentic/v9/turn-decision";
+import { attachQuestionsToTurns, attachOfferResultToTurns } from "@/lib/rectification-agentic/v9/turn-question";
+import { previousInferenceFromReceipt } from "@/lib/rectification-agentic/v9/inference-adapter";
+import { publicDecisionFields } from "@/lib/rectification-agentic/core/rectification-decision";
+import { collectionProgressFromReceipt } from "@/lib/rectification-agentic/v9/evidence-model";
+import { slimDecisionReceipt } from "@/lib/rectification-agentic/v9/case-receipt-projection";
+import { rangeDeliveryForSnapshot } from "@/lib/rectification-agentic/v9/divergence-panel";
+import { latestResultToolProjection } from "@/mastra/rectification-v9-tools";
+
+export function dossierResponse(
+  dossier: V9CaseDossier,
+  receipts: Array<Awaited<ReturnType<typeof loadV9TurnReceipt>>>,
+  skillIdentity: Awaited<ReturnType<typeof loadV9CaseSkillIdentityStatus>>,
+  options: { fullDetail?: boolean; listed?: ConversationFocusList } = {},
+) {
+  const decision = decideFromDossier(dossier, {
+    currentEvidenceFingerprint: evidenceLedgerFingerprint(dossier.evidence),
+  });
+  const listed = options.listed ?? { focuses: [] as const, available: true };
+  const turnsWithQuestions = attachQuestionsToTurns(dossier.turns, listed.focuses);
+  const fields = publicDecisionFields(decision);
+  const overlaid = dossier.latestResult
+    ? overlayPublicDecision(dossier.latestResult, decision)
+    : fields;
+  const turns = attachOfferResultToTurns(turnsWithQuestions, {
+    resultId: dossier.latestResult?.resultId ?? null,
+    canAdopt: overlaid.can_adopt === true,
+    acceptedTime: dossier.case.acceptedTime,
+  });
+  return {
+    case: {
+      case_id: dossier.case.caseId,
+      session_id: dossier.case.sessionId,
+      status: dossier.case.status,
+      skill_name: dossier.case.skillName,
+      skill_version: dossier.case.skillVersion,
+      skill_identity_status: skillIdentity.status,
+      requires_skill_adoption: skillIdentity.requiresSkillAdoption,
+      candidate_range: dossier.case.candidateRange,
+      stage: dossier.case.stage,
+      accepted_time: dossier.case.acceptedTime,
+      confirmed_time: dossier.case.confirmedTime,
+      completed_at: dossier.case.completedAt,
+      closed_reason: dossier.case.closedReason,
+      last_activity_at: dossier.case.lastActivityAt,
+      case_revision: previousInferenceFromReceipt(dossier.latestResult?.decisionReceipt ?? null)?.revision ?? 0,
+    },
+    turns: turns.map((turn) => ({
+      id: turn.id,
+      role: turn.role,
+      text: turn.text,
+      status: turn.status,
+      created_at: turn.createdAt,
+      receipt: turnReceipt(turn.id, receipts),
+      question: turn.question,
+      offer_result_id: turn.offer_result_id,
+    })),
+    evidence: dossier.evidence,
+    latest_result: dossier.case.stage === "block_scan" || decision.sessionOutcome === "compare_blocks"
+      ? null
+      : dossier.latestResult
+      ? publicLatestResult(dossier.latestResult, decision, dossier, options.fullDetail === true)
+      : null,
+    interview: {
+      ...fields,
+      collection_progress: collectionProgressFromReceipt(dossier.latestResult?.decisionReceipt ?? null),
+    },
+    current_question: projectCurrentQuestion(dossier.conversationSummary.activeFocus),
+    choice_card: choiceCardFromCaseDossier(dossier),
+    step_state: stepStateFromCaseDossier(dossier),
+    next_user_action: nextUserActionFromDossier(dossier),
+    question_source: questionSourceFromFocusList(listed),
+  };
+}
+
+function publicLatestResult(
+  latest: V9CaseDossier["latestResult"],
+  decision: ReturnType<typeof decideFromDossier>,
+  dossier: V9CaseDossier,
+  fullDetail: boolean,
+) {
+  if (!latest) return null;
+  const projected = overlayPublicDecision(latest, decision);
+  const toolProjection = latestResultToolProjection(latest, decision);
+  const rangeDelivery = rangeDeliveryForSnapshot({
+    decisionReceipt: projected.decisionReceipt,
+    candidates: projected.candidates,
+    representativeTime: projected.representativeTime ?? decision.representativeTime,
+    representative_time: projected.representativeTime ?? decision.representativeTime,
+    credibleRange: projected.credible_range ?? decision.credibleRange,
+    credible_range: projected.credible_range ?? decision.credibleRange,
+    skill_verification_report: toolProjection.skill_verification_report,
+    evidence: dossier.evidence,
+    declinedTopics: dossier.conversationSummary.declinedSkippedTopics,
+  });
+  const withDelivery = {
+    ...projected,
+    range_delivery: rangeDelivery,
+    rangeDelivery,
+  };
+  if (fullDetail || !projected.decisionReceipt) return withDelivery;
+  return {
+    ...withDelivery,
+    decisionReceipt: slimDecisionReceipt(projected.decisionReceipt, dossier),
+  };
+}
+
+function turnReceipt(
+  turnId: string,
+  receipts: Array<Awaited<ReturnType<typeof loadV9TurnReceipt>>>,
+) {
+  const receipt = receipts.find((item) => item?.turnId === turnId) ?? null;
+  if (!receipt) return null;
+  return {
+    turn_id: receipt.turnId,
+    skill_name: receipt.skillName,
+    skill_version: receipt.skillVersion,
+    engine_version: receipt.engineVersion,
+    status: receiptStatusFromTurn(receipt.status),
+    phases: receipt.phases.map((phase) => phase.phase),
+    tool_activities: receipt.toolActivities.map((activity) => ({
+      tool: activity.tool,
+      status: activity.status,
+      methods: activity.methods,
+      started_at: activity.startedAt ?? null,
+      elapsed_ms: activity.elapsedMs ?? null,
+      detail: activity.detail ?? null,
+    })),
+    tools: receipt.tools,
+    methods: receipt.methods,
+    started_at: receipt.startedAt,
+    completed_at: receipt.completedAt,
+    ...(receipt.phases.some((phase) => phase.phase === "answer.host_fallback")
+      ? { answer_origin: "host_fallback" as const }
+      : {}),
+  };
+}

frontend/src/lib/rectification-agentic/v9/case-status.ts

@@ -89,4 +89,4 @@ export function evidenceWritesAllowed(
 export const MAX_RESUMABLE_CASES_PER_USER = 1;
 
 export const RECTIFICATION_SKILL_NAME = "jyotish-birth-time-rectification";
-export const RECTIFICATION_SKILL_VERSION = "10.0.24";
+export const RECTIFICATION_SKILL_VERSION = "10.0.25";

frontend/src/lib/rectification-agentic/v9/choice-card.ts

@@ -27,6 +27,11 @@ export const CHOICE_STOP_MESSAGE = "先这样";
 export const CHOICE_SKIP_QUESTION_LABEL = "这题跳过";
 export const CHOICE_SKIP_QUESTION_MESSAGE = "这题跳过";
 export const HOLDOUT_MESSAGE_PREFIX = "盘外核对（不计分）";
+export const TARGETED_COLLECT_OPTION_A = "有过这件事";
+export const TARGETED_COLLECT_OPTION_B = "没有发生过";
+export const TARGETED_COLLECT_OPTION_C = "记不太清楚";
+export const TARGETED_COLLECT_OPTION_D = "这条先跳过";
+export const TARGETED_COLLECT_WHY_USER = "答有的话再说大概年月，没有或记不清就问下一条。";
 export const FORBIDDEN_CHOICE_COPY = /外貌|体质|胎记|疤痕|伤疤|身高|体型|(?:[01]?\d|2[0-3]):[0-5]\d/;
 export const FOCUS_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
@@ -553,6 +558,38 @@ export function parseAgentChoiceCopy(value: unknown): AgentChoiceCopy | null {
   };
 }
 
+export function buildTargetedCollectExistenceFrame(input: {
+  questionId: string;
+  methodId: string;
+  prompt: string;
+}): RectificationChoiceFrame | null {
+  const prompt = clippedCopy(input.prompt, 4, 80);
+  if (!prompt) return null;
+  return {
+    question_id: input.questionId,
+    method_id: input.methodId,
+    period: "",
+    prompt,
+    varga: null,
+    why: TARGETED_COLLECT_WHY_USER,
+    option_a_hint: TARGETED_COLLECT_OPTION_A,
+    option_b_hint: TARGETED_COLLECT_OPTION_B,
+    neither_label: TARGETED_COLLECT_OPTION_C,
+    unsure_label: TARGETED_COLLECT_OPTION_D,
+    option_a_answer_class: "yes",
+    option_b_answer_class: "no",
+    option_c_answer_class: "unsure",
+    option_d_answer_class: "weak_yes",
+    choice_mode: CHOICE_MODE,
+    stop_label: CHOICE_STOP_LABEL,
+    stop_message: CHOICE_STOP_MESSAGE,
+    scoring: false,
+    why_user: TARGETED_COLLECT_WHY_USER,
+    answer_impact: { A: "", B: "", C: "", D: "" },
+    choice_kind: "existence",
+  };
+}
+
 export function mergeChoiceCard(
   frame: RectificationChoiceFrame,
   copy: AgentChoiceCopy | null,

frontend/src/lib/rectification-agentic/v9/collection-question-pool.ts

@@ -41,6 +41,9 @@ export type CollectionPoolItem = Readonly<{
   targetKind: string | null;
   year: number | null;
   examples?: readonly string[];
+  existencePrompt?: string;
+  yearPrompt?: string;
+  remainingLine?: string;
 }>;
 
 const KIND_EXAMPLES: Readonly<Record<CollectKind, string>> = {
@@ -490,6 +493,21 @@ const TARGETED_EXAMPLES: Readonly<Record<CollectKind, readonly [string, string]>
   health_pressure: ["哪年住院或手术", "哪年身体明显垮过一截"],
 };
 
+const TARGETED_EXISTENCE_PROMPT: Readonly<Record<CollectKind, string>> = {
+  education: "升过学或考试发挥明显变过吗？",
+  career: "换过工作或岗位变过吗？",
+  relocation: "搬过家或换过城市吗？",
+  relationship: "结过婚或订过婚吗？",
+  family: "家里添过丁或长辈住过院吗？",
+  finance: "收入明显变过或有过大笔进出吗？",
+  health_pressure: "住过院、做过手术或身体明显垮过吗？",
+};
+
+export const TARGETED_YEAR_PROMPT = "大概哪年几月？";
+
+/** Range-endpoint wording that used to name two clocks as if they were the remaining candidates. */
+export const SPLIT_ENDPOINT_PHRASE = /能把 (?:[01]\d|2[0-3]):[0-5]\d 和 (?:[01]\d|2[0-3]):[0-5]\d 分开/;
+
 const SCAN_LAYER_FLAGS: ReadonlyArray<readonly [string, string]> = [
   ["d9", "d9_candidates_differ"],
   ["d10", "d10_candidates_differ"],
@@ -533,14 +551,65 @@ export function remainingSplitLayers(input: {
   return fromScan;
 }
 
+export function remainingCandidateClocks(
+  activeTimes: readonly string[] = [],
+): string[] {
+  return [...new Set(activeTimes.map((item) => clockValue(item)).filter((item): item is string => Boolean(item)))].sort();
+}
+
 export function remainingSplitTimes(
   activeTimes: readonly string[] = [],
 ): readonly [string, string] | null {
-  const clocks = [...new Set(activeTimes.map((item) => clockValue(item)).filter((item): item is string => Boolean(item)))].sort();
+  const clocks = remainingCandidateClocks(activeTimes);
   if (clocks.length < 2) return null;
   return [clocks[0], clocks[clocks.length - 1]];
 }
 
+export function remainingCandidateCount(activeTimes: readonly string[] = []): number {
+  return remainingCandidateClocks(activeTimes).length;
+}
+
+export type TargetedCollectStage = "existence" | "year";
+
+export type TargetedCollectRef = Readonly<{
+  domain: CollectKind;
+  stage: TargetedCollectStage;
+}>;
+
+export function parseTargetedCollectQuestionId(
+  questionId: string | null | undefined,
+): TargetedCollectRef | null {
+  const trimmed = (questionId ?? "").replace(/:(?:next|next2|next3)$/, "").trim();
+  const match = /^collect:targeted:([a-z_]+)(?::(year))?$/.exec(trimmed);
+  if (!match) return null;
+  const domain = normalizeCollectKind(match[1]);
+  if (!domain) return null;
+  return { domain, stage: match[2] === "year" ? "year" : "existence" };
+}
+
+export function parseTargetedCollectKind(
+  kind: string | null | undefined,
+): TargetedCollectRef | null {
+  const trimmed = (kind ?? "").trim();
+  const match = /^targeted:([a-z_]+)(?::(year))?$/.exec(trimmed);
+  if (!match) return null;
+  const domain = normalizeCollectKind(match[1]);
+  if (!domain) return null;
+  return { domain, stage: match[2] === "year" ? "year" : "existence" };
+}
+
+export function targetedCollectQuestionId(
+  domain: CollectKind,
+  stage: TargetedCollectStage = "existence",
+): string {
+  return stage === "year" ? `collect:targeted:${domain}:year` : `collect:targeted:${domain}`;
+}
+
+export function targetedCollectRefFromTopic(topic: CollectionTopic): TargetedCollectRef | null {
+  return parseTargetedCollectQuestionId(topicQuestionId(topic))
+    ?? parseTargetedCollectKind(topicCollectKind(topic));
+}
+
 export function isTargetedCollectTopic(topic: CollectionTopic): boolean {
   const questionId = topicQuestionId(topic);
   const kind = topicCollectKind(topic);
@@ -570,6 +639,21 @@ export function isTargetedCollectFollowup(followup: {
     || hint.startsWith("targeted:");
 }
 
+export function isTargetedCollectYearFollowup(followup: {
+  collection_key?: string;
+  kind_hint?: string | null;
+} | null | undefined): boolean {
+  if (!followup) return false;
+  const key = followup.collection_key ?? "";
+  const hint = followup.kind_hint ?? "";
+  return parseTargetedCollectQuestionId(key)?.stage === "year"
+    || parseTargetedCollectKind(hint)?.stage === "year";
+}
+
+/**
+ * True when at least one targeted line was declined or skipped.
+ * Per-domain cards must not treat this as “the whole targeted pool is done”.
+ */
 export function isTargetedCollectDeclined(
   topics: readonly CollectionTopic[] = [],
 ): boolean {
@@ -592,6 +676,11 @@ function collectDeclinedKinds(topics: readonly CollectionTopic[]): ReadonlySet<C
     if (!collectIntent) continue;
     if (questionId.startsWith("collect:invite:")) continue;
     if (questionId.startsWith("collect:other:")) continue;
+    const targeted = targetedCollectRefFromTopic(topic);
+    if (targeted) {
+      declined.add(targeted.domain);
+      continue;
+    }
     const kind = normalizeCollectKind(topicDomain(topic))
       ?? (questionId.startsWith("collect:generic:")
         ? normalizeCollectKind(questionId.split(":")[2] ?? "")
@@ -600,53 +689,105 @@ function collectDeclinedKinds(topics: readonly CollectionTopic[]): ReadonlySet<C
   }
   return declined;
 }
+
+function targetedDomainClosed(
+  topics: readonly CollectionTopic[],
+  domain: CollectKind,
+): boolean {
+  for (const topic of topics) {
+    const status = topicStatus(topic);
+    if (status === "active" || !status) continue;
+    const targeted = targetedCollectRefFromTopic(topic);
+    if (targeted?.domain !== domain) continue;
+    if (status === "declined" || status === "skipped") return true;
+    if (status === "resolved" && targeted.stage === "existence") return true;
+    if (status === "resolved" && targeted.stage === "year") return true;
+  }
+  return false;
+}
+
+export function pendingTargetedYearDomain(
+  topics: readonly CollectionTopic[] = [],
+  evidence: readonly CollectionEvidence[] = [],
+): CollectKind | null {
+  const covered = coveredCollectKinds(evidence);
+  const yearClosed = new Set<CollectKind>();
+  const existenceResolved = new Set<CollectKind>();
+  for (const topic of topics) {
+    const targeted = targetedCollectRefFromTopic(topic);
+    if (!targeted) continue;
+    const status = topicStatus(topic);
+    if (status === "active" || !status) continue;
+    if (targeted.stage === "year" && (status === "declined" || status === "skipped" || status === "resolved")) {
+      yearClosed.add(targeted.domain);
+    }
+    if (targeted.stage === "existence" && status === "resolved") {
+      existenceResolved.add(targeted.domain);
+    }
+  }
+  for (const domain of existenceResolved) {
+    if (covered.has(domain) || yearClosed.has(domain)) continue;
+    return domain;
+  }
+  return null;
+}
+
 function remainingTargetedDomains(
   layers: readonly string[],
   evidence: readonly CollectionEvidence[],
   declined: ReadonlySet<CollectKind>,
+  topics: readonly CollectionTopic[] = [],
 ): CollectKind[] {
   const covered = coveredCollectKinds(evidence);
   const domains: CollectKind[] = [];
   for (const layer of layers) {
     const domain = REMAINING_LAYER_DOMAIN[layer];
     if (!domain || declined.has(domain) || covered.has(domain)) continue;
+    if (targetedDomainClosed(topics, domain)) continue;
     if (!domains.includes(domain)) domains.push(domain);
   }
   return domains;
 }
 
+export function remainingCandidatesLine(
+  splitTimes: readonly [string, string] | null | undefined,
+  candidateCount: number,
+  examples: readonly string[],
+): string | null {
+  if (!splitTimes?.[0] || !splitTimes[1] || candidateCount < 1 || examples.length === 0) return null;
+  return `现在还剩 ${splitTimes[0]}–${splitTimes[1]} 里 ${candidateCount} 个候选，能把它们分开的是这几条线：${examples.join("、")}`;
+}
+
 export function targetedCollectPool(
   remainingLayers: readonly string[],
   evidence: readonly CollectionEvidence[],
   declinedTopics: readonly CollectionTopic[] = [],
   splitTimes?: readonly [string, string] | null,
+  candidateCount?: number,
 ): CollectionPoolItem[] {
-  if (isTargetedCollectDeclined(declinedTopics)) return [];
+  if (pendingTargetedYearDomain(declinedTopics, evidence)) return [];
   const declined = collectDeclinedKinds(declinedTopics);
-  const domains = remainingTargetedDomains(remainingLayers, evidence, declined);
+  const domains = remainingTargetedDomains(remainingLayers, evidence, declined, declinedTopics);
   if (domains.length === 0) return [];
-  const examples = domains.length === 1
-    ? [...TARGETED_EXAMPLES[domains[0]]]
-    : domains.map((domain) => TARGETED_EXAMPLES[domain][0]);
-  const uniqueExamples = [...new Set(examples)];
-  if (uniqueExamples.length < 2) return [];
-  const shown = uniqueExamples.slice(0, Math.max(2, Math.min(domains.length, uniqueExamples.length)));
-  const pair = splitTimes && splitTimes[0] && splitTimes[1]
-    ? splitTimes
-    : null;
-  const splitText = pair ? `能把 ${pair[0]} 和 ${pair[1]} 分开` : "还能把剩下的候选分开";
-  const prompt = `还有${Math.min(domains.length, shown.length)}条线${splitText}：${shown.join("、")}。记得哪件说哪件，年月大概就行。`;
-  const primary = domains[0];
-  return [{
-    kind: "targeted",
-    value: 1.5,
-    prompt,
-    key: `collect:targeted:${primary}`,
-    domain: primary,
-    targetKind: `targeted:${primary}`,
-    year: null,
-    examples: shown,
-  }];
+  const count = candidateCount ?? 0;
+  const examples = domains.map((domain) => TARGETED_EXAMPLES[domain][0]);
+  const remainingLine = remainingCandidatesLine(splitTimes, count, examples);
+  return domains.map((domain) => {
+    const existencePrompt = TARGETED_EXISTENCE_PROMPT[domain];
+    return {
+      kind: "targeted" as const,
+      value: 1.5,
+      prompt: existencePrompt,
+      key: targetedCollectQuestionId(domain),
+      domain,
+      targetKind: `targeted:${domain}`,
+      year: null,
+      examples: [TARGETED_EXAMPLES[domain][0], TARGETED_EXAMPLES[domain][1]],
+      existencePrompt,
+      yearPrompt: TARGETED_YEAR_PROMPT,
+      ...(remainingLine ? { remainingLine } : {}),
+    };
+  });
 }
 
 export function targetedCollectHint(item: CollectionPoolItem | null | undefined): string | null {
@@ -659,16 +800,56 @@ export function targetedCollectHint(item: CollectionPoolItem | null | undefined)
   return `还能再收窄：如果记得${body}`;
 }
 
+export function targetedCollectHintFromPool(
+  items: readonly CollectionPoolItem[],
+): string | null {
+  const examples = [...new Set(items.flatMap((item) => (
+    item.examples?.length ? [item.examples[0]!] : []
+  )))];
+  if (examples.length >= 2) {
+    return `还能再收窄：如果记得${examples.slice(0, 2).join("、")}`;
+  }
+  return targetedCollectHint(items[0]);
+}
+
 /** Card copy ignores a declined targeted collect so the delivered range still says what would narrow it. */
 export function rangeNarrowHint(
   remainingLayers: readonly string[],
   evidence: readonly CollectionEvidence[],
   declinedTopics: readonly CollectionTopic[] = [],
   splitTimes?: readonly [string, string] | null,
+  candidateCount?: number,
 ): string {
-  const item = targetedCollectPool(remainingLayers, evidence, [], splitTimes)[0]
-    ?? targetedCollectPool(remainingLayers, evidence, declinedTopics, splitTimes)[0];
-  return targetedCollectHint(item) ?? `还能再收窄：${moreCollectHint(evidence, declinedTopics)}`;
+  const open = targetedCollectPool(remainingLayers, evidence, [], splitTimes, candidateCount);
+  const remaining = remainingCandidatesLine(
+    splitTimes,
+    candidateCount ?? 0,
+    open.map((item) => TARGETED_EXAMPLES[item.domain as CollectKind]?.[0] ?? item.examples?.[0] ?? "").filter(Boolean),
+  );
+  const hint = targetedCollectHintFromPool(open)
+    ?? targetedCollectHint(targetedCollectPool(remainingLayers, evidence, declinedTopics, splitTimes, candidateCount)[0])
+    ?? `还能再收窄：${moreCollectHint(evidence, declinedTopics)}`;
+  if (remaining && !hint.startsWith(remaining)) {
+    return `${remaining}。${hint}`;
+  }
+  return hint;
+}
+
+export function targetedCollectExhausted(
+  remainingLayers: readonly string[],
+  evidence: readonly CollectionEvidence[],
+  declinedTopics: readonly CollectionTopic[] = [],
+  splitTimes?: readonly [string, string] | null,
+  candidateCount?: number,
+): boolean {
+  if (pendingTargetedYearDomain(declinedTopics, evidence)) return false;
+  return targetedCollectPool(
+    remainingLayers,
+    evidence,
+    declinedTopics,
+    splitTimes,
+    candidateCount,
+  ).length === 0;
 }
 
 export const COLLECT_FLOW_BANNED_PHRASES = [

frontend/src/lib/rectification-agentic/v9/decision-from-dossier.ts

@@ -52,11 +52,10 @@ import { windowScanFromDecisionReceipt } from "./varga-observations";
 import type { DroppedProbe } from "./probe-question-contract.ts";
 import { RECTIFICATION_POLICY } from "../../rectification-policy.ts";
 import {
+  remainingCandidateCount,
   remainingSplitLayers,
   remainingSplitTimes,
-  targetedCollectPool,
-  isTargetedCollectDeclined,
-  isTargetedCollectClosed,
+  targetedCollectExhausted,
 } from "./collection-question-pool.ts";
 import { evidenceLedgerFingerprint } from "./tool-service";
 import { followupCaseArgs, blockScanDeclinedForFingerprint } from "./block-scan.ts";
@@ -392,6 +391,7 @@ export function rectificationFollowupCatalog(
       .map((item) => ({ domain: item.domain, year: item.year })),
     remainingLayers,
     remainingSplitTimes: remainingSplitTimes(activeTimes.length ? activeTimes : topCandidateTimes),
+    remainingCandidateCount: remainingCandidateCount(activeTimes.length ? activeTimes : topCandidateTimes),
   };
 }
 
@@ -503,12 +503,6 @@ function narrowingExhaustion(
 ) {
   const live = catalog ?? rectificationFollowupCatalog(dossier.latestResult, dossier.evidence);
   const declined = dossier.conversationSummary.declinedSkippedTopics;
-  const targeted = targetedCollectPool(
-    live.remainingLayers,
-    dossier.evidence,
-    declined,
-    live.remainingSplitTimes,
-  );
   const remainingLayers = live.remainingLayers;
   const receipt = dossier.latestResult?.decisionReceipt ?? null;
   const attempts = inference?.refresh_attempts
@@ -530,7 +524,13 @@ function narrowingExhaustion(
       || (inference?.refresh_count ?? 0) >= 1
     ),
     targetedCollectExhausted: options?.targetedCollectExhausted
-      ?? (isTargetedCollectClosed(declined) || isTargetedCollectDeclined(declined) || targeted.length === 0),
+      ?? targetedCollectExhausted(
+        remainingLayers,
+        dossier.evidence,
+        declined,
+        live.remainingSplitTimes,
+        live.remainingCandidateCount,
+      ),
   };
 }
 
@@ -777,6 +777,7 @@ export function decideFromDossier(
     eventProbes: catalog.eventProbes,
     remainingLayers: catalog.remainingLayers,
     remainingSplitTimes: catalog.remainingSplitTimes,
+    remainingCandidateCount: catalog.remainingCandidateCount,
     ...followupCaseArgs({
       stage: dossier.case.stage,
       blockScan: dossier.case.blockScan,
@@ -895,6 +896,7 @@ export function decideAfterInferenceChange(input: {
     eventProbes: catalog.eventProbes,
     remainingLayers: catalog.remainingLayers,
     remainingSplitTimes: catalog.remainingSplitTimes,
+    remainingCandidateCount: catalog.remainingCandidateCount,
     ...followupCaseArgs({
       stage: input.dossier.case.stage,
       blockScan: input.dossier.case.blockScan,

frontend/src/lib/rectification-agentic/v9/divergence-panel.ts

@@ -20,6 +20,7 @@ import {
 import { previousInferenceFromReceipt } from "./inference-adapter.ts";
 import {
   rangeNarrowHint,
+  remainingCandidateCount,
   remainingSplitLayers,
   remainingSplitTimes,
 } from "./collection-question-pool.ts";
@@ -80,6 +81,7 @@ export type RangeDeliveryProjection = Readonly<{
   more_label: string | null;
   verification_markdown: string | null;
   narrow_hint: string | null;
+  tie_break_available: boolean;
 }>;
 
 export type PublicCandidateClock = Readonly<{
@@ -331,6 +333,7 @@ export function buildRangeDelivery(input: {
     summary?: string | null;
   }>[];
   declinedTopics?: readonly Readonly<Record<string, unknown>>[];
+  tieBreakAvailable?: boolean;
 }): RangeDeliveryProjection {
   const inference = input.inference;
   const range = input.credibleRange
@@ -388,6 +391,9 @@ export function buildRangeDelivery(input: {
     fit_line: rangeDeliveryFitLine(column.fit),
     window_line: rangeDeliveryWindowLine(column.windows),
   }));
+  const activeTimes = inference?.candidates
+    .filter((item) => item.status !== "eliminated")
+    .map((item) => item.time) ?? clocks.map((item) => item.time);
   return {
     range: normalizedRange,
     representative_time: representativeTime,
@@ -404,18 +410,14 @@ export function buildRangeDelivery(input: {
       remainingSplitLayers({
         transitions: inference?.transitions ?? windowScan?.transitions ?? [],
         scanFlags: windowScan,
-        activeTimes: inference?.candidates
-          .filter((item) => item.status !== "eliminated")
-          .map((item) => item.time) ?? clocks.map((item) => item.time),
+        activeTimes,
       }),
       input.evidence ?? [],
       input.declinedTopics ?? [],
-      remainingSplitTimes(
-        inference?.candidates
-          .filter((item) => item.status !== "eliminated")
-          .map((item) => item.time) ?? clocks.map((item) => item.time),
-      ),
+      remainingSplitTimes(activeTimes),
+      remainingCandidateCount(activeTimes),
     ),
+    tie_break_available: input.tieBreakAvailable === true,
   };
 }
 
@@ -449,6 +451,16 @@ function rangeFromUnknown(value: unknown): readonly [string, string] | null {
   return start && end ? [start, end] : null;
 }
 
+function rawVargaStyleTieBreak(value: unknown): boolean {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const row = value as Record<string, unknown>;
+  const nested = row.window_scan;
+  const scan = nested && typeof nested === "object" && !Array.isArray(nested)
+    ? nested as Record<string, unknown>
+    : row;
+  return scan.d9_candidates_differ === true || scan.d10_candidates_differ === true;
+}
+
 export function rangeDeliveryForSnapshot(snapshot: {
   decisionReceipt?: Readonly<Record<string, unknown>> | null;
   decision_receipt?: Readonly<Record<string, unknown>> | null;
@@ -471,6 +483,7 @@ export function rangeDeliveryForSnapshot(snapshot: {
     summary?: string | null;
   }>[];
   declinedTopics?: readonly Readonly<Record<string, unknown>>[];
+  window_scan?: unknown;
 } | null | undefined): RangeDeliveryProjection {
   const receipt = snapshot?.decisionReceipt ?? snapshot?.decision_receipt ?? null;
   const inference = previousInferenceFromReceipt(receipt);
@@ -497,6 +510,12 @@ export function rangeDeliveryForSnapshot(snapshot: {
     eventDashaLedger: refinement.event_dasha_ledger,
     evidence: snapshot?.evidence,
     declinedTopics: snapshot?.declinedTopics,
+    tieBreakAvailable: Boolean(
+      windowScan?.d9_candidates_differ
+      || windowScan?.d10_candidates_differ
+      || rawVargaStyleTieBreak(snapshot)
+      || rawVargaStyleTieBreak(receipt)
+    ),
   });
 }
 
@@ -638,5 +657,6 @@ export function parseRangeDelivery(value: unknown): RangeDeliveryProjection | nu
       : typeof row.narrowHint === "string" && row.narrowHint.trim()
         ? row.narrowHint.trim()
         : null,
+    tie_break_available: row.tie_break_available === true || row.tieBreakAvailable === true,
   };
 }

frontend/src/lib/rectification-agentic/v9/method-followup.ts

@@ -77,6 +77,7 @@ import {
   mergeChoiceCard,
   choiceCardFromPersistedVerifyCopy,
   serverOwnedChoiceCopy,
+  buildTargetedCollectExistenceFrame,
   type RectificationChoiceCard,
   type RectificationChoiceFrame,
 } from "./choice-card.ts";
@@ -92,7 +93,13 @@ import {
 import {
   collectionQuestionPool,
   isInviteCollectTopic,
+  pendingTargetedYearDomain,
+  remainingCandidatesLine,
+  remainingCandidateCount,
   targetedCollectPool,
+  targetedCollectQuestionId,
+  TARGETED_YEAR_PROMPT,
+  type CollectKind,
   type CollectionPoolItem,
 } from "./collection-question-pool.ts";
 
@@ -1371,9 +1378,69 @@ export function targetedCollectFollowup(
   evidence: readonly MethodFollowupEvidence[],
   declinedTopics: readonly Readonly<Record<string, unknown>>[] = [],
   splitTimes?: readonly [string, string] | null,
+  candidateCount?: number,
 ): MethodFollowup | null {
-  const top = targetedCollectPool(remainingLayers, evidence, declinedTopics, splitTimes)[0];
-  return top ? followupFromPoolItem(top) : null;
+  const pendingYear = pendingTargetedYearDomain(declinedTopics, evidence);
+  if (pendingYear) {
+    return targetedCollectYearFollowup(pendingYear);
+  }
+  const top = targetedCollectPool(
+    remainingLayers,
+    evidence,
+    declinedTopics,
+    splitTimes,
+    candidateCount,
+  )[0];
+  if (!top) return null;
+  return targetedCollectExistenceFollowup(top, splitTimes, candidateCount);
+}
+
+export function targetedCollectYearFollowup(domain: CollectKind): MethodFollowup {
+  const methodId = domain in PROBE_METHOD_ID
+    ? PROBE_METHOD_ID[domain as keyof typeof PROBE_METHOD_ID]
+    : "dasha_events";
+  const theme = domain in REVERSE_VERIFY_THEME
+    ? REVERSE_VERIFY_THEME[domain as keyof typeof REVERSE_VERIFY_THEME]
+    : "dated_event";
+  return {
+    method_id: methodId,
+    intent: "collect_method_evidence",
+    ask_theme: theme,
+    domain,
+    kind_hint: `targeted:${domain}:year`,
+    user_prompt_hint: TARGETED_YEAR_PROMPT,
+    must_not_label: false,
+    choice_frame: null,
+    source: "method_coverage",
+    spoken_prompt: TARGETED_YEAR_PROMPT,
+    collection_key: targetedCollectQuestionId(domain, "year"),
+  };
+}
+
+function targetedCollectExistenceFollowup(
+  item: CollectionPoolItem,
+  splitTimes?: readonly [string, string] | null,
+  candidateCount?: number,
+): MethodFollowup {
+  const base = followupFromPoolItem(item);
+  const frame = buildTargetedCollectExistenceFrame({
+    questionId: item.key,
+    methodId: base.method_id,
+    prompt: item.existencePrompt ?? item.prompt,
+  });
+  const remaining = item.remainingLine
+    ?? remainingCandidatesLine(
+      splitTimes,
+      candidateCount ?? remainingCandidateCount(),
+      item.examples?.length ? [item.examples[0]!] : [],
+    );
+  return {
+    ...base,
+    choice_frame: frame,
+    choice_kind: "existence",
+    spoken_prompt: remaining ?? item.prompt,
+    collection_key: item.key,
+  };
 }
 
 export function nextDatedCollectFollowup(
@@ -1969,6 +2036,8 @@ export function buildMethodFollowupPlan(input: {
   candidateRange?: { start_time: string; end_time: string } | null;
   remainingLayers?: readonly string[];
   remainingSplitTimes?: readonly [string, string] | null;
+  remainingCandidateCount?: number;
+  tieBreakRequested?: boolean;
 }): MethodFollowupPlan {
   const makeFollowup = (
     item: Omit<MethodFollowup, "must_not_label" | "choice_frame">,
@@ -2444,6 +2513,26 @@ export function buildMethodFollowupPlan(input: {
     }
     return null;
   };
+  const firstRenderablePersonalityFollowup = (): MethodFollowup | null => {
+    const preferred = ["varga.d9", "varga.d10"];
+    const ordered = [...personalityDiscriminators].sort((left, right) => {
+      const leftKey = rankedDiscriminatorKey(left);
+      const rightKey = rankedDiscriminatorKey(right);
+      const leftRank = preferred.findIndex((prefix) => leftKey.startsWith(prefix));
+      const rightRank = preferred.findIndex((prefix) => rightKey.startsWith(prefix));
+      const leftScore = leftRank < 0 ? 99 : leftRank;
+      const rightScore = rightRank < 0 ? 99 : rightRank;
+      return leftScore - rightScore;
+    });
+    for (const ranked of ordered) {
+      const key = rankedDiscriminatorKey(ranked);
+      if (!preferred.some((prefix) => key.startsWith(prefix))) continue;
+      if (key && askedKeys.has(key)) continue;
+      const candidate = followupFromRanked(ranked);
+      if (candidate.choice_frame) return candidate;
+    }
+    return null;
+  };
   const precisionStageFollowup = (): MethodFollowup | null => {
     if (stage === "lagna_frame") {
       return makeFollowup({
@@ -2534,6 +2623,9 @@ export function buildMethodFollowupPlan(input: {
     ? holdoutFollowupFor(input, declined)
     : null;
   if (!next) {
+    if (input.tieBreakRequested) {
+      next = firstRenderablePersonalityFollowup();
+    } else {
     const precisionCard = takeRenderableDistinguish(precisionStageFollowup());
     const datedPrecision = Boolean(
       precisionCard?.choice_frame && followupLocksDatedPeriod(precisionCard),
@@ -2557,6 +2649,7 @@ export function buildMethodFollowupPlan(input: {
           ...(input.closedCollectFocuses ?? []),
         ],
         input.remainingSplitTimes,
+        input.remainingCandidateCount,
       ))
     ) {
       // BUG-651: no yearless personality as the next discriminator.
@@ -2721,6 +2814,7 @@ export function buildMethodFollowupPlan(input: {
       });
     }
     }
+    }
   }
 
   if (next?.intent === "distinguish_candidates" && !next.choice_frame) {
@@ -2746,6 +2840,7 @@ export function buildMethodFollowupPlan(input: {
     } else if (
       meetsAcceptanceEventQuality(input.evidence)
       && datedPoolEmpty
+      && !input.tieBreakRequested
     ) {
       const targeted = targetedCollectFollowup(
         input.remainingLayers ?? [],
@@ -2755,8 +2850,9 @@ export function buildMethodFollowupPlan(input: {
           ...(input.closedCollectFocuses ?? []),
         ],
         input.remainingSplitTimes,
+        input.remainingCandidateCount,
       );
-      if (targeted) next = makeFollowup(targeted);
+      if (targeted) next = targeted;
       else if (pendingHoldout) next = makeFollowup(pendingHoldout, false);
     } else if (pendingHoldout) {
       next = makeFollowup(pendingHoldout, false);
@@ -2800,6 +2896,24 @@ export function buildMethodFollowupPlan(input: {
   };
 }
 
+export function tieBreakPersonalityFollowup(
+  input: Parameters<typeof buildMethodFollowupPlan>[0],
+): MethodFollowup | null {
+  const plan = buildMethodFollowupPlan({
+    ...input,
+    tieBreakRequested: true,
+    sessionOutcome: "discriminate_candidates",
+    candidatesSeparated: false,
+  });
+  const followup = plan.next_followup;
+  if (!followup?.choice_frame) return null;
+  const kind = followup.choice_kind ?? followup.choice_frame.choice_kind;
+  if (kind !== "varga_style") return null;
+  const key = followup.semantic_key ?? "";
+  if (!key.startsWith("varga.d9") && !key.startsWith("varga.d10")) return null;
+  return followup;
+}
+
 export function projectRectificationChoiceCard(
   input: Parameters<typeof buildMethodFollowupPlan>[0] & {
     selectionAllowed?: boolean;

frontend/src/lib/rectification-agentic/v9/refresh-discriminator-probes.ts

@@ -14,7 +14,6 @@ import {
   toEngineEvents,
 } from "./engine-client.ts";
 import { refinementFromDecisionReceipt, type DiscriminatingEventProbe } from "./refinement-packet.ts";
-import { isTargetedCollectDeclined } from "./collection-question-pool.ts";
 import { trainingScoreableGate } from "./evidence-model.ts";
 import {
   evidenceLedgerFingerprint,
@@ -363,9 +362,6 @@ function shouldRefreshDatedPool(input: {
     return false;
   }
   if (!trainingScoreableGate(input.dossier.evidence).open) return false;
-  if (isTargetedCollectDeclined(input.dossier.conversationSummary.declinedSkippedTopics)) {
-    return false;
-  }
   return true;
 }
 

frontend/src/lib/rectification-agentic/v9/server-focus.ts

@@ -99,6 +99,12 @@ export function expectedAnswerSchemaFor(
     candidate_split_hash: followup.candidate_split_hash ?? null,
     choice_kind: frame.choice_kind ?? followup.choice_kind ?? "existence",
     scoring: frame.scoring,
+    ...(followup.collection_key?.startsWith("collect:targeted:")
+      ? {
+        targeted_collect: true,
+        collect_kind: followup.kind_hint ?? null,
+      }
+      : {}),
     ...(followup.block_periods ? { block_periods: followup.block_periods } : {}),
     ...(followup.widen_windows ? { widen_windows: followup.widen_windows } : {}),
   };
@@ -107,11 +113,12 @@ export function expectedAnswerSchemaFor(
     previousInferenceFromReceipt(receipt),
     refinementFromDecisionReceipt(receipt).nakshatra_boundary,
   );
-  if (decisionReceipt?.inference_state !== undefined && !state) return null;
   const verifyOnly = followup.intent === "reverse_verify" || followup.intent === "out_of_sample_check";
+  const targetedCollect = Boolean(followup.collection_key?.startsWith("collect:targeted:"));
+  if (!targetedCollect && decisionReceipt?.inference_state !== undefined && !state) return null;
   const stamped = stampChoiceSchemaWithProbe(
     schema,
-    verifyOnly ? null : state,
+    verifyOnly || targetedCollect ? null : state,
     questionId,
     {
       semantic_key: followup.semantic_key,
@@ -121,7 +128,7 @@ export function expectedAnswerSchemaFor(
   if (typeof followup.probe_year === "number" && followup.probe_year > 0) {
     stamped.probe_year = followup.probe_year;
   }
-  if (verifyOnly) return stamped;
+  if (verifyOnly || targetedCollect) return stamped;
   return state && stamped.scoring !== false && !schemaProbeId(stamped) ? null : stamped;
 }
 
@@ -601,9 +608,14 @@ async function persistServerOwnedFocusCore(input: {
     const result = await setV10ConversationFocus(input.accounting, input.userId, input.caseId, {
       questionId,
       intent: followup.intent,
-      targetEvidenceId: null,
-      targetDomain: followup.domain,
-      targetKind: null,
+      targetEvidenceId: followup.date_reliability_evidence_id ?? null,
+      targetDomain: followup.intent === "collect_method_evidence"
+        ? persistableFocusDomain(followup.domain)
+          ?? persistableFocusDomain(collectQuestionDomain(followup.domain))
+        : followup.domain,
+      targetKind: followup.intent === "collect_method_evidence"
+        ? collectFocusTargetKind(followup)
+        : null,
       expectedAnswerSchema: schema,
       askedTurnId: input.askedTurnId ?? null,
     });

frontend/tests/agent-voice-copy-contract.test.ts

@@ -17,7 +17,7 @@ import {
   openingSpokenBody,
   stopReasonPrefix,
 } from "../src/lib/rectification-agentic/user-copy.ts";
-import { COLLECT_FLOW_BANNED_PHRASES } from "../src/lib/rectification-agentic/v9/collection-question-pool.ts";
+import { COLLECT_FLOW_BANNED_PHRASES, SPLIT_ENDPOINT_PHRASE } from "../src/lib/rectification-agentic/v9/collection-question-pool.ts";
 import { MACHINE_VOICE_LEXICON } from "../src/lib/rectification-agentic/v9/agent-voice-lexicon.ts";
 import { attachQuestionsToTurns } from "../src/lib/rectification-agentic/v9/turn-question.ts";
 import { CASE_ID, FOCUS_ID, TURN_ID } from "./rectification-v9-test-support.ts";
@@ -344,4 +344,14 @@ test("range delivery copy bans 这次给出 / 最终 and titles 目前范围", (
   assert.match(card, /rangeDeliveryTitle/);
   assert.doesNotMatch(card, /这次给出|最终/);
   assert.match(card, /narrow_hint/);
+  assert.match(card, /rangeDeliveryTieBreakEntry/);
+  assert.ok(listUserVisibleCopy().includes(RECTIFICATION_USER_COPY.rangeDeliveryTieBreakEntry));
+  assert.ok(listUserVisibleCopy().includes(RECTIFICATION_USER_COPY.rangeDeliveryTieBreakAck));
+  assert.doesNotMatch(listUserVisibleCopy().join("\n"), SPLIT_ENDPOINT_PHRASE);
+  const pool = readFileSync(
+    new URL("../src/lib/rectification-agentic/v9/collection-question-pool.ts", import.meta.url),
+    "utf8",
+  );
+  assert.match(pool, /SPLIT_ENDPOINT_PHRASE/);
+  assert.doesNotMatch(pool, /能把 04:51 和 05:06 分开/);
 });

frontend/tests/rectification-adopt-narration-20260904.test.ts

@@ -826,7 +826,7 @@ test("three adopt entry points call the model once on first ready_to_adopt and n
   const source = readFileSync(new URL("../src/lib/rectification-agentic/v9/answer-choice.ts", import.meta.url), "utf8");
   const persistFn = source.slice(
     source.indexOf("export async function persistNextInterviewAfterChoice"),
-    source.indexOf("async function persistFocusAfterChoice"),
+    source.indexOf("export async function requestTieBreakPersonality"),
   );
   assert.doesNotMatch(persistFn, /decideFromDossier\(/);
 

frontend/tests/rectification-agentic-entry.test.ts

@@ -57,6 +57,11 @@ const caseRoute = readFileSync(
   new URL("../src/app/api/rectification/cases/[caseId]/route.ts", import.meta.url),
   "utf8",
 );
+const caseDossierResponse = readFileSync(
+  new URL("../src/lib/rectification-agentic/v9/case-dossier-response.ts", import.meta.url),
+  "utf8",
+);
+const caseProjection = `${caseRoute}\n${caseDossierResponse}`;
 const adoptSkillRoute = readFileSync(
   new URL("../src/app/api/rectification/cases/[caseId]/adopt-skill/route.ts", import.meta.url),
   "utf8",
@@ -653,17 +658,17 @@ test("time-selection cards use server adoption state and stay mutually exclusive
   assert.doesNotMatch(chat, /send\("message", choiceCardUserMessage/);
   assert.doesNotMatch(chat, /send\("message", choiceCard\?\.stop_message/);
   assert.doesNotMatch(chat, /choiceCardUserMessage/);
-  assert.match(caseRoute, /choice_card: choiceCardFromCaseDossier/);
+  assert.match(caseProjection, /choice_card: choiceCardFromCaseDossier/);
   assert.match(chat, /choiceCard\s+&& choiceCard\.focus_id === question\.focus_id/);
   assert.match(chat, /disabled=\{!liveQuestion\}/);
-  assert.match(caseRoute, /current_question: projectCurrentQuestion/);
-  assert.match(caseRoute, /overlayPublicDecision/);
-  assert.match(caseRoute, /const fields = publicDecisionFields\(decision\)/);
-  // 原值: interview: fields
-  // 新值: interview: { ...fields, collection_progress }
-  // 原因: GET 投影带上采集进度数字，没有 gate 时为 null。
-  assert.match(caseRoute, /interview: \{\s*\.\.\.fields,/);
-  assert.match(caseRoute, /collection_progress: collectionProgressFromReceipt/);
+  assert.match(caseProjection, /current_question: projectCurrentQuestion/);
+  assert.match(caseProjection, /overlayPublicDecision/);
+  assert.match(caseProjection, /const fields = publicDecisionFields\(decision\)/);
+  // 原值: 断言读 cases/[caseId]/route.ts 的 interview 投影
+  // 新值: 断言读 case-dossier-response.ts（GET 仍调用 dossierResponse）
+  // 原因: Next App Router 不允许 route.ts 导出非 HTTP handler。
+  assert.match(caseProjection, /interview: \{\s*\.\.\.fields,/);
+  assert.match(caseProjection, /collection_progress: collectionProgressFromReceipt/);
   assert.doesNotMatch(chat, /已完成验证/);
   assert.doesNotMatch(messageLoop, /className="rectification-snapshot"/);
 });
@@ -847,6 +852,6 @@ test("legacy Skill adoption is an explicit server-owned route and case refresh e
   assert.match(upgradeSkillRoute, /upgradeRectificationSkill/);
   assert.doesNotMatch(upgradeSkillRoute, /adoptLegacyRectificationSkill/);
   assert.match(caseRoute, /loadV9CaseSkillIdentityStatus/);
-  assert.match(caseRoute, /skill_identity_status/);
-  assert.match(caseRoute, /requires_skill_adoption/);
+  assert.match(caseProjection, /skill_identity_status/);
+  assert.match(caseProjection, /requires_skill_adoption/);
 });

frontend/tests/rectification-answer-choice.test.ts

@@ -1156,8 +1156,11 @@ test("failed card persist still leaves a spoken collect next step", () => {
   );
   const nextInterview = source.slice(
     source.indexOf("async function persistNextInterviewAfterChoice"),
-    source.indexOf("async function persistFocusAfterChoice"),
+    source.indexOf("export async function requestTieBreakPersonality"),
   );
+  // 原值: 切片到 persistFocusAfterChoice（下一函数）
+  // 新值: 切片到 requestTieBreakPersonality
+  // 原因: BUG-663 在 persistNextInterviewAfterChoice 后插入了参考题入口函数
   assert.doesNotMatch(nextInterview, /loadV9CaseCompute/);
 });
 

frontend/tests/rectification-collect-direction-20260904.test.ts

@@ -329,7 +329,7 @@ test("persistNextInterviewAfterChoice after family denial asks the invite, not o
   );
   const persistFn = source.slice(
     source.indexOf("export async function persistNextInterviewAfterChoice"),
-    source.indexOf("async function persistFocusAfterChoice"),
+    source.indexOf("export async function requestTieBreakPersonality"),
   );
   assert.doesNotMatch(persistFn, /decideFromDossier\(/);
 
@@ -547,9 +547,12 @@ test("turn decision and GET interview expose collection_progress 2/3/1 or null",
   assert.ok(withoutGate);
   assert.equal(projectTurnDecision(withoutGate).collection_progress, null);
   const route = readFileSync(
-    new URL("../src/app/api/rectification/cases/[caseId]/route.ts", import.meta.url),
+    new URL("../src/lib/rectification-agentic/v9/case-dossier-response.ts", import.meta.url),
     "utf8",
   );
+  // 原值: 断言读 cases/[caseId]/route.ts
+  // 新值: 断言读 case-dossier-response.ts
+  // 原因: Next App Router 不允许 route.ts 导出非 HTTP handler。
   assert.match(route, /collection_progress: collectionProgressFromReceipt/);
   const tools = readFileSync(
     new URL("../src/mastra/rectification-v9-tools.ts", import.meta.url),

frontend/tests/rectification-collect-stall.test.ts

@@ -458,8 +458,11 @@ function rpcDossier(decision: DecisionDossier, activeFocus?: Record<string, unkn
   });
 }
 
-test("skill version is 10.0.24 after the collect-semantics bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+test("skill version is 10.0.25 after the targeted-collect-cards bump", () => {
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 });
 
 test("revision 5 with uncovered relatives asks the dated family collect, not a yearless D12 card", () => {

frontend/tests/rectification-collection-question-pool.test.ts

@@ -3,10 +3,12 @@ import test from "node:test";
 
 import {
   COLLECT_FLOW_BANNED_PHRASES,
+  SPLIT_ENDPOINT_PHRASE,
   anchoredFollowups,
   collectionQuestionPool,
   inviteDeclined,
   moreCollectHint,
+  pendingTargetedYearDomain,
   preciseGapNarration,
   rangeNarrowHint,
   remainingSplitLayers,
@@ -14,7 +16,7 @@ import {
 } from "../src/lib/rectification-agentic/v9/collection-question-pool.ts";
 import { USER_COLLECT_QUESTION, USER_COLLECT_QUESTION_RETRY } from "../src/lib/rectification-agentic/user-copy.ts";
 import { isOccupationCollectFocus } from "../src/lib/rectification-agentic/v9/evidence-model.ts";
-import { followupFromPoolItem } from "../src/lib/rectification-agentic/v9/method-followup.ts";
+import { followupFromPoolItem, targetedCollectFollowup } from "../src/lib/rectification-agentic/v9/method-followup.ts";
 import { stableFollowupQuestionId } from "../src/lib/rectification-agentic/v9/server-focus.ts";
 
 const educationStart = {
@@ -156,25 +158,39 @@ test("targeted collect names remaining split layers without inferred years", ()
     ],
     activeTimes: ["04:48", "04:53", "05:06", "05:07"],
   });
-  const pool = targetedCollectPool(
-    layers,
-    [educationStart, educationEnd, career],
-    [],
-    ["04:48", "05:07"],
-  );
-  assert.equal(pool.length, 1);
+  const evidence = [educationStart, educationEnd, career];
+  const splitTimes = ["04:48", "05:07"] as const;
+  const pool = targetedCollectPool(layers, evidence, [], splitTimes, 4);
+  // 原值: pool.length === 1，prompt 含「能把 04:48 和 05:07 分开」
+  // 新值: 剩余未覆盖线各一张存在卡；题干是「有没有」，剩余候选句走 remainingLine
+  // 原因: BUG-661 / BUG-662 逐条点选 + 不再用范围端点当候选
+  assert.equal(pool.map((item) => item.domain).join(","), "relationship,relocation,family,finance");
   assert.equal(pool[0]?.kind, "targeted");
   assert.equal(pool[0]?.key, "collect:targeted:relationship");
-  assert.match(pool[0]?.prompt ?? "", /能把 04:48 和 05:07 分开/);
+  assert.equal(pool[0]?.prompt, "结过婚或订过婚吗？");
+  assert.doesNotMatch(pool.map((item) => item.prompt).join("\n"), SPLIT_ENDPOINT_PHRASE);
   assert.doesNotMatch(pool[0]?.prompt ?? "", /1997|2012|推算/);
+  assert.match(pool[0]?.remainingLine ?? "", /现在还剩 04:48–05:07 里 4 个候选，能把它们分开的是这几条线/);
   assert.ok((pool[0]?.examples?.length ?? 0) >= 2);
-  const followup = followupFromPoolItem(pool[0]!);
-  assert.equal(stableFollowupQuestionId(followup), "collect:targeted:relationship");
-  assert.match(rangeNarrowHint(layers, [educationStart, educationEnd, career], [], ["04:48", "05:07"]), /还能再收窄：如果记得/);
-  const declined = targetedCollectPool(layers, [educationStart, educationEnd, career], [{
+  const followup = targetedCollectFollowup(layers, evidence, [], splitTimes, 4);
+  assert.equal(followup?.collection_key, "collect:targeted:relationship");
+  assert.equal(followup?.choice_frame?.scoring, false);
+  assert.equal(followup?.choice_kind, "existence");
+  assert.match(followup?.spoken_prompt ?? "", /现在还剩 04:48–05:07 里 4 个候选/);
+  assert.doesNotMatch(followup?.spoken_prompt ?? "", SPLIT_ENDPOINT_PHRASE);
+  assert.equal(stableFollowupQuestionId(followupFromPoolItem(pool[0]!)), "collect:targeted:relationship");
+  assert.match(rangeNarrowHint(layers, evidence, [], splitTimes, 4), /现在还剩 04:48–05:07 里 4 个候选/);
+  assert.match(rangeNarrowHint(layers, evidence, [], splitTimes, 4), /还能再收窄：如果记得/);
+  const declinedRelationship = targetedCollectPool(layers, evidence, [{
     questionId: "collect:targeted:relationship",
     status: "declined",
     target_kind: "targeted:relationship",
-  }]);
-  assert.equal(declined.length, 0);
+  }], splitTimes, 4);
+  assert.ok(declinedRelationship.length >= 1);
+  assert.notEqual(declinedRelationship[0]?.domain, "relationship");
+  assert.equal(pendingTargetedYearDomain([{
+    questionId: "collect:targeted:relationship",
+    status: "resolved",
+    target_kind: "targeted:relationship",
+  }], evidence), "relationship");
 });

frontend/tests/rectification-confirmation-gate.test.ts

@@ -360,7 +360,10 @@ test("holdout not_ready forbids unique-minute copy and still blocks confirm", as
   assert.match(agentSource, /不得宣称唯一出生分钟/);
   assert.doesNotMatch(agentSource, /±2 分钟/);
   assert.equal(PUBLIC_RECTIFICATION_TOOLS.length, 14);
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 
   const accounting = fakeAccounting({
     ...receiptHandlers,

frontend/tests/rectification-decision-authority.test.ts

@@ -1351,7 +1351,10 @@ test("interview, choice, refresh and next-action all call the same reducer", ()
   const followup = readSource("../src/lib/rectification-agentic/v9/method-followup.ts");
   const tools = readSource("../src/mastra/rectification-v9-tools.ts");
   const separation = readSource("../src/lib/rectification-agentic/core/candidate-separation.ts");
-  const caseRoute = readSource("../src/app/api/rectification/cases/[caseId]/route.ts");
+  const caseRoute = [
+    readSource("../src/app/api/rectification/cases/[caseId]/route.ts"),
+    readSource("../src/lib/rectification-agentic/v9/case-dossier-response.ts"),
+  ].join("\n");
   assert.match(interview, /decideFromDossier\(/);
   assert.match(refresh, /decideFromDossier\(/);
   assert.match(choice, /decideAfterInferenceChange\(/);

frontend/tests/rectification-delivery-report-facts.test.ts

@@ -249,12 +249,18 @@ test("public house table follows the inference representative minute", () => {
   assert.match(source, /natal_recast_pre_inference: _preNatal/);
 });
 
-test("skill 10.0.24 forbids computing varga signs from transition times", () => {
+test("skill 10.0.25 forbids computing varga signs from transition times", () => {
   const skillDir = fileURLToPath(new URL("../../skills/jyotish-birth-time-rectification", import.meta.url));
   const skill = readFileSync(`${skillDir}/SKILL.md`, "utf8");
   const comparison = readFileSync(`${skillDir}/references/candidate-comparison.md`, "utf8");
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
-  assert.match(skill, /^version: 10\.0\.24$/m);
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.match(skill, /^version: 10\.0\.25$/m);
   assert.match(skill, new RegExp(SKILL_SIGN_SENTENCE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
   assert.match(comparison, new RegExp(SKILL_SIGN_SENTENCE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
 });

frontend/tests/rectification-eight-method.test.ts

@@ -943,6 +943,25 @@ test("read-case follows method plan and keeps D9/D10 type tables when SQL missin
       },
     }),
     get_agentic_rectification_case_compute: () => computeFixture(),
+    set_agentic_rectification_conversation_focus: (_fn, args) => ({
+      // 原值: read-case 不落焦点（定向补事是口述，persist 失败即 skipped）
+      // 新值: 存在题卡必须落 choice focus
+      // 原因: BUG-661 定向补事改为点选
+      focus: {
+        id: 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-12T10:00:06.000Z",
+        resolved_at: null,
+      },
+      idempotent: false,
+    }),
   });
   const tools = createRectificationV9Tools({
     userId: USER_ID,
@@ -954,7 +973,13 @@ test("read-case follows method plan and keeps D9/D10 type tables when SQL missin
     execute(input: unknown): Promise<{
       conversation_summary: { missing_evidence_categories: string[] };
       method_followup_plan: {
-        next_followup: { method_id: string; domain: string | null; intent?: string; kind_hint?: string } | null;
+        next_followup: {
+          method_id: string;
+          domain: string | null;
+          intent?: string;
+          kind_hint?: string;
+          choice_frame?: { scoring?: boolean; prompt?: string } | null;
+        } | null;
         deferred_followup: { method_id: string; domain: string | null } | null;
         session_outcome: string;
       };
@@ -984,7 +1009,11 @@ test("read-case follows method plan and keeps D9/D10 type tables when SQL missin
   assert.ok(projection.latest_result.engine_indistinguishable_width_minutes >= 25);
   assert.equal(projection.latest_result.window_scan?.d9_candidates_differ, true);
   assert.doesNotMatch(JSON.stringify(projection), UNIQUE_MINUTE_COPY);
-  assert.doesNotMatch(JSON.stringify(projection), /A\/B\/C\/D/);
+  // 原值: 整份投影不得出现 A/B/C/D（定向补事是口述）
+  // 新值: 存在题卡带 choice_frame，不计分
+  // 原因: BUG-661 定向补事改为逐条点选
+  assert.equal(projection.method_followup_plan.next_followup?.choice_frame?.scoring, false);
+  assert.match(projection.method_followup_plan.next_followup?.choice_frame?.prompt ?? "", /结过婚|订过婚/);
 });
 
 test("accepted batch evidence resolves a spoken collect focus before the next question", async () => {
@@ -1416,9 +1445,12 @@ test("rescore failure does not fail the evidence write", async () => {
   assert.ok(result.rescore.error_code);
 });
 
-test("public tool surface stays at 14 and new cases bind 10.0.24", () => {
+test("public tool surface stays at 14 and new cases bind 10.0.25", () => {
   assert.equal(PUBLIC_RECTIFICATION_TOOLS.length, 14);
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
   const deprecated = resolveExactSkillPackage(
     "jyotish-birth-time-rectification",
     "10.0.2",

frontend/tests/rectification-exhaustion-exit-20260906.test.ts

@@ -591,8 +591,11 @@ function warnLines(run: () => Promise<unknown> | unknown) {
   }).then((result) => ({ result, lines }));
 }
 
-test("skill version is 10.0.24 after the collect-semantics bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+test("skill version is 10.0.25 after the targeted-collect-cards bump", () => {
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 });
 
 test("USER_COLLECT_QUESTION no longer has an other fallback", () => {

frontend/tests/rectification-host-fallback.test.ts

@@ -96,7 +96,7 @@ test("year fallback is gone; only explicit evidence expectedWrite triggers the g
 
 test("case snapshot receipts expose host_fallback origin from the durable phase", () => {
   const route = readFileSync(
-    new URL("../src/app/api/rectification/cases/[caseId]/route.ts", import.meta.url),
+    new URL("../src/lib/rectification-agentic/v9/case-dossier-response.ts", import.meta.url),
     "utf8",
   );
   assert.match(route, /answer_origin: "host_fallback"/);

frontend/tests/rectification-ingest-p0.test.ts

@@ -213,9 +213,15 @@ test("read-case evidence context keeps day labels and confirm does not rewrite d
   assert.equal("p_occurred_from" in confirmCall.args, false);
 });
 
-test("new-case skill identity is 10.0.24 and the prompt prefers batch ingest", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
-  assert.match(skill, /^version: 10\.0\.24$/m);
+test("new-case skill identity is 10.0.25 and the prompt prefers batch ingest", () => {
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.match(skill, /^version: 10\.0\.25$/m);
   assert.match(skill, /不要对同一句用户消息里的多件事件逐条 propose\+confirm/);
   assert.match(agentSource, /新事件走 rectification-record-evidence-batch/);
   assert.doesNotMatch(agentSource, /分别调用 rectification-propose-evidence 和 rectification-confirm-evidence/);

frontend/tests/rectification-occupation-coverage-exit.test.ts

@@ -184,8 +184,11 @@ const CANDIDATE_IDS = [
   "88888888-8888-4888-8888-888888888882",
 ] as const;
 
-test("skill version is 10.0.24 after the collect-semantics bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+test("skill version is 10.0.25 after the targeted-collect-cards bump", () => {
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 });
 
 test("nineteen-row ledger opens the training gate with four scoreable domains", () => {

frontend/tests/rectification-probe-pool-exhausted-20260911.test.ts

@@ -367,6 +367,19 @@ const TARGETED_DECLINED = {
   target_kind: "targeted:family",
 } as const;
 
+const TARGETED_ALL_DECLINED = [
+  "relationship",
+  "relocation",
+  "family",
+  "finance",
+].map((domain) => ({
+  target_domain: domain,
+  status: "declined",
+  intent: "collect_method_evidence",
+  questionId: `collect:targeted:${domain}`,
+  target_kind: `targeted:${domain}`,
+}));
+
 function accidentDossier(answeredCount: number, extra: {
   activeFocus?: ReturnType<typeof activeFocusFixture> | null;
   refreshCount?: number;
@@ -611,11 +624,16 @@ test("T0: sixth dated answer must refresh or targeted-collect, not deliver a car
   // 原因: BUG-654 带年月池空不等于结束
   assert.equal(decision.nextAction, "ask_fact_collection", decision.nextAction);
   assert.equal(decision.canOfferRange, false);
-  assert.equal(plan.next_followup?.choice_kind, undefined);
+  assert.equal(plan.next_followup?.choice_kind, "existence");
   assert.notEqual(plan.next_followup?.choice_kind, "varga_style");
   assert.notEqual(plan.next_followup?.source, "nakshatra_boundary");
-  assert.match(plan.next_followup?.collection_key ?? "", /collect:targeted:/);
-  assert.match(plan.next_followup?.spoken_prompt ?? "", /还能把|能把 04:48 和 05:07 分开/);
+  assert.match(plan.next_followup?.collection_key ?? "", /collect:targeted:relationship/);
+  // 原值: spoken_prompt 含「能把 04:48 和 05:07 分开」
+  // 新值: 题干「结过婚或订过婚吗？」；spoken_prompt 说剩余候选个数
+  // 原因: BUG-661 / BUG-662
+  assert.equal(plan.next_followup?.choice_frame?.prompt, "结过婚或订过婚吗？");
+  assert.match(plan.next_followup?.spoken_prompt ?? "", /现在还剩 04:48–05:07 里 6 个候选/);
+  assert.doesNotMatch(plan.next_followup?.spoken_prompt ?? "", /能把 04:48 和 05:07 分开/);
   const idleAccounting = idleHandlers(dossier);
   const { result: idle } = await warnLines(() => persistNextInterviewIfIdle({
     accounting: idleAccounting.client,
@@ -625,9 +643,10 @@ test("T0: sixth dated answer must refresh or targeted-collect, not deliver a car
   const persisted = idle as Awaited<ReturnType<typeof persistNextInterviewIfIdle>>;
   const host = persisted.hostNarration ?? "";
   assert.ok(host.trim(), "answer/idle transaction must leave a carrier");
-  assert.match(host, /家里|收入|搬家|感情|还能再收窄|添丁|住院/);
+  assert.match(host, /家里|收入|搬家|感情|还能再收窄|添丁|住院|结过婚|现在还剩/);
   assert.doesNotMatch(host, /这次给出|最终|做不了|才会变|没有拿到下一个问题/);
-  assert.equal(persisted.choiceReady, false);
+  assert.doesNotMatch(host, /能把 04:48 和 05:07 分开/);
+  assert.equal(persisted.choiceReady, true);
   const focusWrite = idleAccounting.calls.find((item) => item.fn === "set_agentic_rectification_conversation_focus");
   assert.ok(focusWrite, "targeted collect must become the active focus");
   assert.match(String(focusWrite.args.p_question_id ?? ""), /collect:targeted:/);
@@ -635,6 +654,9 @@ test("T0: sixth dated answer must refresh or targeted-collect, not deliver a car
     (FOCUS_TARGET_KIND_CHECK as readonly string[]).includes(String(focusWrite.args.p_target_kind ?? "")),
     String(focusWrite.args.p_target_kind),
   );
+  const schema = focusWrite.args.p_expected_answer_schema as Record<string, unknown> | undefined;
+  assert.equal(schema?.targeted_collect, true);
+  assert.equal((schema?.choice as { prompt?: string } | undefined)?.prompt, "结过婚或订过婚吗？");
   for (const phrase of COLLECT_FLOW_BANNED_PHRASES) {
     if (phrase === "领域") continue;
     assert.equal(host.includes(phrase), false, phrase);
@@ -740,7 +762,26 @@ test("T3: skipped persist still leaves a non-empty carrier; 没有了 delivers t
     refreshCount: 1,
     declinedTopics: [TARGETED_DECLINED],
   });
-  const delivered = decideFromDossier(declined, { birthDate: "1997-08-08" });
+  const stillAsking = decideFromDossier(declined, { birthDate: "1997-08-08" });
+  // 原值: 拒答任意一条定向补事即出范围卡
+  // 新值: 只关掉 family 这条线后仍问剩余线
+  // 原因: BUG-661 逐条点选
+  assert.equal(stillAsking.nextAction, "ask_fact_collection", stillAsking.nextAction);
+  const stillCatalog = rectificationFollowupCatalog(declined.latestResult, declined.evidence);
+  assert.ok(
+    targetedCollectPool(
+      stillCatalog.remainingLayers,
+      declined.evidence,
+      declined.conversationSummary.declinedSkippedTopics,
+      stillCatalog.remainingSplitTimes,
+      stillCatalog.remainingCandidateCount,
+    ).length > 0,
+  );
+  const allDeclined = accidentDossier(6, {
+    refreshCount: 1,
+    declinedTopics: TARGETED_ALL_DECLINED,
+  });
+  const delivered = decideFromDossier(allDeclined, { birthDate: "1997-08-08" });
   assert.ok(
     delivered.nextAction === "offer_provisional_range"
       || delivered.nextAction === "ready_to_adopt"
@@ -748,13 +789,14 @@ test("T3: skipped persist still leaves a non-empty carrier; 没有了 delivers t
     delivered.nextAction,
   );
   assert.equal(delivered.canOfferRange, true);
-  const catalog = rectificationFollowupCatalog(declined.latestResult, declined.evidence);
+  const catalog = rectificationFollowupCatalog(allDeclined.latestResult, allDeclined.evidence);
   assert.equal(
     targetedCollectPool(
       catalog.remainingLayers,
-      declined.evidence,
-      declined.conversationSummary.declinedSkippedTopics,
+      allDeclined.evidence,
+      allDeclined.conversationSummary.declinedSkippedTopics,
       catalog.remainingSplitTimes,
+      catalog.remainingCandidateCount,
     ).length,
     0,
   );
@@ -767,7 +809,7 @@ test("T4: exhausted refresh and declined targeted collect titles the card 目前
   resetRefreshDiscriminatorProbesForTests();
   const dossier = accidentDossier(6, {
     refreshCount: 1,
-    declinedTopics: [TARGETED_DECLINED],
+    declinedTopics: TARGETED_ALL_DECLINED,
   });
   const decision = decideFromDossier(dossier, { birthDate: "1997-08-08" });
   assert.ok(
@@ -792,7 +834,9 @@ test("T4: exhausted refresh and declined targeted collect titles the card 目前
   const title = `${RECTIFICATION_USER_COPY.rangeDeliveryTitle} ${delivery.range?.[0]}–${delivery.range?.[1]}（对照了 ${delivery.event_count} 件经历）`;
   assert.match(title, /^目前范围 04:48–05:07（对照了 4 件经历）$/);
   assert.doesNotMatch(title, /这次给出|最终|结束| · /);
+  assert.match(delivery.narrow_hint ?? "", /现在还剩 04:48–05:07 里 6 个候选/);
   assert.match(delivery.narrow_hint ?? "", /还能再收窄：如果记得/);
+  assert.doesNotMatch(delivery.narrow_hint ?? "", /能把 04:48 和 05:07 分开/);
   assert.doesNotMatch(delivery.narrow_hint ?? "", /这次给出|最终/);
   const publicAction = publicNextAction(decision);
   assert.equal(publicAction.can_offer_range, true);

frontend/tests/rectification-question-in-message.test.ts

@@ -53,6 +53,8 @@ function choiceSchema(prompt: string) {
 const chat = readFileSync(new URL("../src/components/rectification-agentic-chat.tsx", import.meta.url), "utf8");
 const row = readFileSync(new URL("../src/components/chat-message-row.tsx", import.meta.url), "utf8");
 const casesRoute = readFileSync(new URL("../src/app/api/rectification/cases/[caseId]/route.ts", import.meta.url), "utf8");
+const caseDossierResponse = readFileSync(new URL("../src/lib/rectification-agentic/v9/case-dossier-response.ts", import.meta.url), "utf8");
+const caseProjection = `${casesRoute}\n${caseDossierResponse}`;
 const migration = readFileSync(
   new URL("../supabase/migrations/20260902010000_rectification_question_on_turn.sql", import.meta.url),
   "utf8",
@@ -71,9 +73,9 @@ test("question-on-turn migration adds asked_turn_id and answer_option", () => {
 });
 
 test("GET turns attach question by asked_turn_id and never by timestamps", () => {
-  assert.match(casesRoute, /attachQuestionsToTurns\(dossier\.turns, listed\.focuses/);
-  assert.match(casesRoute, /question: turn\.question/);
-  assert.match(casesRoute, /question_source: questionSourceFromFocusList\(listed\)/);
+  assert.match(caseProjection, /attachQuestionsToTurns\(dossier\.turns, listed\.focuses/);
+  assert.match(caseProjection, /question: turn\.question/);
+  assert.match(caseProjection, /question_source: questionSourceFromFocusList\(listed\)/);
   const attach = readFileSync(new URL("../src/lib/rectification-agentic/v9/turn-question.ts", import.meta.url), "utf8");
   assert.match(attach, /if \(!focus\.askedTurnId\) continue/);
   assert.doesNotMatch(attach, /askedAt|createdAt/);

frontend/tests/rectification-question-ownership.test.ts

@@ -511,7 +511,11 @@ test("list focuses RPC error marks GET questions unavailable and warns", async (
     console.warn = original;
   }
   const casesRoute = readFileSync(new URL("../src/app/api/rectification/cases/[caseId]/route.ts", import.meta.url), "utf8");
-  assert.match(casesRoute, /question_source: questionSourceFromFocusList\(listed\)/);
+  const caseDossierResponse = readFileSync(new URL("../src/lib/rectification-agentic/v9/case-dossier-response.ts", import.meta.url), "utf8");
+  // 原值: question_source 写在 route.ts
+  // 新值: 投影在 case-dossier-response.ts，GET 仍 return NextResponse.json(dossierResponse)
+  // 原因: Next App Router 不允许 route.ts 导出非 HTTP handler。
+  assert.match(caseDossierResponse, /question_source: questionSourceFromFocusList\(listed\)/);
   assert.match(casesRoute, /return NextResponse\.json\(dossierResponse/);
 });
 

frontend/tests/rectification-range-delivery-20260907.test.ts

@@ -261,6 +261,40 @@ test("range-delivery DOM is one button per row and adopted is aria-pressed", ()
   assert.match(source, /aria-pressed=\{adopted\}/);
 });
 
+test("range-delivery tie-break entry is absent until available and wired", () => {
+  const delivery = buildRangeDelivery({
+    inference: inference({ probes: [d9Probe()] }),
+    publicCandidates,
+    credibleRange: ["04:48", "04:59"],
+    representativeTime: "04:50",
+    tieBreakAvailable: true,
+  });
+  const hidden = renderToStaticMarkup(createElement(RectificationRangeDelivery, {
+    result: deliveryResult(delivery, "04:50"),
+    acceptingCandidateId: null,
+    readonly: false,
+    onAccept: () => undefined,
+  }));
+  assert.doesNotMatch(hidden, /再答两道参考题微调排序/);
+  const shown = renderToStaticMarkup(createElement(RectificationRangeDelivery, {
+    result: deliveryResult({ ...delivery, tie_break_available: true }, "04:50"),
+    acceptingCandidateId: null,
+    readonly: false,
+    onAccept: () => undefined,
+    onTieBreak: () => undefined,
+  }));
+  assert.match(shown, /再答两道参考题微调排序/);
+  assert.equal([...shown.matchAll(/<button\b/g)].length, delivery.columns.length + 1);
+  const skipped = renderToStaticMarkup(createElement(RectificationRangeDelivery, {
+    result: deliveryResult({ ...delivery, tie_break_available: false }, "04:50"),
+    acceptingCandidateId: null,
+    readonly: false,
+    onAccept: () => undefined,
+    onTieBreak: () => undefined,
+  }));
+  assert.doesNotMatch(skipped, /再答两道参考题微调排序/);
+});
+
 test("the range-delivery component does not render relative support or the old two actions", () => {
   const source = readFileSync(new URL("../src/components/rectification-range-delivery.tsx", import.meta.url), "utf8");
   const chat = readFileSync(new URL("../src/components/rectification-agentic-chat.tsx", import.meta.url), "utf8");

frontend/tests/rectification-range-offer-deadend.test.ts

@@ -424,8 +424,11 @@ function rpcDossier(decision: DecisionDossier) {
   });
 }
 
-test("skill version is 10.0.24 after the collect-semantics bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+test("skill version is 10.0.25 after the targeted-collect-cards bump", () => {
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 });
 
 test("pre-fix dual-exit constant is gone; range narration carries numbers and the disclaimer", () => {

frontend/tests/rectification-replay-20260911.test.ts

@@ -450,8 +450,11 @@ function warnLines(run: () => Promise<unknown> | unknown) {
   }).then((result) => ({ result, lines }));
 }
 
-test("skill version stays 10.0.24", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+test("skill version is 10.0.25", () => {
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 });
 
 test("two education events do not spawn birth-year reverse questions", () => {

frontend/tests/rectification-spoken-collect.test.ts

@@ -94,8 +94,11 @@ function collectPersistResult(overrides: {
   };
 }
 
-test("skill version is 10.0.24 after the collect-semantics bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+test("skill version is 10.0.25 after the targeted-collect-cards bump", () => {
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 });
 
 test("cases current_question remains the submit contract, not a visual slot", () => {
@@ -271,7 +274,7 @@ test("openQuestionFromPersistedFocus returns collect_spoken without making colle
   const answerChoice = readFileSync(new URL("../src/lib/rectification-agentic/v9/answer-choice.ts", import.meta.url), "utf8");
   const nextInterview = answerChoice.slice(
     answerChoice.indexOf("export async function persistNextInterviewAfterChoice"),
-    answerChoice.indexOf("async function persistFocusAfterChoice"),
+    answerChoice.indexOf("export async function requestTieBreakPersonality"),
   );
   assert.match(nextInterview, /isRenderableChoiceOpenQuestion/);
   assert.match(nextInterview, /hostNarration: open\.prompt/);

frontend/tests/rectification-step-state-20260906.test.ts

@@ -57,7 +57,7 @@ test("step state parser rejects forbidden certainty words", () => {
 
 test("chat does not render the step-state strip above the composer", () => {
   const chat = readFileSync(new URL("../src/components/rectification-agentic-chat.tsx", import.meta.url), "utf8");
-  const route = readFileSync(new URL("../src/app/api/rectification/cases/[caseId]/route.ts", import.meta.url), "utf8");
+  const route = readFileSync(new URL("../src/lib/rectification-agentic/v9/case-dossier-response.ts", import.meta.url), "utf8");
   assert.doesNotMatch(chat, /rectification-step-state/);
   assert.doesNotMatch(chat, /下一步：\{stepState\.next\}/);
   // 原值: 「再补一件经历」后 composer-meta 显示收集提示

frontend/tests/rectification-targeted-collect-cards-20260913.test.ts

@@ -0,0 +1,222 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { applyProbeOutcome } from "../src/lib/rectification-agentic/core/apply-probe-outcome.ts";
+import type { ConflictProbe } from "../src/lib/rectification-agentic/core/types.ts";
+import { RECTIFICATION_USER_COPY } from "../src/lib/rectification-agentic/user-copy.ts";
+import {
+  SPLIT_ENDPOINT_PHRASE,
+  pendingTargetedYearDomain,
+  targetedCollectExhausted,
+  targetedCollectPool,
+} from "../src/lib/rectification-agentic/v9/collection-question-pool.ts";
+import { rangeDeliveryForSnapshot } from "../src/lib/rectification-agentic/v9/divergence-panel.ts";
+import {
+  buildMethodFollowupPlan,
+  targetedCollectFollowup,
+  tieBreakPersonalityFollowup,
+} from "../src/lib/rectification-agentic/v9/method-followup.ts";
+
+const TIMES = ["04:48", "04:53", "05:06", "05:07"] as const;
+const LAYERS = ["d9", "d10", "d4", "d12", "d2", "d11"];
+const EVIDENCE = [
+  {
+    status: "confirmed",
+    domain: "education",
+    datePrecision: "month",
+    occurredFrom: "2016-09-01",
+    occurredTo: "2016-09-30",
+    eventKind: "education_start",
+    summary: "上大学",
+  },
+  {
+    status: "confirmed",
+    domain: "career",
+    datePrecision: "month",
+    occurredFrom: "2020-04-01",
+    occurredTo: null,
+    eventKind: "career_entry",
+    summary: "入职实习",
+  },
+] as const;
+
+function declined(domain: string) {
+  return {
+    target_domain: domain,
+    status: "declined" as const,
+    intent: "collect_method_evidence",
+    questionId: `collect:targeted:${domain}`,
+    target_kind: `targeted:${domain}`,
+  };
+}
+
+test("A resolves existence then asks the year; B/C close only that line", () => {
+  const first = targetedCollectFollowup(LAYERS, EVIDENCE, [], ["04:48", "05:07"], 4);
+  assert.equal(first?.collection_key, "collect:targeted:relationship");
+  assert.equal(first?.choice_frame?.scoring, false);
+  assert.equal(first?.choice_frame?.prompt, "结过婚或订过婚吗？");
+  assert.match(first?.spoken_prompt ?? "", /现在还剩 04:48–05:07 里 4 个候选/);
+  assert.doesNotMatch(first?.spoken_prompt ?? "", SPLIT_ENDPOINT_PHRASE);
+
+  const afterYes = targetedCollectFollowup(
+    LAYERS,
+    EVIDENCE,
+    [{ ...declined("relationship"), status: "resolved", questionId: "collect:targeted:relationship" }],
+    ["04:48", "05:07"],
+    4,
+  );
+  assert.equal(pendingTargetedYearDomain([{
+    ...declined("relationship"),
+    status: "resolved",
+  }], EVIDENCE), "relationship");
+  assert.equal(afterYes?.collection_key, "collect:targeted:relationship:year");
+  assert.equal(afterYes?.choice_frame, null);
+  assert.equal(afterYes?.spoken_prompt, "大概哪年几月？");
+
+  const afterNo = targetedCollectPool(
+    LAYERS,
+    EVIDENCE,
+    [declined("relationship")],
+    ["04:48", "05:07"],
+    4,
+  );
+  assert.equal(afterNo[0]?.domain, "relocation");
+  assert.equal(targetedCollectExhausted(LAYERS, EVIDENCE, [
+    declined("relationship"),
+    declined("relocation"),
+    declined("family"),
+    declined("finance"),
+  ], ["04:48", "05:07"], 4), true);
+});
+
+test("personality D9/D10 stay out of the scoring pool until the range-card opt-in", () => {
+  const ledger = [
+    ...EVIDENCE,
+    {
+      status: "confirmed",
+      domain: "relationship",
+      datePrecision: "month",
+      occurredFrom: "2024-05-01",
+      occurredTo: null,
+      eventKind: "relationship_start",
+      summary: "确定关系",
+    },
+    {
+      status: "confirmed",
+      domain: "family",
+      datePrecision: "month",
+      occurredFrom: "2016-05-01",
+      occurredTo: null,
+      eventKind: "family_event",
+      summary: "家里添丁",
+    },
+  ];
+  const d9 = {
+    probeId: "contrast:varga.d9.巨蟹座/狮子座",
+    candidateSetVersion: "04:48-05:07",
+    question: "亲密关系里更接近下面哪一种相处方式？",
+    expectedOutcomes: [
+      { outcomeId: "yes", supportsCandidateIds: ["04:53"], conflictsCandidateIds: ["05:06"] },
+      { outcomeId: "weak_yes", supportsCandidateIds: ["05:06"], conflictsCandidateIds: ["04:53"] },
+    ],
+    candidateSplitHash: "varga.d9.巨蟹座/狮子座",
+    informationGain: 1.4,
+    sourceFeatures: [{ technique: "D9", calculationResultId: null }],
+    domain: "relationship",
+    year: null,
+    semanticKey: "varga.d9.巨蟹座/狮子座",
+    choiceKind: "varga_style" as const,
+    styleOptions: [
+      { label: "相处里更在意照顾对方的感受", answerClass: "yes" as const, sign: "巨蟹座" },
+      { label: "习惯带头，也不排斥站到台前", answerClass: "weak_yes" as const, sign: "狮子座" },
+    ],
+  };
+  const planInput = {
+    evidence: ledger,
+    declinedTopics: ["relocation", "finance"].map(declined),
+    sessionOutcome: "discriminate_candidates" as const,
+    candidatesSeparated: false,
+    remainingLayers: LAYERS,
+    remainingSplitTimes: ["04:48", "05:07"] as const,
+    remainingCandidateCount: 4,
+    topCandidateTimes: [...TIMES],
+    contrastPacket: {
+      candidateSetVersion: "04:48-05:07",
+      vargaDifferences: [],
+      probes: [d9],
+    },
+  };
+  const auto = buildMethodFollowupPlan(planInput);
+  assert.notEqual(auto.next_followup?.choice_kind, "varga_style");
+  const opted = tieBreakPersonalityFollowup(planInput);
+  assert.equal(opted?.choice_kind, "varga_style");
+  assert.match(opted?.semantic_key ?? "", /varga\.d9/);
+  const d10: ConflictProbe = {
+    id: "probe:varga.d10.狮子座/处女座",
+    semantic_key: "varga.d10.狮子座/处女座",
+    candidate_split_hash: "04:48-05:07:varga.d10",
+    domain: "career",
+    year: 0,
+    question: "平时做事，你更接近下面哪一种？",
+    candidate_ids: [...TIMES],
+    expected_outcomes: [
+      { answer_class: "yes", supports: ["04:53"], conflicts: ["05:06"] },
+      { answer_class: "weak_yes", supports: ["05:06"], conflicts: ["04:53"] },
+      { answer_class: "no", supports: [], conflicts: [] },
+      { answer_class: "unsure", supports: [], conflicts: [] },
+    ],
+    information_gain: 0.9,
+    source: "varga_contrast",
+    choice_kind: "varga_style",
+    style_options: [
+      { label: "相处里更在意照顾对方的感受", answer_class: "yes", sign: "巨蟹座" },
+      { label: "习惯带头，也不排斥站到台前", answer_class: "weak_yes", sign: "狮子座" },
+    ],
+  };
+  const scored = applyProbeOutcome(
+    { "04:48": 10, "04:53": 12, "05:06": 11, "05:07": 10 },
+    d10,
+    "yes",
+  );
+  assert.equal(scored.kind, "tie_break");
+  assert.equal(scored.deltas["04:53"], 1);
+  assert.equal(scored.eliminated_ids.length, 0);
+  const delivery = rangeDeliveryForSnapshot({
+    candidates: TIMES.map((time, index) => ({
+      candidateId: `00000000-0000-4000-8000-${String(index + 1).padStart(12, "0")}`,
+      time,
+    })),
+    representativeTime: "04:53",
+    credibleRange: ["04:48", "05:07"],
+    evidence: ledger,
+    declinedTopics: ["relocation", "finance"].map(declined),
+    window_scan: {
+      scanned: true,
+      d9_lagna_count: 2,
+      d10_lagna_count: 2,
+      d9_candidates_differ: true,
+      d10_candidates_differ: true,
+      d4_candidates_differ: true,
+      d12_candidates_differ: true,
+      d2_candidates_differ: true,
+      d11_candidates_differ: true,
+    },
+  });
+  assert.match(delivery.narrow_hint ?? "", /还能再收窄/);
+  assert.doesNotMatch(delivery.narrow_hint ?? "", SPLIT_ENDPOINT_PHRASE);
+  assert.equal(delivery.tie_break_available, true);
+  const incompleteScan = rangeDeliveryForSnapshot({
+    candidates: TIMES.map((time, index) => ({
+      candidateId: `00000000-0000-4000-8000-${String(index + 1).padStart(12, "0")}`,
+      time,
+    })),
+    representativeTime: "04:53",
+    credibleRange: ["04:48", "05:07"],
+    window_scan: {
+      d9_candidates_differ: true,
+      d10_candidates_differ: false,
+    },
+  });
+  assert.equal(incompleteScan.tie_break_available, true);
+  assert.equal(RECTIFICATION_USER_COPY.rangeDeliveryTieBreakEntry, "再答两道参考题微调排序");
+});

frontend/tests/rectification-v10-focus-receipt-consistency.test.ts

@@ -145,7 +145,7 @@ test("persisted receipt selects the latest attempt and exposes latest terminal t
 });
 
 const caseRoute = readFileSync(
-  new URL("../src/app/api/rectification/cases/[caseId]/route.ts", import.meta.url),
+  new URL("../src/lib/rectification-agentic/v9/case-dossier-response.ts", import.meta.url),
   "utf8",
 );
 const chat = readFileSync(

frontend/tests/rectification-v9-agent.test.ts

@@ -98,11 +98,17 @@ test("system prompt carries only high-priority boundaries, never the method copy
 test("agent pins the dedicated rectification skill and its fixed version", () => {
   assert.equal(RECTIFICATION_V9_SKILL_NAME, "jyotish-birth-time-rectification");
   assert.equal(basename(RECTIFICATION_V9_SKILL_PATH), RECTIFICATION_V9_SKILL_NAME);
-  assert.ok(RECTIFICATION_V9_PACKAGE_PATH.endsWith("skills/jyotish-birth-time-rectification/versions/10.0.24"));
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.ok(RECTIFICATION_V9_PACKAGE_PATH.endsWith("skills/jyotish-birth-time-rectification/versions/10.0.25"));
   assert.notEqual(RECTIFICATION_V9_SKILL_PATH, RECTIFICATION_V9_PACKAGE_PATH);
   assert.equal(realpathSync(RECTIFICATION_V9_SKILL_PATH), RECTIFICATION_V9_PACKAGE_PATH);
   assert.equal(RECTIFICATION_SKILL_NAME, "jyotish-birth-time-rectification");
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 });
 
 test("step budgets are bounded per action with a hard ceiling", () => {

frontend/tests/rectification-v9-contracts.test.ts

@@ -95,9 +95,15 @@ test("terminal transitions are one-way and evidence writes stop at terminal", ()
 
 test("the active rectification skill pins the v10 identity and lives in the right directory", () => {
   assert.equal(RECTIFICATION_SKILL_NAME, "jyotish-birth-time-rectification");
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
   assert.match(skill, /^---\nname: jyotish-birth-time-rectification/m);
-  assert.match(skill, /^version: 10\.0\.24$/m);
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.match(skill, /^version: 10\.0\.25$/m);
   assert.match(skill, /至多一个主问题且唯一来源：[\s\S]*不得自行提出、复述、改写或预告问题/);
   for (const reference of references) {
     const content = readFileSync(`${skillDirectory}/references/${reference}`, "utf8");
@@ -236,7 +242,10 @@ test("shouldStartOpening is server-owned: only freshly created never-started cas
 });
 
 test("case snapshot includes step_state without a composer strip", () => {
-  const route = readFileSync(new URL("../src/app/api/rectification/cases/[caseId]/route.ts", import.meta.url), "utf8");
+  // 原值: 断言读 cases/[caseId]/route.ts
+  // 新值: 断言读 case-dossier-response.ts
+  // 原因: Next App Router 不允许 route.ts 导出非 HTTP handler。
+  const route = readFileSync(new URL("../src/lib/rectification-agentic/v9/case-dossier-response.ts", import.meta.url), "utf8");
   const chat = readFileSync(new URL("../src/components/rectification-agentic-chat.tsx", import.meta.url), "utf8");
   assert.match(route, /step_state: stepStateFromCaseDossier\(dossier\)/);
   assert.doesNotMatch(chat, /rectification-step-state/);

frontend/tests/rectification-v9-entry-routing.test.ts

@@ -209,7 +209,8 @@ test("open RPC passes the pinned skill and server-derived baseline only", async
         session_id: SESSION_ID,
         status: "draft",
         should_start_opening: true,
-        skill_version: "10.0.24",
+        // 原值: "10.0.24"；新值: "10.0.25"；原因: 新案绑定现行 Skill
+        skill_version: "10.0.25",
       };
     }
     return null;
@@ -247,11 +248,17 @@ test("open RPC passes the pinned skill and server-derived baseline only", async
   });
   assert.equal(response.disposition, "created");
   assert.equal(response.shouldStartOpening, true);
-  assert.equal(response.skillVersion, "10.0.24");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(response.skillVersion, "10.0.25");
   const openCall = accounting.calls.find((call) => call.fn === "open_agentic_rectification_case_v2");
   assert.ok(openCall);
   assert.equal(openCall.args.p_skill_name, "jyotish-birth-time-rectification");
-  assert.equal(openCall.args.p_skill_version, "10.0.24");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(openCall.args.p_skill_version, "10.0.25");
   assert.equal(openCall.args.p_user_id, "user-1");
   // The server derives the baseline; the request never carries it from the browser.
   assert.equal("birth_date" in openCall.args, false);

frontend/tests/rectification-window-cluster-cap-20260909.test.ts

@@ -83,5 +83,8 @@ test("agent body cannot verbally accept a spoken birth window", () => {
   assert.equal(stripVerbalWindowChange("以你说的为准。"), "");
   assert.equal(stripVerbalWindowChange("明白了，以你说的为准。"), "明白了。");
   assert.match(SKILL, /不得回答『以你说的为准』或改写搜索窗口/);
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 });

frontend/tests/rectification-yearless-probe-downgrade-20260909.test.ts

@@ -161,7 +161,10 @@ test("SCORE_DELTA stays ±2/±1 and yearless weight is half", () => {
   assert.equal(PROBE_WEIGHT.dated, 1);
   assert.equal(PROBE_WEIGHT.yearless, 0.5);
   assert.equal(STRONG_CONFLICT_ELIMINATION_COUNT, 3);
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.24");
+  // 原值: "10.0.24"
+  // 新值: "10.0.25"
+  // 原因: BUG-661/662/663 定向补事改逐条点选，Skill 升版
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.25");
 });
 
 test("D9 answer B moves scores by ±1 and does not count toward elimination", () => {

frontend/tests/skill-registry.test.ts

@@ -85,8 +85,8 @@ test("checked-in registry verifies hashed product packages and leaves consult on
     [
       {
         name: "jyotish-birth-time-rectification",
-        version: "10.0.24",
-        sha256: "f4267cb93b459a84ec0006b51501b174d5bbc809b571168307affbaede22e4e7",
+        version: "10.0.25",
+        sha256: "263ab00d5a62ee38dde1e13474b50a5e194e412b742d1693acaa9974db9f02e8",
       },
       {
         name: "jyotish-personal-report",
@@ -184,6 +184,28 @@ test("checked-in registry verifies hashed product packages and leaves consult on
     deprecated1022.sha256,
     "e3765b20ce6b49a5c7c9ed6b0a8caacc6fc4b8a16a127b93bd92c537330a54e2",
   );
+  const deprecated1023 = resolveExactSkillPackage(
+    "jyotish-birth-time-rectification",
+    "10.0.23",
+    "91f5839e15514b80fa0370bb8b539686af211082e83bc951dc0e8250cbdbadcb",
+    { projectRoot },
+  );
+  assert.equal(deprecated1023.status, "deprecated");
+  assert.equal(
+    deprecated1023.sha256,
+    "91f5839e15514b80fa0370bb8b539686af211082e83bc951dc0e8250cbdbadcb",
+  );
+  const deprecated1024 = resolveExactSkillPackage(
+    "jyotish-birth-time-rectification",
+    "10.0.24",
+    "f4267cb93b459a84ec0006b51501b174d5bbc809b571168307affbaede22e4e7",
+    { projectRoot },
+  );
+  assert.equal(deprecated1024.status, "deprecated");
+  assert.equal(
+    deprecated1024.sha256,
+    "f4267cb93b459a84ec0006b51501b174d5bbc809b571168307affbaede22e4e7",
+  );
 });
 
 test("exact resolution of an old deprecated package is independent of active switches", (t) => {

skills/jyotish-birth-time-rectification/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: jyotish-birth-time-rectification
-version: 10.0.24
+version: 10.0.25
 description: "生时校正专用 Skill（V10）。以服务器权威 Case、ConversationFocus 与 CaseConversationSummary 驱动低负担访谈；批量证据逐项判定，candidate / accepted / confirmed 严格分离，全部计算与持久化只走服务端工具。触发词：生时校正、出生时间校正、校正出生时间、rectification、birth time correction。"
 ---
 
@@ -74,14 +74,14 @@ description: "生时校正专用 Skill（V10）。以服务器权威 Case、Conv
 - 没有 active focus、focus 已 resolved/declined/skipped/superseded、或当前表达可能指向多个目标时，只做一句简短澄清；不得猜测或写 evidence。
 - 当前轮用户主动、明确、无歧义地提出全新事件时，可按新事件处理；若需要后续问题，由服务器建立新的 focus。
 - 用户已拒绝或跳过的目标不得换词重问；只有用户主动重开该主题或服务器建立新的有效 focus 才可继续。
-- 性格类点选题只在已经给出目前范围之后可选，分值减半、不淘汰。
+- 性格类点选题只在已经给出目前范围之后、用户点了卡下「再答两道参考题微调排序」才出，分值减半、不淘汰。
 
 ## 6. CaseConversationSummary 与长会话记忆
 
 `CaseConversationSummary` 是长会话的权威记忆，至少投影：confirmed evidence summary、pending revisions、active focus、declined/skipped topics、candidate divergence summary、missing evidence categories、`method_followup_plan`、last result policy。
 
 - 选择下一动作、识别已确认事实、避免重复追问、理解候选差异与结果政策时，优先依据服务器提供的 `CaseConversationSummary` 与 `method_followup_plan`。
-- 不要按 `missing_evidence_categories` 轮询迁居。财务、健康与其他经历同权：服务器按 `method_followup_plan.next_followup` 主动问，用户说了就记、就计分。下一问只跟 `method_followup_plan.next_followup`。收集按信息价值排序（邀请「还有吗」→ 用户年份锚定追问 → 无年份通用补问），问到训练门开；训练门开后先问带年月选择题。带年月池空时先按剩余候选刷新一批带年月题，仍无题再按还能切开剩余候选的线定向补事（只举具体例子，不得写出生年推算年份）。用户说「没有了 / 就这些」或刷新与定向补事都用尽后，才交付目前范围。性格题只作卡后可选。训练门关时只写精确缺口、保持开放，不出「做不了」。不得用生日推年份。已有带日期事件且存在 `discriminating_event_probes` 大运冲突探针时，先问该前事筛窗，`source=event_probe` 挡住出牌，不要继续轮询方法层，不要 offer。占问不挡出牌；职业挡出牌。外貌、体质、胎记或疤痕不得追问。收集经历用自然语言问一件带大概年份的事，set-focus 不要写 choice。只有 `next_followup` 带 `choice_frame`（冲突探针、候选已经分不开或采用后核对前事）时才写 A/B/C/D 点选卡；题干由你写成自然语言，时间范围、领域和语义目标以服务器探针为准，不得发明年份，不得改写时间范围；不要逐字复述服务器的事件家族标签，也不要把标签里的多个例子全堆进一句。结合最近对话只选一个用户最容易回答的口语入口，不要问两套盘哪个更像。正文不要复述选项。「先这样」由服务器补全。`next_user_action.id=adopt_representative` 时 `next_followup` 为空，本轮零追问。`next_user_action.id=verify_adopted_time` 时本轮只核一件前事，不要 offer、不要看盘；A 写入并 compare，C 关闭该问，对不上可改选。`id=start_consultation` 时请用户用当前采用时间看盘。`deferred_followup` 留给用户以后再补，不得当成本轮问题。仍有挡住出牌的 `next_followup` 时即使 `selection_allowed` 也继续问，不得 offer。
+- 不要按 `missing_evidence_categories` 轮询迁居。财务、健康与其他经历同权：服务器按 `method_followup_plan.next_followup` 主动问，用户说了就记、就计分。下一问只跟 `method_followup_plan.next_followup`。收集按信息价值排序（邀请「还有吗」→ 用户年份锚定追问 → 无年份通用补问），问到训练门开；训练门开后先问带年月选择题。带年月池空时先按剩余候选刷新一批带年月题，仍无题再按还能切开剩余候选的线逐条点选：每条先问有没有（有 / 没有 / 记不清，不计分），答「有」再问大概哪年几月。题干与提示写「现在还剩 HH:MM–HH:MM 里 N 个候选」，不得写「能把两端钟点分开」。所有线问完或用户说「没有了 / 就这些」后，才交付目前范围。性格题只作卡下可选入口「再答两道参考题微调排序」，不点不出。训练门关时只写精确缺口、保持开放，不出「做不了」。不得用生日推年份。已有带日期事件且存在 `discriminating_event_probes` 大运冲突探针时，先问该前事筛窗，`source=event_probe` 挡住出牌，不要继续轮询方法层，不要 offer。占问不挡出牌；职业挡出牌。外貌、体质、胎记或疤痕不得追问。收集经历用自然语言问一件带大概年份的事，set-focus 不要写 choice。只有 `next_followup` 带 `choice_frame`（冲突探针、定向补事「有没有」、候选已经分不开或采用后核对前事）时才写 A/B/C/D 点选卡；题干由你写成自然语言，时间范围、领域和语义目标以服务器探针为准，不得发明年份，不得改写时间范围；不要逐字复述服务器的事件家族标签，也不要把标签里的多个例子全堆进一句。结合最近对话只选一个用户最容易回答的口语入口，不要问两套盘哪个更像。正文不要复述选项。「先这样」由服务器补全。`next_user_action.id=adopt_representative` 时 `next_followup` 为空，本轮零追问。`next_user_action.id=verify_adopted_time` 时本轮只核一件前事，不要 offer、不要看盘；A 写入并 compare，C 关闭该问，对不上可改选。`id=start_consultation` 时请用户用当前采用时间看盘。`deferred_followup` 留给用户以后再补，不得当成本轮问题。仍有挡住出牌的 `next_followup` 时即使 `selection_allowed` 也继续问，不得 offer。
 - recent turns 只是有界的原文引用窗口，用于核对当前措辞、quote 和局部承接；不得把 recent turns 当作唯一记忆，也不得用截断历史覆盖 summary。
 - summary 与 recent turns 看似冲突时，不自行裁决或默默改写事实：以服务器状态为准；需要用户确认时围绕 active focus 只澄清一个关键点。
 - 超过长会话窗口后仍不得忘记已确认证据、pending revision、拒答主题或 active focus。

skills/jyotish-birth-time-rectification/references/conversation-strategy.md

@@ -75,7 +75,7 @@ active `ConversationFocus` 是承接型意图的唯一目标来源。它由服
 追问必须能澄清事实、提高真实日期精度、补足必要方法层或区分候选；否则不提。优先级：
 
 1. 服务器 `CaseConversationSummary.active focus` 指定的唯一目标。
-2. `method_followup_plan.next_followup` 指定的下一方法层。收集按信息价值排序（邀请「还有吗」→ 用户年份锚定追问 → 无年份通用补问），问到训练门开；训练门开后先问带年月选择题。带年月池空时先按剩余候选刷新一批带年月题，仍无题再按还能切开剩余候选的线定向补事（只举具体例子，不得写出生年推算年份）。用户说「没有了 / 就这些」或刷新与定向补事都用尽后，才交付目前范围。性格题只作卡后可选。已有带日期事件且服务器给出大运冲突探针时，先问该前事筛窗，`source=event_probe` 挡住出牌，不要继续轮询方法层。迁居不进领域轮询，只在 `d4_refine` 精度阶段问搬家/住处。财务、健康与其他经历同权：服务器按 `method_followup_plan.next_followup` 主动问，用户说了就记、就计分。不得询问外貌、体质、胎记或疤痕。收集经历用自然语言。只有候选已经分不开、冲突探针或采用后核对前事时，`choice_frame` 才提供冲突节点；时间范围和事件家族由服务器 `discriminating_event_probes` 锁定（Vimshottari+Narayana 大运/副运起点的年或月差，没有可问边界时才用出生年+年龄带）。题干和 A/B/C/D 由你写成自然语言，A/B 是同一件事的吻合程度，不要照抄 hint，不要问两套盘哪个更像或可能性高低，不得发明年份，不得改写时间范围。Nakshatra pada / Hora / Ghati / Bhava / Pranapada / KP 子主换升只展示，不阻断采用。`next_user_action.id=adopt_representative` 时 `next_followup` 为空，不得把 `deferred_followup` 当成本轮问题。`id=verify_adopted_time` 时本轮只核一件前事。仍有挡住出牌的 `next_followup` 时即使 `selection_allowed` 也继续问。
+2. `method_followup_plan.next_followup` 指定的下一方法层。收集按信息价值排序（邀请「还有吗」→ 用户年份锚定追问 → 无年份通用补问），问到训练门开；训练门开后先问带年月选择题。带年月池空时先按剩余候选刷新一批带年月题，仍无题再按还能切开剩余候选的线逐条点选：每条先问有没有（有 / 没有 / 记不清，不计分），答「有」再问大概哪年几月。题干与提示写「现在还剩 HH:MM–HH:MM 里 N 个候选」，不得写「能把两端钟点分开」。所有线问完或用户说「没有了 / 就这些」后，才交付目前范围。性格题只作卡下可选入口「再答两道参考题微调排序」，不点不出。已有带日期事件且服务器给出大运冲突探针时，先问该前事筛窗，`source=event_probe` 挡住出牌，不要继续轮询方法层。迁居不进领域轮询，只在 `d4_refine` 精度阶段问搬家/住处。财务、健康与其他经历同权：服务器按 `method_followup_plan.next_followup` 主动问，用户说了就记、就计分。不得询问外貌、体质、胎记或疤痕。收集经历用自然语言。只有候选已经分不开、冲突探针、定向补事「有没有」或采用后核对前事时，`choice_frame` 才提供点选卡；时间范围和事件家族由服务器 `discriminating_event_probes` 锁定（Vimshottari+Narayana 大运/副运起点的年或月差，没有可问边界时才用出生年+年龄带）。题干和 A/B/C/D 由你写成自然语言，A/B 是同一件事的吻合程度，不要照抄 hint，不要问两套盘哪个更像或可能性高低，不得发明年份，不得改写时间范围。Nakshatra pada / Hora / Ghati / Bhava / Pranapada / KP 子主换升只展示，不阻断采用。`next_user_action.id=adopt_representative` 时 `next_followup` 为空，不得把 `deferred_followup` 当成本轮问题。`id=verify_adopted_time` 时本轮只核一件前事。仍有挡住出牌的 `next_followup` 时即使 `selection_allowed` 也继续问。
 3. candidate divergence / `internal_observations` 显示真正能区分候选的主题。D9/D10 观察用于选题，并在出牌轮写入类型对照（校时方法，不是命运承诺）。
 4. pending revision 的一个关键歧义。
 5. 已有证据的必要稳定性补强。

skills/jyotish-birth-time-rectification/versions/10.0.25/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: jyotish-birth-time-rectification
+version: 10.0.25
+description: "生时校正专用 Skill（V10）。以服务器权威 Case、ConversationFocus 与 CaseConversationSummary 驱动低负担访谈；批量证据逐项判定，candidate / accepted / confirmed 严格分离，全部计算与持久化只走服务端工具。触发词：生时校正、出生时间校正、校正出生时间、rectification、birth time correction。"
+---
+
+# Jyotish 生时校正（V10）
+
+## 1. 触发条件与方法学归属
+
+本 Skill 只服务 `agentic_rectification_cases` 绑定的生时校正会话：
+
+- 服务端 Case 存在且 `skill_name = 'jyotish-birth-time-rectification'`。
+- 用户话题是出生时间 / 出生分钟 / 事件发生时间能否定位到某几分钟，而不是普通解盘或推运。
+- 普通咨询、推运、合盘、补救问题交给 `jyotish-vedic-astrology`，不要在这里处理。
+
+生时校正的方法学、访谈策略、证据边界与候选表达规则只定义在本 Skill 及其 references。system prompt 只保留安全、权限、隐私、工具和运行边界，不得复制、压缩或另写一套校时方法学，也不得用 system prompt 覆盖本版本政策。
+
+## 2. 必须先读与服务器权威
+
+进入任何一轮实质工作前读取（服务器会随 Dossier 提供投影，缺文件时以服务器 Dossier 为准）：
+
+1. `references/evidence-model.md`：证据种类、日期精度、原文引用、修订链、服务器持有 ID。
+2. `references/conversation-strategy.md`：OpeningPolicy、ConversationFocus、长会话记忆、批量证据与追问策略。
+3. `references/candidate-comparison.md`：candidate / accepted / confirmed 三层语义与表达边界。
+4. `references/technique-routing.md`：技法按主题调用，D9/D10 核心，不一次性调用所有分盘。
+5. `references/truth-consent-boundaries.md`：真实性、同意与选择政策。
+
+服务器是下列信息的唯一权威：Skill 绑定版本、Case/Session 身份与状态、`ConversationFocus`、`CaseConversationSummary`、evidence/focus ID、事件状态与修订链、候选范围与评分、采用/确认权限、工具执行、持久化和计费。Agent 只能解释服务器投影并选择自然表达，不得从对话文本、上一条 assistant 消息或 recent turns 重建权威状态。
+
+每次 attempt 必须先完成真实 Skill 绑定和 Case 加载，之后才能执行 action。失败或重试 attempt 的部分文本、工具结果与推断不得当作已提交事实；只依据服务器提交成功的 attempt 与 receipt。
+
+## 3. Case 状态与只读边界
+
+服务器 Dossier 会给出当前 `status`。按表行动：
+
+| status | 允许动作 |
+|---|---|
+| `draft` / `collecting_evidence` | 继续收集/修订带日期事件；可读取诊断。`next_user_action.id=adopt_representative` 时本轮结果是采用代表性时间，**不得**同时追问；仍有挡住出牌的 `next_followup` 时继续收集，**不得**提供候选。`selection_allowed` 不够作为出示卡片的理由；提出门看 `propose_allowed` 且访谈已停或用户喊停 |
+| `candidate_ready` | 可比较候选、说明当前边界；仍可继续补证据 |
+| `candidate_accepted` | 已采用代表性时间。采用后先按该分钟核最多两件前事，对不上可改选其他候选；核对结束再用这个时间看盘。`unique_minute_path=closed_at_representative` 时本会话以此收口，**不得**进入唯一分钟确认 |
+| `needs_rebaseline` | 出生资料基线已变化，候选失效；只允许重新收集/修订事件，禁止引用旧候选 |
+| `paused` | 可继续访谈；不要声称结束 |
+| `confirmed` / `closed` / `abandoned` / `superseded` | terminal Case，只读历史；不得追加/修订/确认证据，不得采用/确认候选，不得关闭第二次 |
+
+- terminal Case 的只读限制由服务器强制；Agent 不得用换工具、换措辞、重试或旧 focus 绕过。用户要继续校正时，说明需要走显式新建 Case 的入口。
+- 同一用户可以保留多个可恢复 Case；首页显式新建与历史 Session 精确恢复是两条不同入口，不得因存在旧 Case 强制回到旧 Session。
+- 历史 Session 必须恢复对应的精确 Case/Session；不得把另一个 resumable Case 的上下文混入当前会话。
+
+## 4. OpeningPolicy
+
+服务端首次提供 opening brief：Case 状态、当前搜索窗口（`candidate_range`）与来源（intake 声明的不确定档）、做法三句要点、六类领域清单（升学、第一份工作、搬家、恋爱结婚、家里的大事、生病受伤）。Agent 按下列三句模板自然开场，不得要求先准备一套材料，也不得写具体年份：
+
+1. 一句当前搜索窗口与核对做法。
+2. 一句「最后给区间和代表分钟，不给精确到秒」。
+3. 一句「想到几件说几件，有大概年月就行」并点出上述六类。
+
+开场必须满足：
+
+- 一条消息可以报多件；想到几件说几件，有大概年月即可。用户每说一批后由服务端问「还有吗」，例子只列还没提过的具体事物、最多 4 个。用户说「没有了 / 就这些 / 记不清」后改为从已说的事做锚定追问。不得用生日推年份写进题干，也不得重复开场邀请。
+- 允许模糊日期：可以先说大概年份、阶段或范围；如确有信息增益，后续再澄清，不诱导猜测月份或日期。
+- 首题保持采集题身份（`collect:other:*`），题干写成「先说你最容易想起的一两件，年月大概就行」。
+- 至多一个主问题且唯一来源：每轮当前问题只能由服务端建立 `ConversationFocus` 并通过界面问题槽呈现。Agent 回复正文只做承接与解释，不得自行提出、复述、改写或预告问题；正文内容不参与问题槽判定。
+- 不机械复述 opening brief，不泄露服务器字段、内部状态对象或出生资料明文。
+- 用户说出出生时间或时段时，不得回答『以你说的为准』或改写搜索窗口；服务端会固定回复范围在开始时已定、过程中不改。
+
+## 5. ConversationFocus 与意图承接
+
+`ConversationFocus` 是服务器持久化的当前对话目标，至少包含 `id`（即 `focusId`）、`questionId`、`intent`、`targetEvidenceId`、目标领域/类型、预期回答结构、状态与时间。Agent 可做意图分类，但服务器必须验证目标仍为 `active`。
+
+- “是的 / 不是 / 大概那年 / 后来改了 / 不记得 / 不想回答 / 换个方向”等承接、拒答、确认和修订，必须依赖服务器给出的 active focus。
+- 拒绝、跳过、解决或修订既有目标时，工具调用必须引用服务器提供的 `focusId`；涉及既有证据时还必须引用对应 `evidenceId`。用户对已有 pending 说“对/是”时，`rectification-confirm-evidence` 可以省略 `focusId`，尤其当 active focus 是无 `target_evidence_id` 的 opening focus 时，不得用它烧掉后续事件确认。
+- 不得从 assistant 上一句倒推拒答目标，不得仅靠 pending revision 或中文正则构造 active focus，也不得把脱离上下文的承接词保存成新事件。
+- 没有 active focus、focus 已 resolved/declined/skipped/superseded、或当前表达可能指向多个目标时，只做一句简短澄清；不得猜测或写 evidence。
+- 当前轮用户主动、明确、无歧义地提出全新事件时，可按新事件处理；若需要后续问题，由服务器建立新的 focus。
+- 用户已拒绝或跳过的目标不得换词重问；只有用户主动重开该主题或服务器建立新的有效 focus 才可继续。
+- 性格类点选题只在已经给出目前范围之后、用户点了卡下「再答两道参考题微调排序」才出，分值减半、不淘汰。
+
+## 6. CaseConversationSummary 与长会话记忆
+
+`CaseConversationSummary` 是长会话的权威记忆，至少投影：confirmed evidence summary、pending revisions、active focus、declined/skipped topics、candidate divergence summary、missing evidence categories、`method_followup_plan`、last result policy。
+
+- 选择下一动作、识别已确认事实、避免重复追问、理解候选差异与结果政策时，优先依据服务器提供的 `CaseConversationSummary` 与 `method_followup_plan`。
+- 不要按 `missing_evidence_categories` 轮询迁居。财务、健康与其他经历同权：服务器按 `method_followup_plan.next_followup` 主动问，用户说了就记、就计分。下一问只跟 `method_followup_plan.next_followup`。收集按信息价值排序（邀请「还有吗」→ 用户年份锚定追问 → 无年份通用补问），问到训练门开；训练门开后先问带年月选择题。带年月池空时先按剩余候选刷新一批带年月题，仍无题再按还能切开剩余候选的线逐条点选：每条先问有没有（有 / 没有 / 记不清，不计分），答「有」再问大概哪年几月。题干与提示写「现在还剩 HH:MM–HH:MM 里 N 个候选」，不得写「能把两端钟点分开」。所有线问完或用户说「没有了 / 就这些」后，才交付目前范围。性格题只作卡下可选入口「再答两道参考题微调排序」，不点不出。训练门关时只写精确缺口、保持开放，不出「做不了」。不得用生日推年份。已有带日期事件且存在 `discriminating_event_probes` 大运冲突探针时，先问该前事筛窗，`source=event_probe` 挡住出牌，不要继续轮询方法层，不要 offer。占问不挡出牌；职业挡出牌。外貌、体质、胎记或疤痕不得追问。收集经历用自然语言问一件带大概年份的事，set-focus 不要写 choice。只有 `next_followup` 带 `choice_frame`（冲突探针、定向补事「有没有」、候选已经分不开或采用后核对前事）时才写 A/B/C/D 点选卡；题干由你写成自然语言，时间范围、领域和语义目标以服务器探针为准，不得发明年份，不得改写时间范围；不要逐字复述服务器的事件家族标签，也不要把标签里的多个例子全堆进一句。结合最近对话只选一个用户最容易回答的口语入口，不要问两套盘哪个更像。正文不要复述选项。「先这样」由服务器补全。`next_user_action.id=adopt_representative` 时 `next_followup` 为空，本轮零追问。`next_user_action.id=verify_adopted_time` 时本轮只核一件前事，不要 offer、不要看盘；A 写入并 compare，C 关闭该问，对不上可改选。`id=start_consultation` 时请用户用当前采用时间看盘。`deferred_followup` 留给用户以后再补，不得当成本轮问题。仍有挡住出牌的 `next_followup` 时即使 `selection_allowed` 也继续问，不得 offer。
+- recent turns 只是有界的原文引用窗口，用于核对当前措辞、quote 和局部承接；不得把 recent turns 当作唯一记忆，也不得用截断历史覆盖 summary。
+- summary 与 recent turns 看似冲突时，不自行裁决或默默改写事实：以服务器状态为准；需要用户确认时围绕 active focus 只澄清一个关键点。
+- 超过长会话窗口后仍不得忘记已确认证据、pending revision、拒答主题或 active focus。
+
+## 7. 批量证据与日期真实性
+
+一次用户消息可包含多件事件。优先使用服务器提供的批量 proposal/confirmation 服务，并遵守逐项原子语义：
+
+- 每件事件独立保留用户原话 `quote`、`kind`、`domain` 和真实 `date precision`；不得合并、拆错主体或要求用户逐条重发。
+- 服务器逐项返回 `accepted` / `needs_clarification` / `rejected`；Agent 按每项结果分别处理，不得让一条模糊或拒绝项阻塞同批清晰项。
+- 清晰且 quote grounding 通过的新事件必须走批量服务写入；不要对同一句用户消息里的多件事件逐条 propose+confirm。`rectification-confirm-evidence` 只用于用户对已有 pending 明确说“对/是”。
+- 证据有效写入后，服务器会按当前账本重算候选。不要等用户说“没有更多了”才 compare；同一证据指纹不要再 compare。不要调用新的扫描工具。
+- 证据轮正文只写一句复述，格式「记下了：年 月 事件短语（、…）。」例如「记下了：2016 年 9 月入学、2020 年 6 月毕业。」不得加评价句，不得写「很有帮助 / 很有价值 / 很有分量 / 特别有用」。范围变化由服务器接到正文后面。
+- 批量结果中的 evidence item `accepted` 只是该项被服务接纳处理，不等于候选 `accepted`；清晰项在批量路径上可由服务器直接 `confirmed`。
+- 复述任何事件日期必须使用服务器 `display_date_label`。日级不得说成“年份已确定为 YYYY”。用户确认“是/对”不得改 `date_precision`。
+- `needs_clarification` 不得猜补日期、主体、事件身份、主动/被动、原因或人物关系；`rejected` 不得伪装成已记录。
+- 修订必须生成 superseding revision，引用 active `focusId` 与目标 `evidenceId`，不得覆盖历史；pending revision 不自动确认。
+- 日期精度真实保留：`year` / `month` / `quarter` / `day` / `range` / `unknown` 按用户原话保存，范围不得取中点，只有服务器目标已明确年份时才可把用户补充的月份/季度并入修订。
+- 批量服务与单项工具都必须依赖服务器幂等键；重试不得重复创建或确认 evidence。Agent 不自行生成 evidence/focus ID。
+
+## 8. 可调用工具与输入边界
+
+只调用服务器提供的 `rectification-*` 工具，包括 read-case、set/resolve-focus、批量 evidence、单项 proposal/confirmation/revision、candidate comparison/offer/accept/confirm 与 close-case。工具 input 只含服务端合同要求的最小引用（如 caseId、focusId、evidenceId、quote、proposedKind），**绝不**传：
+
+- userId、出生日期/时间/地点/时区、candidate range、完整 events 数组、分数与阈值、confirmationAllowed/selectionAllowed、profile 写入目标。
+
+工具结果只读取；事实、ID、评分、范围、状态、持久化、幂等与权限一律以服务器为准。工具执行对用户保持静默：不得叙述读取 Skill、Case 已加载、调用工具、建立草稿、读取诊断或呈现快照，也不得自行生成“本轮做了什么”“执行步骤”“使用技法”或 Activity 状态文案；运行状态和实际方法 receipt 只由服务器公开凭证展示。
+
+## 9. candidate / accepted / confirmed 语言边界
+
+- `candidate`：引擎对当前证据的归一化比较结果，称“当前候选 / 相对支持度”，**不得**称概率、置信度或确定性。
+- `accepted`：用户明确选择的当前排盘时间，称“校正采用时间”，**不得**称“已确认唯一出生时间”。
+- `confirmed`：通过服务器确认门且用户明确同意，称“已确认校正时间”。
+- `session_outcome=adopt_representative` / `next_user_action.id=adopt_representative`：本轮**有结果**，结果是采用代表性时间作当前排盘。正文应自然说明代表性候选可用于当前排盘，但它不是已确认的唯一出生分钟；不要使用固定收口句式。不要调用 confirm。只有这时才调用 `rectification-offer-candidates`。服务器会拒绝访谈未停且用户未喊停的 offer。`collecting_evidence` 且仍有挡住出牌的 `next_followup` 时不得 offer/accept。`propose_allowed` 需要可评分事件≥4、领域≥3、诊断稳定，或事件吻合率≥80%；唯一领先和宽度≤5只挡确认门，不挡出示代表性时间卡。精度阶段追问在收集达到训练门、选择题问完后才问，且不挡出牌。KP 观察不计分、不挡提出门。
+- 确认门以 `latest_result.confirmation_gate` 为准。`unique_minute_path=closed_at_representative` 或任一 blocker 未通过时，不得把唯一分钟确认当下一步；用户仍可 accepted 代表性候选。
+- `vedastro_minute_sensitive` 为 `not_evaluated` 表示尚未跑通，不等于 fail，但缺它不能写 confirmed。
+- 若 `vedastro_minute_sensitive` 为 `passed` 但 `public_aa_holdout` 为 `not_ready`，可以说官方分钟层已区分相邻分钟，仍必须说公开密封集尚未达标，不能确认唯一分钟。
+- `public_aa_holdout` 为 `not_ready` 时 `unique_minute_path` 必须是 `closed_at_representative`：不得声称已校准到精确分钟，也不得把确认门放到更细宽度或发布准确率。
+- 未达到唯一分钟确认门时，任何“就用 HH:MM”都只能进入 accepted；只有 `confirmation_allowed=true` 且用户同意才可写 confirmed。
+- 若不可分 blocker 为 `blocked`、宽度大于 5、top `tied_minute_count` > 1，或 `confirmation_allowed=false`，正文必须说这是一段不可分区间，把代表分钟称为代表性候选，不得说已定位到唯一分钟。
+- 分钟窗口扫描只在服务端。即使高吻合、宽度 ≤5、`can_apply`/`propose_allowed`，仍写 `candidate_range_not_birth_time_truth`。
+- 出牌/采用轮正文只写三句：目前范围与代表分钟、对照了几件经历与事件吻合率、边界句「这只是代表性候选，不是已确认的唯一出生分钟」。卡片标题用「目前范围」，卡下必有一句「还能再收窄：如果记得 …」。禁用「这次给出」「结束」「最终」。八法验证报告（筛选窗、方法1–8、Technique Audit Table）由服务端 `skill_verification_report.markdown` 渲染在卡片下方折叠块「查看验证报告」，**不得**写入助手气泡。宽度、双轨只抄 `skill_verification_report` 的 `width_minutes` / `dasha_agreement`。分盘上升只抄 `skill_verification_report.sign_by_candidate`，不得自行按换升时刻推算。
+- 80%/60% 只描述**事件吻合率**（高度/中度/低度拟合），**不得**写成“已确认唯一出生分钟”。
+- 不得在同一回复中一边要求继续补证据、一边提供采用候选。
+- 不得伪造出生分钟、分数、权重、事件 ID、分盘事实或确认门结果。
+
+## 10. 输出与停止条件
+
+- 简体中文。访谈按 skill 路径 C：先用自然语言收集带大概年份的经历；只有候选已经分不开时才生成可点选的 A/B/C/D 主题问卷。允许模糊日期、允许分多轮。**不得**一进场就出点选卡，也不得先逼 10–15 条事件长表。
+- 每轮最多一个主要问题；完整回复可以零问题，不为了延续对话强行追问，不生成三条推荐问题。
+- 用户询问“为什么问这个 / 现在到哪一步 / 还需要多少信息”时，基于服务器状态直接回答，不把问题当作事件。
+- 用户说“不知道 / 记不清 / 不想回答 / 换个方向”时，按 active focus 关闭或跳过该目标；用户说“目前没有 / 没有更多事件”时，不再轮换证据领域，也不要求结束、暂停或保存进度。
+- 不得询问外貌、体质、胎记或疤痕。D9/D10 类型表是校时方法，写「该分钟下 D9/D10 升 X，与用户所述特质的对应/冲突」，不是咨询命运承诺。职业对照本命第 10 宫和 D10，允许类型表。占问只问一次；有问起时间则观察，没有也不挡出牌。`internal_observations` 可用于选题，类型对照写入验证报告。若用户消息以「盘外核对（不计分）」开头，不得写入可评分证据。
+- 精度阶段按本命上升 → D9 → D10 → D4 居所 → D5/D24 成就收窄；家人走 D12/D7/D3 方法覆盖。财务走 D2/D11、健康走 D30，与其他领域同权计分，均不得混进 D4。Pada / Hora / Ghati / Bhava / Pranapada / KP 子主只展示换升，不确认唯一分钟。
+- 采用后按采用分钟核最多两件服务器探针前事；对得上写入并重算，对不上可改选其他候选。不得声称唯一分钟，也不自动进入咨询 Agent。
+- 采用候选后自然说明 accepted 与 confirmed 边界；`verify_adopted_time` 时必须核一件前事，核对结束或用户先这样才请看盘。不主动关闭 Case，Session 会保留并可日后继续。
+- 不再有固定 10–15 个事件长表、外貌/体型/疤痕主评分、或“稳定确定到精确分钟”的承诺。A/B/C/D 主题问卷只在候选已经分不开或采用后核对前事时使用。80%/60% 只描述事件吻合率。
+- 无法验证时如实降级并说明受限，不得把内部一致性伪装成全球顶级精度。
+
+## 11. 上游同步边界
+
+方法源只在本 Skill 与 references。不得把本 Skill 内容反向写回 `yinduzhanxing` 上游快照，也不得在同步时自动覆盖商业 Skill。

skills/jyotish-birth-time-rectification/versions/10.0.25/references/candidate-comparison.md

@@ -0,0 +1,59 @@
+# Candidate Comparison（V9）
+
+候选比较是服务器计算产物，Agent 只负责解释与引导，不负责产生候选、分数或范围。
+
+## 1. 三层语义
+
+| 层 | 含义 | 表达 |
+|---|---|---|
+| `candidate` | 引擎对当前证据的归一化比较结果 | “当前候选”“相对支持度” |
+| `accepted` | 用户明确选择的当前排盘时间 | “校正采用时间” |
+| `confirmed` | 通过服务器确认门且用户明确同意 | “已确认校正时间” |
+
+- `candidate_accepted` 不是“唯一出生分钟已确认”，默认仍可继续补充证据。
+- accepted 后用户仍可在同一批有效候选中改选（幂等 RPC 支持）。
+- confirmed 只能由服务器确认门 + 用户明确同意触发，同时写 `completed_at`。
+
+## 2. 何时提供候选
+
+- 只有本轮完成 `rectification-offer-candidates` 且返回 `selection_allowed=true` 时，界面才展示候选卡。
+- `selection_allowed` 只表示可以采用代表性时间，**不是**本轮必须出示卡片。提出门看 `latest_result.propose_allowed`，并且没有挡住出牌的 `method_followup_plan.next_followup`（占问和精度阶段追问不挡；职业挡出牌）。唯一领先和宽度≤5只挡确认门。
+- `next_user_action.id=adopt_representative`，或用户停止且 `on_user_stop` 为 adopt 时，本轮才 offer/accept。服务器会拒绝访谈未停的 offer。这是采用代表性时间，不是 confirmed。
+- 继续收集证据时不得边追问边提供采用。
+- 候选卡内容来自持久化 Candidate Snapshot（`agentic_rectification_results`），不是 Agent 文本解析。
+- 候选卡按一行至多三列并排：每列一个候选分钟，写相对可能性、性格处事、经历对照、往后 12 个月事件窗；「更像这个」即采用。不预标「排盘用」。Agent 正文在出牌轮**不得**复述八法表格或 Technique Audit。
+
+## 3. 表达边界
+
+- 相对支持度是候选间归一化比较，**不是**概率、统计置信度或确定性。卡片上的「相对可能性」是答题后的后验百分比，同样不是引擎置信度。80%/60% 只描述事件吻合率。
+- 出牌轮正文不写事件–Dasha–Gochara 表、D9/D10 类型对照和技法审计；那些只出现在折叠的验证报告里。不暴露隐藏分钟证据或把分数说成唯一分钟概率。分盘上升只抄 `skill_verification_report.sign_by_candidate`，不得自行按换升时刻推算。
+- 候选范围必须说明“待核对边界”，不得表述为已确认出生分钟。
+- 外部验证状态按服务器字面读取：`not_evaluated` 表示未调用（入口门未就绪），不是“调用了但失败”。
+
+## 4. 证据变化与重算
+
+- 证据有效变化时由服务器重算候选；Agent 不必等用户说“没有更多了”才 compare。
+- 相同 evidence 指纹 + 引擎版本复用缓存；不要对同一指纹再 compare。
+- 分钟窗口扫描只在服务端，结果进入候选卡 / 不可分平台语言。不得把若干事件说成已确定到 ±5 分钟。
+- 普通澄清轮若不改变账本指纹，不重复播报。
+- 出生资料基线变化 → `needs_rebaseline`，旧候选失效；不得静默继续用旧结果。
+- `needs_rebaseline` 下不引用旧候选、不提供采用。
+
+## 5. 不可分平台与确认门（必须说出来）
+
+服务器 `latest_result` 含 `confirmation_gate`、`engine_indistinguishable_width_minutes`、`confirmation_allowed`、`selection_allowed` 与 `margin_percent`（若有）。`confirmation_gate` 是确认门权威，不是让 Agent 另算一分钟。折叠验证报告的宽度、双轨、分盘星座只抄 `skill_verification_report`（`width_minutes` / `dasha_agreement` / `sign_by_candidate`），不得用引擎原跨度或已淘汰分钟。Agent 正文不得再写这些表。
+
+- 宽度大于 `maxConfirmationWidthMinutes`（5），或 top 候选 `tied_minute_count` > 1，或 `confirmation_allowed=false` 时：正文必须说这是**一段不可分区间**，必须把代表分钟说成**代表性候选**，不得说已定位到唯一分钟，也不得学本地扫分钟后的 1 分钟尖峰。
+- `vedastro_minute_sensitive` 为 `not_evaluated` 表示官方分钟敏感校验尚未跑通，不是 fail；缺它不能写 confirmed。
+- 若官方分钟层已 `passed` 但 `public_aa_holdout` 为 `not_ready`：可以说已区分相邻分钟，仍不得确认唯一分钟或发布准确率。
+- `public_aa_holdout` 为 `not_ready` 时不得声称已校准到精确分钟，也不得把确认门放到更细宽度或发布准确率。
+- 用户仍可 accepted 代表性候选；accepted ≠ confirmed。`session_outcome=adopt_representative` 时自然说明代表性候选可用于当前排盘、但不是已确认的唯一出生分钟，不要使用固定收口句式。`unique_minute_path=closed_at_representative` 时不得把确认当下一步。
+- `confirmation_allowed=true` 才允许进入唯一分钟确认门；平台结果禁止把 `confirmation_allowed` 说成已确认。
+- 候选卡仍可展示代表性时间；Agent 不得把该时间写成“已校正到 HH:MM”。
+
+## 6. 保存边界
+
+- accepted 写入 `active_birth_time`，保留 `reported_birth_time` 原填报，不写兼容 `birth_time`。
+- 采用后界面按采用分钟重算本命宫位表，并折叠展示本轮技法审计。这不是唯一分钟确认，也不自动进入咨询 Agent。
+- confirmed 同样保留原填报；不自动写入，需要用户明确同意。
+- 失败、空流、Skill 未加载或未完成必要工具链时不保存、不扣费。

skills/jyotish-birth-time-rectification/versions/10.0.25/references/conversation-strategy.md

@@ -0,0 +1,107 @@
+# Conversation Strategy（V10）
+
+生时校正访谈按 skill 路径 C：先用自然语言收集带大概年份的经历，再在候选已经分不开时由服务器锁定时间范围和事件家族，由你写成一句具体生平题干（某年或某月是否搬过家、高考是否发挥失常），用 A/B/C/D 点选卡回答同一件事的吻合程度；不是 10–15 条事件长表，也不是无结构闲聊，更不是让用户给两套盘排序。服务器持有事实、状态、权限、焦点与长会话记忆；Agent 负责意图理解、把问卷说清楚、并选择一个有信息增益的下一步。
+
+## 1. 每轮上下文优先级
+
+每轮先按以下优先级理解会话：
+
+1. 当前 Case 的服务器状态与读写权限。
+2. `CaseConversationSummary`：confirmed evidence、pending revisions、active focus、declined/skipped topics、candidate divergence、`method_followup_plan`、last result policy。不要把 `missing_evidence_categories` 当下一问。
+3. 当前用户消息。
+4. recent turns：只作为有界原文引用窗口，辅助 quote grounding 和局部措辞理解。
+
+recent turns 不是权威记忆，不得依赖“上一条 assistant 问了什么”的倒推、正则匹配或被截断的聊天记录重建 Case 状态。summary 与局部文本不一致时，以服务器状态为准；若用户意图仍不唯一，只澄清一个关键点。
+
+## 2. OpeningPolicy
+
+首次开场只使用服务器 opening brief 中的 Case 状态、当前搜索窗口（intake 不确定档）、做法三句要点与六类领域清单，并自然满足：
+
+- 三句模板：当前窗口与核对做法；「最后给区间和代表分钟，不给精确到秒」；「想到几件说几件，有大概年月就行」并点出升学、第一份工作、搬家、恋爱结婚、家里的大事、生病受伤。
+- 一条消息可以报多件。不索要 10–15 条事件长表，不要一进场就出 A/B/C/D。用户每说一批后由服务端问「还有吗」，例子只列还没提过的具体事物。用户说「没有了 / 就这些 / 记不清」后改为从已说的事做锚定追问。不得用生日推年份，也不得重复开场邀请。
+- 接受“大概某年 / 那几年 / 某个阶段”等模糊日期，不诱导猜月份、日期或精确时点。
+- 不得写具体年份，不得要求先准备材料。
+- 首题 `collect:other:*` 题干写成「先说你最容易想起的一两件，年月大概就行」。
+- 至多一个主问题；开场可以零问题。
+- 不固定复述身份、opening brief 原文或服务器字段。
+
+区分阶段的题干由你写成自然语言；时间范围和事件家族以服务器探针为准，不得发明年份，不得改写时间范围。例如把锁定的 2015 年和搬家写成“2015 年前后你是否搬过家？”，把锁定的 2018 年 3 月写成“2018 年 3 月前后你是否入职或职责加重？”，把已有高考经历写成“高考的时候是否发挥失常？”
+
+## 3. 一轮的基本形态
+
+1. 先判断用户意图：新事件、批量事件、补日期、修正旧事实、回答上一问、确认/否认、询问进度或原因、拒答/换方向、查看或采用候选。
+2. 先读取服务器 Case、summary 与 active focus；静默完成必要的工具调用后再输出答案。正文不叙述内部执行步骤，也不生成 Activity/技法凭证文案。
+3. 自然回应本轮内容。证据轮正文只写一句复述：「记下了：年 月 事件短语（、…）。」不评价价值，不写「很有帮助 / 很有价值 / 很有分量 / 特别有用」。范围变化由服务器接在后面。
+4. 清晰项先处理；若仍需追问，只保留一个最有信息增益的主问题。完整回复可以没有问题。
+5. 不允许在同一回复中既要求补证据、又提供采用候选；不生成三条推荐问题。
+6. `next_user_action.id=adopt_representative` 时本轮只解释结果并邀请采用，零追问（除非有 active focus）。`id=verify_adopted_time` 时本轮只核一件前事，不要 offer，不要看盘。仍有挡住出牌的 `next_followup` 时不得出示采用卡。提出门看 `propose_allowed`。精度阶段追问和占问不挡出牌；职业仍挡。不得询问外貌、体质、胎记或疤痕。宽度大于 5 仍可出示代表性时间卡，不得为把不可分区间问到 5 分钟以内而继续 A/B/C/D。`unique_minute_path=closed_at_representative` 时不得把唯一分钟确认当下一步。
+
+## 4. ConversationFocus
+
+active `ConversationFocus` 是承接型意图的唯一目标来源。它由服务器持久化并提供 `focusId`、目标 `evidenceId`（如有）、intent、预期回答结构和状态。
+
+- “是的 / 不是 / 对 / 不对 / 大概那年 / 后来改了 / 不记得 / 不想回答 / 换个方向”只有在存在唯一 active focus 时才能解释为回答、拒答、确认或修订。
+- 拒绝、跳过、解决 focus 时，工具调用必须引用 active `focusId`；修订既有 evidence 时同时引用目标 `evidenceId`。用户对已有 pending 说“对/是”时，确认工具可以省略 `focusId`；opening focus（无 `target_evidence_id`）不得因第一条确认被 resolve。
+- 无 active focus、focus 已非 active、目标已被 supersede、或一句话可能指向多个问题时，简短问清“你指的是哪一件/哪一个时间点”；不得猜测，不调用 evidence 写工具。
+- 脱离 active focus 的“是的 / 不是”不是新事件。不得从 assistant 上一句倒推目标，不得只用 pending revision 构造 `active_followup`。
+- 当前消息若主动、明确陈述全新事件，可独立进入 evidence 流程；需要追问时由服务器建立新 focus。
+- 服务器验证 focus 已失效时，停止该动作并基于最新 summary 重新回应，不沿用旧目标。
+
+## 5. 自然叙述与批量 evidence
+
+用户一段话中可以包含多件事件。应优先走服务器批量服务：
+
+- 每件事件分别保留原话 `quote`、`kind`、`domain`、主体和日期精度，不合并，不要求逐条重发。
+- 服务器对每项独立返回 `accepted`、`needs_clarification` 或 `rejected`。一项失败不改变其他项结果。
+- 新事件优先走批量服务；一句里两件及以上事件时只允许批量。清晰项在批量路径上可由服务器直接 `confirmed`，不要再逐条 propose+confirm。不要让模糊项阻塞清晰项。
+- 多个模糊项同时存在时，只选择信息增益最高的一项追问一个关键点，其余维持待澄清，不连续抛出问题清单。
+- `needs_clarification` 只问缺失的关键事实；不猜日期、主体、事件身份、动机、因果、主动/被动或人物关系。
+- `rejected` 如需解释，只说明用户可理解的边界，不伪装成已记录。
+- 批量 evidence item 的 `accepted` 是服务处理结果，不是候选采用状态；清晰项的最终 `status` 以服务器返回为准，批量路径上可以为 `confirmed`。
+- 询问进度/原因、拒答、查看结果、采用候选，以及无唯一 active focus 的承接词，都不是新事件。
+
+## 6. 确认、修订、拒答与换方向
+
+- 确认既有事实：必须有对应 `evidenceId`；确认词本身不创建新 evidence。无匹配 pending-target 的 focus 时可省略 `focusId`。
+- 修订既有事实：必须有 active `focusId` 和目标 `evidenceId`，生成 superseding revision，不覆盖历史；pending revision 不自动确认。
+- 用户明确“不知道 / 记不清”：将 active focus 解决为 skipped，本会话不再问该领域采集；采用后核对仍可碰。回执「记下了，这题先放着。」
+- 用户明确“没有 / 不想回答 / 换个方向”：decline/skip active focus；不得换词重开同一目标。采集题「没有」走 declined，回执「记下了，这方面先跳过。」
+- 用户主动重新打开曾拒绝主题时，可让服务器建立新 focus；否则 declined/skipped topics 以 `CaseConversationSummary` 为准。
+- 用户说“目前没有 / 没有更多事件”时，停止轮换证据领域；不要求结束、暂停或保存进度。
+- 若没有其他具备信息增益的问题，可以直接说明当前边界或自然结束本轮。
+
+## 7. 追问策略
+
+追问必须能澄清事实、提高真实日期精度、补足必要方法层或区分候选；否则不提。优先级：
+
+1. 服务器 `CaseConversationSummary.active focus` 指定的唯一目标。
+2. `method_followup_plan.next_followup` 指定的下一方法层。收集按信息价值排序（邀请「还有吗」→ 用户年份锚定追问 → 无年份通用补问），问到训练门开；训练门开后先问带年月选择题。带年月池空时先按剩余候选刷新一批带年月题，仍无题再按还能切开剩余候选的线逐条点选：每条先问有没有（有 / 没有 / 记不清，不计分），答「有」再问大概哪年几月。题干与提示写「现在还剩 HH:MM–HH:MM 里 N 个候选」，不得写「能把两端钟点分开」。所有线问完或用户说「没有了 / 就这些」后，才交付目前范围。性格题只作卡下可选入口「再答两道参考题微调排序」，不点不出。已有带日期事件且服务器给出大运冲突探针时，先问该前事筛窗，`source=event_probe` 挡住出牌，不要继续轮询方法层。迁居不进领域轮询，只在 `d4_refine` 精度阶段问搬家/住处。财务、健康与其他经历同权：服务器按 `method_followup_plan.next_followup` 主动问，用户说了就记、就计分。不得询问外貌、体质、胎记或疤痕。收集经历用自然语言。只有候选已经分不开、冲突探针、定向补事「有没有」或采用后核对前事时，`choice_frame` 才提供点选卡；时间范围和事件家族由服务器 `discriminating_event_probes` 锁定（Vimshottari+Narayana 大运/副运起点的年或月差，没有可问边界时才用出生年+年龄带）。题干和 A/B/C/D 由你写成自然语言，A/B 是同一件事的吻合程度，不要照抄 hint，不要问两套盘哪个更像或可能性高低，不得发明年份，不得改写时间范围。Nakshatra pada / Hora / Ghati / Bhava / Pranapada / KP 子主换升只展示，不阻断采用。`next_user_action.id=adopt_representative` 时 `next_followup` 为空，不得把 `deferred_followup` 当成本轮问题。`id=verify_adopted_time` 时本轮只核一件前事。仍有挡住出牌的 `next_followup` 时即使 `selection_allowed` 也继续问。
+3. candidate divergence / `internal_observations` 显示真正能区分候选的主题。D9/D10 观察用于选题，并在出牌轮写入类型对照（校时方法，不是命运承诺）。
+4. pending revision 的一个关键歧义。
+5. 已有证据的必要稳定性补强。
+
+不要按 `missing_evidence_categories` 轮询迁居。财务、健康与其他领域同权：服务器按 `method_followup_plan.next_followup` 主动问，用户说了就记、就计分。不是 SQL 类别轮询。`stop_domain_rotation=true` 时停止领域清单。一轮最多一个主要问题。用户询问“为什么问这个 / 现在到哪一步 / 还需要多少信息”时，直接说明目的、当前状态和边界，不绕开问题继续索取证据。
+
+## 8. 日期精度
+
+- `year`：只说年份；复述用 `display_date_label`（如 `2024年`）。
+- `month`：明确到月份；复述如 `2024-05`。
+- `quarter`：明确到季度。
+- `day`：明确到日期；复述必须是 `YYYY-MM-DD`，禁止说成“年份已确定为 YYYY”。
+- `range`：只有范围，不得擅自取中点当事实；复述用 `from–to`。
+- `unknown`：日期不明；可保留背景，但不得当作高权重校正证据。
+- 用户确认“是 / 对”不得改 `date_precision`。
+- 用户只补月份/季度时，只有 active focus 与目标 evidence 已由服务器明确年份，才可合并为 revision；不得猜年份。
+- “大概 3 月”仍按用户真实表达保存，不升级成某一天。
+
+## 9. 候选输出与终态
+
+- 候选卡负责呈现时间、排名、相对支持度、采用动作与选中状态。
+- 出牌/采用轮正文写入 skill 八法验证报告：候选窗、代表分钟、相对支持、事件–Dasha–Gochara 表、D9/D10 类型对照、技法审计表。卡片仍作 adopt 控件。
+- `relative_support` 不是概率，不能写“准确率 70%”。80%/60% 只描述事件吻合率。
+- candidate、accepted、confirmed 严格分离；accepted 不是 confirmed。
+- `next_user_action.id=adopt_representative` 时本轮结果是采用代表性时间；正文自然说明代表性候选可用于当前排盘、但不是已确认的唯一出生分钟，不要使用固定收口句式。仍有 `next_followup` 时不得出示采用卡。
+- 确认门以 `confirmation_gate` 为准。`not_evaluated` 不是 fail；holdout `not_ready` 时 `unique_minute_path=closed_at_representative`，不得声称精确分钟或发布准确率，也不得把唯一分钟确认当下一步。官方分钟层 `passed` 仍不能单独打开确认门。
+- 若确认门 `confirmation_allowed=false`，或 `confirmation_gate` 的不可分 blocker 为 blocked，必须说不可分区间 / 代表性候选，不得说已定位到唯一分钟。交付轮宽度只抄 `skill_verification_report.width_minutes`。accepted ≠ confirmed。
+- accepted 后按采用分钟核最多两件前事；对得上写入并重算，对不上可改选。不强制看盘，不要求用户结束、暂停或保存进度。核对结束或用户先这样才 `start_consultation`。
+- terminal Case（confirmed / closed / abandoned / superseded）只读：不得新增/修订/确认 evidence，不得采用/确认候选；若用户要继续，指向显式新建 Case。

skills/jyotish-birth-time-rectification/versions/10.0.25/references/evidence-model.md

@@ -0,0 +1,122 @@
+# Evidence Model（V9）
+
+证据是生时校正的唯一事实账本。本文件定义证据如何进入、校验、修订与关闭。服务器是证据账本的唯一写入者；Agent 只能提出 proposal。
+
+## 1. 证据最小单元
+
+一条证据（`agentic_rectification_evidence` 一行）至少包含：
+
+- `case_id`：所属 Case，由服务器生成。
+- `source_turn_id`：用户消息所在轮次；`source_message_id` 可选。
+- `user_quote`：用户原话的规范化子串。
+- `subject`：主体（`self` 或亲属关系；家庭事件必须显式 `related_person`）。
+- `event_kind`：语义种类（见 §2），不再只保留粗领域。
+- `domain`：评分/路由领域。
+- `occurred_from` / `occurred_to`：真实日期边界，可空。
+- `date_precision`：`year | month | quarter | day | range | unknown`。
+- `summary`：服务器从已验证引用中生成的安全摘要。
+- `status`：`draft | pending_confirmation | confirmed | superseded | rejected`。
+- `supersedes_evidence_id`：修订链指针。
+
+## 2. 事件种类（event_kind）
+
+```text
+education_start
+education_completion
+education_interruption
+education_change
+education_milestone
+career_entry
+career_change
+promotion
+career_pressure
+career_exit
+business_start
+relationship_start
+relationship_commitment
+relationship_separation
+relationship_end
+relationship_change
+relocation
+foreign_move
+return
+home_change
+finance_gain
+finance_loss
+income_change
+asset_change
+finance_change
+self_health_event
+pressure_period
+family_event
+appearance_note
+birthmark_or_scar
+occupation_note
+horary_query
+other
+```
+
+语义不折叠：`career_entry / career_pressure / career_exit` 不同；`relationship_start / relationship_commitment / relationship_separation` 不同；不得把“开始关系”与“关系变化”混成同一事件。`education_milestone`、`relationship_end`、`return`、`home_change`、`health_pressure` 等与 TypeScript `EVIDENCE_KINDS` / `EVIDENCE_DOMAINS` 对齐，不得再因枚举缺口导致写入失败。
+
+领域（`domain`）：
+
+```text
+education
+career
+relationship
+relocation
+finance
+health
+health_pressure
+family
+appearance
+marks
+occupation
+horary
+other
+```
+
+## 3. 日期精度
+
+- 用户只给年份 → `date_precision = 'year'`，`occurred_from = YYYY-01-01`（边界），不得诱导编造月份。
+- 用户给年月 → `month`；给季度 → `quarter`；给年月日 → `day`；给区间 → `range`。
+- 相对表达（“刚毕业那年”）必须由服务器结合权威当前时间解析，Agent 不得自行假设年份。
+- 跨午夜、未知时间不伪造具体分钟；`unknown` 精度允许保留。
+- 服务器投影只读字段 `display_date_label`：日级用 `YYYY-MM-DD`，月级用 `YYYY-MM`，年级用 `YYYY年`，range 用 `from–to`。复述必须用该标签；禁止把日级格式化成“年份已确定为 YYYY”。用户确认“是/对”不得改 `date_precision`。更粗的修订若 quote 并没有更粗的日期表达，服务器拒绝 `precision_downgrade`。
+
+## 4. 原文引用（quote grounding）
+
+- `user_quote` 必须能在对应 `source_turn.user_message` 中找到规范化匹配（去空白、去标点后子串命中）。
+- 服务器确认路径必须校验：引用来自本轮用户消息、kind 属于枚举、日期与原文一致。
+- 模型不得凭空补充月份、日期、原因、主动/被动、人物关系。
+
+## 5. 修订链（append-only）
+
+- 事实变化 = 新增 superseding row，旧行标记 `superseded`，永不覆盖/删除。
+- 合法修订：日期更正、日期补全（如“2016 年 + 9 月”合并为 `2016-09`）、事件重分类（同身份）。
+- 非法修订：跨事件覆盖既有 ID（如把“大学入学”改成“搬家”）；服务器拒绝并降级为新的 pending proposal。
+- 证据 ID 只能由服务器生成；模型不得提供或覆盖。
+
+## 6. 状态迁移
+
+```text
+draft -> confirmed              （当前轮明确事件：proposal 通过原文绑定后，同轮走服务器确认路径）
+draft -> pending_confirmation   （事实模糊、冲突或需要用户补充）
+pending_confirmation -> confirmed （用户明确确认 + 服务器确认路径）
+pending_confirmation -> superseded（用户更正，产生修订）
+confirmed -> superseded          （后续修订使旧事实失效）
+draft / pending_confirmation -> rejected （用户否认，保留只读历史）
+```
+
+- Agent 只能先产生 `draft`；`confirmed` 只能由服务器确认路径产生。服务器确认路径不等于必须额外等待一轮用户回复。
+- 终态 Case（confirmed/closed/abandoned/superseded）禁止新增或修订证据。
+- 同一请求重放不得重复写证据（幂等键 = case + source_turn + quote + kind + summary）。
+
+## 7. 评分输入边界
+
+- 只有 `confirmed` 证据进入评分账本；`draft` 与 `pending_confirmation` 都不参与评分。
+- `family_event` 进入评分（D12 + D7 + D3 + 六亲宫位）。`other` 只作背景，不推进评分覆盖计数。
+- `appearance_note` / `birthmark_or_scar`：无日期只覆盖访谈；有日期才进上升/一宫辅助评分，不得当主公式。
+- `occupation_note`：与带日期事业事件独立。无日期只覆盖访谈；有日期按 D10 + 本命 10 宫辅助评分，允许事业类型表作校时方法。
+- `horary_query` 只作背景观察，不推进评分覆盖计数，也不计入 4 事件 / 3 领域。
+- 证据变化才触发重算；相同证据指纹复用缓存，不重复评分。

skills/jyotish-birth-time-rectification/versions/10.0.25/references/technique-routing.md

@@ -0,0 +1,50 @@
+# Technique Routing（V9）
+
+生时校正是“有日期事件 + Dasha 为主要证据”的校准任务，分盘按主题调用，不一次性调用所有分盘。所有计算只能通过服务端工具；本文件只决定读哪些技法证据，不复制任何引擎实现。
+
+## 1. 主证据
+
+- 有明确日期（年月级或更精确）的人生事件 + 对应 Dasha 边界是主要证据。
+- 事件原文是用户原话；日期精度按用户真实提供保留。
+- 不把“支持某技法”误当作已完成独立验证；内部一致性不得伪装成全球顶级精度。
+
+## 2. 分盘调用层级
+
+| 层级 | 分盘 | 用途 |
+|---|---|---|
+| 核心 | D1（本命） | 全局框架 |
+| 核心辅助 | D9、D10 | 关系与事业的主要主题 |
+| 主题 | D2/D11（财富）、D3（兄弟姐妹）、D7（子女/伴侣细节）、D12（父母）、D24（教育）、D4（居所/不动产）、D5（成就）、D30（健康压力） | 按主题补充 |
+| 仅参考 | D60 | 只作参考，不驱动结论 |
+
+- 同一轮最多调用 2–3 个相关分盘；D9/D10 之外的分盘必须由当前主题驱动。
+- 未执行、不可用或仅供参考的技法不得显示为已执行。
+
+## 3. 按问题域强制调取
+
+- 事业：同一件带日期的事业事件必须同时计算 `D10` **和** D1 第 10 宫 / 10 宫主（A10 为事业 Arudha，服务器可用时）。职业说明与带日期事业事件独立，同样对照 D10 与本命 10 宫，**允许**事业类型表作校时方法；无日期只覆盖访谈。
+- 财富：用户主动提供带日期的收入、资产或财务变化时计分 `D2 / D11`。不要主动追问。窗口扫描记录 D2/D11 换升，但不新增精度阶段。
+- 婚恋：`D9 + UL`（UL 为 Upapada Lagna，服务器可用时）。
+- 六亲/家人：`D12` 加 `D7`（子女/伴侣细节）加 `D3`（兄弟姐妹）加 D1 三/四/五/九宫。家人事件进入评分，不只作背景。D3 不另开精度阶段。
+- 外貌/体质/胎记疤痕：本轮访谈不追问。若用户主动提到带日期的外貌或受伤变化，只对照 D1 上升/一宫作辅助降权，不得当主评分。
+- 健康：用户主动提供带日期的健康、事故或压力变化时计分 D1 + D30。不要主动追问。不是医学判断。窗口扫描记录 D30 换升，但不新增精度阶段。
+- 迁居：精度阶段 `d4_refine` 问带日期的搬家/住处变化；这不是领域轮询。计分 D4 + D1 四/十二宫。
+- 教育/成就：精度阶段 `d5_refine` 在 D5 **或 D24** 换升时问带日期的学业、考试或被委以责任的变化。计分 D24 + D5 + D1 四/五/九宫。D24 窗口扫描并入 `d5_refine`，不新增阶段 id。
+- 占问：只问一次第一次认真问起这件事的时间。有日期则按该时点重算观察盘（出生地经纬，除非另给地点），可附 1/4/7/10 KP 子主。失败写成 blocked 观察，不计分，不挡提出门或确认门。没有时间或拒绝则 `skipped_by_policy`。
+- 精度阶段顺序：有日期事件 → 收集按信息价值（邀请 → 用户年份锚定 → 无年份通用补问）直到训练门开 → 选择题直到收敛或增益见底 → 交付区间。家人不得混进 D4，也不另开 `d11_refine` / `d30_refine`。训练门关时不得出示时间卡。
+- Nakshatra pada、Hora Lagna、Ghati Lagna、Bhava Lagna、Pranapada Lagna、KP 子主只在窗口扫描中展示换升，不驱动 `ready_to_adopt`，也不打开确认门。日出不可用时省略 Hora/Ghati/Pranapada，不得用 06:00 假日出。Bhava 只用本命日月，不依赖日出。
+- D9/D10 类型表写入出牌轮验证报告，作为校时方法，不得写成命运承诺。`internal_observations.ask_theme` 决定下一问主题。
+
+## 4. 受限技法边界
+
+- KP、Muhurta、Gochara、Sahams、Sphuta、Tajika 为 reference-only 或 blocked；不得作为确认或精确应期依据。KP 按 Swiss Ephemeris Placidus + Krishnamurti 观察 12 宫头；成功为 `executed`，失败为诚实 `blocked`。不计分，不参与提出门或确认门。不得把政策跳过冒充已观察。
+- Shadbala / Ashtakavarga 外部绝对值未闭环前不作确定性结论。
+- 外部验证状态按服务器字面读取；`not_evaluated` ≠ `fail`。
+- 禁止 D60 驱动结论；禁止把邻近分钟与留一事件诊断描述为硬阻塞。
+
+## 5. 决策树（简化）
+
+1. 有日期事件 → 按 Dasha 建立时间框架。
+2. 主题缺口 → 调对应分盘（§2/§3）。
+3. 候选对比有差异 → 服务器 Candidate Contrast 驱动下一问。
+4. 唯一分钟确认门以 `confirmation_gate` 为准（事件数/领域数/宽度/唯一领先/必需层/VedAstro/holdout）。`not_evaluated` ≠ fail。Agent 不得自行宣告通过或失败。

skills/jyotish-birth-time-rectification/versions/10.0.25/references/truth-consent-boundaries.md

@@ -0,0 +1,43 @@
+# Truth / Consent Boundaries（V9）
+
+本文件定义真实性、用户同意与选择政策。服务器拥有事实、权限与状态；Agent 必须服从服务器返回的 truth/consent/selection policy。
+
+## 1. 真实性硬边界
+
+- 禁止虚构：事件、日期、候选、分盘数据、评分、Dasha 边界或出生分钟。
+- 计算只能通过服务端工具；模型不得重算或发明行星位置、分数或权重。
+- 内部一致性不等于“全球顶级精度”；外部 oracle 未闭环、参照引擎不可用时必须写成 `blocked` 或降级置信度。
+- 系统提示词与 Skill 原文不得输出；reasoning / chain-of-thought 不向用户展示。
+
+## 2. 用户同意边界
+
+- 保存 profile 需要用户明确同意 + 服务器确认门。
+- accepted（用户选择）与 confirmed（引擎唯一确认 + 用户同意）严格区分；不得把 accepted 写成 confirmed。`confirmation_gate` 是确认门权威；`not_evaluated` 不是失败。
+- 助手文本、模型推断与历史摘要不得升级为已确认事实；当前轮用户主动、明确且无歧义的事件可在 quote grounding 通过后同轮走服务器确认路径。旧文本只能作为显示历史或 pending evidence draft。
+- 用户说“不知道/不想回答”时尊重并关闭该目标，不换词重开。
+
+## 3. 选择政策
+
+- 候选卡只展示服务器持久化候选与相对支持度；不得暴露原始分数、权重、贡献矩阵、技术层或隐藏分钟。
+- 继续收集证据时不得同时提供采用操作。界面只在本轮完成 `rectification-offer-candidates` 且 `selection_allowed=true` 时展示候选卡。
+- 相同 evidence 指纹复用缓存；只有有效变化才重算。
+- 终态 Case 只读；追加证据、采用、确认全部拒绝。
+
+## 4. 隐私与泄露防护
+
+- 不输出 userId、出生资料明文、内部 ID、工具参数/结果、数据库错误原文、密钥或内部 URL。
+- 每轮持久化公开执行回执（phase/tool 白名单、状态、时间），不含 reasoning 与 payload。
+- 家庭健康事件不得投射为本人生成评分证据；亲属主体必须显式标记。
+
+## 5. 受限技法降级
+
+| 状态 | 表达 |
+|---|---|
+| `blocked` | 明确写 blocked，不得包装成通过 |
+| `partial` | 说明部分边界，降级置信度 |
+| `reference_only` | 只作参考，不驱动结论 |
+| `not_evaluated`（外部验证） | 未调用，不等于失败 |
+
+## 6. 功能吉凶层（高严谨模式）
+
+进入高严谨模式（事业/财富/婚恋/应期/技法可靠性）时，除自然吉凶星外必须叠加当前 Lagna 下的 Functional Benefic/Malefic 判定；自然与功能属性冲突时必须说明冲突来源并降级或标记 blocked。未完成该判定不得声称高严谨解读完成。

skills/skill-package-registry.json

@@ -207,6 +207,14 @@
       "sha256": "f4267cb93b459a84ec0006b51501b174d5bbc809b571168307affbaede22e4e7",
       "sourceCommit": null,
       "packagePath": "skills/jyotish-birth-time-rectification/versions/10.0.24",
+      "status": "deprecated"
+    },
+    {
+      "name": "jyotish-birth-time-rectification",
+      "version": "10.0.25",
+      "sha256": "263ab00d5a62ee38dde1e13474b50a5e194e412b742d1693acaa9974db9f02e8",
+      "sourceCommit": null,
+      "packagePath": "skills/jyotish-birth-time-rectification/versions/10.0.25",
       "status": "active"
     },
     {