fix(rectification): downgrade yearless personality probes to tie-breakers (BUG-629)

Ask dated dasha probes first; D9/D10 and nakshatra wait until that pool is empty, score at half weight, and never eliminate. Skill 10.0.21. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-10 00:26:58 +08:00
parent eb8a3120e5
commit fef54b6e42
41 changed files with 1452 additions and 70 deletions
@@ -1,5 +1,10 @@
 # 印度占星 Skill 更新日志

+## 2026-09-09 — 性格点选题只在分不开时才问，且只作排序参考
+
+生时校正的性格类点选题（相处方式、做事风格、月宿边界）不再和带年月的经历题同权。带年月的区分题还问得完时，先问那些题；只在问完仍分不开、还剩两个以上候选时才出性格题。答了只轻轻排序，不会因为性格自评把某一分钟淘汰。验证报告里这两行标成「参考」。Skill 10.0.21。
+
+
 ## 2026-09-09 — 初始化后点「家庭」会真正排盘，不再报步骤没完成

 填完生辰和地址后，从首页点「家庭」等主题，会先按该主题排盘再写回答，不再出现「Agent 未完成必要的方法与计算步骤，本次不会扣点」。点卡不会改你看到的那句问题。自己在输入框里问的普通问题仍可一次看多个领域。Skill 版本不变。
@@ -9732,6 +9732,22 @@
 - 复发自：无
 - 修复版本：待发布

+## BUG-629 | 无年月性格题与带年月题同权，参与了淘汰
+
+- 状态：resolved
+- 首次发现：2026-09-09
+- 最近更新：2026-09-09
+- 影响面：`applyProbeOutcome`、`buildMethodFollowupPlan`、技法审计表、Skill 10.0.21
+- 用户现象：真实校正里头两道题就是性格自评（相处方式 / 做事风格）。这些题没有年月锚点以外的分辨力验证，却按 ±2 计分并计入三次淘汰。
+- 触发条件：账本已有感情或事业锚点（BUG-559），候选尚未分开，计划层把 `varga_style` / `nakshatra_boundary` 与带年月区分题排在同一池。
+- 根因：`varga_style` 与带年月 `dasha_boundary` 共用 `SCORE_DELTA` 和 `strong_conflict_count`。分盘星座是确定计算，「星座 ↔ 性格」「用户自评 ↔ 类型」两层从未校准。
+- 修复：性格题只在可问的带年月区分题为空、且仍有 ≥2 个未分开候选时才成为下一问，否则 `dropped_probes(reason="yearless_deferred")`。分值 ×0.5（±1），不递增冲突次数，`rounds.kind=tie_break`。报告 `D9 / D10 类型对照` 与 `月宿边界` 标 `reference`。离线脚本只对医院记录且不确定度 ≤2 分钟的匿名导出算命中率。
+- 验证：`frontend/tests/rectification-yearless-probe-downgrade-20260909.test.ts`；`tests/test_varga_style_calibration_report.py`；既有 `rectification-probe-replay-loss-20260908.test.ts` 断言未改。
+- 防复发：不得把 `varga_style` / `nakshatra_boundary` 加回带年月区分池；不得让性格冲突计入 `STRONG_CONFLICT_ELIMINATION_COUNT`；不得改 `SCORE_DELTA` 数值来代替权重。`asInferenceState` 的 `ROUND_KINDS` 必须含 `tie_break`，否则答过性格题的 `inference_state` 整份被丢掉。审计列 CHECK 仍只认 `informative` / `low_information`；`tie_break` 只活在 JSON，不得为迁列把 kind 改回 `informative`。
+- 相关记录：BUG-559、BUG-560、BUG-623
+- 复发自：无
+- 修复版本：待发布
+
 ## BUG-630 | 初始化后点首页「家庭」报运行合同未完成（runtime_contract_incomplete）

 - 状态：resolved
@@ -0,0 +1,76 @@
+# 性格题离线命中率导出（医院记录）
+
+产品负责人在有数据库权限的环境跑。执行方不能替你跑。导出给 `scripts/rectification/varga_style_calibration_report.py` 用。
+
+只导出哈希后的 `case_id`。不要导出姓名、出生日期、地点、坐标、邮箱、原话、用户 ID。
+
+筛选在脚本里还会再做一遍：`birth_time_source = hospital_record` 且前后不确定度都 ≤ 2 分钟。SQL 先收窄，减少体积。
+
+`recorded_sign` 必须是**档案里的记录分钟**在该层的分盘星座（或月宿），不是校正后的采用分钟。星座名与选项 `sign` 用同一套中文名（例如 `天秤座`）。
+
+```sql
+-- service_role / schema_owner。输出一行一个 JSON 对象，外层再包成 {"cases":[...]}。
+-- 需要 pgcrypto：encode(digest(...), 'hex')。
+
+with latest_transition as (
+  select distinct on (t.case_id)
+    t.case_id,
+    t.inference_state
+  from public.agentic_rectification_inference_transitions t
+  order by t.case_id, t.revision desc
+),
+hospital_cases as (
+  select
+    encode(digest(c.id::text, 'sha256'), 'hex') as case_id_hash,
+    c.baseline_birth_snapshot->>'birth_time_source' as birth_time_source,
+    to_char((c.baseline_birth_snapshot->>'reported_birth_time')::time, 'HH24:MI') as recorded_minute,
+    (c.baseline_birth_snapshot->>'uncertainty_before_minutes')::int as uncertainty_before_minutes,
+    (c.baseline_birth_snapshot->>'uncertainty_after_minutes')::int as uncertainty_after_minutes,
+    lt.inference_state
+  from public.agentic_rectification_cases c
+  join latest_transition lt on lt.case_id = c.id
+  where c.baseline_birth_snapshot->>'birth_time_source' = 'hospital_record'
+    and coalesce((c.baseline_birth_snapshot->>'uncertainty_before_minutes')::int, 99) <= 2
+    and coalesce((c.baseline_birth_snapshot->>'uncertainty_after_minutes')::int, 99) <= 2
+    and nullif(c.baseline_birth_snapshot->>'reported_birth_time', '') is not null
+)
+select jsonb_build_object(
+  'cases',
+  coalesce(jsonb_agg(
+    jsonb_build_object(
+      'case_id_hash', h.case_id_hash,
+      'birth_time_source', h.birth_time_source,
+      'recorded_minute', h.recorded_minute,
+      'uncertainty_before_minutes', h.uncertainty_before_minutes,
+      'uncertainty_after_minutes', h.uncertainty_after_minutes,
+      'answers', coalesce((
+        select jsonb_agg(
+          jsonb_build_object(
+            'semantic_key', probe->>'semantic_key',
+            'answer_class', ans->>'answer_class',
+            'recorded_sign', null,  -- 用记录分钟在该层的星座/月宿填上；不要用采用分钟
+            'options', coalesce(probe->'style_options', '[]'::jsonb)
+          )
+        )
+        from jsonb_array_elements(coalesce(h.inference_state->'answered_probes', '[]'::jsonb)) ans
+        join jsonb_array_elements(coalesce(h.inference_state->'probes', '[]'::jsonb)) probe
+          on probe->>'id' = ans->>'probe_id'
+          or probe->>'semantic_key' = ans->>'semantic_key'
+        where (
+          probe->>'choice_kind' = 'varga_style'
+          or probe->>'source' = 'nakshatra_boundary'
+        )
+      ), '[]'::jsonb)
+    )
+  ), '[]'::jsonb)
+) as payload
+from hospital_cases h;
+```
+
+把结果存成 JSON 后：
+
+```bash
+.venv/bin/python scripts/rectification/varga_style_calibration_report.py export.json
+```
+
+只打印 `d9` / `d10` / `nakshatra` 的 `n` 与 `hit_rate`。命中率接近 1/3（三选一随机）时，再由产品决定是否删题。
@@ -0,0 +1,54 @@
+# PROGRESS · 无年月性格题降级（2026-09-09）
+
+工作树：`.worktrees/rectification-yearless-probe-downgrade-20260909`
+分支：`codex/rectification-yearless-probe-downgrade-20260909`
+任务书：`docs/tasks/TASK-rectification-yearless-probe-downgrade-20260909.md`
+基线：任务书写 `4eea9c10`；开工时接到 `origin/staging` @ `eb8a3120`（家庭合同 BUG-630 已在其上）。本单不依赖 BUG-626～628，不碰 `holdoutFollowupFor` / 领域别名。
+
+## 开工回执
+
+- 编号 **BUG-629**（`docs/BUG_HISTORY.md` 当时最大已发布号是 628；630 是同日另一条家庭合同，本单不占用）。
+- 顺序：3.2 权重 → 3.1 计划层 → 3.3 报告/Skill 10.0.21 → 3.4 离线脚本 → 3.5 记录。
+
+## 已完成
+
+- **3.2**：`PROBE_WEIGHT = { dated: 1, yearless: 0.5 }`。`applyProbeOutcome` 对 `varga_style` 与 `source=nakshatra_boundary` 乘 0.5、不递增 `strong_conflict_count`、`kind=tie_break`。`SCORE_DELTA` 数值未改。不确定答仍是 `low_information`。`asInferenceState` 的 `ROUND_KINDS` 补上 `tie_break`，否则答过性格题的 `inference_state` 整份被解析丢掉（审计列 CHECK 仍只认 `informative` / `low_information`，`tie_break` 只活在 JSON）。
+- **3.1**：`varga_style` 退出带年月锁定期桶，进入 `personality`。可问的 `dasha_boundary` / `dasha_activation` 仍在时，性格题 `yearless_deferred`。带年月题空且 ≥2 个未分开候选才问。1 个候选或已分开则不问。锚点（BUG-559）保留。`decideFromDossier` 把真实分离状态传进计划层，不再写死 `false`。
+- **3.3**：技法审计表 `D9 / D10 类型对照`、`月宿边界` 为 `reference`，说明「性格自评，只作排序参考，不参与淘汰」。Skill **10.0.21**（live + `versions/10.0.21`，sha256 `3ced107366b2c4b0f26bae81440162032501f77a8d762d42c84a20fa394ea807`）。§5 一句：「性格类点选题只在带年月题问完仍分不开时出现，分值减半、不淘汰。」三列卡性格描述未改。未改 `frontend/DESIGN.md`（无视觉改动）。
+- **3.4**：`scripts/rectification/varga_style_calibration_report.py` 只对医院记录且不确定度 ≤2 分钟聚合命中率。导出 SQL：`docs/operations/varga-style-calibration-export.md`（产品跑；本环境无库）。
+- **3.5**：BUG-629、CHANGELOG、走查 `docs/testing/rectification-scenarios-20260907.md` 第 0 条与第 8 条。任务板「待验收」。
+
+## 三栏（既有断言）
+
+| 位置 | 原值 | 新值 | 原因 |
+| --- | --- | --- | --- |
+| 性格题分值 / 淘汰 | ±2、计 `strong_conflict_count` | ±1、不计 | 任务书决策 2 |
+| `rectification-varga-style-weight.test.ts` 两组/三组绝对 delta | 2 与 `[2,2,2]` | 1 与 `[1,1,1]` | 决策 2 |
+| 同上 B 选项三次弱是 | 计 3 次冲突并淘汰 | 计数 0、不淘汰 | 决策 2 |
+| Skill 当前钉 | 10.0.20 | 10.0.21 | 任务书决策 3 |
+| `rectification-eight-method.test.ts` 绑定 D9 探针 | next 是 `varga.d9`，压过 `relationship.2021` | next 是 `relationship.2021.dasha_activation`；D9 `yearless_deferred` | 决策 1 |
+| 同上 D10 增益 3.1 vs `career.2018` | next 是 `varga.d10` | next 是 `career.2018.dasha_activation`；D10 `yearless_deferred` | 决策 1 |
+| `rectification-probe-replay-loss-20260908.test.ts` | 未改 | 未改 | 任务书：带年月题逐字节不变 |
+
+## 验收命令（实测）
+
+工作树 `codex/rectification-yearless-probe-downgrade-20260909`，相对 `origin/staging` @ `eb8a3120`。
+
+| 命令 | 结果 |
+| --- | --- |
+| `frontend` `./node_modules/.bin/tsc --noEmit` | 0 错 |
+| `npm run lint` | **0 error**，108 warning（与门禁口径一致，未顺手改） |
+| `ls tests/rectification-*.test.ts tests/skill-registry.test.ts \| grep -v database \| xargs npx tsx --test` | **1087 tests / 1087 pass / 0 fail**（开工基线同 glob 为 1086；本单新增 `asInferenceState` 性格轮回放 1 条） |
+| `.venv/bin/python -m pytest tests/test_varga_style_calibration_report.py` | 通过 |
+| `next build` | 未跑（本机耗时长；无 Docker。首页 Static / gzip 留给验收） |
+
+## 环境缺口
+
+- 无 Docker：未跑 `npm run test:db`、未应用迁移（本单无表结构改动；`round_kind` 列 CHECK 仍是 `informative` / `low_information`）。
+- 无登录态、无 Chrome：`docs/testing/rectification-scenarios-20260907.md` 第 0 条真人走查未做。
+- 无生产/预发库：校准导出 SQL 未跑，命中率数字未测。
+
+## 未做
+
+- 未 commit、未 push、未提升 `main`。
+- 未改 `SCORE_DELTA`、四选项合同、采用/确认门、`MIN_SEPARATION_LEAD`、三列性格描述。
@@ -92,7 +92,7 @@
 | `TASK-rectification-window-cluster-cap-20260909.md` | `PROGRESS-rectification-window-cluster-cap-20260909.md` | **P0** 真实用户：一小时窗口分 17 个签名簇，`select_signature_representatives` 按时间取前 12 个，14:40 之后整簇丢弃（本机复现表）；区间按代表分钟跨度而非簇覆盖；中途说出真实时段时助手口头答应却未改 → 改为固定回复"范围开始时按资料定、中途不改"（产品否决口头改范围）；intake 自定义范围等产品答复 | 待验收 | `codex/rectification-window-cluster-cap-20260909`（BUG-623～625，Skill 10.0.20）；走查 `docs/testing/rectification-window-cluster-cap-20260909.md` |
 | `TASK-rectification-skipped-health-deadend-20260909.md` | `PROGRESS-rectification-skipped-health-deadend-20260909.md` | 真实用户：健康题「记不清」后职业答完即断（『没有拿到下一个问题』）：holdout 的 `declined` 未归并 health/health_pressure，把跳过的健康线再问一次，撞同 id 焦点 `duplicate_focus` 静默；出口闸门把 `exhausted` 当已交付不修复；『重新加载』只重取快照 | 待执行 | `codex/rectification-skipped-health-deadend-20260909`（BUG-626～627） |
 | `TASK-rectification-domain-alias-audit-20260909.md` | `PROGRESS-rectification-domain-alias-audit-20260909.md` | 领域命名审计：健康线 `health`（账本/焦点）与 `health_pressure`（计划/引擎）在十处比较里六处未归并（holdout declined、reverse-verify、conflict probes、probeYearAlreadyCovered、引擎 oos_blind_prompts / _event_years / volunteered）；职业线焦点存为 `other` 只靠 questionId 兜底。其余六领域三层同名无问题。决策：TS/Python 各一个归并函数 + 源码合同禁字面量比较 | 待执行 | `codex/rectification-domain-alias-audit-20260909`（BUG-628） |
-| `TASK-rectification-yearless-probe-downgrade-20260909.md` | `PROGRESS-rectification-yearless-probe-downgrade-20260909.md` | 产品拍板：无年月性格题（D9/D10 风格、月宿边界）降级为平局裁决——带年月题问完且候选仍分不开才问，分值减半（±1）、不计淘汰，报告标「参考」；三列卡性格描述不动；新增离线命中率测量脚本 + 导出 SQL（有出生证用户，聚合）；Skill 10.0.21 | 待执行 | `codex/rectification-yearless-probe-downgrade-20260909`（BUG-629） |
+| `TASK-rectification-yearless-probe-downgrade-20260909.md` | `PROGRESS-rectification-yearless-probe-downgrade-20260909.md` | 产品拍板：无年月性格题（D9/D10 风格、月宿边界）降级为平局裁决——带年月题问完且候选仍分不开才问，分值减半（±1）、不计淘汰，报告标「参考」；三列卡性格描述不动；新增离线命中率测量脚本 + 导出 SQL（有出生证用户，聚合）；Skill 10.0.21 | 待验收 | `codex/rectification-yearless-probe-downgrade-20260909`（BUG-629） |

 ### 聊天主链路与首页

@@ -8,10 +8,12 @@

 资料：家人记得大概时间，钟点任意，范围「差不多准」。地点任意公开城市。

-开场后依次说三件不同领域、带年月的虚构经历，等到出现候选比较和性格对照卡。答完一张性格卡后，再说一件带年月的事。
+开场后依次说三件不同领域、带年月的虚构经历，等到出现候选比较。**先会出现带年月的点选题**（某年前后有没有某类事）。把能答的带年月题答完，候选还分不开时，才可能出现性格对照卡。答完一张性格卡后，再说一件带年月的事。

 期望：

+- 有可问的带年月区分题时，不得先出性格卡（相处方式 / 做事风格 / 月宿两组性格）
+- 性格卡出现时，旁边或报告里应能看出这是参考，不是淘汰依据
 - 顶部范围必须变化，或旁白说明这次比较没跑成、下一句会再试
 - 不得出现：比较失败后仍只写「记下了、很有帮助」，顶部范围完全不动
 - 点「先这样，先看当前范围」后必须出现候选卡或当前范围，不得只剩「没有拿到下一个问题」
@@ -172,3 +174,15 @@
 - 想跳过可以打字「没有」或「记不清」
 - 每轮助手正文一句复述（可另接一句范围变化）；气泡里没有「本轮对照了…」，也没有「很有帮助 / 很有价值 / 很有分量 / 特别有用」

+## 8. 性格题只作平局参考（BUG-629）
+
+资料与开场同第 0 条。虚构经历。
+
+期望：
+
+- 2023 年 5 月这类带年月事业题还问得完时，不出 D9 相处方式卡
+- 带年月区分题问完、还剩两个候选、仍分不开：可以出性格卡
+- 只剩一个候选：不再出性格卡
+- 交付后展开验证报告，「D9 / D10 类型对照」和「月宿边界」状态是 `reference`，说明是性格自评、只作排序参考、不参与淘汰
+- 三列对照卡上的性格句子仍按类型表展示，不改写
+
@@ -5,6 +5,7 @@ import {
  type TransitionSignLookup,
 } from "./sign-from-transitions.ts";
 import {
+  PROBE_WEIGHT,
  SCORE_DELTA,
  STRONG_CONFLICT_ELIMINATION_COUNT,
  type AnswerClass,
@@ -16,11 +17,17 @@ import {
 export type ProbeApplyResult = Readonly<{
  scores: Readonly<Record<string, number>>;
  eliminated_ids: readonly string[];
-  kind: "informative" | "low_information";
+  kind: "informative" | "low_information" | "tie_break";
  deltas: Readonly<Record<string, number>>;
  strong_conflict_counts: Readonly<Record<string, number>>;
 }>;

+export function isYearlessPersonalityProbe(
+  probe: Pick<ConflictProbe, "choice_kind" | "source">,
+): boolean {
+  return probe.choice_kind === "varga_style" || probe.source === "nakshatra_boundary";
+}
+
 export type ProbeDirectionContext = Readonly<{
  probe?: ConflictProbe;
  transitions?: readonly TransitionSignLookup[];
@@ -181,15 +188,19 @@ export function applyProbeOutcome(
    };
  }
  const context: ProbeDirectionContext = { probe, transitions: options.transitions };
+  const yearless = isYearlessPersonalityProbe(probe);
+  const weight = yearless ? PROBE_WEIGHT.yearless : PROBE_WEIGHT.dated;
  for (const [id, score] of Object.entries(scores)) {
    const direction = directionFor(id, outcome, probe.choice_kind, context);
-    if (direction === "conflict") conflictCounts[id] = (conflictCounts[id] ?? 0) + 1;
+    if (direction === "conflict" && !yearless) {
+      conflictCounts[id] = (conflictCounts[id] ?? 0) + 1;
+    }
    if (eliminated.has(id)) {
      next[id] = score;
      deltas[id] = 0;
      continue;
    }
-    const delta = SCORE_DELTA[direction];
+    const delta = SCORE_DELTA[direction] * weight;
    deltas[id] = delta;
    next[id] = score + delta;
  }
@@ -210,7 +221,7 @@ export function applyProbeOutcome(
  return {
    scores: next,
    eliminated_ids: [...eliminated],
-    kind: changed ? "informative" : "low_information",
+    kind: yearless ? "tie_break" : (changed ? "informative" : "low_information"),
    deltas,
    strong_conflict_counts: conflictCounts,
  };
@@ -16,7 +16,7 @@ export type InferenceTransitionSnapshot = Readonly<{
  entropyBefore?: number | null;
  entropyAfter?: number | null;
  eliminatedCandidateIds?: readonly string[];
-  roundKind?: "informative" | "low_information" | null;
+  roundKind?: "informative" | "low_information" | "tie_break" | null;
 }>;

 const CLOCK = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
@@ -34,7 +34,7 @@ const EVENT_USAGES = new Set(["training", "holdout", "unused"]);
 const ANSWER_CLASSES = new Set(["yes", "weak_yes", "no", "unsure"]);
 const PROBE_CHOICE_KINDS = new Set(["existence", "varga_style", "event_quality"]);
 const ANSWER_SOURCES = new Set(["choice", "evidence", "declined"]);
-const ROUND_KINDS = new Set(["informative", "low_information"]);
+const ROUND_KINDS = new Set(["informative", "low_information", "tie_break"]);
 const SCORE_DIRECTIONS = new Set(["support", "weak_support", "neutral", "weak_conflict", "conflict"]);

 function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
@@ -47,6 +47,12 @@ export const SCORE_DELTA: Readonly<Record<ScoreDirection, number>> = {
  conflict: -2,
 };

+/** Dated distinguish probes keep full SCORE_DELTA. Yearless personality is tie-break only. */
+export const PROBE_WEIGHT = {
+  dated: 1,
+  yearless: 0.5,
+} as const;
+
 export type InferenceCandidate = Readonly<{
  id: string;
  time: string;
@@ -116,7 +122,7 @@ export type RoundTrace = Readonly<{
  entropy_after: number;
  eliminated_ids: readonly string[];
  winner_id: string | null;
-  kind: "informative" | "low_information";
+  kind: "informative" | "low_information" | "tie_break";
 }>;

 export type InferenceState = Readonly<{
@@ -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.20";
+export const RECTIFICATION_SKILL_VERSION = "10.0.21";
@@ -25,6 +25,7 @@ import {
  type HoldoutValidationStatus,
  type RectificationDecision,
 } from "../core/rectification-decision.ts";
+import { evaluateCandidateSeparation } from "../core/candidate-separation.ts";
 import type { ConflictProbe, InferenceState } from "../core/types.ts";
 import {
  askedDiscriminatorKeys,
@@ -277,6 +278,11 @@ export function contrastPacketFromDossier(dossier: DecisionDossier): CandidateCo
  return contrastPacketFromLatestResult(dossier.latestResult, dossier.evidence);
 }

+function dossierCandidatesSeparated(dossier: DecisionDossier): boolean {
+  const separation = evaluateCandidateSeparation(candidateScoresFromDossier(dossier.latestResult));
+  return separation.status === "separated" || separation.status === "sole_candidate";
+}
+
 export function rectificationFollowupCatalog(
  latest: DecisionDossier["latestResult"] | undefined,
  evidence: DecisionDossier["evidence"] = [],
@@ -474,7 +480,7 @@ function discriminatorProbeIfFollowupCanAsk(input: {
    ...(input.contrastPacket ? { contrastPacket: input.contrastPacket } : {}),
    ...(input.askedKeys ? { askedProbeKeys: input.askedKeys } : {}),
    ...(input.birthDate ? { birthDate: input.birthDate } : {}),
-    candidatesSeparated: false,
+    candidatesSeparated: dossierCandidatesSeparated(input.dossier),
  });
  const dropped = mergeDroppedProbes(input.inspected.dropped, plan.dropped_probes);
  if (!followupAsksRenderableDiscriminator(plan.next_followup)) {
@@ -544,7 +550,7 @@ function nakshatraProbeIfFollowupCanAsk(input: {
    oosBlindPrompts: catalog.oosBlindPrompts,
    holdoutEvents: catalog.holdoutEvents,
    ...(input.birthDate ? { birthDate: input.birthDate } : {}),
-    candidatesSeparated: false,
+    candidatesSeparated: dossierCandidatesSeparated(input.dossier),
  });
  if (!followupAsksRenderableDiscriminator(plan.next_followup)) {
    return { probe: null, dropped: mergeDroppedProbes(inspected.dropped, plan.dropped_probes) };
@@ -43,9 +43,9 @@
 * Scoring A/B/C/D reverse-inference needs the engine year/month.
 * Yearless varga splits do not borrow a ledger year. Pick the next
 * dated discriminator, or collect a dated event in that domain.
- * Remaining chart discriminators (D9/D10 style and dated dasha
- * probes) stay in the pool; the highest information-gain renderable
- * probe is asked next, with no preferred domain.
+ * Remaining dated dasha distinguish probes are asked first. Yearless
+ * D9/D10 style and nakshatra_boundary wait until that pool is empty and
+ * at least two active candidates are still unseparated (BUG-629).
 * If holdout is already reserved but training is still short,
 * keep collecting a dated event instead of discriminating.
 * Once blocking methods are covered, move into candidate discrimination.
@@ -1082,11 +1082,35 @@ function discriminatorChoiceKind(row: RankedDiscriminator): string {
 }

 function discriminatorLocksScoringPeriod(row: RankedDiscriminator): boolean {
-  if (discriminatorChoiceKind(row) === "varga_style") return true;
+  if (discriminatorChoiceKind(row) === "varga_style") return false;
  const year = row.eventProbe?.year ?? row.contrastProbe?.year ?? 0;
  return year > 0;
 }

+function isYearlessPersonalityRow(row: RankedDiscriminator): boolean {
+  return discriminatorChoiceKind(row) === "varga_style";
+}
+
+function yearlessPersonalityCanAsk(input: {
+  datedCount: number;
+  candidatesSeparated: boolean;
+  topCandidateTimes?: readonly string[];
+}): boolean {
+  if (input.datedCount > 0 || input.candidatesSeparated) return false;
+  const times = input.topCandidateTimes;
+  if (times !== undefined && times.length < 2) return false;
+  return true;
+}
+
+function emptyRankedCatalog(): {
+  locked: RankedDiscriminator[];
+  personality: RankedDiscriminator[];
+  yearless: RankedDiscriminator[];
+  dropped: DroppedProbe[];
+} {
+  return { locked: [], personality: [], yearless: [], dropped: [] };
+}
+
 function rankRenderableDiscriminators(input: {
  eventProbes: readonly DiscriminatingEventProbe[];
  contrastProbes: readonly CandidateDiscriminatorProbe[];
@@ -1096,7 +1120,7 @@ function rankRenderableDiscriminators(input: {
  providedDomains?: readonly string[];
  evidence?: readonly MethodFollowupEvidence[];
  birthDate?: string | null;
-}): { locked: RankedDiscriminator[]; yearless: RankedDiscriminator[]; dropped: DroppedProbe[] } {
+}): { locked: RankedDiscriminator[]; personality: RankedDiscriminator[]; yearless: RankedDiscriminator[]; dropped: DroppedProbe[] } {
  const top = input.topCandidateTimes ?? [];
  const provided = new Set(input.providedDomains ?? []);
  const mentioned = input.mentionedKeys ?? new Set();
@@ -1146,7 +1170,8 @@ function rankRenderableDiscriminators(input: {
  const sorted = rows.sort((left, right) => right.score - left.score || (right.eventProbe?.information_gain ?? right.contrastProbe?.informationGain ?? 0) - (left.eventProbe?.information_gain ?? left.contrastProbe?.informationGain ?? 0));
  return {
    locked: sorted.filter((row) => discriminatorLocksScoringPeriod(row)),
-    yearless: sorted.filter((row) => !discriminatorLocksScoringPeriod(row) && discriminatorChoiceKind(row) !== "varga_style"),
+    personality: sorted.filter((row) => isYearlessPersonalityRow(row)),
+    yearless: sorted.filter((row) => !discriminatorLocksScoringPeriod(row) && !isYearlessPersonalityRow(row)),
    dropped,
  };
 }
@@ -1992,7 +2017,7 @@ export function buildMethodFollowupPlan(input: {
    ...(input.askedProbeKeys ?? []),
  ]);
  const rankedCatalog = input.caseStage === "block_scan"
-    ? { locked: [] as RankedDiscriminator[], yearless: [] as RankedDiscriminator[], dropped: [] as DroppedProbe[] }
+    ? emptyRankedCatalog()
    : dashaCovered && meetsAcceptanceEventQuality(input.evidence)
    ? rankRenderableDiscriminators({
      eventProbes: remainingConflictProbes(input.eventProbes, input.evidence, declined, askedKeys, input.birthDate),
@@ -2004,8 +2029,9 @@ export function buildMethodFollowupPlan(input: {
      evidence: input.evidence,
      birthDate: input.birthDate,
    })
-    : { locked: [] as RankedDiscriminator[], yearless: [] as RankedDiscriminator[], dropped: [] as DroppedProbe[] };
+    : emptyRankedCatalog();
  const rankedDiscriminators = rankedCatalog.locked;
+  const personalityDiscriminators = rankedCatalog.personality;
  const yearlessDiscriminators = rankedCatalog.yearless;
  const bestDiscriminator = rankedDiscriminators[0] ?? null;
  const catalogWinnerKey = rankedDiscriminatorKey(bestDiscriminator);
@@ -2298,6 +2324,30 @@ export function buildMethodFollowupPlan(input: {
      }
    }
  }
+  const personalityAllowed = yearlessPersonalityCanAsk({
+    datedCount: rankedDiscriminators.length,
+    candidatesSeparated,
+    topCandidateTimes: input.topCandidateTimes,
+  });
+  if (dashaCovered && personalityAllowed && !next) {
+    const allowLowGainDiscriminator = !coverageComplete || !candidatesSeparated;
+    for (const ranked of personalityDiscriminators) {
+      if (!allowLowGainDiscriminator && ranked.score < 0.08) continue;
+      const candidate = followupFromRanked(ranked);
+      if (candidate.choice_frame) {
+        next = candidate;
+        break;
+      }
+    }
+  } else {
+    for (const ranked of personalityDiscriminators) {
+      extraDropped.push(droppedFromProbe(
+        ranked.eventProbe?.semantic_key ?? ranked.contrastProbe?.semanticKey ?? "varga_style",
+        ranked.eventProbe?.information_gain ?? ranked.contrastProbe?.informationGain ?? ranked.score,
+        "yearless_deferred",
+      ));
+    }
+  }
  if (!next && !dashaCovered) {
    next = makeFollowup({
      method_id: "dasha_events",
@@ -2341,6 +2391,7 @@ export function buildMethodFollowupPlan(input: {
  }
  if (
    !next
+    && personalityAllowed
    && input.holdoutValidation !== "not_started"
    && !datedMethodCollectOpen(methods)
    && input.nakshatraProbe
@@ -2373,6 +2424,12 @@ export function buildMethodFollowupPlan(input: {
        reason: "not_renderable",
      });
    }
+  } else if (input.nakshatraProbe && !personalityAllowed) {
+    extraDropped.push(droppedFromProbe(
+      input.nakshatraProbe.semantic_key,
+      input.nakshatraProbe.information_gain,
+      "yearless_deferred",
+    ));
  }
  const sameDomainYearlessCard = (domain: string): MethodFollowup | null => {
    const ranked = yearlessDiscriminators.find((row) => (
@@ -36,6 +36,7 @@ export type ProbeRejectReason =
  | "yearless_ungrounded_contrast"
  | "no_split_among_active"
  | "unanchored_varga_style"
+  | "yearless_deferred"
  | "frameless_distinguish"
  | "same_year_asked"
  | "below_adult_floor";
@@ -129,21 +129,38 @@ export function buildSkillVerificationPacket(input: SkillVerificationReportInput
  const d10Table = d10TableSigns.length > 0
    ? ["| D10上升 | 事业特质 | 职业类型 | 工作风格 |", "|---|---|---|---|", ...d10TableSigns.map((sign) => typeRow(sign, "d10"))]
    : ["当前窗还没有可对照的 D10 上升名，类型表待候选换升后填写。"];
+  const PERSONALITY_AUDIT_NOTE = "性格自评，只作排序参考，不参与淘汰";
+
+  function isPersonalityAuditTechnique(name: string): boolean {
+    return /D9\s*\/\s*D10|类型对照|月宿/.test(name);
+  }
+
  const audit = (input.techniqueAuditTable ?? []).slice(0, 16);
+  const mappedAudit = audit.map((row) => {
+    const technique = row.technique ?? "技法";
+    if (isPersonalityAuditTechnique(technique)) {
+      return `| ${technique} | reference | ${PERSONALITY_AUDIT_NOTE} |`;
+    }
+    const executed = row.status === "executed" && Boolean(row.calculation_result_id);
+    const status = executed ? "executed" : (row.status === "executed" ? "input_covered" : (row.status ?? "blocked"));
+    const note = executed
+      ? (row.note ?? "")
+      : (row.note || "该方法所需资料已覆盖，没有可追溯的 calculationResultId，不能写成已执行。");
+    return `| ${technique} | ${status} | ${note} |`;
+  });
+  const auditText = mappedAudit.join("\n");
+  const withPersonalityRows = [
+    mappedAudit,
+    auditText.includes("D9 / D10 类型对照") ? [] : [`| D9 / D10 类型对照 | reference | ${PERSONALITY_AUDIT_NOTE} |`],
+    auditText.includes("月宿边界") ? [] : [`| 月宿边界 | reference | ${PERSONALITY_AUDIT_NOTE} |`],
+  ].flat();
  const auditRows = audit.length > 0
-    ? audit.map((row) => {
-      const executed = row.status === "executed" && Boolean(row.calculation_result_id);
-      const status = executed ? "executed" : (row.status === "executed" ? "input_covered" : (row.status ?? "blocked"));
-      const note = executed
-        ? (row.note ?? "")
-        : (row.note || "该方法所需资料已覆盖，没有可追溯的 calculationResultId，不能写成已执行。");
-      return `| ${row.technique ?? "技法"} | ${status} | ${note} |`;
-    })
+    ? withPersonalityRows
    : [
      "| Vimshottari + 受控行运 | input_covered | 没有 calculationResultId 时不能写成已执行 |",
-      "| D9/D10 分盘 | input_covered | 类型表是校时方法；差异要进入区分探针 |",
+      `| D9 / D10 类型对照 | reference | ${PERSONALITY_AUDIT_NOTE} |`,
      "| 宫位 / 六亲六步 | input_covered | 后三步方法论层 |",
-      "| Nakshatra Pada | observation_only | 不确认唯一分钟 |",
+      `| 月宿边界 | reference | ${PERSONALITY_AUDIT_NOTE} |`,
      "| KP / D60 / Gulika | observation_only | 不进提出门或确认门计分 |",
      "| 占问 | observation_only | AI 暂不支持独立占问；有问起时间则观察 |",
    ];
@@ -1679,7 +1679,9 @@ function parseTransitionSnapshot(value: unknown): InferenceTransitionSnapshot |
    eliminatedCandidateIds: Array.isArray(row.eliminated_candidate_ids)
      ? row.eliminated_candidate_ids.filter((item): item is string => typeof item === "string")
      : [],
-    roundKind: row.round_kind === "informative" || row.round_kind === "low_information"
+    roundKind: row.round_kind === "informative"
+      || row.round_kind === "low_information"
+      || row.round_kind === "tie_break"
      ? row.round_kind
      : null,
  };
@@ -463,8 +463,8 @@ function rpcDossier(decision: DecisionDossier, activeFocus?: Record<string, unkn
  });
 }

-test("skill version is 10.0.20 after the delivery UI simplify bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.20");
+test("skill version is 10.0.21 after the delivery UI simplify bump", () => {
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
 });

 test("revision 5 with uncovered relatives asks the dated family collect, not a yearless D12 card", () => {
@@ -359,7 +359,7 @@ 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.20");
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");

  const accounting = fakeAccounting({
    ...receiptHandlers,
@@ -199,12 +199,12 @@ test("delivery report gives 04:53 D10 as Cancer instead of letting the model inf
  assert.match(report.markdown, /04:53 \| .*巨蟹座/);
 });

-test("skill 10.0.20 forbids computing varga signs from transition times", () => {
+test("skill 10.0.21 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.20");
-  assert.match(skill, /^version: 10\.0\.20$/m);
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
+  assert.match(skill, /^version: 10\.0\.21$/m);
  assert.match(skill, new RegExp(SKILL_SIGN_SENTENCE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
  assert.match(comparison, new RegExp(SKILL_SIGN_SENTENCE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
 });
@@ -1454,9 +1454,9 @@ 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.20", () => {
+test("public tool surface stays at 14 and new cases bind 10.0.21", () => {
  assert.equal(PUBLIC_RECTIFICATION_TOOLS.length, 14);
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.20");
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
  const deprecated = resolveExactSkillPackage(
    "jyotish-birth-time-rectification",
    "10.0.2",
@@ -1945,10 +1945,20 @@ test("confirmed relationship evidence skips generic D9 followups unless a real p
      candidate_split_hash: "set-test:relationship:2021",
    }],
  });
+  // 原值: 绑定真实 D9 探针时 next 是 varga.d9，压过同域 2021 带年月题
+  // 新值: next 是 relationship.2021.dasha_activation；D9 记 yearless_deferred
+  // 原因: BUG-629 决策 1，可问的带年月区分题优先于性格题
  assert.equal(probed.next_followup?.domain, "relationship");
  assert.equal(probed.next_followup?.source, "event_probe");
-  assert.equal(probed.next_followup?.semantic_key, "varga.d9.05:00|05:14");
-  assert.doesNotMatch(probed.next_followup?.semantic_key ?? "", /relationship\.2021/);
+  assert.equal(probed.next_followup?.semantic_key, "relationship.2021.dasha_activation");
+  assert.notEqual(probed.next_followup?.semantic_key, "varga.d9.05:00|05:14");
+  assert.equal(
+    probed.dropped_probes.some((item) => (
+      item.semantic_key === "varga.d9.05:00|05:14" && item.reason === "yearless_deferred"
+    )),
+    true,
+    JSON.stringify(probed.dropped_probes),
+  );
 });

 test("d9_refine after relationship still asks uncovered career first", () => {
@@ -2823,8 +2833,18 @@ test("same-year existence probes are skipped; a different-year dasha still ranks
    },
    candidatesSeparated: false,
  });
-  assert.equal(highest.next_followup?.semantic_key, d10.semanticKey);
-  assert.doesNotMatch(highest.next_followup?.semantic_key ?? "", /career\.2018/);
+  // 原值: next = varga.d10（增益 3.1 压过 career.2018）
+  // 新值: next = career.2018.dasha_activation；D10 记 yearless_deferred
+  // 原因: BUG-629 决策 1，带年月区分题优先于性格题
+  assert.equal(highest.next_followup?.semantic_key, "career.2018.dasha_activation");
+  assert.notEqual(highest.next_followup?.semantic_key, d10.semanticKey);
+  assert.equal(
+    highest.dropped_probes.some((item) => (
+      item.semantic_key === d10.semanticKey && item.reason === "yearless_deferred"
+    )),
+    true,
+    JSON.stringify(highest.dropped_probes),
+  );

  const d24Wins = buildMethodFollowupPlan({
    evidence,
@@ -576,8 +576,8 @@ function warnLines(run: () => Promise<unknown> | unknown) {
  }).then((result) => ({ result, lines }));
 }

-test("skill version is 10.0.20 after the delivery UI simplify bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.20");
+test("skill version is 10.0.21 after the delivery UI simplify bump", () => {
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
 });

 test("USER_COLLECT_QUESTION no longer has an other fallback", () => {
@@ -213,9 +213,9 @@ 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.20 and the prompt prefers batch ingest", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.20");
-  assert.match(skill, /^version: 10\.0\.20$/m);
+test("new-case skill identity is 10.0.21 and the prompt prefers batch ingest", () => {
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
+  assert.match(skill, /^version: 10\.0\.21$/m);
  assert.match(skill, /不要对同一句用户消息里的多件事件逐条 propose\+confirm/);
  assert.match(agentSource, /新事件走 rectification-record-evidence-batch/);
  assert.doesNotMatch(agentSource, /分别调用 rectification-propose-evidence 和 rectification-confirm-evidence/);
@@ -184,8 +184,8 @@ const CANDIDATE_IDS = [
  "88888888-8888-4888-8888-888888888882",
 ] as const;

-test("skill version is 10.0.20 after the delivery UI simplify bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.20");
+test("skill version is 10.0.21 after the delivery UI simplify bump", () => {
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
 });

 test("nineteen-row ledger opens the training gate with four scoreable domains", () => {
@@ -426,8 +426,8 @@ function rpcDossier(decision: DecisionDossier) {
  });
 }

-test("skill version is 10.0.20 after the delivery UI simplify bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.20");
+test("skill version is 10.0.21 after the delivery UI simplify bump", () => {
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
 });

 test("pre-fix dual-exit constant is gone; range narration carries numbers and the disclaimer", () => {
@@ -94,8 +94,8 @@ function collectPersistResult(overrides: {
  };
 }

-test("skill version is 10.0.20 after the delivery UI simplify bump", () => {
-  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.20");
+test("skill version is 10.0.21 after the delivery UI simplify bump", () => {
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
 });

 test("cases current_question remains the submit contract, not a visual slot", () => {
@@ -96,11 +96,11 @@ 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.20"));
+  assert.ok(RECTIFICATION_V9_PACKAGE_PATH.endsWith("skills/jyotish-birth-time-rectification/versions/10.0.21"));
  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.20");
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
 });

 test("step budgets are bounded per action with a hard ceiling", () => {
@@ -95,9 +95,9 @@ 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.20");
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
  assert.match(skill, /^---\nname: jyotish-birth-time-rectification/m);
-  assert.match(skill, /^version: 10\.0\.20$/m);
+  assert.match(skill, /^version: 10\.0\.21$/m);
  assert.match(skill, /至多一个主问题且唯一来源：[\s\S]*不得自行提出、复述、改写或预告问题/);
  for (const reference of references) {
    const content = readFileSync(`${skillDirectory}/references/${reference}`, "utf8");
@@ -209,7 +209,7 @@ 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.20",
+        skill_version: "10.0.21",
      };
    }
    return null;
@@ -247,11 +247,11 @@ 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.20");
+  assert.equal(response.skillVersion, "10.0.21");
  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.20");
+  assert.equal(openCall.args.p_skill_version, "10.0.21");
  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);
@@ -55,8 +55,11 @@ test("two-group varga_style A and B move their groups by the same absolute delta
  assert.notEqual(yesGroup, weakGroup);
  const yesDelta = absSupportDelta(probe, "yes", yesGroup);
  const weakDelta = absSupportDelta(probe, "weak_yes", weakGroup);
-  assert.equal(yesDelta, 2);
-  assert.equal(weakDelta, 2);
+  // 原值: 2 and 2（与带年月题同权）
+  // 新值: 1 and 1（仍相等）
+  // 原因: BUG-629 决策 2，PROBE_WEIGHT.yearless = 0.5
+  assert.equal(yesDelta, 1);
+  assert.equal(weakDelta, 1);
  assert.equal(yesDelta, weakDelta);
  const unsure = applyProbeOutcome(
    Object.fromEntries(probe.candidate_ids.map((id) => [id, 10])),
@@ -74,7 +77,10 @@ test("three-group varga_style A/B/C each carry full peer weight", () => {
    assert.ok(support, answer);
    return absSupportDelta(probe, answer, support);
  });
-  assert.deepEqual(scored, [2, 2, 2]);
+  // 原值: [2, 2, 2]
+  // 新值: [1, 1, 1]
+  // 原因: BUG-629 决策 2，三组性格题同样减半
+  assert.deepEqual(scored, [1, 1, 1]);
 });

 test("old ConflictProbe receipts without choice_kind keep half-weight weak_yes", () => {
@@ -136,8 +142,11 @@ test("varga_style B-option weak_yes counts as strong conflict; existence weak_ye
    styleCounts = { ...applied.strong_conflict_counts };
    eliminated = new Set(applied.eliminated_ids);
  }
-  assert.equal(styleCounts[styleConflicted], 3);
-  assert.equal(eliminated.has(styleConflicted), true);
+  // 原值: 三次 B 选项计 3 次强冲突并淘汰
+  // 新值: strong_conflict_count 仍为 0，不淘汰
+  // 原因: BUG-629 决策 2，性格题不计淘汰
+  assert.equal(styleCounts[styleConflicted], 0);
+  assert.equal(eliminated.has(styleConflicted), false);

  const existencePacket = buildCandidateContrastPacket({
    candidateSetVersion: "05:00-05:04",
@@ -80,5 +80,5 @@ 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.20");
+  assert.equal(RECTIFICATION_SKILL_VERSION, "10.0.21");
 });
@@ -0,0 +1,328 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { applyProbeOutcome } from "../src/lib/rectification-agentic/core/apply-probe-outcome.ts";
+import { applyAnswerToState, buildInferenceState } from "../src/lib/rectification-agentic/core/build-state.ts";
+import { asInferenceState } from "../src/lib/rectification-agentic/core/compose-receipt.ts";
+import {
+  PROBE_WEIGHT,
+  SCORE_DELTA,
+  STRONG_CONFLICT_ELIMINATION_COUNT,
+  type ConflictProbe,
+} from "../src/lib/rectification-agentic/core/types.ts";
+import type { CandidateDiscriminatorProbe } from "../src/lib/rectification-agentic/core/candidate-contrast-packet.ts";
+import { buildMethodFollowupPlan } from "../src/lib/rectification-agentic/v9/method-followup.ts";
+import { buildSkillVerificationPacket } from "../src/lib/rectification-agentic/v9/skill-verification-report.ts";
+import type { DiscriminatingEventProbe } from "../src/lib/rectification-agentic/v9/refinement-packet.ts";
+import { RECTIFICATION_SKILL_VERSION } from "../src/lib/rectification-agentic/v9/case-status.ts";
+
+const TIMES = ["05:00", "05:10"] as const;
+
+function dated(
+  id: string,
+  domain: string,
+  eventKind: string,
+  occurredFrom: string,
+) {
+  return {
+    id,
+    status: "confirmed" as const,
+    domain,
+    datePrecision: "month" as const,
+    occurredFrom,
+    occurredTo: null,
+    eventKind,
+  };
+}
+
+const LEDGER = [
+  dated("e-edu", "education", "education_start", "2016-09-01"),
+  dated("e-rel", "relationship", "relationship_start", "2024-05-01"),
+  dated("e-family", "family", "family_event", "2016-05-01"),
+  dated("e-reloc", "relocation", "home_change", "2022-10-01"),
+];
+
+const D9_STYLE: CandidateDiscriminatorProbe = {
+  probeId: "contrast:varga.d9.巨蟹座/狮子座",
+  candidateSetVersion: "05:00-05:10",
+  question: "亲密关系里更接近下面哪一种相处方式？",
+  expectedOutcomes: [
+    { outcomeId: "yes", supportsCandidateIds: ["05:00"], conflictsCandidateIds: ["05:10"] },
+    { outcomeId: "weak_yes", supportsCandidateIds: ["05:10"], conflictsCandidateIds: ["05:00"] },
+  ],
+  candidateSplitHash: "varga.d9.巨蟹座/狮子座",
+  informationGain: 1.4,
+  sourceFeatures: [{ technique: "D9", calculationResultId: null }],
+  domain: "relationship",
+  year: null,
+  semanticKey: "varga.d9.巨蟹座/狮子座",
+  choiceKind: "varga_style",
+  styleOptions: [
+    { label: "相处里更在意照顾对方的感受", answerClass: "yes", sign: "巨蟹座" },
+    { label: "习惯带头，也不排斥站到台前", answerClass: "weak_yes", sign: "狮子座" },
+  ],
+};
+
+const CAREER_2023_05: DiscriminatingEventProbe = {
+  year: 2023,
+  year_label: "2023 年 5 月前后",
+  month: 5,
+  domain: "career",
+  event_family: "入职或职责变化",
+  source: "dasha_boundary",
+  tracks: ["vimshottari", "narayana"],
+  tracks_agree: true,
+  unique_minute_claim: false,
+  user_meaning: "2023 年 5 月前后有没有入职或换工作？",
+  role: "distinguish",
+  phase: "candidate_discriminator",
+  information_gain: 0.9,
+  semantic_key: "career.2023.05.dasha_boundary",
+  candidate_split_hash: "career.2023.05",
+  candidate_ids: [...TIMES],
+  expected_outcomes: [
+    { answer_class: "yes", supports: ["05:00"], conflicts: ["05:10"] },
+    { answer_class: "no", supports: ["05:10"], conflicts: ["05:00"] },
+    { answer_class: "unsure", supports: [], conflicts: [] },
+  ],
+  style_options: [
+    { label: "明确发生且时间吻合", answer_class: "yes" },
+    { label: "发生过但程度较弱", answer_class: "weak_yes" },
+    { label: "明确没有发生", answer_class: "no" },
+    { label: "这段记不清楚", answer_class: "unsure" },
+  ],
+  choice_kind: "existence",
+};
+
+function personalityPlan(extra: Partial<Parameters<typeof buildMethodFollowupPlan>[0]> = {}) {
+  return buildMethodFollowupPlan({
+    evidence: LEDGER,
+    sessionOutcome: "discriminate_candidates",
+    candidatesSeparated: false,
+    topCandidateTimes: [...TIMES],
+    contrastPacket: {
+      candidateSetVersion: "05:00-05:10",
+      vargaDifferences: [],
+      probes: [D9_STYLE],
+    },
+    ...extra,
+  });
+}
+
+function clockProbe(input: {
+  id: string;
+  semanticKey: string;
+  domain: string;
+  year: number;
+  source: string;
+  choiceKind?: ConflictProbe["choice_kind"];
+  yesSupports: readonly string[];
+  yesConflicts: readonly string[];
+}): ConflictProbe {
+  return {
+    id: input.id,
+    semantic_key: input.semanticKey,
+    candidate_split_hash: `${input.semanticKey}:${input.yesSupports.join(",")}`,
+    domain: input.domain,
+    year: input.year,
+    question: input.semanticKey,
+    candidate_ids: [...input.yesSupports, ...input.yesConflicts],
+    expected_outcomes: [
+      { answer_class: "yes", supports: input.yesSupports, conflicts: input.yesConflicts },
+      { answer_class: "weak_yes", supports: input.yesConflicts, conflicts: input.yesSupports },
+      { answer_class: "no", supports: [], conflicts: [] },
+      { answer_class: "unsure", supports: [], conflicts: [] },
+    ],
+    information_gain: 0.4,
+    source: input.source,
+    ...(input.choiceKind ? { choice_kind: input.choiceKind } : {}),
+  };
+}
+
+const D9_PROBE = clockProbe({
+  id: "probe:varga.d9",
+  semanticKey: "varga.d9.巨蟹座/狮子座",
+  domain: "relationship",
+  year: 0,
+  source: "varga_contrast",
+  choiceKind: "varga_style",
+  yesSupports: ["05:00"],
+  yesConflicts: ["05:10"],
+});
+
+test("SCORE_DELTA stays ±2/±1 and yearless weight is half", () => {
+  assert.deepEqual(SCORE_DELTA, {
+    support: 2,
+    weak_support: 1,
+    neutral: 0,
+    weak_conflict: -1,
+    conflict: -2,
+  });
+  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.21");
+});
+
+test("D9 answer B moves scores by ±1 and does not count toward elimination", () => {
+  const applied = applyProbeOutcome(
+    { "05:00": 20, "05:10": 20 },
+    D9_PROBE,
+    "weak_yes",
+  );
+  assert.equal(applied.kind, "tie_break");
+  assert.equal(applied.deltas["05:10"], 1);
+  assert.equal(applied.deltas["05:00"], -1);
+  assert.equal(applied.strong_conflict_counts["05:00"], 0);
+  assert.equal(applied.strong_conflict_counts["05:10"], 0);
+  assert.deepEqual(applied.eliminated_ids, []);
+});
+
+test("three yearless conflicts never eliminate; three dated conflicts still do", () => {
+  const yearless = [1, 2, 3].map((index) => clockProbe({
+    id: `probe:varga.d9.${index}`,
+    semanticKey: `varga.d9.style.${index}`,
+    domain: "relationship",
+    year: 0,
+    source: "varga_contrast",
+    choiceKind: "varga_style",
+    yesSupports: ["05:00"],
+    yesConflicts: ["05:10"],
+  }));
+  let scores: Record<string, number> = { "05:00": 20, "05:10": 20 };
+  let counts: Record<string, number> = { "05:00": 0, "05:10": 0 };
+  let eliminated = new Set<string>();
+  for (const probe of yearless) {
+    const applied = applyProbeOutcome(scores, probe, "yes", {
+      eliminatedIds: eliminated,
+      strongConflictCounts: counts,
+    });
+    scores = { ...applied.scores };
+    counts = { ...applied.strong_conflict_counts };
+    eliminated = new Set(applied.eliminated_ids);
+  }
+  assert.equal(counts["05:10"], 0);
+  assert.equal(eliminated.has("05:10"), false);
+
+  const dated = [1, 2, 3].map((index) => clockProbe({
+    id: `probe:career.${2019 + index}`,
+    semanticKey: `career.${2019 + index}.dasha_boundary`,
+    domain: "career",
+    year: 2019 + index,
+    source: "dasha_boundary",
+    yesSupports: ["05:00"],
+    yesConflicts: ["05:10"],
+  }));
+  for (const probe of dated) {
+    const applied = applyProbeOutcome(scores, probe, "yes", {
+      eliminatedIds: eliminated,
+      strongConflictCounts: counts,
+    });
+    scores = { ...applied.scores };
+    counts = { ...applied.strong_conflict_counts };
+    eliminated = new Set(applied.eliminated_ids);
+    assert.equal(applied.kind, "informative");
+    assert.equal(applied.deltas["05:00"], 2);
+    assert.equal(applied.deltas["05:10"], -2);
+  }
+  assert.ok(counts["05:10"] >= STRONG_CONFLICT_ELIMINATION_COUNT);
+  assert.equal(eliminated.has("05:10"), true);
+});
+
+test("nakshatra_boundary is yearless: ±1 and no conflict count", () => {
+  const probe = clockProbe({
+    id: "probe:nakshatra",
+    semanticKey: "nakshatra.boundary.a/b",
+    domain: "other",
+    year: 0,
+    source: "nakshatra_boundary",
+    choiceKind: "varga_style",
+    yesSupports: ["05:00"],
+    yesConflicts: ["05:10"],
+  });
+  const applied = applyProbeOutcome({ "05:00": 20, "05:10": 20 }, probe, "yes");
+  assert.equal(applied.kind, "tie_break");
+  assert.equal(applied.deltas["05:00"], 1);
+  assert.equal(applied.deltas["05:10"], -1);
+  assert.equal(applied.strong_conflict_counts["05:10"], 0);
+});
+
+test("an askable 2023.05 career probe keeps D9 deferred", () => {
+  const plan = personalityPlan({ eventProbes: [CAREER_2023_05] });
+  assert.equal(plan.next_followup?.semantic_key, CAREER_2023_05.semantic_key);
+  assert.notEqual(plan.next_followup?.choice_kind, "varga_style");
+  assert.equal(
+    plan.dropped_probes.some((item) => (
+      item.semantic_key === D9_STYLE.semanticKey && item.reason === "yearless_deferred"
+    )),
+    true,
+    JSON.stringify(plan.dropped_probes),
+  );
+});
+
+test("dated distinguish empty and two unseparated candidates asks D9", () => {
+  const plan = personalityPlan({ eventProbes: [] });
+  assert.equal(plan.next_followup?.semantic_key, D9_STYLE.semanticKey);
+  assert.equal(plan.next_followup?.choice_kind, "varga_style");
+  assert.ok(plan.next_followup?.choice_frame);
+  assert.equal(
+    plan.dropped_probes.some((item) => item.reason === "yearless_deferred"),
+    false,
+  );
+});
+
+test("a sole remaining candidate defers D9 as yearless_deferred", () => {
+  const plan = personalityPlan({
+    eventProbes: [],
+    topCandidateTimes: ["05:00"],
+  });
+  assert.notEqual(plan.next_followup?.semantic_key, D9_STYLE.semanticKey);
+  assert.equal(
+    plan.dropped_probes.some((item) => (
+      item.semantic_key === D9_STYLE.semanticKey && item.reason === "yearless_deferred"
+    )),
+    true,
+    JSON.stringify(plan.dropped_probes),
+  );
+});
+
+test("already-separated candidates do not ask D9", () => {
+  const plan = personalityPlan({
+    eventProbes: [],
+    candidatesSeparated: true,
+  });
+  assert.notEqual(plan.next_followup?.semantic_key, D9_STYLE.semanticKey);
+  assert.notEqual(plan.next_followup?.choice_kind, "varga_style");
+});
+
+test("asInferenceState round-trips a varga_style tie_break round", () => {
+  const before = buildInferenceState({
+    range_start: "05:00",
+    range_end: "05:10",
+    candidates: [
+      { id: "05:00", time: "05:00", relative_support: 20 },
+      { id: "05:10", time: "05:10", relative_support: 18 },
+    ],
+    events: [{ id: "e-rel", domain: "relationship", year: 2024, precision: "year" }],
+    probes: [D9_PROBE],
+  });
+  const after = applyAnswerToState(before, D9_PROBE.id, "weak_yes");
+  assert.equal(after.rounds.at(-1)?.kind, "tie_break");
+  const loaded = asInferenceState(JSON.parse(JSON.stringify(after)));
+  assert.ok(loaded);
+  assert.equal(loaded.rounds.at(-1)?.kind, "tie_break");
+  assert.equal(loaded.answered_probes.length, 1);
+});
+
+test("verification report marks D9/D10 and nakshatra as reference", () => {
+  const packet = buildSkillVerificationPacket({
+    representativeTime: "05:00",
+    widthMinutes: 10,
+    candidates: [
+      { time: "05:00", rank: 1, relativeSupport: 20 },
+      { time: "05:10", rank: 2, relativeSupport: 18 },
+    ],
+  });
+  assert.match(packet.markdown, /\| D9 \/ D10 类型对照 \| reference \| 性格自评，只作排序参考，不参与淘汰 \|/);
+  assert.match(packet.markdown, /\| 月宿边界 \| reference \| 性格自评，只作排序参考，不参与淘汰 \|/);
+});
@@ -85,8 +85,8 @@ test("checked-in registry verifies hashed product packages and leaves consult on
    [
      {
        name: "jyotish-birth-time-rectification",
-        version: "10.0.20",
-        sha256: "9c09867591cc9e8726f3577346230339b5a6dd4b4f3d634a9cda3e66170d6ac6",
+        version: "10.0.21",
+        sha256: "3ced107366b2c4b0f26bae81440162032501f77a8d762d42c84a20fa394ea807",
      },
      {
        name: "jyotish-personal-report",
@@ -0,0 +1,135 @@
+"""Offline hit-rate for yearless personality probes.
+
+Reads an anonymized JSON export. Prints n and hit rate grouped by D9 / D10 /
+nakshatra. Never prints a per-case row.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Iterable, Mapping
+
+GROUPS = ("d9", "d10", "nakshatra")
+HOSPITAL = "hospital_record"
+MAX_UNCERTAINTY_MINUTES = 2
+
+
+def _text(value: object) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
+def _int(value: object) -> int | None:
+    if isinstance(value, bool) or value is None:
+        return None
+    if isinstance(value, int) and not isinstance(value, bool):
+        return value
+    if isinstance(value, float) and value.is_integer():
+        return int(value)
+    if isinstance(value, str) and value.strip().lstrip("-").isdigit():
+        return int(value.strip())
+    return None
+
+
+def infer_group(row: Mapping[str, Any]) -> str | None:
+    explicit = _text(row.get("group")).lower()
+    if explicit in GROUPS:
+        return explicit
+    key = _text(row.get("semantic_key") or row.get("semanticKey")).lower()
+    if key.startswith("varga.d9.") or ".d9." in key:
+        return "d9"
+    if key.startswith("varga.d10.") or ".d10." in key:
+        return "d10"
+    if "nakshatra" in key:
+        return "nakshatra"
+    return None
+
+
+def _sign(value: object) -> str:
+    return _text(value)
+
+
+def selected_sign(row: Mapping[str, Any]) -> str | None:
+    answer = _text(row.get("answer_class") or row.get("answerClass"))
+    if not answer or answer in {"unsure", "no"}:
+        return None
+    options = row.get("options")
+    if not isinstance(options, list):
+        return None
+    for option in options:
+        if not isinstance(option, Mapping):
+            continue
+        option_class = _text(option.get("answer_class") or option.get("answerClass"))
+        if option_class != answer:
+            continue
+        sign = _sign(option.get("sign"))
+        return sign or None
+    return None
+
+
+def recorded_sign(row: Mapping[str, Any]) -> str | None:
+    sign = _sign(row.get("recorded_sign") or row.get("recordedSign"))
+    return sign or None
+
+
+def hospital_case(row: Mapping[str, Any]) -> bool:
+    if _text(row.get("birth_time_source") or row.get("birthTimeSource")) != HOSPITAL:
+        return False
+    before = _int(row.get("uncertainty_before_minutes") or row.get("uncertaintyBeforeMinutes"))
+    after = _int(row.get("uncertainty_after_minutes") or row.get("uncertaintyAfterMinutes"))
+    if before is None or after is None:
+        return False
+    return before <= MAX_UNCERTAINTY_MINUTES and after <= MAX_UNCERTAINTY_MINUTES
+
+
+def summarize(payload: Mapping[str, Any] | Iterable[Any]) -> dict[str, dict[str, float | int | None]]:
+    cases = payload.get("cases") if isinstance(payload, Mapping) else payload
+    if not isinstance(cases, list):
+        cases = []
+    hits: dict[str, int] = defaultdict(int)
+    total: dict[str, int] = defaultdict(int)
+    for case in cases:
+        if not isinstance(case, Mapping) or not hospital_case(case):
+            continue
+        answers = case.get("answers")
+        if not isinstance(answers, list):
+            continue
+        for answer in answers:
+            if not isinstance(answer, Mapping):
+                continue
+            group = infer_group(answer)
+            chosen = selected_sign(answer)
+            recorded = recorded_sign(answer)
+            if group is None or not chosen or not recorded:
+                continue
+            total[group] += 1
+            if chosen == recorded:
+                hits[group] += 1
+    out: dict[str, dict[str, float | int | None]] = {}
+    for group in GROUPS:
+        n = total[group]
+        rate = round(hits[group] / n, 3) if n else None
+        out[group] = {"n": n, "hit_rate": rate}
+    return out
+
+
+def load_payload(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Yearless personality probe hit-rate (hospital records only).")
+    parser.add_argument("path", type=Path, help="Anonymized JSON export")
+    args = parser.parse_args(argv)
+    payload = load_payload(args.path)
+    report = summarize(payload)
+    json.dump(report, sys.stdout, ensure_ascii=False)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -1,6 +1,6 @@
 ---
 name: jyotish-birth-time-rectification
-version: 10.0.20
+version: 10.0.21
 description: "生时校正专用 Skill（V10）。以服务器权威 Case、ConversationFocus 与 CaseConversationSummary 驱动低负担访谈；批量证据逐项判定，candidate / accepted / confirmed 严格分离，全部计算与持久化只走服务端工具。触发词：生时校正、出生时间校正、校正出生时间、rectification、birth time correction。"
 ---

@@ -74,6 +74,7 @@ description: "生时校正专用 Skill（V10）。以服务器权威 Case、Conv
 - 没有 active focus、focus 已 resolved/declined/skipped/superseded、或当前表达可能指向多个目标时，只做一句简短澄清；不得猜测或写 evidence。
 - 当前轮用户主动、明确、无歧义地提出全新事件时，可按新事件处理；若需要后续问题，由服务器建立新的 focus。
 - 用户已拒绝或跳过的目标不得换词重问；只有用户主动重开该主题或服务器建立新的有效 focus 才可继续。
+- 性格类点选题只在带年月题问完仍分不开时出现，分值减半、不淘汰。

 ## 6. CaseConversationSummary 与长会话记忆

@@ -0,0 +1,146 @@
+---
+name: jyotish-birth-time-rectification
+version: 10.0.21
+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. 一句「想到几件说几件，有大概年月就行」并点出上述六类。
+
+开场必须满足：
+
+- 一条消息可以报多件；想到几件说几件，有大概年月即可。只报一件也继续既有逐领域采集，不得追问「还有吗 / 还能想起别的吗」，也不得重复开场邀请。第一道逐领域题干末尾由服务端带一次「想到别的也可以一起说」。
+- 允许模糊日期：可以先说大概年份、阶段或范围；如确有信息增益，后续再澄清，不诱导猜测月份或日期。
+- 首题保持采集题身份（`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`。先走完方法覆盖（感情 → 事业 → 家人 → 职业 → 占问），再对已覆盖领域做精度追问。已有带日期事件且存在 `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。
@@ -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 未加载或未完成必要工具链时不保存、不扣费。
@@ -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` 指定的下一方法层。方法覆盖优先于对已覆盖领域的精度追问：有日期事件 → 感情 → 事业 → 家人（D12/D7/D3）→ 职业（挡出牌，独立于带日期事业事件）→ 占问（只问一次，不挡出牌）→ 再按精度阶段问关系盘/事业盘/居所（D4）/学业成就（D5，D24 换升并入同一问）。已有带日期事件且服务器给出大运冲突探针时，先问该前事筛窗，`source=event_probe` 挡住出牌，不要继续轮询方法层。迁居不进领域轮询，只在 `d4_refine` 精度阶段问搬家/住处。财务与健康只有用户主动说才问，仍可计分。不得询问外貌、体质、胎记或疤痕。收集经历用自然语言。只有候选已经分不开、冲突探针或采用后核对前事时，`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` 轮询迁居。财务与健康只有用户主动说才问，不是 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。
@@ -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 领域。
+- 证据变化才触发重算；相同证据指纹复用缓存，不重复评分。
@@ -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`。
+- 精度阶段顺序：有日期事件 → 本命上升 → 方法覆盖（感情 → 事业 → 家人 → 职业 → 占问）→ 再对已覆盖领域做 D9 / D10 / D4 / D5（含 D24 换升）。家人不得混进 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 不得自行宣告通过或失败。
@@ -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。未完成该判定不得声称高严谨解读完成。
@@ -175,6 +175,14 @@
      "sha256": "9c09867591cc9e8726f3577346230339b5a6dd4b4f3d634a9cda3e66170d6ac6",
      "sourceCommit": null,
      "packagePath": "skills/jyotish-birth-time-rectification/versions/10.0.20",
+      "status": "deprecated"
+    },
+    {
+      "name": "jyotish-birth-time-rectification",
+      "version": "10.0.21",
+      "sha256": "3ced107366b2c4b0f26bae81440162032501f77a8d762d42c84a20fa394ea807",
+      "sourceCommit": null,
+      "packagePath": "skills/jyotish-birth-time-rectification/versions/10.0.21",
      "status": "active"
    },
    {
@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import json
+import unittest
+from pathlib import Path
+
+from scripts.rectification.varga_style_calibration_report import summarize
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _answer(group: str, answer_class: str, recorded: str, chosen: str) -> dict:
+    other = "天蝎座" if recorded == "天秤座" else "天秤座"
+    yes_sign = chosen if answer_class == "yes" else other
+    weak_sign = chosen if answer_class == "weak_yes" else (recorded if recorded != yes_sign else other)
+    return {
+        "group": group,
+        "answer_class": answer_class,
+        "recorded_sign": recorded,
+        "options": [
+            {"answer_class": "yes", "sign": yes_sign},
+            {"answer_class": "weak_yes", "sign": weak_sign},
+        ],
+    }
+
+
+def _case(case_id: str, source: str, answers: list[dict], before: int = 2, after: int = 2) -> dict:
+    return {
+        "case_id_hash": case_id,
+        "birth_time_source": source,
+        "recorded_minute": "04:51",
+        "uncertainty_before_minutes": before,
+        "uncertainty_after_minutes": after,
+        "answers": answers,
+    }
+
+
+class VargaStyleCalibrationReportTest(unittest.TestCase):
+    def test_random_third_and_high_hit_rate(self) -> None:
+        random_third = {
+            "cases": [
+                _case("a", "hospital_record", [_answer("d9", "yes", "天秤座", "天秤座")]),
+                _case("b", "hospital_record", [_answer("d9", "yes", "天秤座", "天蝎座")]),
+                _case("c", "hospital_record", [_answer("d9", "weak_yes", "天秤座", "天蝎座")]),
+            ]
+        }
+        random_report = summarize(random_third)
+        self.assertEqual(random_report["d9"]["n"], 3)
+        self.assertEqual(random_report["d9"]["hit_rate"], 0.333)
+        self.assertEqual(random_report["d10"]["n"], 0)
+        self.assertIsNone(random_report["d10"]["hit_rate"])
+
+        high = {
+            "cases": [
+                _case(str(index), "hospital_record", [
+                    _answer("d10", "yes", "巨蟹座", "巨蟹座" if index < 9 else "狮子座"),
+                ])
+                for index in range(10)
+            ]
+        }
+        high_report = summarize(high)
+        self.assertEqual(high_report["d10"]["n"], 10)
+        self.assertEqual(high_report["d10"]["hit_rate"], 0.9)
+
+    def test_filters_non_hospital_and_wide_uncertainty(self) -> None:
+        payload = {
+            "cases": [
+                _case("hospital", "hospital_record", [_answer("nakshatra", "yes", "角宿", "角宿")]),
+                _case("approx", "approximate", [_answer("nakshatra", "yes", "角宿", "角宿")]),
+                _case("wide", "hospital_record", [_answer("nakshatra", "yes", "角宿", "角宿")], before=15, after=15),
+            ]
+        }
+        report = summarize(payload)
+        self.assertEqual(report["nakshatra"]["n"], 1)
+        self.assertEqual(report["nakshatra"]["hit_rate"], 1.0)
+
+    def test_summary_has_no_case_ids(self) -> None:
+        payload = {
+            "cases": [
+                _case("secret-hash", "hospital_record", [_answer("d9", "yes", "天秤座", "天秤座")]),
+            ]
+        }
+        dumped = json.dumps(summarize(payload), ensure_ascii=False)
+        self.assertNotIn("secret-hash", dumped)
+        self.assertNotIn("04:51", dumped)
+
+
+if __name__ == "__main__":
+    unittest.main()