From ee9d4327620af7bbff7f16210031605ddd2827de Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Wed, 29 Jul 2026 17:49:04 +0800
Subject: [PATCH 01/15] feat: make rectification agent conversational

---
 docs/BUG_HISTORY.md                           |  28 ++
 .../evidence-extractor.ts                     |  67 ++++-
 .../src/lib/rectification-agent/contracts.ts  | 150 +++++++++--
 .../event-extractor-agent.ts                  |  68 +++++
 .../opportunity-builder.ts                    | 206 +++++++++++----
 .../lib/rectification-agent/orchestrator.ts   |  43 ++-
 .../lib/rectification-agent/reasoner-agent.ts |  56 +++-
 .../lib/rectification-agent/renderer-agent.ts | 155 +++++++++--
 .../src/lib/rectification-v4/case-service.ts  |   5 +-
 .../src/lib/rectification-v4/extraction.ts    |  47 +++-
 ...010000_rectification_agent_v6_versions.sql |  14 +
 .../tests/birth-time-journey-engine.test.ts   |   1 -
 ...ational-rectification-orchestrator.test.ts |   4 +-
 .../tests/identity-auth-integration.test.ts   |   2 +-
 frontend/tests/onboarding-route.test.ts       |   6 +-
 .../rectification-agent-contracts.test.ts     |   8 +-
 frontend/tests/rectification-agent-v5.test.ts | 134 ++++++++--
 frontend/tests/rectification-agent-v6.test.ts | 246 ++++++++++++++++++
 .../tests/rectification-v4-domain.test.ts     |   4 +-
 .../tests/rectification-v4-replay.test.ts     |  33 +--
 .../tests/rectification-v4-service.test.ts    |   9 +-
 skills/birth-time-rectification/SKILL.md      |  65 +++--
 .../references/event-schema.md                |  28 +-
 .../references/failure-policy.md              |  20 +-
 .../references/output-contract.md             |  43 ++-
 .../references/product-contract.md            |  28 +-
 .../references/question-policy.md             |  43 ++-
 .../references/technique-policy.md            |  21 +-
 28 files changed, 1329 insertions(+), 205 deletions(-)
 create mode 100644 frontend/src/lib/rectification-agent/event-extractor-agent.ts
 create mode 100644 frontend/supabase/migrations/20260729010000_rectification_agent_v6_versions.sql
 create mode 100644 frontend/tests/rectification-agent-v6.test.ts

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 329fcca0..d374a9a1 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1578,3 +1578,31 @@
 - 防复发：当前事件延续必须是服务端 opportunity 所有权规则，而不是 prompt 建议；模型输出即使结构合法，也必须经过 bounded tool budget、active-opportunity lookup、decision validation 和 completion payload hash 四层门控。
 - 相关记录：BUG-075、BUG-085
 - 修复版本：本地 V5 重构，待提交与 staging 验收
+
+## BUG-087 | 语义机会仍退化为固定文案并在拒绝后重复追问
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：生时校正 Agent 的证据协调、问题机会、Reasoner 上下文、Renderer、候选范围提示与 Skill 合同
+- 用户现象：对话会把月份已经明确的经历继续机械追问具体日期，按固定领域顺序轮询；用户表示不知道、跳过或换方向后仍可能回到同一事件，Renderer 还会重复套话和未变化的候选范围。
+- 触发条件：Question Opportunity 直接持久化最终 `prompt`，Renderer 再用服务端问题覆盖自然生成结果；缺失领域按固定数组选择，日期策略把所有非日精度事件视为未完成，且证据协调未完整区分拒绝、未知、换向和回答了另一事件。
+- 根因：机会合同混合了“为什么问、要补什么字段”和“最终怎么说”，导致 Reasoner 看不到最近对话语义、Renderer 无法安全自然表达；同时 target disposition 和重复追问预算不完整，固定领域与日期控制流绕过了信息增益、隐私成本和稳定性诊断。
+- 修复：升级为兼容旧 `prompt` 的 `semantic-question-v2`，由 Builder 同时生成并按 utility 排序最多五个活动机会；补齐 `resolved / unknown / declined / direction_change / answered_other_event / unresolved / not_applicable`，限制同一目标连续追问和回答其他事件后的温和补问次数；月份默认足够，仅在日期敏感诊断不稳定时细化。Reasoner 获得脱敏的最近 Turn、事件、目标和机会语义；Renderer 改为验证自然问题并在失败时使用锚定 fallback，同时只在公开门首次通过或范围实际变化时播报范围，相同范围即使再次计算或收到 offer 决策也不重复播报。受限模型辅助提取仅补充确定性解析缺口，服务端继续校验原文子串和日期。
+- 验证：V6 语义合同、日期敏感性、拒绝/换向、回答新事件不覆盖旧事件、单次补问、Renderer 锚点/单问题/分钟注入/内部信息拒绝、候选范围去重、Reasoner 上下文、模型辅助提取和旧 Opportunity 兼容测试通过；四轮端到端测试覆盖月份职业事件、外地入学、无日期搬家换向和后续职业事件，并保留 exact-minute、Profile 写入、legacy/shadow、V5 候选引擎与 completed-job replay 边界。完整前端测试、lint、TypeScript 与 Python 结果见本任务交付记录。
+- 防复发：问题机会只表达服务器拥有的语义目标和约束，最终文案必须通过 realization validator；日期追问必须有诊断依据，拒绝/换向必须关闭目标，领域选择必须由 utility 和上下文驱动。Skill 明确禁止固定问卷、重复范围、唯一分钟、D60 驱动和公开内部评分/技术轨迹。
+- 相关记录：BUG-068、BUG-075、BUG-080、BUG-081、BUG-082、BUG-085、BUG-086
+- 复发自：BUG-085、BUG-086
+- 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`，本地验证完成，待提交与 staging 发布
+
+## BUG-088 | TypeScript 全量检查被过期测试夹具阻塞
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：`npx tsc --noEmit` 本地发布前质量门
+- 用户现象：生产构建通过，但全量 TypeScript 检查在三个测试文件报错：事件评分输入仍传入服务端固定的 `high_rigor`、身份全局缓存清理被控制流误收窄为 `never`、onboarding 测试未归一化 PostgreSQL `Date` 联合类型。
+- 根因：测试夹具落后于现有生产合同；这些报错不来自 V6 Agent 运行时，但会让显式 TypeScript 验证失败。
+- 修复：删除客户端不应拥有的 `high_rigor` 输入；在异步请求结束后从 `globalThis` 重新读取身份缓存；按生产边界把 `Date` 归一化为日期字符串后再构建 onboarding cache identity。
+- 验证：`npx tsc --noEmit`、相关前端测试和生产构建通过。
+- 防复发：测试输入只使用公开类型拥有的字段；异步初始化的全局缓存不要依赖删除前的局部控制流；数据库日期联合类型在进入纯字符串合同前必须归一化。
diff --git a/frontend/src/lib/conversational-rectification/evidence-extractor.ts b/frontend/src/lib/conversational-rectification/evidence-extractor.ts
index d7ecd277..6973a6e4 100644
--- a/frontend/src/lib/conversational-rectification/evidence-extractor.ts
+++ b/frontend/src/lib/conversational-rectification/evidence-extractor.ts
@@ -35,7 +35,7 @@ const unresolvedRelativeTimePattern = /(?:来年|次年|第二年|翌年|后来|
 const leadingRelativeTimePattern = /^\s*(?:(?:来年|次年|第二年|翌年|后来(?:又)?|此前|同年|当年|那年|随后|先前|然后|之前|之后|今年|去年|前年|明年)\s*)+/;
 const missingEventSummary = "事件内容待补充";
 
-function normalizedDate(value: string, asOfDate: string): ParsedDate | null {
+export function parseDeclaredDateText(value: string, asOfDate: string): ParsedDate | null {
   const chinese = value.match(/^((?:1\d{3}|20\d{2}|\d{2}))\s*年(?:\s*(\d{1,2})\s*月(?:\s*(\d{1,2})\s*(?:日|号))?)?$/);
   const iso = value.match(/^((?:1\d{3}|20\d{2}))-(\d{2})(?:-(\d{2}))?$/);
   const match = chinese ?? iso;
@@ -70,7 +70,7 @@ function datesIn(value: string, asOfDate: string): ParsedDate[] {
   const matches = [...value.matchAll(chineseDatePattern), ...value.matchAll(isoDatePattern)]
     .sort((left, right) => (left.index ?? 0) - (right.index ?? 0));
   return matches.flatMap((match) => {
-    const parsed = normalizedDate(match[0], asOfDate);
+    const parsed = parseDeclaredDateText(match[0], asOfDate);
     return parsed ? [parsed] : [];
   });
 }
@@ -139,7 +139,7 @@ function classifyEvent(summary: string): EventSemantics {
   if (/收入|工资|薪资|奖金|财富|财务|投资|亏损|盈利|负债|债务|资产/.test(summary)) {
     return { domain: "finance", eventKind: "finance_change", subject: "self", relatedPerson: null, scoreability: "scoreable" };
   }
-  if (/工作|入职|离职|辞职|升职|创业|职业|职位|任职|管理职责|公司|项目/.test(summary)) {
+  if (/工作|实习|研究员|入职|离职|辞职|升职|创业|职业|职位|任职|负责|管理职责|公司|项目/.test(summary)) {
     return { domain: "career", eventKind: "career_change", subject: "self", relatedPerson: null, scoreability: "scoreable" };
   }
   return { domain: "other", eventKind: "other", subject: "other", relatedPerson: null, scoreability: "unsupported" };
@@ -269,3 +269,64 @@ export function extractLifeEventEvidence(
   }
   return coalesceSameEventDetails(input, events);
 }
+
+
+export type ModelAssistedEventExtraction = Readonly<{
+  sourceSpan: string;
+  summary: string;
+  domain: RectificationEvidenceDomain;
+  eventKind: string;
+  subject: "self" | "family" | "partner" | "other";
+  relatedPerson: "father" | "mother" | "grandparent" | "sibling" | "partner" | null;
+  dateText: string | null;
+}>;
+
+const allowedKindsByDomain: Readonly<Record<RectificationEvidenceDomain, readonly string[]>> = {
+  education: ["education_milestone"],
+  relocation: ["relocation"],
+  relationship: ["relationship_start", "relationship_end", "relationship_change"],
+  career: ["career_change"],
+  finance: ["finance_change"],
+  health_pressure: ["self_health_event"],
+  family: ["family_health_event", "family_bereavement", "family_event"],
+  other: ["other"],
+};
+
+export function validatedModelAssistedEvidence(input: Readonly<{
+  rawText: string;
+  sourceTurnId: string;
+  asOfDate: string;
+  extraction: ModelAssistedEventExtraction;
+}>): ExtractedLifeEventEvidence | null {
+  const sourceSpan = input.extraction.sourceSpan.trim();
+  const dateText = input.extraction.dateText?.trim() || null;
+  if (!sourceSpan || !input.rawText.includes(sourceSpan)) return null;
+  if (!dateText || !input.rawText.includes(dateText)) return null;
+  const date = parseDeclaredDateText(dateText.normalize("NFKC"), input.asOfDate);
+  if (!date || dateIsFuture(date, input.asOfDate)) return null;
+  if (!allowedKindsByDomain[input.extraction.domain]?.includes(input.extraction.eventKind)) return null;
+  if (input.extraction.subject === "partner" && input.extraction.domain !== "relationship") return null;
+  const summary = eventSummary(sourceSpan);
+  if (summary === missingEventSummary) return null;
+  const familyContext = input.extraction.subject === "family" || input.extraction.domain === "family";
+  const scoreability = familyContext
+    ? "context_only" as const
+    : input.extraction.subject === "self" || (input.extraction.subject === "partner" && input.extraction.domain === "relationship")
+      ? "scoreable" as const
+      : "unsupported" as const;
+  return {
+    id: evidenceId({ rawText: input.rawText, sourceTurnId: input.sourceTurnId, asOfDate: input.asOfDate }, 0, summary),
+    rawText: input.rawText,
+    domain: input.extraction.domain,
+    eventKind: input.extraction.eventKind,
+    subject: input.extraction.subject,
+    relatedPerson: input.extraction.relatedPerson,
+    eventSummary: summary,
+    dateValue: date.value,
+    datePrecision: date.precision,
+    extractionStatus: "clear",
+    scoreability,
+    scoreable: scoreability === "scoreable",
+    correctsEvidenceIds: [],
+  };
+}
diff --git a/frontend/src/lib/rectification-agent/contracts.ts b/frontend/src/lib/rectification-agent/contracts.ts
index 840fe28d..a75629cd 100644
--- a/frontend/src/lib/rectification-agent/contracts.ts
+++ b/frontend/src/lib/rectification-agent/contracts.ts
@@ -5,6 +5,9 @@ const uuid = z.string().uuid();
 const hash = z.string().regex(/^[a-f0-9]{64}$/);
 const nonblank = (max: number) => z.string().trim().min(1).max(max);
 
+export const CURRENT_RECTIFICATION_SKILL_VERSION = "birth-time-rectification-v6" as const;
+export const CURRENT_RECTIFICATION_PROMPT_VERSION = "rectification-agent-v6-1" as const;
+
 export const rectificationDiagnosticSchema = z.enum([
   "leave_one_event_out",
   "leave_one_domain_out",
@@ -26,21 +29,41 @@ export const rectificationDecisionSchema = z.discriminatedUnion("action", [
 ]);
 export type RectificationDecision = z.infer<typeof rectificationDecisionSchema>;
 
-export const questionOpportunitySchema = z.object({
-  opportunityId: uuid,
-  kind: z.enum([
-    "clarify_intake",
-    "clarify_event_subject",
-    "refine_event_date",
-    "pair_related_event",
-    "ask_new_event",
-    "resolve_event_conflict",
-    "disambiguate_candidate_split",
-  ]),
-  domain: evidenceDomainSchema,
-  targetEventId: uuid.nullable(),
-  prompt: nonblank(1_000),
-  reason: nonblank(240),
+export const semanticQuestionKindSchema = z.enum([
+  "clarify_intake",
+  "clarify_event_subject",
+  "refine_event_date",
+  "pair_related_event",
+  "ask_new_event",
+  "resolve_event_conflict",
+  "disambiguate_candidate_split",
+]);
+export type SemanticQuestionKind = z.infer<typeof semanticQuestionKindSchema>;
+
+export const requestedQuestionFieldSchema = z.enum([
+  "event_year",
+  "event_month",
+  "event_day",
+  "event_range",
+  "event_subject",
+  "event_stage",
+  "new_dated_event",
+]);
+export type RequestedQuestionField = z.infer<typeof requestedQuestionFieldSchema>;
+
+export const forbiddenQuestionMoveSchema = z.enum([
+  "switch_target_event",
+  "ask_multiple_questions",
+  "claim_exact_birth_minute",
+  "invent_event",
+  "invent_date",
+  "expose_private_score",
+  "expose_internal_id",
+  "expose_technique_trace",
+]);
+export type ForbiddenQuestionMove = z.infer<typeof forbiddenQuestionMoveSchema>;
+
+const opportunityMetrics = {
   expectedInformationGain: z.number().finite().min(0).max(1),
   dateSensitivity: z.number().finite().min(0).max(1),
   candidateSplitRelevance: z.number().finite().min(0).max(1),
@@ -51,8 +74,103 @@ export const questionOpportunitySchema = z.object({
   privacyCost: z.number().finite().min(0).max(1),
   utility: z.number().finite(),
   active: z.boolean(),
+} as const;
+
+export const semanticQuestionOpportunitySchema = z.object({
+  contractVersion: z.literal("semantic-question-v2"),
+  opportunityId: uuid,
+  kind: semanticQuestionKindSchema,
+  domain: evidenceDomainSchema,
+  targetEventId: uuid.nullable(),
+  goal: nonblank(500),
+  requestedFields: z.array(requestedQuestionFieldSchema).min(1).max(4),
+  anchors: z.array(nonblank(240)).max(8),
+  contextFacts: z.array(nonblank(500)).max(16),
+  forbiddenMoves: z.array(forbiddenQuestionMoveSchema).min(1).max(8),
+  fallbackPrompt: nonblank(1_000),
+  reason: nonblank(500),
+  ...opportunityMetrics,
 }).strict();
-export type QuestionOpportunity = z.infer<typeof questionOpportunitySchema>;
+export type SemanticQuestionOpportunity = z.infer<typeof semanticQuestionOpportunitySchema>;
+
+const legacyQuestionOpportunitySchema = z.object({ prompt: nonblank(1_000) }).passthrough();
+
+function legacyUuid(value: string): string {
+  let hashValue = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hashValue ^= value.charCodeAt(index);
+    hashValue = Math.imul(hashValue, 16777619);
+  }
+  const block = (hashValue >>> 0).toString(16).padStart(8, "0");
+  return `${block}-${block.slice(0, 4)}-4${block.slice(1, 4)}-8${block.slice(1, 4)}-${block}${block.slice(0, 4)}`;
+}
+
+const defaultForbiddenMoves: SemanticQuestionOpportunity["forbiddenMoves"] = [
+  "switch_target_event",
+  "ask_multiple_questions",
+  "claim_exact_birth_minute",
+  "invent_event",
+  "invent_date",
+  "expose_private_score",
+  "expose_internal_id",
+  "expose_technique_trace",
+];
+
+function numberFrom(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function requestedFieldsFor(kind: SemanticQuestionKind): SemanticQuestionOpportunity["requestedFields"] {
+  if (kind === "clarify_event_subject") return ["event_subject"];
+  if (kind === "refine_event_date") return ["event_month"];
+  if (kind === "disambiguate_candidate_split") return ["event_stage"];
+  if (kind === "ask_new_event" || kind === "pair_related_event") return ["new_dated_event"];
+  return ["event_range"];
+}
+
+export function normalizeQuestionOpportunity(value: unknown): SemanticQuestionOpportunity {
+  const semantic = semanticQuestionOpportunitySchema.safeParse(value);
+  if (semantic.success) return semantic.data;
+  const legacy = legacyQuestionOpportunitySchema.parse(value) as Record<string, unknown> & { prompt: string };
+  const kind = semanticQuestionKindSchema.safeParse(legacy.kind).success
+    ? semanticQuestionKindSchema.parse(legacy.kind)
+    : "clarify_intake";
+  const domain = evidenceDomainSchema.safeParse(legacy.domain).success
+    ? evidenceDomainSchema.parse(legacy.domain)
+    : "other";
+  const targetEventId = uuid.safeParse(legacy.targetEventId).success ? uuid.parse(legacy.targetEventId) : null;
+  const reason = typeof legacy.reason === "string" && legacy.reason.trim() ? legacy.reason.trim().slice(0, 500) : "历史问题机会兼容读取。";
+  return semanticQuestionOpportunitySchema.parse({
+    contractVersion: "semantic-question-v2",
+    opportunityId: uuid.safeParse(legacy.opportunityId).success ? legacy.opportunityId : legacyUuid(legacy.prompt),
+    kind,
+    domain,
+    targetEventId,
+    goal: reason,
+    requestedFields: requestedFieldsFor(kind),
+    anchors: [],
+    contextFacts: [],
+    forbiddenMoves: defaultForbiddenMoves,
+    fallbackPrompt: legacy.prompt,
+    reason,
+    expectedInformationGain: numberFrom(legacy.expectedInformationGain, .5),
+    dateSensitivity: numberFrom(legacy.dateSensitivity, .5),
+    candidateSplitRelevance: numberFrom(legacy.candidateSplitRelevance, .5),
+    domainCoverageGain: numberFrom(legacy.domainCoverageGain, 0),
+    recallEase: numberFrom(legacy.recallEase, .5),
+    novelty: numberFrom(legacy.novelty, .5),
+    repetitionPenalty: numberFrom(legacy.repetitionPenalty, 0),
+    privacyCost: numberFrom(legacy.privacyCost, 0),
+    utility: numberFrom(legacy.utility, .5),
+    active: typeof legacy.active === "boolean" ? legacy.active : true,
+  });
+}
+
+export const questionOpportunitySchema = z.union([
+  semanticQuestionOpportunitySchema,
+  legacyQuestionOpportunitySchema,
+]).transform(normalizeQuestionOpportunity);
+export type QuestionOpportunity = z.output<typeof questionOpportunitySchema>;
 
 export const eventDateSensitivitySchema = z.object({
   eventId: uuid,
diff --git a/frontend/src/lib/rectification-agent/event-extractor-agent.ts b/frontend/src/lib/rectification-agent/event-extractor-agent.ts
new file mode 100644
index 00000000..bfe02192
--- /dev/null
+++ b/frontend/src/lib/rectification-agent/event-extractor-agent.ts
@@ -0,0 +1,68 @@
+import { Agent } from "@mastra/core/agent";
+import { z } from "zod";
+import { defaultLanguageModel, resolveLanguageModel } from "@/mastra/model";
+import {
+  eventKindSchema,
+  eventSubjectSchema,
+  evidenceDomainSchema,
+  relatedPersonSchema,
+} from "../rectification-v4/contracts.ts";
+import {
+  validatedModelAssistedEvidence,
+  type ExtractedLifeEventEvidence,
+  type ModelAssistedEventExtraction,
+} from "../conversational-rectification/evidence-extractor.ts";
+
+export const modelAssistedEventExtractionSchema = z.object({
+  sourceSpan: z.string().trim().min(1).max(4_000),
+  summary: z.string().trim().min(1).max(1_000),
+  domain: evidenceDomainSchema,
+  eventKind: eventKindSchema,
+  subject: eventSubjectSchema,
+  relatedPerson: relatedPersonSchema.nullable(),
+  dateText: z.string().trim().min(1).max(80).nullable(),
+}).strict();
+
+export type EventExtractorGenerator = (prompt: string) => Promise<Readonly<{ object: unknown }>>;
+
+export async function extractEventWithModel(input: Readonly<{
+  rawText: string;
+  sourceTurnId: string;
+  asOfDate: string;
+  modelId?: string | null;
+  timeoutMs?: number;
+  generateExtraction?: EventExtractorGenerator;
+}>): Promise<ExtractedLifeEventEvidence | null> {
+  const model = (input.modelId ? resolveLanguageModel(input.modelId) : null) ?? defaultLanguageModel();
+  if (!model && !input.generateExtraction) return null;
+  const agent = model ? new Agent({
+    id: `rectification-event-extractor-${model.id}`,
+    name: "Restricted Rectification Event Extractor",
+    model: model.model,
+    instructions: "Extract at most one explicitly stated dated life event. sourceSpan and dateText must be exact continuous substrings of the user text. Never infer or invent a date, normalized range, candidate time, score, id, or profile value. Return strict JSON only.",
+  }) : null;
+  const generate = input.generateExtraction ?? (async (prompt: string) => {
+    if (!agent) throw new Error("event_extractor_model_unavailable");
+    return agent.generate(prompt, {
+      abortSignal: AbortSignal.timeout(input.timeoutMs ?? 10_000),
+      structuredOutput: { schema: modelAssistedEventExtractionSchema, jsonPromptInjection: "inline" },
+    });
+  });
+  try {
+    const result = await generate(JSON.stringify({
+      task: "Extract one event that deterministic parsing could not classify. Use only literal text from userText.",
+      userText: input.rawText,
+      asOfDate: input.asOfDate,
+      allowedOutput: ["sourceSpan", "summary", "domain", "eventKind", "subject", "relatedPerson", "dateText"],
+    }));
+    const extraction = modelAssistedEventExtractionSchema.parse(result.object) as ModelAssistedEventExtraction;
+    return validatedModelAssistedEvidence({
+      rawText: input.rawText,
+      sourceTurnId: input.sourceTurnId,
+      asOfDate: input.asOfDate,
+      extraction,
+    });
+  } catch {
+    return null;
+  }
+}
diff --git a/frontend/src/lib/rectification-agent/opportunity-builder.ts b/frontend/src/lib/rectification-agent/opportunity-builder.ts
index 8dd73b4f..365b9a24 100644
--- a/frontend/src/lib/rectification-agent/opportunity-builder.ts
+++ b/frontend/src/lib/rectification-agent/opportunity-builder.ts
@@ -1,8 +1,27 @@
 import { createHash } from "node:crypto";
 import type { CandidateSnapshot, EvidenceDomain, LifeEventRevision, RectificationV4Turn } from "../rectification-v4/contracts.ts";
-import type { DiagnosticsSummary, QuestionOpportunity } from "./contracts.ts";
+import type { TargetDisposition } from "../rectification-v4/extraction.ts";
+import type { DiagnosticsSummary, QuestionOpportunity, SemanticQuestionOpportunity } from "./contracts.ts";
 
-const domains: readonly EvidenceDomain[] = ["education", "relocation", "relationship", "career", "finance", "health_pressure"];
+const forbiddenMoves: SemanticQuestionOpportunity["forbiddenMoves"] = [
+  "switch_target_event", "ask_multiple_questions", "claim_exact_birth_minute", "invent_event",
+  "invent_date", "expose_private_score", "expose_internal_id", "expose_technique_trace",
+];
+
+const domainPolicy: Readonly<Record<Exclude<EvidenceDomain, "family" | "other">, Readonly<{
+  goal: string;
+  fallbackPrompt: string;
+  keywords: RegExp;
+  recallEase: number;
+  privacyCost: number;
+}>>> = {
+  education: { goal: "收集一件有大致日期的教育转折。", fallbackPrompt: "哪次入学、毕业或专业变化的时间你比较确定？", keywords: /大学|学校|入学|毕业|考试|专业|读书/, recallEase: .82, privacyCost: .03 },
+  relocation: { goal: "收集一件有大致日期的迁居经历。", fallbackPrompt: "哪次搬家、离乡或长期迁居的时间你比较确定？", keywords: /搬家|迁居|离家|外地|城市|北京|上海|出国/, recallEase: .78, privacyCost: .04 },
+  relationship: { goal: "在用户愿意的前提下收集一件有大致日期的关系转折。", fallbackPrompt: "如果方便，哪段关系开始、结束或进入婚姻的时间比较确定？", keywords: /恋爱|关系|结婚|离婚|分手|伴侣|对象/, recallEase: .62, privacyCost: .22 },
+  career: { goal: "收集一件有大致日期的职业转折。", fallbackPrompt: "哪次入职、离职、转行、创业或职责变化的时间你比较确定？", keywords: /工作|实习|公司|研究院|职业|入职|离职|创业|负责/, recallEase: .85, privacyCost: .03 },
+  finance: { goal: "在用户愿意的前提下收集一件有大致日期的财务转折。", fallbackPrompt: "如果方便，哪次收入、负债或资产明显变化的时间比较确定？", keywords: /收入|负债|投资|资产|财务|买房|卖房/, recallEase: .6, privacyCost: .18 },
+  health_pressure: { goal: "在用户愿意的前提下收集一件本人有大致日期的健康转折。", fallbackPrompt: "如果方便，你本人哪次住院、手术、事故或健康转折的时间比较确定？", keywords: /住院|手术|事故|健康|生病|确诊|康复/, recallEase: .58, privacyCost: .28 },
+};
 
 function stableUuid(value: string): string {
   const hex = createHash("sha256").update(value).digest("hex").slice(0, 32).split("");
@@ -21,7 +40,9 @@ const routingValue: Record<QuestionOpportunity["kind"], number> = {
   ask_new_event: 0,
 };
 
-function utility(value: Omit<QuestionOpportunity, "opportunityId" | "utility" | "active">): number {
+type OpportunityInput = Omit<SemanticQuestionOpportunity, "contractVersion" | "opportunityId" | "utility" | "active" | "forbiddenMoves">;
+
+function utility(value: OpportunityInput): number {
   return Number((
     .35 * value.expectedInformationGain + .20 * value.dateSensitivity + .15 * value.candidateSplitRelevance
     + .10 * value.domainCoverageGain + .10 * value.recallEase + .10 * value.novelty
@@ -29,8 +50,34 @@ function utility(value: Omit<QuestionOpportunity, "opportunityId" | "utility" |
   ).toFixed(6));
 }
 
-function opportunity(caseId: string, input: Omit<QuestionOpportunity, "opportunityId" | "utility" | "active">): QuestionOpportunity {
-  const result = { ...input, opportunityId: stableUuid(`${caseId}:${input.kind}:${input.targetEventId ?? input.domain}:${input.prompt}`), utility: utility(input), active: true };
+function opportunity(caseId: string, input: OpportunityInput): QuestionOpportunity {
+  return {
+    contractVersion: "semantic-question-v2",
+    ...input,
+    forbiddenMoves,
+    opportunityId: stableUuid(`${caseId}:${input.kind}:${input.targetEventId ?? input.domain}:${input.goal}:${input.fallbackPrompt}`),
+    utility: utility(input),
+    active: true,
+  };
+}
+
+function daysWide(event: LifeEventRevision): number {
+  return Math.floor((Date.parse(`${event.dateRange.end}T00:00:00Z`) - Date.parse(`${event.dateRange.start}T00:00:00Z`)) / 86_400_000) + 1;
+}
+
+function anchorFor(event: LifeEventRevision): string {
+  return event.summary.replace(/[“”"']/g, "").trim().slice(0, 80);
+}
+
+function recentText(turns: readonly RectificationV4Turn[]): string {
+  return turns.slice(-6).map((turn) => turn.answer).join(" ");
+}
+
+function declinedSensitiveDomains(turns: readonly RectificationV4Turn[]): ReadonlySet<EvidenceDomain> {
+  const result = new Set<EvidenceDomain>();
+  for (const turn of turns) {
+    if (turn.questionDomain && /不想说|不方便说|不想回答|跳过|这个不说|换个方向|不聊这个/.test(turn.answer)) result.add(turn.questionDomain);
+  }
   return result;
 }
 
@@ -40,74 +87,125 @@ export function buildQuestionOpportunities(input: Readonly<{
   turns: readonly RectificationV4Turn[];
   snapshot: CandidateSnapshot | null;
   diagnostics: DiagnosticsSummary | null;
+  targetDisposition?: TargetDisposition;
   retryTargetEventIds?: readonly string[];
 }>): readonly QuestionOpportunity[] {
-  const attempted = new Set(input.turns.flatMap((turn) => turn.questionTargetEventId ? [turn.questionTargetEventId] : []));
+  const targetAttempts = new Map<string, number>();
+  for (const turn of input.turns) {
+    if (turn.questionTargetEventId) targetAttempts.set(turn.questionTargetEventId, (targetAttempts.get(turn.questionTargetEventId) ?? 0) + 1);
+  }
   const retryTargets = new Set(input.retryTargetEventIds ?? []);
   const scoreableDomains = new Set(input.events.filter((event) => event.scoreability === "scoreable").map((event) => event.domain));
+  const refusedDomains = declinedSensitiveDomains(input.turns);
+  const latestContext = recentText(input.turns);
   const opportunities: QuestionOpportunity[] = [];
-  for (const eventId of retryTargets) {
-    const event = input.events.find((value) => value.eventId === eventId);
-    if (!event) continue;
-    opportunities.push(opportunity(input.caseId, {
-      kind: "resolve_event_conflict", domain: event.domain, targetEventId: event.eventId,
-      prompt: `你刚才补充的新经历已经另行保存。关于“${event.summary}”的时间仍没有确定；如果记不清，可以直接说不知道。`,
-      reason: "用户补充了另一件事，原事件的日期或主体仍待确认。",
-      expectedInformationGain: .85, dateSensitivity: .75, candidateSplitRelevance: .6, domainCoverageGain: 0, recallEase: .8, novelty: .7, repetitionPenalty: .15, privacyCost: .05,
-    }));
-  }
-  if (opportunities.length > 0) {
-    return opportunities.sort((left, right) =>
-      right.utility - left.utility
-      || left.opportunityId.localeCompare(right.opportunityId));
+
+  if (input.targetDisposition === "answered_other_event") {
+    for (const eventId of retryTargets) {
+      const event = input.events.find((value) => value.eventId === eventId);
+      if (!event || (targetAttempts.get(eventId) ?? 0) > 1) continue;
+      const anchor = anchorFor(event);
+      opportunities.push(opportunity(input.caseId, {
+        kind: "resolve_event_conflict", domain: event.domain, targetEventId: event.eventId,
+        goal: `温和确认“${anchor}”尚缺的日期或主体；允许用户直接跳过。`,
+        requestedFields: ["event_range"], anchors: [anchor], contextFacts: [`用户刚补充了另一件完整事件。`, `同一目标最多补问一次。`],
+        fallbackPrompt: `关于“${anchor}”，如果还记得大概时间范围，可以补充一下吗？`,
+        reason: "用户回答了另一件新事件，原目标只允许一次温和补问。",
+        expectedInformationGain: .78, dateSensitivity: .7, candidateSplitRelevance: .55, domainCoverageGain: 0,
+        recallEase: .72, novelty: .55, repetitionPenalty: .25, privacyCost: .05,
+      }));
+    }
   }
+
+  const targetClosed = input.targetDisposition === "unknown"
+    || input.targetDisposition === "declined"
+    || input.targetDisposition === "direction_change";
   for (const event of input.events) {
-    if (retryTargets.has(event.eventId)) continue;
-    if ((event.scoreability === "pending_review" || event.subject === "other") && !attempted.has(event.eventId)) {
+    if (targetClosed && retryTargets.has(event.eventId)) continue;
+    const attemptCount = targetAttempts.get(event.eventId) ?? 0;
+    const anchor = anchorFor(event);
+    if ((event.scoreability === "pending_review" || event.subject === "other") && attemptCount === 0) {
       opportunities.push(opportunity(input.caseId, {
         kind: "clarify_event_subject", domain: event.domain, targetEventId: event.eventId,
-        prompt: `你刚才提到“${event.summary}”，这件事主要发生在你本人，还是家人或伴侣身上？`, reason: "事件主体决定是否允许进入个人分盘评分。",
-        expectedInformationGain: .9, dateSensitivity: .2, candidateSplitRelevance: .3, domainCoverageGain: .2, recallEase: .95, novelty: .9, repetitionPenalty: 0, privacyCost: .05,
-      }));
-    }
-    if (event.scoreability === "scoreable" && event.dateRange.precision !== "day" && !attempted.has(event.eventId)) {
-      const sensitivity = input.diagnostics?.eventDateSensitivity.find((item) => item.eventId === event.eventId);
-      opportunities.push(opportunity(input.caseId, {
-        kind: "refine_event_date", domain: event.domain, targetEventId: event.eventId,
-        prompt: `关于“${event.summary}”，你还记得更具体的月份或日期吗？不确定也可以只说大概范围。`, reason: "日期采样显示这件事的时间精度可能影响候选排序。",
-        expectedInformationGain: sensitivity ? 1 - sensitivity.winnerRetentionRate : .72,
-        dateSensitivity: sensitivity ? 1 - sensitivity.candidateClusterRetentionRate : .7,
-        candidateSplitRelevance: .55, domainCoverageGain: 0, recallEase: .72, novelty: .8, repetitionPenalty: 0, privacyCost: .05,
+        goal: `确认“${anchor}”发生在本人、家人还是伴侣。`, requestedFields: ["event_subject"],
+        anchors: [anchor], contextFacts: [`当前主体为 ${event.subject}。`],
+        fallbackPrompt: `“${anchor}”主要发生在你本人、家人还是伴侣身上？`,
+        reason: "事件主体决定是否允许进入个人评分。",
+        expectedInformationGain: .9, dateSensitivity: .2, candidateSplitRelevance: .3, domainCoverageGain: .2,
+        recallEase: .95, novelty: .9, repetitionPenalty: 0, privacyCost: event.domain === "health_pressure" || event.domain === "family" ? .24 : .05,
       }));
     }
+    if (event.scoreability !== "scoreable" || event.dateRange.precision === "day" || attemptCount > 0) continue;
+    const sensitivity = input.diagnostics?.eventDateSensitivity.find((item) => item.eventId === event.eventId);
+    const dateSensitive = Boolean(sensitivity && (sensitivity.winnerRetentionRate < .65 || sensitivity.candidateClusterRetentionRate < .65));
+    const precision = event.dateRange.precision;
+    const shouldRefine = precision === "quarter" || precision === "year" || (precision === "month" && dateSensitive)
+      || (precision === "range" && daysWide(event) > 120 && dateSensitive);
+    if (!shouldRefine) continue;
+    const requestedFields: SemanticQuestionOpportunity["requestedFields"] = precision === "year" || precision === "quarter"
+      ? ["event_month"]
+      : precision === "range" ? ["event_range"] : ["event_day"];
+    const fallbackPrompt = precision === "year" || precision === "quarter"
+      ? `“${anchor}”大概发生在哪个月，或一年中的哪个时间段？`
+      : precision === "range"
+        ? `“${anchor}”的时间范围还能再缩小一些吗？`
+        : `关于“${anchor}”，你还记得大概哪一天吗？`;
+    opportunities.push(opportunity(input.caseId, {
+      kind: "refine_event_date", domain: event.domain, targetEventId: event.eventId,
+      goal: `仅在必要精度上细化“${anchor}”的日期。`, requestedFields, anchors: [anchor],
+      contextFacts: [`现有精度为 ${precision}。`, ...(sensitivity ? [`候选保持率 ${sensitivity.candidateClusterRetentionRate}。`] : [])],
+      fallbackPrompt, reason: dateSensitive ? "日期敏感性诊断显示该事件可能改变候选排序。" : "当前日期范围较宽。",
+      expectedInformationGain: sensitivity ? 1 - sensitivity.winnerRetentionRate : .66,
+      dateSensitivity: sensitivity ? 1 - sensitivity.candidateClusterRetentionRate : .55,
+      candidateSplitRelevance: .55, domainCoverageGain: 0, recallEase: precision === "year" ? .8 : .62,
+      novelty: .78, repetitionPenalty: 0, privacyCost: .05,
+    }));
   }
+
   const split = input.diagnostics?.candidateSplits[0];
   if (split) {
-    const target = input.events.find((event) => split.eventIds.includes(event.eventId));
+    const target = input.events.find((event) => split.eventIds.includes(event.eventId)
+      && (targetAttempts.get(event.eventId) ?? 0) === 0
+      && !(targetClosed && retryTargets.has(event.eventId)));
+    const anchor = target ? anchorFor(target) : null;
     opportunities.push(opportunity(input.caseId, {
       kind: "disambiguate_candidate_split", domain: target?.domain ?? "other", targetEventId: target?.eventId ?? null,
-      prompt: target ? `围绕“${target.summary}”，当时最明显的转折是事情开始、达到高峰，还是正式结束？` : "剩余候选在同一事件的阶段上有差异：你记得当时更接近开始、达到高峰，还是正式结束吗？",
-      reason: `候选簇在 ${split.techniqueLayers.slice(0, 3).join("、") || "技术层"} 上出现可检验分歧。`,
-      expectedInformationGain: .88, dateSensitivity: .45, candidateSplitRelevance: .95, domainCoverageGain: 0, recallEase: .65, novelty: .9, repetitionPenalty: target && attempted.has(target.eventId) ? .35 : 0, privacyCost: .1,
+      goal: target ? `确认“${anchor}”更接近开始、高峰还是正式结束。` : "确认一件现有事件的发生阶段。",
+      requestedFields: ["event_stage"], anchors: anchor ? [anchor] : [],
+      contextFacts: [`候选分歧涉及 ${split.techniqueLayers.length} 个已计算技术层。`],
+      fallbackPrompt: target ? `“${anchor}”当时更接近事情开始、达到高峰，还是正式结束？` : "那件经历更接近开始、达到高峰，还是正式结束？",
+      reason: "候选簇在现有诊断中出现可检验分歧。",
+      expectedInformationGain: .88, dateSensitivity: .45, candidateSplitRelevance: .95, domainCoverageGain: 0,
+      recallEase: .65, novelty: .9, repetitionPenalty: 0, privacyCost: .1,
     }));
   }
-  const missingDomain = domains.find((domain) => !scoreableDomains.has(domain));
-  if (missingDomain) {
-    const prompts: Record<EvidenceDomain, string> = {
-      education: "你人生中有没有一次入学、毕业、考试或专业变化，时间大致在什么时候？",
-      relocation: "你有没有一次印象深刻的搬家、离乡或长期迁居？大致在什么时候？",
-      relationship: "你有没有一段关系正式开始、结束或进入婚姻的明确时间点？",
-      career: "你有没有一次入职、离职、升职、转行或创业的明确时间点？",
-      finance: "你有没有一次收入、投资、负债或资产状况明显改变的时间点？",
-      health_pressure: "你本人有没有一次住院、手术、事故或明显健康转折？大致在什么时候？",
-      family: "请补充一个家庭事件。", other: "请补充一个有明确时间的重要人生事件。",
-    };
+
+  const scoreableCount = input.events.filter((event) => event.scoreability === "scoreable").length;
+  for (const [domain, policy] of Object.entries(domainPolicy) as [Exclude<EvidenceDomain, "family" | "other">, (typeof domainPolicy)[Exclude<EvidenceDomain, "family" | "other">]][]) {
+    if (refusedDomains.has(domain)) continue;
+    const covered = scoreableDomains.has(domain);
+    const themeBonus = policy.keywords.test(latestContext) ? .12 : 0;
+    const alreadyAsked = input.turns.some((turn) => turn.questionDomain === domain && !turn.questionTargetEventId);
+    const latestEvent = input.events.at(-1);
+    const latestAnchor = latestEvent ? anchorFor(latestEvent) : null;
+    const prompt = latestAnchor
+      ? `承接“${latestAnchor}”，请再说一件时间相对明确的经历：${policy.fallbackPrompt}`
+      : policy.fallbackPrompt;
     opportunities.push(opportunity(input.caseId, {
-      kind: "ask_new_event", domain: missingDomain, targetEventId: null, prompt: prompts[missingDomain], reason: "当前证据领域覆盖不足。",
-      expectedInformationGain: .7, dateSensitivity: .45, candidateSplitRelevance: .5, domainCoverageGain: 1, recallEase: .7, novelty: 1, repetitionPenalty: 0, privacyCost: missingDomain === "health_pressure" ? .2 : .08,
+      kind: "ask_new_event", domain, targetEventId: null, goal: policy.goal,
+      requestedFields: ["new_dated_event"], anchors: latestAnchor ? [latestAnchor] : [],
+      contextFacts: [`已有 ${scoreableCount} 件可评分事件。`, `该领域${covered ? "已有覆盖" : "尚未覆盖"}。`],
+      fallbackPrompt: prompt, reason: covered ? "继续收集可区分候选的独立事件。" : "补足证据领域覆盖。",
+      expectedInformationGain: covered ? .54 + themeBonus : .7 + themeBonus,
+      dateSensitivity: input.snapshot ? .5 : .35,
+      candidateSplitRelevance: input.diagnostics?.candidateSplits.length ? .58 : .42,
+      domainCoverageGain: covered ? 0 : 1,
+      recallEase: policy.recallEase, novelty: alreadyAsked ? .35 : .9,
+      repetitionPenalty: alreadyAsked ? .3 : 0, privacyCost: policy.privacyCost,
     }));
   }
-  return opportunities.sort((left, right) =>
-    right.utility - left.utility
-    || left.opportunityId.localeCompare(right.opportunityId));
+
+  return opportunities
+    .sort((left, right) => right.utility - left.utility || left.opportunityId.localeCompare(right.opportunityId))
+    .slice(0, 5);
 }
diff --git a/frontend/src/lib/rectification-agent/orchestrator.ts b/frontend/src/lib/rectification-agent/orchestrator.ts
index 29e2085c..b5eb9525 100644
--- a/frontend/src/lib/rectification-agent/orchestrator.ts
+++ b/frontend/src/lib/rectification-agent/orchestrator.ts
@@ -4,6 +4,7 @@ import { buildCandidateClusters } from "../rectification-v4/candidate-clusters.t
 import type { CandidateSnapshot, RectificationV4Question } from "../rectification-v4/contracts.ts";
 import { evaluateDecisionGate } from "../rectification-v4/decision-gate.ts";
 import { reconcileV4Evidence } from "../rectification-v4/extraction.ts";
+import { extractEventWithModel } from "./event-extractor-agent.ts";
 import { evidenceSetHash } from "../rectification-v4/fingerprints.ts";
 import { latestEventRevisions, scoreableEvents } from "../rectification-v4/evidence-ledger.ts";
 import { projectLegacyV4Turn } from "../rectification-v4/legacy-projector.ts";
@@ -48,15 +49,38 @@ export async function processRectificationAgentTurn(input: Readonly<{
 }>> {
   const { claimed, now } = input;
   await input.onPhase?.("extracting_evidence");
-  const reconciliation = claimed.turn.answer ? reconcileV4Evidence({
+  const asOfDate = now.toISOString().slice(0, 10);
+  let reconciliation = claimed.turn.answer ? reconcileV4Evidence({
     caseId: claimed.case.id,
     answer: claimed.turn.answer,
     sourceTurnId: claimed.turn.id,
-    asOfDate: now.toISOString().slice(0, 10),
+    asOfDate,
     existing: claimed.events,
     targetEventId: claimed.turn.questionTargetEventId,
     now,
-  }) : { revisions: [], pending: [], unansweredTargetEventId: null };
+  }) : { revisions: [], pending: [], unansweredTargetEventId: null, targetDisposition: "not_applicable" as const };
+  const needsAssistance = claimed.case.deploymentMode !== "v4_legacy" && (
+    reconciliation.pending.some((event) => event.reasonCode === "event_unparsed")
+    || reconciliation.revisions.some((event) => event.scoreability === "pending_review" || event.scoreability === "unsupported")
+  );
+  if (needsAssistance) {
+    const assisted = await extractEventWithModel({
+      rawText: claimed.turn.answer,
+      sourceTurnId: claimed.turn.id,
+      asOfDate,
+      modelId: claimed.case.orchestrationModelId,
+    });
+    if (assisted) reconciliation = reconcileV4Evidence({
+      caseId: claimed.case.id,
+      answer: claimed.turn.answer,
+      sourceTurnId: claimed.turn.id,
+      asOfDate,
+      existing: claimed.events,
+      targetEventId: claimed.turn.questionTargetEventId,
+      assistedEvidence: [assisted],
+      now,
+    });
+  }
   const extracted = reconciliation.revisions;
   const events = latestEventRevisions([...claimed.events, ...extracted]);
   const scoreable = scoreableEvents(events);
@@ -174,6 +198,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
     turns: claimed.turns,
     snapshot,
     diagnostics,
+    targetDisposition: reconciliation.targetDisposition,
     retryTargetEventIds: reconciliation.unansweredTargetEventId ? [reconciliation.unansweredTargetEventId] : [],
   });
   await input.onPhase?.("reasoning");
@@ -182,6 +207,15 @@ export async function processRectificationAgentTurn(input: Readonly<{
     snapshot,
     diagnostics: safeDiagnostics,
     opportunities,
+    recentTurns: claimed.turns,
+    recentEvents: events,
+    currentTarget: claimed.turn.questionTargetEventId
+      ? events.find((event) => event.eventId === claimed.turn.questionTargetEventId) ?? null
+      : null,
+    targetDisposition: reconciliation.targetDisposition,
+    pendingEvidence: reconciliation.pending,
+    candidateRangeChanged: claimed.case.latestSnapshot?.clusters[0]?.startTime !== snapshot?.clusters[0]?.startTime
+      || claimed.case.latestSnapshot?.clusters[0]?.endTime !== snapshot?.clusters[0]?.endTime,
     enabled: claimed.case.deploymentMode !== "v4_legacy",
   });
   const rawDecision = reasoned.decision;
@@ -241,6 +275,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
       acceptedEvents: extracted,
       pendingEvidence: reconciliation.pending,
       snapshot,
+      previousSnapshot: claimed.case.latestSnapshot,
       validated: validatedDecision,
     })
     : legacyProjection.publicMessage;
@@ -248,7 +283,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
     id: randomUUID(),
     domain: selectedOpportunity.domain,
     targetEventId: selectedOpportunity.targetEventId,
-    prompt: selectedOpportunity.prompt,
+    prompt: publicMessage.question ?? selectedOpportunity.fallbackPrompt,
     recallCost: selectedOpportunity.privacyCost >= .2
       ? "high" as const
       : selectedOpportunity.recallEase < .6
diff --git a/frontend/src/lib/rectification-agent/reasoner-agent.ts b/frontend/src/lib/rectification-agent/reasoner-agent.ts
index 18eec113..9f044b6f 100644
--- a/frontend/src/lib/rectification-agent/reasoner-agent.ts
+++ b/frontend/src/lib/rectification-agent/reasoner-agent.ts
@@ -3,7 +3,8 @@ import { Agent } from "@mastra/core/agent";
 import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
 import { defaultLanguageModel, resolveLanguageModel } from "@/mastra/model";
-import type { CandidateSnapshot, RectificationV4Case } from "../rectification-v4/contracts.ts";
+import type { CandidateSnapshot, LifeEventRevision, PendingEvidence, RectificationV4Case, RectificationV4Turn } from "../rectification-v4/contracts.ts";
+import type { TargetDisposition } from "../rectification-v4/extraction.ts";
 import { deterministicDecision } from "./fallback-policy.ts";
 import { recordRectificationAgentTelemetry } from "./telemetry.ts";
 import {
@@ -34,11 +35,53 @@ function diagnosticPayload(diagnostic: RectificationDiagnostic, summary: Diagnos
   }
 }
 
+export function buildReasonerState(input: Readonly<{
+  snapshot: CandidateSnapshot | null;
+  diagnostics: DiagnosticsSummary;
+  opportunities: readonly QuestionOpportunity[];
+  recentTurns?: readonly RectificationV4Turn[];
+  recentEvents?: readonly LifeEventRevision[];
+  currentTarget?: LifeEventRevision | null;
+  targetDisposition?: TargetDisposition;
+  pendingEvidence?: readonly PendingEvidence[];
+  candidateRangeChanged?: boolean;
+}>) {
+  return {
+    task: "Choose the next bounded rectification action.",
+    currentSnapshotId: input.snapshot?.id ?? null,
+    canOfferCandidateRange: input.snapshot?.canAcceptRange ?? false,
+    hasCandidateRange: Boolean(input.snapshot?.clusters[0]),
+    candidateRangeChanged: input.candidateRangeChanged ?? false,
+    latestAnswer: input.recentTurns?.at(-1)?.answer ?? "",
+    recentTurns: (input.recentTurns ?? []).slice(-6).map((turn) => ({ question: turn.question, answer: turn.answer })),
+    recentEvents: (input.recentEvents ?? []).slice(-5).map((event) => ({ summary: event.summary, date: event.dateRange.label, domain: event.domain, subject: event.subject })),
+    currentTarget: input.currentTarget ? { summary: input.currentTarget.summary, date: input.currentTarget.dateRange.label, domain: input.currentTarget.domain } : null,
+    targetDisposition: input.targetDisposition ?? "not_applicable",
+    pendingEvidence: {
+      count: input.pendingEvidence?.length ?? 0,
+      reasons: [...new Set((input.pendingEvidence ?? []).map((item) => item.reasonCode))],
+    },
+    compactDiagnostics: {
+      primaryClusterRetentionRate: input.diagnostics.primaryClusterRetentionRate,
+      mostDiscriminatingLayers: input.diagnostics.mostDiscriminatingLayers,
+    },
+    opportunities: input.opportunities.map(({ opportunityId, kind, targetEventId, goal, requestedFields, anchors, utility, reason }) => ({
+      opportunityId, kind, targetEventId, goal, requestedFields, anchors, utility, reason,
+    })),
+  };
+}
+
 export async function runBoundedReasoner(input: Readonly<{
   caseValue: RectificationV4Case;
   snapshot: CandidateSnapshot | null;
   diagnostics: DiagnosticsSummary;
   opportunities: readonly QuestionOpportunity[];
+  recentTurns?: readonly RectificationV4Turn[];
+  recentEvents?: readonly LifeEventRevision[];
+  currentTarget?: LifeEventRevision | null;
+  targetDisposition?: TargetDisposition;
+  pendingEvidence?: readonly PendingEvidence[];
+  candidateRangeChanged?: boolean;
   maxToolCalls?: number;
   timeoutMs?: number;
   enabled?: boolean;
@@ -131,16 +174,7 @@ export async function runBoundedReasoner(input: Readonly<{
     outputTokenCount += Math.max(0, Math.trunc(usage.outputTokens ?? 0));
     usageObserved = true;
   };
-  const baseState = {
-    task: "Choose the next bounded rectification action.",
-    currentSnapshotId: input.snapshot?.id ?? null,
-    canOfferCandidateRange: input.snapshot?.canAcceptRange ?? false,
-    compactDiagnostics: {
-      primaryClusterRetentionRate: input.diagnostics.primaryClusterRetentionRate,
-      mostDiscriminatingLayers: input.diagnostics.mostDiscriminatingLayers,
-    },
-    opportunities: input.opportunities.map(({ opportunityId, kind, targetEventId, utility, reason }) => ({ opportunityId, kind, targetEventId, utility, reason })),
-  };
+  const baseState = buildReasonerState(input);
 
   recordRectificationAgentTelemetry({ caseId: input.caseValue.id, phase: "reasoner", outcome: "started", modelId, toolName: null, decisionAction: null, durationMs: null, errorCode: null, deploymentSha });
   try {
diff --git a/frontend/src/lib/rectification-agent/renderer-agent.ts b/frontend/src/lib/rectification-agent/renderer-agent.ts
index 553c779c..2c216bc3 100644
--- a/frontend/src/lib/rectification-agent/renderer-agent.ts
+++ b/frontend/src/lib/rectification-agent/renderer-agent.ts
@@ -2,46 +2,142 @@ import path from "node:path";
 import { Agent } from "@mastra/core/agent";
 import { defaultLanguageModel, resolveLanguageModel } from "@/mastra/model";
 import type { CandidateSnapshot, LifeEventRevision, PendingEvidence, RectificationV4Case } from "../rectification-v4/contracts.ts";
-import { publicMessageSchema, type PublicMessage, type ValidatedDecision } from "./contracts.ts";
+import { publicMessageSchema, type PublicMessage, type QuestionOpportunity, type ValidatedDecision } from "./contracts.ts";
 import { recordRectificationAgentTelemetry } from "./telemetry.ts";
 
 const skillPath = process.env.RECTIFICATION_SKILL_PATH?.trim() || path.resolve(process.cwd(), "..", "skills", "birth-time-rectification");
 const agents = new Map<string, Agent>();
+const bannedAcknowledgement = /(?:这个信息很有用|它不是单纯的|而是把|接下来最有价值的是|这样可以避免|已记录[:：]?|我记下了)/;
+const overinterpretedAcknowledgement = /(?:职业方向正式落地|人生意义|意味着你|说明你(?:已经|开始|正式)|标志着你)/;
+const internalTerms = /(?:opportunityId|snapshotId|eventId|targetEventId|requestedFields|fallbackPrompt|tool\s*call|tool_call|score|评分|模型名|opportunity|snapshot|D\d{1,2}|KP\b|Vimshottari)/i;
+const multiQuestionMoves = /(?:另外|还有|同时再说|并且告诉我|顺便|再告诉我)/;
+const birthMinute = /(?:出生|生时|几点).{0,12}(?:[01]\d|2[0-3]):[0-5]\d|(?:[01]\d|2[0-3]):[0-5]\d.{0,12}(?:出生|生时)/;
+
 function agentFor(modelId: string | null): { id: string; agent: Agent } | null {
   const selected = (modelId ? resolveLanguageModel(modelId) : null) ?? defaultLanguageModel();
   if (!selected) return null;
   const cached = agents.get(selected.id);
   if (cached) return { id: selected.id, agent: cached };
   const agent = new Agent({
-    id: `rectification-v5-renderer-${selected.id}`, name: "Birth Time Rectification Response Renderer", model: selected.model, skills: [skillPath],
-    instructions: "Write concise natural Simplified Chinese. Acknowledge the latest experience, state uncertainty honestly, and never expose ids, scores, internal domains, representative minutes, model/tool details, or claim an exact birth minute. Return strict JSON only.",
+    id: `rectification-v6-renderer-${selected.id}`,
+    name: "Birth Time Rectification Response Renderer",
+    model: selected.model,
+    skills: [skillPath],
+    instructions: "Write concise natural Simplified Chinese. Realize exactly one question from the supplied semantic opportunity. Do not invent events or dates, switch targets, interpret the life meaning of an experience, expose ids/scores/techniques, mention a representative minute, or claim an exact birth minute. Avoid canned acknowledgement. Return strict JSON only.",
   });
   agents.set(selected.id, agent);
   return { id: selected.id, agent };
 }
 
-function deterministic(input: { latestAnswer: string; acceptedEvents: readonly LifeEventRevision[]; pendingEvidence: readonly PendingEvidence[]; snapshot: CandidateSnapshot | null; validated: ValidatedDecision }): PublicMessage {
-  const latest = input.acceptedEvents.at(-1);
-  const acknowledgement = latest
-    ? `我记下了你提到的“${latest.summary}”，并保留了你给出的时间精度。`
-    : input.pendingEvidence.length
-      ? "我保留了你刚才的原始描述；其中的日期或事件关系还不能安全进入评分。"
-      : input.latestAnswer
-        ? "我保留了你刚才的原始描述；目前还没有足够明确的新日期可以直接进入评分。"
-        : "我会继续根据已确认的人生事件比较候选范围。";
-  const primary = input.snapshot?.clusters[0];
-  const candidateUpdate = primary ? `目前较集中的候选仍是 ${primary.startTime}–${primary.endTime}；这只是待验证范围，不代表其中某一分钟已被确认。` : null;
-  const limitation = input.validated.decision.action === "stop_low_confidence" ? "现有证据不足以安全缩小范围，我不会把不稳定结果包装成确定时间。" : null;
-  return { acknowledgement, candidateUpdate, limitation, question: input.validated.selectedOpportunity?.prompt ?? null };
+function normalized(value: string): string {
+  return value.normalize("NFKC").replace(/[“”"'\s，,。.!！?？:：；;]/g, "");
 }
 
-export function enforceServerQuestion(value: unknown, question: string | null): PublicMessage {
-  return { ...publicMessageSchema.parse(value), question };
+export function validateQuestionRealization(question: unknown, opportunity: QuestionOpportunity): Readonly<{ valid: boolean; issues: readonly string[] }> {
+  if (typeof question !== "string") return { valid: false, issues: ["question_missing"] };
+  const value = question.trim();
+  const issues: string[] = [];
+  if (value.length < 8 || value.length > 180) issues.push("question_length_invalid");
+  if ((value.match(/[?？]/g) ?? []).length > 1) issues.push("multiple_question_marks");
+  if ((value.match(/[。.!！?？]/g) ?? []).length > 2) issues.push("too_many_sentences");
+  if (/\n\s*(?:[-*•]|\d+[.)、])/.test(value)) issues.push("question_list_forbidden");
+  if (internalTerms.test(value)) issues.push("internal_information_exposed");
+  if (multiQuestionMoves.test(value)) issues.push("multiple_question_instruction");
+  if (birthMinute.test(value)) issues.push("birth_minute_injected");
+  if (opportunity.targetEventId) {
+    const questionText = normalized(value);
+    if (!opportunity.anchors.some((anchor) => questionText.includes(normalized(anchor)))) issues.push("target_anchor_missing");
+  }
+  for (const field of opportunity.requestedFields) {
+    if (field === "event_subject" && !/(?:本人|你自己|家人|伴侣|配偶)/.test(value)) issues.push("event_subject_not_requested");
+    if (field === "event_month" && !/(?:月份|哪个月|几月|大概月份|时间段)/.test(value)) issues.push("event_month_not_requested");
+    if (field === "event_day" && !/(?:哪一天|几号|具体日期|大概日期)/.test(value)) issues.push("event_day_not_requested");
+    if (field === "event_range" && !/(?:大概时间|时间范围|什么时候|哪个时间|哪一段时间)/.test(value)) issues.push("event_range_not_requested");
+    if (field === "event_stage" && !/(?:开始|高峰|结束|正式发生)/.test(value)) issues.push("event_stage_not_requested");
+    if (field === "new_dated_event" && !/(?:哪次|哪件|一件|经历)/.test(value)) issues.push("new_event_not_requested");
+    if (field === "new_dated_event" && !/(?:时间|日期|什么时候|哪年|哪月|几月)/.test(value)) issues.push("new_event_date_not_requested");
+    if (field === "event_year" && !/(?:哪年|年份|哪一年)/.test(value)) issues.push("event_year_not_requested");
+  }
+  return { valid: issues.length === 0, issues };
+}
+
+function primaryRange(snapshot: CandidateSnapshot | null): string | null {
+  const primary = snapshot?.clusters[0];
+  return primary ? `${primary.startTime}–${primary.endTime}` : null;
+}
+
+export function candidateUpdateFor(input: Readonly<{
+  snapshot: CandidateSnapshot | null;
+  previousSnapshot: CandidateSnapshot | null;
+  decisionAction: ValidatedDecision["decision"]["action"];
+}>): string | null {
+  if (!input.snapshot?.canAcceptRange) return null;
+  const current = primaryRange(input.snapshot);
+  if (!current) return null;
+  const previous = primaryRange(input.previousSnapshot);
+  const firstStable = !input.previousSnapshot?.canAcceptRange;
+  const changed = previous !== current;
+  if (!firstStable && !changed) return null;
+  return `目前通过稳定性门的候选范围是 ${current}；它仍是待验证范围，不代表其中某一分钟已被确认。`;
+}
+
+function naturalAcknowledgement(input: { latestAnswer: string; acceptedEvents: readonly LifeEventRevision[]; pendingEvidence: readonly PendingEvidence[] }): string {
+  const latest = input.acceptedEvents.at(-1);
+  if (latest) return `你提到的是 ${latest.dateRange.label} 的“${latest.summary}”。`;
+  if (input.pendingEvidence.length) return "这段经历的事件或日期目前还不足以安全进入评分。";
+  if (input.latestAnswer) return "我会保留你刚才的原始说法，不补写你没有确认的信息。";
+  return "我们继续用时间相对明确的经历比较候选范围。";
+}
+
+function deterministic(input: {
+  latestAnswer: string;
+  acceptedEvents: readonly LifeEventRevision[];
+  pendingEvidence: readonly PendingEvidence[];
+  snapshot: CandidateSnapshot | null;
+  previousSnapshot: CandidateSnapshot | null;
+  validated: ValidatedDecision;
+}): PublicMessage {
+  return {
+    acknowledgement: naturalAcknowledgement(input),
+    candidateUpdate: candidateUpdateFor({ snapshot: input.snapshot, previousSnapshot: input.previousSnapshot, decisionAction: input.validated.decision.action }),
+    limitation: input.validated.decision.action === "stop_low_confidence"
+      ? "现有证据不足以安全缩小范围，我会在这里停下，不把不稳定结果包装成确定时间。"
+      : null,
+    question: input.validated.selectedOpportunity?.fallbackPrompt ?? null,
+  };
+}
+
+export function realizePublicMessage(value: unknown, input: Parameters<typeof deterministic>[0]): PublicMessage {
+  const parsed = publicMessageSchema.parse(value);
+  const opportunity = input.validated.selectedOpportunity;
+  const fallback = deterministic(input);
+  const acknowledgement = bannedAcknowledgement.test(parsed.acknowledgement)
+    || overinterpretedAcknowledgement.test(parsed.acknowledgement)
+    || internalTerms.test(parsed.acknowledgement)
+    || (parsed.acknowledgement.match(/[。.!！?？]/g) ?? []).length > 2
+    || (input.acceptedEvents.at(-1) && !normalized(parsed.acknowledgement).includes(normalized(input.acceptedEvents.at(-1)!.summary)))
+    ? fallback.acknowledgement
+    : parsed.acknowledgement;
+  const question = opportunity
+    ? validateQuestionRealization(parsed.question, opportunity).valid ? parsed.question : opportunity.fallbackPrompt
+    : null;
+  return {
+    acknowledgement,
+    candidateUpdate: fallback.candidateUpdate,
+    limitation: fallback.limitation ?? (parsed.limitation && !internalTerms.test(parsed.limitation) ? parsed.limitation : null),
+    question,
+  };
 }
 
 export async function renderPublicTurn(input: Readonly<{
-  caseValue: RectificationV4Case; latestAnswer: string; acceptedEvents: readonly LifeEventRevision[];
-  pendingEvidence: readonly PendingEvidence[]; snapshot: CandidateSnapshot | null; validated: ValidatedDecision; timeoutMs?: number;
+  caseValue: RectificationV4Case;
+  latestAnswer: string;
+  acceptedEvents: readonly LifeEventRevision[];
+  pendingEvidence: readonly PendingEvidence[];
+  snapshot: CandidateSnapshot | null;
+  previousSnapshot: CandidateSnapshot | null;
+  validated: ValidatedDecision;
+  timeoutMs?: number;
 }>): Promise<PublicMessage> {
   const started = Date.now();
   const deploymentSha = process.env.DEPLOYMENT_SHA?.trim() || null;
@@ -53,14 +149,23 @@ export async function renderPublicTurn(input: Readonly<{
   }
   recordRectificationAgentTelemetry({ caseId: input.caseValue.id, phase: "renderer", outcome: "started", modelId: selected.id, toolName: null, decisionAction: input.validated.decision.action, durationMs: null, errorCode: null, deploymentSha });
   try {
+    const opportunity = input.validated.selectedOpportunity;
     const result = await selected.agent.generate(JSON.stringify({
-      task: "Render the public turn. The server-owned question must not be changed.", latestAnswer: input.latestAnswer,
+      task: "Render one public turn and naturally realize the semantic question contract.",
+      latestAnswer: input.latestAnswer,
       acceptedEvents: input.acceptedEvents.slice(-3).map((event) => ({ summary: event.summary, date: event.dateRange.label, subject: event.subject })),
-      pendingEvidence: input.pendingEvidence.slice(-3).map((event) => ({ rawText: event.rawText, reasonCode: event.reasonCode })),
-      candidateRange: input.snapshot?.clusters[0] ? { start: input.snapshot.clusters[0].startTime, end: input.snapshot.clusters[0].endTime } : null,
-      action: input.validated.decision.action, exactQuestion: input.validated.selectedOpportunity?.prompt ?? null,
+      pendingEvidence: input.pendingEvidence.slice(-3).map((event) => ({ reasonCode: event.reasonCode })),
+      action: input.validated.decision.action,
+      selectedOpportunity: opportunity ? {
+        kind: opportunity.kind,
+        goal: opportunity.goal,
+        requestedFields: opportunity.requestedFields,
+        anchors: opportunity.anchors,
+        contextFacts: opportunity.contextFacts,
+        forbiddenMoves: opportunity.forbiddenMoves,
+      } : null,
     }), { abortSignal: AbortSignal.timeout(input.timeoutMs ?? 15_000), structuredOutput: { schema: publicMessageSchema, jsonPromptInjection: "inline" } });
-    const message = enforceServerQuestion(result.object, input.validated.selectedOpportunity?.prompt ?? null);
+    const message = realizePublicMessage(result.object, input);
     recordRectificationAgentTelemetry({ caseId: input.caseValue.id, phase: "renderer", outcome: "succeeded", modelId: selected.id, toolName: null, decisionAction: input.validated.decision.action, durationMs: Date.now() - started, errorCode: null, deploymentSha });
     return message;
   } catch {
diff --git a/frontend/src/lib/rectification-v4/case-service.ts b/frontend/src/lib/rectification-v4/case-service.ts
index 886c63c9..8766a152 100644
--- a/frontend/src/lib/rectification-v4/case-service.ts
+++ b/frontend/src/lib/rectification-v4/case-service.ts
@@ -7,6 +7,7 @@ import type {
 } from "./contracts.ts";
 import { rectificationAgentV5Protocol, rectificationV4AlgorithmVersion, rectificationV4Protocol } from "./contracts.ts";
 import { selectRectificationDeploymentMode } from "../rectification-agent/feature-policy.ts";
+import { CURRENT_RECTIFICATION_PROMPT_VERSION, CURRENT_RECTIFICATION_SKILL_VERSION } from "../rectification-agent/contracts.ts";
 import { calculationSpecHash, evidenceSetHash } from "./fingerprints.ts";
 import { openingQuestion } from "./opening-question.ts";
 import type { RectificationV4Store } from "./store.ts";
@@ -45,8 +46,8 @@ export function createRectificationV4CaseService(store: RectificationV4Store, op
         latestSnapshot: null,
         orchestrationModelId: process.env.RECTIFICATION_ORCHESTRATION_MODEL_ID?.trim() || null,
         narrationModelId: process.env.RECTIFICATION_NARRATION_MODEL_ID?.trim() || null,
-        skillVersion: "birth-time-rectification-v5",
-        promptVersion: "rectification-agent-v5-1",
+        skillVersion: CURRENT_RECTIFICATION_SKILL_VERSION,
+        promptVersion: CURRENT_RECTIFICATION_PROMPT_VERSION,
         algorithmVersion: rectificationV4AlgorithmVersion,
         deploymentMode,
         agentMode: "deterministic_fallback",
diff --git a/frontend/src/lib/rectification-v4/extraction.ts b/frontend/src/lib/rectification-v4/extraction.ts
index e6ecb0c2..c1231b72 100644
--- a/frontend/src/lib/rectification-v4/extraction.ts
+++ b/frontend/src/lib/rectification-v4/extraction.ts
@@ -17,6 +17,25 @@ const allowedKinds = new Set<EventKind>([
   "career_change", "finance_change", "self_health_event", "family_health_event", "family_bereavement", "family_event", "other",
 ]);
 const missingEventSummary = "事件内容待补充";
+const directionChangePattern = /(?:换一个|换个问题|问别的|换个方向|都不符合|不是这个|不聊这个)/;
+const declinedPattern = /(?:不想说|不方便说|不想回答|跳过|这个不说)/;
+const unknownPattern = /(?:不知道|不清楚|记不清|不确定|没印象|忘了|想不起来)/;
+
+export type TargetDisposition =
+  | "resolved"
+  | "unknown"
+  | "declined"
+  | "direction_change"
+  | "answered_other_event"
+  | "unresolved"
+  | "not_applicable";
+
+function explicitDisposition(answer: string): TargetDisposition | null {
+  if (directionChangePattern.test(answer)) return "direction_change";
+  if (declinedPattern.test(answer)) return "declined";
+  if (unknownPattern.test(answer)) return "unknown";
+  return null;
+}
 
 function normalizeKind(domain: EvidenceDomain, value: string, summary: string): EventKind {
   if (allowedKinds.has(value as EventKind)) return value as EventKind;
@@ -100,6 +119,7 @@ export type ReconciledV4Evidence = Readonly<{
   revisions: readonly LifeEventRevision[];
   pending: readonly PendingEvidence[];
   unansweredTargetEventId: string | null;
+  targetDisposition: TargetDisposition;
 }>;
 
 export function reconcileV4Evidence(input: {
@@ -109,13 +129,16 @@ export function reconcileV4Evidence(input: {
   readonly asOfDate: string;
   readonly existing: readonly LifeEventRevision[];
   readonly targetEventId?: string | null;
+  readonly assistedEvidence?: readonly ExtractedLifeEventEvidence[];
   readonly now?: Date;
 }): ReconciledV4Evidence {
-  const extracted = extractLifeEventEvidence({ rawText: input.answer, sourceTurnId: input.sourceTurnId, asOfDate: input.asOfDate });
+  const deterministic = extractLifeEventEvidence({ rawText: input.answer, sourceTurnId: input.sourceTurnId, asOfDate: input.asOfDate });
+  const extracted = [...(input.assistedEvidence ?? []), ...deterministic];
   const target = input.targetEventId ? latestEventRevisions(input.existing).find((event) => event.eventId === input.targetEventId) ?? null : null;
   if (input.targetEventId && !target) throw new Error("rectification_v4_target_event_not_found");
 
   const revisions: LifeEventRevision[] = [];
+  const consumed = new Set<string>();
   let unresolvedReason: PendingEvidence["reasonCode"] | null = null;
   let targetResolved = !target;
 
@@ -140,6 +163,7 @@ export function reconcileV4Evidence(input: {
             dateRange,
             scoreability: target.scoreability,
           }, { id: targetAnswer.id, now: input.now }));
+          consumed.add(targetAnswer.id);
           targetResolved = true;
         }
       }
@@ -147,17 +171,27 @@ export function reconcileV4Evidence(input: {
   }
 
   for (const event of extracted) {
-    if (revisions.some((revision) => revision.id === event.id)) continue;
+    if (consumed.has(event.id) || revisions.some((revision) => revision.id === event.id)) continue;
     const revision = newRevision(event, [...input.existing, ...revisions], input.now);
     if (revision && revision.dateRange.start <= input.asOfDate) {
-      revisions.push(revision);
+      if (!revisions.some((value) => value.eventId === revision.eventId)) revisions.push(revision);
       continue;
     }
     unresolvedReason = event.datePrecision === "unknown" ? "date_unresolved" : "event_unparsed";
   }
 
-  if (extracted.length === 0) unresolvedReason = "event_unparsed";
-  const pending = unresolvedReason ? [
+  const explicit = explicitDisposition(input.answer);
+  const addedOtherEvent = target
+    ? revisions.some((revision) => revision.eventId !== target.eventId)
+    : false;
+  const targetDisposition: TargetDisposition = explicit ?? (!target
+    ? "not_applicable"
+    : targetResolved ? "resolved" : addedOtherEvent ? "answered_other_event" : "unresolved");
+  const suppressPending = targetDisposition === "unknown"
+    || targetDisposition === "declined"
+    || targetDisposition === "direction_change";
+  if (extracted.length === 0 && !suppressPending) unresolvedReason = "event_unparsed";
+  const pending = unresolvedReason && !suppressPending ? [
     pendingEvidence({
       caseId: input.caseId,
       turnId: input.sourceTurnId,
@@ -171,7 +205,8 @@ export function reconcileV4Evidence(input: {
   return {
     revisions,
     pending,
-    unansweredTargetEventId: target && !targetResolved ? target.eventId : null,
+    unansweredTargetEventId: target && (targetDisposition === "unresolved" || targetDisposition === "answered_other_event") ? target.eventId : null,
+    targetDisposition,
   };
 }
 
diff --git a/frontend/supabase/migrations/20260729010000_rectification_agent_v6_versions.sql b/frontend/supabase/migrations/20260729010000_rectification_agent_v6_versions.sql
new file mode 100644
index 00000000..beb9fc6c
--- /dev/null
+++ b/frontend/supabase/migrations/20260729010000_rectification_agent_v6_versions.sql
@@ -0,0 +1,14 @@
+-- New cases use the semantic-question V6 prompt contract by default.
+alter table public.birth_time_rectification_v4_cases
+  alter column skill_version set default 'birth-time-rectification-v6',
+  alter column prompt_version set default 'rectification-agent-v6-1';
+
+-- Advance only unfinished rectification cases to the semantic-question V6 prompt contract.
+-- Historical completed, abandoned, range-ready, and audit artifacts remain immutable.
+update public.birth_time_rectification_v4_cases
+set skill_version = 'birth-time-rectification-v6',
+    prompt_version = 'rectification-agent-v6-1',
+    updated_at = greatest(updated_at, now())
+where status in ('awaiting_answer', 'processing', 'paused')
+  and (skill_version is distinct from 'birth-time-rectification-v6'
+    or prompt_version is distinct from 'rectification-agent-v6-1');
diff --git a/frontend/tests/birth-time-journey-engine.test.ts b/frontend/tests/birth-time-journey-engine.test.ts
index e46e819d..97dd966e 100644
--- a/frontend/tests/birth-time-journey-engine.test.ts
+++ b/frontend/tests/birth-time-journey-engine.test.ts
@@ -19,7 +19,6 @@ test("journey engine serializes only stored event-scoring inputs", () => {
     lat: 31.2304,
     lon: 121.4737,
     tz: 8,
-    high_rigor: true,
     events: [
       { id: "5cb071d6-6d99-46be-85dc-a9bf59ef6ac5", domain: "career", date: "2019-07", precision: "month", summary: "晋升为团队负责人" },
       { id: "0790866c-ad5e-4a45-b2b4-a5c73f6be6ea", domain: "education", date: "2011", precision: "year" },
diff --git a/frontend/tests/conversational-rectification-orchestrator.test.ts b/frontend/tests/conversational-rectification-orchestrator.test.ts
index 1cc3814d..047d5f2f 100644
--- a/frontend/tests/conversational-rectification-orchestrator.test.ts
+++ b/frontend/tests/conversational-rectification-orchestrator.test.ts
@@ -774,10 +774,10 @@ test("uses Agent semantic classification when a single event falls through the d
     caseId: startActionId,
     actionId: answerActionId,
     turnVersion: 0,
-    answer: "2020年4月去石油化工研究院实习做研究员",
+    answer: "2020年4月开始带团队做商业巡演",
   });
 
-  assert.deepEqual(classifiedTexts, ["2020年4月去石油化工研究院实习做研究员"]);
+  assert.deepEqual(classifiedTexts, ["2020年4月开始带团队做商业巡演"]);
   const saved = value.cases.get(startActionId)?.row.eventEvidence.at(-1);
   assert.equal(saved?.dateValue, "2020-04");
   assert.equal(saved?.domain, "career");
diff --git a/frontend/tests/identity-auth-integration.test.ts b/frontend/tests/identity-auth-integration.test.ts
index 50af8fbd..407719be 100644
--- a/frontend/tests/identity-auth-integration.test.ts
+++ b/frontend/tests/identity-auth-integration.test.ts
@@ -346,7 +346,7 @@ test("Better Auth supports user OTP/password flows and password-only admin login
     );
     assert.equal(adminPasswordRoute.status, 401);
   } finally {
-    const globalServices = identityGlobal.jyotishaIdentityAuth;
+    const globalServices = (globalThis as typeof identityGlobal).jyotishaIdentityAuth;
     if (globalServices) {
       await globalServices.pool.end();
       delete identityGlobal.jyotishaIdentityAuth;
diff --git a/frontend/tests/onboarding-route.test.ts b/frontend/tests/onboarding-route.test.ts
index 6e316d9d..aa49a79d 100644
--- a/frontend/tests/onboarding-route.test.ts
+++ b/frontend/tests/onboarding-route.test.ts
@@ -228,7 +228,11 @@ test("profile B replaces profile A active pending claim instead of waiting on A"
   // Given: A has a fresh pending claim, then B changes the active birth time.
   const profile = completeProfileRow();
   const identityA = createOnboardingCacheIdentity({
-    name: profile.name, birthDate: profile.birth_date, birthTime: profile.birth_time,
+    name: profile.name,
+    birthDate: profile.birth_date instanceof Date
+      ? profile.birth_date.toISOString().slice(0, 10)
+      : profile.birth_date,
+    birthTime: profile.birth_time,
     activeBirthTime: profile.active_birth_time, birthTimeStatus: profile.birth_time_status,
     countryCode: profile.country_code, provinceCode: profile.province_code, cityCode: profile.city_code,
   });
diff --git a/frontend/tests/rectification-agent-contracts.test.ts b/frontend/tests/rectification-agent-contracts.test.ts
index c8379eb7..33d9bc2c 100644
--- a/frontend/tests/rectification-agent-contracts.test.ts
+++ b/frontend/tests/rectification-agent-contracts.test.ts
@@ -30,11 +30,17 @@ const diagnostics: DiagnosticsSummary = {
   createdAt: "2026-07-28T00:00:00.000Z",
 };
 const opportunity: QuestionOpportunity = {
+  contractVersion: "semantic-question-v2",
   opportunityId,
   kind: "ask_new_event",
   domain: "career",
   targetEventId: null,
-  prompt: "请补充一个有明确年月的重要事件。",
+  goal: "收集一件有大致日期的职业转折。",
+  requestedFields: ["new_dated_event"],
+  anchors: [],
+  contextFacts: ["职业领域尚未覆盖。"],
+  forbiddenMoves: ["switch_target_event", "ask_multiple_questions", "claim_exact_birth_minute", "invent_event", "invent_date", "expose_private_score", "expose_internal_id", "expose_technique_trace"],
+  fallbackPrompt: "请说一件时间比较明确的职业变化经历。",
   reason: "当前证据领域覆盖不足。",
   expectedInformationGain: 0.8,
   dateSensitivity: 0.5,
diff --git a/frontend/tests/rectification-agent-v5.test.ts b/frontend/tests/rectification-agent-v5.test.ts
index 96b72771..fe91dd29 100644
--- a/frontend/tests/rectification-agent-v5.test.ts
+++ b/frontend/tests/rectification-agent-v5.test.ts
@@ -11,7 +11,7 @@ import {
 import { rectificationCanaryBucket, selectRectificationDeploymentMode } from "../src/lib/rectification-agent/feature-policy.ts";
 import { buildQuestionOpportunities } from "../src/lib/rectification-agent/opportunity-builder.ts";
 import { runBoundedReasoner } from "../src/lib/rectification-agent/reasoner-agent.ts";
-import { enforceServerQuestion } from "../src/lib/rectification-agent/renderer-agent.ts";
+import { realizePublicMessage, validateQuestionRealization } from "../src/lib/rectification-agent/renderer-agent.ts";
 import { createRectificationV4CaseService } from "../src/lib/rectification-v4/case-service.ts";
 import type {
   CalculationSpec,
@@ -82,11 +82,17 @@ const diagnostics: DiagnosticsSummary = diagnosticsSummarySchema.parse({
   createdAt: now,
 });
 const opportunity: QuestionOpportunity = {
+  contractVersion: "semantic-question-v2",
   opportunityId,
   kind: "ask_new_event",
   domain: "career",
   targetEventId: null,
-  prompt: "请补充一次职业变化。",
+  goal: "收集一件有大致日期的职业变化。",
+  requestedFields: ["new_dated_event"],
+  anchors: [],
+  contextFacts: ["职业领域尚未覆盖。"],
+  forbiddenMoves: ["switch_target_event", "ask_multiple_questions", "claim_exact_birth_minute", "invent_event", "invent_date", "expose_private_score", "expose_internal_id", "expose_technique_trace"],
+  fallbackPrompt: "请说一件时间比较明确的职业变化经历。",
   reason: "领域覆盖不足。",
   expectedInformationGain: .8,
   dateSensitivity: .5,
@@ -171,7 +177,7 @@ test("opportunities are ordered only by their published utility", () => {
   assert.deepEqual(values.map((value) => value.utility), [...values].map((value) => value.utility).sort((a, b) => b - a));
 });
 
-test("an unresolved current target exclusively owns the next-question route", () => {
+test("a previously asked unresolved target does not monopolize the next-question route", () => {
   const target = event();
   const values = buildQuestionOpportunities({
     caseId,
@@ -179,9 +185,11 @@ test("an unresolved current target exclusively owns the next-question route", ()
     turns: [],
     snapshot: null,
     diagnostics: null,
+    targetDisposition: "unresolved",
     retryTargetEventIds: [target.eventId],
   });
-  assert.deepEqual(values.map((value) => [value.kind, value.targetEventId]), [["resolve_event_conflict", target.eventId]]);
+  assert.ok(values.length > 0);
+  assert.ok(values.every((value) => value.targetEventId !== target.eventId));
 });
 
 test("reasoner falls back when unavailable", async () => {
@@ -238,18 +246,39 @@ test("reasoner rejects a second diagnostic and enforces the tool budget", async
   assert.equal(exhausted.toolCalls[0]?.outcome, "rejected");
 });
 
-test("renderer cannot replace the server-owned question", () => {
-  assert.deepEqual(enforceServerQuestion({
-    acknowledgement: "已记录。",
+test("renderer rejects an unrelated question and falls back to the semantic contract", () => {
+  const target = event({ summary: "2020年4月研究院实习" });
+  const targeted: QuestionOpportunity = {
+    ...opportunity,
+    kind: "refine_event_date",
+    domain: "career",
+    targetEventId: target.eventId,
+    goal: "细化研究院实习日期。",
+    requestedFields: ["event_day"],
+    anchors: [target.summary],
+    contextFacts: ["日期敏感。"],
+    fallbackPrompt: "关于“2020年4月研究院实习”，你还记得大概哪一天吗？",
+  };
+  assert.equal(validateQuestionRealization("你后来有没有搬家？", targeted).valid, false);
+  const message = realizePublicMessage({
+    acknowledgement: "你提到的是2020年4月研究院实习。",
     candidateUpdate: null,
     limitation: null,
-    question: "模型注入的问题",
-  }, "服务器选定的问题"), {
-    acknowledgement: "已记录。",
-    candidateUpdate: null,
-    limitation: null,
-    question: "服务器选定的问题",
+    question: "你后来有没有搬家？",
+  }, {
+    latestAnswer: "2020年4月研究院实习",
+    acceptedEvents: [target],
+    pendingEvidence: [],
+    snapshot: null,
+    previousSnapshot: null,
+    validated: {
+      decision: { action: "ask_question", opportunityId: targeted.opportunityId, narrativeFocus: [] },
+      mode: "agent",
+      validationIssues: [],
+      selectedOpportunity: targeted,
+    },
   });
+  assert.equal(message.question, targeted.fallbackPrompt);
 });
 
 test("agent-run persistence contract carries deployment, tool, token, and latency facts", () => {
@@ -289,13 +318,15 @@ test("an answer about another event never overwrites the current target and crea
     turns: [],
     snapshot: null,
     diagnostics: null,
+    targetDisposition: reconciled.targetDisposition,
     retryTargetEventIds: [target.eventId],
   });
-  assert.equal(opportunities[0]?.kind, "resolve_event_conflict");
-  assert.equal(opportunities[0]?.targetEventId, target.eventId);
+  const conflict = opportunities.filter((item) => item.kind === "resolve_event_conflict");
+  assert.equal(conflict.length, 1);
+  assert.equal(conflict[0]?.targetEventId, target.eventId);
 });
 
-test("unparsed answers are retained as pending evidence", () => {
+test("unknown target answers are kept in the turn without pending evidence", () => {
   const target = event();
   const turnId = randomUUID();
   const reconciled = reconcileV4Evidence({
@@ -308,9 +339,8 @@ test("unparsed answers are retained as pending evidence", () => {
     now: new Date(now),
   });
   assert.equal(reconciled.revisions.length, 0);
-  assert.equal(reconciled.pending.length, 1);
-  assert.equal(reconciled.pending[0]?.turnId, turnId);
-  assert.equal(reconciled.pending[0]?.targetEventId, target.eventId);
+  assert.equal(reconciled.targetDisposition, "unknown");
+  assert.equal(reconciled.pending.length, 0);
 });
 
 test("shadow mode persists V5 artifacts while preserving the legacy visible reply", async () => {
@@ -344,3 +374,69 @@ test("shadow mode persists V5 artifacts while preserving the legacy visible repl
   assert.equal(shadow.question?.prompt, legacy.question?.prompt);
   assert.equal(shadow.agentRuns, 1);
 });
+
+test("V6 agent conversation follows dated events, respects direction change, and runs the existing V5 engine", async () => {
+  await withV5Mode("v5_agent", async () => {
+    const store = createRectificationV4MemoryStore();
+    const service = createRectificationV4CaseService(store, { now: () => new Date("2026-07-29T00:00:00.000Z") });
+    let scoreCalls = 0;
+    const worker = createRectificationV4Worker({
+      store,
+      now: () => new Date("2026-07-29T00:00:00.000Z"),
+      engine: { score: async ({ calculationSpec, events }) => {
+        scoreCalls += 1;
+        return v5EngineResult(calculationSpec, events);
+      } },
+    });
+    const userId = randomUUID();
+    const created = await service.createCase({ userId, actionId: randomUUID(), calculationSpec: spec });
+
+    async function answer(value: string) {
+      const current = await service.loadCase(userId, created.case.id);
+      assert.ok(current?.case.currentQuestion);
+      const queued = await service.answer({
+        userId,
+        caseId: created.case.id,
+        actionId: randomUUID(),
+        expectedCaseVersion: current.case.version,
+        answer: value,
+      });
+      assert.ok(queued?.job);
+      assert.equal(await worker.runOnce(), true);
+      const loaded = await service.loadCase(userId, created.case.id);
+      assert.ok(loaded);
+      return loaded;
+    }
+
+    const first = await answer("2020 年 4 月去石油化工研究院实习做研究员。");
+    const firstEvent = first.events.find((event) => event.summary.includes("石油化工研究院实习做研究员"));
+    assert.deepEqual(
+      firstEvent && [firstEvent.domain, firstEvent.subject, firstEvent.dateRange.precision, firstEvent.scoreability],
+      ["career", "self", "month", "scoreable"],
+    );
+    assert.doesNotMatch(first.case.currentQuestion?.prompt ?? "", /哪一天|几号|具体日期/);
+    const firstMessage = [...store.publicMessages.values()].at(-1);
+    assert.doesNotMatch(firstMessage?.acknowledgement ?? "", /已记录|我记下了|职业方向正式落地/);
+    assert.match(firstMessage?.acknowledgement ?? "", /研究院实习/);
+
+    const second = await answer("2016 年 9 月离家去外地上大学。");
+    assert.ok(second.events.some((event) => event.domain === "education" && event.dateRange.precision === "month"));
+    assert.doesNotMatch(second.case.currentQuestion?.prompt ?? "", /^请说一次搬家/);
+    assert.ok(!second.case.currentQuestion?.targetEventId || /离家去外地上大学/.test(second.case.currentQuestion.prompt));
+
+    const pendingBefore = store.pendingEvidence.size;
+    const third = await answer("后来有一次搬家，但我记不清时间了，换一个吧。");
+    assert.equal(store.pendingEvidence.size, pendingBefore);
+    assert.equal(third.events.filter((event) => event.domain === "relocation").length, 0);
+    assert.doesNotMatch(third.case.currentQuestion?.prompt ?? "", /搬家.*(?:时间|日期|月份)|(?:时间|日期|月份).*搬家/);
+
+    const fourth = await answer("2023 年 9 月开始负责一家商业巡演经纪公司。");
+    assert.ok(fourth.events.some((event) => event.domain === "career" && event.summary.includes("商业巡演经纪公司")));
+    assert.equal(scoreCalls, 1);
+    assert.ok(store.diagnostics.size > 0);
+    assert.equal(fourth.case.latestSnapshot?.canConfirmExactMinute, false);
+    assert.equal(fourth.case.algorithmVersion, "rectification-v5-matrix-scoring-1");
+    const finalMessage = [...store.publicMessages.values()].at(-1);
+    assert.doesNotMatch(`${finalMessage?.candidateUpdate ?? ""}${finalMessage?.limitation ?? ""}`, /唯一分钟|准确分钟|代表分钟|05:13/);
+  });
+});
diff --git a/frontend/tests/rectification-agent-v6.test.ts b/frontend/tests/rectification-agent-v6.test.ts
new file mode 100644
index 00000000..5c23b277
--- /dev/null
+++ b/frontend/tests/rectification-agent-v6.test.ts
@@ -0,0 +1,246 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import {
+  diagnosticsSummarySchema,
+  normalizeQuestionOpportunity,
+  type DiagnosticsSummary,
+  type QuestionOpportunity,
+  type ValidatedDecision,
+} from "../src/lib/rectification-agent/contracts.ts";
+import { buildQuestionOpportunities } from "../src/lib/rectification-agent/opportunity-builder.ts";
+import { buildReasonerState } from "../src/lib/rectification-agent/reasoner-agent.ts";
+import { candidateUpdateFor, realizePublicMessage, validateQuestionRealization } from "../src/lib/rectification-agent/renderer-agent.ts";
+import { extractLifeEventEvidence, validatedModelAssistedEvidence } from "../src/lib/conversational-rectification/evidence-extractor.ts";
+import type { CandidateSnapshot, LifeEventRevision, PendingEvidence, RectificationV4Turn } from "../src/lib/rectification-v4/contracts.ts";
+import { reconcileV4Evidence } from "../src/lib/rectification-v4/extraction.ts";
+
+const now = "2026-07-29T00:00:00.000Z";
+const caseId = "00000000-0000-4000-8000-000000000601";
+const snapshotId = "00000000-0000-4000-8000-000000000602";
+
+function event(overrides: Partial<LifeEventRevision> = {}): LifeEventRevision {
+  return {
+    id: randomUUID(), eventId: randomUUID(), revision: 1, domain: "education", eventKind: "education_milestone",
+    subject: "self", relatedPerson: null, summary: "2016年大学入学", rawText: "2016年9月离家去外地上大学",
+    dateRange: { start: "2016-09-01", end: "2016-09-30", precision: "month", label: "2016年9月" },
+    scoreability: "scoreable", supersedesRevisionId: null, createdAt: now, ...overrides,
+  };
+}
+
+function turn(overrides: Partial<RectificationV4Turn> = {}): RectificationV4Turn {
+  return {
+    id: randomUUID(), caseId, caseVersion: 1, questionId: randomUUID(), questionDomain: "education",
+    questionTargetEventId: null, question: "请说一件时间比较确定的经历。", answer: "2016年9月离家去外地上大学。",
+    modelId: null, actionId: randomUUID(), createdAt: now, ...overrides,
+  };
+}
+
+function diagnostics(overrides: Partial<DiagnosticsSummary> = {}): DiagnosticsSummary {
+  return diagnosticsSummarySchema.parse({
+    id: randomUUID(), caseId, snapshotId, primaryClusterRetentionRate: .8, leaveOneEventOutRetentionRate: .8,
+    leaveOneDomainOutRetentionRate: .8, dateSensitivityRetentionRate: .8, neighborSupportMinutes: 8,
+    primarySecondaryMarginPercent: 14, clusterMassRatio: .7, unstableEventIds: [], mostDiscriminatingLayers: ["D9"],
+    eventDateSensitivity: [], candidateSplits: [], calculationHash: "d".repeat(64), createdAt: now, ...overrides,
+  });
+}
+
+function snapshot(range: readonly [string, string], overrides: Partial<CandidateSnapshot> = {}): CandidateSnapshot {
+  const [startTime, endTime] = range;
+  return {
+    id: randomUUID(), caseId, caseVersion: 3, evidenceSetHash: "e".repeat(64), calculationSpecHash: "c".repeat(64),
+    algorithmVersion: "rectification-v5-matrix-scoring-1",
+    candidates: [{ time: startTime, score: 10, supportingEventIds: [], conflictingEventIds: [] }],
+    clusters: [{ rank: 1, startTime, endTime, representativeTime: startTime, widthMinutes: 7, peakScore: 10, scoreMass: 1 }],
+    robustness: { neighborSupportMinutes: 8, leaveOneOutRetentionRate: .8, dateSensitivityRetentionRate: .8, calculationSpecHashMatched: true },
+    canConfirmExactMinute: false, canAcceptRange: true, gateReasons: [], createdAt: now, ...overrides,
+  };
+}
+
+function targetOpportunity(target: LifeEventRevision): QuestionOpportunity {
+  return {
+    contractVersion: "semantic-question-v2", opportunityId: randomUUID(), kind: "refine_event_date", domain: target.domain,
+    targetEventId: target.eventId, goal: `细化“${target.summary}”的日期。`, requestedFields: ["event_day"], anchors: [target.summary],
+    contextFacts: ["日期敏感性较高。"],
+    forbiddenMoves: ["switch_target_event", "ask_multiple_questions", "claim_exact_birth_minute", "invent_event", "invent_date", "expose_private_score", "expose_internal_id", "expose_technique_trace"],
+    fallbackPrompt: `关于“${target.summary}”，你还记得大概哪一天吗？`, reason: "日期敏感性诊断显示该事件可能改变候选排序。",
+    expectedInformationGain: .8, dateSensitivity: .8, candidateSplitRelevance: .5, domainCoverageGain: 0,
+    recallEase: .6, novelty: .8, repetitionPenalty: 0, privacyCost: .05, utility: .7, active: true,
+  };
+}
+
+function validated(opportunity: QuestionOpportunity): ValidatedDecision {
+  return {
+    decision: { action: "ask_question", opportunityId: opportunity.opportunityId, narrativeFocus: ["latest_event"] },
+    mode: "agent", validationIssues: [], selectedOpportunity: opportunity,
+  };
+}
+
+test("研究院实习被确定性提取为 career/self/month/scoreable", () => {
+  const [result] = extractLifeEventEvidence({ rawText: "2020 年 4 月去石油化工研究院实习做研究员。", sourceTurnId: randomUUID(), asOfDate: "2026-07-29" });
+  assert.ok(result);
+  assert.equal(result.domain, "career");
+  assert.equal(result.eventKind, "career_change");
+  assert.equal(result.subject, "self");
+  assert.equal(result.datePrecision, "month");
+  assert.equal(result.dateValue, "2020-04");
+  assert.equal(result.scoreability, "scoreable");
+  assert.equal(result.scoreable, true);
+});
+
+test("month 默认不细化，只有 retention 低于 .65 时才允许细化", () => {
+  const internship = event({ domain: "career", eventKind: "career_change", summary: "去石油化工研究院实习做研究员", rawText: "2020年4月去石油化工研究院实习做研究员", dateRange: { start: "2020-04-01", end: "2020-04-30", precision: "month", label: "2020年4月" } });
+  const coveredEvents = [
+    internship,
+    event({ domain: "education", eventKind: "education_milestone" }),
+    event({ domain: "relocation", eventKind: "relocation" }),
+    event({ domain: "relationship", eventKind: "relationship_change", relatedPerson: "partner" }),
+    event({ domain: "finance", eventKind: "finance_change" }),
+    event({ domain: "health_pressure", eventKind: "self_health_event" }),
+  ];
+  const build = (summary: DiagnosticsSummary | null) => buildQuestionOpportunities({ caseId, events: coveredEvents, turns: [], snapshot: null, diagnostics: summary });
+  assert.equal(build(null).some((item) => item.kind === "refine_event_date"), false);
+  const sensitivity = (winnerRetentionRate: number, candidateClusterRetentionRate: number) => diagnostics({
+    eventDateSensitivity: [{ eventId: internship.eventId, declaredDateRange: { start: "2020-04-01", end: "2020-04-30", precision: "month" }, sampleDates: ["2020-04-01", "2020-04-30"], winnerRetentionRate, scoreVariance: 1, candidateClusterRetentionRate }],
+  });
+  const sensitiveOpportunities = build(sensitivity(.64, .1));
+  assert.equal(sensitiveOpportunities.some((item) => item.kind === "refine_event_date" && item.targetEventId === internship.eventId), true);
+  assert.doesNotMatch(sensitiveOpportunities.find((item) => item.kind === "refine_event_date")!.fallbackPrompt, /敏感性|排序|保持率|score/i);
+  assert.equal(build(sensitivity(.65, .65)).some((item) => item.kind === "refine_event_date"), false);
+});
+
+test("不知道或换方向不产生 pending，也不再生成同 target 机会", () => {
+  const target = event({ dateRange: { start: "2016-01-01", end: "2016-12-31", precision: "year", label: "2016年" } });
+  const answer = "记不清了，换一个吧。";
+  const result = reconcileV4Evidence({ caseId, answer, sourceTurnId: randomUUID(), asOfDate: "2026-07-29", existing: [target], targetEventId: target.eventId });
+  assert.equal(result.targetDisposition, "direction_change");
+  assert.deepEqual(result.pending, []);
+  const opportunities = buildQuestionOpportunities({ caseId, events: [target], turns: [turn({ questionTargetEventId: target.eventId, answer })], snapshot: null, diagnostics: null, targetDisposition: result.targetDisposition, retryTargetEventIds: [target.eventId] });
+  assert.equal(opportunities.some((item) => item.targetEventId === target.eventId), false);
+  assert.ok(opportunities.some((item) => item.kind === "ask_new_event"));
+});
+
+test("无 target 的换方向表达也不会被记为 event_unparsed", () => {
+  const result = reconcileV4Evidence({ caseId, answer: "后来有一次搬家，但我记不清时间了，换一个吧。", sourceTurnId: randomUUID(), asOfDate: "2026-07-29", existing: [] });
+  assert.equal(result.targetDisposition, "direction_change");
+  assert.deepEqual(result.pending, []);
+  assert.equal(result.revisions.some((item) => item.scoreability === "scoreable"), false);
+});
+
+test("回答新 relocation 不覆盖 education target，原目标最多补问一次", () => {
+  const target = event({ dateRange: { start: "2016-01-01", end: "2016-12-31", precision: "year", label: "2016年" } });
+  const answer = "2018 年 8 月搬到北京。";
+  const assisted = validatedModelAssistedEvidence({
+    rawText: answer,
+    sourceTurnId: randomUUID(),
+    asOfDate: "2026-07-29",
+    extraction: { sourceSpan: "2018 年 8 月搬到北京", summary: "搬到北京", domain: "relocation", eventKind: "relocation", subject: "self", relatedPerson: null, dateText: "2018 年 8 月" },
+  });
+  assert.ok(assisted);
+  const result = reconcileV4Evidence({ caseId, answer, sourceTurnId: randomUUID(), asOfDate: "2026-07-29", existing: [target], targetEventId: target.eventId, assistedEvidence: [assisted] });
+  assert.equal(result.targetDisposition, "answered_other_event");
+  const relocation = result.revisions.find((item) => item.domain === "relocation");
+  assert.ok(relocation);
+  assert.notEqual(relocation.eventId, target.eventId);
+  assert.equal(result.revisions.some((item) => item.eventId === target.eventId), false);
+  const firstTurns = [turn({ questionTargetEventId: target.eventId, answer: "2018 年 8 月搬到北京。" })];
+  const first = buildQuestionOpportunities({ caseId, events: [target, relocation], turns: firstTurns, snapshot: null, diagnostics: null, targetDisposition: "answered_other_event", retryTargetEventIds: [target.eventId] });
+  assert.equal(first.filter((item) => item.kind === "resolve_event_conflict" && item.targetEventId === target.eventId).length, 1);
+  const second = buildQuestionOpportunities({ caseId, events: [target, relocation], turns: [...firstTurns, turn({ questionTargetEventId: target.eventId, answer: "2020年又搬到上海。" })], snapshot: null, diagnostics: null, targetDisposition: "answered_other_event", retryTargetEventIds: [target.eventId] });
+  assert.equal(second.some((item) => item.kind === "resolve_event_conflict" && item.targetEventId === target.eventId), false);
+});
+
+test("Renderer 对切换目标、多问题、出生分钟和内部信息统一回落锚定 fallback", () => {
+  const target = event({ summary: "2020年4月研究院实习" });
+  const opportunity = targetOpportunity(target);
+  const input = { latestAnswer: target.rawText, acceptedEvents: [target], pendingEvidence: [] as PendingEvidence[], snapshot: null, previousSnapshot: null, validated: validated(opportunity) };
+  const invalidQuestions = [
+    "你后来有没有搬家？",
+    "关于2020年4月研究院实习，你还记得具体月份吗？另外后来有没有换工作？",
+    "关于2020年4月研究院实习，你是不是05:13出生？",
+    "关于2020年4月研究院实习，opportunityId 是什么？",
+    "关于2020年4月研究院实习，snapshotId 是什么？",
+    "关于2020年4月研究院实习，请告诉我 score。",
+    "关于2020年4月研究院实习，D9 显示什么？",
+    "关于2020年4月研究院实习，tool call 返回什么？",
+  ];
+  for (const question of invalidQuestions) {
+    assert.equal(validateQuestionRealization(question, opportunity).valid, false, question);
+    const message = realizePublicMessage({ acknowledgement: `你提到的是“${target.summary}”。`, candidateUpdate: null, limitation: null, question }, input);
+    assert.equal(message.question, opportunity.fallbackPrompt, question);
+  }
+});
+
+test("稳定候选范围相同不重复提示，实际变化才提示且不确认唯一分钟", () => {
+  const previous = snapshot(["05:00", "05:30"]);
+  const same = snapshot(["05:00", "05:30"]);
+  const changed = snapshot(["05:12", "05:18"]);
+  assert.equal(candidateUpdateFor({ snapshot: same, previousSnapshot: previous, decisionAction: "ask_question" }), null);
+  const update = candidateUpdateFor({ snapshot: changed, previousSnapshot: previous, decisionAction: "ask_question" });
+  assert.ok(update);
+  assert.match(update, /05:12.*05:18/);
+  assert.doesNotMatch(update, /唯一|确认.*分钟|代表分钟/);
+  assert.equal(changed.canConfirmExactMinute, false);
+});
+
+test("Builder 的领域排序不受事件输入数组顺序影响", () => {
+  const education = event();
+  const career = event({ domain: "career", eventKind: "career_change", summary: "2023年开始负责商业巡演经纪公司", rawText: "2023年9月开始负责一家商业巡演经纪公司", dateRange: { start: "2023-09-01", end: "2023-09-30", precision: "month", label: "2023年9月" } });
+  const domains = (events: readonly LifeEventRevision[]) => buildQuestionOpportunities({ caseId, events, turns: [], snapshot: null, diagnostics: null }).map((item) => [item.kind, item.domain, item.utility]);
+  assert.deepEqual(domains([education, career]), domains([career, education]));
+});
+
+test("Reasoner 状态包含最近语义上下文但不包含贡献矩阵", () => {
+  const latestEvent = event();
+  const opportunity = targetOpportunity(latestEvent);
+  const recentTurns = Array.from({ length: 7 }, (_, index) => turn({ answer: `回答${index}` }));
+  const pending: PendingEvidence = { id: randomUUID(), caseId, turnId: recentTurns.at(-1)!.id, rawText: "后来去了北京", reasonCode: "date_unresolved", targetEventId: null, resolvedEventId: null, createdAt: now, resolvedAt: null };
+  const state = buildReasonerState({ snapshot: snapshot(["05:12", "05:18"]), diagnostics: diagnostics(), opportunities: [opportunity], recentTurns, recentEvents: [latestEvent], currentTarget: latestEvent, targetDisposition: "unresolved", pendingEvidence: [pending], candidateRangeChanged: true });
+  assert.equal(state.latestAnswer, "回答6");
+  assert.equal(state.recentTurns.length, 6);
+  assert.equal(state.recentEvents[0]?.summary, latestEvent.summary);
+  assert.equal(state.targetDisposition, "unresolved");
+  assert.equal(state.opportunities[0]?.goal, opportunity.goal);
+  assert.equal(state.pendingEvidence.count, 1);
+  assert.doesNotMatch(JSON.stringify(state), /contribution(?:Matrix| matrix|_matrix)?/i);
+});
+
+test("模型辅助提取拒绝发明日期，接受原文连续日期并可进入 Event Ledger", () => {
+  const invented = validatedModelAssistedEvidence({
+    rawText: "大学毕业后去了北京。", sourceTurnId: randomUUID(), asOfDate: "2026-07-29",
+    extraction: { sourceSpan: "大学毕业后去了北京", summary: "大学毕业后去了北京", domain: "relocation", eventKind: "relocation", subject: "self", relatedPerson: null, dateText: "2020年7月" },
+  });
+  assert.equal(invented, null);
+  const normalizedButNotLiteral = validatedModelAssistedEvidence({
+    rawText: "２０２２年１１月把生活重心挪到了成都。", sourceTurnId: randomUUID(), asOfDate: "2026-07-29",
+    extraction: { sourceSpan: "2022年11月把生活重心挪到了成都", summary: "把生活重心挪到了成都", domain: "relocation", eventKind: "relocation", subject: "self", relatedPerson: null, dateText: "2022年11月" },
+  });
+  assert.equal(normalizedButNotLiteral, null);
+  const rawText = "2022年11月把生活重心挪到了成都。";
+  const assisted = validatedModelAssistedEvidence({
+    rawText, sourceTurnId: randomUUID(), asOfDate: "2026-07-29",
+    extraction: { sourceSpan: "2022年11月把生活重心挪到了成都", summary: "把生活重心挪到了成都", domain: "relocation", eventKind: "relocation", subject: "self", relatedPerson: null, dateText: "2022年11月" },
+  });
+  assert.ok(assisted);
+  assert.equal(assisted.dateValue, "2022-11");
+  const reconciled = reconcileV4Evidence({ caseId, answer: rawText, sourceTurnId: randomUUID(), asOfDate: "2026-07-29", existing: [], assistedEvidence: [assisted] });
+  assert.ok(reconciled.revisions.some((item) => item.domain === "relocation" && item.scoreability === "scoreable"));
+});
+
+test("旧 prompt Opportunity 归一化为 semantic-question-v2", () => {
+  const legacyPrompt = "请说一件时间比较明确的经历。";
+  const normalized = normalizeQuestionOpportunity({ prompt: legacyPrompt, domain: "career", reason: "历史记录" });
+  assert.equal(normalized.contractVersion, "semantic-question-v2");
+  assert.equal(normalized.fallbackPrompt, legacyPrompt);
+  assert.equal(normalized.domain, "career");
+  assert.ok(normalized.opportunityId);
+});
+
+test("V6 迁移只更新未完成 Case 版本且不写 active_birth_time", () => {
+  const migration = readFileSync(new URL("../supabase/migrations/20260729010000_rectification_agent_v6_versions.sql", import.meta.url), "utf8");
+  assert.match(migration, /alter column skill_version set default 'birth-time-rectification-v6'/);
+  assert.match(migration, /alter column prompt_version set default 'rectification-agent-v6-1'/);
+  assert.match(migration, /where status in \('awaiting_answer', 'processing', 'paused'\)/);
+  assert.doesNotMatch(migration, /profiles\s*\.\s*active_birth_time|active_birth_time/i);
+});
diff --git a/frontend/tests/rectification-v4-domain.test.ts b/frontend/tests/rectification-v4-domain.test.ts
index ee33c936..9e3b6770 100644
--- a/frontend/tests/rectification-v4-domain.test.ts
+++ b/frontend/tests/rectification-v4-domain.test.ts
@@ -97,8 +97,8 @@ test("Opportunity Builder prioritizes event-local date refinement and never asks
   const local = opportunities.find((item) => item.kind === "refine_event_date");
   assert.equal(local?.targetEventId, event.eventId);
   assert.equal(local?.domain, "education");
-  assert.match(local?.prompt ?? "", /离家去外地上大学/);
-  assert.match(local?.prompt ?? "", /月份或日期/);
+  assert.match(local?.fallbackPrompt ?? "", /离家去外地上大学/);
+  assert.match(local?.fallbackPrompt ?? "", /哪个月|时间段/);
   assert.ok(opportunities.every((item, index) => index === 0 || opportunities[index - 1]!.utility >= item.utility));
   assert.ok(opportunities.every((item) => item.domain !== "family"));
 });
diff --git a/frontend/tests/rectification-v4-replay.test.ts b/frontend/tests/rectification-v4-replay.test.ts
index 5081ffbb..f7fdcebe 100644
--- a/frontend/tests/rectification-v4-replay.test.ts
+++ b/frontend/tests/rectification-v4-replay.test.ts
@@ -73,32 +73,7 @@ test("V5 golden replay persists the full artifact chain, returns ranges only, an
     ["2015-07-01", "2015-07-31"],
     ["2016-06-01", "2016-06-30"],
   ]);
-  const firstTarget = loaded.case.currentQuestion?.targetEventId;
-  assert.ok(firstTarget);
-  const firstTargetEvent = loaded.events.find((event) => event.eventId === firstTarget);
-  assert.ok(firstTargetEvent);
-  loaded = await answerAndRun(
-    service,
-    worker,
-    userId,
-    created.case.id,
-    loaded.case.version,
-    firstTargetEvent.dateRange.start.startsWith("2015-") ? "2015年7月18日" : "2016年6月22日",
-  );
-  const secondTarget = loaded.case.currentQuestion?.targetEventId;
-  assert.ok(secondTarget);
-  assert.notEqual(secondTarget, firstTarget);
-  const secondTargetEvent = loaded.events.find((event) => event.eventId === secondTarget);
-  assert.ok(secondTargetEvent);
-  loaded = await answerAndRun(
-    service,
-    worker,
-    userId,
-    created.case.id,
-    loaded.case.version,
-    secondTargetEvent.dateRange.start.startsWith("2015-") ? "2015年7月18日" : "2016年6月22日",
-  );
-  assert.equal(loaded.case.currentQuestion?.domain, "relocation");
+  assert.equal(loaded.case.currentQuestion?.targetEventId, null, "month precision should move to a new dated event");
   loaded = await answerAndRun(
     service,
     worker,
@@ -119,9 +94,9 @@ test("V5 golden replay persists the full artifact chain, returns ranges only, an
   assert.ok(loaded.case.latestDiagnosticsId);
   assert.equal(store.featureSnapshots.size, 1);
   assert.equal(store.diagnostics.size, 1);
-  assert.equal(store.agentRuns.size, 4);
-  assert.equal(store.publicMessages.size, 4);
-  assert.equal(store.validatedDecisions.size, 4);
+  assert.equal(store.agentRuns.size, 2);
+  assert.equal(store.publicMessages.size, 2);
+  assert.equal(store.validatedDecisions.size, 2);
   const finalRun = [...store.agentRuns.values()].at(-1);
   assert.equal(finalRun?.validatedDecision.decision.action, "offer_candidate_range");
   assert.equal(finalRun?.inputTokenCount, null);
diff --git a/frontend/tests/rectification-v4-service.test.ts b/frontend/tests/rectification-v4-service.test.ts
index 4d0c202b..c8adb6fb 100644
--- a/frontend/tests/rectification-v4-service.test.ts
+++ b/frontend/tests/rectification-v4-service.test.ts
@@ -93,9 +93,11 @@ test("V5 agent fallback persists Agent Run, Public Message and a server-owned op
   assert.ok(event && run && message);
   assert.equal(run.deploymentMode, "v5_agent");
   assert.equal(run.validatedDecision.mode, "deterministic_fallback");
-  assert.equal(run.validatedDecision.selectedOpportunity?.targetEventId, event.eventId);
-  assert.equal(done?.case.currentQuestion?.targetEventId, event.eventId);
+  assert.equal(run.validatedDecision.selectedOpportunity?.kind, "ask_new_event");
+  assert.equal(run.validatedDecision.selectedOpportunity?.targetEventId, null);
+  assert.equal(done?.case.currentQuestion?.targetEventId, null);
   assert.match(done?.case.currentQuestion?.prompt ?? "", /离家去外地上大学/);
+  assert.doesNotMatch(done?.case.currentQuestion?.prompt ?? "", /具体哪一天|几号/);
   assert.equal(message.question, done?.case.currentQuestion?.prompt);
   assert.equal(done?.case.latestSnapshot, null);
 }));
@@ -119,7 +121,8 @@ test("V5 shadow runs and persists V5 artifacts but keeps the legacy visible proj
   const run = [...store.agentRuns.values()][0];
   assert.ok(queued?.job && event && run);
   assert.equal(run.deploymentMode, "v5_shadow");
-  assert.equal(run.validatedDecision.selectedOpportunity?.targetEventId, event.eventId);
+  assert.equal(run.validatedDecision.selectedOpportunity?.kind, "ask_new_event");
+  assert.equal(run.validatedDecision.selectedOpportunity?.targetEventId, null);
   assert.equal(done.case.currentQuestion?.targetEventId, event.eventId);
   assert.match(done.case.currentQuestion?.reason ?? "", /V4 legacy projector/);
   assert.match(store.publicMessages.get(queued.job.id)?.acknowledgement ?? "", /我记下了/);
diff --git a/skills/birth-time-rectification/SKILL.md b/skills/birth-time-rectification/SKILL.md
index 68b08205..ff626c1b 100644
--- a/skills/birth-time-rectification/SKILL.md
+++ b/skills/birth-time-rectification/SKILL.md
@@ -1,36 +1,63 @@
 ---
 name: birth-time-rectification
-description: Evidence-led birth-time rectification for the Web agent. Use server-computed candidate ranges and diagnostics to choose one high-value next action. Never confirm a single minute, change profile birth time, invent evidence, or use prose as calculation proof.
+description: Natural, evidence-led birth-time rectification for the Web agent. Select one server-owned semantic question opportunity at a time; never create candidate results, confirm a unique minute, change profile birth time, invent evidence, or expose private scoring and technique traces.
 ---
 
 # Birth-time rectification
 
-This is a constrained evidence workflow, not a generic astrology reading.
+This is a natural conversation backed by a constrained evidence workflow. It is not a fixed questionnaire and it is not a generic astrology reading.
 
-Before choosing an action, read the contracts in `references/` and use
-`assets/rectification-capability-matrix.json` only as a capability boundary.
+Before choosing an action, read the contracts in `references/`. Treat `assets/rectification-capability-matrix.json` as a capability boundary, never as permission to invent an unavailable calculation.
 
-## Hard boundaries
+## Product boundary
 
-- The server owns candidate scanning, scores, diagnostics, event IDs, and policy gates.
-- The agent may select one server-provided opportunity or request one server-provided diagnostic.
-- Never invent candidate times, scores, event IDs, dates, techniques, or tool inputs.
-- Never confirm a single minute or write `profiles.active_birth_time`.
-- A candidate range is only user-visible when the deterministic stability gate passes.
-- Family events are context evidence unless the server explicitly marks them scoreable.
+- Current skill version: `birth-time-rectification-v6`.
+- Current prompt version: `rectification-agent-v6-1`.
+- The scoring algorithm remains `rectification-v5-matrix-scoring-1`; the V6 label describes the conversation contract, not a replacement scoring engine.
+- The server owns event reconciliation, candidate-minute scanning, event contributions, snapshots, diagnostics, stability gates, jobs, replay, persistence, and final decision validation.
+- The agent may select one active server opportunity, call at most one allowed read-only diagnostic, offer an already-gated candidate range, or stop for low confidence.
+- The agent never creates events, dates, scores, candidate minutes, or profile updates.
+- `canConfirmExactMinute` is always `false`. Never write `profiles.active_birth_time` automatically.
+
+## Seventeen conversation boundaries
+
+1. Conduct a natural conversation, never a fixed questionnaire.
+2. Ask at most one question in an ordinary turn.
+3. Do not rotate through domains in a fixed order.
+4. Month precision is sufficient by default.
+5. Ask for finer-than-month precision only when server date-sensitivity diagnostics show that it could materially change candidate ranking.
+6. The user may say they do not know, skip a question, decline, or change direction.
+7. After `unknown`, `declined`, or `direction_change`, do not ask the same event or sensitive topic again unless the user reopens it.
+8. Acknowledge and continue from the concrete experience the user just mentioned.
+9. Do not use empty stock phrases such as “这个信息很有用” or repetitive “已记录” openings.
+10. Do not assign life meaning to an ordinary experience or claim an unconfirmed turning point.
+11. The agent selects a server-generated semantic opportunity; it does not create candidate results or an unrestricted question route.
+12. Show a candidate range only after the deterministic stability gate passes.
+13. Never confirm, imply, or display a unique or representative birth minute as the answer.
+14. Stop with an honest low-confidence result when evidence is sparse, conflicting, or unstable; do not prolong the interview indefinitely.
+15. Family events are background/context evidence by default, not the user's own scoreable event.
+16. D60 is reference-only and must not drive a conclusion.
+17. Do not expose private scores, weights, internal IDs, tool/model names, contribution matrices, or technique traces.
 
 ## Turn strategy
 
-1. Acknowledge the concrete experience the user just supplied.
-2. Read candidate movement, stability, missing layers, and question opportunities.
-3. Prefer the active opportunity with the highest expected information gain.
-4. Ask one natural question only.
-5. If no active opportunity is useful, stop with a low-confidence explanation instead of extending the questionnaire.
+1. Reconcile the latest answer and preserve its original wording and stated date precision.
+2. Respect the current target disposition before generating a follow-up.
+3. Review up to five active semantic opportunities built from evidence coverage, candidate split, date sensitivity, recent topics, novelty, recall ease, repetition, and privacy cost.
+4. Select one useful opportunity and realize one short, anchored question. If none is useful, stop at low confidence.
+5. Mention a candidate range only when it is newly displayable or materially changed; never repeat an unchanged range.
 
-## Layer priority
+A user who answers with a different complete event may have that event saved without overwriting the old target. The old target may receive at most one gentle clarification; repeated diversion closes it and moves the conversation on.
 
-Use the server's available layers only. Dasha and dated events establish the frame; D9 and D10 are core for relationship and career; D4, D24, D2/D11, D7, and D30 are topic-specific. D60 is reference-only and must never drive a conclusion.
+## Date and privacy policy
+
+- `day`: never request finer precision.
+- `month`: normally complete; do not ask for a day merely because a day is absent.
+- `quarter`: a month may be requested.
+- `year`: a month or approximate range may be requested.
+- `range`: refine only when the range is broad and diagnostics show ranking impact.
+- Health, bereavement, family illness, and relationship questions have higher privacy cost. Once declined in a Case, do not proactively ask that sensitive category again unless the user raises it.
 
 ## Public language
 
-Explain whether the latest evidence moved or supported the current candidate range. Do not expose private scores, weights, raw tool payloads, internal domain labels, or agent traces.
+Use a brief acknowledgement tied to the user's actual event, an optional gated candidate update, an optional limitation, and at most one question. Do not repeat an unchanged range, over-interpret the event, or turn sparse/conflicting evidence into certainty.
diff --git a/skills/birth-time-rectification/references/event-schema.md b/skills/birth-time-rectification/references/event-schema.md
index bdb6038a..7cf1f139 100644
--- a/skills/birth-time-rectification/references/event-schema.md
+++ b/skills/birth-time-rectification/references/event-schema.md
@@ -1,3 +1,29 @@
 # Event schema
 
-Keep event subject, related person, event kind, date precision, extraction status, correction lineage, and scoreability. A family bereavement is a family context event, not the user's health event.
+Preserve the event's subject, related person, domain, event kind, original user wording, declared date text, normalized date range, precision, extraction status, correction lineage, source Turn, and scoreability.
+
+## Subject and scoreability
+
+- A user's own supported event may be `scoreable`.
+- A partner relationship event is scoreable only when the server policy explicitly permits it.
+- Family events, bereavement, illness of relatives, and other third-party events are `context_only` by default.
+- Do not classify a family health or death event as the user's own health event.
+- A newly supplied event must not overwrite the event currently being clarified.
+
+## Date precision
+
+Keep `day`, `month`, `quarter`, `year`, `range`, and unresolved precision honestly. Never invent a day to complete a month, or a month/year from common sense. Month precision is sufficient by default; finer detail requires a server date-sensitivity reason.
+
+Relative phrases such as “后来”, “第二年”, or “那时候” may be resolved only by the existing server context-date parser. If that parser cannot resolve them reliably, keep the evidence pending or contextual rather than guessing.
+
+## Extraction boundary
+
+Run deterministic extraction first. Model assistance is allowed only for deterministic `event_unparsed`, `pending_review`, or unsupported results. Its output is limited to a source span, summary, domain, event kind, subject, related person, and date text.
+
+- `sourceSpan` and `dateText` must be continuous substrings of the user's answer.
+- The model cannot provide normalized start/end dates.
+- Server date parsing and schema validation remain authoritative.
+- Invalid, timed-out, or invented model output is rejected and the deterministic pending result remains.
+- The extraction agent receives no candidate ranges, scores, database write access, or profile mutation authority.
+
+The raw answer remains in the Turn even when the user skips, declines, changes direction, or the event cannot be scored.
diff --git a/skills/birth-time-rectification/references/failure-policy.md b/skills/birth-time-rectification/references/failure-policy.md
index e14b46af..f376fd7a 100644
--- a/skills/birth-time-rectification/references/failure-policy.md
+++ b/skills/birth-time-rectification/references/failure-policy.md
@@ -1,3 +1,21 @@
 # Failure policy
 
-On invalid model output, unavailable tools, or a failed policy gate, use the deterministic fallback and record the failure. Do not fabricate a next question or candidate result.
+## Conversation failures
+
+- Invalid Reasoner output, an unavailable model, or exhausted diagnostic budget uses the deterministic server policy.
+- Invalid Renderer output uses the selected opportunity's validated `fallbackPrompt`.
+- A failed or unavailable model-assisted event extraction leaves deterministic extraction and pending evidence intact; it must not fabricate an event or date.
+- `unknown`, `declined`, and `direction_change` are valid conversation outcomes, not parsing failures and not life events.
+- After a refusal or direction change, close the target and do not repeat it.
+
+## Evidence failures
+
+Stop with low confidence when evidence is too sparse, conflicting, tied, unstable, privacy-costly, or unlikely to add information. Do not turn an internal Snapshot into a public range before its gate passes. Do not keep asking merely to fill a domain checklist.
+
+A month-dated event is not a failure. Refine it only when date-sensitivity diagnostics show that finer precision could change candidate ranking.
+
+## System failures
+
+Preserve the existing Job and persistence guarantees: claim/lease, idempotency, completed-job replay, and atomic completion. A renderer or extraction failure must not cause partial artifact writes, duplicate completion, profile mutation, or a different replay result.
+
+Never log raw sensitive answers to ordinary telemetry. Persist user text only in the approved Turn/evidence stores required by the product contract.
diff --git a/skills/birth-time-rectification/references/output-contract.md b/skills/birth-time-rectification/references/output-contract.md
index 95e57758..6d682629 100644
--- a/skills/birth-time-rectification/references/output-contract.md
+++ b/skills/birth-time-rectification/references/output-contract.md
@@ -1,3 +1,44 @@
 # Output contract
 
-Public output contains an acknowledgement, a concise calculation update grounded in the packet, and at most one question. It never contains a single-minute conclusion or private scores.
+Public output keeps the existing shape:
+
+```ts
+{
+  acknowledgement: string;
+  candidateUpdate: string | null;
+  limitation: string | null;
+  question: string | null;
+}
+```
+
+## Acknowledgement
+
+Use at most one or two short sentences and refer to the user's concrete experience. Do not repeatedly begin with “已记录” or “我记下了”. Do not use “这个信息很有用”, “它不是单纯的……”, “而是把……”, “接下来最有价值的是……”, or “这样可以避免……”. Do not interpret an ordinary event as a confirmed life turning point.
+
+## Question
+
+When a validated opportunity is selected, `question` is required; otherwise it is `null`. The question must:
+
+- be 8-180 characters, at most two sentences, and contain at most one question mark;
+- ask one thing only and match the opportunity's requested fields;
+- include a valid anchor when `targetEventId` is present;
+- ask self/family/partner only for `event_subject`;
+- ask month, approximate month, or range for `event_month`;
+- ask start, peak, end, or formal stage for `event_stage`;
+- ask for one new roughly dated event for `new_dated_event`;
+- contain no internal ID/field, score, snapshot, opportunity, tool call, model name, technique trace such as `D9`/`D60`, or unapproved `HH:MM` birth time.
+
+Reject multi-question transitions such as “另外”, “还有”, “同时再说”, or “并且告诉我” when they introduce another request. On validation failure, use the selected opportunity's short, anchored `fallbackPrompt`.
+
+## Candidate update
+
+`candidateUpdate` is allowed only when the current range has passed every public gate and one of these is true:
+
+1. it differs materially from the previous Snapshot's primary range; or
+2. it is the first Snapshot to pass the public stability gate.
+
+The no-repeat rule takes precedence: it must be `null` for an unchanged range, insufficient event/domain coverage, an internal unstable Snapshot, or a repeated equivalent calculation. Never state or imply a unique or representative birth minute.
+
+## Deterministic fallback
+
+Fallback follows the same public rules as model output: acknowledge the actual event naturally, ask one anchored question, avoid repetition and over-interpretation, and never claim exact-minute certainty.
diff --git a/skills/birth-time-rectification/references/product-contract.md b/skills/birth-time-rectification/references/product-contract.md
index 32041ad4..b9991d3f 100644
--- a/skills/birth-time-rectification/references/product-contract.md
+++ b/skills/birth-time-rectification/references/product-contract.md
@@ -1,3 +1,29 @@
 # Product contract
 
-The product returns a candidate range, not a verified birth minute. Existing profile birth time remains unchanged until the user explicitly saves an allowed candidate range through the product flow.
+## Version and ownership
+
+- Skill: `birth-time-rectification-v6`.
+- Prompt: `rectification-agent-v6-1`.
+- Algorithm: `rectification-v5-matrix-scoring-1` remains unchanged.
+- V6 changes the conversation and semantic-question contracts; it does not replace the V5 candidate engine.
+- The server owns candidate-minute scanning, the event contribution matrix, Candidate Snapshots, diagnostics, stability gates, Decision Validator, deterministic fallback, Jobs, claim/lease, completed-job replay, atomic completion, idempotency, and persistence.
+- Preserve `v4_legacy`, `v5_shadow`, and `v5_agent` deployment behavior. Shadow artifacts must not change the legacy visible reply.
+
+## Result boundary
+
+The product can return a candidate time range only after deterministic minimum-event, minimum-domain, and stability gates pass. An internal or unstable Snapshot is not a public result. A repeated calculation of the same primary range is not a new update.
+
+`canConfirmExactMinute` is always `false`. The product must not present a unique minute or representative minute as the user's true birth time, and rectification completion must not automatically write `profiles.active_birth_time`.
+
+When evidence is sparse, conflicting, tied, date-sensitive, or unstable, stop or continue with one genuinely useful question. Never package uncertainty as certainty or extend the interview without a useful active opportunity.
+
+## Agent authority
+
+The agent may only:
+
+1. select one active server-generated semantic question opportunity;
+2. call at most one permitted read-only diagnostic;
+3. offer a server-generated candidate range that has passed the public gate; or
+4. stop with low confidence.
+
+The agent must not create or alter events, normalized dates, candidate minutes, scores, diagnostic results, or profile birth data.
diff --git a/skills/birth-time-rectification/references/question-policy.md b/skills/birth-time-rectification/references/question-policy.md
index fa92f57a..b09f4fdc 100644
--- a/skills/birth-time-rectification/references/question-policy.md
+++ b/skills/birth-time-rectification/references/question-policy.md
@@ -1,3 +1,44 @@
 # Question policy
 
-Choose one active server opportunity. Prefer date sensitivity, candidate-split relevance, and new domain coverage over recency or fixed domain order. Do not repeat a resolved follow-up.
+## Semantic opportunities
+
+Question opportunities describe meaning, not final prose. New opportunities use `semantic-question-v2` and carry a goal, requested fields, anchors, context facts, forbidden moves, a natural fallback prompt, utility inputs, target event, and active state. Historical opportunities with only `prompt` remain readable by normalizing that text to `fallbackPrompt`.
+
+The builder produces several candidates and publishes at most five active opportunities. Rank them by evidence and context: expected information gain, candidate-split relevance, date sensitivity, domain coverage, recent user topics, recall ease, novelty, repetition penalty, and privacy cost. Never select the first missing domain from a fixed education/relocation/relationship/career/finance/health sequence.
+
+## One-turn rule
+
+- Ask one question only.
+- Prefer the concrete event the user just mentioned.
+- A targeted question must include a valid text anchor for that event and must not switch targets.
+- Do not ask a list of questions or combine a clarification with a new-domain request.
+- Do not invent an event or date.
+- Do not expose IDs, fields, scores, tools, models, or technique traces.
+
+## Target disposition
+
+Respect the reconciled target state:
+
+- `resolved`: close the target.
+- `unknown`: close it; do not create an unparsed-event pending item for the refusal phrase.
+- `declined`: close it and do not proactively return to that event or sensitive category.
+- `direction_change`: close it and choose another useful opportunity.
+- `answered_other_event`: save the new event without overwriting the old target; allow at most one gentle follow-up to the old target.
+- `unresolved`: one follow-up is allowed only when the user has not refused or changed direction.
+- `not_applicable`: no old target is being resolved.
+
+The same `targetEventId` may be followed up consecutively at most once. A second answer about another event closes the old target instead of creating a loop.
+
+## Date precision
+
+- `day`: complete; never ask for finer detail.
+- `month`: complete by default. Ask for a day or narrower stage only when diagnostics exist and either `winnerRetentionRate < 0.65` or `candidateClusterRetentionRate < 0.65`.
+- `quarter`: a month may be requested.
+- `year`: request a month or approximate range only when useful.
+- `range`: refine only when it is broad and diagnostics show candidate-ranking impact.
+
+Before enough events exist to score candidates, a month-dated event should lead to another important dated event, not a request for the exact day.
+
+## Privacy and stopping
+
+Health, death, illness, family, and relationship questions carry higher privacy cost. Once the user declines a category in the current Case, do not ask it again unless the user raises it. If no opportunity has enough value, stop with low confidence rather than running a longer questionnaire.
diff --git a/skills/birth-time-rectification/references/technique-policy.md b/skills/birth-time-rectification/references/technique-policy.md
index 08d891f1..4f6a2262 100644
--- a/skills/birth-time-rectification/references/technique-policy.md
+++ b/skills/birth-time-rectification/references/technique-policy.md
@@ -1,3 +1,22 @@
 # Technique policy
 
-Only server-reported available layers may be described as used. Missing, blocked, reference-only, and research-only layers are not evidence of a result.
+The conversation refactor does not change the scoring algorithm. Keep `rectification-v5-matrix-scoring-1`, Python candidate-minute scanning, the event contribution matrix, Candidate Snapshots, leave-one-event-out, leave-one-domain-out, date sensitivity, neighbor stability, candidate split, Decision Validator, and deterministic fallback.
+
+Only server-reported available layers may be described as used. Missing, blocked, reference-only, and research-only layers are not evidence of a result. Do not import or reproduce the portable ZIP's candidate segmentation, manual `supports/conflicts` scoring, fixed unknown-mode blocks, dynamic repository loading, or `main_repository_enhanced` mode.
+
+## Diagnostic use
+
+- The Reasoner may request at most one allowed read-only diagnostic in a turn.
+- Send only compact conclusions needed for opportunity selection, not the full contribution matrix.
+- Date sensitivity determines whether finer date precision is worth asking for.
+- Leave-one-event/domain-out, neighbor stability, and candidate split diagnose fragility; they do not independently authorize public certainty.
+- Sparse, conflicting, or unstable diagnostics require a lower-confidence stop or another genuinely discriminating question.
+
+## Technique boundaries
+
+- Dasha and dated evidence can frame comparison only when present in server results.
+- D9 and D10 may support relationship and career analysis when available.
+- Topic-specific layers such as D4, D24, D2/D11, D7, and D30 remain bounded by server capability.
+- D60 is reference-only and must never drive candidate selection or the public conclusion.
+- Never expose private scores, weights, contribution values, internal technique traces, or tool/model names in the user-facing message.
+- No technique result can override `canConfirmExactMinute === false` or authorize an automatic profile birth-time write.

From 163d3fd1be4b57ed1f9397f86b79698f877bb78f Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Wed, 29 Jul 2026 18:17:46 +0800
Subject: [PATCH 02/15] fix: stabilize rectification staging release

---
 docs/BUG_HISTORY.md                           |  28 ++++
 .../evidence-extractor.ts                     |  21 ++-
 .../opportunity-builder.ts                    |   3 +-
 .../lib/rectification-agent/reasoner-agent.ts |   3 +-
 .../lib/rectification-agent/renderer-agent.ts |  19 ++-
 .../lib/rectification-v4/evidence-ledger.ts   |   6 +
 frontend/tests/rectification-agent-v6.test.ts |  25 ++++
 ...tion-assisted-extraction-safety-v6.test.ts |  66 +++++++++
 .../rectification-renderer-safety-v6.test.ts  | 136 ++++++++++++++++++
 pyproject.toml                                |   2 +-
 requirements.txt                              |   2 +-
 tests/test_mcp_dependency_contract.py         |  17 +++
 12 files changed, 317 insertions(+), 11 deletions(-)
 create mode 100644 frontend/tests/rectification-assisted-extraction-safety-v6.test.ts
 create mode 100644 frontend/tests/rectification-renderer-safety-v6.test.ts
 create mode 100644 tests/test_mcp_dependency_contract.py

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index d374a9a1..53925c57 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1606,3 +1606,31 @@
 - 修复：删除客户端不应拥有的 `high_rigor` 输入；在异步请求结束后从 `globalThis` 重新读取身份缓存；按生产边界把 `Date` 归一化为日期字符串后再构建 onboarding cache identity。
 - 验证：`npx tsc --noEmit`、相关前端测试和生产构建通过。
 - 防复发：测试输入只使用公开类型拥有的字段；异步初始化的全局缓存不要依赖删除前的局部控制流；数据库日期联合类型在进入纯字符串合同前必须归一化。
+
+## BUG-089 | Staging CI 自动升级 MCP 2.0 导致旧 FastMCP 导入失败
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：`Staging Backend Quality Gate` 的 Python quick quality gate 与 staging 发布
+- 用户现象：本地完整验证通过，但 staging push 的质量门在导入 `mcp_server.py` 时失败，报 `ModuleNotFoundError: No module named 'mcp.server.fastmcp'`。
+- 根因：`requirements.txt` 与 `pyproject.toml` 仅声明 `mcp>=1.0`；CI 在 2026-07-29 安装了不兼容的 `mcp 2.0.0`，而仓库当前服务端仍使用 MCP 1.x 的 `mcp.server.fastmcp.FastMCP` 导入合同。本地环境保留 `mcp 1.25.0`，因此未复现依赖漂移。
+- 修复：两个发布依赖入口统一限制为 `mcp>=1.0,<2`，继续使用已验证的 MCP 1.x API，不在本次发布中混入 MCP 2.0 迁移。
+- 验证：新增依赖合同测试同时读取 `requirements.txt` 和 `pyproject.toml`，防止任一入口再次放宽到 MCP 2.x；Python quick quality gate 与构建重新执行。
+- 防复发：运行时依赖的主版本兼容边界必须在全部安装入口保持一致；升级 MCP 2.x 必须作为独立迁移处理并先替换导入/API 合同。
+- 相关记录：BUG-087、BUG-088
+- 修复版本：待本次 staging 修复提交与部署验收
+
+## BUG-090 | V6 审查发现用户可见分钟注入、家庭事件越权和最新事件排序错误
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：生时纠正 Renderer、模型辅助事件提取、Opportunity 与 Reasoner 最近事件上下文
+- 用户现象：模型可能在 acknowledgement 或 limitation 中声称唯一出生分钟；家庭健康事件可能被矛盾模型字段伪装成本人可评分事件；UUID 排序与创建时间相反时，下一问可能承接较早经历。
+- 根因：分钟安全验证只覆盖 question；辅助提取校验未拒绝 `subject=self` 与非空家庭 `relatedPerson` 的矛盾组合；账本的稳定 UUID 排序被误当作会话时间顺序。
+- 修复：全部用户可见 Renderer 字段统一执行出生分钟和内部信息安全校验并回落到服务器确定性文案；辅助提取在服务器拒绝主体/亲属矛盾并保持家庭事件 `context_only` 边界；Builder 与 Reasoner 显式按 `createdAt`、`eventId`、revision 稳定排序最近事件，不改变证据哈希使用的账本排序。
+- 验证：新增 acknowledgement/limitation 分钟注入、家庭 ICU 事件越权、UUID 与创建时间逆序的回归测试，并重新运行前端完整测试、lint、TypeScript 与构建。
+- 防复发：所有模型可写用户文案共享同一安全边界；模型提取不能决定评分主体；用于哈希的稳定顺序不得被复用为会话时序。
+- 相关记录：BUG-075、BUG-086、BUG-087
+- 修复版本：待本次 staging 修复提交与部署验收
diff --git a/frontend/src/lib/conversational-rectification/evidence-extractor.ts b/frontend/src/lib/conversational-rectification/evidence-extractor.ts
index 6973a6e4..b9df6abf 100644
--- a/frontend/src/lib/conversational-rectification/evidence-extractor.ts
+++ b/frontend/src/lib/conversational-rectification/evidence-extractor.ts
@@ -292,6 +292,18 @@ const allowedKindsByDomain: Readonly<Record<RectificationEvidenceDomain, readonl
   other: ["other"],
 };
 
+const familyRelatedPeople = new Set<ModelAssistedEventExtraction["relatedPerson"]>([
+  "father",
+  "mother",
+  "grandparent",
+  "sibling",
+]);
+const explicitFamilySubjectMarkers = [
+  "父亲", "爸爸", "老爸", "母亲", "妈妈", "老妈",
+  "爷爷", "奶奶", "外公", "外婆", "祖父", "祖母", "外祖父", "外祖母",
+  "兄弟", "姐妹", "家里老人", "家中老人",
+] as const;
+
 export function validatedModelAssistedEvidence(input: Readonly<{
   rawText: string;
   sourceTurnId: string;
@@ -305,7 +317,14 @@ export function validatedModelAssistedEvidence(input: Readonly<{
   const date = parseDeclaredDateText(dateText.normalize("NFKC"), input.asOfDate);
   if (!date || dateIsFuture(date, input.asOfDate)) return null;
   if (!allowedKindsByDomain[input.extraction.domain]?.includes(input.extraction.eventKind)) return null;
-  if (input.extraction.subject === "partner" && input.extraction.domain !== "relationship") return null;
+  const { subject, relatedPerson, domain } = input.extraction;
+  if (subject === "self" && relatedPerson !== null) return null;
+  if ((subject === "family") !== (domain === "family")) return null;
+  if (familyRelatedPeople.has(relatedPerson) && subject !== "family") return null;
+  if (relatedPerson === "partner" && (subject !== "partner" || domain !== "relationship")) return null;
+  if (subject === "partner" && (domain !== "relationship" || relatedPerson !== "partner")) return null;
+  if (explicitFamilySubjectMarkers.some((marker) => sourceSpan.includes(marker))
+    && (subject !== "family" || domain !== "family")) return null;
   const summary = eventSummary(sourceSpan);
   if (summary === missingEventSummary) return null;
   const familyContext = input.extraction.subject === "family" || input.extraction.domain === "family";
diff --git a/frontend/src/lib/rectification-agent/opportunity-builder.ts b/frontend/src/lib/rectification-agent/opportunity-builder.ts
index 365b9a24..0a88ea5c 100644
--- a/frontend/src/lib/rectification-agent/opportunity-builder.ts
+++ b/frontend/src/lib/rectification-agent/opportunity-builder.ts
@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import type { CandidateSnapshot, EvidenceDomain, LifeEventRevision, RectificationV4Turn } from "../rectification-v4/contracts.ts";
+import { chronologicalEvents } from "../rectification-v4/evidence-ledger.ts";
 import type { TargetDisposition } from "../rectification-v4/extraction.ts";
 import type { DiagnosticsSummary, QuestionOpportunity, SemanticQuestionOpportunity } from "./contracts.ts";
 
@@ -181,12 +182,12 @@ export function buildQuestionOpportunities(input: Readonly<{
   }
 
   const scoreableCount = input.events.filter((event) => event.scoreability === "scoreable").length;
+  const latestEvent = chronologicalEvents(input.events).at(-1);
   for (const [domain, policy] of Object.entries(domainPolicy) as [Exclude<EvidenceDomain, "family" | "other">, (typeof domainPolicy)[Exclude<EvidenceDomain, "family" | "other">]][]) {
     if (refusedDomains.has(domain)) continue;
     const covered = scoreableDomains.has(domain);
     const themeBonus = policy.keywords.test(latestContext) ? .12 : 0;
     const alreadyAsked = input.turns.some((turn) => turn.questionDomain === domain && !turn.questionTargetEventId);
-    const latestEvent = input.events.at(-1);
     const latestAnchor = latestEvent ? anchorFor(latestEvent) : null;
     const prompt = latestAnchor
       ? `承接“${latestAnchor}”，请再说一件时间相对明确的经历：${policy.fallbackPrompt}`
diff --git a/frontend/src/lib/rectification-agent/reasoner-agent.ts b/frontend/src/lib/rectification-agent/reasoner-agent.ts
index 9f044b6f..d36e1864 100644
--- a/frontend/src/lib/rectification-agent/reasoner-agent.ts
+++ b/frontend/src/lib/rectification-agent/reasoner-agent.ts
@@ -4,6 +4,7 @@ import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
 import { defaultLanguageModel, resolveLanguageModel } from "@/mastra/model";
 import type { CandidateSnapshot, LifeEventRevision, PendingEvidence, RectificationV4Case, RectificationV4Turn } from "../rectification-v4/contracts.ts";
+import { chronologicalEvents } from "../rectification-v4/evidence-ledger.ts";
 import type { TargetDisposition } from "../rectification-v4/extraction.ts";
 import { deterministicDecision } from "./fallback-policy.ts";
 import { recordRectificationAgentTelemetry } from "./telemetry.ts";
@@ -54,7 +55,7 @@ export function buildReasonerState(input: Readonly<{
     candidateRangeChanged: input.candidateRangeChanged ?? false,
     latestAnswer: input.recentTurns?.at(-1)?.answer ?? "",
     recentTurns: (input.recentTurns ?? []).slice(-6).map((turn) => ({ question: turn.question, answer: turn.answer })),
-    recentEvents: (input.recentEvents ?? []).slice(-5).map((event) => ({ summary: event.summary, date: event.dateRange.label, domain: event.domain, subject: event.subject })),
+    recentEvents: chronologicalEvents(input.recentEvents ?? []).slice(-5).map((event) => ({ summary: event.summary, date: event.dateRange.label, domain: event.domain, subject: event.subject })),
     currentTarget: input.currentTarget ? { summary: input.currentTarget.summary, date: input.currentTarget.dateRange.label, domain: input.currentTarget.domain } : null,
     targetDisposition: input.targetDisposition ?? "not_applicable",
     pendingEvidence: {
diff --git a/frontend/src/lib/rectification-agent/renderer-agent.ts b/frontend/src/lib/rectification-agent/renderer-agent.ts
index 2c216bc3..e2d0d2c7 100644
--- a/frontend/src/lib/rectification-agent/renderer-agent.ts
+++ b/frontend/src/lib/rectification-agent/renderer-agent.ts
@@ -11,7 +11,8 @@ const bannedAcknowledgement = /(?:这个信息很有用|它不是单纯的|而
 const overinterpretedAcknowledgement = /(?:职业方向正式落地|人生意义|意味着你|说明你(?:已经|开始|正式)|标志着你)/;
 const internalTerms = /(?:opportunityId|snapshotId|eventId|targetEventId|requestedFields|fallbackPrompt|tool\s*call|tool_call|score|评分|模型名|opportunity|snapshot|D\d{1,2}|KP\b|Vimshottari)/i;
 const multiQuestionMoves = /(?:另外|还有|同时再说|并且告诉我|顺便|再告诉我)/;
-const birthMinute = /(?:出生|生时|几点).{0,12}(?:[01]\d|2[0-3]):[0-5]\d|(?:[01]\d|2[0-3]):[0-5]\d.{0,12}(?:出生|生时)/;
+const exactClockMinute = /(?:[01]?\d|2[0-3])[:：][0-5]\d|(?:[零〇一二两三四五六七八九十]{1,3}|(?:[01]?\d|2[0-3]))点(?:[零〇一二两三四五六七八九十]{1,3}|[0-5]?\d)分/;
+const exactMinuteClaim = /(?:唯一|准确|精确|确切|确认|确定|代表).{0,12}(?:出生|生时)?(?:时间|时刻|分钟)|(?:出生|生时)(?:时间|时刻|分钟)?.{0,12}(?:唯一|准确|精确|确切|确认|确定|代表|就是)/;
 
 function agentFor(modelId: string | null): { id: string; agent: Agent } | null {
   const selected = (modelId ? resolveLanguageModel(modelId) : null) ?? defaultLanguageModel();
@@ -33,6 +34,13 @@ function normalized(value: string): string {
   return value.normalize("NFKC").replace(/[“”"'\s，,。.!！?？:：；;]/g, "");
 }
 
+function visibleTextSafetyIssues(value: string): string[] {
+  const issues: string[] = [];
+  if (internalTerms.test(value)) issues.push("internal_information_exposed");
+  if (exactClockMinute.test(value) || exactMinuteClaim.test(value)) issues.push("birth_minute_injected");
+  return issues;
+}
+
 export function validateQuestionRealization(question: unknown, opportunity: QuestionOpportunity): Readonly<{ valid: boolean; issues: readonly string[] }> {
   if (typeof question !== "string") return { valid: false, issues: ["question_missing"] };
   const value = question.trim();
@@ -41,9 +49,8 @@ export function validateQuestionRealization(question: unknown, opportunity: Ques
   if ((value.match(/[?？]/g) ?? []).length > 1) issues.push("multiple_question_marks");
   if ((value.match(/[。.!！?？]/g) ?? []).length > 2) issues.push("too_many_sentences");
   if (/\n\s*(?:[-*•]|\d+[.)、])/.test(value)) issues.push("question_list_forbidden");
-  if (internalTerms.test(value)) issues.push("internal_information_exposed");
+  issues.push(...visibleTextSafetyIssues(value));
   if (multiQuestionMoves.test(value)) issues.push("multiple_question_instruction");
-  if (birthMinute.test(value)) issues.push("birth_minute_injected");
   if (opportunity.targetEventId) {
     const questionText = normalized(value);
     if (!opportunity.anchors.some((anchor) => questionText.includes(normalized(anchor)))) issues.push("target_anchor_missing");
@@ -111,9 +118,9 @@ export function realizePublicMessage(value: unknown, input: Parameters<typeof de
   const parsed = publicMessageSchema.parse(value);
   const opportunity = input.validated.selectedOpportunity;
   const fallback = deterministic(input);
-  const acknowledgement = bannedAcknowledgement.test(parsed.acknowledgement)
+  const acknowledgement = visibleTextSafetyIssues(parsed.acknowledgement).length > 0
+    || bannedAcknowledgement.test(parsed.acknowledgement)
     || overinterpretedAcknowledgement.test(parsed.acknowledgement)
-    || internalTerms.test(parsed.acknowledgement)
     || (parsed.acknowledgement.match(/[。.!！?？]/g) ?? []).length > 2
     || (input.acceptedEvents.at(-1) && !normalized(parsed.acknowledgement).includes(normalized(input.acceptedEvents.at(-1)!.summary)))
     ? fallback.acknowledgement
@@ -124,7 +131,7 @@ export function realizePublicMessage(value: unknown, input: Parameters<typeof de
   return {
     acknowledgement,
     candidateUpdate: fallback.candidateUpdate,
-    limitation: fallback.limitation ?? (parsed.limitation && !internalTerms.test(parsed.limitation) ? parsed.limitation : null),
+    limitation: fallback.limitation ?? (parsed.limitation && visibleTextSafetyIssues(parsed.limitation).length === 0 ? parsed.limitation : null),
     question,
   };
 }
diff --git a/frontend/src/lib/rectification-v4/evidence-ledger.ts b/frontend/src/lib/rectification-v4/evidence-ledger.ts
index dba76a92..3236751e 100644
--- a/frontend/src/lib/rectification-v4/evidence-ledger.ts
+++ b/frontend/src/lib/rectification-v4/evidence-ledger.ts
@@ -15,6 +15,12 @@ export function latestEventRevisions(revisions: readonly LifeEventRevision[]): r
   return [...latest.values()].sort((left, right) => left.eventId.localeCompare(right.eventId));
 }
 
+export function chronologicalEvents(events: readonly LifeEventRevision[]): readonly LifeEventRevision[] {
+  return [...events].sort((left, right) => left.createdAt.localeCompare(right.createdAt)
+    || left.eventId.localeCompare(right.eventId)
+    || left.revision - right.revision);
+}
+
 export function appendEventRevision(
   revisions: readonly LifeEventRevision[],
   input: NewEventRevision,
diff --git a/frontend/tests/rectification-agent-v6.test.ts b/frontend/tests/rectification-agent-v6.test.ts
index 5c23b277..d95ab428 100644
--- a/frontend/tests/rectification-agent-v6.test.ts
+++ b/frontend/tests/rectification-agent-v6.test.ts
@@ -191,6 +191,31 @@ test("Builder 的领域排序不受事件输入数组顺序影响", () => {
   assert.deepEqual(domains([education, career]), domains([career, education]));
 });
 
+test("Builder 和 Reasoner 按事件创建时间承接最近经历而不是 UUID 顺序", () => {
+  const older = event({
+    eventId: "ffffffff-ffff-4fff-8fff-ffffffffffff",
+    summary: "较早的研究院实习",
+    createdAt: "2026-07-29T01:00:00.000Z",
+  });
+  const newer = event({
+    eventId: "00000000-0000-4000-8000-000000000000",
+    domain: "relocation",
+    eventKind: "relocation",
+    summary: "刚提到的搬到北京",
+    rawText: "2018年8月搬到北京",
+    dateRange: { start: "2018-08-01", end: "2018-08-31", precision: "month", label: "2018年8月" },
+    createdAt: "2026-07-29T02:00:00.000Z",
+  });
+  const opportunities = buildQuestionOpportunities({ caseId, events: [newer, older], turns: [], snapshot: null, diagnostics: null });
+  const askNewEvent = opportunities.find((item) => item.kind === "ask_new_event");
+  assert.ok(askNewEvent);
+  assert.match(askNewEvent.fallbackPrompt, /刚提到的搬到北京/);
+  assert.doesNotMatch(askNewEvent.fallbackPrompt, /较早的研究院实习/);
+
+  const state = buildReasonerState({ snapshot: null, diagnostics: diagnostics(), opportunities, recentEvents: [newer, older] });
+  assert.equal(state.recentEvents.at(-1)?.summary, "刚提到的搬到北京");
+});
+
 test("Reasoner 状态包含最近语义上下文但不包含贡献矩阵", () => {
   const latestEvent = event();
   const opportunity = targetOpportunity(latestEvent);
diff --git a/frontend/tests/rectification-assisted-extraction-safety-v6.test.ts b/frontend/tests/rectification-assisted-extraction-safety-v6.test.ts
new file mode 100644
index 00000000..78003a2b
--- /dev/null
+++ b/frontend/tests/rectification-assisted-extraction-safety-v6.test.ts
@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import test from "node:test";
+import { validatedModelAssistedEvidence } from "../src/lib/conversational-rectification/evidence-extractor.ts";
+
+test("模型辅助提取拒绝 self 与家庭 relatedPerson 的矛盾组合", () => {
+  const rawText = "2020年4月老爸进了ICU。";
+  const result = validatedModelAssistedEvidence({
+    rawText,
+    sourceTurnId: randomUUID(),
+    asOfDate: "2026-07-29",
+    extraction: {
+      sourceSpan: "2020年4月老爸进了ICU",
+      summary: "老爸进了ICU",
+      domain: "health_pressure",
+      eventKind: "self_health_event",
+      subject: "self",
+      relatedPerson: "father",
+      dateText: "2020年4月",
+    },
+  });
+
+  assert.equal(result, null);
+});
+
+test("明确家庭主体不能被模型伪装为 self scoreable", () => {
+  const rawText = "2021年6月家里老人病危。";
+  const result = validatedModelAssistedEvidence({
+    rawText,
+    sourceTurnId: randomUUID(),
+    asOfDate: "2026-07-29",
+    extraction: {
+      sourceSpan: "2021年6月家里老人病危",
+      summary: "家里老人病危",
+      domain: "health_pressure",
+      eventKind: "self_health_event",
+      subject: "self",
+      relatedPerson: null,
+      dateText: "2021年6月",
+    },
+  });
+
+  assert.equal(result, null);
+});
+
+test("合法家庭健康事件只作为 context_only", () => {
+  const rawText = "2020年4月老爸进了ICU。";
+  const result = validatedModelAssistedEvidence({
+    rawText,
+    sourceTurnId: randomUUID(),
+    asOfDate: "2026-07-29",
+    extraction: {
+      sourceSpan: "2020年4月老爸进了ICU",
+      summary: "老爸进了ICU",
+      domain: "family",
+      eventKind: "family_health_event",
+      subject: "family",
+      relatedPerson: "father",
+      dateText: "2020年4月",
+    },
+  });
+
+  assert.ok(result);
+  assert.equal(result.scoreability, "context_only");
+  assert.equal(result.scoreable, false);
+});
diff --git a/frontend/tests/rectification-renderer-safety-v6.test.ts b/frontend/tests/rectification-renderer-safety-v6.test.ts
new file mode 100644
index 00000000..c31fae51
--- /dev/null
+++ b/frontend/tests/rectification-renderer-safety-v6.test.ts
@@ -0,0 +1,136 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import test from "node:test";
+import type { QuestionOpportunity, ValidatedDecision } from "../src/lib/rectification-agent/contracts.ts";
+import { realizePublicMessage, validateQuestionRealization } from "../src/lib/rectification-agent/renderer-agent.ts";
+import type { CandidateSnapshot, LifeEventRevision, PendingEvidence } from "../src/lib/rectification-v4/contracts.ts";
+
+const caseId = "00000000-0000-4000-8000-000000000701";
+const now = "2026-07-29T00:00:00.000Z";
+
+function event(): LifeEventRevision {
+  return {
+    id: randomUUID(),
+    eventId: randomUUID(),
+    revision: 1,
+    domain: "career",
+    eventKind: "career_change",
+    subject: "self",
+    relatedPerson: null,
+    summary: "2020年4月研究院实习",
+    rawText: "2020年4月去石油化工研究院实习做研究员。",
+    dateRange: { start: "2020-04-01", end: "2020-04-30", precision: "month", label: "2020年4月" },
+    scoreability: "scoreable",
+    supersedesRevisionId: null,
+    createdAt: now,
+  };
+}
+
+function opportunity(target: LifeEventRevision): QuestionOpportunity {
+  return {
+    contractVersion: "semantic-question-v2",
+    opportunityId: randomUUID(),
+    kind: "refine_event_date",
+    domain: "career",
+    targetEventId: target.eventId,
+    goal: "确认研究院实习发生的大概阶段。",
+    requestedFields: ["event_stage"],
+    anchors: [target.summary],
+    contextFacts: [],
+    forbiddenMoves: ["switch_target_event", "ask_multiple_questions", "claim_exact_birth_minute", "invent_event", "invent_date", "expose_private_score", "expose_internal_id", "expose_technique_trace"],
+    fallbackPrompt: `关于“${target.summary}”，你更记得是开始、高峰还是结束阶段吗？`,
+    reason: "当前事件仍需区分发生阶段。",
+    expectedInformationGain: 0.7,
+    dateSensitivity: 0.7,
+    candidateSplitRelevance: 0.4,
+    domainCoverageGain: 0,
+    recallEase: 0.6,
+    novelty: 0.8,
+    repetitionPenalty: 0,
+    privacyCost: 0.05,
+    utility: 0.65,
+    active: true,
+  };
+}
+
+function validated(selectedOpportunity: QuestionOpportunity): ValidatedDecision {
+  return {
+    decision: { action: "ask_question", opportunityId: selectedOpportunity.opportunityId, narrativeFocus: ["latest_event"] },
+    mode: "agent",
+    validationIssues: [],
+    selectedOpportunity,
+  };
+}
+
+function snapshot(range: readonly [string, string]): CandidateSnapshot {
+  const [startTime, endTime] = range;
+  return {
+    id: randomUUID(),
+    caseId,
+    caseVersion: 3,
+    evidenceSetHash: "e".repeat(64),
+    calculationSpecHash: "c".repeat(64),
+    algorithmVersion: "rectification-v5-matrix-scoring-1",
+    candidates: [{ time: startTime, score: 10, supportingEventIds: [], conflictingEventIds: [] }],
+    clusters: [{ rank: 1, startTime, endTime, representativeTime: startTime, widthMinutes: 7, peakScore: 10, scoreMass: 1 }],
+    robustness: { neighborSupportMinutes: 8, leaveOneOutRetentionRate: 0.8, dateSensitivityRetentionRate: 0.8, calculationSpecHashMatched: true },
+    canConfirmExactMinute: false,
+    canAcceptRange: true,
+    gateReasons: [],
+    createdAt: now,
+  };
+}
+
+test("Renderer 对全部模型可见文本执行 exact-minute 和内部信息安全回落", () => {
+  const target = event();
+  const selectedOpportunity = opportunity(target);
+  const input = {
+    latestAnswer: target.rawText,
+    acceptedEvents: [target],
+    pendingEvidence: [] as PendingEvidence[],
+    snapshot: null,
+    previousSnapshot: null,
+    validated: validated(selectedOpportunity),
+  };
+
+  const message = realizePublicMessage({
+    acknowledgement: `你提到的是“${target.summary}”，所以准确出生分钟是05:13。`,
+    candidateUpdate: null,
+    limitation: "准确出生分钟是五点十三分，snapshotId 已确认。",
+    question: `关于${target.summary}，唯一出生分钟是什么？`,
+  }, input);
+
+  assert.equal(message.acknowledgement, `你提到的是 ${target.dateRange.label} 的“${target.summary}”。`);
+  assert.equal(message.limitation, null);
+  assert.equal(message.question, selectedOpportunity.fallbackPrompt);
+  assert.doesNotMatch(JSON.stringify(message), /05:13|五点十三分|准确出生分钟|唯一出生分钟|snapshotId/);
+
+  for (const question of [
+    `关于${target.summary}，你是不是五点十三分出生？`,
+    `关于${target.summary}，eventId 是什么？`,
+  ]) {
+    assert.equal(validateQuestionRealization(question, selectedOpportunity).valid, false, question);
+  }
+});
+
+test("Renderer 保留服务器生成的合法候选范围表达", () => {
+  const target = event();
+  const selectedOpportunity = opportunity(target);
+  const message = realizePublicMessage({
+    acknowledgement: `你提到的是“${target.summary}”。`,
+    candidateUpdate: "模型声称出生时间就是05:13。",
+    limitation: null,
+    question: `关于${target.summary}，你更记得是开始、高峰还是结束阶段吗？`,
+  }, {
+    latestAnswer: target.rawText,
+    acceptedEvents: [target],
+    pendingEvidence: [],
+    snapshot: snapshot(["05:12", "05:18"]),
+    previousSnapshot: null,
+    validated: validated(selectedOpportunity),
+  });
+
+  assert.match(message.candidateUpdate ?? "", /候选范围.*05:12.*05:18/);
+  assert.match(message.candidateUpdate ?? "", /不代表其中某一分钟已被确认/);
+  assert.doesNotMatch(message.candidateUpdate ?? "", /就是05:13/);
+});
diff --git a/pyproject.toml b/pyproject.toml
index 94341479..2c41f44d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -42,7 +42,7 @@ dev = [
     "wheel>=0.40",
 ]
 api = [
-    "mcp>=1.0",
+    "mcp>=1.0,<2",
 ]
 
 [project.scripts]
diff --git a/requirements.txt b/requirements.txt
index ddbb3fcb..374dafc1 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -16,7 +16,7 @@ pandas>=1.3,<3
 numpy>=1.20,<3
 
 # 严格证据收集器通过 mcp_server 复用（API 运行时必需）
-mcp>=1.0
+mcp>=1.0,<2
 
 # 以下为标准库，无需安装（仅供参考）：
 # argparse, json, sys, os, csv, math, sqlite3
diff --git a/tests/test_mcp_dependency_contract.py b/tests/test_mcp_dependency_contract.py
new file mode 100644
index 00000000..0475e0b6
--- /dev/null
+++ b/tests/test_mcp_dependency_contract.py
@@ -0,0 +1,17 @@
+import tomllib
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+MCP_REQUIREMENT = "mcp>=1.0,<2"
+
+
+def test_mcp_dependency_stays_on_compatible_major_version() -> None:
+    requirements = {
+        line.strip()
+        for line in (ROOT / "requirements.txt").read_text(encoding="utf-8").splitlines()
+        if line.strip() and not line.lstrip().startswith("#")
+    }
+    project = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+
+    assert MCP_REQUIREMENT in requirements
+    assert MCP_REQUIREMENT in project["project"]["optional-dependencies"]["api"]

From 6ed9f2dd0a5f2a573991c3d49a817f13a202b56c Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Wed, 29 Jul 2026 19:18:09 +0800
Subject: [PATCH 03/15] fix: enable semantic rectification rollout

---
 deploy/README.md                                  | 11 +++++++----
 deploy/configure-staging-rectification-rollout.sh |  6 +++++-
 docs/BUG_HISTORY.md                               | 14 ++++++++++++++
 frontend/tests/staging-backend-workflows.test.ts  | 11 ++++++++++-
 4 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/deploy/README.md b/deploy/README.md
index fc9142b9..32e69025 100644
--- a/deploy/README.md
+++ b/deploy/README.md
@@ -406,11 +406,14 @@ previous-revision smoke SHA must remain pending. If the create flag, migration
 flag, deployment SHA, or strict UUID allowlist is invalid, creation audience
 must be `paused`, including for the smoke account.
 
-After the smoke sequence below passes, set
+After the smoke sequence below passes, use the guarded rollout workflow to set
 `RECTIFICATION_V3_SYNTHETIC_SMOKE_SHA` to the exact deployed 40-character
-lowercase Git SHA, remove `RECTIFICATION_V3_SYNTHETIC_SMOKE_USER_IDS`, and
-restart the web container. Then fetch health again and
-verify all of the following against the revision that passed validation:
+lowercase Git SHA, remove `RECTIFICATION_V3_SYNTHETIC_SMOKE_USER_IDS`, enable
+`RECTIFICATION_AGENT_V5_ENABLED=true`, disable shadow mode, set the canary to
+100 percent, and restart both the web and rectification worker containers. The
+workflow writes these selectors together so public Case creation cannot silently
+fall back to the fixed `v4_legacy` projector. Then fetch health again and verify
+all of the following against the revision that passed validation:
 
 - `deployment.gitCommit` exactly equals the tested 40-character Git SHA;
 - `rollout.conversationalRectificationV3.protocol` is
diff --git a/deploy/configure-staging-rectification-rollout.sh b/deploy/configure-staging-rectification-rollout.sh
index 4edfbf9b..1725d6c6 100755
--- a/deploy/configure-staging-rectification-rollout.sh
+++ b/deploy/configure-staging-rectification-rollout.sh
@@ -102,12 +102,16 @@ awk \
   -v create="$creation_enabled" \
   -v migrations="true" \
   -v smoke_sha="$smoke_sha" \
-  -v smoke_users="$smoke_user_ids" '
+  -v smoke_users="$smoke_user_ids" \
+  -v agent_enabled="$creation_enabled" '
 BEGIN {
   values["RECTIFICATION_V3_CREATE_ENABLED"] = create
   values["RECTIFICATION_V3_MIGRATIONS_READY"] = migrations
   values["RECTIFICATION_V3_SYNTHETIC_SMOKE_SHA"] = smoke_sha
   values["RECTIFICATION_V3_SYNTHETIC_SMOKE_USER_IDS"] = smoke_users
+  values["RECTIFICATION_AGENT_V5_ENABLED"] = agent_enabled
+  values["RECTIFICATION_AGENT_V5_SHADOW"] = "false"
+  values["RECTIFICATION_AGENT_V5_CANARY_PERCENT"] = "100"
 }
 {
   split($0, parts, "=")
diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 53925c57..3daf8723 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1634,3 +1634,17 @@
 - 防复发：所有模型可写用户文案共享同一安全边界；模型提取不能决定评分主体；用于哈希的稳定顺序不得被复用为会话时序。
 - 相关记录：BUG-075、BUG-086、BUG-087
 - 修复版本：待本次 staging 修复提交与部署验收
+
+## BUG-091 | Staging Case rollout 未启用 V5 Agent 导致 V6 继续输出固定模板
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：staging 生时纠正新 Case 与 V6 未完成 Case 的用户可见回复
+- 用户现象：用户提交“2016 年 9 月离家去外地上大学”后，回复仍固定为“我记下了这段经历。接下来请继续讲另一件……”，没有进入 Semantic Question Renderer。
+- 根因：Case rollout 只写入 V3 创建门和 smoke 状态，没有写入 `RECTIFICATION_AGENT_V5_ENABLED`、`RECTIFICATION_AGENT_V5_SHADOW`、`RECTIFICATION_AGENT_V5_CANARY_PERCENT`；因此 `selectRectificationDeploymentMode()` 把新 Case 持久化为 `v4_legacy`，Orchestrator 必然调用 Legacy Projector。
+- 修复：受控 staging rollout 现在原子写入 V5 Agent 开关，public 与 smoke rollout 使用 `v5_agent`、100% canary，并重建 web/worker；staging 中唯一满足 V6 版本、未完成、无 open Job 条件的错误 Case 已原位升级为 `rectification-evidence-v5` / `v5_agent`，历史 Turn、Event、Job 与 Agent Run 保持不变。
+- 验证：rollout 脚本测试断言三项 V5 选择器只写一次；staging 运行容器已读取 `enabled=true`、`shadow=false`、`canary=100`；活跃 Case 聚合只剩 `v5_agent`；健康检查保持 exact SHA、public、ready。
+- 防复发：公开 Case rollout 必须同时控制创建门与 Agent deployment mode；仅有 `readyForNewCases=true` 不再视为新对话 Renderer 已启用的充分证据。
+- 相关记录：BUG-085、BUG-086、BUG-087
+- 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`
diff --git a/frontend/tests/staging-backend-workflows.test.ts b/frontend/tests/staging-backend-workflows.test.ts
index 9986d41c..2a94a8b7 100644
--- a/frontend/tests/staging-backend-workflows.test.ts
+++ b/frontend/tests/staging-backend-workflows.test.ts
@@ -405,7 +405,7 @@ test("production remains manual-only and separate from staging database automati
 });
 
 
-test("public rectification rollout rewrites only rollout gates and recreates web runtimes", () => {
+test("public rectification rollout enables the semantic agent and recreates web runtimes", () => {
   const root = mkdtempSync(join(tmpdir(), "jyotisha-rollout-"));
   const deploymentPath = join(root, "app");
   const statePath = join(deploymentPath, ".state");
@@ -441,6 +441,9 @@ test("public rectification rollout rewrites only rollout gates and recreates web
       "RECTIFICATION_V3_MIGRATIONS_READY=false",
       "RECTIFICATION_V3_SYNTHETIC_SMOKE_SHA=old",
       "RECTIFICATION_V3_SYNTHETIC_SMOKE_USER_IDS=00000000-0000-4000-8000-000000009001",
+      "RECTIFICATION_AGENT_V5_ENABLED=false",
+      "RECTIFICATION_AGENT_V5_SHADOW=true",
+      "RECTIFICATION_AGENT_V5_CANARY_PERCENT=0",
       "",
     ].join("\n"),
     { mode: 0o600 },
@@ -487,7 +490,13 @@ test("public rectification rollout rewrites only rollout gates and recreates web
     assert.match(env, /^RECTIFICATION_V3_MIGRATIONS_READY=true$/m);
     assert.match(env, new RegExp(`^RECTIFICATION_V3_SYNTHETIC_SMOKE_SHA=${sha}$`, "m"));
     assert.match(env, /^RECTIFICATION_V3_SYNTHETIC_SMOKE_USER_IDS=$/m);
+    assert.match(env, /^RECTIFICATION_AGENT_V5_ENABLED=true$/m);
+    assert.match(env, /^RECTIFICATION_AGENT_V5_SHADOW=false$/m);
+    assert.match(env, /^RECTIFICATION_AGENT_V5_CANARY_PERCENT=100$/m);
     assert.equal((env.match(/^RECTIFICATION_V3_CREATE_ENABLED=/gm) ?? []).length, 1);
+    assert.equal((env.match(/^RECTIFICATION_AGENT_V5_ENABLED=/gm) ?? []).length, 1);
+    assert.equal((env.match(/^RECTIFICATION_AGENT_V5_SHADOW=/gm) ?? []).length, 1);
+    assert.equal((env.match(/^RECTIFICATION_AGENT_V5_CANARY_PERCENT=/gm) ?? []).length, 1);
     assert.match(readFileSync(join(root, "docker.log"), "utf8"), /force-recreate --no-deps web rectification-v4-worker/);
   } finally {
     rmSync(root, { recursive: true, force: true });

From f0f7c27382df297ea3e1c275e695922567e048b3 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Wed, 29 Jul 2026 19:26:51 +0800
Subject: [PATCH 04/15] fix: verify semantic rollout runtime

---
 deploy/README.md                                  |  6 +++---
 deploy/configure-staging-rectification-rollout.sh | 12 ++++++++++++
 docs/BUG_HISTORY.md                               |  4 ++--
 frontend/tests/staging-backend-workflows.test.ts  |  3 ++-
 4 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/deploy/README.md b/deploy/README.md
index 32e69025..80bf1127 100644
--- a/deploy/README.md
+++ b/deploy/README.md
@@ -437,9 +437,9 @@ sequence. A plain HTTP `200` is not substitute evidence:
    event, then a clear event. Verify the ambiguous/future facts do not score.
 4. Pause, reload, and resume from a second authenticated browser session.
    Verify no second rectification charge.
-5. Reach a candidate, verify the prior active time is still in force, reject a
-   mismatched candidate confirmation, then explicitly confirm the exact
-   candidate. Verify the time changes atomically.
+5. Reach a stable candidate range and verify the prior active time remains in
+   force. Confirm that no exact minute can be accepted and that rectification
+   does not write `profiles.active_birth_time`.
 6. Explicitly continue the saved ordinary question. Verify one normal
    consultation reservation. Delete its chat and verify the account case still
    resumes/loads.
diff --git a/deploy/configure-staging-rectification-rollout.sh b/deploy/configure-staging-rectification-rollout.sh
index 1725d6c6..75cd5bd1 100755
--- a/deploy/configure-staging-rectification-rollout.sh
+++ b/deploy/configure-staging-rectification-rollout.sh
@@ -151,6 +151,18 @@ compose=(docker compose -p jyotisha-staging --env-file .env.staging "${compose_f
 "${compose[@]}" config --quiet
 "${compose[@]}" up -d --no-build --pull never --force-recreate --no-deps web rectification-v4-worker
 
+for service in web rectification-v4-worker; do
+  container="$(docker ps -q --filter 'label=com.docker.compose.project=jyotisha-staging' --filter "label=com.docker.compose.service=$service" | head -n 1)"
+  [ -n "$container" ] || {
+    echo "staging $service container is missing after rollout" >&2
+    false
+  }
+  runtime_env="$(docker inspect --format '{{range .Config.Env}}{{println .}}{{end}}' "$container")"
+  grep -Fxq "RECTIFICATION_AGENT_V5_ENABLED=$creation_enabled" <<<"$runtime_env"
+  grep -Fxq "RECTIFICATION_AGENT_V5_SHADOW=false" <<<"$runtime_env"
+  grep -Fxq "RECTIFICATION_AGENT_V5_CANARY_PERCENT=100" <<<"$runtime_env"
+done
+
 health=""
 for _ in $(seq 1 30); do
   health="$(curl --fail --silent --show-error "$STAGING_URL/api/health" 2>/dev/null || true)"
diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 3daf8723..9ae1bb04 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1644,7 +1644,7 @@
 - 用户现象：用户提交“2016 年 9 月离家去外地上大学”后，回复仍固定为“我记下了这段经历。接下来请继续讲另一件……”，没有进入 Semantic Question Renderer。
 - 根因：Case rollout 只写入 V3 创建门和 smoke 状态，没有写入 `RECTIFICATION_AGENT_V5_ENABLED`、`RECTIFICATION_AGENT_V5_SHADOW`、`RECTIFICATION_AGENT_V5_CANARY_PERCENT`；因此 `selectRectificationDeploymentMode()` 把新 Case 持久化为 `v4_legacy`，Orchestrator 必然调用 Legacy Projector。
 - 修复：受控 staging rollout 现在原子写入 V5 Agent 开关，public 与 smoke rollout 使用 `v5_agent`、100% canary，并重建 web/worker；staging 中唯一满足 V6 版本、未完成、无 open Job 条件的错误 Case 已原位升级为 `rectification-evidence-v5` / `v5_agent`，历史 Turn、Event、Job 与 Agent Run 保持不变。
-- 验证：rollout 脚本测试断言三项 V5 选择器只写一次；staging 运行容器已读取 `enabled=true`、`shadow=false`、`canary=100`；活跃 Case 聚合只剩 `v5_agent`；健康检查保持 exact SHA、public、ready。
-- 防复发：公开 Case rollout 必须同时控制创建门与 Agent deployment mode；仅有 `readyForNewCases=true` 不再视为新对话 Renderer 已启用的充分证据。
+- 验证：rollout 脚本测试断言三项 V5 选择器只写一次，并在成功前核对 web/worker 容器实际读取的 `enabled`、`shadow`、`canary`；staging 活跃 Case 聚合只剩 `v5_agent`；健康检查保持 exact SHA、public、ready。
+- 防复发：公开 Case rollout 必须同时控制创建门与 Agent deployment mode，并验证运行容器的实际环境；仅有 `readyForNewCases=true` 不再视为新对话 Renderer 已启用的充分证据。
 - 相关记录：BUG-085、BUG-086、BUG-087
 - 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`
diff --git a/frontend/tests/staging-backend-workflows.test.ts b/frontend/tests/staging-backend-workflows.test.ts
index 2a94a8b7..a9bde16d 100644
--- a/frontend/tests/staging-backend-workflows.test.ts
+++ b/frontend/tests/staging-backend-workflows.test.ts
@@ -458,7 +458,8 @@ test("public rectification rollout enables the semantic agent and recreates web
     [
       "#!/usr/bin/env bash",
       'if [ "$1" = ps ]; then echo web-container; exit 0; fi',
-      `if [ "$1" = inspect ]; then echo ghcr.io/jesse-ux/jyotisha-web@sha256:${"b".repeat(64)}; exit 0; fi`,
+      `if [ "$1" = inspect ] && [[ "$*" == *Config.Image* ]]; then echo ghcr.io/jesse-ux/jyotisha-web@sha256:${"b".repeat(64)}; exit 0; fi`,
+      'if [ "$1" = inspect ] && [[ "$*" == *Config.Env* ]]; then printf "%s\n" RECTIFICATION_AGENT_V5_ENABLED=true RECTIFICATION_AGENT_V5_SHADOW=false RECTIFICATION_AGENT_V5_CANARY_PERCENT=100; exit 0; fi',
       `printf '%s\n' "$*" >>${join(root, "docker.log")}`,
     ].join("\n"),
   );

From 555e7d9befe9c40410eb614c6f138fc102a75a32 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Wed, 29 Jul 2026 20:30:23 +0800
Subject: [PATCH 05/15] fix: stop rectification question template fallback

---
 docs/BUG_HISTORY.md                           | 14 +++++
 .../opportunity-builder.ts                    | 33 ++++-------
 .../lib/rectification-agent/renderer-agent.ts | 28 +++++++--
 frontend/tests/rectification-agent-v6.test.ts | 59 +++++++++++++++++++
 .../references/question-policy.md             |  4 ++
 5 files changed, 113 insertions(+), 25 deletions(-)

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 9ae1bb04..734e0022 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1648,3 +1648,17 @@
 - 防复发：公开 Case rollout 必须同时控制创建门与 Agent deployment mode，并验证运行容器的实际环境；仅有 `readyForNewCases=true` 不再视为新对话 Renderer 已启用的充分证据。
 - 相关记录：BUG-085、BUG-086、BUG-087
 - 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`
+
+## BUG-092 | Semantic Renderer 成功后仍被静默替换成固定领域模板
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：V6 `ask_new_event` Opportunity 排序、问题验证、Renderer telemetry 与 staging 用户可见下一问
+- 用户现象：用户提交“2020 年 4 月去石油化工研究院实习做研究员”后，系统仍显示“承接……请再说一件……哪次搬家、离乡或长期迁居……”，像固定问卷。
+- 根因：Builder 将最近六轮答案拼接为当前主题，使较早教育事件中的“离家/外地”再次提升 relocation，同时未覆盖领域奖励在已经满足最小领域数后仍占主导；Renderer 对自然 `new_dated_event` 问法使用过窄词面校验，校验失败后静默替换为 Builder 固定 fallback，telemetry 仍记为 `renderer succeeded`。
+- 修复：当前主题只读取最新回答或最新事件；达到两个可评分领域后显著降低纯领域覆盖收益并提高最新主题连续性；移除“承接……请再说一件……”拼接，fallback 改为锚定当前经历的单句问题；放宽自然新事件词面但继续执行单问题、锚点、内部信息和出生分钟安全校验；validator 回退单独记录 `renderer rejected` 与脱敏错误码。
+- 验证：真实两事件重放断言 career 机会优先于旧 relocation 关键词、月份不被细化、旧固定模板被拒绝、锚定研究院实习的自然问题被保留且不等于 fallback；完整前端、lint、TypeScript、Python V5 与 staging smoke 随发布记录执行。
+- 防复发：模型调用成功、Schema 成功和问题被接受必须分开观测；Opportunity utility 不得把历史关键词与“未覆盖领域”组合成伪装的固定轮询。
+- 相关记录：BUG-086、BUG-090、BUG-091
+- 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`
diff --git a/frontend/src/lib/rectification-agent/opportunity-builder.ts b/frontend/src/lib/rectification-agent/opportunity-builder.ts
index 0a88ea5c..b505ebce 100644
--- a/frontend/src/lib/rectification-agent/opportunity-builder.ts
+++ b/frontend/src/lib/rectification-agent/opportunity-builder.ts
@@ -11,17 +11,17 @@ const forbiddenMoves: SemanticQuestionOpportunity["forbiddenMoves"] = [
 
 const domainPolicy: Readonly<Record<Exclude<EvidenceDomain, "family" | "other">, Readonly<{
   goal: string;
-  fallbackPrompt: string;
+  fallbackPrompt: (anchor: string | null) => string;
   keywords: RegExp;
   recallEase: number;
   privacyCost: number;
 }>>> = {
-  education: { goal: "收集一件有大致日期的教育转折。", fallbackPrompt: "哪次入学、毕业或专业变化的时间你比较确定？", keywords: /大学|学校|入学|毕业|考试|专业|读书/, recallEase: .82, privacyCost: .03 },
-  relocation: { goal: "收集一件有大致日期的迁居经历。", fallbackPrompt: "哪次搬家、离乡或长期迁居的时间你比较确定？", keywords: /搬家|迁居|离家|外地|城市|北京|上海|出国/, recallEase: .78, privacyCost: .04 },
-  relationship: { goal: "在用户愿意的前提下收集一件有大致日期的关系转折。", fallbackPrompt: "如果方便，哪段关系开始、结束或进入婚姻的时间比较确定？", keywords: /恋爱|关系|结婚|离婚|分手|伴侣|对象/, recallEase: .62, privacyCost: .22 },
-  career: { goal: "收集一件有大致日期的职业转折。", fallbackPrompt: "哪次入职、离职、转行、创业或职责变化的时间你比较确定？", keywords: /工作|实习|公司|研究院|职业|入职|离职|创业|负责/, recallEase: .85, privacyCost: .03 },
-  finance: { goal: "在用户愿意的前提下收集一件有大致日期的财务转折。", fallbackPrompt: "如果方便，哪次收入、负债或资产明显变化的时间比较确定？", keywords: /收入|负债|投资|资产|财务|买房|卖房/, recallEase: .6, privacyCost: .18 },
-  health_pressure: { goal: "在用户愿意的前提下收集一件本人有大致日期的健康转折。", fallbackPrompt: "如果方便，你本人哪次住院、手术、事故或健康转折的时间比较确定？", keywords: /住院|手术|事故|健康|生病|确诊|康复/, recallEase: .58, privacyCost: .28 },
+  education: { goal: "收集一件有大致日期的教育转折。", fallbackPrompt: (anchor) => anchor ? `在“${anchor}”之外，你还记得哪次入学、毕业或专业变化大概发生在哪年哪月？` : "你还记得哪次入学、毕业或专业变化大概发生在哪年哪月？", keywords: /大学|学校|入学|毕业|考试|专业|读书/, recallEase: .82, privacyCost: .03 },
+  relocation: { goal: "收集一件有大致日期的迁居经历。", fallbackPrompt: (anchor) => anchor ? `以“${anchor}”为时间参照，你哪次搬到新城市或长期离乡的年月最确定？` : "你哪次搬到新城市或长期离乡的年月最确定？", keywords: /搬家|迁居|离家|外地|城市|北京|上海|出国/, recallEase: .78, privacyCost: .04 },
+  relationship: { goal: "在用户愿意的前提下收集一件有大致日期的关系转折。", fallbackPrompt: (anchor) => anchor ? `说到“${anchor}”这段时期，如果你愿意，哪次关系变化的大概年月还记得？` : "如果你愿意，哪次关系变化的大概年月还记得？", keywords: /恋爱|关系|结婚|离婚|分手|伴侣|对象/, recallEase: .62, privacyCost: .22 },
+  career: { goal: "收集一件有大致日期的职业转折。", fallbackPrompt: (anchor) => anchor ? `在“${anchor}”之后，哪次工作或职责明显变化的年月你还记得？` : "哪次工作或职责明显变化的年月你还记得？", keywords: /工作|实习|公司|研究院|职业|入职|离职|创业|负责/, recallEase: .85, privacyCost: .03 },
+  finance: { goal: "在用户愿意的前提下收集一件有大致日期的财务转折。", fallbackPrompt: (anchor) => anchor ? `以“${anchor}”为时间参照，如果方便，哪次财务状况明显变化的年月你还记得？` : "如果方便，哪次财务状况明显变化的年月你还记得？", keywords: /收入|负债|投资|资产|财务|买房|卖房/, recallEase: .6, privacyCost: .18 },
+  health_pressure: { goal: "在用户愿意的前提下收集一件本人有大致日期的健康转折。", fallbackPrompt: (anchor) => anchor ? `说到“${anchor}”前后，如果方便，你本人哪次健康变化的大概年月还记得？` : "如果方便，你本人哪次健康变化的大概年月还记得？", keywords: /住院|手术|事故|健康|生病|确诊|康复/, recallEase: .58, privacyCost: .28 },
 };
 
 function stableUuid(value: string): string {
@@ -70,10 +70,6 @@ function anchorFor(event: LifeEventRevision): string {
   return event.summary.replace(/[“”"']/g, "").trim().slice(0, 80);
 }
 
-function recentText(turns: readonly RectificationV4Turn[]): string {
-  return turns.slice(-6).map((turn) => turn.answer).join(" ");
-}
-
 function declinedSensitiveDomains(turns: readonly RectificationV4Turn[]): ReadonlySet<EvidenceDomain> {
   const result = new Set<EvidenceDomain>();
   for (const turn of turns) {
@@ -98,7 +94,8 @@ export function buildQuestionOpportunities(input: Readonly<{
   const retryTargets = new Set(input.retryTargetEventIds ?? []);
   const scoreableDomains = new Set(input.events.filter((event) => event.scoreability === "scoreable").map((event) => event.domain));
   const refusedDomains = declinedSensitiveDomains(input.turns);
-  const latestContext = recentText(input.turns);
+  const latestEvent = chronologicalEvents(input.events).at(-1);
+  const latestContext = input.turns.at(-1)?.answer ?? latestEvent?.rawText ?? "";
   const opportunities: QuestionOpportunity[] = [];
 
   if (input.targetDisposition === "answered_other_event") {
@@ -182,25 +179,21 @@ export function buildQuestionOpportunities(input: Readonly<{
   }
 
   const scoreableCount = input.events.filter((event) => event.scoreability === "scoreable").length;
-  const latestEvent = chronologicalEvents(input.events).at(-1);
   for (const [domain, policy] of Object.entries(domainPolicy) as [Exclude<EvidenceDomain, "family" | "other">, (typeof domainPolicy)[Exclude<EvidenceDomain, "family" | "other">]][]) {
     if (refusedDomains.has(domain)) continue;
     const covered = scoreableDomains.has(domain);
-    const themeBonus = policy.keywords.test(latestContext) ? .12 : 0;
+    const themeBonus = policy.keywords.test(latestContext) ? .22 : 0;
     const alreadyAsked = input.turns.some((turn) => turn.questionDomain === domain && !turn.questionTargetEventId);
     const latestAnchor = latestEvent ? anchorFor(latestEvent) : null;
-    const prompt = latestAnchor
-      ? `承接“${latestAnchor}”，请再说一件时间相对明确的经历：${policy.fallbackPrompt}`
-      : policy.fallbackPrompt;
     opportunities.push(opportunity(input.caseId, {
       kind: "ask_new_event", domain, targetEventId: null, goal: policy.goal,
       requestedFields: ["new_dated_event"], anchors: latestAnchor ? [latestAnchor] : [],
       contextFacts: [`已有 ${scoreableCount} 件可评分事件。`, `该领域${covered ? "已有覆盖" : "尚未覆盖"}。`],
-      fallbackPrompt: prompt, reason: covered ? "继续收集可区分候选的独立事件。" : "补足证据领域覆盖。",
-      expectedInformationGain: covered ? .54 + themeBonus : .7 + themeBonus,
+      fallbackPrompt: policy.fallbackPrompt(latestAnchor), reason: covered ? "继续收集可区分候选的独立事件。" : "补足证据领域覆盖。",
+      expectedInformationGain: covered ? .54 + themeBonus : .65 + themeBonus / 2,
       dateSensitivity: input.snapshot ? .5 : .35,
       candidateSplitRelevance: input.diagnostics?.candidateSplits.length ? .58 : .42,
-      domainCoverageGain: covered ? 0 : 1,
+      domainCoverageGain: covered ? 0 : scoreableDomains.size < 2 ? 1 : .15,
       recallEase: policy.recallEase, novelty: alreadyAsked ? .35 : .9,
       repetitionPenalty: alreadyAsked ? .3 : 0, privacyCost: policy.privacyCost,
     }));
diff --git a/frontend/src/lib/rectification-agent/renderer-agent.ts b/frontend/src/lib/rectification-agent/renderer-agent.ts
index e2d0d2c7..5aa2d6f0 100644
--- a/frontend/src/lib/rectification-agent/renderer-agent.ts
+++ b/frontend/src/lib/rectification-agent/renderer-agent.ts
@@ -11,6 +11,7 @@ const bannedAcknowledgement = /(?:这个信息很有用|它不是单纯的|而
 const overinterpretedAcknowledgement = /(?:职业方向正式落地|人生意义|意味着你|说明你(?:已经|开始|正式)|标志着你)/;
 const internalTerms = /(?:opportunityId|snapshotId|eventId|targetEventId|requestedFields|fallbackPrompt|tool\s*call|tool_call|score|评分|模型名|opportunity|snapshot|D\d{1,2}|KP\b|Vimshottari)/i;
 const multiQuestionMoves = /(?:另外|还有|同时再说|并且告诉我|顺便|再告诉我)/;
+const cannedQuestion = /(?:承接[“\"']?.{0,80}[”\"']?，?请再说一件|接下来请继续讲另一件|我会顺着你的叙述继续核对)/;
 const exactClockMinute = /(?:[01]?\d|2[0-3])[:：][0-5]\d|(?:[零〇一二两三四五六七八九十]{1,3}|(?:[01]?\d|2[0-3]))点(?:[零〇一二两三四五六七八九十]{1,3}|[0-5]?\d)分/;
 const exactMinuteClaim = /(?:唯一|准确|精确|确切|确认|确定|代表).{0,12}(?:出生|生时)?(?:时间|时刻|分钟)|(?:出生|生时)(?:时间|时刻|分钟)?.{0,12}(?:唯一|准确|精确|确切|确认|确定|代表|就是)/;
 
@@ -34,6 +35,16 @@ function normalized(value: string): string {
   return value.normalize("NFKC").replace(/[“”"'\s，,。.!！?？:：；;]/g, "");
 }
 
+function includesAnchor(question: string, anchor: string): boolean {
+  const normalizedQuestion = normalized(question);
+  const normalizedAnchor = normalized(anchor);
+  if (normalizedQuestion.includes(normalizedAnchor)) return true;
+  for (let start = 0; start <= normalizedAnchor.length - 4; start += 1) {
+    if (normalizedQuestion.includes(normalizedAnchor.slice(start, start + 4))) return true;
+  }
+  return false;
+}
+
 function visibleTextSafetyIssues(value: string): string[] {
   const issues: string[] = [];
   if (internalTerms.test(value)) issues.push("internal_information_exposed");
@@ -51,9 +62,9 @@ export function validateQuestionRealization(question: unknown, opportunity: Ques
   if (/\n\s*(?:[-*•]|\d+[.)、])/.test(value)) issues.push("question_list_forbidden");
   issues.push(...visibleTextSafetyIssues(value));
   if (multiQuestionMoves.test(value)) issues.push("multiple_question_instruction");
-  if (opportunity.targetEventId) {
-    const questionText = normalized(value);
-    if (!opportunity.anchors.some((anchor) => questionText.includes(normalized(anchor)))) issues.push("target_anchor_missing");
+  if (cannedQuestion.test(value)) issues.push("canned_question_forbidden");
+  if (opportunity.targetEventId || (opportunity.kind === "ask_new_event" && opportunity.anchors.length > 0)) {
+    if (!opportunity.anchors.some((anchor) => includesAnchor(value, anchor))) issues.push("target_anchor_missing");
   }
   for (const field of opportunity.requestedFields) {
     if (field === "event_subject" && !/(?:本人|你自己|家人|伴侣|配偶)/.test(value)) issues.push("event_subject_not_requested");
@@ -61,7 +72,7 @@ export function validateQuestionRealization(question: unknown, opportunity: Ques
     if (field === "event_day" && !/(?:哪一天|几号|具体日期|大概日期)/.test(value)) issues.push("event_day_not_requested");
     if (field === "event_range" && !/(?:大概时间|时间范围|什么时候|哪个时间|哪一段时间)/.test(value)) issues.push("event_range_not_requested");
     if (field === "event_stage" && !/(?:开始|高峰|结束|正式发生)/.test(value)) issues.push("event_stage_not_requested");
-    if (field === "new_dated_event" && !/(?:哪次|哪件|一件|经历)/.test(value)) issues.push("new_event_not_requested");
+    if (field === "new_dated_event" && !/(?:哪次|哪件|一件|经历|变化|转折|发生)/.test(value)) issues.push("new_event_not_requested");
     if (field === "new_dated_event" && !/(?:时间|日期|什么时候|哪年|哪月|几月)/.test(value)) issues.push("new_event_date_not_requested");
     if (field === "event_year" && !/(?:哪年|年份|哪一年)/.test(value)) issues.push("event_year_not_requested");
   }
@@ -172,7 +183,14 @@ export async function renderPublicTurn(input: Readonly<{
         forbiddenMoves: opportunity.forbiddenMoves,
       } : null,
     }), { abortSignal: AbortSignal.timeout(input.timeoutMs ?? 15_000), structuredOutput: { schema: publicMessageSchema, jsonPromptInjection: "inline" } });
-    const message = realizePublicMessage(result.object, input);
+    const generated = publicMessageSchema.parse(result.object);
+    const questionValidation = opportunity ? validateQuestionRealization(generated.question, opportunity) : null;
+    const message = realizePublicMessage(generated, input);
+    if (questionValidation && !questionValidation.valid) {
+      recordRectificationAgentTelemetry({ caseId: input.caseValue.id, phase: "renderer", outcome: "rejected", modelId: selected.id, toolName: null, decisionAction: input.validated.decision.action, durationMs: Date.now() - started, errorCode: questionValidation.issues[0] ?? "renderer_question_rejected", deploymentSha });
+      recordRectificationAgentTelemetry({ caseId: input.caseValue.id, phase: "fallback", outcome: "succeeded", modelId: selected.id, toolName: null, decisionAction: input.validated.decision.action, durationMs: Date.now() - started, errorCode: "renderer_question_rejected", deploymentSha });
+      return message;
+    }
     recordRectificationAgentTelemetry({ caseId: input.caseValue.id, phase: "renderer", outcome: "succeeded", modelId: selected.id, toolName: null, decisionAction: input.validated.decision.action, durationMs: Date.now() - started, errorCode: null, deploymentSha });
     return message;
   } catch {
diff --git a/frontend/tests/rectification-agent-v6.test.ts b/frontend/tests/rectification-agent-v6.test.ts
index d95ab428..98c4192b 100644
--- a/frontend/tests/rectification-agent-v6.test.ts
+++ b/frontend/tests/rectification-agent-v6.test.ts
@@ -191,6 +191,65 @@ test("Builder 的领域排序不受事件输入数组顺序影响", () => {
   assert.deepEqual(domains([education, career]), domains([career, education]));
 });
 
+test("研究院实习后优先延续最新主题，不被旧教育事件的离家关键词拉回迁居问卷", () => {
+  const education = event({
+    summary: "离家去外地上大学",
+    rawText: "2016年9月离家去外地上大学",
+    createdAt: "2026-07-29T01:00:00.000Z",
+  });
+  const career = event({
+    domain: "career",
+    eventKind: "career_change",
+    summary: "去石油化工研究院实习做研究员",
+    rawText: "2020年4月去石油化工研究院实习做研究员",
+    dateRange: { start: "2020-04-01", end: "2020-04-30", precision: "month", label: "2020年4月" },
+    createdAt: "2026-07-29T02:00:00.000Z",
+  });
+  const opportunities = buildQuestionOpportunities({
+    caseId,
+    events: [education, career],
+    turns: [
+      turn({ answer: education.rawText, createdAt: "2026-07-29T01:00:00.000Z" }),
+      turn({ answer: career.rawText, createdAt: "2026-07-29T02:00:00.000Z" }),
+    ],
+    snapshot: null,
+    diagnostics: null,
+  });
+
+  assert.equal(opportunities.some((item) => item.kind === "refine_event_date"), false);
+  assert.equal(opportunities[0]?.kind, "ask_new_event");
+  assert.equal(opportunities[0]?.domain, "career");
+  assert.match(opportunities[0]?.fallbackPrompt ?? "", /研究院实习/);
+  assert.doesNotMatch(opportunities[0]?.fallbackPrompt ?? "", /承接.*请再说一件|哪次搬家、离乡或长期迁居/);
+});
+
+test("Renderer 接受锚定最新事件的自然新事件问题并拒绝旧固定模板", () => {
+  const latest = event({
+    domain: "career",
+    eventKind: "career_change",
+    summary: "去石油化工研究院实习做研究员",
+    rawText: "2020年4月去石油化工研究院实习做研究员",
+    dateRange: { start: "2020-04-01", end: "2020-04-30", precision: "month", label: "2020年4月" },
+  });
+  const opportunity = buildQuestionOpportunities({ caseId, events: [latest], turns: [turn({ answer: latest.rawText })], snapshot: null, diagnostics: null })
+    .find((item) => item.kind === "ask_new_event" && item.domain === "career");
+  assert.ok(opportunity);
+  const naturalQuestion = "研究院实习之后，下一次工作发生明显变化大概是什么时候？";
+  const canned = `承接“${latest.summary}”，请再说一件时间相对明确的经历：哪次工作变化的时间你比较确定？`;
+  assert.equal(validateQuestionRealization(naturalQuestion, opportunity).valid, true);
+  assert.equal(validateQuestionRealization(canned, opportunity).valid, false);
+  const message = realizePublicMessage({ acknowledgement: `你提到的是“${latest.summary}”。`, candidateUpdate: null, limitation: null, question: naturalQuestion }, {
+    latestAnswer: latest.rawText,
+    acceptedEvents: [latest],
+    pendingEvidence: [],
+    snapshot: null,
+    previousSnapshot: null,
+    validated: validated(opportunity),
+  });
+  assert.equal(message.question, naturalQuestion);
+  assert.notEqual(message.question, opportunity.fallbackPrompt);
+});
+
 test("Builder 和 Reasoner 按事件创建时间承接最近经历而不是 UUID 顺序", () => {
   const older = event({
     eventId: "ffffffff-ffff-4fff-8fff-ffffffffffff",
diff --git a/skills/birth-time-rectification/references/question-policy.md b/skills/birth-time-rectification/references/question-policy.md
index b09f4fdc..c88af13d 100644
--- a/skills/birth-time-rectification/references/question-policy.md
+++ b/skills/birth-time-rectification/references/question-policy.md
@@ -6,6 +6,8 @@ Question opportunities describe meaning, not final prose. New opportunities use
 
 The builder produces several candidates and publishes at most five active opportunities. Rank them by evidence and context: expected information gain, candidate-split relevance, date sensitivity, domain coverage, recent user topics, recall ease, novelty, repetition penalty, and privacy cost. Never select the first missing domain from a fixed education/relocation/relationship/career/finance/health sequence.
 
+Use the latest answer and latest accepted event as the current topic. Do not let keywords from older turns pull the conversation back to a stale domain, and do not give an uncovered domain both a coverage reward and a second topic reward from the same older event. Once the minimum domain coverage is already present, continuity and information gain should outweigh collecting another domain merely because it is missing.
+
 ## One-turn rule
 
 - Ask one question only.
@@ -14,6 +16,8 @@ The builder produces several candidates and publishes at most five active opport
 - Do not ask a list of questions or combine a clarification with a new-domain request.
 - Do not invent an event or date.
 - Do not expose IDs, fields, scores, tools, models, or technique traces.
+- Reject canned realizations such as `承接……请再说一件……`; a deterministic fallback must still read as one short contextual question.
+- Validate the question semantically. Natural wording such as “下一次明显变化大概发生在什么时候” must not be rejected only because it omits a fixed phrase such as `哪次` or `哪件`.
 
 ## Target disposition
 

From a5f409a500b42cf568023af5acd537580f9c2434 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Wed, 29 Jul 2026 22:49:17 +0800
Subject: [PATCH 06/15] fix: align rectification spec hashes across runtimes

---
 docs/BUG_HISTORY.md                      | 14 ++++++++++++++
 scripts/rectification/scoring_service.py |  7 ++++++-
 tests/test_rectification_v5_services.py  | 15 ++++++++++++++-
 3 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 734e0022..b6d279c8 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1662,3 +1662,17 @@
 - 防复发：模型调用成功、Schema 成功和问题被接受必须分开观测；Opportunity utility 不得把历史关键词与“未覆盖领域”组合成伪装的固定轮询。
 - 相关记录：BUG-086、BUG-090、BUG-091
 - 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`
+
+## BUG-093 | 首次候选评分因跨语言计算规格哈希不一致而失败
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：V5 Candidate Engine 首次达到三事件评分门后的 Feature Snapshot 原子持久化
+- 用户现象：第三件可评分事件已经保存在 Turn，但 Worker 最终显示“这次比较没有完成，回答已经保留，请再试一次”，Case 恢复上一问题且没有写入新事件。
+- 根因：服务器创建 Case 时由 TypeScript 对整数时区 `8` 计算规格哈希；Python 请求归一化把它变成浮点数 `8.0`，而 Python JSON 序列化保留 `.0`。两个运行时对语义相同的规格得到不同哈希，完成事务因此拒绝 Feature Snapshot 并抛出 `rectification_v5_feature_snapshot_mismatch`。
+- 修复：Python 生成跨服务 Calculation Spec 时将整数值的经纬度和时区规范化为整数，使其 JSON 数字表示与 TypeScript `JSON.stringify` 一致；评分算法和候选矩阵不变。
+- 验证：新增已知 TypeScript 哈希向量测试，修复前稳定失败、修复后通过；staging Case `e2d3e1d2-efb0-461d-9914-f890bc2b8569` 的 PostgreSQL 日志确认原始异常，使用同一规格重放确认 Python Feature Snapshot 哈希恢复为 Case 哈希。
+- 防复发：跨语言持久化指纹必须使用已知向量验证 JSON 数字规范化，不能只在各自语言内断言自洽。
+- 相关记录：BUG-087、BUG-092
+- 修复版本：`rectification-v5-matrix-scoring-1`（仅修复输入规范化，算法版本不变）
diff --git a/scripts/rectification/scoring_service.py b/scripts/rectification/scoring_service.py
index 6f119573..84a2816f 100644
--- a/scripts/rectification/scoring_service.py
+++ b/scripts/rectification/scoring_service.py
@@ -150,11 +150,16 @@ def score_from_matrix(request: RectificationRequest, built: dict[str, Any]) -> l
 
 
 def calculation_spec(request: RectificationRequest) -> dict[str, Any]:
+    def json_number(value: float) -> int | float:
+        return int(value) if value.is_integer() else value
+
     return {
         "version": INPUT_CONTRACT_VERSION,
         "birthDate": request["birth_date"],
         "candidateRange": {"start": request["start_time"], "end": request["end_time"]},
-        "latitude": request["lat"], "longitude": request["lon"], "timezoneOffsetHours": request["tz"],
+        "latitude": json_number(request["lat"]),
+        "longitude": json_number(request["lon"]),
+        "timezoneOffsetHours": json_number(request["tz"]),
         "ayanamsa": "lahiri", "nodeMode": "mean", "minuteStep": 1,
     }
 
diff --git a/tests/test_rectification_v5_services.py b/tests/test_rectification_v5_services.py
index 76bd1224..60364f0e 100644
--- a/tests/test_rectification_v5_services.py
+++ b/tests/test_rectification_v5_services.py
@@ -6,7 +6,13 @@ from unittest.mock import patch
 
 from scripts.rectification.api_service import diagnostics, score_candidates
 from scripts.rectification.contracts import normalize_rectification_request
-from scripts.rectification.scoring_service import build_event_contribution_matrix, sample_event_dates, score_from_matrix
+from scripts.rectification.scoring_service import (
+    build_event_contribution_matrix,
+    calculation_spec,
+    sample_event_dates,
+    score_from_matrix,
+    sha256,
+)
 from scripts.jyotish_api_server import (
     API_COMMAND_MAP,
     TECHNIQUE_EXAMPLE_ENDPOINTS,
@@ -38,6 +44,13 @@ def request(*, precision: str = "month", event_kind: str = "education_milestone"
 
 
 class RectificationV5ServicesTest(unittest.TestCase):
+    def test_calculation_spec_hash_matches_typescript_for_integral_timezone(self):
+        normalized = normalize_rectification_request(request(), today=date(2026, 7, 28))
+        self.assertEqual(
+            sha256(calculation_spec(normalized)),
+            "f05fe0f56ef9ba2b18ec3c6c54f1649f06f1ae5a926491a5c5f676d718d92865",
+        )
+
     def test_shared_validator_rejects_family_and_non_self_health_scoring(self):
         with self.assertRaisesRegex(ValueError, "domain is not scoreable"):
             normalize_rectification_request(request(domain="family", event_kind="family_bereavement"), today=date(2026, 7, 28))

From 0a5b8cd23930e8ffe93d8779519977523cacfa12 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Thu, 30 Jul 2026 00:41:48 +0800
Subject: [PATCH 07/15] fix: restore rectification agent message actions

---
 docs/BUG_HISTORY.md                           |  16 +++
 .../v4/cases/[caseId]/regenerate/route.ts     |  22 ++++
 .../src/components/rectification-v4-panel.tsx | 118 +++++++++++++++++-
 frontend/src/hooks/use-rectification-v4.ts    |   4 +
 .../lib/rectification-agent/renderer-agent.ts |  41 ++++++
 .../src/lib/rectification-v4/case-service.ts  |  35 ++++++
 frontend/src/lib/rectification-v4/client.ts   |   6 +
 .../src/lib/rectification-v4/memory-store.ts  |  31 +++++
 frontend/src/lib/rectification-v4/store.ts    |   9 ++
 .../lib/rectification-v4/supabase-store.ts    |  22 ++++
 ...ation_v4_current_question_regeneration.sql |  80 ++++++++++++
 ...ersational-rectification-component.test.ts |  47 ++++++-
 .../conversational-visible-narrative.test.ts  |   3 +-
 .../tests/rectification-v4-migration.test.ts  |  14 +++
 .../tests/rectification-v4-service.test.ts    |  69 ++++++++++
 15 files changed, 513 insertions(+), 4 deletions(-)
 create mode 100644 frontend/src/app/api/rectification/v4/cases/[caseId]/regenerate/route.ts
 create mode 100644 frontend/supabase/migrations/20260729020000_rectification_v4_current_question_regeneration.sql

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index b6d279c8..5e4ae6c7 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1676,3 +1676,19 @@
 - 防复发：跨语言持久化指纹必须使用已知向量验证 JSON 数字规范化，不能只在各自语言内断言自洽。
 - 相关记录：BUG-087、BUG-092
 - 修复版本：`rectification-v5-matrix-scoring-1`（仅修复输入规范化，算法版本不变）
+
+## BUG-094 | V5 Agent 消息操作栏在 V4 面板切换后消失
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：生时校正 V5 Agent 对话、助手消息反馈与当前问题重新生成
+- 用户现象：助手消息气泡下不再显示点赞、点踩、复制和重新生成操作。
+- 触发条件：生时校正页面使用 `RectificationV4Panel` 渲染 V5 Agent 会话。
+- 根因：旧对话组件中的消息操作栏没有迁入 V4/V5 共用面板，同时新 V4 API 没有与当前语义问题绑定的重新生成命令。
+- 修复：复用现有消息操作栏样式，仅为 `v5_agent` 的稳定助手消息恢复操作；重新生成只重写当前已验证 Semantic Question Opportunity 的自然语言实现，并通过用户、Case 版本、当前目标和 action ID 原子校验，不重跑事件提取、候选评分、诊断或 Job。
+- 验证：组件资格与反馈互斥测试、V4 service 幂等重放与数据不变量测试、Renderer 安全回落测试、迁移契约测试，以及 staging 精确 SHA 部署和浏览器验收。
+- 防复发：测试锁定 V5 Agent 操作栏、仅当前问题可重跑、legacy/shadow 不启用新 Renderer、重跑不改变 turns/events/snapshots/profile 且 completed Job 不被改写。
+- 相关记录：BUG-090、BUG-091、BUG-092、BUG-093
+- 复发自：无
+- 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`
diff --git a/frontend/src/app/api/rectification/v4/cases/[caseId]/regenerate/route.ts b/frontend/src/app/api/rectification/v4/cases/[caseId]/regenerate/route.ts
new file mode 100644
index 00000000..d98398c6
--- /dev/null
+++ b/frontend/src/app/api/rectification/v4/cases/[caseId]/regenerate/route.ts
@@ -0,0 +1,22 @@
+import { NextResponse } from "next/server";
+import { caseActionRequestSchema } from "@/lib/rectification-v4/contracts";
+import { rectificationV4Context, rectificationV4Error, requestBody, routeId } from "../../../_server";
+
+export const runtime = "nodejs";
+
+export async function POST(request: Request, { params }: { params: Promise<{ caseId: string }> }) {
+  try {
+    const body = await requestBody(request, caseActionRequestSchema);
+    const context = await rectificationV4Context();
+    const result = await context.service.regenerateQuestion({
+      ...body,
+      userId: context.userId,
+      caseId: routeId((await params).caseId),
+    });
+    return result
+      ? NextResponse.json(result)
+      : NextResponse.json({ error: "当前问题不能重新生成，请刷新后重试。" }, { status: 409 });
+  } catch (error) {
+    return rectificationV4Error(error);
+  }
+}
diff --git a/frontend/src/components/rectification-v4-panel.tsx b/frontend/src/components/rectification-v4-panel.tsx
index 53b64b3b..8a42dcb5 100644
--- a/frontend/src/components/rectification-v4-panel.tsx
+++ b/frontend/src/components/rectification-v4-panel.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { ArrowUp } from "lucide-react";
+import { ArrowUp, Check, Copy, RotateCcw, ThumbsDown, ThumbsUp } from "lucide-react";
 import { useEffect, useRef, useState } from "react";
 import { useRectificationV4 } from "@/hooks/use-rectification-v4";
 import type { ChatMessageView } from "@/lib/chat-message-view";
@@ -29,6 +29,28 @@ type RectificationV4PanelProps = Readonly<{
   onContinueOriginalQuestion?: (continuation: RectificationV4Continuation) => void;
 }>;
 
+export function toggleRectificationFeedback(
+  current: "up" | "down" | undefined,
+  requested: "up" | "down",
+): "up" | "down" | undefined {
+  return current === requested ? undefined : requested;
+}
+
+export function canRegenerateRectificationMessage(input: Readonly<{
+  message: ChatMessageView;
+  currentMessageKey: string | null;
+  deploymentMode: RectificationV4ApiResponse["case"]["deploymentMode"] | null;
+  busy: boolean;
+  canAnswer: boolean;
+}>): boolean {
+  return input.deploymentMode === "v5_agent"
+    && input.message.role === "assistant"
+    && input.message.state === "settled"
+    && input.message.renderKey === input.currentMessageKey
+    && !input.busy
+    && input.canAnswer;
+}
+
 export function rectificationV4ChatMessages(
   data: RectificationV4ApiResponse | null,
   processing: boolean,
@@ -129,6 +151,9 @@ export function RectificationV4Panel(props: RectificationV4PanelProps) {
     onPendingChange: props.onPendingChange,
   });
   const [draft, setDraft] = useState("");
+  const [feedback, setFeedback] = useState<Record<string, "up" | "down" | undefined>>({});
+  const [copiedMessageKey, setCopiedMessageKey] = useState<string | null>(null);
+  const [regeneratingMessageKey, setRegeneratingMessageKey] = useState<string | null>(null);
   const composer = useRef<HTMLTextAreaElement>(null);
   const conversationEnd = useRef<HTMLDivElement>(null);
   const caseValue = controller.data?.case;
@@ -145,6 +170,10 @@ export function RectificationV4Panel(props: RectificationV4PanelProps) {
     && !processing
     && !controller.pending
     && ["awaiting_answer", "range_ready"].includes(caseValue?.status ?? "");
+  const currentMessageKey = caseValue?.currentQuestion
+    ? `rectification-current-${caseValue.currentQuestion.id}`
+    : null;
+  const busy = processing || controller.pending || regeneratingMessageKey !== null;
   const canAcceptRange = caseValue?.status === "range_ready"
     && Boolean(caseValue.latestSnapshot?.canAcceptRange)
     && !caseValue.acceptedRange;
@@ -174,6 +203,27 @@ export function RectificationV4Panel(props: RectificationV4PanelProps) {
     if (result) setDraft("");
   }
 
+  async function copyMessage(message: ChatMessageView) {
+    try {
+      await navigator.clipboard.writeText(message.text);
+      setCopiedMessageKey(message.renderKey);
+      window.setTimeout(() => setCopiedMessageKey((current) => (
+        current === message.renderKey ? null : current
+      )), 1_500);
+    } catch {
+      // Clipboard permission failures must not interrupt the conversation.
+    }
+  }
+
+  async function regenerateMessage(messageKey: string) {
+    setRegeneratingMessageKey(messageKey);
+    try {
+      await controller.regenerate();
+    } finally {
+      setRegeneratingMessageKey((current) => current === messageKey ? null : current);
+    }
+  }
+
   function continueOriginalQuestion() {
     if (!caseValue?.acceptedRange || !handoff) return;
     props.onContinueOriginalQuestion?.({
@@ -189,7 +239,71 @@ export function RectificationV4Panel(props: RectificationV4PanelProps) {
     <>
       <section className="conversation" aria-label="生时校正对话" aria-busy={processing || controller.pending}>
         <div className="message-list" aria-live="polite">
-          {messages.map((message) => <ChatMessageRow key={message.renderKey} message={message} />)}
+          {messages.map((message) => {
+            const showActions = caseValue?.deploymentMode === "v5_agent"
+              && message.role === "assistant"
+              && message.state === "settled"
+              && Boolean(message.text);
+            const regenerating = regeneratingMessageKey === message.renderKey;
+            const canRegenerate = canRegenerateRectificationMessage({
+              message,
+              currentMessageKey,
+              deploymentMode: caseValue?.deploymentMode ?? null,
+              busy,
+              canAnswer,
+            });
+            return (
+              <div className="rectification-message-entry" key={message.renderKey}>
+                <ChatMessageRow message={regenerating
+                  ? { ...message, text: "", state: "thinking" }
+                  : message} />
+                {showActions && !regenerating && (
+                  <div className="rectification-message-actions" aria-label="Agent 回答操作">
+                    <button
+                      aria-label="赞"
+                      aria-pressed={feedback[message.renderKey] === "up"}
+                      className={feedback[message.renderKey] === "up" ? "is-active" : ""}
+                      title="赞"
+                      type="button"
+                      onClick={() => setFeedback((current) => ({
+                        ...current,
+                        [message.renderKey]: toggleRectificationFeedback(current[message.renderKey], "up"),
+                      }))}
+                    >
+                      <ThumbsUp aria-hidden="true" />
+                    </button>
+                    <button
+                      aria-label="踩"
+                      aria-pressed={feedback[message.renderKey] === "down"}
+                      className={feedback[message.renderKey] === "down" ? "is-active" : ""}
+                      title="踩"
+                      type="button"
+                      onClick={() => setFeedback((current) => ({
+                        ...current,
+                        [message.renderKey]: toggleRectificationFeedback(current[message.renderKey], "down"),
+                      }))}
+                    >
+                      <ThumbsDown aria-hidden="true" />
+                    </button>
+                    <button aria-label="复制回答" title="复制" type="button" onClick={() => void copyMessage(message)}>
+                      {copiedMessageKey === message.renderKey
+                        ? <Check aria-hidden="true" />
+                        : <Copy aria-hidden="true" />}
+                    </button>
+                    <button
+                      aria-label="重新生成回答"
+                      disabled={!canRegenerate}
+                      title={canRegenerate ? "重新生成" : "只能重新生成当前问题"}
+                      type="button"
+                      onClick={() => void regenerateMessage(message.renderKey)}
+                    >
+                      <RotateCcw aria-hidden="true" />
+                    </button>
+                  </div>
+                )}
+              </div>
+            );
+          })}
           {controller.error && <p className="error-message" role="alert">{controller.error}</p>}
           <div ref={conversationEnd} />
         </div>
diff --git a/frontend/src/hooks/use-rectification-v4.ts b/frontend/src/hooks/use-rectification-v4.ts
index 981a1f9c..abc027d2 100644
--- a/frontend/src/hooks/use-rectification-v4.ts
+++ b/frontend/src/hooks/use-rectification-v4.ts
@@ -16,6 +16,7 @@ import {
   loadRectificationV4,
   loadRectificationV4Handoff,
   loadRectificationV4Job,
+  regenerateRectificationV4Question,
   transitionRectificationV4,
 } from "@/lib/rectification-v4/client";
 
@@ -136,6 +137,9 @@ export function useRectificationV4(input: {
     answer: (answer: string, modelId?: string | null) => data
       ? mutate(() => answerRectificationV4(data.case.id, data.case.version, answer, modelId))
       : Promise.resolve(null),
+    regenerate: () => data
+      ? mutate(() => regenerateRectificationV4Question(data.case.id, data.case.version))
+      : Promise.resolve(null),
     pause: () => data
       ? mutate(() => transitionRectificationV4(data.case.id, data.case.version, "pause"))
       : Promise.resolve(null),
diff --git a/frontend/src/lib/rectification-agent/renderer-agent.ts b/frontend/src/lib/rectification-agent/renderer-agent.ts
index 5aa2d6f0..b7d3ca02 100644
--- a/frontend/src/lib/rectification-agent/renderer-agent.ts
+++ b/frontend/src/lib/rectification-agent/renderer-agent.ts
@@ -1,5 +1,6 @@
 import path from "node:path";
 import { Agent } from "@mastra/core/agent";
+import { z } from "zod";
 import { defaultLanguageModel, resolveLanguageModel } from "@/mastra/model";
 import type { CandidateSnapshot, LifeEventRevision, PendingEvidence, RectificationV4Case } from "../rectification-v4/contracts.ts";
 import { publicMessageSchema, type PublicMessage, type QuestionOpportunity, type ValidatedDecision } from "./contracts.ts";
@@ -14,6 +15,7 @@ const multiQuestionMoves = /(?:另外|还有|同时再说|并且告诉我|顺便
 const cannedQuestion = /(?:承接[“\"']?.{0,80}[”\"']?，?请再说一件|接下来请继续讲另一件|我会顺着你的叙述继续核对)/;
 const exactClockMinute = /(?:[01]?\d|2[0-3])[:：][0-5]\d|(?:[零〇一二两三四五六七八九十]{1,3}|(?:[01]?\d|2[0-3]))点(?:[零〇一二两三四五六七八九十]{1,3}|[0-5]?\d)分/;
 const exactMinuteClaim = /(?:唯一|准确|精确|确切|确认|确定|代表).{0,12}(?:出生|生时)?(?:时间|时刻|分钟)|(?:出生|生时)(?:时间|时刻|分钟)?.{0,12}(?:唯一|准确|精确|确切|确认|确定|代表|就是)/;
+const questionRealizationSchema = z.object({ question: z.string().trim().min(1).max(1_000) }).strict();
 
 function agentFor(modelId: string | null): { id: string; agent: Agent } | null {
   const selected = (modelId ? resolveLanguageModel(modelId) : null) ?? defaultLanguageModel();
@@ -199,3 +201,42 @@ export async function renderPublicTurn(input: Readonly<{
     return fallback;
   }
 }
+
+export async function regenerateQuestionRealization(input: Readonly<{
+  caseValue: RectificationV4Case;
+  currentPrompt: string;
+  latestAnswer: string;
+  acceptedEvents: readonly LifeEventRevision[];
+  opportunity: QuestionOpportunity;
+  timeoutMs?: number;
+}>): Promise<string> {
+  const selected = agentFor(input.caseValue.narrationModelId);
+  if (!selected) return input.currentPrompt;
+  try {
+    const result = await selected.agent.generate(JSON.stringify({
+      task: "Rewrite the current question naturally without changing its semantic target. Return one question only.",
+      currentPrompt: input.currentPrompt,
+      latestAnswer: input.latestAnswer,
+      recentEvents: input.acceptedEvents.slice(-5).map((event) => ({
+        summary: event.summary,
+        date: event.dateRange.label,
+        subject: event.subject,
+      })),
+      selectedOpportunity: {
+        kind: input.opportunity.kind,
+        goal: input.opportunity.goal,
+        requestedFields: input.opportunity.requestedFields,
+        anchors: input.opportunity.anchors,
+        contextFacts: input.opportunity.contextFacts,
+        forbiddenMoves: input.opportunity.forbiddenMoves,
+      },
+    }), {
+      abortSignal: AbortSignal.timeout(input.timeoutMs ?? 15_000),
+      structuredOutput: { schema: questionRealizationSchema, jsonPromptInjection: "inline" },
+    });
+    const question = questionRealizationSchema.parse(result.object).question;
+    return validateQuestionRealization(question, input.opportunity).valid ? question : input.currentPrompt;
+  } catch {
+    return input.currentPrompt;
+  }
+}
diff --git a/frontend/src/lib/rectification-v4/case-service.ts b/frontend/src/lib/rectification-v4/case-service.ts
index 8766a152..db4fc5fc 100644
--- a/frontend/src/lib/rectification-v4/case-service.ts
+++ b/frontend/src/lib/rectification-v4/case-service.ts
@@ -8,6 +8,7 @@ import type {
 import { rectificationAgentV5Protocol, rectificationV4AlgorithmVersion, rectificationV4Protocol } from "./contracts.ts";
 import { selectRectificationDeploymentMode } from "../rectification-agent/feature-policy.ts";
 import { CURRENT_RECTIFICATION_PROMPT_VERSION, CURRENT_RECTIFICATION_SKILL_VERSION } from "../rectification-agent/contracts.ts";
+import { regenerateQuestionRealization } from "../rectification-agent/renderer-agent.ts";
 import { calculationSpecHash, evidenceSetHash } from "./fingerprints.ts";
 import { openingQuestion } from "./opening-question.ts";
 import type { RectificationV4Store } from "./store.ts";
@@ -88,6 +89,40 @@ export function createRectificationV4CaseService(store: RectificationV4Store, op
       return response(input.userId, saved.case, saved.job.id);
     },
 
+    async regenerateQuestion(input: {
+      readonly userId: string;
+      readonly caseId: string;
+      readonly actionId: string;
+      readonly expectedCaseVersion: number;
+    }) {
+      const current = await store.loadCase(input.userId, input.caseId);
+      if (!current?.currentQuestion || current.deploymentMode !== "v5_agent") return null;
+      const validated = await store.loadLatestValidatedDecision(input.userId, input.caseId);
+      const opportunity = validated?.selectedOpportunity;
+      if (!opportunity) return null;
+      const [events, turns] = await Promise.all([
+        store.loadEvents(input.userId, input.caseId),
+        store.loadTurns(input.userId, input.caseId),
+      ]);
+      const prompt = await regenerateQuestionRealization({
+        caseValue: current,
+        currentPrompt: current.currentQuestion.prompt,
+        latestAnswer: turns.at(-1)?.answer ?? "",
+        acceptedEvents: events,
+        opportunity,
+      });
+      const nextQuestion = {
+        ...current.currentQuestion,
+        id: randomUUID(),
+        prompt,
+      };
+      return response(input.userId, await store.replaceCurrentQuestion({
+        ...input,
+        question: nextQuestion,
+        now: now().toISOString(),
+      }));
+    },
+
     async reviseEvent(input: {
       readonly userId: string;
       readonly caseId: string;
diff --git a/frontend/src/lib/rectification-v4/client.ts b/frontend/src/lib/rectification-v4/client.ts
index 5c8af417..b0fe65ff 100644
--- a/frontend/src/lib/rectification-v4/client.ts
+++ b/frontend/src/lib/rectification-v4/client.ts
@@ -63,6 +63,12 @@ export function answerRectificationV4(caseId: string, expectedCaseVersion: numbe
   });
 }
 
+export function regenerateRectificationV4Question(caseId: string, expectedCaseVersion: number) {
+  return post(`/api/rectification/v4/cases/${caseId}/regenerate`, {
+    actionId: globalThis.crypto.randomUUID(), expectedCaseVersion,
+  });
+}
+
 export function transitionRectificationV4(
   caseId: string,
   expectedCaseVersion: number,
diff --git a/frontend/src/lib/rectification-v4/memory-store.ts b/frontend/src/lib/rectification-v4/memory-store.ts
index aef2c457..37f6522c 100644
--- a/frontend/src/lib/rectification-v4/memory-store.ts
+++ b/frontend/src/lib/rectification-v4/memory-store.ts
@@ -69,6 +69,14 @@ export function createRectificationV4MemoryStore(): RectificationV4Store & {
         .filter((turn) => turn.caseId === caseId)
         .sort((left, right) => left.caseVersion - right.caseVersion || left.createdAt.localeCompare(right.createdAt));
     },
+    async loadLatestValidatedDecision(userId, caseId) {
+      const caseValue = cases.get(caseId);
+      if (!caseValue || caseValue.userId !== userId) return null;
+      const latest = [...agentRuns.values()]
+        .filter((run) => run.caseId === caseId)
+        .sort((left, right) => right.caseVersion - left.caseVersion || right.createdAt.localeCompare(left.createdAt))[0];
+      return latest ? validatedDecisions.get(latest.jobId) ?? latest.validatedDecision : null;
+    },
     async createCase(input) {
       const replay = actionResults.get(`${input.case.userId}:${input.actionId}`);
       if (replay) return owned(input.case.userId, replay.caseId);
@@ -91,6 +99,29 @@ export function createRectificationV4MemoryStore(): RectificationV4Store & {
       actionResults.set(`${input.case.userId}:${input.actionId}`, { caseId: input.case.id, jobId: null });
       return input.case;
     },
+    async replaceCurrentQuestion(input) {
+      const key = `${input.userId}:${input.actionId}`;
+      const replay = actionResults.get(key);
+      if (replay) return owned(input.userId, replay.caseId);
+      const current = owned(input.userId, input.caseId);
+      if (current.version !== input.expectedCaseVersion) throw new RectificationV4StoreError("stale_version");
+      if (current.deploymentMode !== "v5_agent"
+        || !["awaiting_answer", "range_ready"].includes(current.status)
+        || !current.currentQuestion) throw new RectificationV4StoreError("invalid_state");
+      const updated: RectificationV4Case = {
+        ...current,
+        version: current.version + 1,
+        currentQuestion: {
+          ...input.question,
+          domain: current.currentQuestion.domain,
+          targetEventId: current.currentQuestion.targetEventId,
+        },
+        updatedAt: input.now,
+      };
+      cases.set(current.id, updated);
+      actionResults.set(key, { caseId: current.id, jobId: null });
+      return updated;
+    },
     async submitAnswer(input) {
       const key = `${input.userId}:${input.actionId}`;
       const replay = actionResults.get(key);
diff --git a/frontend/src/lib/rectification-v4/store.ts b/frontend/src/lib/rectification-v4/store.ts
index 812d3dcc..1601d21c 100644
--- a/frontend/src/lib/rectification-v4/store.ts
+++ b/frontend/src/lib/rectification-v4/store.ts
@@ -45,7 +45,16 @@ export interface RectificationV4Store {
   loadCase(userId: string, caseId: string): Promise<RectificationV4Case | null>;
   loadEvents(userId: string, caseId: string): Promise<readonly LifeEventRevision[]>;
   loadTurns(userId: string, caseId: string): Promise<readonly RectificationV4Turn[]>;
+  loadLatestValidatedDecision(userId: string, caseId: string): Promise<ValidatedDecision | null>;
   createCase(input: { readonly case: RectificationV4Case; readonly actionId: string }): Promise<RectificationV4Case>;
+  replaceCurrentQuestion(input: {
+    readonly userId: string;
+    readonly caseId: string;
+    readonly actionId: string;
+    readonly expectedCaseVersion: number;
+    readonly question: RectificationV4Question;
+    readonly now: string;
+  }): Promise<RectificationV4Case>;
   submitAnswer(input: {
     readonly userId: string;
     readonly caseId: string;
diff --git a/frontend/src/lib/rectification-v4/supabase-store.ts b/frontend/src/lib/rectification-v4/supabase-store.ts
index 045bd25e..3ae3e1d9 100644
--- a/frontend/src/lib/rectification-v4/supabase-store.ts
+++ b/frontend/src/lib/rectification-v4/supabase-store.ts
@@ -1,4 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
+import { validatedDecisionSchema, type ValidatedDecision } from "../rectification-agent/contracts.ts";
 import {
   candidateSnapshotSchema,
   lifeEventRevisionSchema,
@@ -199,6 +200,14 @@ export function createRectificationV4SupabaseStore(supabase: SupabaseClient): Re
     loadCase: loadCaseById,
     loadEvents: loadEventsByCase,
     loadTurns: loadTurnsByCase,
+    async loadLatestValidatedDecision(userId, caseId): Promise<ValidatedDecision | null> {
+      const { data, error } = await supabase.from("birth_time_rectification_agent_runs")
+        .select("validated_decision_json").eq("case_id", caseId).eq("user_id", userId)
+        .order("case_version", { ascending: false }).order("created_at", { ascending: false })
+        .limit(1).maybeSingle();
+      if (error) throw storeError(error);
+      return data ? validatedDecisionSchema.parse((data as Row).validated_decision_json) : null;
+    },
     async createCase(input) {
       const id = String(await rpc("create_birth_time_rectification_v5_case", {
         p_user_id: input.case.userId,
@@ -222,6 +231,19 @@ export function createRectificationV4SupabaseStore(supabase: SupabaseClient): Re
       if (!value) throw new RectificationV4StoreError("not_found");
       return value;
     },
+    async replaceCurrentQuestion(input) {
+      const id = String(await rpc("replace_birth_time_rectification_v4_current_question", {
+        p_user_id: input.userId,
+        p_case_id: input.caseId,
+        p_action_id: input.actionId,
+        p_expected_version: input.expectedCaseVersion,
+        p_question: input.question,
+        p_now: input.now,
+      }));
+      const value = await loadCaseById(input.userId, id);
+      if (!value) throw new RectificationV4StoreError("not_found");
+      return value;
+    },
     async submitAnswer(input) {
       const jobId = String(await rpc("submit_birth_time_rectification_v4_answer", {
         p_user_id: input.userId,
diff --git a/frontend/supabase/migrations/20260729020000_rectification_v4_current_question_regeneration.sql b/frontend/supabase/migrations/20260729020000_rectification_v4_current_question_regeneration.sql
new file mode 100644
index 00000000..210d837d
--- /dev/null
+++ b/frontend/supabase/migrations/20260729020000_rectification_v4_current_question_regeneration.sql
@@ -0,0 +1,80 @@
+begin;
+
+create or replace function public.replace_birth_time_rectification_v4_current_question(
+  p_user_id uuid,
+  p_case_id uuid,
+  p_action_id uuid,
+  p_expected_version bigint,
+  p_question jsonb,
+  p_now timestamptz
+) returns uuid
+language plpgsql security definer set search_path = '' as $$
+declare
+  v_case public.birth_time_rectification_v4_cases%rowtype;
+  v_case_id uuid;
+  v_question jsonb;
+begin
+  select action.case_id into v_case_id
+  from public.birth_time_rectification_v4_actions action
+  where action.user_id = p_user_id and action.action_id = p_action_id;
+  if v_case_id is not null then return v_case_id; end if;
+
+  select value.* into v_case
+  from public.birth_time_rectification_v4_cases value
+  where value.id = p_case_id and value.user_id = p_user_id
+  for update;
+  if not found then raise exception 'rectification_v4_case_not_found'; end if;
+
+  select action.case_id into v_case_id
+  from public.birth_time_rectification_v4_actions action
+  where action.user_id = p_user_id and action.action_id = p_action_id;
+  if v_case_id is not null then return v_case_id; end if;
+
+  if v_case.version <> p_expected_version then raise exception 'stale_rectification_v4_case'; end if;
+  if v_case.deployment_mode <> 'v5_agent'
+    or v_case.status not in ('awaiting_answer', 'range_ready')
+    or v_case.current_question is null then
+    raise exception 'rectification_v4_question_not_regenerable';
+  end if;
+  if p_question is null or pg_catalog.jsonb_typeof(p_question) <> 'object' then
+    raise exception 'invalid_rectification_v4_question';
+  end if;
+  if nullif(pg_catalog.btrim(p_question->>'id'), '') is null
+    or (p_question->>'id') !~* '^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$'
+    or nullif(pg_catalog.btrim(p_question->>'prompt'), '') is null
+    or pg_catalog.length(pg_catalog.btrim(p_question->>'prompt')) > 1000
+    or p_question->>'recallCost' not in ('low', 'medium', 'high')
+    or nullif(pg_catalog.btrim(p_question->>'reason'), '') is null
+    or pg_catalog.length(pg_catalog.btrim(p_question->>'reason')) > 240 then
+    raise exception 'invalid_rectification_v4_question';
+  end if;
+
+  v_question := p_question || pg_catalog.jsonb_build_object(
+    'domain', v_case.current_question->'domain',
+    'targetEventId', v_case.current_question->'targetEventId'
+  );
+
+  update public.birth_time_rectification_v4_cases
+  set version = p_expected_version + 1,
+      current_question = v_question,
+      updated_at = p_now
+  where id = p_case_id;
+
+  insert into public.birth_time_rectification_v4_actions(
+    user_id, action_id, case_id, created_at
+  ) values (
+    p_user_id, p_action_id, p_case_id, p_now
+  );
+
+  return p_case_id;
+end;
+$$;
+
+revoke all on function public.replace_birth_time_rectification_v4_current_question(
+  uuid, uuid, uuid, bigint, jsonb, timestamptz
+) from public, anon, authenticated, service_role;
+grant execute on function public.replace_birth_time_rectification_v4_current_question(
+  uuid, uuid, uuid, bigint, jsonb, timestamptz
+) to service_role;
+
+commit;
diff --git a/frontend/tests/conversational-rectification-component.test.ts b/frontend/tests/conversational-rectification-component.test.ts
index 667c1e43..7030d996 100644
--- a/frontend/tests/conversational-rectification-component.test.ts
+++ b/frontend/tests/conversational-rectification-component.test.ts
@@ -1,7 +1,11 @@
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import test from "node:test";
-import { rectificationV4ChatMessages } from "../src/components/rectification-v4-panel.tsx";
+import {
+  canRegenerateRectificationMessage,
+  rectificationV4ChatMessages,
+  toggleRectificationFeedback,
+} from "../src/components/rectification-v4-panel.tsx";
 import type { RectificationV4ApiResponse } from "../src/lib/rectification-v4/contracts.ts";
 
 const id = "00000000-0000-4000-8000-000000000901";
@@ -87,6 +91,11 @@ test("v4 rectification reuses the ordinary session message list, composer, and m
   assert.match(component, /className="composer"/);
   assert.match(component, /<Textarea/);
   assert.match(component, /<ModelSelector/);
+  assert.match(component, /aria-label="赞"/);
+  assert.match(component, /aria-label="踩"/);
+  assert.match(component, /aria-label="重新生成回答"/);
+  assert.match(component, /caseValue\?\.deploymentMode === "v5_agent"/);
+  assert.match(component, /controller\.regenerate\(\)/);
   assert.match(component, /controller\.answer\(answer, props\.selectedModelId \|\| null\)/);
   assert.match(wrapper, /<RectificationV4Panel \{\.\.\.props\} \/>/);
   assert.match(page, /\{!rectificationSurfaceOpen && \(\s*<div className=\{`conversation/);
@@ -96,6 +105,42 @@ test("v4 rectification reuses the ordinary session message list, composer, and m
   assert.doesNotMatch(css, /\.rectification-chat/);
 });
 
+test("V5 Agent feedback is mutually exclusive and regenerate is limited to the current settled assistant question", () => {
+  assert.equal(toggleRectificationFeedback(undefined, "up"), "up");
+  assert.equal(toggleRectificationFeedback("up", "up"), undefined);
+  assert.equal(toggleRectificationFeedback("up", "down"), "down");
+
+  const message = rectificationV4ChatMessages(response(), false).at(-1)!;
+  assert.equal(canRegenerateRectificationMessage({
+    message,
+    currentMessageKey: `rectification-current-${questionId}`,
+    deploymentMode: "v5_agent",
+    busy: false,
+    canAnswer: true,
+  }), true);
+  assert.equal(canRegenerateRectificationMessage({
+    message,
+    currentMessageKey: message.renderKey,
+    deploymentMode: "v5_shadow",
+    busy: false,
+    canAnswer: true,
+  }), false);
+  assert.equal(canRegenerateRectificationMessage({
+    message,
+    currentMessageKey: message.renderKey,
+    deploymentMode: "v5_agent",
+    busy: true,
+    canAnswer: true,
+  }), false);
+  assert.equal(canRegenerateRectificationMessage({
+    message: { ...message, role: "user" },
+    currentMessageKey: message.renderKey,
+    deploymentMode: "v5_agent",
+    busy: false,
+    canAnswer: true,
+  }), false);
+});
+
 test("turn history and the context-aware next question render as one chat timeline", () => {
   const messages = rectificationV4ChatMessages(response(), false);
 
diff --git a/frontend/tests/conversational-visible-narrative.test.ts b/frontend/tests/conversational-visible-narrative.test.ts
index f82b1d26..ec6e3c0d 100644
--- a/frontend/tests/conversational-visible-narrative.test.ts
+++ b/frontend/tests/conversational-visible-narrative.test.ts
@@ -77,6 +77,7 @@ test("the v4 rectification chat renders persisted turns as alternating message h
   assert.match(source, /for \(const turn of data\.turns\)/);
   assert.match(source, /role: "assistant"[\s\S]*?text: turn\.question/);
   assert.match(source, /role: "user"[\s\S]*?text: turn\.answer/);
-  assert.match(source, /messages\.map\(\(message\) => <ChatMessageRow/);
+  assert.match(source, /messages\.map\(\(message\) => \{/);
+  assert.match(source, /<ChatMessageRow message=/);
   assert.doesNotMatch(source, /rectification-progress-details|evidenceRecap\.map/);
 });
diff --git a/frontend/tests/rectification-v4-migration.test.ts b/frontend/tests/rectification-v4-migration.test.ts
index 00a54f09..003c4fae 100644
--- a/frontend/tests/rectification-v4-migration.test.ts
+++ b/frontend/tests/rectification-v4-migration.test.ts
@@ -4,6 +4,7 @@ import { readFileSync } from "node:fs";
 
 const sql = readFileSync(new URL("../supabase/migrations/20260726020000_birth_time_rectification_v4.sql", import.meta.url), "utf8");
 const conversationalSql = readFileSync(new URL("../supabase/migrations/20260727010000_rectification_v4_conversational_turns.sql", import.meta.url), "utf8");
+const regenerationSql = readFileSync(new URL("../supabase/migrations/20260729020000_rectification_v4_current_question_regeneration.sql", import.meta.url), "utf8");
 
 test("v4 migration creates canonical append-only storage and leased jobs", () => {
   for (const table of [
@@ -44,3 +45,16 @@ test("v4 handoff SQL enforces range acceptance, leases, idempotent settlement, a
   assert.match(sql, /birth_time_rectification_v4_handoff_settlements/i);
   assert.doesNotMatch(sql, /update\s+public\.profiles[\s\S]*active_birth_time/i);
 });
+
+
+test("current-question regeneration is service-role-only, atomic, idempotent, and preserves the semantic target", () => {
+  assert.match(regenerationSql, /create or replace function public\.replace_birth_time_rectification_v4_current_question/i);
+  assert.match(regenerationSql, /where value\.id = p_case_id and value\.user_id = p_user_id[\s\S]*for update/i);
+  assert.match(regenerationSql, /where action\.user_id = p_user_id and action\.action_id = p_action_id[\s\S]*return v_case_id/i);
+  assert.match(regenerationSql, /v_case\.version <> p_expected_version[\s\S]*stale_rectification_v4_case/i);
+  assert.match(regenerationSql, /v_case\.deployment_mode <> 'v5_agent'/i);
+  assert.match(regenerationSql, /'domain', v_case\.current_question->'domain'[\s\S]*'targetEventId', v_case\.current_question->'targetEventId'/i);
+  assert.match(regenerationSql, /grant execute on function public\.replace_birth_time_rectification_v4_current_question\([\s\S]*to service_role/i);
+  assert.doesNotMatch(regenerationSql, /insert into public\.birth_time_rectification_v4_(?:turns|events|jobs|candidate_snapshots)/i);
+  assert.doesNotMatch(regenerationSql, /update\s+public\.profiles/i);
+});
diff --git a/frontend/tests/rectification-v4-service.test.ts b/frontend/tests/rectification-v4-service.test.ts
index c8adb6fb..40c5296a 100644
--- a/frontend/tests/rectification-v4-service.test.ts
+++ b/frontend/tests/rectification-v4-service.test.ts
@@ -148,3 +148,72 @@ test("legacy cases are not hard-switched to V5 even when flags change later", as
     assert.equal(run.fallbackReason, "deployment_mode_legacy");
   });
 });
+
+test("V5 Agent regenerate rewrites only the current semantic question and replays the same action once", async () => withMode("v5_agent", async () => {
+  const store = createRectificationV4MemoryStore();
+  const service = createRectificationV4CaseService(store, { now: fixedNow });
+  const userId = randomUUID();
+  const created = await service.createCase({ userId, actionId: randomUUID(), calculationSpec: spec });
+  const queued = await service.answer({
+    userId,
+    caseId: created.case.id,
+    actionId: randomUUID(),
+    expectedCaseVersion: created.case.version,
+    answer: "2020年4月去石油化工研究院实习做研究员",
+  });
+  assert.ok(queued?.job);
+  const worker = createRectificationV4Worker({
+    store,
+    now: fixedNow,
+    engine: { async score() { throw new Error("engine must not run before enough events"); } },
+  });
+  assert.equal(await worker.runOnce(), true);
+
+  const before = await service.loadCase(userId, created.case.id);
+  assert.ok(before?.case.currentQuestion);
+  const actionId = randomUUID();
+  const regenerated = await service.regenerateQuestion({
+    userId,
+    caseId: created.case.id,
+    actionId,
+    expectedCaseVersion: before.case.version,
+  });
+  assert.ok(regenerated?.case.currentQuestion);
+  assert.equal(regenerated.case.version, before.case.version + 1);
+  assert.notEqual(regenerated.case.currentQuestion.id, before.case.currentQuestion.id);
+  assert.equal(regenerated.case.currentQuestion.domain, before.case.currentQuestion.domain);
+  assert.equal(regenerated.case.currentQuestion.targetEventId, before.case.currentQuestion.targetEventId);
+  assert.equal(regenerated.case.evidenceSetHash, before.case.evidenceSetHash);
+  assert.deepEqual(regenerated.events, before.events);
+  assert.deepEqual(regenerated.turns, before.turns);
+  assert.deepEqual(regenerated.case.latestSnapshot, before.case.latestSnapshot);
+  assert.equal(store.jobs.size, 1);
+
+  const replayed = await service.regenerateQuestion({
+    userId,
+    caseId: created.case.id,
+    actionId,
+    expectedCaseVersion: before.case.version,
+  });
+  assert.equal(replayed?.case.version, regenerated.case.version);
+  assert.equal(replayed?.case.currentQuestion?.id, regenerated.case.currentQuestion.id);
+  assert.equal(store.jobs.size, 1);
+  assert.equal(regenerated.case.latestSnapshot?.canConfirmExactMinute ?? false, false);
+}));
+
+test("legacy and shadow cases cannot call the V5 Agent question renderer", async () => {
+  for (const mode of ["v4_legacy", "v5_shadow"] as const) {
+    await withMode(mode, async () => {
+      const store = createRectificationV4MemoryStore();
+      const service = createRectificationV4CaseService(store, { now: fixedNow });
+      const userId = randomUUID();
+      const created = await service.createCase({ userId, actionId: randomUUID(), calculationSpec: spec });
+      assert.equal(await service.regenerateQuestion({
+        userId,
+        caseId: created.case.id,
+        actionId: randomUUID(),
+        expectedCaseVersion: created.case.version,
+      }), null);
+    });
+  }
+});

From 29374ded2aaa0b6322317b1f8c6b0f9cfd2b6ea2 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Thu, 30 Jul 2026 00:52:40 +0800
Subject: [PATCH 08/15] fix: deduplicate rectification question regeneration

---
 .../src/lib/rectification-v4/case-service.ts  | 76 ++++++++++++-------
 .../src/lib/rectification-v4/memory-store.ts  |  4 +
 frontend/src/lib/rectification-v4/store.ts    |  1 +
 .../lib/rectification-v4/supabase-store.ts    |  6 ++
 .../tests/rectification-v4-service.test.ts    | 21 ++++-
 5 files changed, 78 insertions(+), 30 deletions(-)

diff --git a/frontend/src/lib/rectification-v4/case-service.ts b/frontend/src/lib/rectification-v4/case-service.ts
index db4fc5fc..20f6df7e 100644
--- a/frontend/src/lib/rectification-v4/case-service.ts
+++ b/frontend/src/lib/rectification-v4/case-service.ts
@@ -13,8 +13,17 @@ import { calculationSpecHash, evidenceSetHash } from "./fingerprints.ts";
 import { openingQuestion } from "./opening-question.ts";
 import type { RectificationV4Store } from "./store.ts";
 
-export function createRectificationV4CaseService(store: RectificationV4Store, options: { readonly now?: () => Date } = {}) {
+const regenerationInFlight = new Map<string, Promise<RectificationV4Case | null>>();
+
+export function createRectificationV4CaseService(
+  store: RectificationV4Store,
+  options: {
+    readonly now?: () => Date;
+    readonly regenerateQuestion?: typeof regenerateQuestionRealization;
+  } = {},
+) {
   const now = options.now ?? (() => new Date());
+  const realizeQuestion = options.regenerateQuestion ?? regenerateQuestionRealization;
 
   async function response(userId: string, caseValue: RectificationV4Case, jobId?: string): Promise<RectificationV4ApiResponse> {
     const [events, turns] = await Promise.all([
@@ -95,32 +104,45 @@ export function createRectificationV4CaseService(store: RectificationV4Store, op
       readonly actionId: string;
       readonly expectedCaseVersion: number;
     }) {
-      const current = await store.loadCase(input.userId, input.caseId);
-      if (!current?.currentQuestion || current.deploymentMode !== "v5_agent") return null;
-      const validated = await store.loadLatestValidatedDecision(input.userId, input.caseId);
-      const opportunity = validated?.selectedOpportunity;
-      if (!opportunity) return null;
-      const [events, turns] = await Promise.all([
-        store.loadEvents(input.userId, input.caseId),
-        store.loadTurns(input.userId, input.caseId),
-      ]);
-      const prompt = await regenerateQuestionRealization({
-        caseValue: current,
-        currentPrompt: current.currentQuestion.prompt,
-        latestAnswer: turns.at(-1)?.answer ?? "",
-        acceptedEvents: events,
-        opportunity,
-      });
-      const nextQuestion = {
-        ...current.currentQuestion,
-        id: randomUUID(),
-        prompt,
-      };
-      return response(input.userId, await store.replaceCurrentQuestion({
-        ...input,
-        question: nextQuestion,
-        now: now().toISOString(),
-      }));
+      const replay = await store.loadActionCase(input.userId, input.actionId);
+      if (replay) return response(input.userId, replay);
+
+      const key = `${input.userId}:${input.actionId}`;
+      let pending = regenerationInFlight.get(key);
+      if (!pending) {
+        pending = (async () => {
+          const secondReplay = await store.loadActionCase(input.userId, input.actionId);
+          if (secondReplay) return secondReplay;
+          const current = await store.loadCase(input.userId, input.caseId);
+          if (!current?.currentQuestion || current.deploymentMode !== "v5_agent") return null;
+          const validated = await store.loadLatestValidatedDecision(input.userId, input.caseId);
+          const opportunity = validated?.selectedOpportunity;
+          if (!opportunity) return null;
+          const [events, turns] = await Promise.all([
+            store.loadEvents(input.userId, input.caseId),
+            store.loadTurns(input.userId, input.caseId),
+          ]);
+          const prompt = await realizeQuestion({
+            caseValue: current,
+            currentPrompt: current.currentQuestion.prompt,
+            latestAnswer: turns.at(-1)?.answer ?? "",
+            acceptedEvents: events,
+            opportunity,
+          });
+          return store.replaceCurrentQuestion({
+            ...input,
+            question: { ...current.currentQuestion, id: randomUUID(), prompt },
+            now: now().toISOString(),
+          });
+        })();
+        regenerationInFlight.set(key, pending);
+      }
+      try {
+        const saved = await pending;
+        return saved ? response(input.userId, saved) : null;
+      } finally {
+        if (regenerationInFlight.get(key) === pending) regenerationInFlight.delete(key);
+      }
     },
 
     async reviseEvent(input: {
diff --git a/frontend/src/lib/rectification-v4/memory-store.ts b/frontend/src/lib/rectification-v4/memory-store.ts
index 37f6522c..154787c5 100644
--- a/frontend/src/lib/rectification-v4/memory-store.ts
+++ b/frontend/src/lib/rectification-v4/memory-store.ts
@@ -77,6 +77,10 @@ export function createRectificationV4MemoryStore(): RectificationV4Store & {
         .sort((left, right) => right.caseVersion - left.caseVersion || right.createdAt.localeCompare(left.createdAt))[0];
       return latest ? validatedDecisions.get(latest.jobId) ?? latest.validatedDecision : null;
     },
+    async loadActionCase(userId, actionId) {
+      const replay = actionResults.get(`${userId}:${actionId}`);
+      return replay ? owned(userId, replay.caseId) : null;
+    },
     async createCase(input) {
       const replay = actionResults.get(`${input.case.userId}:${input.actionId}`);
       if (replay) return owned(input.case.userId, replay.caseId);
diff --git a/frontend/src/lib/rectification-v4/store.ts b/frontend/src/lib/rectification-v4/store.ts
index 1601d21c..39d59707 100644
--- a/frontend/src/lib/rectification-v4/store.ts
+++ b/frontend/src/lib/rectification-v4/store.ts
@@ -46,6 +46,7 @@ export interface RectificationV4Store {
   loadEvents(userId: string, caseId: string): Promise<readonly LifeEventRevision[]>;
   loadTurns(userId: string, caseId: string): Promise<readonly RectificationV4Turn[]>;
   loadLatestValidatedDecision(userId: string, caseId: string): Promise<ValidatedDecision | null>;
+  loadActionCase(userId: string, actionId: string): Promise<RectificationV4Case | null>;
   createCase(input: { readonly case: RectificationV4Case; readonly actionId: string }): Promise<RectificationV4Case>;
   replaceCurrentQuestion(input: {
     readonly userId: string;
diff --git a/frontend/src/lib/rectification-v4/supabase-store.ts b/frontend/src/lib/rectification-v4/supabase-store.ts
index 3ae3e1d9..8b1c8b28 100644
--- a/frontend/src/lib/rectification-v4/supabase-store.ts
+++ b/frontend/src/lib/rectification-v4/supabase-store.ts
@@ -208,6 +208,12 @@ export function createRectificationV4SupabaseStore(supabase: SupabaseClient): Re
       if (error) throw storeError(error);
       return data ? validatedDecisionSchema.parse((data as Row).validated_decision_json) : null;
     },
+    async loadActionCase(userId, actionId) {
+      const { data, error } = await supabase.from("birth_time_rectification_v4_actions")
+        .select("case_id").eq("user_id", userId).eq("action_id", actionId).maybeSingle();
+      if (error) throw storeError(error);
+      return data ? loadCaseById(userId, String((data as Row).case_id)) : null;
+    },
     async createCase(input) {
       const id = String(await rpc("create_birth_time_rectification_v5_case", {
         p_user_id: input.case.userId,
diff --git a/frontend/tests/rectification-v4-service.test.ts b/frontend/tests/rectification-v4-service.test.ts
index 40c5296a..9aa8068a 100644
--- a/frontend/tests/rectification-v4-service.test.ts
+++ b/frontend/tests/rectification-v4-service.test.ts
@@ -151,7 +151,15 @@ test("legacy cases are not hard-switched to V5 even when flags change later", as
 
 test("V5 Agent regenerate rewrites only the current semantic question and replays the same action once", async () => withMode("v5_agent", async () => {
   const store = createRectificationV4MemoryStore();
-  const service = createRectificationV4CaseService(store, { now: fixedNow });
+  let realizationCalls = 0;
+  const service = createRectificationV4CaseService(store, {
+    now: fixedNow,
+    regenerateQuestion: async ({ opportunity }) => {
+      realizationCalls += 1;
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      return opportunity.fallbackPrompt;
+    },
+  });
   const userId = randomUUID();
   const created = await service.createCase({ userId, actionId: randomUUID(), calculationSpec: spec });
   const queued = await service.answer({
@@ -172,13 +180,19 @@ test("V5 Agent regenerate rewrites only the current semantic question and replay
   const before = await service.loadCase(userId, created.case.id);
   assert.ok(before?.case.currentQuestion);
   const actionId = randomUUID();
-  const regenerated = await service.regenerateQuestion({
+  const regenerationInput = {
     userId,
     caseId: created.case.id,
     actionId,
     expectedCaseVersion: before.case.version,
-  });
+  };
+  const [regenerated, concurrentReplay] = await Promise.all([
+    service.regenerateQuestion(regenerationInput),
+    service.regenerateQuestion(regenerationInput),
+  ]);
   assert.ok(regenerated?.case.currentQuestion);
+  assert.equal(concurrentReplay?.case.currentQuestion?.id, regenerated.case.currentQuestion.id);
+  assert.equal(realizationCalls, 1);
   assert.equal(regenerated.case.version, before.case.version + 1);
   assert.notEqual(regenerated.case.currentQuestion.id, before.case.currentQuestion.id);
   assert.equal(regenerated.case.currentQuestion.domain, before.case.currentQuestion.domain);
@@ -197,6 +211,7 @@ test("V5 Agent regenerate rewrites only the current semantic question and replay
   });
   assert.equal(replayed?.case.version, regenerated.case.version);
   assert.equal(replayed?.case.currentQuestion?.id, regenerated.case.currentQuestion.id);
+  assert.equal(realizationCalls, 1);
   assert.equal(store.jobs.size, 1);
   assert.equal(regenerated.case.latestSnapshot?.canConfirmExactMinute ?? false, false);
 }));

From ee10fb4d8a777d64f79073aa38bd36f5903af8e4 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Thu, 30 Jul 2026 03:15:06 +0800
Subject: [PATCH 09/15] feat: persist rectification analysis traces

---
 docs/BUG_HISTORY.md                           |  16 +
 frontend/src/app/globals.css                  |  55 +++
 .../src/components/rectification-v4-panel.tsx | 141 +++++-
 .../src/lib/rectification-agent/contracts.ts  |   7 +-
 .../lib/rectification-agent/orchestrator.ts   | 107 ++++-
 .../lib/rectification-agent/reasoner-agent.ts |  66 ++-
 .../src/lib/rectification-v4/case-service.ts  |   6 +-
 .../src/lib/rectification-v4/contracts.ts     |  38 ++
 .../src/lib/rectification-v4/memory-store.ts  |  13 +-
 frontend/src/lib/rectification-v4/store.ts    |   6 +-
 .../lib/rectification-v4/supabase-store.ts    |  38 +-
 ...ersational-rectification-component.test.ts | 121 ++++-
 frontend/tests/rectification-agent-v5.test.ts |  14 +-
 .../rectification-analysis-trace.test.ts      | 432 ++++++++++++++++++
 ...ectification-v5-migration-contract.test.ts |   6 +
 skills/birth-time-rectification/SKILL.md      |  13 +
 .../references/failure-policy.md              |   9 +
 .../references/output-contract.md             |  16 +
 .../references/technique-policy.md            |  12 +
 19 files changed, 1084 insertions(+), 32 deletions(-)
 create mode 100644 frontend/tests/rectification-analysis-trace.test.ts

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 5e4ae6c7..19119f3e 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1692,3 +1692,19 @@
 - 相关记录：BUG-090、BUG-091、BUG-092、BUG-093
 - 复发自：无
 - 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`
+
+
+## BUG-095 | 生时校正“思考中”无法证明实际执行步骤且刷新后不可溯源
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：V4/V5 生时校正运行状态、历史助手消息、候选计算与诊断的测试可观测性
+- 用户现象：页面只显示“正在核对星盘信息……”动画，无法判断本轮实际执行了哪些阶段、工具和技法；任务结束或刷新后也无法回看。
+- 根因：Job 只保存一个会被后续步骤覆盖的当前 `phase`，不能还原阶段历史；已持久化的 Public Message 与 Agent Run 工具记录没有被 Case API 投影到对应 Turn；UI 的 thinking 状态只是客户端进度动画，不是模型 reasoning，也不是服务端执行收据。
+- 修复：将“分析过程”定义为与 Turn 关联、可持久化和刷新后可恢复的服务端执行收据；只投影实际发生的阶段、工具调用和 allowlist 技法。供应商显式返回的 reasoning 内容只有通过服务端来源校验与安全过滤后才可作为可选摘要，缺失或不安全时直接省略，不伪造且不读取 hidden chain-of-thought。
+- 安全边界：不公开分数、权重、贡献矩阵、内部 ID/字段、候选分钟、工具参数或原始结果、Prompt、模型内部信息和用户敏感原文；D60 不展示且不驱动结论；未执行、不可用或仅供参考的技法不得显示为已执行。
+- 兼容边界：历史无收据记录继续读取；`v4_legacy` 与 `v5_shadow` 保持原有用户可见回复，shadow 仅持久化新产物而不展示分析轨迹；completed-job replay、原子 completion、`canConfirmExactMinute === false` 和禁止自动写入 `profiles.active_birth_time` 保持不变。
+- 防复发：API 与组件测试必须锁定 Turn 关联、刷新恢复、运行中真实 phase、仅展示实际工具/技法、无安全 reasoning 时不补写摘要，以及旧记录、legacy、shadow 的兼容行为。
+- 相关记录：BUG-011、BUG-086、BUG-087、BUG-094
+- 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`
diff --git a/frontend/src/app/globals.css b/frontend/src/app/globals.css
index e665c9a2..46b5d654 100644
--- a/frontend/src/app/globals.css
+++ b/frontend/src/app/globals.css
@@ -601,6 +601,56 @@ button:disabled { cursor: default; opacity: .45; }
 .rectification-message-actions button:focus-visible { outline: 2px solid color-mix(in srgb, var(--color-focus) 52%, transparent); outline-offset: 1px; }
 .rectification-message-actions button:disabled { cursor: default; opacity: 0.32; }
 .rectification-message-actions svg { width: 13px; height: 13px; stroke-width: 1.65; }
+.rectification-analysis {
+  width: min(620px, calc(100% - 42px));
+  margin: -2px 0 var(--space-1) 42px;
+  color: var(--color-ink-secondary);
+  font-size: var(--type-caption);
+}
+.rectification-analysis > summary {
+  width: fit-content;
+  display: flex;
+  align-items: center;
+  gap: var(--space-2);
+  min-height: 30px;
+  padding: 0 var(--space-2);
+  border-radius: var(--radius-sm);
+  color: var(--color-ink-tertiary);
+  cursor: pointer;
+  list-style: none;
+  transition: background-color 120ms ease-out, color 120ms ease-out;
+}
+.rectification-analysis > summary::-webkit-details-marker { display: none; }
+.rectification-analysis > summary::before {
+  width: 6px;
+  height: 6px;
+  border-right: 1.5px solid currentColor;
+  border-bottom: 1.5px solid currentColor;
+  content: "";
+  transform: rotate(-45deg);
+  transition: transform 120ms ease-out;
+}
+.rectification-analysis[open] > summary::before { transform: rotate(45deg) translate(-1px, -1px); }
+.rectification-analysis > summary:hover { background: var(--color-canvas-muted); color: var(--color-ink-secondary); }
+.rectification-analysis > summary:focus-visible { outline: 2px solid color-mix(in srgb, var(--color-focus) 52%, transparent); outline-offset: 1px; }
+.rectification-analysis > summary small { color: var(--color-ink-muted); font-size: inherit; }
+.rectification-analysis-content {
+  display: grid;
+  gap: var(--space-3);
+  margin: var(--space-1) 0 var(--space-2);
+  padding: var(--space-3) var(--space-4);
+  border: 1px solid color-mix(in srgb, var(--color-border) 76%, transparent);
+  border-radius: var(--radius-md);
+  background: color-mix(in srgb, var(--color-canvas-muted) 54%, transparent);
+}
+.rectification-analysis-content section { display: grid; gap: var(--space-2); }
+.rectification-analysis-content h4 { margin: 0; color: var(--color-ink-secondary); font-size: var(--type-caption); font-weight: 600; }
+.rectification-analysis-content ol,
+.rectification-analysis-content ul { display: grid; gap: 6px; margin: 0; padding: 0; list-style: none; }
+.rectification-analysis-content li { display: flex; align-items: baseline; justify-content: space-between; gap: var(--space-3); }
+.rectification-analysis-content li span { min-width: 0; color: var(--color-ink-secondary); }
+.rectification-analysis-content li small { flex: 0 0 auto; color: var(--color-ink-muted); }
+.rectification-analysis-content p { margin: 0; color: var(--color-ink-secondary); font-size: var(--type-caption); line-height: 1.55; }
 .message p, .message-markdown { color: var(--color-ink-strong); font-size: var(--type-body-md); line-height: 1.65; text-wrap: pretty; word-break: auto-phrase; }
 .message-evidence-status { margin: var(--space-3) 0 0; padding-top: var(--space-2); border-top: 1px solid var(--color-border); color: var(--color-ink-muted); font-size: var(--type-body-sm); line-height: 1.5; }
 .message-user p { line-height: 1.55; color: var(--color-ink); font-size: var(--type-body-sm); }
@@ -1539,6 +1589,11 @@ input:disabled, select:disabled { color: var(--color-ink-tertiary); background:
     max-width: 88%;
   }
 
+  .rectification-analysis {
+    width: calc(100% - 38px);
+    margin-left: 38px;
+  }
+
   .conversation:not(.is-empty):not(.is-rectification) + .composer-wrap {
     padding-top: var(--space-3);
     padding-bottom: var(--space-3);
diff --git a/frontend/src/components/rectification-v4-panel.tsx b/frontend/src/components/rectification-v4-panel.tsx
index 8a42dcb5..97bc302d 100644
--- a/frontend/src/components/rectification-v4-panel.tsx
+++ b/frontend/src/components/rectification-v4-panel.tsx
@@ -2,11 +2,12 @@
 
 import { ArrowUp, Check, Copy, RotateCcw, ThumbsDown, ThumbsUp } from "lucide-react";
 import { useEffect, useRef, useState } from "react";
+import { AgentActivityStatus } from "@/components/agent-activity-status";
 import { useRectificationV4 } from "@/hooks/use-rectification-v4";
 import type { ChatMessageView } from "@/lib/chat-message-view";
 import type { PublicLanguageModel } from "@/lib/public-models";
-import type { RectificationV4ApiResponse } from "@/lib/rectification-v4/contracts";
-import { ChatMessageRow } from "./chat-message-row";
+import type { RectificationAnalysisItem, RectificationAnalysisTrace, RectificationV4ApiResponse } from "@/lib/rectification-v4/contracts";
+import { AgentAvatar, ChatMessageRow } from "./chat-message-row";
 import { ModelSelector } from "./model-selector";
 import { Button } from "./ui/button";
 import { Textarea } from "./ui/textarea";
@@ -29,6 +30,115 @@ type RectificationV4PanelProps = Readonly<{
   onContinueOriginalQuestion?: (continuation: RectificationV4Continuation) => void;
 }>;
 
+type RectificationChatMessageView = ChatMessageView & Readonly<{
+  analysisTrace?: RectificationAnalysisTrace;
+}>;
+
+const phaseLabels = {
+  collecting_evidence: "正在准备继续收集经历…",
+  extracting_evidence: "正在整理你刚才提到的经历…",
+  scoring_candidates: "正在扫描候选时间…",
+  checking_robustness: "正在检查候选范围的稳定性…",
+  planning_question: "正在选择下一条最有信息量的问题…",
+  reasoning: "正在结合上下文决定下一步…",
+  rendering: "正在组织下一条回复…",
+  complete: "分析已完成",
+} as const;
+
+export function rectificationPhaseLabel(
+  phase: NonNullable<RectificationV4ApiResponse["job"]>["phase"],
+): string {
+  return phaseLabels[phase];
+}
+
+function durationLabel(durationMs: number | null): string | null {
+  if (durationMs === null || durationMs < 0) return null;
+  return durationMs < 1_000 ? `${durationMs} 毫秒` : `${(durationMs / 1_000).toFixed(1)} 秒`;
+}
+
+function publicStatusLabel(status: string): string {
+  return ({
+    completed: "已完成",
+    succeeded: "已完成",
+    running: "进行中",
+    failed: "未完成",
+    skipped: "已跳过",
+    legacy: "历史记录",
+  } as Record<string, string>)[status] ?? "已记录";
+}
+
+function RectificationAnalysisDetails({ trace }: Readonly<{ trace: RectificationAnalysisTrace }>) {
+  return (
+    <details className="rectification-analysis">
+      <summary>
+        <span>分析过程</span>
+        <small>{publicStatusLabel(trace.status)}</small>
+      </summary>
+      <div className="rectification-analysis-content">
+        {trace.stages.length > 0 && (
+          <section aria-label="执行阶段">
+            <h4>执行阶段</h4>
+            <ol>
+              {trace.stages.map((stage, index) => {
+                const duration = durationLabel(stage.durationMs);
+                return (
+                  <li key={`${stage.phase}-${index}`}>
+                    <span>{stage.label}</span>
+                    <small>{publicStatusLabel(stage.status)}{duration ? ` · ${duration}` : ""}</small>
+                  </li>
+                );
+              })}
+            </ol>
+          </section>
+        )}
+        {trace.toolCalls.length > 0 && (
+          <section aria-label="实际调用">
+            <h4>实际调用</h4>
+            <ul>
+              {trace.toolCalls.map((toolCall, index) => {
+                const duration = durationLabel(toolCall.durationMs);
+                return (
+                  <li key={`${toolCall.category}-${index}`}>
+                    <span>{toolCall.label}</span>
+                    <small>{publicStatusLabel(toolCall.outcome)}{duration ? ` · ${duration}` : ""}</small>
+                  </li>
+                );
+              })}
+            </ul>
+          </section>
+        )}
+        {trace.techniques.length > 0 && (
+          <section aria-label="实际使用的技法">
+            <h4>实际使用的技法</h4>
+            <p>{trace.techniques.join("、")}</p>
+          </section>
+        )}
+        {trace.reasoningSource === "provider_summary" && trace.reasoningSummary && (
+          <section aria-label="推理摘要">
+            <h4>推理摘要</h4>
+            <p>{trace.reasoningSummary}</p>
+          </section>
+        )}
+      </div>
+    </details>
+  );
+}
+
+function RectificationMessageRow({ message }: Readonly<{ message: RectificationChatMessageView }>) {
+  if (message.state !== "thinking" || !message.text) return <ChatMessageRow message={message} />;
+
+  return (
+    <article className="message message-assistant" aria-label="Jyotisha 正在分析">
+      <AgentAvatar />
+      <div className="message-content">
+        <div className="message-bubble">
+          <AgentActivityStatus state="working" label={message.text} />
+        </div>
+      </div>
+    </article>
+  );
+}
+
 export function toggleRectificationFeedback(
   current: "up" | "down" | undefined,
   requested: "up" | "down",
@@ -55,7 +165,7 @@ export function rectificationV4ChatMessages(
   data: RectificationV4ApiResponse | null,
   processing: boolean,
   pendingConsultationQuestion?: string | null,
-): readonly ChatMessageView[] {
+): readonly RectificationChatMessageView[] {
   if (!data) {
     return [{
       role: "assistant",
@@ -65,7 +175,13 @@ export function rectificationV4ChatMessages(
     }];
   }
 
-  const messages: ChatMessageView[] = [];
+  const messages: RectificationChatMessageView[] = [];
+  const analysis = data.case.deploymentMode === "v5_agent"
+    ? (data as RectificationV4ApiResponse & {
+      readonly analysis?: readonly RectificationAnalysisItem[];
+    }).analysis ?? []
+    : [];
+  const analysisBySourceTurnId = new Map(analysis.map((item) => [item.sourceTurnId, item.trace]));
   if (pendingConsultationQuestion?.trim()) {
     messages.push({
       role: "assistant",
@@ -75,12 +191,14 @@ export function rectificationV4ChatMessages(
     });
   }
 
+  let previousTurnId: string | null = null;
   for (const turn of data.turns) {
     messages.push({
       role: "assistant",
       text: turn.question,
       renderKey: `rectification-question-${turn.id}`,
       state: "settled",
+      analysisTrace: previousTurnId ? analysisBySourceTurnId.get(previousTurnId) : undefined,
     });
     if (turn.answer) {
       messages.push({
@@ -90,16 +208,20 @@ export function rectificationV4ChatMessages(
         state: "settled",
       });
     }
+    previousTurnId = turn.id;
   }
 
   const caseValue = data.case;
   const primary = caseValue.latestSnapshot?.clusters[0];
+  const latestTurnTrace = analysisBySourceTurnId.get(data.turns.at(-1)?.id ?? "");
+  const terminalTrace = caseValue.currentQuestion ? undefined : latestTurnTrace;
   if (caseValue.acceptedRange) {
     messages.push({
       role: "assistant",
       text: `候选范围已保存为 ${caseValue.acceptedRange.start}–${caseValue.acceptedRange.end}。这是校正得到的候选范围，原出生时间没有被自动改写。`,
       renderKey: `rectification-accepted-${caseValue.version}`,
       state: "settled",
+      analysisTrace: terminalTrace,
     });
   } else if (caseValue.status === "range_ready" && primary) {
     messages.push({
@@ -107,6 +229,7 @@ export function rectificationV4ChatMessages(
       text: `根据目前这些经历，可以先把范围稳定缩小到 ${primary.startTime}–${primary.endTime}。这是候选范围，不是已确认的出生分钟；你可以保存它，也可以继续补充经历。`,
       renderKey: `rectification-range-${caseValue.version}`,
       state: "settled",
+      analysisTrace: terminalTrace,
     });
   }
 
@@ -116,13 +239,14 @@ export function rectificationV4ChatMessages(
       text: caseValue.currentQuestion.prompt,
       renderKey: `rectification-current-${caseValue.currentQuestion.id}`,
       state: "settled",
+      analysisTrace: latestTurnTrace,
     });
   }
 
   if (processing) {
     messages.push({
       role: "assistant",
-      text: "",
+      text: rectificationPhaseLabel(data.job?.phase ?? caseValue.phase),
       renderKey: `rectification-processing-${data.job?.id ?? caseValue.version}`,
       state: "thinking",
     });
@@ -132,6 +256,7 @@ export function rectificationV4ChatMessages(
       text: "进度已经保存。准备好后，我们可以从这里继续。",
       renderKey: `rectification-paused-${caseValue.version}`,
       state: "settled",
+      analysisTrace: terminalTrace,
     });
   } else if (caseValue.status === "abandoned") {
     messages.push({
@@ -139,6 +264,7 @@ export function rectificationV4ChatMessages(
       text: "这次校正已经结束，原出生时间没有被改写。",
       renderKey: `rectification-abandoned-${caseValue.version}`,
       state: "settled",
+      analysisTrace: terminalTrace,
     });
   }
 
@@ -254,9 +380,12 @@ export function RectificationV4Panel(props: RectificationV4PanelProps) {
             });
             return (
               <div className="rectification-message-entry" key={message.renderKey}>
-                <ChatMessageRow message={regenerating
+                <RectificationMessageRow message={regenerating
                   ? { ...message, text: "", state: "thinking" }
                   : message} />
+                {message.role === "assistant" && message.state === "settled" && message.analysisTrace && (
+                  <RectificationAnalysisDetails trace={message.analysisTrace} />
+                )}
                 {showActions && !regenerating && (
                   <div className="rectification-message-actions" aria-label="Agent 回答操作">
                     <button
diff --git a/frontend/src/lib/rectification-agent/contracts.ts b/frontend/src/lib/rectification-agent/contracts.ts
index a75629cd..26f13300 100644
--- a/frontend/src/lib/rectification-agent/contracts.ts
+++ b/frontend/src/lib/rectification-agent/contracts.ts
@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { clockTimeSchema, evidenceDomainSchema, rectificationDeploymentModeSchema } from "../rectification-v4/contracts.ts";
+import { clockTimeSchema, evidenceDomainSchema, rectificationAnalysisTraceSchema, rectificationDeploymentModeSchema } from "../rectification-v4/contracts.ts";
 
 const uuid = z.string().uuid();
 const hash = z.string().regex(/^[a-f0-9]{64}$/);
@@ -254,6 +254,11 @@ export const publicMessageSchema = z.object({
 }).strict();
 export type PublicMessage = z.infer<typeof publicMessageSchema>;
 
+export const storedPublicMessageSchema = publicMessageSchema.extend({
+  analysisTrace: rectificationAnalysisTraceSchema.optional(),
+}).strict();
+export type StoredPublicMessage = z.infer<typeof storedPublicMessageSchema>;
+
 export const agentRunSchema = z.object({
   id: uuid,
   caseId: uuid,
diff --git a/frontend/src/lib/rectification-agent/orchestrator.ts b/frontend/src/lib/rectification-agent/orchestrator.ts
index b5eb9525..efb95a6e 100644
--- a/frontend/src/lib/rectification-agent/orchestrator.ts
+++ b/frontend/src/lib/rectification-agent/orchestrator.ts
@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
-import type { RectificationV4CandidateEngine } from "../rectification-v4/candidate-engine.ts";
+import type { CandidateEngineResult, RectificationV4CandidateEngine } from "../rectification-v4/candidate-engine.ts";
 import { buildCandidateClusters } from "../rectification-v4/candidate-clusters.ts";
-import type { CandidateSnapshot, RectificationV4Question } from "../rectification-v4/contracts.ts";
+import type { CandidateSnapshot, RectificationAnalysisTrace, RectificationV4Question } from "../rectification-v4/contracts.ts";
 import { evaluateDecisionGate } from "../rectification-v4/decision-gate.ts";
 import { reconcileV4Evidence } from "../rectification-v4/extraction.ts";
 import { extractEventWithModel } from "./event-extractor-agent.ts";
@@ -21,7 +21,7 @@ import {
   type AgentRun,
   type CandidateFeatureSnapshot,
   type DiagnosticsSummary,
-  type PublicMessage,
+  type StoredPublicMessage,
   type ValidatedDecision,
 } from "./contracts.ts";
 
@@ -29,6 +29,48 @@ function hash(value: unknown): string {
   return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
 
+const analysisPhaseLabels = {
+  extracting_evidence: "整理用户经历",
+  scoring_candidates: "扫描候选分钟",
+  checking_robustness: "检查候选稳定性",
+  planning_question: "生成语义问题机会",
+  reasoning: "选择下一步动作",
+  rendering: "生成安全回复",
+} as const;
+
+const diagnosticLabels = {
+  leave_one_event_out: "留一事件稳定性",
+  leave_one_domain_out: "留一领域稳定性",
+  date_sensitivity: "日期敏感性",
+  neighbor_stability: "相邻分钟稳定性",
+  candidate_split: "候选分裂诊断",
+} as const;
+
+type AnalysisPhase = keyof typeof analysisPhaseLabels;
+
+export function publicRectificationTechniques(result: CandidateEngineResult | null): string[] {
+  if (!result) return [];
+  const techniques = new Set<string>();
+  const add = (value: string) => {
+    const normalized = value.toLocaleLowerCase();
+    if (normalized.includes("vim")) techniques.add("Vimshottari Dasha");
+    if (normalized.includes("narayana")) techniques.add("Narayana Dasha");
+    if (normalized.includes("controlled_transit")) techniques.add("木星/土星受控行运");
+    if (normalized.includes("ashtakavarga")) techniques.add("Ashtakavarga");
+    if (normalized.includes("shadbala")) techniques.add("Shadbala 已验证分量");
+    for (const layer of ["D2", "D4", "D9", "D10", "D11", "D24", "D30"] as const) {
+      if (new RegExp(`(?:^|[^0-9])${layer}(?:$|[^0-9])`, "i").test(value)) techniques.add(layer);
+    }
+  };
+  for (const candidate of Object.values(result.contributionMatrix)) {
+    for (const contribution of Object.values(candidate)) {
+      contribution.rule_ids.forEach(add);
+      contribution.technique_layers.forEach(add);
+    }
+  }
+  return [...techniques];
+}
+
 export async function processRectificationAgentTurn(input: Readonly<{
   claimed: ClaimedRectificationV4Job;
   engine: RectificationV4CandidateEngine;
@@ -41,14 +83,33 @@ export async function processRectificationAgentTurn(input: Readonly<{
   diagnostics: DiagnosticsSummary | null;
   featureSnapshot: CandidateFeatureSnapshot | null;
   validatedDecision: ValidatedDecision;
-  publicMessage: PublicMessage;
+  publicMessage: StoredPublicMessage;
   nextQuestion: RectificationV4Question | null;
   agentRun: AgentRun;
   status: "awaiting_answer" | "range_ready" | "paused";
   phase: "collecting_evidence" | "complete";
 }>> {
   const { claimed, now } = input;
-  await input.onPhase?.("extracting_evidence");
+  const stages: RectificationAnalysisTrace["stages"] = [];
+  let activePhase: AnalysisPhase | null = null;
+  let activePhaseStarted = 0;
+  const finishPhase = (status: "completed" | "failed" = "completed") => {
+    if (!activePhase) return;
+    stages.push({
+      phase: activePhase,
+      label: analysisPhaseLabels[activePhase],
+      status,
+      durationMs: Math.max(0, Date.now() - activePhaseStarted),
+    });
+    activePhase = null;
+  };
+  const enterPhase = async (phase: AnalysisPhase) => {
+    finishPhase();
+    activePhase = phase;
+    activePhaseStarted = Date.now();
+    await input.onPhase?.(phase);
+  };
+  await enterPhase("extracting_evidence");
   const asOfDate = now.toISOString().slice(0, 10);
   let reconciliation = claimed.turn.answer ? reconcileV4Evidence({
     caseId: claimed.case.id,
@@ -88,11 +149,16 @@ export async function processRectificationAgentTurn(input: Readonly<{
   let snapshot: CandidateSnapshot | null = null;
   let diagnostics: DiagnosticsSummary | null = null;
   let featureSnapshot: CandidateFeatureSnapshot | null = null;
+  let engineResult: CandidateEngineResult | null = null;
+  const analysisToolCalls: RectificationAnalysisTrace["toolCalls"] = [];
 
   if (scoreable.length >= 3 && domains.size >= 2) {
-    await input.onPhase?.("scoring_candidates");
+    await enterPhase("scoring_candidates");
+    const engineStarted = Date.now();
     const scored = await input.engine.score({ calculationSpec: claimed.case.calculationSpec, events: scoreable });
-    await input.onPhase?.("checking_robustness");
+    engineResult = scored;
+    analysisToolCalls.push({ category: "candidate_engine", label: "候选分钟扫描与稳定性诊断", outcome: "succeeded", durationMs: Date.now() - engineStarted });
+    await enterPhase("checking_robustness");
     const clusters = buildCandidateClusters(scored.candidates);
     const robustness = {
       neighborSupportMinutes: scored.robustness.neighborSupportMinutes,
@@ -191,7 +257,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
     createdAt: now.toISOString(),
   });
 
-  await input.onPhase?.("planning_question");
+  await enterPhase("planning_question");
   const opportunities = buildQuestionOpportunities({
     caseId: claimed.case.id,
     events,
@@ -201,7 +267,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
     targetDisposition: reconciliation.targetDisposition,
     retryTargetEventIds: reconciliation.unansweredTargetEventId ? [reconciliation.unansweredTargetEventId] : [],
   });
-  await input.onPhase?.("reasoning");
+  await enterPhase("reasoning");
   const reasoned = await runBoundedReasoner({
     caseValue: claimed.case,
     snapshot,
@@ -259,7 +325,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
     selectedOpportunity,
   };
 
-  await input.onPhase?.("rendering");
+  await enterPhase("rendering");
   const legacyProjection = projectLegacyV4Turn({
     events,
     newEvents: extracted,
@@ -268,7 +334,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
     snapshot,
   });
   const agentVisible = claimed.case.deploymentMode === "v5_agent";
-  const publicMessage = agentVisible
+  const renderedMessage = agentVisible
     ? await renderPublicTurn({
       caseValue: claimed.case,
       latestAnswer: claimed.turn.answer,
@@ -279,6 +345,25 @@ export async function processRectificationAgentTurn(input: Readonly<{
       validated: validatedDecision,
     })
     : legacyProjection.publicMessage;
+  finishPhase();
+  for (const call of reasoned.toolCalls) {
+    analysisToolCalls.push({
+      category: "agent_diagnostic",
+      label: call.diagnostic ? diagnosticLabels[call.diagnostic] : "只读诊断",
+      outcome: call.outcome,
+      durationMs: call.durationMs,
+    });
+  }
+  const reasoningSummary = reasoned.mode === "agent" && !fallbackReason ? reasoned.reasoningSummary : null;
+  const analysisTrace: RectificationAnalysisTrace = {
+    status: claimed.case.deploymentMode === "v4_legacy" ? "legacy" : "completed",
+    stages,
+    toolCalls: analysisToolCalls,
+    techniques: publicRectificationTechniques(engineResult),
+    reasoningSummary,
+    reasoningSource: reasoningSummary ? "provider_summary" : "none",
+  };
+  const publicMessage: StoredPublicMessage = { ...renderedMessage, analysisTrace };
   const nextQuestion = agentVisible && selectedOpportunity ? {
     id: randomUUID(),
     domain: selectedOpportunity.domain,
diff --git a/frontend/src/lib/rectification-agent/reasoner-agent.ts b/frontend/src/lib/rectification-agent/reasoner-agent.ts
index d36e1864..a493161f 100644
--- a/frontend/src/lib/rectification-agent/reasoner-agent.ts
+++ b/frontend/src/lib/rectification-agent/reasoner-agent.ts
@@ -20,12 +20,40 @@ import {
 
 const skillPath = process.env.RECTIFICATION_SKILL_PATH?.trim() || path.resolve(process.cwd(), "..", "skills", "birth-time-rectification");
 type Usage = Readonly<{ inputTokens?: number; outputTokens?: number }>;
-type GeneratedDecision = Readonly<{ object: unknown; totalUsage?: Usage | Promise<Usage> }>;
+type GeneratedDecision = Readonly<{
+  object: unknown;
+  totalUsage?: Usage | Promise<Usage>;
+  reasoningSummary?: string | null;
+  reasoningSource?: "provider_summary" | null;
+}>;
 export type RectificationReasonerGenerator = (
   prompt: string,
   phase: "initial" | "after_diagnostic",
 ) => Promise<GeneratedDecision>;
 
+const unsafeReasoningPattern = /(?:[0-9a-f]{8}-[0-9a-f-]{27,}|(?:[01]\d|2[0-3]):[0-5]\d|(?:凌晨|清晨|上午|中午|下午|傍晚|晚上)?[零〇一二两三四五六七八九十百\d]{1,4}[点时](?:[零〇一二两三四五六七八九十百\d]{1,4}分?)?|opportunity(?:id)?|snapshot(?:id)?|event(?:id)?|tool[ _-]?call|score|diagnostic|rule[ _-]?id|贡献矩阵|内部字段|权重|保留率|比例|百分之|分数|得分|阈值|边际|cluster|D\d{1,2})/iu;
+
+function compactText(value: string): string {
+  return value.replace(/\s+/gu, "").toLocaleLowerCase();
+}
+
+export function sanitizeReasoningSummary(value: unknown, sensitiveTexts: readonly string[] = []): string | null {
+  if (typeof value !== "string") return null;
+  const text = value.replace(/\s+/gu, " ").trim();
+  if (!text || unsafeReasoningPattern.test(text)) return null;
+  const compact = compactText(text);
+  for (const sensitiveText of sensitiveTexts) {
+    const source = compactText(sensitiveText);
+    if (source.length < 2) continue;
+    const overlapLength = Math.min(4, source.length);
+    for (let index = 0; index <= source.length - overlapLength; index += 1) {
+      if (compact.includes(source.slice(index, index + overlapLength))) return null;
+    }
+  }
+  const sentences = text.match(/[^。！？!?]+[。！？!?]?/gu)?.slice(0, 2).join("").trim() ?? text;
+  return sentences.slice(0, 240).trim() || null;
+}
+
 function diagnosticPayload(diagnostic: RectificationDiagnostic, summary: DiagnosticsSummary) {
   switch (diagnostic) {
     case "leave_one_event_out": return { retentionRate: summary.leaveOneEventOutRetentionRate, unstableEventIds: summary.unstableEventIds };
@@ -95,6 +123,7 @@ export async function runBoundedReasoner(input: Readonly<{
   inputTokenCount: number | null;
   outputTokenCount: number | null;
   latencyMs: number;
+  reasoningSummary: string | null;
 }>> {
   const started = Date.now();
   const deploymentSha = process.env.DEPLOYMENT_SHA?.trim() || null;
@@ -116,6 +145,7 @@ export async function runBoundedReasoner(input: Readonly<{
       inputTokenCount: usageObserved ? inputTokenCount : null,
       outputTokenCount: usageObserved ? outputTokenCount : null,
       latencyMs: Date.now() - started,
+      reasoningSummary: null,
     };
   };
   if (input.enabled === false) return fallback("deployment_mode_legacy");
@@ -160,13 +190,30 @@ export async function runBoundedReasoner(input: Readonly<{
     tools: { run_rectification_diagnostics: diagnosticsTool },
     instructions: "Choose one server-owned action. Never create an event id, candidate, score, date, question, calculation input, or birth minute. Ask only by opportunityId. Candidate ranges may only use currentSnapshotId. You may request or call one diagnostic, then must return a final non-diagnostic action. Return strict structured output.",
   }) : null;
+  const isOpenAiProvider = model?.mode === "openai";
   const generate: RectificationReasonerGenerator = input.generateDecision ?? (async (prompt) => {
     if (!agent) throw new Error("reasoner_model_unavailable");
-    return agent.generate(prompt, {
+    let reasoningSummary = "";
+    const stream = await agent.stream(prompt, {
       abortSignal: AbortSignal.timeout(input.timeoutMs ?? 20_000),
       maxSteps: maxToolCalls + 2,
+      providerOptions: isOpenAiProvider
+        ? { openai: { reasoningEffort: "high", reasoningSummary: "auto" } }
+        : undefined,
       structuredOutput: { schema: rectificationDecisionSchema, jsonPromptInjection: "inline" },
     });
+    for await (const chunk of stream.fullStream) {
+      const isOpenAiSummary = isOpenAiProvider && chunk.type === "reasoning-delta";
+      if (isOpenAiSummary && reasoningSummary.length < 2_000) {
+        reasoningSummary += chunk.payload.text.slice(0, 2_000 - reasoningSummary.length);
+      }
+    }
+    return {
+      object: await stream.object,
+      totalUsage: stream.totalUsage,
+      reasoningSummary,
+      reasoningSource: reasoningSummary ? "provider_summary" : null,
+    };
   });
   const addUsage = async (result: GeneratedDecision) => {
     if (!result.totalUsage) return;
@@ -176,11 +223,22 @@ export async function runBoundedReasoner(input: Readonly<{
     usageObserved = true;
   };
   const baseState = buildReasonerState(input);
+  const sensitiveTexts = [
+    baseState.latestAnswer,
+    ...baseState.recentTurns.flatMap((turn) => [turn.question, turn.answer]),
+    ...baseState.recentEvents.flatMap((event) => [event.summary, event.date]),
+    ...(baseState.currentTarget ? [baseState.currentTarget.summary, baseState.currentTarget.date] : []),
+    ...baseState.opportunities.flatMap((opportunity) => opportunity.anchors),
+  ];
+  let reasoningSummary: string | null = null;
 
   recordRectificationAgentTelemetry({ caseId: input.caseValue.id, phase: "reasoner", outcome: "started", modelId, toolName: null, decisionAction: null, durationMs: null, errorCode: null, deploymentSha });
   try {
     const first = await generate(JSON.stringify(baseState), "initial");
     await addUsage(first);
+    reasoningSummary = first.reasoningSource === "provider_summary"
+      ? sanitizeReasoningSummary(first.reasoningSummary, sensitiveTexts)
+      : null;
     let decision = rectificationDecisionSchema.parse(first.object);
     if (decision.action === "run_diagnostic") {
       const result = await readDiagnostic(decision.diagnostic);
@@ -190,6 +248,9 @@ export async function runBoundedReasoner(input: Readonly<{
         diagnosticResult: { diagnostic: decision.diagnostic, result },
       }), "after_diagnostic");
       await addUsage(second);
+      reasoningSummary = second.reasoningSource === "provider_summary"
+        ? sanitizeReasoningSummary(second.reasoningSummary, sensitiveTexts) ?? reasoningSummary
+        : reasoningSummary;
       decision = rectificationDecisionSchema.parse(second.object);
       if (decision.action === "run_diagnostic") return fallback("reasoner_returned_nonfinal_diagnostic");
     }
@@ -200,6 +261,7 @@ export async function runBoundedReasoner(input: Readonly<{
       inputTokenCount: usageObserved ? inputTokenCount : null,
       outputTokenCount: usageObserved ? outputTokenCount : null,
       latencyMs,
+      reasoningSummary,
     };
   } catch (error) {
     const reason = error instanceof DOMException && error.name === "TimeoutError" ? "reasoner_timeout"
diff --git a/frontend/src/lib/rectification-v4/case-service.ts b/frontend/src/lib/rectification-v4/case-service.ts
index 20f6df7e..7c1e89a0 100644
--- a/frontend/src/lib/rectification-v4/case-service.ts
+++ b/frontend/src/lib/rectification-v4/case-service.ts
@@ -26,15 +26,19 @@ export function createRectificationV4CaseService(
   const realizeQuestion = options.regenerateQuestion ?? regenerateQuestionRealization;
 
   async function response(userId: string, caseValue: RectificationV4Case, jobId?: string): Promise<RectificationV4ApiResponse> {
-    const [events, turns] = await Promise.all([
+    const [events, turns, analysis] = await Promise.all([
       store.loadEvents(userId, caseValue.id),
       store.loadTurns(userId, caseValue.id),
+      caseValue.deploymentMode === "v5_agent"
+        ? store.loadAnalysisMessages(userId, caseValue.id)
+        : Promise.resolve([]),
     ]);
     return {
       case: caseValue,
       job: jobId ? await store.loadJob(userId, jobId) : null,
       events: [...events],
       turns: [...turns],
+      analysis: [...analysis],
     };
   }
 
diff --git a/frontend/src/lib/rectification-v4/contracts.ts b/frontend/src/lib/rectification-v4/contracts.ts
index 4d18165c..91d75009 100644
--- a/frontend/src/lib/rectification-v4/contracts.ts
+++ b/frontend/src/lib/rectification-v4/contracts.ts
@@ -270,11 +270,49 @@ export const rectificationV4JobSchema = z.object({
 }).strict();
 export type RectificationV4Job = z.infer<typeof rectificationV4JobSchema>;
 
+export const rectificationAnalysisStageSchema = z.object({
+  phase: z.enum([
+    "extracting_evidence",
+    "scoring_candidates",
+    "checking_robustness",
+    "planning_question",
+    "reasoning",
+    "rendering",
+  ]),
+  label: z.string().trim().min(1).max(120),
+  status: z.enum(["completed", "failed"]),
+  durationMs: z.number().int().min(0).max(300_000).nullable(),
+}).strict();
+
+export const rectificationAnalysisToolCallSchema = z.object({
+  category: z.enum(["candidate_engine", "diagnostic", "agent_diagnostic"]),
+  label: z.string().trim().min(1).max(120),
+  outcome: z.enum(["succeeded", "failed", "rejected"]),
+  durationMs: z.number().int().min(0).max(300_000).nullable(),
+}).strict();
+
+export const rectificationAnalysisTraceSchema = z.object({
+  status: z.enum(["completed", "failed", "legacy"]),
+  stages: z.array(rectificationAnalysisStageSchema).max(12),
+  toolCalls: z.array(rectificationAnalysisToolCallSchema).max(16),
+  techniques: z.array(z.string().trim().min(1).max(120)).max(24),
+  reasoningSummary: z.string().trim().min(1).max(500).nullable(),
+  reasoningSource: z.enum(["provider_summary", "none"]),
+}).strict();
+export type RectificationAnalysisTrace = z.infer<typeof rectificationAnalysisTraceSchema>;
+
+export const rectificationAnalysisItemSchema = z.object({
+  sourceTurnId: z.string().uuid(),
+  trace: rectificationAnalysisTraceSchema,
+}).strict();
+export type RectificationAnalysisItem = z.infer<typeof rectificationAnalysisItemSchema>;
+
 export const rectificationV4ApiResponseSchema = z.object({
   case: rectificationV4CaseSchema,
   job: rectificationV4JobSchema.nullable(),
   events: z.array(lifeEventRevisionSchema),
   turns: z.array(rectificationV4TurnSchema),
+  analysis: z.array(rectificationAnalysisItemSchema).optional(),
 }).strict();
 export type RectificationV4ApiResponse = z.infer<typeof rectificationV4ApiResponseSchema>;
 
diff --git a/frontend/src/lib/rectification-v4/memory-store.ts b/frontend/src/lib/rectification-v4/memory-store.ts
index 154787c5..e61e15b3 100644
--- a/frontend/src/lib/rectification-v4/memory-store.ts
+++ b/frontend/src/lib/rectification-v4/memory-store.ts
@@ -1,4 +1,4 @@
-import type { AgentRun, CandidateFeatureSnapshot, DiagnosticsSummary, PublicMessage, ValidatedDecision } from "../rectification-agent/contracts.ts";
+import type { AgentRun, CandidateFeatureSnapshot, DiagnosticsSummary, StoredPublicMessage, ValidatedDecision } from "../rectification-agent/contracts.ts";
 import type {
   LifeEventRevision,
   PendingEvidence,
@@ -20,7 +20,7 @@ export function createRectificationV4MemoryStore(): RectificationV4Store & {
   readonly diagnostics: Map<string, DiagnosticsSummary>;
   readonly featureSnapshots: Map<string, CandidateFeatureSnapshot>;
   readonly agentRuns: Map<string, AgentRun>;
-  readonly publicMessages: Map<string, PublicMessage>;
+  readonly publicMessages: Map<string, StoredPublicMessage>;
   readonly validatedDecisions: Map<string, ValidatedDecision>;
   readonly pendingEvidence: Map<string, PendingEvidence>;
 } {
@@ -32,7 +32,7 @@ export function createRectificationV4MemoryStore(): RectificationV4Store & {
   const diagnostics = new Map<string, DiagnosticsSummary>();
   const featureSnapshots = new Map<string, CandidateFeatureSnapshot>();
   const agentRuns = new Map<string, AgentRun>();
-  const publicMessages = new Map<string, PublicMessage>();
+  const publicMessages = new Map<string, StoredPublicMessage>();
   const validatedDecisions = new Map<string, ValidatedDecision>();
   const pendingEvidence = new Map<string, PendingEvidence>();
 
@@ -69,6 +69,13 @@ export function createRectificationV4MemoryStore(): RectificationV4Store & {
         .filter((turn) => turn.caseId === caseId)
         .sort((left, right) => left.caseVersion - right.caseVersion || left.createdAt.localeCompare(right.createdAt));
     },
+    async loadAnalysisMessages(userId, caseId) {
+      owned(userId, caseId);
+      return [...jobs.values()]
+        .filter((job) => job.caseId === caseId && publicMessages.get(job.id)?.analysisTrace)
+        .sort((left, right) => turns.get(left.turnId)!.caseVersion - turns.get(right.turnId)!.caseVersion)
+        .map((job) => ({ sourceTurnId: job.turnId, trace: publicMessages.get(job.id)!.analysisTrace! }));
+    },
     async loadLatestValidatedDecision(userId, caseId) {
       const caseValue = cases.get(caseId);
       if (!caseValue || caseValue.userId !== userId) return null;
diff --git a/frontend/src/lib/rectification-v4/store.ts b/frontend/src/lib/rectification-v4/store.ts
index 39d59707..76a6b6fe 100644
--- a/frontend/src/lib/rectification-v4/store.ts
+++ b/frontend/src/lib/rectification-v4/store.ts
@@ -1,8 +1,9 @@
-import type { AgentRun, CandidateFeatureSnapshot, DiagnosticsSummary, PublicMessage, ValidatedDecision } from "../rectification-agent/contracts.ts";
+import type { AgentRun, CandidateFeatureSnapshot, DiagnosticsSummary, StoredPublicMessage, ValidatedDecision } from "../rectification-agent/contracts.ts";
 import type {
   CandidateSnapshot,
   LifeEventRevision,
   PendingEvidence,
+  RectificationAnalysisItem,
   RectificationV4Case,
   RectificationV4Job,
   RectificationV4Phase,
@@ -33,7 +34,7 @@ export type CompleteRectificationV4JobInput = Readonly<{
   diagnostics: DiagnosticsSummary | null;
   featureSnapshot: CandidateFeatureSnapshot | null;
   validatedDecision: ValidatedDecision;
-  publicMessage: PublicMessage;
+  publicMessage: StoredPublicMessage;
   agentRun: AgentRun;
   nextQuestion: RectificationV4Question | null;
   status: RectificationV4Case["status"];
@@ -45,6 +46,7 @@ export interface RectificationV4Store {
   loadCase(userId: string, caseId: string): Promise<RectificationV4Case | null>;
   loadEvents(userId: string, caseId: string): Promise<readonly LifeEventRevision[]>;
   loadTurns(userId: string, caseId: string): Promise<readonly RectificationV4Turn[]>;
+  loadAnalysisMessages(userId: string, caseId: string): Promise<readonly RectificationAnalysisItem[]>;
   loadLatestValidatedDecision(userId: string, caseId: string): Promise<ValidatedDecision | null>;
   loadActionCase(userId: string, actionId: string): Promise<RectificationV4Case | null>;
   createCase(input: { readonly case: RectificationV4Case; readonly actionId: string }): Promise<RectificationV4Case>;
diff --git a/frontend/src/lib/rectification-v4/supabase-store.ts b/frontend/src/lib/rectification-v4/supabase-store.ts
index 8b1c8b28..914099cd 100644
--- a/frontend/src/lib/rectification-v4/supabase-store.ts
+++ b/frontend/src/lib/rectification-v4/supabase-store.ts
@@ -1,13 +1,15 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import { validatedDecisionSchema, type ValidatedDecision } from "../rectification-agent/contracts.ts";
+import { storedPublicMessageSchema, validatedDecisionSchema, type ValidatedDecision } from "../rectification-agent/contracts.ts";
 import {
   candidateSnapshotSchema,
   lifeEventRevisionSchema,
+  rectificationAnalysisItemSchema,
   rectificationV4CaseSchema,
   rectificationV4JobSchema,
   rectificationV4TurnSchema,
   type CandidateSnapshot,
   type LifeEventRevision,
+  type RectificationAnalysisItem,
   type RectificationV4Case,
   type RectificationV4Job,
   type RectificationV4Turn,
@@ -22,6 +24,24 @@ import { evidenceSetHash, rectificationFingerprint } from "./fingerprints.ts";
 
 type Row = Record<string, unknown>;
 
+export function projectAnalysisMessages(
+  publicMessageRows: readonly Readonly<Row>[],
+  jobRows: readonly Readonly<Row>[],
+): readonly RectificationAnalysisItem[] {
+  const turnByJob = new Map(jobRows.map((row) => [String(row.id), row.turn_id]));
+  return [...publicMessageRows]
+    .sort((left, right) => timestamp(left.created_at).localeCompare(timestamp(right.created_at)))
+    .flatMap((row) => {
+      const message = storedPublicMessageSchema.safeParse(row.message);
+      if (!message.success || !message.data.analysisTrace) return [];
+      const item = rectificationAnalysisItemSchema.safeParse({
+        sourceTurnId: turnByJob.get(String(row.job_id)),
+        trace: message.data.analysisTrace,
+      });
+      return item.success ? [item.data] : [];
+    });
+}
+
 function timestamp(value: unknown): string {
   return value instanceof Date ? value.toISOString() : String(value);
 }
@@ -183,6 +203,21 @@ export function createRectificationV4SupabaseStore(supabase: SupabaseClient): Re
     return ((data ?? []) as Row[]).map(turnValue);
   }
 
+  async function loadAnalysisMessagesByCase(userId: string, caseId: string): Promise<readonly RectificationAnalysisItem[]> {
+    if (!await loadCaseById(userId, caseId)) throw new RectificationV4StoreError("not_found");
+    const { data, error } = await supabase.from("birth_time_rectification_public_messages")
+      .select("job_id,message,created_at").eq("case_id", caseId).eq("user_id", userId)
+      .order("created_at", { ascending: true });
+    if (error) throw storeError(error);
+    const rows = (data ?? []) as Row[];
+    if (rows.length === 0) return [];
+    const jobIds = rows.map((row) => String(row.job_id));
+    const { data: jobData, error: jobError } = await supabase.from("birth_time_rectification_v4_jobs")
+      .select("id,turn_id").eq("case_id", caseId).eq("user_id", userId).in("id", jobIds);
+    if (jobError) throw storeError(jobError);
+    return projectAnalysisMessages(rows, (jobData ?? []) as Row[]);
+  }
+
   async function rpc(name: string, args: Row): Promise<unknown> {
     const { data, error } = await supabase.rpc(name, args);
     if (error) throw storeError(error);
@@ -200,6 +235,7 @@ export function createRectificationV4SupabaseStore(supabase: SupabaseClient): Re
     loadCase: loadCaseById,
     loadEvents: loadEventsByCase,
     loadTurns: loadTurnsByCase,
+    loadAnalysisMessages: loadAnalysisMessagesByCase,
     async loadLatestValidatedDecision(userId, caseId): Promise<ValidatedDecision | null> {
       const { data, error } = await supabase.from("birth_time_rectification_agent_runs")
         .select("validated_decision_json").eq("case_id", caseId).eq("user_id", userId)
diff --git a/frontend/tests/conversational-rectification-component.test.ts b/frontend/tests/conversational-rectification-component.test.ts
index 7030d996..46d4d476 100644
--- a/frontend/tests/conversational-rectification-component.test.ts
+++ b/frontend/tests/conversational-rectification-component.test.ts
@@ -4,6 +4,7 @@ import test from "node:test";
 import {
   canRegenerateRectificationMessage,
   rectificationV4ChatMessages,
+  rectificationPhaseLabel,
   toggleRectificationFeedback,
 } from "../src/components/rectification-v4-panel.tsx";
 import type { RectificationV4ApiResponse } from "../src/lib/rectification-v4/contracts.ts";
@@ -59,6 +60,7 @@ function response(overrides: Record<string, unknown> = {}): RectificationV4ApiRe
     },
     job: null,
     events: [],
+    analysis: [],
     turns: [{
       id: "00000000-0000-4000-8000-000000000903",
       caseId: id,
@@ -72,7 +74,28 @@ function response(overrides: Record<string, unknown> = {}): RectificationV4ApiRe
       actionId: "00000000-0000-4000-8000-000000000905",
       createdAt: now,
     }],
-  };
+  } as unknown as RectificationV4ApiResponse;
+}
+
+function analysisTrace(label: string) {
+  return {
+    status: "completed",
+    stages: [{
+      phase: "extracting_evidence",
+      label,
+      status: "completed",
+      durationMs: 320,
+    }],
+    toolCalls: [{
+      category: "candidate_engine",
+      label: "候选分钟扫描",
+      outcome: "succeeded",
+      durationMs: 840,
+    }],
+    techniques: ["Vimshottari Dasha", "D24"],
+    reasoningSummary: "现有证据更适合继续收集另一件时间明确的经历。",
+    reasoningSource: "provider_summary",
+  } as const;
 }
 
 test("v4 rectification reuses the ordinary session message list, composer, and model selector", () => {
@@ -93,7 +116,14 @@ test("v4 rectification reuses the ordinary session message list, composer, and m
   assert.match(component, /<ModelSelector/);
   assert.match(component, /aria-label="赞"/);
   assert.match(component, /aria-label="踩"/);
+  assert.match(component, /aria-label="复制回答"/);
   assert.match(component, /aria-label="重新生成回答"/);
+  assert.match(component, /<details className="rectification-analysis">/);
+  assert.match(component, /<span>分析过程<\/span>/);
+  assert.match(
+    component,
+    /<RectificationAnalysisDetails trace=\{message\.analysisTrace\} \/>[\s\S]*?<div className="rectification-message-actions"/,
+  );
   assert.match(component, /caseValue\?\.deploymentMode === "v5_agent"/);
   assert.match(component, /controller\.regenerate\(\)/);
   assert.match(component, /controller\.answer\(answer, props\.selectedModelId \|\| null\)/);
@@ -151,10 +181,95 @@ test("turn history and the context-aware next question render as one chat timeli
   ]);
 });
 
-test("processing is an ordinary assistant thinking message after the saved answer", () => {
-  const messages = rectificationV4ChatMessages(response({ currentQuestion: null, status: "processing" }), true);
+test("completed analysis is attached to the next Agent message by source turn", () => {
+  const base = response();
+  const firstTurn = base.turns[0]!;
+  const secondTurn = {
+    ...firstTurn,
+    id: "00000000-0000-4000-8000-000000000906",
+    caseVersion: 2,
+    questionId: "00000000-0000-4000-8000-000000000907",
+    question: "承接复读后再次毕业，你还记得哪次职业变化的大概时间？",
+    answer: "2020年4月去研究院实习。",
+    actionId: "00000000-0000-4000-8000-000000000908",
+  };
+  const firstTrace = analysisTrace("整理第一轮经历");
+  const secondTrace = analysisTrace("整理第二轮经历");
+  const data = {
+    ...base,
+    turns: [firstTurn, secondTurn],
+    analysis: [
+      { sourceTurnId: firstTurn.id, trace: firstTrace },
+      { sourceTurnId: secondTurn.id, trace: secondTrace },
+    ],
+  } as unknown as RectificationV4ApiResponse;
+
+  const assistantMessages = rectificationV4ChatMessages(data, false)
+    .filter((message) => message.role === "assistant");
+
+  assert.equal(assistantMessages[0]?.analysisTrace, undefined);
+  assert.equal(assistantMessages[1]?.analysisTrace, firstTrace);
+  assert.equal(assistantMessages[2]?.analysisTrace, secondTrace);
+});
+
+test("legacy and shadow modes do not expose persisted analysis traces", () => {
+  const base = response();
+  const trace = analysisTrace("不应显示");
+  for (const deploymentMode of ["v4_legacy", "v5_shadow"] as const) {
+    const data = {
+      ...base,
+      case: { ...base.case, deploymentMode },
+      analysis: [{ sourceTurnId: base.turns[0]!.id, trace }],
+    } as unknown as RectificationV4ApiResponse;
+    assert.equal(
+      rectificationV4ChatMessages(data, false).some((message) => message.analysisTrace),
+      false,
+      deploymentMode,
+    );
+  }
+});
+
+test("processing shows the current server job phase in Chinese", () => {
+  const base = response({ currentQuestion: null, status: "processing", phase: "checking_robustness" });
+  const data = {
+    ...base,
+    job: {
+      id: "00000000-0000-4000-8000-000000000909",
+      caseId: id,
+      status: "processing",
+      phase: "checking_robustness",
+      expectedCaseVersion: 2,
+      evidenceSetHash: "b".repeat(64),
+      calculationSpecHash: "a".repeat(64),
+      errorCode: null,
+      createdAt: now,
+      updatedAt: now,
+    },
+  } as unknown as RectificationV4ApiResponse;
+  const messages = rectificationV4ChatMessages(data, true);
   assert.equal(messages.at(-1)?.role, "assistant");
   assert.equal(messages.at(-1)?.state, "thinking");
+  assert.equal(messages.at(-1)?.text, "正在检查候选范围的稳定性…");
+  assert.equal(rectificationPhaseLabel("planning_question"), "正在选择下一条最有信息量的问题…");
+});
+
+test("analysis details render only public labels and preserve the message action icons", () => {
+  const component = readFileSync(new URL("../src/components/rectification-v4-panel.tsx", import.meta.url), "utf8");
+  const css = readFileSync(new URL("../src/app/globals.css", import.meta.url), "utf8");
+
+  assert.match(component, /\{stage\.label\}/);
+  assert.match(component, /\{toolCall\.label\}/);
+  assert.match(component, /trace\.techniques\.join\("、"\)/);
+  assert.match(component, /trace\.reasoningSource === "provider_summary"/);
+  assert.doesNotMatch(component, />\{stage\.phase\}</);
+  assert.doesNotMatch(component, />\{toolCall\.category\}</);
+  assert.doesNotMatch(component, />\{item\.sourceTurnId\}</);
+  assert.match(component, /<ThumbsUp aria-hidden="true" \/>/);
+  assert.match(component, /<ThumbsDown aria-hidden="true" \/>/);
+  assert.match(component, /<Copy aria-hidden="true" \/>/);
+  assert.match(component, /<RotateCcw aria-hidden="true" \/>/);
+  assert.match(css, /\.rectification-analysis > summary/);
+  assert.doesNotMatch(component, /candidateScore|contributionMatrix|opportunityId|snapshotId/);
 });
 
 test("range messages never claim an exact confirmed birth minute", () => {
diff --git a/frontend/tests/rectification-agent-v5.test.ts b/frontend/tests/rectification-agent-v5.test.ts
index fe91dd29..c67d4202 100644
--- a/frontend/tests/rectification-agent-v5.test.ts
+++ b/frontend/tests/rectification-agent-v5.test.ts
@@ -361,17 +361,27 @@ test("shadow mode persists V5 artifacts while preserving the legacy visible repl
       });
       assert.ok(queued?.job);
       await worker.runOnce();
+      const loaded = await service.loadCase(userId, created.case.id);
       return {
         message: [...store.publicMessages.values()][0],
-        question: (await service.loadCase(userId, created.case.id))?.case.currentQuestion,
+        question: loaded?.case.currentQuestion,
+        analysis: loaded?.analysis ?? [],
         agentRuns: store.agentRuns.size,
       };
     });
   }
   const legacy = await run("v4_legacy");
   const shadow = await run("v5_shadow");
-  assert.deepEqual(shadow.message, legacy.message);
+  const visibleMessage = (message: NonNullable<typeof legacy.message>) => ({
+    acknowledgement: message.acknowledgement,
+    candidateUpdate: message.candidateUpdate,
+    limitation: message.limitation,
+    question: message.question,
+  });
+  assert.deepEqual(visibleMessage(shadow.message!), visibleMessage(legacy.message!));
   assert.equal(shadow.question?.prompt, legacy.question?.prompt);
+  assert.deepEqual(legacy.analysis, []);
+  assert.deepEqual(shadow.analysis, []);
   assert.equal(shadow.agentRuns, 1);
 });
 
diff --git a/frontend/tests/rectification-analysis-trace.test.ts b/frontend/tests/rectification-analysis-trace.test.ts
new file mode 100644
index 00000000..3fe839a5
--- /dev/null
+++ b/frontend/tests/rectification-analysis-trace.test.ts
@@ -0,0 +1,432 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import test from "node:test";
+
+import {
+  diagnosticsSummarySchema,
+  storedPublicMessageSchema,
+  type DiagnosticsSummary,
+  type QuestionOpportunity,
+} from "../src/lib/rectification-agent/contracts.ts";
+import { processRectificationAgentTurn } from "../src/lib/rectification-agent/orchestrator.ts";
+import { runBoundedReasoner, sanitizeReasoningSummary } from "../src/lib/rectification-agent/reasoner-agent.ts";
+import { createRectificationV4CaseService } from "../src/lib/rectification-v4/case-service.ts";
+import type { CandidateEngineResult } from "../src/lib/rectification-v4/candidate-engine.ts";
+import type {
+  CalculationSpec,
+  LifeEventRevision,
+  RectificationAnalysisTrace,
+  RectificationV4Case,
+  RectificationV4Turn,
+} from "../src/lib/rectification-v4/contracts.ts";
+import { calculationSpecHash } from "../src/lib/rectification-v4/fingerprints.ts";
+import { createRectificationV4MemoryStore } from "../src/lib/rectification-v4/memory-store.ts";
+import { projectAnalysisMessages } from "../src/lib/rectification-v4/supabase-store.ts";
+import type { ClaimedRectificationV4Job } from "../src/lib/rectification-v4/store.ts";
+import { createRectificationV4Worker } from "../src/lib/rectification-v4/worker.ts";
+import { v5EngineResult, withV5Mode } from "./rectification-v5-test-support.ts";
+
+const now = "2026-07-29T00:00:00.000Z";
+const spec: CalculationSpec = {
+  version: "rectification-calculation-spec-v4",
+  birthDate: "1997-08-08",
+  candidateRange: { start: "05:00", end: "06:00" },
+  latitude: 36.419,
+  longitude: 114.213,
+  timezoneOffsetHours: 8,
+  ayanamsa: "lahiri",
+  nodeMode: "mean",
+  minuteStep: 1,
+};
+
+function event(
+  domain: LifeEventRevision["domain"],
+  eventKind: LifeEventRevision["eventKind"],
+  summary: string,
+  date: string,
+): LifeEventRevision {
+  return {
+    id: randomUUID(),
+    eventId: randomUUID(),
+    revision: 1,
+    domain,
+    eventKind,
+    subject: "self",
+    relatedPerson: null,
+    summary,
+    rawText: `${date} ${summary}`,
+    dateRange: { start: `${date}-01`, end: `${date}-28`, precision: "month", label: date },
+    scoreability: "scoreable",
+    supersedesRevisionId: null,
+    createdAt: now,
+  };
+}
+
+function makeClaimed(events: readonly LifeEventRevision[]): ClaimedRectificationV4Job {
+  const caseId = randomUUID();
+  const turn: RectificationV4Turn = {
+    id: randomUUID(),
+    caseId,
+    caseVersion: 1,
+    questionId: randomUUID(),
+    questionDomain: "other",
+    questionTargetEventId: null,
+    question: "请换一个方向，补充一件时间较清楚的经历。",
+    answer: "记不清了，换一个吧。",
+    modelId: null,
+    actionId: randomUUID(),
+    createdAt: now,
+  };
+  const caseValue: RectificationV4Case = {
+    id: caseId,
+    userId: randomUUID(),
+    protocol: "rectification-evidence-v5",
+    version: 1,
+    status: "processing",
+    phase: "extracting_evidence",
+    calculationSpec: spec,
+    calculationSpecHash: calculationSpecHash(spec),
+    evidenceSetHash: "e".repeat(64),
+    currentQuestion: null,
+    latestSnapshot: null,
+    orchestrationModelId: null,
+    narrationModelId: null,
+    skillVersion: "birth-time-rectification-v6",
+    promptVersion: "rectification-agent-v6-1",
+    algorithmVersion: "rectification-v5-matrix-scoring-1",
+    deploymentMode: "v5_agent",
+    agentMode: "deterministic_fallback",
+    featureSnapshotId: null,
+    latestDiagnosticsId: null,
+    acceptedRange: null,
+    createdAt: now,
+    updatedAt: now,
+  };
+  return {
+    case: caseValue,
+    turn,
+    turns: [turn],
+    events,
+    attemptedRefinementEventIds: [],
+    job: {
+      id: randomUUID(),
+      caseId,
+      status: "processing",
+      phase: "extracting_evidence",
+      expectedCaseVersion: 1,
+      evidenceSetHash: caseValue.evidenceSetHash,
+      calculationSpecHash: caseValue.calculationSpecHash,
+      errorCode: null,
+      createdAt: now,
+      updatedAt: now,
+    },
+  };
+}
+
+const opportunity: QuestionOpportunity = {
+  contractVersion: "semantic-question-v2",
+  opportunityId: randomUUID(),
+  kind: "ask_new_event",
+  domain: "career",
+  targetEventId: null,
+  goal: "收集一件有大致日期的新经历。",
+  requestedFields: ["new_dated_event"],
+  anchors: [],
+  contextFacts: [],
+  forbiddenMoves: [
+    "switch_target_event",
+    "ask_multiple_questions",
+    "claim_exact_birth_minute",
+    "invent_event",
+    "invent_date",
+    "expose_private_score",
+    "expose_internal_id",
+    "expose_technique_trace",
+  ],
+  fallbackPrompt: "请再说一件时间比较明确的经历。",
+  reason: "补充可区分的证据。",
+  expectedInformationGain: .8,
+  dateSensitivity: .5,
+  candidateSplitRelevance: .5,
+  domainCoverageGain: .8,
+  recallEase: .8,
+  novelty: 1,
+  repetitionPenalty: 0,
+  privacyCost: 0,
+  utility: .85,
+  active: true,
+};
+
+const diagnostics: DiagnosticsSummary = diagnosticsSummarySchema.parse({
+  id: randomUUID(),
+  caseId: randomUUID(),
+  snapshotId: randomUUID(),
+  primaryClusterRetentionRate: .8,
+  leaveOneEventOutRetentionRate: .8,
+  leaveOneDomainOutRetentionRate: .8,
+  dateSensitivityRetentionRate: .8,
+  neighborSupportMinutes: 3,
+  primarySecondaryMarginPercent: 12,
+  clusterMassRatio: .8,
+  unstableEventIds: [],
+  mostDiscriminatingLayers: [],
+  eventDateSensitivity: [],
+  candidateSplits: [],
+  calculationHash: "d".repeat(64),
+  createdAt: now,
+});
+
+function analysisToolLabels(trace: RectificationAnalysisTrace, category: RectificationAnalysisTrace["toolCalls"][number]["category"]): string[] {
+  return trace.toolCalls.filter((call) => call.category === category).map((call) => call.label);
+}
+
+test("provider reasoning keeps safe summaries and rejects private or copied content", async () => {
+  const safeSummary = "现有材料还不足，宜先补充一件时间较清楚的经历。";
+  const reasoned = await runBoundedReasoner({
+    caseValue: makeClaimed([]).case,
+    snapshot: null,
+    diagnostics,
+    opportunities: [opportunity],
+    generateDecision: async () => ({
+      object: { action: "ask_question", opportunityId: opportunity.opportunityId, narrativeFocus: ["uncertainty"] },
+      reasoningSummary: safeSummary,
+      reasoningSource: "provider_summary",
+    }),
+  });
+  assert.equal(reasoned.reasoningSummary, safeSummary);
+
+  const unsafe = [
+    "参考 00000000-0000-4000-8000-000000000901",
+    "候选是 05:13",
+    "score 较高",
+    "snapshotId 已更新",
+    "opportunityId 已选中",
+    "执行 tool call",
+    "采用 D9 继续判断",
+    "候选更接近清晨五点十三分",
+    "保留率低于百分之六十五",
+  ];
+  for (const value of unsafe) assert.equal(sanitizeReasoningSummary(value), null, value);
+
+  const userText = "2016年9月离家去外地上大学";
+  assert.equal(sanitizeReasoningSummary(`用户提到${userText}，所以继续。`, [userText]), null);
+  assert.equal(sanitizeReasoningSummary("母亲去世后需要继续收集证据。", ["母亲去世"]), null);
+  assert.equal(sanitizeReasoningSummary("癌症使这项证据需要谨慎处理。", ["癌症"]), null);
+
+  const unverifiedSource = await runBoundedReasoner({
+    caseValue: makeClaimed([]).case,
+    snapshot: null,
+    diagnostics,
+    opportunities: [opportunity],
+    generateDecision: async () => ({
+      object: { action: "ask_question", opportunityId: opportunity.opportunityId, narrativeFocus: [] },
+      reasoningSummary: safeSummary,
+    }),
+  });
+  assert.equal(unverifiedSource.reasoningSummary, null);
+});
+
+test("below the scoring gate does not claim candidate scanning, diagnostics, or techniques", async () => {
+  let scoreCalls = 0;
+  const result = await processRectificationAgentTurn({
+    claimed: makeClaimed([
+      event("education", "education_milestone", "离家去外地上大学", "2016-09"),
+      event("career", "career_change", "开始第一份工作", "2020-04"),
+    ]),
+    engine: { score: async () => { scoreCalls += 1; throw new Error("candidate_engine_should_not_run"); } },
+    now: new Date(now),
+  });
+  const trace = result.publicMessage.analysisTrace;
+  assert.ok(trace);
+  assert.equal(scoreCalls, 0);
+  assert.equal(result.snapshot, null);
+  assert.equal(trace.stages.some((stage) => stage.phase === "scoring_candidates"), false);
+  assert.equal(trace.stages.some((stage) => stage.phase === "checking_robustness"), false);
+  assert.deepEqual(trace.toolCalls, []);
+  assert.deepEqual(trace.techniques, []);
+});
+
+test("scoring trace records one real engine call and only matrix-confirmed techniques", async () => {
+  const claimed = makeClaimed([
+    event("education", "education_milestone", "离家去外地上大学", "2016-09"),
+    event("relocation", "relocation", "搬到北京长期居住", "2018-08"),
+    event("career", "career_change", "开始负责商业巡演公司", "2023-09"),
+  ]);
+  let scoreCalls = 0;
+  const result = await processRectificationAgentTurn({
+    claimed,
+    engine: {
+      score: async ({ calculationSpec, events }) => {
+        scoreCalls += 1;
+        const base = v5EngineResult(calculationSpec, events);
+        const contributionMatrix: CandidateEngineResult["contributionMatrix"] = Object.fromEntries(
+          Object.entries(base.contributionMatrix).map(([eventId, candidates]) => [
+            eventId,
+            Object.fromEntries(Object.entries(candidates).map(([time, contribution]) => [time, {
+              ...contribution,
+              rule_ids: ["vimshottari_dasha", "D60"],
+              technique_layers: ["D2", "D60"],
+            }])),
+          ]),
+        );
+        return { ...base, contributionMatrix };
+      },
+    },
+    now: new Date(now),
+  });
+  const trace = result.publicMessage.analysisTrace;
+  assert.ok(trace);
+  assert.equal(scoreCalls, 1);
+  assert.equal(result.snapshot?.canConfirmExactMinute, false);
+  assert.equal(trace.stages.some((stage) => stage.phase === "scoring_candidates"), true);
+  assert.equal(trace.stages.some((stage) => stage.phase === "checking_robustness"), true);
+  assert.deepEqual(analysisToolLabels(trace, "candidate_engine"), ["候选分钟扫描与稳定性诊断"]);
+  assert.deepEqual(analysisToolLabels(trace, "diagnostic"), []);
+  assert.deepEqual(new Set(trace.techniques), new Set(["Vimshottari Dasha", "D2"]));
+  assert.equal(trace.techniques.includes("D60"), false);
+  assert.equal(trace.techniques.includes("D9"), false);
+  assert.equal(trace.techniques.includes("D10"), false);
+  assert.deepEqual(analysisToolLabels(trace, "agent_diagnostic"), []);
+});
+
+test("read-only Agent diagnostics are traced only when the reasoner actually requests one", async () => {
+  const caseValue = makeClaimed([]).case;
+  const direct = await runBoundedReasoner({
+    caseValue,
+    snapshot: null,
+    diagnostics,
+    opportunities: [opportunity],
+    generateDecision: async () => ({ object: { action: "ask_question", opportunityId: opportunity.opportunityId, narrativeFocus: [] } }),
+  });
+  assert.deepEqual(direct.toolCalls, []);
+
+  const phases: string[] = [];
+  const diagnosticRun = await runBoundedReasoner({
+    caseValue,
+    snapshot: null,
+    diagnostics,
+    opportunities: [opportunity],
+    generateDecision: async (_prompt, phase) => {
+      phases.push(phase);
+      return phase === "initial"
+        ? { object: { action: "run_diagnostic", diagnostic: "neighbor_stability" } }
+        : { object: { action: "ask_question", opportunityId: opportunity.opportunityId, narrativeFocus: ["uncertainty"] } };
+    },
+  });
+  assert.deepEqual(phases, ["initial", "after_diagnostic"]);
+  assert.deepEqual(diagnosticRun.toolCalls.map((call) => [call.tool, call.diagnostic, call.outcome]), [
+    ["run_rectification_diagnostics", "neighbor_stability", "succeeded"],
+  ]);
+});
+
+test("old public messages without analysisTrace remain readable and are omitted from trace history", async () => {
+  await withV5Mode("v5_agent", async () => {
+    const store = createRectificationV4MemoryStore();
+    const service = createRectificationV4CaseService(store, { now: () => new Date(now) });
+    const worker = createRectificationV4Worker({
+      store,
+      now: () => new Date(now),
+      engine: { score: async () => { throw new Error("candidate_engine_should_not_run"); } },
+    });
+    const userId = randomUUID();
+    const created = await service.createCase({ userId, actionId: randomUUID(), calculationSpec: spec });
+    const queued = await service.answer({
+      userId,
+      caseId: created.case.id,
+      actionId: randomUUID(),
+      expectedCaseVersion: created.case.version,
+      answer: "2016年9月离家去外地上大学",
+    });
+    assert.ok(queued?.job);
+    assert.equal(await worker.runOnce(), true);
+
+    const legacyMessage = storedPublicMessageSchema.parse({
+      acknowledgement: "你提到的是离家去外地上大学。",
+      candidateUpdate: null,
+      limitation: null,
+      question: "请再说一件时间比较明确的经历。",
+    });
+    assert.equal(legacyMessage.analysisTrace, undefined);
+    store.publicMessages.set(queued.job.id, legacyMessage);
+    assert.deepEqual(await store.loadAnalysisMessages(userId, created.case.id), []);
+  });
+});
+
+
+function storedMessageWithTrace(trace: unknown): Record<string, unknown> {
+  return {
+    acknowledgement: "承接这段经历。",
+    candidateUpdate: null,
+    limitation: null,
+    question: "请再说一件时间比较明确的经历。",
+    analysisTrace: trace,
+  };
+}
+
+test("Supabase analysis projection orders multiple turns and maps job ids to turn ids", () => {
+  const earlierJobId = randomUUID();
+  const laterJobId = randomUUID();
+  const earlierTurnId = randomUUID();
+  const laterTurnId = randomUUID();
+  const earlierTrace: RectificationAnalysisTrace = {
+    status: "completed",
+    stages: [],
+    toolCalls: [],
+    techniques: ["D2"],
+    reasoningSummary: null,
+    reasoningSource: "none",
+  };
+  const laterTrace: RectificationAnalysisTrace = {
+    status: "completed",
+    stages: [],
+    toolCalls: [],
+    techniques: ["D4"],
+    reasoningSummary: null,
+    reasoningSource: "none",
+  };
+
+  const projected = projectAnalysisMessages([
+    { job_id: laterJobId, message: storedMessageWithTrace(laterTrace), created_at: "2026-07-29T02:00:00.000Z" },
+    { job_id: earlierJobId, message: storedMessageWithTrace(earlierTrace), created_at: "2026-07-29T01:00:00.000Z" },
+  ], [
+    { id: laterJobId, turn_id: laterTurnId },
+    { id: earlierJobId, turn_id: earlierTurnId },
+  ]);
+
+  assert.deepEqual(projected, [
+    { sourceTurnId: earlierTurnId, trace: earlierTrace },
+    { sourceTurnId: laterTurnId, trace: laterTrace },
+  ]);
+});
+
+test("Supabase analysis projection ignores legacy messages without analysisTrace", () => {
+  const jobId = randomUUID();
+  const turnId = randomUUID();
+  assert.deepEqual(projectAnalysisMessages([{
+    job_id: jobId,
+    message: {
+      acknowledgement: "承接这段经历。",
+      candidateUpdate: null,
+      limitation: null,
+      question: "请再说一件时间比较明确的经历。",
+    },
+    created_at: "2026-07-29T01:00:00.000Z",
+  }], [{ id: jobId, turn_id: turnId }]), []);
+});
+
+test("Supabase analysis projection ignores invalid traces", () => {
+  const jobId = randomUUID();
+  const turnId = randomUUID();
+  assert.deepEqual(projectAnalysisMessages([{
+    job_id: jobId,
+    message: storedMessageWithTrace({
+      status: "invented",
+      stages: [],
+      toolCalls: [],
+      techniques: [],
+      reasoningSummary: null,
+      reasoningSource: "none",
+    }),
+    created_at: "2026-07-29T01:00:00.000Z",
+  }], [{ id: jobId, turn_id: turnId }]), []);
+});
diff --git a/frontend/tests/rectification-v5-migration-contract.test.ts b/frontend/tests/rectification-v5-migration-contract.test.ts
index 0e6c7dd9..eb2afe98 100644
--- a/frontend/tests/rectification-v5-migration-contract.test.ts
+++ b/frontend/tests/rectification-v5-migration-contract.test.ts
@@ -69,6 +69,12 @@ test("V5 completion is lease-bound, hash-bound, ownership-bound and replay-safe"
   assert.match(migration, /completion_payload_hash = p_completion_payload_hash/);
 });
 
+test("V5 completion accepts and replays the full extensible public message JSON", () => {
+  assert.match(migration, /jsonb_typeof\(p_public_message\) is distinct from 'object'/);
+  assert.match(migration, /v_existing_message\.message is distinct from p_public_message/);
+  assert.match(migration, /birth_time_rectification_public_messages[\s\S]*p_public_message/);
+});
+
 test("V5 inserts use explicit columns and never mutate the profile birth minute", () => {
   for (const table of [
     "birth_time_rectification_v4_events",
diff --git a/skills/birth-time-rectification/SKILL.md b/skills/birth-time-rectification/SKILL.md
index ff626c1b..fac7ab30 100644
--- a/skills/birth-time-rectification/SKILL.md
+++ b/skills/birth-time-rectification/SKILL.md
@@ -17,6 +17,7 @@ Before choosing an action, read the contracts in `references/`. Treat `assets/re
 - The server owns event reconciliation, candidate-minute scanning, event contributions, snapshots, diagnostics, stability gates, jobs, replay, persistence, and final decision validation.
 - The agent may select one active server opportunity, call at most one allowed read-only diagnostic, offer an already-gated candidate range, or stop for low confidence.
 - The agent never creates events, dates, scores, candidate minutes, or profile updates.
+- The persisted “分析过程” is a server-owned execution receipt, not hidden chain-of-thought. It may list only stages, tools, and techniques that actually ran, plus a provider-explicit reasoning summary after server-side safety filtering.
 - `canConfirmExactMinute` is always `false`. Never write `profiles.active_birth_time` automatically.
 
 ## Seventeen conversation boundaries
@@ -61,3 +62,15 @@ A user who answers with a different complete event may have that event saved wit
 ## Public language
 
 Use a brief acknowledgement tied to the user's actual event, an optional gated candidate update, an optional limitation, and at most one question. Do not repeat an unchanged range, over-interpret the event, or turn sparse/conflicting evidence into certainty.
+
+
+## Analysis process receipt
+
+The collapsible “分析过程” shown with an assistant message is a durable projection of server execution artifacts. It must remain attached to the correct Turn after refresh; the browser must not infer history from timestamps or manufacture missing phases.
+
+- Show only phases that actually ran and only tools or techniques confirmed by persisted server artifacts.
+- Never present an unavailable, skipped, reference-only, or merely supported technique as executed.
+- A provider reasoning summary may be shown only when the provider explicitly returned displayable reasoning content and the server accepted it through the public safety filter. Never synthesize a replacement summary or expose hidden chain-of-thought.
+- Do not expose scores, weights, contribution matrices, internal IDs or field names, candidate minutes, tool arguments/results, prompts, sensitive answer text, or model/provider internals.
+- D60 is neither displayed nor allowed to drive a conclusion.
+- Historical records without a receipt remain readable. `v4_legacy` and `v5_shadow` retain their existing visible-reply behavior and gain trace display only when compatible persisted artifacts actually exist.
diff --git a/skills/birth-time-rectification/references/failure-policy.md b/skills/birth-time-rectification/references/failure-policy.md
index f376fd7a..21155376 100644
--- a/skills/birth-time-rectification/references/failure-policy.md
+++ b/skills/birth-time-rectification/references/failure-policy.md
@@ -19,3 +19,12 @@ A month-dated event is not a failure. Refine it only when date-sensitivity diagn
 Preserve the existing Job and persistence guarantees: claim/lease, idempotency, completed-job replay, and atomic completion. A renderer or extraction failure must not cause partial artifact writes, duplicate completion, profile mutation, or a different replay result.
 
 Never log raw sensitive answers to ordinary telemetry. Persist user text only in the approved Turn/evidence stores required by the product contract.
+
+
+## Analysis receipt failures
+
+- Missing phase history, tool traces, technique evidence, or provider reasoning is represented by omission, never by reconstruction or invented text.
+- A provider reasoning payload that fails source checks or the server safety filter is discarded. Do not fall back to hidden reasoning, a second-model summary, or raw provider metadata.
+- If a Job fails before durable artifacts exist, show only a safe public failure state; do not expose internal error codes or partial model output.
+- Legacy records without analysis receipts must continue to load. `v4_legacy` and `v5_shadow` visible replies must not change merely to populate the receipt.
+- Receipt persistence and Turn association must be replay-safe and owner-scoped. Refresh, completed-job replay, or retry must not duplicate, reorder, or attach a receipt to another Turn.
diff --git a/skills/birth-time-rectification/references/output-contract.md b/skills/birth-time-rectification/references/output-contract.md
index 6d682629..fdd87b9d 100644
--- a/skills/birth-time-rectification/references/output-contract.md
+++ b/skills/birth-time-rectification/references/output-contract.md
@@ -42,3 +42,19 @@ The no-repeat rule takes precedence: it must be `null` for an unchanged range, i
 ## Deterministic fallback
 
 Fallback follows the same public rules as model output: acknowledge the actual event naturally, ask one anchored question, avoid repetition and over-interpretation, and never claim exact-minute certainty.
+
+
+## Persisted analysis process
+
+“分析过程” is rendered beside the assistant message as a collapsible, refresh-safe server execution receipt. It is not part of the model-authored public message fields above and is never generated by the Renderer.
+
+The public projection may contain only:
+
+- server phases that actually started or completed;
+- allowlisted labels for candidate calculation, stability diagnostics, and a Reasoner read-only diagnostic that actually ran;
+- allowlisted techniques proven present in persisted execution artifacts;
+- an optional provider-explicit reasoning summary accepted by the server safety filter.
+
+Do not infer missing phases from the final Job phase, and do not label a capability as executed merely because the deployment supports it. If no safe provider summary exists, omit it; never create a substitute or expose hidden chain-of-thought.
+
+The receipt must exclude scores, weights, contribution matrices, internal IDs and field names, candidate minutes, tool arguments or raw results, prompts, model/provider internals, and sensitive user wording. D60 is never displayed. Historical messages without a receipt remain valid, and `v4_legacy`/`v5_shadow` keep their established visible reply semantics.
diff --git a/skills/birth-time-rectification/references/technique-policy.md b/skills/birth-time-rectification/references/technique-policy.md
index 4f6a2262..0fdb5910 100644
--- a/skills/birth-time-rectification/references/technique-policy.md
+++ b/skills/birth-time-rectification/references/technique-policy.md
@@ -20,3 +20,15 @@ Only server-reported available layers may be described as used. Missing, blocked
 - D60 is reference-only and must never drive candidate selection or the public conclusion.
 - Never expose private scores, weights, contribution values, internal technique traces, or tool/model names in the user-facing message.
 - No technique result can override `canConfirmExactMinute === false` or authorize an automatic profile birth-time write.
+
+
+## Public execution receipt
+
+The analysis receipt reports observed execution, not the complete capability catalog. A technique or diagnostic may be named only when persisted server artifacts prove it ran in that Turn.
+
+- Candidate-minute scanning and stability diagnostics are shown only on turns that executed them.
+- A Reasoner diagnostic is shown as an Agent read only when its persisted tool trace records the call; precomputed diagnostics are not Agent tool calls.
+- Technique labels are derived through a server allowlist from actual contribution/technique metadata. Never expose rule IDs, raw layers, scores, weights, contribution values, matrices, arguments, or candidate minutes.
+- Unsupported, unavailable, skipped, blocked, reference-only, and research-only layers are omitted rather than shown as missing work.
+- D60 is omitted from the receipt and must not drive candidate selection, stability claims, or public conclusions.
+- Provider-explicit reasoning content is not technique evidence. It may appear only as a separately labeled, server-filtered summary and never as hidden chain-of-thought.

From eb303c708902042a25bd01902842ffb7d2a51bbc Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Thu, 30 Jul 2026 04:09:51 +0800
Subject: [PATCH 10/15] fix: resolve timezone for postgres birth dates

---
 docs/BUG_HISTORY.md                              | 16 ++++++++++++++++
 frontend/src/lib/birth-profile-timezone.ts       |  7 ++++++-
 .../tests/global-birth-profile-routes.test.ts    |  2 +-
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 19119f3e..2e55ea86 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1708,3 +1708,19 @@
 - 防复发：API 与组件测试必须锁定 Turn 关联、刷新恢复、运行中真实 phase、仅展示实际工具/技法、无安全 reasoning 时不补写摘要，以及旧记录、legacy、shadow 的兼容行为。
 - 相关记录：BUG-011、BUG-086、BUG-087、BUG-094
 - 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`
+
+## BUG-096 | PostgreSQL 日期对象导致生时纠正 Case 创建误报资料格式错误
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：staging 自托管 PostgreSQL 出生资料读取、历史时区偏移补全与生时纠正 Case 创建
+- 用户现象：已完成出生资料的账号启动生时纠正时返回 400，并显示“出生资料或提交内容格式不正确”。
+- 触发条件：数据库驱动将 `birth_date` 返回为 JavaScript `Date`，且历史资料的 `timezone_offset` 为空、需要根据日期和时区 ID 补全。
+- 根因：共享 `resolveMissingBirthTimezoneOffset()` 只把非空字符串识别为出生日期；合法 `Date` 被当成缺失值，补全提前返回，随后严格出生资料解析以 `Historical timezone offset must be resolved before parsing` 拒绝请求。
+- 修复：共享时区补全 resolver 在读取出生日期时同时接受有效 `Date` 与既有字符串，并统一归一化为 `YYYY-MM-DD`；不放宽后续 Zod 校验，也不改变生时纠正计算规格。
+- 验证：路由回归夹具改为 PostgreSQL 实际返回形态的 `Date`；聚焦测试、前端全量测试、lint、TypeScript、生产构建和 Python V5 服务测试通过，staging 精确 SHA smoke 随本次发布执行。
+- 防复发：所有从 PostgreSQL 进入纯日期字符串合同的共享边界必须先覆盖 `string | Date` 驱动返回类型；Case 创建继续要求历史时区偏移在严格解析前完成。
+- 相关记录：BUG-076、BUG-091、BUG-095
+- 复发自：无
+- 修复版本：待本次 staging 修复提交与部署验收
diff --git a/frontend/src/lib/birth-profile-timezone.ts b/frontend/src/lib/birth-profile-timezone.ts
index c7f328a8..719aee26 100644
--- a/frontend/src/lib/birth-profile-timezone.ts
+++ b/frontend/src/lib/birth-profile-timezone.ts
@@ -21,6 +21,11 @@ function text(value: unknown): string | null {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
+function calendarDate(value: unknown): string | null {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString().slice(0, 10);
+  return text(value);
+}
+
 export function finiteBirthNumber(value: unknown): number | null {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
@@ -66,7 +71,7 @@ export async function resolveMissingBirthTimezoneOffset(
   if (existingOffset !== null) return value;
   const latitude = finiteBirthNumber(profile.latitude);
   const longitude = finiteBirthNumber(profile.longitude);
-  const birthDate = text(valueFor(profile, "birth_date", "date"));
+  const birthDate = calendarDate(valueFor(profile, "birth_date", "date"));
   const timezoneId = text(valueFor(profile, "timezone_id", "timezoneId"));
   if (latitude === null || longitude === null || !birthDate || !timezoneId) return value;
 
diff --git a/frontend/tests/global-birth-profile-routes.test.ts b/frontend/tests/global-birth-profile-routes.test.ts
index 513a36e2..b4281a2f 100644
--- a/frontend/tests/global-birth-profile-routes.test.ts
+++ b/frontend/tests/global-birth-profile-routes.test.ts
@@ -77,7 +77,7 @@ test("shared timezone resolver supports camelCase browser profiles and preserves
 
 test("journey entry and stored-case loader resolve nullable offsets before strict chart parsing", async () => {
   const resolved = await resolveMissingBirthTimezoneOffset({
-    birth_date: "1955-02-24",
+    birth_date: new Date("1955-02-24T00:00:00.000Z"),
     reported_birth_time: null,
     birth_time_source: "period_only",
     birth_time_period: "evening",

From e9d20382d972955a20d43fae93cf222cabcd0054 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Thu, 30 Jul 2026 07:58:06 +0800
Subject: [PATCH 11/15] fix: keep rectification questions context-aware

---
 docs/BUG_HISTORY.md                           |  16 +++
 .../src/components/rectification-v4-panel.tsx |  12 +-
 frontend/src/hooks/use-rectification-v4.ts    |  56 ++++++----
 .../opportunity-builder.ts                    |  18 +--
 .../lib/rectification-agent/renderer-agent.ts |  51 +++++++--
 .../src/lib/rectification-v4/case-service.ts  |   7 +-
 .../src/lib/rectification-v4/memory-store.ts  |   6 +
 frontend/src/lib/rectification-v4/store.ts    |   1 +
 .../lib/rectification-v4/supabase-store.ts    |   8 ++
 ...ersational-rectification-component.test.ts |  76 +++++++++----
 frontend/tests/rectification-agent-v6.test.ts | 105 ++++++++++++++++++
 .../tests/rectification-v4-service.test.ts    |  37 +++++-
 12 files changed, 322 insertions(+), 71 deletions(-)

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 2e55ea86..60ec2433 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1724,3 +1724,19 @@
 - 相关记录：BUG-076、BUG-091、BUG-095
 - 复发自：无
 - 修复版本：待本次 staging 修复提交与部署验收
+
+## BUG-097 | 生时纠正分析状态停滞且教育事件被换词重问为迁居
+
+- 状态：resolved
+- 首次发现：2026-07-29
+- 最近更新：2026-07-29
+- 影响面：V5 Agent 生时纠正运行状态、历史消息布局、Semantic Question Opportunity 排序与 Renderer 安全回退
+- 用户现象：任务实际已经经过“生成语义问题机会、选择下一步动作、生成安全回复”，页面运行中却一直显示“正在整理你刚才提到的经历”；完成后的“分析过程”显示在 Agent 正文下方；用户已经说明离家去外地上大学的年月后，下一问仍把同一经历换词问成搬到新城市或长期离乡。
+- 触发条件：Job 轮询返回新的 `phase`，但聊天消息继续读取首次 Case 响应中的旧 `data.job`；同时教育事件原文中的“离家、外地”命中迁居领域关键词并抬高 relocation 机会，Renderer 失败回退后直接使用带“以当前事件为时间参照”的模板。
+- 根因：Hook 同时维护 `data.job` 与独立 Job state，轮询只更新后者；恢复 processing Case 时 API 没有返回 active Job，刷新后无法继续轮询；`setInterval` 允许并发请求，较旧响应可能覆盖较新 phase；机会排序把零散地点词当成迁居主题信号，没有优先采用最新账本事件的已确认领域；迁居 fallback 和问题验证器没有禁止把当前事件改写成另一件事件继续追问。
+- 修复：轮询结果原子合并回 `data.job`，消息状态直接跟随服务端 `extracting_evidence / planning_question / reasoning / rendering`；Case Store 和 API 为 processing Case 恢复最新 pending/processing Job；轮询改为单飞 `setTimeout` 并拒绝较旧响应；把持久化分析收据移动到 Agent 正文上方并保留正文下方操作栏；迁居关键词收窄为明确搬迁动作，最新事件主题加权以账本领域为准；所有新事件 fallback 明确询问另一件独立事件，Renderer 拒绝旧跨事件模板、同义重复和与所选机会领域不匹配的问题。
+- 验证：组件测试锁定分析过程、正文、操作栏顺序、连续 Job phase 更新及乱序响应不倒退；服务测试锁定 processing 刷新恢复 active Job 和 shadow 年精度 legacy 细化；Agent 测试锁定外地上大学不会提升 relocation、事件数组顺序不改变排序、旧模板与跨领域实现触发安全 fallback；完整前端测试、lint、TypeScript、staging 构建、Python V5 服务测试和 staging 精确 SHA smoke 随本次发布执行。
+- 防复发：UI 只允许一个 Job 真源，恢复 processing Case 必须携带 active Job，轮询必须单飞且单调更新；新事件机会不得把 anchor 当作待细化目标；主题信号优先来自已验证事件领域，地点词不能单独代表迁居；Renderer 必须同时验证“另一件事件”、所选领域语义与安全边界。
+- 相关记录：BUG-090、BUG-093、BUG-094、BUG-095
+- 复发自：BUG-093、BUG-095
+- 修复版本：待本次 staging 修复提交与部署验收
diff --git a/frontend/src/components/rectification-v4-panel.tsx b/frontend/src/components/rectification-v4-panel.tsx
index 97bc302d..f59d8402 100644
--- a/frontend/src/components/rectification-v4-panel.tsx
+++ b/frontend/src/components/rectification-v4-panel.tsx
@@ -39,9 +39,9 @@ const phaseLabels = {
   extracting_evidence: "正在整理你刚才提到的经历…",
   scoring_candidates: "正在扫描候选时间…",
   checking_robustness: "正在检查候选范围的稳定性…",
-  planning_question: "正在选择下一条最有信息量的问题…",
-  reasoning: "正在结合上下文决定下一步…",
-  rendering: "正在组织下一条回复…",
+  planning_question: "正在生成语义问题机会…",
+  reasoning: "正在选择下一步动作…",
+  rendering: "正在生成安全回复…",
   complete: "分析已完成",
 } as const;
 
@@ -380,12 +380,12 @@ export function RectificationV4Panel(props: RectificationV4PanelProps) {
             });
             return (
               <div className="rectification-message-entry" key={message.renderKey}>
-                <RectificationMessageRow message={regenerating
-                  ? { ...message, text: "", state: "thinking" }
-                  : message} />
                 {message.role === "assistant" && message.state === "settled" && message.analysisTrace && (
                   <RectificationAnalysisDetails trace={message.analysisTrace} />
                 )}
+                <RectificationMessageRow message={regenerating
+                  ? { ...message, text: "", state: "thinking" }
+                  : message} />
                 {showActions && !regenerating && (
                   <div className="rectification-message-actions" aria-label="Agent 回答操作">
                     <button
diff --git a/frontend/src/hooks/use-rectification-v4.ts b/frontend/src/hooks/use-rectification-v4.ts
index abc027d2..d6d314bd 100644
--- a/frontend/src/hooks/use-rectification-v4.ts
+++ b/frontend/src/hooks/use-rectification-v4.ts
@@ -24,6 +24,16 @@ function friendly(error: unknown): string {
   return error instanceof Error ? error.message : "暂时无法处理，请稍后再试。";
 }
 
+export function applyRectificationV4JobUpdate(
+  data: RectificationV4ApiResponse | null,
+  job: RectificationV4Job,
+): RectificationV4ApiResponse | null {
+  if (data?.job?.id !== job.id) return data;
+  if (["completed", "failed", "stale"].includes(data.job.status)) return data;
+  if (job.updatedAt < data.job.updatedAt) return data;
+  return { ...data, job };
+}
+
 export function useRectificationV4(input: {
   readonly pendingConsultationQuestion?: string | null;
   readonly onPendingChange?: (pending: boolean) => void;
@@ -31,13 +41,17 @@ export function useRectificationV4(input: {
   const onPendingChange = input.onPendingChange;
   const pendingConsultationQuestion = input.pendingConsultationQuestion?.trim() || null;
   const [data, setData] = useState<RectificationV4ApiResponse | null>(null);
-  const [job, setJob] = useState<RectificationV4Job | null>(null);
   const [handoff, setHandoff] = useState<RectificationV4Handoff | null>(null);
   const [loading, setLoading] = useState(true);
   const [pending, setPending] = useState(false);
   const [error, setError] = useState("");
   const mounted = useRef(true);
 
+  const job = data?.job ?? null;
+  const jobId = job?.id ?? null;
+  const jobStatus = job?.status ?? null;
+  const caseId = data?.case.id ?? null;
+
   const setBusy = useCallback((value: boolean) => {
     setPending(value);
     onPendingChange?.(value);
@@ -47,7 +61,6 @@ export function useRectificationV4(input: {
     const result = caseId ? await loadRectificationV4(caseId) : await loadActiveRectificationV4();
     if (mounted.current) {
       setData(result);
-      setJob(result?.job ?? null);
     }
     return result;
   }, []);
@@ -74,7 +87,6 @@ export function useRectificationV4(input: {
         }
         if (mounted.current) {
           setData(result);
-          setJob(result.job);
           setHandoff(nextHandoff);
         }
       } catch (caught) {
@@ -87,23 +99,30 @@ export function useRectificationV4(input: {
   }, [pendingConsultationQuestion]);
 
   useEffect(() => {
-    const jobId = job?.id;
-    if (!jobId || !["pending", "processing"].includes(job.status)) return;
-    const timer = window.setInterval(() => {
-      void loadRectificationV4Job(jobId).then(async (next) => {
-        if (!mounted.current) return;
-        setJob(next);
-        if (["completed", "failed", "stale"].includes(next.status) && data) {
-          window.clearInterval(timer);
-          const latest = await refresh(data.case.id);
+    if (!jobId || !jobStatus || !["pending", "processing"].includes(jobStatus)) return;
+    let cancelled = false;
+    let timer: number | null = null;
+    const poll = async () => {
+      try {
+        const next = await loadRectificationV4Job(jobId);
+        if (cancelled || !mounted.current) return;
+        setData((current) => applyRectificationV4JobUpdate(current, next));
+        if (["completed", "failed", "stale"].includes(next.status) && caseId) {
+          const latest = await refresh(caseId);
           if (next.status === "failed" && latest) setError("这次比较没有完成，回答已经保留，请再试一次。");
+          return;
         }
-      }).catch((caught) => {
-        if (mounted.current) setError(friendly(caught));
-      });
-    }, 1_000);
-    return () => window.clearInterval(timer);
-  }, [data, job, refresh]);
+      } catch (caught) {
+        if (!cancelled && mounted.current) setError(friendly(caught));
+      }
+      if (!cancelled) timer = window.setTimeout(() => void poll(), 1_000);
+    };
+    timer = window.setTimeout(() => void poll(), 1_000);
+    return () => {
+      cancelled = true;
+      if (timer !== null) window.clearTimeout(timer);
+    };
+  }, [caseId, jobId, jobStatus, refresh]);
 
   const mutate = useCallback(async (operation: () => Promise<RectificationV4ApiResponse>) => {
     setBusy(true);
@@ -112,7 +131,6 @@ export function useRectificationV4(input: {
       const result = await operation();
       if (mounted.current) {
         setData(result);
-        setJob(result.job);
       }
       return result;
     } catch (caught) {
diff --git a/frontend/src/lib/rectification-agent/opportunity-builder.ts b/frontend/src/lib/rectification-agent/opportunity-builder.ts
index b505ebce..9f433547 100644
--- a/frontend/src/lib/rectification-agent/opportunity-builder.ts
+++ b/frontend/src/lib/rectification-agent/opportunity-builder.ts
@@ -16,12 +16,12 @@ const domainPolicy: Readonly<Record<Exclude<EvidenceDomain, "family" | "other">,
   recallEase: number;
   privacyCost: number;
 }>>> = {
-  education: { goal: "收集一件有大致日期的教育转折。", fallbackPrompt: (anchor) => anchor ? `在“${anchor}”之外，你还记得哪次入学、毕业或专业变化大概发生在哪年哪月？` : "你还记得哪次入学、毕业或专业变化大概发生在哪年哪月？", keywords: /大学|学校|入学|毕业|考试|专业|读书/, recallEase: .82, privacyCost: .03 },
-  relocation: { goal: "收集一件有大致日期的迁居经历。", fallbackPrompt: (anchor) => anchor ? `以“${anchor}”为时间参照，你哪次搬到新城市或长期离乡的年月最确定？` : "你哪次搬到新城市或长期离乡的年月最确定？", keywords: /搬家|迁居|离家|外地|城市|北京|上海|出国/, recallEase: .78, privacyCost: .04 },
-  relationship: { goal: "在用户愿意的前提下收集一件有大致日期的关系转折。", fallbackPrompt: (anchor) => anchor ? `说到“${anchor}”这段时期，如果你愿意，哪次关系变化的大概年月还记得？` : "如果你愿意，哪次关系变化的大概年月还记得？", keywords: /恋爱|关系|结婚|离婚|分手|伴侣|对象/, recallEase: .62, privacyCost: .22 },
-  career: { goal: "收集一件有大致日期的职业转折。", fallbackPrompt: (anchor) => anchor ? `在“${anchor}”之后，哪次工作或职责明显变化的年月你还记得？` : "哪次工作或职责明显变化的年月你还记得？", keywords: /工作|实习|公司|研究院|职业|入职|离职|创业|负责/, recallEase: .85, privacyCost: .03 },
-  finance: { goal: "在用户愿意的前提下收集一件有大致日期的财务转折。", fallbackPrompt: (anchor) => anchor ? `以“${anchor}”为时间参照，如果方便，哪次财务状况明显变化的年月你还记得？` : "如果方便，哪次财务状况明显变化的年月你还记得？", keywords: /收入|负债|投资|资产|财务|买房|卖房/, recallEase: .6, privacyCost: .18 },
-  health_pressure: { goal: "在用户愿意的前提下收集一件本人有大致日期的健康转折。", fallbackPrompt: (anchor) => anchor ? `说到“${anchor}”前后，如果方便，你本人哪次健康变化的大概年月还记得？` : "如果方便，你本人哪次健康变化的大概年月还记得？", keywords: /住院|手术|事故|健康|生病|确诊|康复/, recallEase: .58, privacyCost: .28 },
+  education: { goal: "收集一件有大致日期的教育转折。", fallbackPrompt: (anchor) => anchor ? `除了“${anchor}”，你还记得哪次入学、毕业或专业变化大概发生在哪年哪月？` : "你还记得哪次入学、毕业或专业变化大概发生在哪年哪月？", keywords: /大学|学校|入学|毕业|考试|专业|读书/, recallEase: .82, privacyCost: .03 },
+  relocation: { goal: "收集一件有大致日期的迁居经历。", fallbackPrompt: (anchor) => anchor ? `除了“${anchor}”，你还记得哪次独立搬家或迁居大概发生在哪年哪月？` : "你还记得哪次搬家或迁居大概发生在哪年哪月？", keywords: /搬家|搬到|搬去|迁居|迁到|迁往|移居|定居|长期居住/, recallEase: .78, privacyCost: .04 },
+  relationship: { goal: "在用户愿意的前提下收集一件有大致日期的关系转折。", fallbackPrompt: (anchor) => anchor ? `除了“${anchor}”，如果你愿意，哪次关系变化的大概年月还记得？` : "如果你愿意，哪次关系变化的大概年月还记得？", keywords: /恋爱|关系|结婚|离婚|分手|伴侣|对象/, recallEase: .62, privacyCost: .22 },
+  career: { goal: "收集一件有大致日期的职业转折。", fallbackPrompt: (anchor) => anchor ? `除了“${anchor}”，哪次工作或职责明显变化的年月你还记得？` : "哪次工作或职责明显变化的年月你还记得？", keywords: /工作|实习|公司|研究院|职业|入职|离职|创业|负责/, recallEase: .85, privacyCost: .03 },
+  finance: { goal: "在用户愿意的前提下收集一件有大致日期的财务转折。", fallbackPrompt: (anchor) => anchor ? `除了“${anchor}”，如果方便，哪次财务状况明显变化的年月你还记得？` : "如果方便，哪次财务状况明显变化的年月你还记得？", keywords: /收入|负债|投资|资产|财务|买房|卖房/, recallEase: .6, privacyCost: .18 },
+  health_pressure: { goal: "在用户愿意的前提下收集一件本人有大致日期的健康转折。", fallbackPrompt: (anchor) => anchor ? `除了“${anchor}”，如果方便，你本人哪次健康变化的大概年月还记得？` : "如果方便，你本人哪次健康变化的大概年月还记得？", keywords: /住院|手术|事故|健康|生病|确诊|康复/, recallEase: .58, privacyCost: .28 },
 };
 
 function stableUuid(value: string): string {
@@ -182,13 +182,15 @@ export function buildQuestionOpportunities(input: Readonly<{
   for (const [domain, policy] of Object.entries(domainPolicy) as [Exclude<EvidenceDomain, "family" | "other">, (typeof domainPolicy)[Exclude<EvidenceDomain, "family" | "other">]][]) {
     if (refusedDomains.has(domain)) continue;
     const covered = scoreableDomains.has(domain);
-    const themeBonus = policy.keywords.test(latestContext) ? .22 : 0;
+    const themeBonus = latestEvent
+      ? latestEvent.domain === domain ? .22 : 0
+      : policy.keywords.test(latestContext) ? .22 : 0;
     const alreadyAsked = input.turns.some((turn) => turn.questionDomain === domain && !turn.questionTargetEventId);
     const latestAnchor = latestEvent ? anchorFor(latestEvent) : null;
     opportunities.push(opportunity(input.caseId, {
       kind: "ask_new_event", domain, targetEventId: null, goal: policy.goal,
       requestedFields: ["new_dated_event"], anchors: latestAnchor ? [latestAnchor] : [],
-      contextFacts: [`已有 ${scoreableCount} 件可评分事件。`, `该领域${covered ? "已有覆盖" : "尚未覆盖"}。`],
+      contextFacts: [`已有 ${scoreableCount} 件可评分事件。`, `该领域${covered ? "已有覆盖" : "尚未覆盖"}。`, "需要另一件独立事件，不要把最新事件换词重问。"],
       fallbackPrompt: policy.fallbackPrompt(latestAnchor), reason: covered ? "继续收集可区分候选的独立事件。" : "补足证据领域覆盖。",
       expectedInformationGain: covered ? .54 + themeBonus : .65 + themeBonus / 2,
       dateSensitivity: input.snapshot ? .5 : .35,
diff --git a/frontend/src/lib/rectification-agent/renderer-agent.ts b/frontend/src/lib/rectification-agent/renderer-agent.ts
index b7d3ca02..c5ef92c7 100644
--- a/frontend/src/lib/rectification-agent/renderer-agent.ts
+++ b/frontend/src/lib/rectification-agent/renderer-agent.ts
@@ -12,9 +12,19 @@ const bannedAcknowledgement = /(?:这个信息很有用|它不是单纯的|而
 const overinterpretedAcknowledgement = /(?:职业方向正式落地|人生意义|意味着你|说明你(?:已经|开始|正式)|标志着你)/;
 const internalTerms = /(?:opportunityId|snapshotId|eventId|targetEventId|requestedFields|fallbackPrompt|tool\s*call|tool_call|score|评分|模型名|opportunity|snapshot|D\d{1,2}|KP\b|Vimshottari)/i;
 const multiQuestionMoves = /(?:另外|还有|同时再说|并且告诉我|顺便|再告诉我)/;
-const cannedQuestion = /(?:承接[“\"']?.{0,80}[”\"']?，?请再说一件|接下来请继续讲另一件|我会顺着你的叙述继续核对)/;
+const cannedQuestion = /(?:承接[“\"']?.{0,80}[”\"']?，?请再说一件|接下来请继续讲另一件|我会顺着你的叙述继续核对|以[“\"']?.{0,80}[”\"']?为(?:时间)?参照|搬到新城市|长期离乡)/;
 const exactClockMinute = /(?:[01]?\d|2[0-3])[:：][0-5]\d|(?:[零〇一二两三四五六七八九十]{1,3}|(?:[01]?\d|2[0-3]))点(?:[零〇一二两三四五六七八九十]{1,3}|[0-5]?\d)分/;
 const exactMinuteClaim = /(?:唯一|准确|精确|确切|确认|确定|代表).{0,12}(?:出生|生时)?(?:时间|时刻|分钟)|(?:出生|生时)(?:时间|时刻|分钟)?.{0,12}(?:唯一|准确|精确|确切|确认|确定|代表|就是)/;
+const distinctEventMove = /(?:除了|另一(?:件|次)|下(?:一|1)次|之后|后来|此后|还记得)/;
+const explicitAnchorReference = /(?:这次经历|这段经历|刚才那段|刚才这段|你刚说的|你刚提到的|刚说的|刚提到的|前面那段|这件事)/;
+const newEventDomainTerms: Readonly<Partial<Record<QuestionOpportunity["domain"], RegExp>>> = {
+  education: /(?:入学|升学|毕业|学校|大学|专业|考试|读书)/,
+  relocation: /(?:搬家|搬到|搬去|迁居|迁到|迁往|移居|定居)/,
+  relationship: /(?:恋爱|关系|结婚|离婚|分手|伴侣|对象)/,
+  career: /(?:工作|实习|公司|研究院|职业|入职|离职|创业|职责|负责)/,
+  finance: /(?:收入|负债|投资|资产|财务|买房|卖房)/,
+  health_pressure: /(?:住院|手术|事故|健康|生病|确诊|康复)/,
+};
 const questionRealizationSchema = z.object({ question: z.string().trim().min(1).max(1_000) }).strict();
 
 function agentFor(modelId: string | null): { id: string; agent: Agent } | null {
@@ -37,14 +47,32 @@ function normalized(value: string): string {
   return value.normalize("NFKC").replace(/[“”"'\s，,。.!！?？:：；;]/g, "");
 }
 
-function includesAnchor(question: string, anchor: string): boolean {
+function matchingAnchorFragment(question: string, anchor: string): string | null {
   const normalizedQuestion = normalized(question);
   const normalizedAnchor = normalized(anchor);
-  if (normalizedQuestion.includes(normalizedAnchor)) return true;
-  for (let start = 0; start <= normalizedAnchor.length - 4; start += 1) {
-    if (normalizedQuestion.includes(normalizedAnchor.slice(start, start + 4))) return true;
+  if (!normalizedAnchor) return null;
+  if (normalizedQuestion.includes(normalizedAnchor)) return normalizedAnchor;
+  for (let length = Math.min(normalizedQuestion.length, normalizedAnchor.length); length >= 4; length -= 1) {
+    for (let start = 0; start <= normalizedAnchor.length - length; start += 1) {
+      const fragment = normalizedAnchor.slice(start, start + length);
+      if (normalizedQuestion.includes(fragment)) return fragment;
+    }
   }
-  return false;
+  return null;
+}
+
+function includesStrictAnchor(question: string, anchor: string): boolean {
+  const normalizedAnchor = normalized(anchor);
+  return normalizedAnchor.length > 0 && normalized(question).includes(normalizedAnchor);
+}
+
+function withoutMatchedAnchors(question: string, anchors: readonly string[]): string {
+  let remaining = normalized(question);
+  for (const anchor of anchors) {
+    const matched = matchingAnchorFragment(remaining, anchor);
+    if (matched) remaining = remaining.replace(matched, "");
+  }
+  return remaining;
 }
 
 function visibleTextSafetyIssues(value: string): string[] {
@@ -65,8 +93,15 @@ export function validateQuestionRealization(question: unknown, opportunity: Ques
   issues.push(...visibleTextSafetyIssues(value));
   if (multiQuestionMoves.test(value)) issues.push("multiple_question_instruction");
   if (cannedQuestion.test(value)) issues.push("canned_question_forbidden");
-  if (opportunity.targetEventId || (opportunity.kind === "ask_new_event" && opportunity.anchors.length > 0)) {
-    if (!opportunity.anchors.some((anchor) => includesAnchor(value, anchor))) issues.push("target_anchor_missing");
+  if (opportunity.targetEventId) {
+    if (!opportunity.anchors.some((anchor) => includesStrictAnchor(value, anchor))) issues.push("target_anchor_missing");
+  } else if (opportunity.kind === "ask_new_event") {
+    const anchorMatched = opportunity.anchors.some((anchor) => matchingAnchorFragment(value, anchor) !== null);
+    if (opportunity.anchors.length > 0 && !anchorMatched && !explicitAnchorReference.test(value)) issues.push("target_anchor_missing");
+    if (opportunity.anchors.length > 0 && !distinctEventMove.test(value)) issues.push("new_event_not_distinct");
+    const domainTerms = newEventDomainTerms[opportunity.domain];
+    const questionWithoutAnchor = withoutMatchedAnchors(value, opportunity.anchors);
+    if (domainTerms && !domainTerms.test(questionWithoutAnchor)) issues.push("new_event_domain_mismatch");
   }
   for (const field of opportunity.requestedFields) {
     if (field === "event_subject" && !/(?:本人|你自己|家人|伴侣|配偶)/.test(value)) issues.push("event_subject_not_requested");
diff --git a/frontend/src/lib/rectification-v4/case-service.ts b/frontend/src/lib/rectification-v4/case-service.ts
index 7c1e89a0..b187c891 100644
--- a/frontend/src/lib/rectification-v4/case-service.ts
+++ b/frontend/src/lib/rectification-v4/case-service.ts
@@ -26,16 +26,19 @@ export function createRectificationV4CaseService(
   const realizeQuestion = options.regenerateQuestion ?? regenerateQuestionRealization;
 
   async function response(userId: string, caseValue: RectificationV4Case, jobId?: string): Promise<RectificationV4ApiResponse> {
-    const [events, turns, analysis] = await Promise.all([
+    const [events, turns, analysis, job] = await Promise.all([
       store.loadEvents(userId, caseValue.id),
       store.loadTurns(userId, caseValue.id),
       caseValue.deploymentMode === "v5_agent"
         ? store.loadAnalysisMessages(userId, caseValue.id)
         : Promise.resolve([]),
+      jobId
+        ? store.loadJob(userId, jobId)
+        : caseValue.status === "processing" ? store.loadActiveJob(userId, caseValue.id) : null,
     ]);
     return {
       case: caseValue,
-      job: jobId ? await store.loadJob(userId, jobId) : null,
+      job,
       events: [...events],
       turns: [...turns],
       analysis: [...analysis],
diff --git a/frontend/src/lib/rectification-v4/memory-store.ts b/frontend/src/lib/rectification-v4/memory-store.ts
index e61e15b3..bee09ec4 100644
--- a/frontend/src/lib/rectification-v4/memory-store.ts
+++ b/frontend/src/lib/rectification-v4/memory-store.ts
@@ -230,6 +230,12 @@ export function createRectificationV4MemoryStore(): RectificationV4Store & {
       owned(userId, job.caseId);
       return job;
     },
+    async loadActiveJob(userId, caseId) {
+      owned(userId, caseId);
+      return [...jobs.values()]
+        .filter((job) => job.caseId === caseId && ["pending", "processing"].includes(job.status))
+        .sort((left, right) => right.createdAt.localeCompare(left.createdAt))[0] ?? null;
+    },
     async updateJobPhase(input) {
       const job = jobs.get(input.jobId);
       if (!job || job.workerId !== input.workerId || job.status !== "processing") throw new RectificationV4StoreError("lease_lost");
diff --git a/frontend/src/lib/rectification-v4/store.ts b/frontend/src/lib/rectification-v4/store.ts
index 76a6b6fe..37151885 100644
--- a/frontend/src/lib/rectification-v4/store.ts
+++ b/frontend/src/lib/rectification-v4/store.ts
@@ -90,6 +90,7 @@ export interface RectificationV4Store {
     readonly now: string;
   }): Promise<RectificationV4Case>;
   loadJob(userId: string, jobId: string): Promise<RectificationV4Job | null>;
+  loadActiveJob(userId: string, caseId: string): Promise<RectificationV4Job | null>;
   updateJobPhase(input: { readonly workerId: string; readonly jobId: string; readonly phase: RectificationV4Phase; readonly now: string }): Promise<void>;
   claimNextJob(workerId: string, now: string): Promise<ClaimedRectificationV4Job | null>;
   completeJob(input: CompleteRectificationV4JobInput, now: string): Promise<RectificationV4Case>;
diff --git a/frontend/src/lib/rectification-v4/supabase-store.ts b/frontend/src/lib/rectification-v4/supabase-store.ts
index 914099cd..7b7348fa 100644
--- a/frontend/src/lib/rectification-v4/supabase-store.ts
+++ b/frontend/src/lib/rectification-v4/supabase-store.ts
@@ -345,6 +345,14 @@ export function createRectificationV4SupabaseStore(supabase: SupabaseClient): Re
       if (!row || row.user_id !== userId) return null;
       return jobValue(row);
     },
+    async loadActiveJob(userId, caseId) {
+      const { data, error } = await supabase.from("birth_time_rectification_v4_jobs")
+        .select("*").eq("user_id", userId).eq("case_id", caseId)
+        .in("status", ["pending", "processing"])
+        .order("created_at", { ascending: false }).limit(1).maybeSingle();
+      if (error) throw storeError(error);
+      return data ? jobValue(data as Row) : null;
+    },
     async updateJobPhase(input) {
       await rpc("update_birth_time_rectification_v4_job_phase", {
         p_worker_id: input.workerId,
diff --git a/frontend/tests/conversational-rectification-component.test.ts b/frontend/tests/conversational-rectification-component.test.ts
index 46d4d476..74288ad8 100644
--- a/frontend/tests/conversational-rectification-component.test.ts
+++ b/frontend/tests/conversational-rectification-component.test.ts
@@ -7,6 +7,7 @@ import {
   rectificationPhaseLabel,
   toggleRectificationFeedback,
 } from "../src/components/rectification-v4-panel.tsx";
+import { applyRectificationV4JobUpdate } from "../src/hooks/use-rectification-v4.ts";
 import type { RectificationV4ApiResponse } from "../src/lib/rectification-v4/contracts.ts";
 
 const id = "00000000-0000-4000-8000-000000000901";
@@ -122,7 +123,7 @@ test("v4 rectification reuses the ordinary session message list, composer, and m
   assert.match(component, /<span>分析过程<\/span>/);
   assert.match(
     component,
-    /<RectificationAnalysisDetails trace=\{message\.analysisTrace\} \/>[\s\S]*?<div className="rectification-message-actions"/,
+    /<RectificationAnalysisDetails trace=\{message\.analysisTrace\} \/>[\s\S]*?<RectificationMessageRow[\s\S]*?<div className="rectification-message-actions"/,
   );
   assert.match(component, /caseValue\?\.deploymentMode === "v5_agent"/);
   assert.match(component, /controller\.regenerate\(\)/);
@@ -229,28 +230,57 @@ test("legacy and shadow modes do not expose persisted analysis traces", () => {
   }
 });
 
-test("processing shows the current server job phase in Chinese", () => {
-  const base = response({ currentQuestion: null, status: "processing", phase: "checking_robustness" });
-  const data = {
-    ...base,
-    job: {
-      id: "00000000-0000-4000-8000-000000000909",
-      caseId: id,
-      status: "processing",
-      phase: "checking_robustness",
-      expectedCaseVersion: 2,
-      evidenceSetHash: "b".repeat(64),
-      calculationSpecHash: "a".repeat(64),
-      errorCode: null,
-      createdAt: now,
-      updatedAt: now,
-    },
-  } as unknown as RectificationV4ApiResponse;
-  const messages = rectificationV4ChatMessages(data, true);
-  assert.equal(messages.at(-1)?.role, "assistant");
-  assert.equal(messages.at(-1)?.state, "thinking");
-  assert.equal(messages.at(-1)?.text, "正在检查候选范围的稳定性…");
-  assert.equal(rectificationPhaseLabel("planning_question"), "正在选择下一条最有信息量的问题…");
+test("processing follows every server job phase returned by polling", () => {
+  const base = response({ currentQuestion: null, status: "processing", phase: "extracting_evidence" });
+  const job = {
+    id: "00000000-0000-4000-8000-000000000909",
+    caseId: id,
+    status: "processing",
+    phase: "extracting_evidence",
+    expectedCaseVersion: 2,
+    evidenceSetHash: "b".repeat(64),
+    calculationSpecHash: "a".repeat(64),
+    errorCode: null,
+    createdAt: now,
+    updatedAt: now,
+  } as const;
+  let data = { ...base, job } as unknown as RectificationV4ApiResponse;
+  const phases = [
+    ["extracting_evidence", "正在整理你刚才提到的经历…"],
+    ["planning_question", "正在生成语义问题机会…"],
+    ["reasoning", "正在选择下一步动作…"],
+    ["rendering", "正在生成安全回复…"],
+  ] as const;
+
+  for (const [phase, label] of phases) {
+    const updated = applyRectificationV4JobUpdate(data, { ...job, phase });
+    assert.ok(updated);
+    data = updated;
+    const message = rectificationV4ChatMessages(data, true).at(-1);
+    assert.equal(message?.role, "assistant");
+    assert.equal(message?.state, "thinking");
+    assert.equal(message?.text, label);
+  }
+  assert.equal(rectificationPhaseLabel("checking_robustness"), "正在检查候选范围的稳定性…");
+});
+
+test("polling ignores an older job response so the visible phase cannot move backward", () => {
+  const base = response({ currentQuestion: null, status: "processing", phase: "rendering" });
+  const latest = {
+    id: "00000000-0000-4000-8000-000000000909",
+    caseId: id,
+    status: "processing",
+    phase: "rendering",
+    expectedCaseVersion: 2,
+    evidenceSetHash: "b".repeat(64),
+    calculationSpecHash: "a".repeat(64),
+    errorCode: null,
+    createdAt: now,
+    updatedAt: "2026-07-27T00:00:02.000Z",
+  } as const;
+  const data = { ...base, job: latest } as unknown as RectificationV4ApiResponse;
+  const stale = { ...latest, phase: "planning_question" as const, updatedAt: "2026-07-27T00:00:01.000Z" };
+  assert.equal(applyRectificationV4JobUpdate(data, stale)?.job?.phase, "rendering");
 });
 
 test("analysis details render only public labels and preserve the message action icons", () => {
diff --git a/frontend/tests/rectification-agent-v6.test.ts b/frontend/tests/rectification-agent-v6.test.ts
index 98c4192b..c4c9e900 100644
--- a/frontend/tests/rectification-agent-v6.test.ts
+++ b/frontend/tests/rectification-agent-v6.test.ts
@@ -191,6 +191,66 @@ test("Builder 的领域排序不受事件输入数组顺序影响", () => {
   assert.deepEqual(domains([education, career]), domains([career, education]));
 });
 
+test("外地上大学不会被换词提升为迁居问题", () => {
+  const education = event({
+    summary: "离家去外地上大学",
+    rawText: "2016 年 9 月离家去外地上大学",
+  });
+  const opportunities = buildQuestionOpportunities({
+    caseId,
+    events: [education],
+    turns: [turn({ answer: education.rawText })],
+    snapshot: null,
+    diagnostics: null,
+  });
+
+  assert.notEqual(opportunities[0]?.domain, "relocation");
+  const relocation = opportunities.find((item) => item.kind === "ask_new_event" && item.domain === "relocation");
+  assert.ok(relocation);
+  assert.doesNotMatch(relocation.fallbackPrompt, /搬到新城市|长期离乡|以.*为(?:时间)?参照/);
+  assert.match(relocation.fallbackPrompt, /除了.*离家去外地上大学.*搬家或迁居/);
+
+  const repeated = "以“离家去外地上大学”为时间参照，你哪次搬到新城市或长期离乡的年月最确定？";
+  assert.equal(validateQuestionRealization(repeated, relocation).valid, false);
+  assert.equal(validateQuestionRealization("离家去外地上大学这件事大概发生在哪年哪月？", relocation).valid, false);
+  assert.equal(validateQuestionRealization("除了离家去外地上大学，你哪次工作变化发生在哪年哪月？", relocation).valid, false);
+  const message = realizePublicMessage({ acknowledgement: "你提到的是 2016 年 9 月离家去外地上大学。", candidateUpdate: null, limitation: null, question: repeated }, {
+    latestAnswer: education.rawText,
+    acceptedEvents: [education],
+    pendingEvidence: [],
+    snapshot: null,
+    previousSnapshot: null,
+    validated: validated(relocation),
+  });
+  assert.equal(message.question, relocation.fallbackPrompt);
+});
+
+test("外地上大学场景的机会排序不受事件数组顺序影响", () => {
+  const education = event({
+    summary: "离家去外地上大学",
+    rawText: "2016 年 9 月离家去外地上大学",
+    createdAt: "2026-07-29T02:00:00.000Z",
+  });
+  const career = event({
+    domain: "career",
+    eventKind: "career_change",
+    summary: "开始第一份工作",
+    rawText: "2019 年 7 月开始第一份工作",
+    dateRange: { start: "2019-07-01", end: "2019-07-31", precision: "month", label: "2019年7月" },
+    createdAt: "2026-07-29T01:00:00.000Z",
+  });
+  const ranked = (events: readonly LifeEventRevision[]) => buildQuestionOpportunities({
+    caseId,
+    events,
+    turns: [turn({ answer: education.rawText, createdAt: education.createdAt })],
+    snapshot: null,
+    diagnostics: null,
+  }).map((item) => [item.kind, item.domain, item.utility, item.fallbackPrompt]);
+
+  assert.deepEqual(ranked([education, career]), ranked([career, education]));
+  assert.doesNotMatch(ranked([education, career]).map((item) => item[3]).join("\n"), /搬到新城市|长期离乡|以.*为(?:时间)?参照/);
+});
+
 test("研究院实习后优先延续最新主题，不被旧教育事件的离家关键词拉回迁居问卷", () => {
   const education = event({
     summary: "离家去外地上大学",
@@ -250,6 +310,51 @@ test("Renderer 接受锚定最新事件的自然新事件问题并拒绝旧固
   assert.notEqual(message.question, opportunity.fallbackPrompt);
 });
 
+test("ask_new_event 领域验证忽略承接 anchor，拒绝实际询问的跨领域事件", () => {
+  const latest = event({
+    domain: "career",
+    eventKind: "career_change",
+    summary: "去石油化工研究院实习做研究员",
+    rawText: "2020年4月去石油化工研究院实习做研究员",
+    dateRange: { start: "2020-04-01", end: "2020-04-30", precision: "month", label: "2020年4月" },
+  });
+  const opportunity = buildQuestionOpportunities({ caseId, events: [latest], turns: [turn({ answer: latest.rawText })], snapshot: null, diagnostics: null })
+    .find((item) => item.kind === "ask_new_event" && item.domain === "career");
+  assert.ok(opportunity);
+
+  const result = validateQuestionRealization("研究院实习之后，下一次升学大概发生在什么时候？", opportunity);
+  assert.equal(result.valid, false);
+  assert.ok(result.issues.includes("new_event_domain_mismatch"));
+});
+
+test("ask_new_event 允许明确代词承接并识别教育领域的升学事件", () => {
+  const latest = event({
+    domain: "career",
+    eventKind: "career_change",
+    summary: "去石油化工研究院实习做研究员",
+    rawText: "2020年4月去石油化工研究院实习做研究员",
+    dateRange: { start: "2020-04-01", end: "2020-04-30", precision: "month", label: "2020年4月" },
+  });
+  const baseOpportunity = buildQuestionOpportunities({ caseId, events: [latest], turns: [turn({ answer: latest.rawText })], snapshot: null, diagnostics: null })
+    .find((item) => item.kind === "ask_new_event" && item.domain === "career");
+  assert.ok(baseOpportunity);
+  const opportunity: QuestionOpportunity = { ...baseOpportunity, domain: "education" };
+
+  for (const reference of ["这次经历", "刚才那段", "你刚说的"]) {
+    const result = validateQuestionRealization(`${reference}之后，下一次升学大概发生在什么时候？`, opportunity);
+    assert.equal(result.valid, true, `${reference}: ${result.issues.join(",")}`);
+  }
+});
+
+test("targetEventId 非空时只接受完整真实 anchor，不接受代词或四字片段", () => {
+  const target = event({ summary: "2020年4月研究院实习" });
+  const opportunity = targetOpportunity(target);
+
+  assert.equal(validateQuestionRealization("关于2020年4月研究院实习，你还记得具体日期吗？", opportunity).valid, true);
+  assert.equal(validateQuestionRealization("关于研究院实习，你还记得具体日期吗？", opportunity).valid, false);
+  assert.equal(validateQuestionRealization("关于这次经历，你还记得具体日期吗？", opportunity).valid, false);
+});
+
 test("Builder 和 Reasoner 按事件创建时间承接最近经历而不是 UUID 顺序", () => {
   const older = event({
     eventId: "ffffffff-ffff-4fff-8fff-ffffffffffff",
diff --git a/frontend/tests/rectification-v4-service.test.ts b/frontend/tests/rectification-v4-service.test.ts
index 9aa8068a..b6314c3b 100644
--- a/frontend/tests/rectification-v4-service.test.ts
+++ b/frontend/tests/rectification-v4-service.test.ts
@@ -53,7 +53,7 @@ test("same calculation spec resumes while a changed spec abandons the old case a
   assert.equal(store.jobs.get(queued.job.id)?.status, "stale");
 }));
 
-test("answer is durably queued and polling does not mutate the job", async () => withMode("v5_agent", async () => {
+test("answer is durably queued and a processing case reload restores its active job", async () => withMode("v5_agent", async () => {
   const store = createRectificationV4MemoryStore();
   const service = createRectificationV4CaseService(store, { now: fixedNow });
   const userId = randomUUID();
@@ -66,8 +66,12 @@ test("answer is durably queued and polling does not mutate the job", async () =>
   });
   assert.equal(queued?.case.status, "processing");
   assert.equal(queued?.turns.at(-1)?.modelId, "gpt-5.5");
+  const queuedJob = queued?.job;
+  assert.ok(queuedJob);
   const before = JSON.stringify([...store.jobs.values()]);
-  assert.equal((await service.loadCase(userId, created.case.id))?.job, null);
+  const restored = await service.loadCase(userId, created.case.id);
+  assert.equal(restored?.job?.id, queuedJob.id);
+  assert.equal(restored?.job?.status, "pending");
   assert.equal(JSON.stringify([...store.jobs.values()]), before);
 }));
 
@@ -78,7 +82,7 @@ test("V5 agent fallback persists Agent Run, Public Message and a server-owned op
   const created = await service.createCase({ userId, actionId: randomUUID(), calculationSpec: spec });
   const queued = await service.answer({
     userId, caseId: created.case.id, actionId: randomUUID(), expectedCaseVersion: 0,
-    answer: "2016年离家去外地上大学",
+    answer: "2016年9月离家去外地上大学",
   });
   assert.ok(queued?.job);
   const worker = createRectificationV4Worker({
@@ -109,7 +113,7 @@ test("V5 shadow runs and persists V5 artifacts but keeps the legacy visible proj
   const created = await service.createCase({ userId, actionId: randomUUID(), calculationSpec: spec });
   const queued = await service.answer({
     userId, caseId: created.case.id, actionId: randomUUID(), expectedCaseVersion: 0,
-    answer: "2016年离家去外地上大学",
+    answer: "2016年9月离家去外地上大学",
   });
   const worker = createRectificationV4Worker({
     store, now: fixedNow,
@@ -123,11 +127,34 @@ test("V5 shadow runs and persists V5 artifacts but keeps the legacy visible proj
   assert.equal(run.deploymentMode, "v5_shadow");
   assert.equal(run.validatedDecision.selectedOpportunity?.kind, "ask_new_event");
   assert.equal(run.validatedDecision.selectedOpportunity?.targetEventId, null);
-  assert.equal(done.case.currentQuestion?.targetEventId, event.eventId);
+  assert.equal(done.case.currentQuestion?.targetEventId, null);
   assert.match(done.case.currentQuestion?.reason ?? "", /V4 legacy projector/);
   assert.match(store.publicMessages.get(queued.job.id)?.acknowledgement ?? "", /我记下了/);
 }));
 
+test("V5 shadow keeps legacy year-precision refinement targeted to the original event", async () => withMode("v5_shadow", async () => {
+  const store = createRectificationV4MemoryStore();
+  const service = createRectificationV4CaseService(store, { now: fixedNow });
+  const userId = randomUUID();
+  const created = await service.createCase({ userId, actionId: randomUUID(), calculationSpec: spec });
+  const queued = await service.answer({
+    userId, caseId: created.case.id, actionId: randomUUID(), expectedCaseVersion: 0,
+    answer: "2016年离家去外地上大学",
+  });
+  const worker = createRectificationV4Worker({
+    store, now: fixedNow,
+    engine: { async score() { throw new Error("engine must not run before enough events"); } },
+  });
+  assert.equal(await worker.runOnce(), true);
+  const done = await service.loadCase(userId, created.case.id);
+  const event = done?.events[0];
+  assert.ok(queued?.job && event);
+  assert.equal(done.case.currentQuestion?.targetEventId, event.eventId);
+  assert.match(done.case.currentQuestion?.reason ?? "", /V4 legacy projector/);
+  assert.ok([...store.agentRuns.values()].length > 0);
+  assert.ok(store.publicMessages.has(queued.job.id));
+}));
+
 test("legacy cases are not hard-switched to V5 even when flags change later", async () => {
   const store = createRectificationV4MemoryStore();
   const service = createRectificationV4CaseService(store, { now: fixedNow });

From 2384faf367806c117b55328eea41467e10df63e7 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Thu, 30 Jul 2026 10:55:39 +0800
Subject: [PATCH 12/15] feat: harden rectification candidate validation

---
 docs/BUG_HISTORY.md                           |  16 +
 .../src/app/api/rectification/v4/_server.ts   |  28 +-
 .../events/[eventId]/revisions/route.ts       |   3 +-
 .../lib/rectification-agent/orchestrator.ts   |   6 +-
 .../rectification-v4/candidate-clusters.ts    |   3 +
 .../lib/rectification-v4/candidate-engine.ts  |   8 +
 .../src/lib/rectification-v4/contracts.ts     |  45 +-
 .../src/lib/rectification-v4/decision-gate.ts |  17 +-
 .../lib/rectification-v4/evidence-ledger.ts   |  14 +
 .../src/lib/rectification-v4/extraction.ts    |   4 +-
 .../src/lib/rectification-v4/fingerprints.ts  |   3 +-
 .../lib/rectification-v4/supabase-store.ts    |  11 +-
 .../technique-layer-policy.ts                 |  43 ++
 ...0260730010000_rectification_provenance.sql | 390 ++++++++++++++++++
 frontend/tests/rectification-agent-v5.test.ts |   3 +-
 frontend/tests/rectification-agent-v6.test.ts |   2 +-
 ...cation-candidate-clusters-midnight.test.ts |  53 +++
 .../tests/rectification-provenance.test.ts    |  89 ++++
 ...rectification-public-range-gate-v6.test.ts | 112 +++++
 .../rectification-renderer-safety-v6.test.ts  |   2 +-
 .../tests/rectification-v4-domain.test.ts     |   4 +-
 scripts/rectification/contracts.py            |  53 ++-
 scripts/rectification/diagnostics_service.py  |  14 +-
 scripts/rectification/scoring_service.py      |  11 +-
 skills/birth-time-rectification/SKILL.md      |  13 +-
 .../references/event-schema.md                |   2 +
 .../references/failure-policy.md              |   6 +
 .../references/output-contract.md             |   6 +-
 .../references/technique-policy.md            |  16 +-
 ...test_rectification_diagnostics_clusters.py |  53 +++
 tests/test_rectification_provenance.py        |  47 +++
 tests/test_rectification_v5_services.py       |  60 ++-
 32 files changed, 1093 insertions(+), 44 deletions(-)
 create mode 100644 frontend/src/lib/rectification-v4/technique-layer-policy.ts
 create mode 100644 frontend/supabase/migrations/20260730010000_rectification_provenance.sql
 create mode 100644 frontend/tests/rectification-candidate-clusters-midnight.test.ts
 create mode 100644 frontend/tests/rectification-provenance.test.ts
 create mode 100644 frontend/tests/rectification-public-range-gate-v6.test.ts
 create mode 100644 tests/test_rectification_diagnostics_clusters.py
 create mode 100644 tests/test_rectification_provenance.py

diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index 60ec2433..487cb860 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -1740,3 +1740,19 @@
 - 相关记录：BUG-090、BUG-093、BUG-094、BUG-095
 - 复发自：BUG-093、BUG-095
 - 修复版本：待本次 staging 修复提交与部署验收
+
+## BUG-098 | V6 公开候选门禁未明确 LODO、技法层级与独立 holdout 边界
+
+- 状态：resolved/partial
+- 首次发现：2026-07-30
+- 最近更新：2026-07-30
+- 影响面：V6 Python 候选扫描、Candidate Snapshot 公开范围门禁、生时纠正 Skill 与参考 Skill 能力声明
+- 用户现象：现有说明容易把“支持某技法”、同一 Case 内的留一诊断和参考 Skill 方法论误读为已完成独立验证；缺失 `KP_cusps` 或 D60 也可能被错误当成公开范围的统一硬阻塞。
+- 根因：文档没有把真实实现链、LODO public gate、active-domain required/optional/reference-only 技法策略和参考 Skill 的未实现能力分开；LOEO/LODO 使用同一事件贡献矩阵做事后减项，不能替代 prospective independent holdout。
+- 修复：记录 V6 的真实链路为跨午夜兼容的逐分钟 Python 扫描、事件贡献矩阵、Snapshot、LOEO/LODO、date sensitivity、neighbor stability 与 candidate split；公开范围新增 LODO 稳定性门禁，并按活跃可评分领域判定 required layer，`KP_cusps` 为 optional、D60 为 reference-only、未知层失败关闭；事件 provenance 仅用于审计且不参与加权。
+- 验证：本工作树的聚焦合同覆盖跨午夜分钟枚举、LODO 低于 `0.8` 拒绝公开范围、required layer 缺失阻塞、`KP_cusps`/D60 缺失不阻塞，以及旧 Snapshot 兼容；本记录不把这些回归误写成独立 holdout 验证。
+- Partial / deferred：per-Case independent holdout 因缺少 prospective sticky partition 与 calibration contract 延期。当前 LOEO/LODO 只证明同一 Case 内的敏感性，不得伪称 prospective、independent 或 calibrated validation 已完成。
+- 安全边界：继续禁止手工 `supports/conflicts` 伪评分、任意外部仓动态加载、唯一分钟结论和自动写入 `profiles.active_birth_time`；参考 Skill 只作方法与审计参照，不成为第二评分真源。
+- 防复发：公开候选必须同时通过事件/领域覆盖、范围宽度、邻近分钟、LOEO、LODO、日期敏感性、计算规格和 required-technique 门禁；任何 holdout 完成声明必须先有稳定分区持久化与校准验收证据。
+- 相关记录：BUG-082、BUG-090、BUG-093、BUG-095
+- 修复版本：`birth-time-rectification-v6` / `rectification-agent-v6-1`，独立 holdout 延期
diff --git a/frontend/src/app/api/rectification/v4/_server.ts b/frontend/src/app/api/rectification/v4/_server.ts
index 32445068..6cd759d3 100644
--- a/frontend/src/app/api/rectification/v4/_server.ts
+++ b/frontend/src/app/api/rectification/v4/_server.ts
@@ -43,13 +43,33 @@ export async function calculationSpecForUser(
   userId: string,
 ): Promise<CalculationSpec> {
   const { data, error } = await auth.from("profiles")
-    .select("birth_date,reported_birth_time,birth_time_source,birth_time_period,birth_time_clue,uncertainty_before_minutes,uncertainty_after_minutes,latitude,longitude,timezone_id,timezone_offset")
+    .select("birth_date,reported_birth_time,birth_time_source,birth_time_period,birth_time_clue,uncertainty_before_minutes,uncertainty_after_minutes,latitude,longitude,timezone_id,timezone_source,timezone_offset")
     .eq("id", userId).maybeSingle();
   if (error) throw error;
   if (!data) throw new RectificationV4HttpError(409, "请先补全出生日期、时间线索和出生地点。");
-  const profile = await resolveMissingBirthTimezoneOffset(data);
+  let resolvedLocalTimeStatus: CalculationSpec["localTimeStatus"] | undefined;
+  const profile = await resolveMissingBirthTimezoneOffset(data, {
+    fetchImpl: async (input, init) => {
+      const response = await fetch(input, init);
+      const payload = await response.clone().json().catch(() => null) as { localTimeStatus?: unknown } | null;
+      const status = payload?.localTimeStatus;
+      if (status === "resolved" || status === "not_provided" || status === "ambiguous" || status === "nonexistent") {
+        resolvedLocalTimeStatus = status;
+      }
+      return response;
+    },
+  });
   const assessment = parseBirthTimeProfile(profile);
   const range = assessBirthTime(assessment, { kind: "unavailable" }).reportedRange;
+  const birthTimeSource = typeof data.birth_time_source === "string" && data.birth_time_source.trim()
+    ? data.birth_time_source.trim() as CalculationSpec["birthTimeSource"]
+    : undefined;
+  const timezoneId = typeof data.timezone_id === "string" && data.timezone_id.trim()
+    ? data.timezone_id.trim()
+    : undefined;
+  const timezoneSource = typeof data.timezone_source === "string" && data.timezone_source.trim()
+    ? data.timezone_source.trim()
+    : undefined;
   return {
     version: "rectification-calculation-spec-v4",
     birthDate: assessment.date,
@@ -60,6 +80,10 @@ export async function calculationSpecForUser(
     latitude: assessment.location.lat,
     longitude: assessment.location.lon,
     timezoneOffsetHours: assessment.location.tz,
+    ...(birthTimeSource ? { birthTimeSource } : {}),
+    ...(timezoneId ? { timezoneId } : {}),
+    ...(timezoneSource ? { timezoneSource } : {}),
+    ...(resolvedLocalTimeStatus ? { localTimeStatus: resolvedLocalTimeStatus } : {}),
     ayanamsa: "lahiri",
     nodeMode: "mean",
     minuteStep: 1,
diff --git a/frontend/src/app/api/rectification/v4/cases/[caseId]/events/[eventId]/revisions/route.ts b/frontend/src/app/api/rectification/v4/cases/[caseId]/events/[eventId]/revisions/route.ts
index 31955439..dd26fe02 100644
--- a/frontend/src/app/api/rectification/v4/cases/[caseId]/events/[eventId]/revisions/route.ts
+++ b/frontend/src/app/api/rectification/v4/cases/[caseId]/events/[eventId]/revisions/route.ts
@@ -1,6 +1,6 @@
 import { NextResponse } from "next/server";
 import { reviseEventRequestSchema } from "@/lib/rectification-v4/contracts";
-import { appendEventRevision } from "@/lib/rectification-v4/evidence-ledger";
+import { appendEventRevision, eventDateProvenance } from "@/lib/rectification-v4/evidence-ledger";
 import { rectificationV4Context, rectificationV4Error, requestBody, routeId } from "../../../../../_server";
 
 export const runtime = "nodejs";
@@ -23,6 +23,7 @@ export async function POST(request: Request, { params }: { params: Promise<{ cas
       summary: body.summary,
       rawText: body.rawText,
       dateRange: body.dateRange,
+      ...eventDateProvenance(body),
       scoreability: body.scoreability,
     });
     return NextResponse.json(await context.service.reviseEvent({
diff --git a/frontend/src/lib/rectification-agent/orchestrator.ts b/frontend/src/lib/rectification-agent/orchestrator.ts
index efb95a6e..aafbdea7 100644
--- a/frontend/src/lib/rectification-agent/orchestrator.ts
+++ b/frontend/src/lib/rectification-agent/orchestrator.ts
@@ -163,6 +163,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
     const robustness = {
       neighborSupportMinutes: scored.robustness.neighborSupportMinutes,
       leaveOneOutRetentionRate: scored.robustness.leaveOneOutRetentionRate,
+      leaveOneDomainOutRetentionRate: scored.robustness.leaveOneDomainOutRetentionRate,
       dateSensitivityRetentionRate: scored.robustness.dateSensitivityRetentionRate,
       calculationSpecHashMatched: scored.calculationSpecHash === claimed.case.calculationSpecHash,
     };
@@ -170,7 +171,8 @@ export async function processRectificationAgentTurn(input: Readonly<{
       clusters,
       robustness,
       scoreableEventCount: scoreable.length,
-      scoreableDomainCount: domains.size,
+      scoreableDomains: [...domains],
+      missingTechniqueLayers: scored.missingLayers,
     });
     snapshot = {
       id: scored.resultId,
@@ -184,7 +186,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
       robustness,
       canConfirmExactMinute: false,
       canAcceptRange: gate.canAcceptRange,
-      gateReasons: [...gate.reasons, ...scored.missingLayers.map((layer) => `missing_layer:${layer}`)],
+      gateReasons: [...gate.reasons],
       createdAt: now.toISOString(),
     };
     diagnostics = diagnosticsSummarySchema.parse({
diff --git a/frontend/src/lib/rectification-v4/candidate-clusters.ts b/frontend/src/lib/rectification-v4/candidate-clusters.ts
index 1b32637d..d3138a5f 100644
--- a/frontend/src/lib/rectification-v4/candidate-clusters.ts
+++ b/frontend/src/lib/rectification-v4/candidate-clusters.ts
@@ -24,6 +24,9 @@ export function buildCandidateClusters(
     if (group && nextMinute(group.at(-1)!.time, candidate.time)) group.push(candidate);
     else groups.push([candidate]);
   }
+  if (groups.length > 1 && nextMinute(groups.at(-1)!.at(-1)!.time, groups[0]![0]!.time)) {
+    groups[0] = [...groups.pop()!, ...groups[0]!];
+  }
   return groups.map((group) => {
     const peakScore = Math.max(...group.map((candidate) => candidate.score));
     const peakCandidate = group.find((candidate) => candidate.score === peakScore)!;
diff --git a/frontend/src/lib/rectification-v4/candidate-engine.ts b/frontend/src/lib/rectification-v4/candidate-engine.ts
index 499cfed3..a4c3dd39 100644
--- a/frontend/src/lib/rectification-v4/candidate-engine.ts
+++ b/frontend/src/lib/rectification-v4/candidate-engine.ts
@@ -91,9 +91,17 @@ export function createRectificationV4CandidateEngine(options: { readonly apiBase
       body: JSON.stringify({
         birth_date: calculationSpec.birthDate, start_time: calculationSpec.candidateRange.start, end_time: calculationSpec.candidateRange.end,
         lat: calculationSpec.latitude, lon: calculationSpec.longitude, tz: calculationSpec.timezoneOffsetHours,
+        ...(Object.hasOwn(calculationSpec, "birthTimeSource") ? { birth_time_source: calculationSpec.birthTimeSource } : {}),
+        ...(Object.hasOwn(calculationSpec, "timezoneId") ? { timezone_id: calculationSpec.timezoneId } : {}),
+        ...(Object.hasOwn(calculationSpec, "timezoneSource") ? { timezone_source: calculationSpec.timezoneSource } : {}),
+        ...(Object.hasOwn(calculationSpec, "localTimeStatus") ? { local_time_status: calculationSpec.localTimeStatus } : {}),
         events: events.map((event) => ({
           id: event.eventId, domain: event.domain, event_kind: event.eventKind,
           date_start: event.dateRange.start, date_end: event.dateRange.end, precision: event.dateRange.precision, summary: event.summary,
+          ...(Object.hasOwn(event, "dateSource") ? { date_source: event.dateSource } : {}),
+          ...(Object.hasOwn(event, "dateReliability") ? { date_reliability: event.dateReliability } : {}),
+          ...(Object.hasOwn(event, "dateCorroboration") ? { date_corroboration: event.dateCorroboration } : {}),
+          ...(Object.hasOwn(event, "dateConflictStatus") ? { date_conflict_status: event.dateConflictStatus } : {}),
         })),
       }),
     });
diff --git a/frontend/src/lib/rectification-v4/contracts.ts b/frontend/src/lib/rectification-v4/contracts.ts
index 91d75009..e9d91f0d 100644
--- a/frontend/src/lib/rectification-v4/contracts.ts
+++ b/frontend/src/lib/rectification-v4/contracts.ts
@@ -82,6 +82,13 @@ export type RelatedPerson = z.infer<typeof relatedPersonSchema>;
 export const scoreabilitySchema = z.enum(["scoreable", "context_only", "pending_review", "unsupported"]);
 export type Scoreability = z.infer<typeof scoreabilitySchema>;
 
+const eventDateProvenanceFields = {
+  dateSource: z.string().trim().min(1).max(120).nullable().optional(),
+  dateReliability: z.string().trim().min(1).max(120).nullable().optional(),
+  dateCorroboration: z.string().trim().min(1).max(1_000).nullable().optional(),
+  dateConflictStatus: z.string().trim().min(1).max(120).nullable().optional(),
+} as const;
+
 export const lifeEventRevisionSchema = z.object({
   id: z.string().uuid(),
   eventId: z.string().uuid(),
@@ -93,6 +100,7 @@ export const lifeEventRevisionSchema = z.object({
   summary: z.string().trim().min(1).max(1_000),
   rawText: z.string().trim().min(1).max(4_000),
   dateRange: eventDateRangeSchema,
+  ...eventDateProvenanceFields,
   scoreability: scoreabilitySchema,
   supersedesRevisionId: z.string().uuid().nullable(),
   createdAt: z.string().datetime({ offset: true }),
@@ -119,6 +127,17 @@ export const calculationSpecSchema = z.object({
   latitude: z.number().finite().min(-90).max(90),
   longitude: z.number().finite().min(-180).max(180),
   timezoneOffsetHours: z.number().finite().min(-14).max(14),
+  birthTimeSource: z.enum([
+    "hospital_record",
+    "family_exact",
+    "approximate",
+    "period_only",
+    "unknown",
+    "legacy_import",
+  ]).nullable().optional(),
+  timezoneId: z.string().trim().min(1).max(120).nullable().optional(),
+  timezoneSource: z.string().trim().min(1).max(80).nullable().optional(),
+  localTimeStatus: z.enum(["resolved", "not_provided", "ambiguous", "nonexistent"]).nullable().optional(),
   ayanamsa: z.literal("lahiri"),
   nodeMode: z.literal("mean"),
   minuteStep: z.literal(1),
@@ -144,15 +163,20 @@ export const candidateClusterSchema = z.object({
 }).strict();
 export type CandidateCluster = z.infer<typeof candidateClusterSchema>;
 
-export const robustnessSchema = z.object({
+const robustnessValueSchema = z.object({
   neighborSupportMinutes: z.number().int().nonnegative(),
   leaveOneOutRetentionRate: z.number().finite().min(0).max(1),
+  leaveOneDomainOutRetentionRate: z.number().finite().min(0).max(1),
   dateSensitivityRetentionRate: z.number().finite().min(0).max(1),
   calculationSpecHashMatched: z.boolean(),
 }).strict();
-export type Robustness = z.infer<typeof robustnessSchema>;
+export type Robustness = z.infer<typeof robustnessValueSchema>;
+export const robustnessSchema: z.ZodType<Robustness> = z.preprocess((value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value) || "leaveOneDomainOutRetentionRate" in value) return value;
+  return { ...value, leaveOneDomainOutRetentionRate: 0.8 };
+}, robustnessValueSchema) as z.ZodType<Robustness>;
 
-export const candidateSnapshotSchema = z.object({
+const candidateSnapshotBaseSchema = z.object({
   id: z.string().uuid(),
   caseId: z.string().uuid(),
   caseVersion: z.number().int().nonnegative(),
@@ -167,7 +191,19 @@ export const candidateSnapshotSchema = z.object({
   gateReasons: z.array(z.string().trim().min(1).max(120)).max(20),
   createdAt: z.string().datetime({ offset: true }),
 }).strict();
-export type CandidateSnapshot = z.infer<typeof candidateSnapshotSchema>;
+
+export type CandidateSnapshot = z.infer<typeof candidateSnapshotBaseSchema>;
+export const candidateSnapshotSchema: z.ZodType<CandidateSnapshot> = candidateSnapshotBaseSchema.transform((snapshot) => {
+  if (snapshot.robustness.leaveOneDomainOutRetentionRate >= 0.8) return snapshot;
+  const reason = "leave_one_domain_out_not_stable";
+  return {
+    ...snapshot,
+    canAcceptRange: false,
+    gateReasons: snapshot.gateReasons.includes(reason)
+      ? snapshot.gateReasons
+      : [...snapshot.gateReasons, reason].slice(0, 20),
+  };
+});
 
 export const rectificationV4QuestionSchema = z.object({
   id: z.string().uuid(),
@@ -243,6 +279,7 @@ export const reviseEventRequestSchema = z.object({
   summary: z.string().trim().min(1).max(1_000),
   rawText: z.string().trim().min(1).max(4_000),
   dateRange: eventDateRangeSchema,
+  ...eventDateProvenanceFields,
   scoreability: scoreabilitySchema.optional(),
 }).strict();
 
diff --git a/frontend/src/lib/rectification-v4/decision-gate.ts b/frontend/src/lib/rectification-v4/decision-gate.ts
index 5c0a6519..e4cd896e 100644
--- a/frontend/src/lib/rectification-v4/decision-gate.ts
+++ b/frontend/src/lib/rectification-v4/decision-gate.ts
@@ -1,4 +1,5 @@
-import type { CandidateCluster, Robustness } from "./contracts.ts";
+import type { CandidateCluster, EvidenceDomain, Robustness } from "./contracts.ts";
+import { classifyMissingTechniqueLayers } from "./technique-layer-policy.ts";
 
 export type DecisionGateResult = Readonly<{
   canConfirmExactMinute: false;
@@ -10,18 +11,28 @@ export function evaluateDecisionGate(input: {
   readonly clusters: readonly CandidateCluster[];
   readonly robustness: Robustness;
   readonly scoreableEventCount: number;
-  readonly scoreableDomainCount: number;
+  readonly scoreableDomains: readonly EvidenceDomain[];
+  readonly missingTechniqueLayers?: readonly string[];
 }): DecisionGateResult {
   const reasons: string[] = [];
   const primary = input.clusters[0];
   if (!primary) reasons.push("no_primary_candidate_cluster");
   if (input.scoreableEventCount < 5) reasons.push("insufficient_scoreable_events");
-  if (input.scoreableDomainCount < 3) reasons.push("insufficient_scoreable_domains");
+  if (new Set(input.scoreableDomains).size < 3) reasons.push("insufficient_scoreable_domains");
   if ((primary?.widthMinutes ?? 0) < 2) reasons.push("single_minute_cluster_not_acceptable");
   if ((primary?.widthMinutes ?? Number.POSITIVE_INFINITY) > 15) reasons.push("primary_cluster_too_wide");
   if (input.robustness.neighborSupportMinutes < 2) reasons.push("neighbor_support_not_passed");
   if (input.robustness.leaveOneOutRetentionRate < 0.8) reasons.push("leave_one_out_not_stable");
+  if (input.robustness.leaveOneDomainOutRetentionRate < 0.8) reasons.push("leave_one_domain_out_not_stable");
   if (input.robustness.dateSensitivityRetentionRate < 0.8) reasons.push("date_range_sensitivity_not_stable");
   if (!input.robustness.calculationSpecHashMatched) reasons.push("calculation_spec_changed");
+
+  const missing = classifyMissingTechniqueLayers(
+    input.missingTechniqueLayers ?? [],
+    input.scoreableDomains,
+  );
+  reasons.push(...missing.required.map((layer) => `missing_required_layer:${layer}`));
+  reasons.push(...missing.unclassified.map((layer) => `missing_unclassified_layer:${layer}`));
+
   return { canConfirmExactMinute: false, canAcceptRange: reasons.length === 0, reasons };
 }
diff --git a/frontend/src/lib/rectification-v4/evidence-ledger.ts b/frontend/src/lib/rectification-v4/evidence-ledger.ts
index 3236751e..3870bba8 100644
--- a/frontend/src/lib/rectification-v4/evidence-ledger.ts
+++ b/frontend/src/lib/rectification-v4/evidence-ledger.ts
@@ -6,6 +6,20 @@ export type NewEventRevision = Omit<LifeEventRevision, "id" | "revision" | "supe
   readonly scoreability?: LifeEventRevision["scoreability"];
 };
 
+export type EventDateProvenance = Pick<
+  LifeEventRevision,
+  "dateSource" | "dateReliability" | "dateCorroboration" | "dateConflictStatus"
+>;
+
+export function eventDateProvenance(value: Partial<EventDateProvenance>): Partial<EventDateProvenance> {
+  return {
+    ...(Object.prototype.hasOwnProperty.call(value, "dateSource") ? { dateSource: value.dateSource } : {}),
+    ...(Object.prototype.hasOwnProperty.call(value, "dateReliability") ? { dateReliability: value.dateReliability } : {}),
+    ...(Object.prototype.hasOwnProperty.call(value, "dateCorroboration") ? { dateCorroboration: value.dateCorroboration } : {}),
+    ...(Object.prototype.hasOwnProperty.call(value, "dateConflictStatus") ? { dateConflictStatus: value.dateConflictStatus } : {}),
+  };
+}
+
 export function latestEventRevisions(revisions: readonly LifeEventRevision[]): readonly LifeEventRevision[] {
   const latest = new Map<string, LifeEventRevision>();
   for (const revision of revisions) {
diff --git a/frontend/src/lib/rectification-v4/extraction.ts b/frontend/src/lib/rectification-v4/extraction.ts
index c1231b72..998df44d 100644
--- a/frontend/src/lib/rectification-v4/extraction.ts
+++ b/frontend/src/lib/rectification-v4/extraction.ts
@@ -10,7 +10,7 @@ import type {
   Scoreability,
 } from "./contracts.ts";
 import { dateRangeFromDeclared } from "./date-range.ts";
-import { appendEventRevision, latestEventRevisions } from "./evidence-ledger.ts";
+import { appendEventRevision, eventDateProvenance, latestEventRevisions } from "./evidence-ledger.ts";
 
 const allowedKinds = new Set<EventKind>([
   "education_milestone", "relocation", "relationship_start", "relationship_end", "relationship_change",
@@ -111,6 +111,7 @@ function subjectRevision(answer: string, target: LifeEventRevision, existing: re
     summary: target.summary,
     rawText: answer,
     dateRange: target.dateRange,
+    ...eventDateProvenance(target),
     scoreability,
   }, { now });
 }
@@ -161,6 +162,7 @@ export function reconcileV4Evidence(input: {
             summary: target.summary,
             rawText: input.answer,
             dateRange,
+            ...eventDateProvenance(target),
             scoreability: target.scoreability,
           }, { id: targetAnswer.id, now: input.now }));
           consumed.add(targetAnswer.id);
diff --git a/frontend/src/lib/rectification-v4/fingerprints.ts b/frontend/src/lib/rectification-v4/fingerprints.ts
index 2912313c..dbca91e3 100644
--- a/frontend/src/lib/rectification-v4/fingerprints.ts
+++ b/frontend/src/lib/rectification-v4/fingerprints.ts
@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import type { CalculationSpec, LifeEventRevision } from "./contracts.ts";
-import { latestEventRevisions } from "./evidence-ledger.ts";
+import { eventDateProvenance, latestEventRevisions } from "./evidence-ledger.ts";
 
 function canonical(value: unknown): unknown {
   if (Array.isArray(value)) return value.map(canonical);
@@ -28,6 +28,7 @@ export function evidenceSetHash(revisions: readonly LifeEventRevision[]): string
     subject: event.subject,
     relatedPerson: event.relatedPerson,
     dateRange: event.dateRange,
+    ...eventDateProvenance(event),
     scoreability: event.scoreability,
   })));
 }
diff --git a/frontend/src/lib/rectification-v4/supabase-store.ts b/frontend/src/lib/rectification-v4/supabase-store.ts
index 7b7348fa..4928bea5 100644
--- a/frontend/src/lib/rectification-v4/supabase-store.ts
+++ b/frontend/src/lib/rectification-v4/supabase-store.ts
@@ -108,7 +108,10 @@ function caseValue(row: Row, latestSnapshot: CandidateSnapshot | null): Rectific
   });
 }
 
-function eventRevision(row: Row): LifeEventRevision {
+export function rectificationEventRevisionFromRow(row: Row): LifeEventRevision {
+  const provenance = row.date_provenance && typeof row.date_provenance === "object" && !Array.isArray(row.date_provenance)
+    ? row.date_provenance as Row
+    : null;
   return lifeEventRevisionSchema.parse({
     id: row.id,
     eventId: row.event_id,
@@ -125,6 +128,10 @@ function eventRevision(row: Row): LifeEventRevision {
       precision: row.date_precision,
       label: row.date_label,
     },
+    ...(provenance && Object.prototype.hasOwnProperty.call(provenance, "dateSource") ? { dateSource: provenance.dateSource } : {}),
+    ...(provenance && Object.prototype.hasOwnProperty.call(provenance, "dateReliability") ? { dateReliability: provenance.dateReliability } : {}),
+    ...(provenance && Object.prototype.hasOwnProperty.call(provenance, "dateCorroboration") ? { dateCorroboration: provenance.dateCorroboration } : {}),
+    ...(provenance && Object.prototype.hasOwnProperty.call(provenance, "dateConflictStatus") ? { dateConflictStatus: provenance.dateConflictStatus } : {}),
     scoreability: row.scoreability,
     supersedesRevisionId: row.supersedes_revision_id,
     createdAt: timestamp(row.created_at),
@@ -191,7 +198,7 @@ export function createRectificationV4SupabaseStore(supabase: SupabaseClient): Re
       .select("*").eq("case_id", caseId).eq("user_id", userId)
       .order("created_at", { ascending: true });
     if (error) throw storeError(error);
-    return ((data ?? []) as Row[]).map(eventRevision);
+    return ((data ?? []) as Row[]).map(rectificationEventRevisionFromRow);
   }
 
   async function loadTurnsByCase(userId: string, caseId: string): Promise<readonly RectificationV4Turn[]> {
diff --git a/frontend/src/lib/rectification-v4/technique-layer-policy.ts b/frontend/src/lib/rectification-v4/technique-layer-policy.ts
new file mode 100644
index 00000000..eff4c57d
--- /dev/null
+++ b/frontend/src/lib/rectification-v4/technique-layer-policy.ts
@@ -0,0 +1,43 @@
+import type { EvidenceDomain } from "./contracts.ts";
+import { domainScorerRegistry } from "./domain-scorers.ts";
+
+export type MissingTechniqueLayerClassification = Readonly<{
+  required: readonly string[];
+  optional: readonly string[];
+  referenceOnly: readonly string[];
+  unclassified: readonly string[];
+}>;
+
+const aliases: Readonly<Record<string, string>> = {
+  Vimshottari_MD_AD_PD: "vimshottari",
+  Narayana_MD_AD: "narayana",
+};
+const optionalLayers = new Set(["KP_cusps", "A7", "Ashtakavarga", "Shadbala"]);
+const referenceOnlyLayers = new Set(["D60"]);
+const knownDomainLayers = new Set(
+  Object.values(domainScorerRegistry).flatMap((policy) => policy.techniqueLayers),
+);
+
+export function classifyMissingTechniqueLayers(
+  missingLayers: readonly string[],
+  activeScoreableDomains: readonly EvidenceDomain[],
+): MissingTechniqueLayerClassification {
+  const requiredLayers = new Set(
+    activeScoreableDomains.flatMap((domain) => domainScorerRegistry[domain].techniqueLayers),
+  );
+  const classified = {
+    required: [] as string[],
+    optional: [] as string[],
+    referenceOnly: [] as string[],
+    unclassified: [] as string[],
+  };
+
+  for (const layer of [...new Set(missingLayers)]) {
+    const canonical = aliases[layer] ?? layer;
+    if (referenceOnlyLayers.has(canonical)) classified.referenceOnly.push(layer);
+    else if (requiredLayers.has(canonical)) classified.required.push(layer);
+    else if (optionalLayers.has(canonical) || knownDomainLayers.has(canonical)) classified.optional.push(layer);
+    else classified.unclassified.push(layer);
+  }
+  return classified;
+}
diff --git a/frontend/supabase/migrations/20260730010000_rectification_provenance.sql b/frontend/supabase/migrations/20260730010000_rectification_provenance.sql
new file mode 100644
index 00000000..d6dba0bb
--- /dev/null
+++ b/frontend/supabase/migrations/20260730010000_rectification_provenance.sql
@@ -0,0 +1,390 @@
+begin;
+
+alter table public.birth_time_rectification_v4_event_revisions
+  add column if not exists date_provenance jsonb;
+
+alter table public.birth_time_rectification_v4_event_revisions
+  drop constraint if exists birth_time_rectification_v4_event_revisions_date_provenance_check;
+alter table public.birth_time_rectification_v4_event_revisions
+  add constraint birth_time_rectification_v4_event_revisions_date_provenance_check
+  check (date_provenance is null or pg_catalog.jsonb_typeof(date_provenance) = 'object');
+
+create or replace function public.revise_birth_time_rectification_v4_event(
+  p_user_id uuid, p_case_id uuid, p_action_id uuid, p_expected_version bigint,
+  p_revision jsonb, p_output_evidence_set_hash text, p_turn_id uuid, p_job_id uuid, p_now timestamptz
+) returns uuid
+language plpgsql security definer set search_path = '' as $$
+declare v_case public.birth_time_rectification_v4_cases%rowtype; v_job_id uuid; v_event_id uuid;
+begin
+  select action.job_id into v_job_id from public.birth_time_rectification_v4_actions action
+    where action.user_id = p_user_id and action.action_id = p_action_id;
+  if v_job_id is not null then return v_job_id; end if;
+  select value.* into v_case from public.birth_time_rectification_v4_cases value
+    where value.id = p_case_id and value.user_id = p_user_id for update;
+  if not found then raise exception 'rectification_v4_case_not_found'; end if;
+  if v_case.version <> p_expected_version then raise exception 'stale_rectification_v4_case'; end if;
+  if v_case.status in ('processing', 'abandoned', 'paused') then raise exception 'rectification_v4_case_invalid_state'; end if;
+  if jsonb_typeof(p_revision) <> 'object' then raise exception 'invalid_rectification_v4_event_revision'; end if;
+  v_event_id = (p_revision->>'eventId')::uuid;
+  insert into public.birth_time_rectification_v4_events(id, case_id, user_id, created_at)
+    values (v_event_id, p_case_id, p_user_id, p_now) on conflict (id) do nothing;
+  insert into public.birth_time_rectification_v4_event_revisions(
+    id, event_id, case_id, user_id, revision, domain, event_kind, summary, raw_text,
+    date_start, date_end, date_precision, date_label, date_provenance, scoreability, supersedes_revision_id, created_at
+  ) values (
+    (p_revision->>'id')::uuid, v_event_id, p_case_id, p_user_id,
+    (p_revision->>'revision')::integer, p_revision->>'domain', p_revision->>'eventKind',
+    p_revision->>'summary', p_revision->>'rawText',
+    (p_revision#>>'{dateRange,start}')::date, (p_revision#>>'{dateRange,end}')::date,
+    p_revision#>>'{dateRange,precision}', p_revision#>>'{dateRange,label}',
+    (select pg_catalog.jsonb_object_agg(entry.key, entry.value)
+       from pg_catalog.jsonb_each(p_revision) entry
+      where entry.key in ('dateSource', 'dateReliability', 'dateCorroboration', 'dateConflictStatus')),
+    p_revision->>'scoreability', nullif(p_revision->>'supersedesRevisionId', '')::uuid,
+    (p_revision->>'createdAt')::timestamptz
+  );
+  insert into public.birth_time_rectification_v4_turns(
+    id, case_id, user_id, case_version, question, answer, action_id, created_at
+  ) values (p_turn_id, p_case_id, p_user_id, p_expected_version + 1, '修订事件', '', p_action_id, p_now);
+  update public.birth_time_rectification_v4_cases set
+    version = p_expected_version + 1, status = 'processing', phase = 'scoring_candidates',
+    evidence_set_hash = p_output_evidence_set_hash, current_question = null, updated_at = p_now
+    where id = p_case_id;
+  insert into public.birth_time_rectification_v4_jobs(
+    id, case_id, user_id, turn_id, status, phase, expected_case_version,
+    evidence_set_hash, calculation_spec_hash, created_at, updated_at
+  ) values (
+    p_job_id, p_case_id, p_user_id, p_turn_id, 'pending', 'scoring_candidates', p_expected_version + 1,
+    p_output_evidence_set_hash, v_case.calculation_spec_hash, p_now, p_now
+  );
+  insert into public.birth_time_rectification_v4_actions(user_id, action_id, case_id, job_id, created_at)
+    values (p_user_id, p_action_id, p_case_id, p_job_id, p_now);
+  return p_job_id;
+end;
+$$;
+
+create or replace function public.complete_birth_time_rectification_v5_job(
+  p_worker_id uuid,
+  p_job_id uuid,
+  p_expected_case_version bigint,
+  p_input_evidence_set_hash text,
+  p_output_evidence_set_hash text,
+  p_calculation_spec_hash text,
+  p_completion_payload_hash text,
+  p_event_revisions jsonb,
+  p_pending_evidence jsonb,
+  p_snapshot jsonb,
+  p_diagnostics jsonb,
+  p_feature_snapshot jsonb,
+  p_validated_decision jsonb,
+  p_public_message jsonb,
+  p_agent_run jsonb,
+  p_next_question jsonb,
+  p_status text,
+  p_phase text,
+  p_now timestamptz
+) returns uuid
+language plpgsql security definer set search_path = '' as $$
+declare
+  v_job public.birth_time_rectification_v4_jobs%rowtype;
+  v_case public.birth_time_rectification_v4_cases%rowtype;
+  v_existing_run public.birth_time_rectification_agent_runs%rowtype;
+  v_existing_message public.birth_time_rectification_public_messages%rowtype;
+  item jsonb;
+  v_snapshot_id uuid;
+  v_feature_id uuid;
+  v_diagnostics_id uuid;
+  v_event_id uuid;
+  v_supersedes_id uuid;
+  v_pending_count integer;
+begin
+  if jsonb_typeof(p_event_revisions) is distinct from 'array'
+    or jsonb_typeof(p_pending_evidence) is distinct from 'array'
+    or jsonb_typeof(p_validated_decision) is distinct from 'object'
+    or jsonb_typeof(p_public_message) is distinct from 'object'
+    or jsonb_typeof(p_agent_run) is distinct from 'object'
+    or p_output_evidence_set_hash !~ '^[a-f0-9]{64}$'
+    or p_calculation_spec_hash !~ '^[a-f0-9]{64}$'
+    or p_completion_payload_hash !~ '^[a-f0-9]{64}$' then
+    raise exception 'invalid_rectification_v5_completion_payload';
+  end if;
+
+  select value.* into v_job
+  from public.birth_time_rectification_v4_jobs value
+  where value.id = p_job_id
+  for update;
+  if not found then raise exception 'rectification_v4_job_lease_lost'; end if;
+
+  select value.* into v_case
+  from public.birth_time_rectification_v4_cases value
+  where value.id = v_job.case_id
+  for update;
+  if not found then raise exception 'rectification_v4_case_not_found'; end if;
+
+  -- A network retry after commit is an idempotent read, never a second artifact write.
+  if v_job.status = 'completed' then
+    select value.* into v_existing_run
+    from public.birth_time_rectification_agent_runs value
+    where value.job_id = p_job_id;
+    select value.* into v_existing_message
+    from public.birth_time_rectification_public_messages value
+    where value.job_id = p_job_id;
+    select count(*) into v_pending_count
+    from public.birth_time_rectification_pending_evidence value
+    where value.turn_id = v_job.turn_id;
+    if v_existing_run.id is null
+      or v_existing_run.id is distinct from (p_agent_run->>'id')::uuid
+      or v_existing_run.case_id is distinct from v_case.id
+      or v_existing_run.case_version is distinct from p_expected_case_version
+      or v_existing_run.validated_decision_json is distinct from p_validated_decision
+      or v_existing_message.job_id is null
+      or v_existing_message.message is distinct from p_public_message
+      or v_job.completion_payload_hash is distinct from p_completion_payload_hash
+      or v_pending_count is distinct from pg_catalog.jsonb_array_length(p_pending_evidence) then
+      raise exception 'rectification_v5_replay_payload_mismatch';
+    end if;
+    for item in select value from pg_catalog.jsonb_array_elements(p_pending_evidence) loop
+      if not exists (
+        select 1 from public.birth_time_rectification_pending_evidence value
+        where value.id = (item->>'id')::uuid
+          and value.case_id = v_case.id
+          and value.user_id = v_case.user_id
+          and value.turn_id = v_job.turn_id
+          and value.target_event_id is not distinct from nullif(item->>'targetEventId', '')::uuid
+          and value.raw_text = item->>'rawText'
+          and value.reason_code = item->>'reasonCode'
+          and value.resolved_event_id is not distinct from nullif(item->>'resolvedEventId', '')::uuid
+          and value.created_at = (item->>'createdAt')::timestamptz
+          and value.resolved_at is not distinct from nullif(item->>'resolvedAt', '')::timestamptz
+      ) then
+        raise exception 'rectification_v5_replay_payload_mismatch';
+      end if;
+    end loop;
+    return v_case.id;
+  end if;
+
+  if v_job.worker_id is distinct from p_worker_id
+    or v_job.status <> 'processing'
+    or v_job.lease_expires_at <= p_now then
+    raise exception 'rectification_v4_job_lease_lost';
+  end if;
+  if v_case.version is distinct from p_expected_case_version
+    or v_case.evidence_set_hash is distinct from p_input_evidence_set_hash
+    or v_case.calculation_spec_hash is distinct from p_calculation_spec_hash
+    or v_job.expected_case_version is distinct from p_expected_case_version
+    or v_job.evidence_set_hash is distinct from p_input_evidence_set_hash
+    or v_job.calculation_spec_hash is distinct from p_calculation_spec_hash then
+    raise exception 'stale_rectification_v4_job';
+  end if;
+
+  if (p_agent_run->>'caseId')::uuid is distinct from v_case.id
+    or (p_agent_run->>'jobId')::uuid is distinct from p_job_id
+    or (p_agent_run->>'caseVersion')::bigint is distinct from p_expected_case_version
+    or p_agent_run->>'deploymentMode' is distinct from v_case.deployment_mode
+    or p_agent_run->'validatedDecision' is distinct from p_validated_decision
+    or jsonb_typeof(p_agent_run->'toolCalls') is distinct from 'array'
+    or pg_catalog.jsonb_array_length(p_agent_run->'toolCalls') > 8
+    or p_validated_decision->>'mode' not in ('agent', 'deterministic_fallback') then
+    raise exception 'invalid_rectification_v5_agent_run';
+  end if;
+
+  for item in select value from pg_catalog.jsonb_array_elements(p_event_revisions) loop
+    v_event_id := (item->>'eventId')::uuid;
+    v_supersedes_id := nullif(item->>'supersedesRevisionId', '')::uuid;
+    if (item->>'caseId') is not null and (item->>'caseId')::uuid is distinct from v_case.id then
+      raise exception 'rectification_v5_event_case_mismatch';
+    end if;
+    insert into public.birth_time_rectification_v4_events(
+      id, case_id, user_id, created_at
+    ) values (
+      v_event_id, v_case.id, v_case.user_id, (item->>'createdAt')::timestamptz
+    ) on conflict (id) do nothing;
+    if not exists (
+      select 1 from public.birth_time_rectification_v4_events value
+      where value.id = v_event_id and value.case_id = v_case.id and value.user_id = v_case.user_id
+    ) then
+      raise exception 'rectification_v5_event_case_mismatch';
+    end if;
+    if v_supersedes_id is not null and not exists (
+      select 1 from public.birth_time_rectification_v4_event_revisions value
+      where value.id = v_supersedes_id and value.event_id = v_event_id and value.case_id = v_case.id
+    ) then
+      raise exception 'rectification_v5_superseded_revision_mismatch';
+    end if;
+    insert into public.birth_time_rectification_v4_event_revisions(
+      id, event_id, case_id, user_id, revision, domain, event_kind, subject,
+      related_person, summary, raw_text, date_start, date_end, date_precision,
+      date_label, date_provenance, scoreability, supersedes_revision_id, created_at
+    ) values (
+      (item->>'id')::uuid, v_event_id, v_case.id, v_case.user_id,
+      (item->>'revision')::integer, item->>'domain', item->>'eventKind', item->>'subject',
+      nullif(item->>'relatedPerson', ''), item->>'summary', item->>'rawText',
+      (item#>>'{dateRange,start}')::date, (item#>>'{dateRange,end}')::date,
+      item#>>'{dateRange,precision}', item#>>'{dateRange,label}',
+      (select pg_catalog.jsonb_object_agg(entry.key, entry.value)
+         from pg_catalog.jsonb_each(item) entry
+        where entry.key in ('dateSource', 'dateReliability', 'dateCorroboration', 'dateConflictStatus')),
+      item->>'scoreability', v_supersedes_id, (item->>'createdAt')::timestamptz
+    );
+  end loop;
+
+  for item in select value from pg_catalog.jsonb_array_elements(p_pending_evidence) loop
+    if (item->>'caseId')::uuid is distinct from v_case.id
+      or (item->>'turnId')::uuid is distinct from v_job.turn_id
+      or item->>'reasonCode' not in ('date_unresolved', 'event_unparsed')
+      or nullif(btrim(item->>'rawText'), '') is null
+      or (nullif(item->>'resolvedEventId', '') is null) is distinct from (nullif(item->>'resolvedAt', '') is null) then
+      raise exception 'invalid_rectification_v5_pending_evidence';
+    end if;
+    if nullif(item->>'targetEventId', '') is not null and not exists (
+      select 1 from public.birth_time_rectification_v4_events value
+      where value.id = (item->>'targetEventId')::uuid and value.case_id = v_case.id
+    ) then
+      raise exception 'rectification_v5_pending_target_event_mismatch';
+    end if;
+    if nullif(item->>'resolvedEventId', '') is not null and not exists (
+      select 1 from public.birth_time_rectification_v4_events value
+      where value.id = (item->>'resolvedEventId')::uuid and value.case_id = v_case.id
+    ) then
+      raise exception 'rectification_v5_pending_resolved_event_mismatch';
+    end if;
+    insert into public.birth_time_rectification_pending_evidence(
+      id, case_id, user_id, turn_id, target_event_id, raw_text, reason_code,
+      resolved_event_id, created_at, resolved_at
+    ) values (
+      (item->>'id')::uuid, v_case.id, v_case.user_id, (item->>'turnId')::uuid,
+      nullif(item->>'targetEventId', '')::uuid, item->>'rawText', item->>'reasonCode',
+      nullif(item->>'resolvedEventId', '')::uuid, (item->>'createdAt')::timestamptz,
+      nullif(item->>'resolvedAt', '')::timestamptz
+    );
+  end loop;
+
+  if p_snapshot is not null then
+    if jsonb_typeof(p_snapshot) is distinct from 'object'
+      or coalesce((p_snapshot->>'canConfirmExactMinute')::boolean, false) then
+      raise exception 'exact_minute_confirmation_forbidden';
+    end if;
+    v_snapshot_id := (p_snapshot->>'id')::uuid;
+    if (p_snapshot->>'caseId')::uuid is distinct from v_case.id
+      or (p_snapshot->>'caseVersion')::bigint is distinct from p_expected_case_version
+      or p_snapshot->>'evidenceSetHash' is distinct from p_output_evidence_set_hash
+      or p_snapshot->>'calculationSpecHash' is distinct from p_calculation_spec_hash
+      or p_snapshot->>'algorithmVersion' is distinct from v_case.algorithm_version then
+      raise exception 'rectification_v5_snapshot_mismatch';
+    end if;
+    insert into public.birth_time_rectification_v4_candidate_snapshots(
+      id, case_id, user_id, case_version, evidence_set_hash, calculation_spec_hash,
+      algorithm_version, candidates, clusters, robustness, can_confirm_exact_minute,
+      can_accept_range, gate_reasons, created_at
+    ) values (
+      v_snapshot_id, v_case.id, v_case.user_id, (p_snapshot->>'caseVersion')::bigint,
+      p_snapshot->>'evidenceSetHash', p_snapshot->>'calculationSpecHash',
+      p_snapshot->>'algorithmVersion', p_snapshot->'candidates', p_snapshot->'clusters',
+      p_snapshot->'robustness', false, (p_snapshot->>'canAcceptRange')::boolean,
+      p_snapshot->'gateReasons', (p_snapshot->>'createdAt')::timestamptz
+    );
+  end if;
+
+  if p_feature_snapshot is not null then
+    if jsonb_typeof(p_feature_snapshot) is distinct from 'object' then
+      raise exception 'invalid_rectification_v5_feature_snapshot';
+    end if;
+    v_feature_id := (p_feature_snapshot->>'id')::uuid;
+    if (p_feature_snapshot->>'caseId')::uuid is distinct from v_case.id
+      or p_feature_snapshot->>'calculationSpecHash' is distinct from p_calculation_spec_hash
+      or p_feature_snapshot->>'algorithmVersion' is distinct from v_case.algorithm_version then
+      raise exception 'rectification_v5_feature_snapshot_mismatch';
+    end if;
+    insert into public.birth_time_rectification_candidate_feature_snapshots(
+      id, case_id, user_id, calculation_spec_hash, algorithm_version,
+      candidate_count, feature_hash, features, created_at
+    ) values (
+      v_feature_id, v_case.id, v_case.user_id,
+      p_feature_snapshot->>'calculationSpecHash', p_feature_snapshot->>'algorithmVersion',
+      (p_feature_snapshot->>'candidateCount')::integer, p_feature_snapshot->>'featureHash',
+      p_feature_snapshot->'features', (p_feature_snapshot->>'createdAt')::timestamptz
+    );
+  end if;
+
+  if p_diagnostics is not null then
+    if jsonb_typeof(p_diagnostics) is distinct from 'object' or v_snapshot_id is null then
+      raise exception 'invalid_rectification_v5_diagnostics';
+    end if;
+    v_diagnostics_id := (p_diagnostics->>'id')::uuid;
+    if (p_diagnostics->>'caseId')::uuid is distinct from v_case.id
+      or (p_diagnostics->>'snapshotId')::uuid is distinct from v_snapshot_id then
+      raise exception 'rectification_v5_diagnostics_mismatch';
+    end if;
+    insert into public.birth_time_rectification_diagnostics(
+      id, case_id, user_id, snapshot_id, summary, calculation_hash, created_at
+    ) values (
+      v_diagnostics_id, v_case.id, v_case.user_id, v_snapshot_id,
+      p_diagnostics, p_diagnostics->>'calculationHash',
+      (p_diagnostics->>'createdAt')::timestamptz
+    );
+  end if;
+
+  if (p_diagnostics is null) is distinct from (p_snapshot is null)
+    or (p_feature_snapshot is null) is distinct from (p_snapshot is null) then
+    raise exception 'rectification_v5_artifact_set_incomplete';
+  end if;
+
+  insert into public.birth_time_rectification_agent_runs(
+    id, case_id, job_id, user_id, case_version, model_id, skill_version,
+    prompt_version, deployment_sha, deployment_mode, decision_json,
+    validated_decision_json, tool_calls_json, tool_call_count, fallback_reason,
+    input_token_count, output_token_count, latency_ms, created_at
+  ) values (
+    (p_agent_run->>'id')::uuid, v_case.id, p_job_id, v_case.user_id,
+    (p_agent_run->>'caseVersion')::bigint, nullif(p_agent_run->>'modelId', ''),
+    p_agent_run->>'skillVersion', p_agent_run->>'promptVersion',
+    nullif(p_agent_run->>'deploymentSha', ''), p_agent_run->>'deploymentMode',
+    p_agent_run->'decision', p_validated_decision, p_agent_run->'toolCalls',
+    pg_catalog.jsonb_array_length(p_agent_run->'toolCalls'),
+    nullif(p_agent_run->>'fallbackReason', ''),
+    nullif(p_agent_run->>'inputTokenCount', '')::integer,
+    nullif(p_agent_run->>'outputTokenCount', '')::integer,
+    (p_agent_run->>'latencyMs')::integer,
+    (p_agent_run->>'createdAt')::timestamptz
+  );
+  insert into public.birth_time_rectification_public_messages(
+    job_id, case_id, user_id, message, created_at
+  ) values (
+    p_job_id, v_case.id, v_case.user_id, p_public_message, p_now
+  );
+
+  update public.birth_time_rectification_v4_cases
+  set version = p_expected_case_version + 1,
+      evidence_set_hash = p_output_evidence_set_hash,
+      latest_snapshot_id = coalesce(v_snapshot_id, latest_snapshot_id),
+      feature_snapshot_id = coalesce(v_feature_id, feature_snapshot_id),
+      latest_diagnostics_id = coalesce(v_diagnostics_id, latest_diagnostics_id),
+      agent_mode = p_validated_decision->>'mode',
+      current_question = p_next_question,
+      status = p_status,
+      phase = p_phase,
+      updated_at = p_now
+  where id = v_case.id;
+  update public.birth_time_rectification_v4_jobs
+  set status = 'completed', phase = p_phase, result_snapshot_id = v_snapshot_id,
+      completion_payload_hash = p_completion_payload_hash,
+      lease_expires_at = null, updated_at = p_now
+  where id = p_job_id;
+  return v_case.id;
+end;
+$$;
+
+revoke all on function public.revise_birth_time_rectification_v4_event(uuid, uuid, uuid, bigint, jsonb, text, uuid, uuid, timestamptz) from public, anon, authenticated;
+grant execute on function public.revise_birth_time_rectification_v4_event(uuid, uuid, uuid, bigint, jsonb, text, uuid, uuid, timestamptz) to service_role;
+revoke all on function public.complete_birth_time_rectification_v5_job(
+  uuid, uuid, bigint, text, text, text, text,
+  jsonb, jsonb, jsonb, jsonb, jsonb, jsonb, jsonb, jsonb, jsonb,
+  text, text, timestamptz
+) from public, anon, authenticated;
+grant execute on function public.complete_birth_time_rectification_v5_job(
+  uuid, uuid, bigint, text, text, text, text,
+  jsonb, jsonb, jsonb, jsonb, jsonb, jsonb, jsonb, jsonb, jsonb,
+  text, text, timestamptz
+) to service_role;
+
+commit;
diff --git a/frontend/tests/rectification-agent-v5.test.ts b/frontend/tests/rectification-agent-v5.test.ts
index c67d4202..c72cc79d 100644
--- a/frontend/tests/rectification-agent-v5.test.ts
+++ b/frontend/tests/rectification-agent-v5.test.ts
@@ -57,7 +57,7 @@ const snapshot: CandidateSnapshot = {
   algorithmVersion: "rectification-v5-matrix-scoring-1",
   candidates: [{ time: "05:13", score: 10, supportingEventIds: [], conflictingEventIds: [] }],
   clusters: [{ rank: 1, startTime: "05:13", endTime: "05:15", representativeTime: "05:13", widthMinutes: 3, peakScore: 10, scoreMass: 1 }],
-  robustness: { neighborSupportMinutes: 3, leaveOneOutRetentionRate: 1, dateSensitivityRetentionRate: 1, calculationSpecHashMatched: true },
+  robustness: { neighborSupportMinutes: 3, leaveOneOutRetentionRate: 1, leaveOneDomainOutRetentionRate: 1, dateSensitivityRetentionRate: 1, calculationSpecHashMatched: true },
   canConfirmExactMinute: false,
   canAcceptRange: false,
   gateReasons: ["insufficient_scoreable_events"],
@@ -444,6 +444,7 @@ test("V6 agent conversation follows dated events, respects direction change, and
     assert.ok(fourth.events.some((event) => event.domain === "career" && event.summary.includes("商业巡演经纪公司")));
     assert.equal(scoreCalls, 1);
     assert.ok(store.diagnostics.size > 0);
+    assert.equal(fourth.case.latestSnapshot?.robustness.leaveOneDomainOutRetentionRate, 1);
     assert.equal(fourth.case.latestSnapshot?.canConfirmExactMinute, false);
     assert.equal(fourth.case.algorithmVersion, "rectification-v5-matrix-scoring-1");
     const finalMessage = [...store.publicMessages.values()].at(-1);
diff --git a/frontend/tests/rectification-agent-v6.test.ts b/frontend/tests/rectification-agent-v6.test.ts
index c4c9e900..37a37672 100644
--- a/frontend/tests/rectification-agent-v6.test.ts
+++ b/frontend/tests/rectification-agent-v6.test.ts
@@ -53,7 +53,7 @@ function snapshot(range: readonly [string, string], overrides: Partial<Candidate
     algorithmVersion: "rectification-v5-matrix-scoring-1",
     candidates: [{ time: startTime, score: 10, supportingEventIds: [], conflictingEventIds: [] }],
     clusters: [{ rank: 1, startTime, endTime, representativeTime: startTime, widthMinutes: 7, peakScore: 10, scoreMass: 1 }],
-    robustness: { neighborSupportMinutes: 8, leaveOneOutRetentionRate: .8, dateSensitivityRetentionRate: .8, calculationSpecHashMatched: true },
+    robustness: { neighborSupportMinutes: 8, leaveOneOutRetentionRate: .8, leaveOneDomainOutRetentionRate: .8, dateSensitivityRetentionRate: .8, calculationSpecHashMatched: true },
     canConfirmExactMinute: false, canAcceptRange: true, gateReasons: [], createdAt: now, ...overrides,
   };
 }
diff --git a/frontend/tests/rectification-candidate-clusters-midnight.test.ts b/frontend/tests/rectification-candidate-clusters-midnight.test.ts
new file mode 100644
index 00000000..f9aa087b
--- /dev/null
+++ b/frontend/tests/rectification-candidate-clusters-midnight.test.ts
@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { buildCandidateClusters } from "../src/lib/rectification-v4/candidate-clusters.ts";
+
+const candidate = (time: string, score: number) => ({
+  time,
+  score,
+  supportingEventIds: [],
+  conflictingEventIds: [],
+});
+
+test("candidate clusters join midnight neighbors without treating representativeTime as a confirmed minute", () => {
+  const clusters = buildCandidateClusters([
+    candidate("23:59", 100),
+    candidate("12:00", 98),
+    candidate("00:00", 99),
+  ]);
+
+  assert.deepEqual(clusters, [
+    {
+      rank: 1,
+      startTime: "23:59",
+      endTime: "00:00",
+      representativeTime: "23:59",
+      widthMinutes: 2,
+      peakScore: 100,
+      scoreMass: 199,
+    },
+    {
+      rank: 2,
+      startTime: "12:00",
+      endTime: "12:00",
+      representativeTime: "12:00",
+      widthMinutes: 1,
+      peakScore: 98,
+      scoreMass: 98,
+    },
+  ]);
+});
+
+test("candidate clusters keep ordinary daytime gaps separate", () => {
+  assert.deepEqual(
+    buildCandidateClusters([
+      candidate("05:13", 100),
+      candidate("05:14", 99),
+      candidate("05:16", 98),
+    ]).map(({ startTime, endTime, widthMinutes }) => ({ startTime, endTime, widthMinutes })),
+    [
+      { startTime: "05:13", endTime: "05:14", widthMinutes: 2 },
+      { startTime: "05:16", endTime: "05:16", widthMinutes: 1 },
+    ],
+  );
+});
diff --git a/frontend/tests/rectification-provenance.test.ts b/frontend/tests/rectification-provenance.test.ts
new file mode 100644
index 00000000..6ce643f7
--- /dev/null
+++ b/frontend/tests/rectification-provenance.test.ts
@@ -0,0 +1,89 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import { calculationSpecSchema, lifeEventRevisionSchema, reviseEventRequestSchema, type CalculationSpec, type LifeEventRevision } from "../src/lib/rectification-v4/contracts.ts";
+import { createRectificationV4CandidateEngine } from "../src/lib/rectification-v4/candidate-engine.ts";
+import { calculationSpecHash, evidenceSetHash } from "../src/lib/rectification-v4/fingerprints.ts";
+import { rectificationEventRevisionFromRow } from "../src/lib/rectification-v4/supabase-store.ts";
+
+const legacySpec: CalculationSpec = {
+  version: "rectification-calculation-spec-v4", birthDate: "1990-01-02",
+  candidateRange: { start: "05:00", end: "06:00" }, latitude: 25.033, longitude: 121.5654,
+  timezoneOffsetHours: 8, ayanamsa: "lahiri", nodeMode: "mean", minuteStep: 1,
+};
+const baseEvent: LifeEventRevision = {
+  id: "00000000-0000-4000-8000-000000000001", eventId: "00000000-0000-4000-8000-000000000002", revision: 1,
+  domain: "career", eventKind: "career_change", subject: "self", relatedPerson: null,
+  summary: "工作变动", rawText: "2020年工作变动", dateRange: { start: "2020-01-01", end: "2020-12-31", precision: "year", label: "2020" },
+  scoreability: "scoreable", supersedesRevisionId: null, createdAt: "2026-07-30T00:00:00.000Z",
+};
+
+test("legacy provenance stays absent and legacy hashes stay unchanged", () => {
+  const spec = calculationSpecSchema.parse(legacySpec);
+  const event = lifeEventRevisionSchema.parse(baseEvent);
+  assert.equal(Object.hasOwn(spec, "birthTimeSource"), false);
+  assert.equal(Object.hasOwn(event, "dateSource"), false);
+  assert.equal(calculationSpecHash(spec), "b50754817fd516b4bb089ee85f9ebb4c8fa2a148e9cdfa5c6bf694e979b216fe");
+  assert.equal(evidenceSetHash([event]), "9086797178bfcaf2f5d23f309eacf49ddab4e75e2aefa120b111dbc31a7382f5");
+});
+
+test("enriched calculation spec and evidence provenance hash deterministically", () => {
+  const enriched = calculationSpecSchema.parse({ ...legacySpec, birthTimeSource: "family_exact", timezoneId: "Asia/Taipei", timezoneSource: "iana_historical", localTimeStatus: "resolved" });
+  assert.equal(calculationSpecHash(enriched), "fa4afe79228bedebd809c7b3c9d9d32a428f7066e3e1fd1813e44b317bd38e66");
+  assert.notEqual(evidenceSetHash([{ ...baseEvent, dateSource: null }]), evidenceSetHash([baseEvent]));
+  assert.equal(evidenceSetHash([{ ...baseEvent, dateSource: "user_reported", dateReliability: "medium" }]), evidenceSetHash([{ ...baseEvent, dateReliability: "medium", dateSource: "user_reported" }]));
+});
+
+test("revision requests and Supabase rows preserve missing versus explicit null", () => {
+  const request = reviseEventRequestSchema.parse({
+    actionId: "00000000-0000-4000-8000-000000000003", expectedCaseVersion: 1,
+    domain: "career", eventKind: "career_change", subject: "self", relatedPerson: null,
+    summary: "工作变动", rawText: "2020年工作变动", dateRange: baseEvent.dateRange, dateSource: null,
+  });
+  assert.equal(Object.hasOwn(request, "dateSource"), true);
+  const row = {
+    id: baseEvent.id, event_id: baseEvent.eventId, revision: 1, domain: "career", event_kind: "career_change",
+    subject: "self", related_person: null, summary: baseEvent.summary, raw_text: baseEvent.rawText,
+    date_start: "2020-01-01", date_end: "2020-12-31", date_precision: "year", date_label: "2020",
+    scoreability: "scoreable", supersedes_revision_id: null, created_at: baseEvent.createdAt,
+  };
+  assert.equal(Object.hasOwn(rectificationEventRevisionFromRow(row), "dateSource"), false);
+  const enriched = rectificationEventRevisionFromRow({ ...row, date_provenance: { dateSource: null, dateReliability: "medium" } });
+  assert.equal(Object.hasOwn(enriched, "dateSource"), true);
+  assert.equal(enriched.dateSource, null);
+  assert.equal(enriched.dateReliability, "medium");
+});
+
+test("forward-only migration persists provenance in both RPCs and retains completed replay", () => {
+  const sql = readFileSync(new URL("../supabase/migrations/20260730010000_rectification_provenance.sql", import.meta.url), "utf8");
+  assert.match(sql, /add column if not exists date_provenance jsonb/);
+  assert.equal((sql.match(/where entry\.key in \('dateSource'/g) ?? []).length, 2);
+  assert.match(sql, /create or replace function public\.revise_birth_time_rectification_v4_event/);
+  assert.match(sql, /create or replace function public\.complete_birth_time_rectification_v5_job/);
+  assert.match(sql, /if v_job\.status = 'completed'[\s\S]*rectification_v5_replay_payload_mismatch[\s\S]*return v_case\.id/);
+  assert.doesNotMatch(sql, /update public\.birth_time_rectification_v4_event_revisions/i);
+});
+
+test("candidate engine forwards present provenance without inventing missing fields", async () => {
+  let body: Record<string, unknown> | null = null;
+  const engine = createRectificationV4CandidateEngine({
+    apiBase: "http://example.test",
+    fetchImpl: async (_input, init) => {
+      body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+      throw new Error("captured");
+    },
+  });
+  await assert.rejects(engine.score({
+    calculationSpec: { ...legacySpec, birthTimeSource: "family_exact", timezoneId: "Asia/Taipei", localTimeStatus: null },
+    events: [{ ...baseEvent, dateSource: "user_reported", dateReliability: null }],
+  }), /captured/);
+  const captured = body as unknown as Record<string, unknown>;
+  assert.equal(captured.birth_time_source, "family_exact");
+  assert.equal(captured.timezone_id, "Asia/Taipei");
+  assert.equal(Object.hasOwn(captured, "timezone_source"), false);
+  assert.equal(captured.local_time_status, null);
+  const event = (captured.events as Record<string, unknown>[])[0];
+  assert.equal(event.date_source, "user_reported");
+  assert.equal(event.date_reliability, null);
+  assert.equal(Object.hasOwn(event, "date_corroboration"), false);
+});
diff --git a/frontend/tests/rectification-public-range-gate-v6.test.ts b/frontend/tests/rectification-public-range-gate-v6.test.ts
new file mode 100644
index 00000000..cd4c8074
--- /dev/null
+++ b/frontend/tests/rectification-public-range-gate-v6.test.ts
@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { candidateSnapshotSchema, type EvidenceDomain, type Robustness } from "../src/lib/rectification-v4/contracts.ts";
+import { evaluateDecisionGate } from "../src/lib/rectification-v4/decision-gate.ts";
+import { classifyMissingTechniqueLayers } from "../src/lib/rectification-v4/technique-layer-policy.ts";
+
+const cluster = {
+  rank: 1,
+  startTime: "05:13",
+  endTime: "05:17",
+  representativeTime: "05:15",
+  widthMinutes: 5,
+  peakScore: 10,
+  scoreMass: 40,
+} as const;
+const robustness: Robustness = {
+  neighborSupportMinutes: 4,
+  leaveOneOutRetentionRate: 1,
+  leaveOneDomainOutRetentionRate: 1,
+  dateSensitivityRetentionRate: 1,
+  calculationSpecHashMatched: true,
+};
+const domains = ["education", "relocation", "career"] as const satisfies readonly EvidenceDomain[];
+
+function gate(overrides: Partial<Parameters<typeof evaluateDecisionGate>[0]> = {}) {
+  return evaluateDecisionGate({
+    clusters: [cluster],
+    robustness,
+    scoreableEventCount: 6,
+    scoreableDomains: domains,
+    missingTechniqueLayers: [],
+    ...overrides,
+  });
+}
+
+test("single-domain dependence blocks the public candidate range", () => {
+  const result = gate({ robustness: { ...robustness, leaveOneDomainOutRetentionRate: 0.79 } });
+  assert.equal(result.canAcceptRange, false);
+  assert.ok(result.reasons.includes("leave_one_domain_out_not_stable"));
+  assert.equal(result.canConfirmExactMinute, false);
+});
+
+test("KP cusps alone do not block the public candidate range", () => {
+  const classified = classifyMissingTechniqueLayers(["KP_cusps"], domains);
+  assert.deepEqual(classified.optional, ["KP_cusps"]);
+  assert.equal(gate({ missingTechniqueLayers: ["KP_cusps"] }).canAcceptRange, true);
+});
+
+test("D60 remains reference-only and does not block the public candidate range", () => {
+  const classified = classifyMissingTechniqueLayers(["D60"], domains);
+  assert.deepEqual(classified.referenceOnly, ["D60"]);
+  assert.equal(gate({ missingTechniqueLayers: ["D60"] }).canAcceptRange, true);
+});
+
+test("missing D10 blocks when career evidence is active", () => {
+  const result = gate({ missingTechniqueLayers: ["D10"] });
+  assert.equal(result.canAcceptRange, false);
+  assert.ok(result.reasons.includes("missing_required_layer:D10"));
+});
+
+test("missing D10 does not block without career evidence", () => {
+  const scoreableDomains = ["education", "relocation", "relationship"] as const;
+  assert.equal(gate({ scoreableDomains, missingTechniqueLayers: ["D10"] }).canAcceptRange, true);
+});
+
+test("unclassified missing layers fail closed", () => {
+  const result = gate({ missingTechniqueLayers: ["future_unknown_layer"] });
+  assert.equal(result.canAcceptRange, false);
+  assert.ok(result.reasons.includes("missing_unclassified_layer:future_unknown_layer"));
+});
+
+function snapshotInput(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "00000000-0000-4000-8000-000000000001",
+    caseId: "00000000-0000-4000-8000-000000000002",
+    caseVersion: 1,
+    evidenceSetHash: "e".repeat(64),
+    calculationSpecHash: "c".repeat(64),
+    algorithmVersion: "rectification-v5-matrix-scoring-1",
+    candidates: [{ time: "05:15", score: 10, supportingEventIds: [], conflictingEventIds: [] }],
+    clusters: [cluster],
+    canConfirmExactMinute: false,
+    canAcceptRange: true,
+    gateReasons: [],
+    createdAt: "2026-07-29T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+test("legacy snapshots without domain retention still parse without retroactive rejection", () => {
+  const parsed = candidateSnapshotSchema.parse(snapshotInput({
+    robustness: {
+      neighborSupportMinutes: 4,
+      leaveOneOutRetentionRate: 1,
+      dateSensitivityRetentionRate: 1,
+      calculationSpecHashMatched: true,
+    },
+  }));
+  assert.equal(parsed.robustness.leaveOneDomainOutRetentionRate, 0.8);
+  assert.equal(parsed.canAcceptRange, true);
+  assert.ok(!parsed.gateReasons.includes("leave_one_domain_out_not_stable"));
+});
+
+test("snapshots with explicit low domain retention are normalized to rejected", () => {
+  const parsed = candidateSnapshotSchema.parse(snapshotInput({
+    robustness: { ...robustness, leaveOneDomainOutRetentionRate: 0.79 },
+  }));
+  assert.equal(parsed.robustness.leaveOneDomainOutRetentionRate, 0.79);
+  assert.equal(parsed.canAcceptRange, false);
+  assert.ok(parsed.gateReasons.includes("leave_one_domain_out_not_stable"));
+});
diff --git a/frontend/tests/rectification-renderer-safety-v6.test.ts b/frontend/tests/rectification-renderer-safety-v6.test.ts
index c31fae51..24bd11d1 100644
--- a/frontend/tests/rectification-renderer-safety-v6.test.ts
+++ b/frontend/tests/rectification-renderer-safety-v6.test.ts
@@ -73,7 +73,7 @@ function snapshot(range: readonly [string, string]): CandidateSnapshot {
     algorithmVersion: "rectification-v5-matrix-scoring-1",
     candidates: [{ time: startTime, score: 10, supportingEventIds: [], conflictingEventIds: [] }],
     clusters: [{ rank: 1, startTime, endTime, representativeTime: startTime, widthMinutes: 7, peakScore: 10, scoreMass: 1 }],
-    robustness: { neighborSupportMinutes: 8, leaveOneOutRetentionRate: 0.8, dateSensitivityRetentionRate: 0.8, calculationSpecHashMatched: true },
+    robustness: { neighborSupportMinutes: 8, leaveOneOutRetentionRate: 0.8, leaveOneDomainOutRetentionRate: 0.8, dateSensitivityRetentionRate: 0.8, calculationSpecHashMatched: true },
     canConfirmExactMinute: false,
     canAcceptRange: true,
     gateReasons: [],
diff --git a/frontend/tests/rectification-v4-domain.test.ts b/frontend/tests/rectification-v4-domain.test.ts
index 9e3b6770..ab6526d0 100644
--- a/frontend/tests/rectification-v4-domain.test.ts
+++ b/frontend/tests/rectification-v4-domain.test.ts
@@ -70,9 +70,9 @@ test("candidate minutes merge into ranked contiguous clusters and never confirm
   assert.deepEqual(clusters.map((cluster) => [cluster.rank, cluster.startTime, cluster.endTime]), [[1, "05:13", "05:15"], [2, "05:17", "05:18"]]);
   const gate = evaluateDecisionGate({
     clusters: [clusters[0]!],
-    robustness: { neighborSupportMinutes: 3, leaveOneOutRetentionRate: 1, dateSensitivityRetentionRate: 0.9, calculationSpecHashMatched: true },
+    robustness: { neighborSupportMinutes: 3, leaveOneOutRetentionRate: 1, leaveOneDomainOutRetentionRate: 1, dateSensitivityRetentionRate: 0.9, calculationSpecHashMatched: true },
     scoreableEventCount: 10,
-    scoreableDomainCount: 5,
+    scoreableDomains: ["education", "relocation", "relationship", "career", "finance"],
   });
   assert.equal(gate.canAcceptRange, true);
   assert.equal(gate.canConfirmExactMinute, false);
diff --git a/scripts/rectification/contracts.py b/scripts/rectification/contracts.py
index a2dd90ce..9311ea9f 100644
--- a/scripts/rectification/contracts.py
+++ b/scripts/rectification/contracts.py
@@ -17,8 +17,12 @@ SCOREABLE_EVENT_KINDS: dict[str, frozenset[str]] = {
     "health_pressure": frozenset({"self_health_event"}),
 }
 DATE_PRECISIONS = frozenset({"day", "month", "quarter", "year", "range"})
-_REQUEST_FIELDS = frozenset({"birth_date", "start_time", "end_time", "lat", "lon", "tz", "events"})
-_EVENT_FIELDS = frozenset({"id", "domain", "event_kind", "date_start", "date_end", "precision", "summary"})
+_BIRTH_TIME_SOURCES = frozenset({"hospital_record", "family_exact", "approximate", "period_only", "unknown", "legacy_import"})
+_LOCAL_TIME_STATUSES = frozenset({"resolved", "not_provided", "ambiguous", "nonexistent"})
+_REQUEST_PROVENANCE_FIELDS = frozenset({"birth_time_source", "timezone_id", "timezone_source", "local_time_status"})
+_EVENT_PROVENANCE_FIELDS = frozenset({"date_source", "date_reliability", "date_corroboration", "date_conflict_status"})
+_REQUEST_FIELDS = frozenset({"birth_date", "start_time", "end_time", "lat", "lon", "tz", "events"}) | _REQUEST_PROVENANCE_FIELDS
+_EVENT_FIELDS = frozenset({"id", "domain", "event_kind", "date_start", "date_end", "precision", "summary"}) | _EVENT_PROVENANCE_FIELDS
 _CLOCK = re.compile(r"(?:[01]\d|2[0-3]):[0-5]\d\Z")
 
 
@@ -30,6 +34,10 @@ class LifeEvent(TypedDict):
     date_end: str
     precision: DatePrecision
     summary: NotRequired[str]
+    date_source: NotRequired[str | None]
+    date_reliability: NotRequired[str | None]
+    date_corroboration: NotRequired[str | None]
+    date_conflict_status: NotRequired[str | None]
 
 
 class RectificationRequest(TypedDict):
@@ -40,6 +48,10 @@ class RectificationRequest(TypedDict):
     lon: float
     tz: float
     events: list[LifeEvent]
+    birth_time_source: NotRequired[str | None]
+    timezone_id: NotRequired[str | None]
+    timezone_source: NotRequired[str | None]
+    local_time_status: NotRequired[str | None]
 
 
 JsonObject = dict[str, Any]
@@ -64,6 +76,24 @@ def _calendar_date(value: Any, label: str) -> date:
         raise ValueError(f"{label} must be a valid YYYY-MM-DD value") from exc
 
 
+def _copy_nullable_text(
+    source: dict[str, Any], target: dict[str, Any], name: str, label: str, maximum: int,
+    allowed: frozenset[str] | None = None,
+) -> None:
+    if name not in source:
+        return
+    value = source[name]
+    if value is None:
+        target[name] = None
+        return
+    if not isinstance(value, str) or not value.strip() or len(value.strip()) > maximum:
+        raise ValueError(f"{label} must be null or a non-empty string up to {maximum} characters")
+    cleaned = value.strip()
+    if allowed is not None and cleaned not in allowed:
+        raise ValueError(f"{label} is invalid")
+    target[name] = cleaned
+
+
 def normalize_rectification_request(body: Any, *, today: date | None = None) -> RectificationRequest:
     if not isinstance(body, dict):
         raise ValueError("request body must be an object")
@@ -77,9 +107,6 @@ def normalize_rectification_request(body: Any, *, today: date | None = None) ->
         raise ValueError("start_time must be HH:MM")
     if not isinstance(end_time, str) or not _CLOCK.fullmatch(end_time):
         raise ValueError("end_time must be HH:MM")
-    if start_time > end_time:
-        raise ValueError("start_time must not exceed end_time")
-
     events = body.get("events")
     if not isinstance(events, list) or not 1 <= len(events) <= 100:
         raise ValueError("events must contain between 1 and 100 items")
@@ -112,7 +139,7 @@ def normalize_rectification_request(body: Any, *, today: date | None = None) ->
         summary = raw_event.get("summary", "")
         if not isinstance(summary, str) or len(summary) > 1_000:
             raise ValueError(f"events[{index}].summary must be a string up to 1000 characters")
-        cleaned_events.append({
+        cleaned_event: dict[str, Any] = {
             "id": event_id,
             "domain": cast(str, domain),
             "event_kind": cast(str, event_kind),
@@ -120,9 +147,14 @@ def normalize_rectification_request(body: Any, *, today: date | None = None) ->
             "date_end": end_day.isoformat(),
             "precision": cast(DatePrecision, precision),
             "summary": summary.strip(),
-        })
+        }
+        _copy_nullable_text(raw_event, cleaned_event, "date_source", f"events[{index}].date_source", 120)
+        _copy_nullable_text(raw_event, cleaned_event, "date_reliability", f"events[{index}].date_reliability", 120)
+        _copy_nullable_text(raw_event, cleaned_event, "date_corroboration", f"events[{index}].date_corroboration", 1_000)
+        _copy_nullable_text(raw_event, cleaned_event, "date_conflict_status", f"events[{index}].date_conflict_status", 120)
+        cleaned_events.append(cast(LifeEvent, cleaned_event))
 
-    return {
+    cleaned_request: dict[str, Any] = {
         "birth_date": birth_day.isoformat(),
         "start_time": start_time,
         "end_time": end_time,
@@ -131,3 +163,8 @@ def normalize_rectification_request(body: Any, *, today: date | None = None) ->
         "tz": _bounded_number(body, "tz", -14, 14),
         "events": cleaned_events,
     }
+    _copy_nullable_text(body, cleaned_request, "birth_time_source", "birth_time_source", 120, _BIRTH_TIME_SOURCES)
+    _copy_nullable_text(body, cleaned_request, "timezone_id", "timezone_id", 120)
+    _copy_nullable_text(body, cleaned_request, "timezone_source", "timezone_source", 80)
+    _copy_nullable_text(body, cleaned_request, "local_time_status", "local_time_status", 120, _LOCAL_TIME_STATUSES)
+    return cast(RectificationRequest, cleaned_request)
diff --git a/scripts/rectification/diagnostics_service.py b/scripts/rectification/diagnostics_service.py
index f80aed88..846a7524 100644
--- a/scripts/rectification/diagnostics_service.py
+++ b/scripts/rectification/diagnostics_service.py
@@ -12,22 +12,28 @@ def _winner(rows: Sequence[CandidateScoreRow]) -> str | None:
     return max(rows, key=lambda row: row["score"])["time"] if rows else None
 
 
+def _minute_value(value: str) -> int:
+    return int(value[:2]) * 60 + int(value[3:])
+
+
 def _primary_cluster(rows: Sequence[CandidateScoreRow], relative_floor: float = .97) -> list[str]:
     if not rows:
         return []
     peak = max(row["score"] for row in rows)
     floor = peak * relative_floor if peak >= 0 else peak / relative_floor
-    selected = [row["time"] for row in rows if row["score"] >= floor]
+    selected = sorted((row["time"] for row in rows if row["score"] >= floor), key=_minute_value)
     if not selected:
         return []
     groups: list[list[str]] = []
     for current in selected:
-        minute = lambda value: int(value[:2]) * 60 + int(value[3:])
-        if groups and minute(current) - minute(groups[-1][-1]) == 1:
+        if groups and (_minute_value(current) - _minute_value(groups[-1][-1])) % 1_440 == 1:
             groups[-1].append(current)
         else:
             groups.append([current])
-    return max(groups, key=lambda group: (max(next(row["score"] for row in rows if row["time"] == time) for time in group), len(group)))
+    if len(groups) > 1 and (_minute_value(groups[0][0]) - _minute_value(groups[-1][-1])) % 1_440 == 1:
+        groups[0] = [*groups.pop(), *groups[0]]
+    scores = {row["time"]: row["score"] for row in rows}
+    return max(groups, key=lambda group: (max(scores[time] for time in group), sum(max(scores[time], 0) for time in group)))
 
 
 def _subtract(rows: Sequence[CandidateScoreRow], removed_ids: set[str]) -> list[CandidateScoreRow]:
diff --git a/scripts/rectification/scoring_service.py b/scripts/rectification/scoring_service.py
index 84a2816f..578d0e15 100644
--- a/scripts/rectification/scoring_service.py
+++ b/scripts/rectification/scoring_service.py
@@ -153,7 +153,7 @@ def calculation_spec(request: RectificationRequest) -> dict[str, Any]:
     def json_number(value: float) -> int | float:
         return int(value) if value.is_integer() else value
 
-    return {
+    spec = {
         "version": INPUT_CONTRACT_VERSION,
         "birthDate": request["birth_date"],
         "candidateRange": {"start": request["start_time"], "end": request["end_time"]},
@@ -162,6 +162,15 @@ def calculation_spec(request: RectificationRequest) -> dict[str, Any]:
         "timezoneOffsetHours": json_number(request["tz"]),
         "ayanamsa": "lahiri", "nodeMode": "mean", "minuteStep": 1,
     }
+    for source, target in (
+        ("birth_time_source", "birthTimeSource"),
+        ("timezone_id", "timezoneId"),
+        ("timezone_source", "timezoneSource"),
+        ("local_time_status", "localTimeStatus"),
+    ):
+        if source in request:
+            spec[target] = request[source]  # type: ignore[literal-required]
+    return spec
 
 
 def sha256(value: Any) -> str:
diff --git a/skills/birth-time-rectification/SKILL.md b/skills/birth-time-rectification/SKILL.md
index fac7ab30..c7c59e3b 100644
--- a/skills/birth-time-rectification/SKILL.md
+++ b/skills/birth-time-rectification/SKILL.md
@@ -14,12 +14,21 @@ Before choosing an action, read the contracts in `references/`. Treat `assets/re
 - Current skill version: `birth-time-rectification-v6`.
 - Current prompt version: `rectification-agent-v6-1`.
 - The scoring algorithm remains `rectification-v5-matrix-scoring-1`; the V6 label describes the conversation contract, not a replacement scoring engine.
-- The server owns event reconciliation, candidate-minute scanning, event contributions, snapshots, diagnostics, stability gates, jobs, replay, persistence, and final decision validation.
+- The server owns event reconciliation, the real Python scan of every minute in the candidate window, the event contribution matrix, Candidate Snapshots, LOEO/LODO, date sensitivity, neighbor stability, candidate split, jobs, replay, persistence, and final decision validation.
 - The agent may select one active server opportunity, call at most one allowed read-only diagnostic, offer an already-gated candidate range, or stop for low confidence.
 - The agent never creates events, dates, scores, candidate minutes, or profile updates.
+- Candidate windows are inclusive. When `start_time > end_time`, the Python scan continues across midnight into the next calendar day; equal endpoints mean one candidate minute, and a window may not exceed 1,440 minutes.
 - The persisted “分析过程” is a server-owned execution receipt, not hidden chain-of-thought. It may list only stages, tools, and techniques that actually ran, plus a provider-explicit reasoning summary after server-side safety filtering.
 - `canConfirmExactMinute` is always `false`. Never write `profiles.active_birth_time` automatically.
 
+## Implementation truth and reference gap
+
+- The current decision path is server-owned: minute scan -> event contribution matrix -> Snapshot -> LOEO/LODO/date sensitivity/neighbor stability/candidate split -> deterministic public gate. The reference skill remains methodology and audit input; it is not a second scoring authority.
+- The public range gate includes LODO and an active-domain technique policy. Missing required or unclassified layers block publication; `KP_cusps` is optional, while D60 is reference-only and cannot score, gate, or support a conclusion.
+- Event source, raw wording, Turn, and revision lineage are provenance for audit only. Provenance never adds or removes points and is not a confidence multiplier.
+- LOEO and LODO are same-Case sensitivity checks, not an independent holdout. Per-Case independent holdout is deferred until a prospective sticky partition and calibration contract exist; never describe it as implemented or validated.
+- Continue to reject manual `supports/conflicts` pseudo-scoring, arbitrary external repository loading, a unique-minute answer, and automatic profile writes.
+
 ## Seventeen conversation boundaries
 
 1. Conduct a natural conversation, never a fixed questionnaire.
@@ -33,7 +42,7 @@ Before choosing an action, read the contracts in `references/`. Treat `assets/re
 9. Do not use empty stock phrases such as “这个信息很有用” or repetitive “已记录” openings.
 10. Do not assign life meaning to an ordinary experience or claim an unconfirmed turning point.
 11. The agent selects a server-generated semantic opportunity; it does not create candidate results or an unrestricted question route.
-12. Show a candidate range only after the deterministic stability gate passes.
+12. Show a candidate range only after the deterministic stability gate, including LODO and required-technique availability, passes.
 13. Never confirm, imply, or display a unique or representative birth minute as the answer.
 14. Stop with an honest low-confidence result when evidence is sparse, conflicting, or unstable; do not prolong the interview indefinitely.
 15. Family events are background/context evidence by default, not the user's own scoreable event.
diff --git a/skills/birth-time-rectification/references/event-schema.md b/skills/birth-time-rectification/references/event-schema.md
index 7cf1f139..9bdbea0c 100644
--- a/skills/birth-time-rectification/references/event-schema.md
+++ b/skills/birth-time-rectification/references/event-schema.md
@@ -2,6 +2,8 @@
 
 Preserve the event's subject, related person, domain, event kind, original user wording, declared date text, normalized date range, precision, extraction status, correction lineage, source Turn, and scoreability.
 
+These source fields are provenance for audit and replay only. Raw wording, source Turn, extraction path, and revision lineage must never add points, change technique weights, or act as a confidence multiplier. Scoring uses only the validated scoreable event contract and the server-owned contribution rules.
+
 ## Subject and scoreability
 
 - A user's own supported event may be `scoreable`.
diff --git a/skills/birth-time-rectification/references/failure-policy.md b/skills/birth-time-rectification/references/failure-policy.md
index 21155376..4bb64a71 100644
--- a/skills/birth-time-rectification/references/failure-policy.md
+++ b/skills/birth-time-rectification/references/failure-policy.md
@@ -14,10 +14,16 @@ Stop with low confidence when evidence is too sparse, conflicting, tied, unstabl
 
 A month-dated event is not a failure. Refine it only when date-sensitivity diagnostics show that finer precision could change candidate ranking.
 
+- LODO retention below `0.8` blocks the public range, as does LOEO below `0.8`.
+- A missing active-domain required layer or an unclassified missing layer blocks publication. Missing optional layers such as `KP_cusps`, or reference-only D60, do not make the calculation fail and must not be presented as completed evidence.
+- LOEO/LODO are same-Case sensitivity checks. Until prospective sticky partitioning and calibration exist, the absence of per-Case independent holdout is a deferred safety boundary, not a passed validation.
+
 ## System failures
 
 Preserve the existing Job and persistence guarantees: claim/lease, idempotency, completed-job replay, and atomic completion. A renderer or extraction failure must not cause partial artifact writes, duplicate completion, profile mutation, or a different replay result.
 
+Do not recover a failed gate by loading an arbitrary external repository, adding provenance-based weight, inventing manual `supports/conflicts` scores, choosing a unique minute, or writing a profile birth time.
+
 Never log raw sensitive answers to ordinary telemetry. Persist user text only in the approved Turn/evidence stores required by the product contract.
 
 
diff --git a/skills/birth-time-rectification/references/output-contract.md b/skills/birth-time-rectification/references/output-contract.md
index fdd87b9d..651f1b1e 100644
--- a/skills/birth-time-rectification/references/output-contract.md
+++ b/skills/birth-time-rectification/references/output-contract.md
@@ -37,7 +37,9 @@ Reject multi-question transitions such as “另外”, “还有”, “同时
 1. it differs materially from the previous Snapshot's primary range; or
 2. it is the first Snapshot to pass the public stability gate.
 
-The no-repeat rule takes precedence: it must be `null` for an unchanged range, insufficient event/domain coverage, an internal unstable Snapshot, or a repeated equivalent calculation. Never state or imply a unique or representative birth minute.
+The no-repeat rule takes precedence: it must be `null` for an unchanged range, insufficient event/domain coverage, LOEO or LODO retention below `0.8`, failed date/neighbor stability, a missing active-domain required or unclassified technique layer, an internal unstable Snapshot, or a repeated equivalent calculation. Missing optional `KP_cusps` and reference-only D60 do not block by themselves. Never state or imply a unique or representative birth minute.
+
+Do not describe LOEO/LODO as an independent holdout, prospective validation, or calibrated accuracy result. Per-Case independent holdout remains deferred until sticky partitioning and calibration exist.
 
 ## Deterministic fallback
 
@@ -57,4 +59,4 @@ The public projection may contain only:
 
 Do not infer missing phases from the final Job phase, and do not label a capability as executed merely because the deployment supports it. If no safe provider summary exists, omit it; never create a substitute or expose hidden chain-of-thought.
 
-The receipt must exclude scores, weights, contribution matrices, internal IDs and field names, candidate minutes, tool arguments or raw results, prompts, model/provider internals, and sensitive user wording. D60 is never displayed. Historical messages without a receipt remain valid, and `v4_legacy`/`v5_shadow` keep their established visible reply semantics.
+The receipt must exclude scores, weights, contribution matrices, internal IDs and field names, candidate minutes, tool arguments or raw results, prompts, model/provider internals, and sensitive user wording. Provenance may support audit linkage only and must never be rendered as added evidence strength. D60 is never displayed. Historical messages without a receipt remain valid, and `v4_legacy`/`v5_shadow` keep their established visible reply semantics.
diff --git a/skills/birth-time-rectification/references/technique-policy.md b/skills/birth-time-rectification/references/technique-policy.md
index 0fdb5910..0a6c9914 100644
--- a/skills/birth-time-rectification/references/technique-policy.md
+++ b/skills/birth-time-rectification/references/technique-policy.md
@@ -1,23 +1,33 @@
 # Technique policy
 
-The conversation refactor does not change the scoring algorithm. Keep `rectification-v5-matrix-scoring-1`, Python candidate-minute scanning, the event contribution matrix, Candidate Snapshots, leave-one-event-out, leave-one-domain-out, date sensitivity, neighbor stability, candidate split, Decision Validator, and deterministic fallback.
+The conversation refactor does not change the scoring algorithm. Keep `rectification-v5-matrix-scoring-1`, the real Python scan of every minute in the inclusive candidate window, the event contribution matrix, Candidate Snapshots, leave-one-event-out (LOEO), leave-one-domain-out (LODO), date sensitivity, neighbor stability, candidate split, Decision Validator, and deterministic fallback. A cross-midnight window continues into the next calendar day; equal endpoints mean one minute and the maximum window is 1,440 minutes.
 
-Only server-reported available layers may be described as used. Missing, blocked, reference-only, and research-only layers are not evidence of a result. Do not import or reproduce the portable ZIP's candidate segmentation, manual `supports/conflicts` scoring, fixed unknown-mode blocks, dynamic repository loading, or `main_repository_enhanced` mode.
+Only server-reported available layers may be described as used. Missing, blocked, reference-only, and research-only layers are not evidence of a result. Do not import or reproduce the portable ZIP's candidate segmentation, manual `supports/conflicts` scoring, fixed unknown-mode blocks, arbitrary/dynamic external repository loading, or `main_repository_enhanced` mode.
+
+## Public technique availability gate
+
+- **Required:** only the layers registered for active scoreable domains. Education requires `D24 + vimshottari + narayana`; relocation `D4 + vimshottari + narayana`; relationship `D9 + UL + vimshottari + narayana`; career `D10 + A10 + vimshottari + narayana`; finance `D2 + D11 + vimshottari + narayana`; self health pressure `D30 + vimshottari + narayana`. A missing required layer blocks the public range.
+- **Optional:** `KP_cusps`, `A7`, `Ashtakavarga`, and `Shadbala`, plus known domain layers that are not required by the active domains. Their absence does not block the public range. In particular, `KP_cusps` is optional.
+- **Reference-only:** D60. It must not contribute points, satisfy a gate, appear as executed in the public receipt, or drive a conclusion.
+- **Unclassified:** fail closed. An unknown missing layer blocks publication until classified server-side.
 
 ## Diagnostic use
 
 - The Reasoner may request at most one allowed read-only diagnostic in a turn.
 - Send only compact conclusions needed for opportunity selection, not the full contribution matrix.
 - Date sensitivity determines whether finer date precision is worth asking for.
-- Leave-one-event/domain-out, neighbor stability, and candidate split diagnose fragility; they do not independently authorize public certainty.
+- LOEO, LODO, neighbor stability, and candidate split diagnose fragility; they do not independently authorize public certainty. The public gate requires LOEO and LODO retention of at least `0.8`.
 - Sparse, conflicting, or unstable diagnostics require a lower-confidence stop or another genuinely discriminating question.
 
+LOEO/LODO reuse the same Case matrix after subtracting one event or domain. They are not prospective or independent holdout validation. Per-Case independent holdout remains deferred because no sticky train/holdout partition or calibrated acceptance threshold exists; do not claim it is complete.
+
 ## Technique boundaries
 
 - Dasha and dated evidence can frame comparison only when present in server results.
 - D9 and D10 may support relationship and career analysis when available.
 - Topic-specific layers such as D4, D24, D2/D11, D7, and D30 remain bounded by server capability.
 - D60 is reference-only and must never drive candidate selection or the public conclusion.
+- Event provenance is audit lineage only. Source Turn, raw wording, extraction path, and revision lineage must not change contribution points, layer weights, or confidence.
 - Never expose private scores, weights, contribution values, internal technique traces, or tool/model names in the user-facing message.
 - No technique result can override `canConfirmExactMinute === false` or authorize an automatic profile birth-time write.
 
diff --git a/tests/test_rectification_diagnostics_clusters.py b/tests/test_rectification_diagnostics_clusters.py
new file mode 100644
index 00000000..223fb87d
--- /dev/null
+++ b/tests/test_rectification_diagnostics_clusters.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import unittest
+
+from scripts.rectification.diagnostics_service import run_diagnostics
+
+
+def row(time: str, score: float) -> dict:
+    return {"time": time, "score": score, "evidence": [], "missing_layers": []}
+
+
+def diagnostics(rows: list[dict]) -> dict:
+    return run_diagnostics({"events": []}, rows, {"date_sensitivity": [], "matrix": {}})
+
+
+class RectificationDiagnosticsClustersTest(unittest.TestCase):
+    def test_primary_cluster_joins_adjacent_minutes_across_midnight(self):
+        result = diagnostics([
+            row("23:59", 100),
+            row("12:00", 98),
+            row("00:00", 99),
+        ])
+
+        self.assertEqual(result["neighbor_support_minutes"], 2)
+        self.assertEqual(result["candidate_splits"][0]["left_cluster"], {
+            "start": "23:59",
+            "end": "00:00",
+        })
+        self.assertEqual(result["candidate_splits"][0]["right_cluster"], {
+            "start": "12:00",
+            "end": "12:00",
+        })
+
+    def test_primary_cluster_keeps_ordinary_daytime_gaps_separate(self):
+        result = diagnostics([
+            row("05:13", 100),
+            row("05:14", 99),
+            row("05:16", 98),
+        ])
+
+        self.assertEqual(result["neighbor_support_minutes"], 2)
+        self.assertEqual(result["candidate_splits"][0]["left_cluster"], {
+            "start": "05:13",
+            "end": "05:14",
+        })
+        self.assertEqual(result["candidate_splits"][0]["right_cluster"], {
+            "start": "05:16",
+            "end": "05:16",
+        })
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_rectification_provenance.py b/tests/test_rectification_provenance.py
new file mode 100644
index 00000000..387da6c9
--- /dev/null
+++ b/tests/test_rectification_provenance.py
@@ -0,0 +1,47 @@
+from datetime import date
+import unittest
+
+from scripts.rectification.contracts import normalize_rectification_request
+from scripts.rectification.scoring_service import build_event_contribution_matrix, calculation_spec, sha256
+
+EVENT_ID = "00000000-0000-4000-8000-000000000002"
+
+def request():
+    return {
+        "birth_date": "1990-01-02", "start_time": "05:00", "end_time": "06:00",
+        "lat": 25.033, "lon": 121.5654, "tz": 8,
+        "events": [{"id": EVENT_ID, "domain": "career", "event_kind": "career_change", "date_start": "2020-01-01", "date_end": "2020-12-31", "precision": "year", "summary": "工作变动"}],
+    }
+
+class RectificationProvenanceTest(unittest.TestCase):
+    def test_missing_and_explicit_null_remain_distinct(self):
+        legacy = normalize_rectification_request(request(), today=date(2026, 7, 30))
+        self.assertNotIn("birth_time_source", legacy)
+        enriched_input = request()
+        enriched_input["birth_time_source"] = None
+        enriched_input["events"][0]["date_source"] = None
+        enriched = normalize_rectification_request(enriched_input, today=date(2026, 7, 30))
+        self.assertIn("birth_time_source", enriched)
+        self.assertIsNone(enriched["birth_time_source"])
+        self.assertIn("date_source", enriched["events"][0])
+
+    def test_enriched_spec_hash_matches_typescript_fixture(self):
+        value = request()
+        value.update({"birth_time_source": "family_exact", "timezone_id": "Asia/Taipei", "timezone_source": "iana_historical", "local_time_status": "resolved"})
+        normalized = normalize_rectification_request(value, today=date(2026, 7, 30))
+        self.assertEqual(sha256(calculation_spec(normalized)), "fa4afe79228bedebd809c7b3c9d9d32a428f7066e3e1fd1813e44b317bd38e66")
+
+    def test_event_provenance_is_not_forwarded_to_scoring_weights(self):
+        value = request()
+        value["events"][0].update({"date_source": "user_reported", "date_reliability": "medium"})
+        normalized = normalize_rectification_request(value, today=date(2026, 7, 30))
+        seen = []
+        def provider(payload):
+            seen.append(payload)
+            return [{"time": "05:00", "score": 1, "evidence": [{"event_id": EVENT_ID, "domain": "career", "candidate_time": "05:00", "rule_ids": ["D10:test"], "points": 1}], "missing_layers": []}]
+        build_event_contribution_matrix(normalized, provider)
+        self.assertTrue(seen)
+        self.assertTrue(all("date_source" not in payload["events"][0] for payload in seen))
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_rectification_v5_services.py b/tests/test_rectification_v5_services.py
index 60364f0e..2ed2bd5f 100644
--- a/tests/test_rectification_v5_services.py
+++ b/tests/test_rectification_v5_services.py
@@ -4,6 +4,7 @@ import unittest
 from datetime import date
 from unittest.mock import patch
 
+from scripts.active_rectification_event_engine import _candidate_datetimes
 from scripts.rectification.api_service import diagnostics, score_candidates
 from scripts.rectification.contracts import normalize_rectification_request
 from scripts.rectification.scoring_service import (
@@ -23,11 +24,18 @@ from scripts.jyotish_api_server import (
 EVENT_ID = "00000000-0000-4000-8000-000000000001"
 
 
-def request(*, precision: str = "month", event_kind: str = "education_milestone", domain: str = "education"):
+def request(
+    *,
+    precision: str = "month",
+    event_kind: str = "education_milestone",
+    domain: str = "education",
+    start_time: str = "05:13",
+    end_time: str = "05:15",
+):
     return {
         "birth_date": "1997-08-08",
-        "start_time": "05:13",
-        "end_time": "05:15",
+        "start_time": start_time,
+        "end_time": end_time,
         "lat": 36.419,
         "lon": 114.213,
         "tz": 8,
@@ -51,6 +59,52 @@ class RectificationV5ServicesTest(unittest.TestCase):
             "f05fe0f56ef9ba2b18ec3c6c54f1649f06f1ae5a926491a5c5f676d718d92865",
         )
 
+    def test_cross_midnight_range_preserves_next_day_datetimes_and_typescript_hash(self):
+        normalized = normalize_rectification_request(
+            request(start_time="23:00", end_time="03:59"),
+            today=date(2026, 7, 28),
+        )
+
+        candidates = _candidate_datetimes(normalized)
+
+        self.assertEqual(len(candidates), 300)
+        self.assertEqual(candidates[0].isoformat(), "1997-08-08T23:00:00")
+        self.assertEqual(candidates[60].isoformat(), "1997-08-09T00:00:00")
+        self.assertEqual(candidates[-1].isoformat(), "1997-08-09T03:59:00")
+        self.assertEqual(
+            sha256(calculation_spec(normalized)),
+            "b0d5c5ec7f56edbfa2b2e1041b4aa3b648c6cb0681f3f502c7b7910c2894b205",
+        )
+
+    def test_candidate_range_boundaries_stay_bounded_and_equal_is_one_minute(self):
+        full_day = normalize_rectification_request(
+            request(start_time="00:00", end_time="23:59"),
+            today=date(2026, 7, 28),
+        )
+        equal = normalize_rectification_request(
+            request(start_time="05:13", end_time="05:13"),
+            today=date(2026, 7, 28),
+        )
+
+        self.assertEqual(len(_candidate_datetimes(full_day)), 1_440)
+        self.assertEqual(len(_candidate_datetimes(equal)), 1)
+        with self.assertRaisesRegex(ValueError, "end_time must be HH:MM"):
+            normalize_rectification_request(
+                request(start_time="00:00", end_time="24:00"),
+                today=date(2026, 7, 28),
+            )
+
+    def test_daytime_candidate_range_remains_on_birth_date(self):
+        normalized = normalize_rectification_request(request(), today=date(2026, 7, 28))
+
+        candidates = _candidate_datetimes(normalized)
+
+        self.assertEqual([value.isoformat() for value in candidates], [
+            "1997-08-08T05:13:00",
+            "1997-08-08T05:14:00",
+            "1997-08-08T05:15:00",
+        ])
+
     def test_shared_validator_rejects_family_and_non_self_health_scoring(self):
         with self.assertRaisesRegex(ValueError, "domain is not scoreable"):
             normalize_rectification_request(request(domain="family", event_kind="family_bereavement"), today=date(2026, 7, 28))

From 31e5709f33cb6cf4f52ecb56c40bdc3c9116cb26 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Thu, 30 Jul 2026 11:48:02 +0800
Subject: [PATCH 13/15] feat: add VedAstro rectification post-validation

---
 .../src/lib/rectification-agent/contracts.ts  |  33 +++
 .../lib/rectification-agent/orchestrator.ts   |  77 +++++
 .../lib/rectification-v4/candidate-engine.ts  | 120 ++++++--
 .../rectification-analysis-trace.test.ts      |  96 ++++++-
 .../tests/rectification-provenance.test.ts    |  47 ++++
 .../tests/rectification-v4-replay.test.ts     |   5 +-
 .../tests/rectification-v5-test-support.ts    |  28 ++
 scripts/jyotish_api_server.py                 | 193 ++++++++++++-
 skills/birth-time-rectification/SKILL.md      |   2 +
 .../references/failure-policy.md              |   5 +-
 .../references/output-contract.md             |   4 +-
 .../references/technique-policy.md            |   7 +
 ...st_rectification_v5_vedastro_validation.py | 263 ++++++++++++++++++
 13 files changed, 856 insertions(+), 24 deletions(-)
 create mode 100644 tests/test_rectification_v5_vedastro_validation.py

diff --git a/frontend/src/lib/rectification-agent/contracts.ts b/frontend/src/lib/rectification-agent/contracts.ts
index 26f13300..569a390c 100644
--- a/frontend/src/lib/rectification-agent/contracts.ts
+++ b/frontend/src/lib/rectification-agent/contracts.ts
@@ -188,6 +188,38 @@ export const candidateSplitSchema = z.object({
   eventIds: z.array(uuid).max(100),
 }).strict();
 
+export const vedAstroCandidateMetricSchema = z.object({
+  role: z.enum(["primary", "runner_up"]),
+  requestedEventCount: z.number().int().nonnegative().max(20),
+  successfulEventCount: z.number().int().nonnegative().max(20),
+  matchedEventCount: z.number().int().nonnegative().max(20),
+  eventHitCount: z.number().int().nonnegative(),
+  signalLift: z.number().finite(),
+}).strict();
+
+export const vedAstroPostValidationSchema = z.object({
+  contractVersion: z.literal("vedastro-post-validation-v1"),
+  provider: z.literal("vedastro_official"),
+  status: z.enum(["pass", "blocked", "not_validated"]),
+  providerStatus: nonblank(80),
+  blockers: z.array(nonblank(120)).max(20),
+  primaryCandidateTime: clockTimeSchema.nullable(),
+  runnerUpCandidateTime: clockTimeSchema.nullable(),
+  eligibleEventCount: z.number().int().nonnegative().max(100),
+  selectedEventCount: z.number().int().nonnegative().max(20),
+  unsupportedEventCount: z.number().int().nonnegative().max(100),
+  candidateMetrics: z.array(vedAstroCandidateMetricSchema).max(2),
+  minuteSensitiveValidation: z.object({
+    comparisonReady: z.boolean(),
+    discriminated: z.boolean(),
+    discriminatedLayers: z.array(nonblank(80)).max(10),
+  }).strict(),
+  validationHash: hash,
+  validatedAt: z.string().datetime({ offset: true }),
+  canConfirmExactMinute: z.literal(false),
+}).strict();
+export type VedAstroPostValidation = z.infer<typeof vedAstroPostValidationSchema>;
+
 export const diagnosticsSummarySchema = z.object({
   id: uuid,
   caseId: uuid,
@@ -203,6 +235,7 @@ export const diagnosticsSummarySchema = z.object({
   mostDiscriminatingLayers: z.array(nonblank(80)).max(40),
   eventDateSensitivity: z.array(eventDateSensitivitySchema).max(100),
   candidateSplits: z.array(candidateSplitSchema).max(20),
+  externalValidation: vedAstroPostValidationSchema.optional(),
   calculationHash: hash,
   createdAt: z.string().datetime({ offset: true }),
 }).strict();
diff --git a/frontend/src/lib/rectification-agent/orchestrator.ts b/frontend/src/lib/rectification-agent/orchestrator.ts
index aafbdea7..13073858 100644
--- a/frontend/src/lib/rectification-agent/orchestrator.ts
+++ b/frontend/src/lib/rectification-agent/orchestrator.ts
@@ -17,18 +17,51 @@ import { recordRectificationAgentTelemetry } from "./telemetry.ts";
 import {
   candidateFeatureSnapshotSchema,
   diagnosticsSummarySchema,
+  vedAstroPostValidationSchema,
   validateRectificationDecision,
   type AgentRun,
   type CandidateFeatureSnapshot,
   type DiagnosticsSummary,
   type StoredPublicMessage,
   type ValidatedDecision,
+  type VedAstroPostValidation,
 } from "./contracts.ts";
 
 function hash(value: unknown): string {
   return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
 
+function vedAstroCandidateTimes(snapshot: CandidateSnapshot): readonly [string, string] | null {
+  const primary = snapshot.clusters[0]?.representativeTime;
+  if (!primary) return null;
+  const runnerUp = snapshot.clusters[1]?.representativeTime
+    ?? [...snapshot.candidates].sort((left, right) => right.score - left.score).find((candidate) => candidate.time !== primary)?.time;
+  return runnerUp && runnerUp !== primary ? [primary, runnerUp] : null;
+}
+
+function blockedVedAstroValidation(now: Date, blocker: string, candidateTimes: readonly [string, string] | null): VedAstroPostValidation {
+  const safe = {
+    contractVersion: "vedastro-post-validation-v1" as const,
+    provider: "vedastro_official" as const,
+    status: "blocked" as const,
+    providerStatus: "unavailable",
+    blockers: [blocker],
+    primaryCandidateTime: candidateTimes?.[0] ?? null,
+    runnerUpCandidateTime: candidateTimes?.[1] ?? null,
+    eligibleEventCount: 0,
+    selectedEventCount: 0,
+    unsupportedEventCount: 0,
+    candidateMetrics: [],
+    minuteSensitiveValidation: { comparisonReady: false, discriminated: false, discriminatedLayers: [] },
+    canConfirmExactMinute: false as const,
+  };
+  return vedAstroPostValidationSchema.parse({
+    ...safe,
+    validationHash: hash(safe),
+    validatedAt: now.toISOString(),
+  });
+}
+
 const analysisPhaseLabels = {
   extracting_evidence: "整理用户经历",
   scoring_candidates: "扫描候选分钟",
@@ -240,6 +273,50 @@ export async function processRectificationAgentTurn(input: Readonly<{
     });
   }
 
+  if (snapshot?.canAcceptRange && diagnostics && claimed.case.deploymentMode === "v5_agent") {
+    const candidateTimes = vedAstroCandidateTimes(snapshot);
+    const validationStarted = Date.now();
+    let externalValidation: VedAstroPostValidation;
+    let outcome: "succeeded" | "failed" | "rejected";
+    if (!candidateTimes) {
+      externalValidation = blockedVedAstroValidation(now, "vedastro_runner_up_candidate_missing", null);
+      outcome = "rejected";
+    } else if (!input.engine.validateWithVedAstro) {
+      externalValidation = blockedVedAstroValidation(now, "vedastro_validator_unavailable", candidateTimes);
+      outcome = "failed";
+    } else {
+      try {
+        externalValidation = await input.engine.validateWithVedAstro({
+          calculationSpec: claimed.case.calculationSpec,
+          events: scoreable,
+          candidateTimes,
+        });
+        outcome = externalValidation.status === "pass" ? "succeeded" : "rejected";
+      } catch {
+        externalValidation = blockedVedAstroValidation(now, "vedastro_validation_failed", candidateTimes);
+        outcome = "failed";
+      }
+    }
+    diagnostics = diagnosticsSummarySchema.parse({ ...diagnostics, externalValidation });
+    analysisToolCalls.push({
+      category: "diagnostic",
+      label: "VedAstro 事后校验",
+      outcome,
+      durationMs: Date.now() - validationStarted,
+    });
+    if (externalValidation.status !== "pass") {
+      snapshot = {
+        ...snapshot,
+        canAcceptRange: false,
+        gateReasons: [...new Set([
+          ...snapshot.gateReasons,
+          "vedastro_validation_not_passed",
+          ...externalValidation.blockers,
+        ])].slice(0, 20),
+      };
+    }
+  }
+
   const safeDiagnostics = diagnostics ?? diagnosticsSummarySchema.parse({
     id: randomUUID(),
     caseId: claimed.case.id,
diff --git a/frontend/src/lib/rectification-v4/candidate-engine.ts b/frontend/src/lib/rectification-v4/candidate-engine.ts
index a4c3dd39..2f04deaf 100644
--- a/frontend/src/lib/rectification-v4/candidate-engine.ts
+++ b/frontend/src/lib/rectification-v4/candidate-engine.ts
@@ -1,6 +1,8 @@
+import { createHash } from "node:crypto";
 import { z } from "zod";
 import type { CalculationSpec, CandidateMinute, LifeEventRevision } from "./contracts.ts";
 import { rectificationV4AlgorithmVersion } from "./contracts.ts";
+import { vedAstroPostValidationSchema, type VedAstroPostValidation } from "../rectification-agent/contracts.ts";
 
 const uuid = z.string().uuid();
 const hash = z.string().regex(/^[a-f0-9]{64}$/);
@@ -45,6 +47,34 @@ const featureSchema = z.object({
     fingerprints: z.record(z.string(), z.string()),
   }).passthrough()),
 }).passthrough();
+const vedAstroResponseSchema = z.object({
+  status: z.enum(["pass", "fail"]),
+  passed: z.boolean(),
+  can_confirm_exact_minute: z.literal(false),
+  candidate_times: z.object({ primary: z.string(), runner_up: z.string() }).strict(),
+  blockers: z.array(z.string()),
+  minute_sensitive_validation: z.object({
+    comparison_ready: z.boolean(),
+    discriminated: z.boolean(),
+    discriminated_layers: z.array(z.string()),
+  }).passthrough(),
+  event_validation: z.object({
+    eligible_event_count: z.number().int().nonnegative(),
+    supported_event_count: z.number().int().nonnegative(),
+    unsupported_events: z.array(z.unknown()),
+    candidates: z.array(z.object({
+      role: z.enum(["primary", "runner_up"]),
+      metric: z.object({
+        requested_event_count: z.number().int().nonnegative(),
+        successful_event_count: z.number().int().nonnegative(),
+        matched_event_count: z.number().int().nonnegative(),
+        event_hit_count: z.number().int().nonnegative(),
+        signal_lift: z.number().finite(),
+      }).strict(),
+    }).passthrough()).max(2),
+  }).passthrough(),
+}).passthrough();
+
 const responseSchema = z.object({
   result_id: uuid,
   algorithm_version: z.literal(rectificationV4AlgorithmVersion),
@@ -79,8 +109,71 @@ export type CandidateEngineResult = Readonly<{
   missingLayers: readonly string[];
 }>;
 
+function rectificationRequestBody(calculationSpec: CalculationSpec, events: readonly LifeEventRevision[]) {
+  return {
+    birth_date: calculationSpec.birthDate,
+    start_time: calculationSpec.candidateRange.start,
+    end_time: calculationSpec.candidateRange.end,
+    lat: calculationSpec.latitude,
+    lon: calculationSpec.longitude,
+    tz: calculationSpec.timezoneOffsetHours,
+    ...(Object.hasOwn(calculationSpec, "birthTimeSource") ? { birth_time_source: calculationSpec.birthTimeSource } : {}),
+    ...(Object.hasOwn(calculationSpec, "timezoneId") ? { timezone_id: calculationSpec.timezoneId } : {}),
+    ...(Object.hasOwn(calculationSpec, "timezoneSource") ? { timezone_source: calculationSpec.timezoneSource } : {}),
+    ...(Object.hasOwn(calculationSpec, "localTimeStatus") ? { local_time_status: calculationSpec.localTimeStatus } : {}),
+    events: events.map((event) => ({
+      id: event.eventId,
+      domain: event.domain,
+      event_kind: event.eventKind,
+      date_start: event.dateRange.start,
+      date_end: event.dateRange.end,
+      precision: event.dateRange.precision,
+      summary: event.summary,
+      ...(Object.hasOwn(event, "dateSource") ? { date_source: event.dateSource } : {}),
+      ...(Object.hasOwn(event, "dateReliability") ? { date_reliability: event.dateReliability } : {}),
+      ...(Object.hasOwn(event, "dateCorroboration") ? { date_corroboration: event.dateCorroboration } : {}),
+      ...(Object.hasOwn(event, "dateConflictStatus") ? { date_conflict_status: event.dateConflictStatus } : {}),
+    })),
+  };
+}
+
+function projectVedAstroValidation(payload: z.infer<typeof vedAstroResponseSchema>): VedAstroPostValidation {
+  const safe = {
+    contractVersion: "vedastro-post-validation-v1" as const,
+    provider: "vedastro_official" as const,
+    status: payload.passed && payload.status === "pass" ? "pass" as const : "blocked" as const,
+    providerStatus: payload.status,
+    blockers: payload.blockers,
+    primaryCandidateTime: payload.candidate_times.primary,
+    runnerUpCandidateTime: payload.candidate_times.runner_up,
+    eligibleEventCount: payload.event_validation.eligible_event_count,
+    selectedEventCount: payload.event_validation.supported_event_count,
+    unsupportedEventCount: payload.event_validation.unsupported_events.length,
+    candidateMetrics: payload.event_validation.candidates.map((candidate) => ({
+      role: candidate.role,
+      requestedEventCount: candidate.metric.requested_event_count,
+      successfulEventCount: candidate.metric.successful_event_count,
+      matchedEventCount: candidate.metric.matched_event_count,
+      eventHitCount: candidate.metric.event_hit_count,
+      signalLift: candidate.metric.signal_lift,
+    })),
+    minuteSensitiveValidation: {
+      comparisonReady: payload.minute_sensitive_validation.comparison_ready,
+      discriminated: payload.minute_sensitive_validation.discriminated,
+      discriminatedLayers: payload.minute_sensitive_validation.discriminated_layers,
+    },
+    canConfirmExactMinute: false as const,
+  };
+  return vedAstroPostValidationSchema.parse({
+    ...safe,
+    validationHash: createHash("sha256").update(JSON.stringify(safe)).digest("hex"),
+    validatedAt: new Date().toISOString(),
+  });
+}
+
 export interface RectificationV4CandidateEngine {
   score(input: { readonly calculationSpec: CalculationSpec; readonly events: readonly LifeEventRevision[] }): Promise<CandidateEngineResult>;
+  validateWithVedAstro?(input: { readonly calculationSpec: CalculationSpec; readonly events: readonly LifeEventRevision[]; readonly candidateTimes: readonly [string, string] }): Promise<VedAstroPostValidation>;
 }
 
 export function createRectificationV4CandidateEngine(options: { readonly apiBase: string; readonly fetchImpl?: typeof fetch }): RectificationV4CandidateEngine {
@@ -88,22 +181,7 @@ export function createRectificationV4CandidateEngine(options: { readonly apiBase
   return { async score({ calculationSpec, events }) {
     const response = await fetchImpl(`${options.apiBase}/api/rectification/v5/score`, {
       method: "POST", headers: { "content-type": "application/json" }, signal: AbortSignal.timeout(5 * 60_000),
-      body: JSON.stringify({
-        birth_date: calculationSpec.birthDate, start_time: calculationSpec.candidateRange.start, end_time: calculationSpec.candidateRange.end,
-        lat: calculationSpec.latitude, lon: calculationSpec.longitude, tz: calculationSpec.timezoneOffsetHours,
-        ...(Object.hasOwn(calculationSpec, "birthTimeSource") ? { birth_time_source: calculationSpec.birthTimeSource } : {}),
-        ...(Object.hasOwn(calculationSpec, "timezoneId") ? { timezone_id: calculationSpec.timezoneId } : {}),
-        ...(Object.hasOwn(calculationSpec, "timezoneSource") ? { timezone_source: calculationSpec.timezoneSource } : {}),
-        ...(Object.hasOwn(calculationSpec, "localTimeStatus") ? { local_time_status: calculationSpec.localTimeStatus } : {}),
-        events: events.map((event) => ({
-          id: event.eventId, domain: event.domain, event_kind: event.eventKind,
-          date_start: event.dateRange.start, date_end: event.dateRange.end, precision: event.dateRange.precision, summary: event.summary,
-          ...(Object.hasOwn(event, "dateSource") ? { date_source: event.dateSource } : {}),
-          ...(Object.hasOwn(event, "dateReliability") ? { date_reliability: event.dateReliability } : {}),
-          ...(Object.hasOwn(event, "dateCorroboration") ? { date_corroboration: event.dateCorroboration } : {}),
-          ...(Object.hasOwn(event, "dateConflictStatus") ? { date_conflict_status: event.dateConflictStatus } : {}),
-        })),
-      }),
+      body: JSON.stringify(rectificationRequestBody(calculationSpec, events)),
     });
     const payload: unknown = await response.json();
     if (!response.ok) throw new Error(`rectification_v5_engine_${response.status}`);
@@ -123,5 +201,15 @@ export function createRectificationV4CandidateEngine(options: { readonly apiBase
       contributionMatrix: parsed.event_contribution_matrix,
       missingLayers: parsed.missing_layers,
     };
+  }, async validateWithVedAstro({ calculationSpec, events, candidateTimes }) {
+    const response = await fetchImpl(`${options.apiBase}/api/rectification/v5/vedastro-validate`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      signal: AbortSignal.timeout(90_000),
+      body: JSON.stringify({ ...rectificationRequestBody(calculationSpec, events), candidate_times: candidateTimes }),
+    });
+    const payload: unknown = await response.json();
+    if (!response.ok) throw new Error(`rectification_v5_vedastro_${response.status}`);
+    return projectVedAstroValidation(vedAstroResponseSchema.parse(payload));
   }};
 }
diff --git a/frontend/tests/rectification-analysis-trace.test.ts b/frontend/tests/rectification-analysis-trace.test.ts
index 3fe839a5..7cf53024 100644
--- a/frontend/tests/rectification-analysis-trace.test.ts
+++ b/frontend/tests/rectification-analysis-trace.test.ts
@@ -14,6 +14,7 @@ import { createRectificationV4CaseService } from "../src/lib/rectification-v4/ca
 import type { CandidateEngineResult } from "../src/lib/rectification-v4/candidate-engine.ts";
 import type {
   CalculationSpec,
+  CandidateMinute,
   LifeEventRevision,
   RectificationAnalysisTrace,
   RectificationV4Case,
@@ -24,9 +25,19 @@ import { createRectificationV4MemoryStore } from "../src/lib/rectification-v4/me
 import { projectAnalysisMessages } from "../src/lib/rectification-v4/supabase-store.ts";
 import type { ClaimedRectificationV4Job } from "../src/lib/rectification-v4/store.ts";
 import { createRectificationV4Worker } from "../src/lib/rectification-v4/worker.ts";
-import { v5EngineResult, withV5Mode } from "./rectification-v5-test-support.ts";
+import { passingVedAstroValidation, v5EngineResult, withV5Mode } from "./rectification-v5-test-support.ts";
 
 const now = "2026-07-29T00:00:00.000Z";
+const rangeReadyCandidates: CandidateMinute[] = [
+  { time: "05:13", score: 100, supportingEventIds: [], conflictingEventIds: [] },
+  { time: "05:14", score: 99, supportingEventIds: [], conflictingEventIds: [] },
+  { time: "05:15", score: 98, supportingEventIds: [], conflictingEventIds: [] },
+  { time: "05:16", score: 60, supportingEventIds: [], conflictingEventIds: [] },
+  { time: "05:17", score: 97.8, supportingEventIds: [], conflictingEventIds: [] },
+  { time: "05:18", score: 97.7, supportingEventIds: [], conflictingEventIds: [] },
+  { time: "05:19", score: 97.6, supportingEventIds: [], conflictingEventIds: [] },
+];
+
 const spec: CalculationSpec = {
   version: "rectification-calculation-spec-v4",
   birthDate: "1997-08-08",
@@ -258,7 +269,7 @@ test("scoring trace records one real engine call and only matrix-confirmed techn
     engine: {
       score: async ({ calculationSpec, events }) => {
         scoreCalls += 1;
-        const base = v5EngineResult(calculationSpec, events);
+        const base = v5EngineResult(calculationSpec, events, rangeReadyCandidates);
         const contributionMatrix: CandidateEngineResult["contributionMatrix"] = Object.fromEntries(
           Object.entries(base.contributionMatrix).map(([eventId, candidates]) => [
             eventId,
@@ -289,6 +300,87 @@ test("scoring trace records one real engine call and only matrix-confirmed techn
   assert.deepEqual(analysisToolLabels(trace, "agent_diagnostic"), []);
 });
 
+test("VedAstro post-validation runs only after the local range gate and blocks publication on safe failure", async () => {
+  const claimed = makeClaimed([
+    event("education", "education_milestone", "离家去外地上大学", "2016-09"),
+    event("relocation", "relocation", "搬到北京长期居住", "2018-08"),
+    event("career", "career_change", "开始负责商业巡演公司", "2023-09"),
+    event("relationship", "relationship_start", "开始一段长期关系", "2021-05"),
+    event("finance", "finance_change", "收入结构发生明显变化", "2024-02"),
+  ]);
+  let validationCalls = 0;
+  const blocked = await processRectificationAgentTurn({
+    claimed,
+    engine: {
+      score: async ({ calculationSpec, events }) => v5EngineResult(calculationSpec, events, rangeReadyCandidates),
+      validateWithVedAstro: async ({ candidateTimes }) => {
+        validationCalls += 1;
+        assert.deepEqual(candidateTimes, ["05:13", "05:14"]);
+        return passingVedAstroValidation(candidateTimes, {
+          status: "blocked",
+          providerStatus: "timeout",
+          blockers: ["vedastro_timeout"],
+          minuteSensitiveValidation: { comparisonReady: false, discriminated: false, discriminatedLayers: [] },
+        });
+      },
+    },
+    now: new Date(now),
+  });
+  assert.equal(validationCalls, 1);
+  assert.equal(blocked.snapshot?.canAcceptRange, false);
+  assert.equal(blocked.snapshot?.canConfirmExactMinute, false);
+  assert.ok(blocked.snapshot?.gateReasons.includes("vedastro_validation_not_passed"));
+  assert.equal(blocked.diagnostics?.externalValidation?.status, "blocked");
+  assert.deepEqual(analysisToolLabels(blocked.publicMessage.analysisTrace!, "diagnostic"), ["VedAstro 事后校验"]);
+
+  validationCalls = 0;
+  const localGateBlocked = await processRectificationAgentTurn({
+    claimed,
+    engine: {
+      score: async ({ calculationSpec, events }) => {
+        const result = v5EngineResult(calculationSpec, events, rangeReadyCandidates);
+        return { ...result, robustness: { ...result.robustness, leaveOneDomainOutRetentionRate: 0 } };
+      },
+      validateWithVedAstro: async ({ candidateTimes }) => {
+        validationCalls += 1;
+        return passingVedAstroValidation(candidateTimes);
+      },
+    },
+    now: new Date(now),
+  });
+  assert.equal(validationCalls, 0);
+  assert.equal(localGateBlocked.snapshot?.canAcceptRange, false);
+  assert.equal(localGateBlocked.diagnostics?.externalValidation, undefined);
+});
+
+test("legacy and shadow modes never call VedAstro post-validation", async () => {
+  const events = [
+    event("education", "education_milestone", "离家去外地上大学", "2016-09"),
+    event("relocation", "relocation", "搬到北京长期居住", "2018-08"),
+    event("career", "career_change", "开始负责商业巡演公司", "2023-09"),
+    event("relationship", "relationship_start", "开始一段长期关系", "2021-05"),
+    event("finance", "finance_change", "收入结构发生明显变化", "2024-02"),
+  ];
+  for (const deploymentMode of ["v4_legacy", "v5_shadow"] as const) {
+    const base = makeClaimed(events);
+    let validationCalls = 0;
+    const result = await processRectificationAgentTurn({
+      claimed: { ...base, case: { ...base.case, deploymentMode } },
+      engine: {
+        score: async ({ calculationSpec, events: scoreEvents }) => v5EngineResult(calculationSpec, scoreEvents),
+        validateWithVedAstro: async ({ candidateTimes }) => {
+          validationCalls += 1;
+          return passingVedAstroValidation(candidateTimes);
+        },
+      },
+      now: new Date(now),
+    });
+    assert.equal(validationCalls, 0, deploymentMode);
+    assert.equal(result.diagnostics?.externalValidation, undefined, deploymentMode);
+    assert.equal(result.snapshot?.canConfirmExactMinute, false, deploymentMode);
+  }
+});
+
 test("read-only Agent diagnostics are traced only when the reasoner actually requests one", async () => {
   const caseValue = makeClaimed([]).case;
   const direct = await runBoundedReasoner({
diff --git a/frontend/tests/rectification-provenance.test.ts b/frontend/tests/rectification-provenance.test.ts
index 6ce643f7..3bb8580d 100644
--- a/frontend/tests/rectification-provenance.test.ts
+++ b/frontend/tests/rectification-provenance.test.ts
@@ -87,3 +87,50 @@ test("candidate engine forwards present provenance without inventing missing fie
   assert.equal(event.date_reliability, null);
   assert.equal(Object.hasOwn(event, "date_corroboration"), false);
 });
+
+test("candidate engine sends only the selected pair and persists a safe VedAstro projection", async () => {
+  let body: Record<string, unknown> | null = null;
+  const engine = createRectificationV4CandidateEngine({
+    apiBase: "http://example.test",
+    fetchImpl: async (input, init) => {
+      assert.equal(String(input), "http://example.test/api/rectification/v5/vedastro-validate");
+      body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+      return new Response(JSON.stringify({
+        status: "pass",
+        passed: true,
+        can_confirm_exact_minute: false,
+        candidate_times: { primary: "05:13", runner_up: "05:14" },
+        blockers: [],
+        minute_sensitive_validation: {
+          comparison_ready: true,
+          discriminated: true,
+          discriminated_layers: ["D9"],
+          raw_response: { secret: true },
+        },
+        event_validation: {
+          eligible_event_count: 1,
+          supported_event_count: 1,
+          unsupported_events: [{ event_id: "private", summary: "must not persist" }],
+          candidates: [
+            { role: "primary", metric: { requested_event_count: 1, successful_event_count: 1, matched_event_count: 1, event_hit_count: 2, signal_lift: 3 }, events: [{ raw_response: "secret" }] },
+            { role: "runner_up", metric: { requested_event_count: 1, successful_event_count: 1, matched_event_count: 1, event_hit_count: 1, signal_lift: 1 } },
+          ],
+        },
+        raw_request: { api_key: "secret" },
+      }), { status: 200, headers: { "content-type": "application/json" } });
+    },
+  });
+  assert.ok(engine.validateWithVedAstro);
+  const validation = await engine.validateWithVedAstro({
+    calculationSpec: legacySpec,
+    events: [baseEvent],
+    candidateTimes: ["05:13", "05:14"],
+  });
+  const captured = body as unknown as Record<string, unknown>;
+  assert.deepEqual(captured.candidate_times, ["05:13", "05:14"]);
+  assert.equal(validation.status, "pass");
+  assert.equal(validation.canConfirmExactMinute, false);
+  assert.deepEqual(validation.minuteSensitiveValidation.discriminatedLayers, ["D9"]);
+  const serialized = JSON.stringify(validation);
+  assert.doesNotMatch(serialized, /raw_request|raw_response|api_key|must not persist|secret/);
+});
diff --git a/frontend/tests/rectification-v4-replay.test.ts b/frontend/tests/rectification-v4-replay.test.ts
index f7fdcebe..9ee496be 100644
--- a/frontend/tests/rectification-v4-replay.test.ts
+++ b/frontend/tests/rectification-v4-replay.test.ts
@@ -6,7 +6,7 @@ import { createRectificationV4CaseService } from "../src/lib/rectification-v4/ca
 import type { CalculationSpec, CandidateMinute } from "../src/lib/rectification-v4/contracts.ts";
 import { createRectificationV4MemoryStore } from "../src/lib/rectification-v4/memory-store.ts";
 import { createRectificationV4Worker } from "../src/lib/rectification-v4/worker.ts";
-import { v5EngineResult, withV5Mode } from "./rectification-v5-test-support.ts";
+import { passingVedAstroValidation, v5EngineResult, withV5Mode } from "./rectification-v5-test-support.ts";
 
 const now = () => new Date("2026-07-26T08:00:00.000Z");
 const spec: CalculationSpec = {
@@ -62,6 +62,9 @@ test("V5 golden replay persists the full artifact chain, returns ranges only, an
           conflictingEventIds: candidate.score < 97 ? ids : [],
         })));
       },
+      async validateWithVedAstro({ candidateTimes }) {
+        return passingVedAstroValidation(candidateTimes);
+      },
     },
   });
   const userId = randomUUID();
diff --git a/frontend/tests/rectification-v5-test-support.ts b/frontend/tests/rectification-v5-test-support.ts
index 841548a3..411d67cf 100644
--- a/frontend/tests/rectification-v5-test-support.ts
+++ b/frontend/tests/rectification-v5-test-support.ts
@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { CandidateEngineResult } from "../src/lib/rectification-v4/candidate-engine.ts";
+import { vedAstroPostValidationSchema, type VedAstroPostValidation } from "../src/lib/rectification-agent/contracts.ts";
 import type { CalculationSpec, CandidateMinute, LifeEventRevision } from "../src/lib/rectification-v4/contracts.ts";
 import { rectificationV4AlgorithmVersion } from "../src/lib/rectification-v4/contracts.ts";
 import { calculationSpecHash } from "../src/lib/rectification-v4/fingerprints.ts";
@@ -72,6 +73,33 @@ export function v5EngineResult(
   };
 }
 
+export function passingVedAstroValidation(
+  candidateTimes: readonly [string, string],
+  overrides: Partial<VedAstroPostValidation> = {},
+): VedAstroPostValidation {
+  return vedAstroPostValidationSchema.parse({
+    contractVersion: "vedastro-post-validation-v1",
+    provider: "vedastro_official",
+    status: "pass",
+    providerStatus: "pass",
+    blockers: [],
+    primaryCandidateTime: candidateTimes[0],
+    runnerUpCandidateTime: candidateTimes[1],
+    eligibleEventCount: 5,
+    selectedEventCount: 3,
+    unsupportedEventCount: 0,
+    candidateMetrics: [
+      { role: "primary", requestedEventCount: 3, successfulEventCount: 3, matchedEventCount: 3, eventHitCount: 5, signalLift: 4 },
+      { role: "runner_up", requestedEventCount: 3, successfulEventCount: 3, matchedEventCount: 2, eventHitCount: 3, signalLift: 2 },
+    ],
+    minuteSensitiveValidation: { comparisonReady: true, discriminated: true, discriminatedLayers: ["D9"] },
+    validationHash: "a".repeat(64),
+    validatedAt: "2026-07-30T00:00:00.000Z",
+    canConfirmExactMinute: false,
+    ...overrides,
+  });
+}
+
 export async function withV5Mode<T>(mode: "v4_legacy" | "v5_shadow" | "v5_agent", run: () => Promise<T>): Promise<T> {
   const keys = ["RECTIFICATION_AGENT_V5_ENABLED", "RECTIFICATION_AGENT_V5_SHADOW", "RECTIFICATION_AGENT_V5_CANARY_PERCENT"] as const;
   const before = Object.fromEntries(keys.map((key) => [key, process.env[key]]));
diff --git a/scripts/jyotish_api_server.py b/scripts/jyotish_api_server.py
index 68d1c2d7..8b85e45c 100644
--- a/scripts/jyotish_api_server.py
+++ b/scripts/jyotish_api_server.py
@@ -148,6 +148,8 @@ _VEDASTRO_RECTIFICATION_DOMAIN_MAP = {
 
 
 def _rectification_event_date_range(event):
+    if event.get('date_start') and event.get('date_end'):
+        return str(event['date_start']), str(event['date_end'])
     value = str(event.get('date') or '')
     precision = str(event.get('precision') or '')
     if precision == 'day':
@@ -173,7 +175,7 @@ def _rectification_event_representative_date(start_date, end_date):
 
 
 def _select_vedastro_rectification_events(events):
-    precision_rank = {'year': 1, 'month': 2, 'day': 3}
+    precision_rank = {'range': 1, 'year': 2, 'quarter': 3, 'month': 4, 'day': 5}
     selected_by_domain = {}
     eligible_event_count = 0
     unsupported_events = []
@@ -294,6 +296,23 @@ def _safe_vedastro_minute_snapshot_summary(candidate_time, report):
     }
 
 
+def _vedastro_minute_snapshot_is_complete(report, summary):
+    if (
+        not isinstance(report, dict)
+        or report.get('source') != 'vedastro_official'
+        or summary.get('status') != 'ok'
+        or not summary.get('available')
+    ):
+        return False
+    layers = summary.get('layers') if isinstance(summary.get('layers'), dict) else {}
+    return all(
+        isinstance(layers.get(name), dict)
+        and layers[name].get('status') == 'ok'
+        and bool(layers[name].get('fingerprint'))
+        for name in _VEDASTRO_MINUTE_SENSITIVE_LAYERS
+    )
+
+
 def _compare_vedastro_minute_snapshots(candidate_snapshots):
     comparison_ready = len(candidate_snapshots) == 2 and all(
         item.get('available') for item in candidate_snapshots
@@ -324,6 +343,18 @@ def _compare_vedastro_minute_snapshots(candidate_snapshots):
     }
 
 
+def _safe_vedastro_adapter_call(call, *args, **kwargs):
+    try:
+        result = call(*args, **kwargs)
+    except TimeoutError:
+        return {'available': False, 'status': 'timeout', '_failure_kind': 'timeout'}
+    except Exception:
+        return {'available': False, 'status': 'exception', '_failure_kind': 'exception'}
+    if not isinstance(result, dict):
+        return {'available': False, 'status': 'invalid_response', '_failure_kind': 'exception'}
+    return result
+
+
 def _rectification_candidate_ready_for_external_validation(result):
     """Allow external validation once local scoring has a narrow, auditable lead."""
     segment = result.get('winning_segment')
@@ -1633,6 +1664,7 @@ API_COMMAND_MAP = {
     'rectification-v5-candidate-features': '/api/rectification/v5/candidate-features',
     'rectification-v5-score': '/api/rectification/v5/score',
     'rectification-v5-diagnostics': '/api/rectification/v5/diagnostics',
+    'rectification-v5-vedastro-validate': '/api/rectification/v5/vedastro-validate',
     'case-validation': '/api/case_validation',
     'divisional-yoga': '/api/divisional_yoga',
     'deep-varga-avastha': '/api/deep_varga_avastha',
@@ -1671,6 +1703,7 @@ TECHNIQUE_EXAMPLE_ENDPOINTS = {
     '/api/rectification/v5/candidate-features',
     '/api/rectification/v5/score',
     '/api/rectification/v5/diagnostics',
+    '/api/rectification/v5/vedastro-validate',
     '/api/relationship',
     '/api/remedies',
     '/api/sade_sati',
@@ -2126,6 +2159,8 @@ class JyotishAPIHandler(BaseHTTPRequestHandler):
                 self._json(self._compute_rectification_v5_score(body))
             elif path == '/api/rectification/v5/diagnostics':
                 self._json(self._compute_rectification_v5_diagnostics(body))
+            elif path == '/api/rectification/v5/vedastro-validate':
+                self._json(self._compute_rectification_v5_vedastro_validate(body))
             elif path == '/api/dynamic_rectification_opportunities':
                 result = self._compute_dynamic_rectification_opportunities(body)
                 self._json(result)
@@ -7570,6 +7605,154 @@ class JyotishAPIHandler(BaseHTTPRequestHandler):
             **diagnostics(self._rectification_v5_request(body)),
         }
 
+    def _compute_rectification_v5_vedastro_validate(self, body):
+        if not isinstance(body, dict):
+            raise BadRequest('request body must be an object')
+        candidate_times = body.get('candidate_times')
+        if (
+            not isinstance(candidate_times, list)
+            or len(candidate_times) != 2
+            or any(not isinstance(value, str) or not re.fullmatch(r'(?:[01]\d|2[0-3]):[0-5]\d', value) for value in candidate_times)
+            or candidate_times[0] == candidate_times[1]
+        ):
+            raise BadRequest('candidate_times must contain exactly two distinct HH:MM values: primary then runner-up')
+
+        request_body = dict(body)
+        request_body.pop('candidate_times', None)
+        request = self._rectification_v5_request(request_body)
+        from scripts.active_rectification_event_engine import _candidate_datetimes
+        allowed_candidate_times = {value.strftime('%H:%M') for value in _candidate_datetimes(request)}
+        if any(value not in allowed_candidate_times for value in candidate_times):
+            raise BadRequest('candidate_times must fall within the V5 candidate range')
+
+        birth_day = datetime.strptime(request['birth_date'], '%Y-%m-%d')
+        selected_events, eligible_event_count, unsupported_events = _select_vedastro_rectification_events(
+            request['events']
+        )
+        adapter = _load_local_module('vedastro_service_adapter')
+        minute_cache = {}
+        range_scan_cache = {}
+        minute_reports = []
+        minute_raw_reports = []
+        candidate_validations = []
+        raw_reports = []
+
+        for role, candidate_time in zip(('primary', 'runner_up'), candidate_times):
+            hour, minute = candidate_time.split(':', 1)
+            candidate_case = {
+                'year': birth_day.year,
+                'month': birth_day.month,
+                'day': birth_day.day,
+                'hour': int(hour),
+                'minute': int(minute),
+                'second': 0,
+                'lat': request['lat'],
+                'lon': request['lon'],
+                'tz': request['tz'],
+            }
+            if candidate_time not in minute_cache:
+                minute_cache[candidate_time] = _safe_vedastro_adapter_call(
+                    adapter.run_rectification_minute_snapshot_for_case,
+                    candidate_case,
+                    case_id=f'rectification_v5_{role}_{candidate_time.replace(":", "")}',
+                )
+            minute_report = minute_cache[candidate_time]
+            minute_raw_reports.append(minute_report)
+            raw_reports.append(minute_report)
+            minute_reports.append(_safe_vedastro_minute_snapshot_summary(candidate_time, minute_report))
+
+            event_scans = []
+            for event, adapter_domain, mapping_mode, start_date, end_date in selected_events:
+                cache_key = (candidate_time, adapter_domain, start_date, end_date)
+                if cache_key not in range_scan_cache:
+                    range_scan_cache[cache_key] = _safe_vedastro_adapter_call(
+                        adapter.run_range_scan_for_case,
+                        candidate_case,
+                        adapter_domain,
+                        start_date,
+                        end_date,
+                        case_id=f'rectification_v5_{role}_{candidate_time.replace(":", "")}',
+                    )
+                report = range_scan_cache[cache_key]
+                raw_reports.append(report)
+                event_scans.append(_safe_vedastro_range_scan_summary(
+                    event,
+                    adapter_domain,
+                    mapping_mode,
+                    start_date,
+                    end_date,
+                    report,
+                ))
+            candidate_validations.append({
+                'role': role,
+                'candidate_time': candidate_time,
+                'metric': _vedastro_candidate_metric(event_scans),
+                'events': event_scans,
+            })
+
+        minute_comparison = _compare_vedastro_minute_snapshots(minute_reports)
+        minute_snapshots_verified = bool(
+            minute_comparison['comparison_ready']
+            and all(
+                _vedastro_minute_snapshot_is_complete(report, summary)
+                for report, summary in zip(minute_raw_reports, minute_reports)
+            )
+        )
+        scans_succeeded = bool(selected_events) and all(
+            item['metric']['successful_event_count'] == item['metric']['requested_event_count']
+            for item in candidate_validations
+        )
+        search_events_primary_supports_local_winner = bool(
+            scans_succeeded
+            and _vedastro_metric_key(candidate_validations[0]['metric'])
+            > _vedastro_metric_key(candidate_validations[1]['metric'])
+        )
+
+        blockers = []
+        failure_kinds = {report.get('_failure_kind') for report in raw_reports}
+        if 'timeout' in failure_kinds or any(report.get('status') == 'timeout' for report in raw_reports):
+            blockers.append('vedastro_timeout')
+        if 'exception' in failure_kinds:
+            blockers.append('vedastro_exception')
+        if not minute_snapshots_verified or not scans_succeeded:
+            blockers.append('vedastro_official_response_missing')
+        if minute_snapshots_verified and not minute_comparison['discriminated']:
+            blockers.append('vedastro_minute_sensitive_layers_not_discriminated')
+        if not selected_events:
+            blockers.append('vedastro_supported_events_missing')
+        blockers = list(dict.fromkeys(blockers))
+        passed = not blockers
+
+        return {
+            'success': True,
+            'endpoint': 'rectification_v5_vedastro_validate',
+            'status': 'pass' if passed else 'fail',
+            'passed': passed,
+            'can_confirm_exact_minute': False,
+            'candidate_times': {
+                'primary': candidate_times[0],
+                'runner_up': candidate_times[1],
+            },
+            'blockers': blockers,
+            'minute_sensitive_validation': {
+                'status': 'pass' if minute_snapshots_verified and minute_comparison['discriminated'] else 'fail',
+                'candidates': minute_reports,
+                **minute_comparison,
+            },
+            'event_validation': {
+                'status': 'pass' if scans_succeeded else 'fail',
+                'eligible_event_count': eligible_event_count,
+                'supported_event_count': len(selected_events),
+                'selection_policy': (
+                    'one_strongest_event_per_native_adapter_domain; '
+                    'direct_mapping_before_proxy; higher_precision_before_lower_precision; newest_on_equal_precision'
+                ),
+                'unsupported_events': unsupported_events,
+                'search_events_primary_supports_local_winner': search_events_primary_supports_local_winner,
+                'candidates': candidate_validations,
+            },
+        }
+
     def _compute_active_rectification_events_v4(self, body):
         """Compatibility projection; validation and calculations are owned by V5 services."""
         from scripts.rectification.api_service import score_candidates
@@ -8445,6 +8628,7 @@ class JyotishAPIHandler(BaseHTTPRequestHandler):
             '/api/rectification/v5/candidate-features': self._compute_rectification_v5_candidate_features,
             '/api/rectification/v5/score': self._compute_rectification_v5_score,
             '/api/rectification/v5/diagnostics': self._compute_rectification_v5_diagnostics,
+            '/api/rectification/v5/vedastro-validate': self._compute_rectification_v5_vedastro_validate,
             '/api/relationship': self._compute_relationship,
             '/api/remedies': self._compute_remedies,
             '/api/sade_sati': self._compute_sade_sati,
@@ -8574,6 +8758,7 @@ class JyotishAPIHandler(BaseHTTPRequestHandler):
             '/api/rectification/v5/candidate-features': 'Scan immutable candidate static features once per calculation specification',
             '/api/rectification/v5/score': 'Build the V5 event-by-candidate contribution matrix and score candidate ranges',
             '/api/rectification/v5/diagnostics': 'Run V5 stability diagnostics over the server-owned contribution matrix',
+            '/api/rectification/v5/vedastro-validate': 'Validate one V5 primary/runner-up pair with safe official VedAstro summaries',
             '/api/relationship': 'Compute relationship and spouse-status evidence',
             '/api/remedies': 'Generate low-risk remedies from doshas/strength/dasha',
             '/api/sade_sati': 'Compute Sade Sati status and phase',
@@ -8651,6 +8836,12 @@ class JyotishAPIHandler(BaseHTTPRequestHandler):
                 'lat': 36.419, 'lon': 114.213, 'tz': 8,
                 'events': [{'id': '00000000-0000-4000-8000-000000000001', 'domain': 'education', 'event_kind': 'education_milestone', 'date_start': '2016-09-01', 'date_end': '2016-09-30', 'precision': 'month', 'summary': '大学入学'}],
             },
+            '/api/rectification/v5/vedastro-validate': {
+                'birth_date': '1997-08-08', 'start_time': '05:00', 'end_time': '05:03',
+                'lat': 36.419, 'lon': 114.213, 'tz': 8,
+                'candidate_times': ['05:01', '05:02'],
+                'events': [{'id': '00000000-0000-4000-8000-000000000001', 'domain': 'education', 'event_kind': 'education_milestone', 'date_start': '2016-09-01', 'date_end': '2016-09-30', 'precision': 'month', 'summary': '大学入学'}],
+            },
             '/api/relationship': {'planets': SAMPLE_PLANETS, 'asc_sign': 'Aries', 'dasha_info': {'maha_dasha': 'Venus', 'antar_dasha': 'Jupiter'}},
             '/api/remedies': {'shadbala': {'Sun': {'rupas': 4.1}, 'Moon': {'rupas': 3.8}}, 'doshas': ['manglik'], 'dasha_lord': 'Venus'},
             '/api/sade_sati': {'moon_degree': SAMPLE_PLANETS['Moon']['lon'], 'asc_degree': SAMPLE_ASCENDANT['lon'], 'saturn_degree': SAMPLE_PLANETS['Saturn']['lon']},
diff --git a/skills/birth-time-rectification/SKILL.md b/skills/birth-time-rectification/SKILL.md
index c7c59e3b..cc04463d 100644
--- a/skills/birth-time-rectification/SKILL.md
+++ b/skills/birth-time-rectification/SKILL.md
@@ -17,9 +17,11 @@ Before choosing an action, read the contracts in `references/`. Treat `assets/re
 - The server owns event reconciliation, the real Python scan of every minute in the candidate window, the event contribution matrix, Candidate Snapshots, LOEO/LODO, date sensitivity, neighbor stability, candidate split, jobs, replay, persistence, and final decision validation.
 - The agent may select one active server opportunity, call at most one allowed read-only diagnostic, offer an already-gated candidate range, or stop for low confidence.
 - The agent never creates events, dates, scores, candidate minutes, or profile updates.
+- VedAstro is a read-only post-validation gate for `v5_agent` only. It runs only after the local stability and range-eligibility gates pass, compares the server-provided primary and runner-up, and never replaces V5 local scoring or lets SearchEvents choose the final candidate.
 - Candidate windows are inclusive. When `start_time > end_time`, the Python scan continues across midnight into the next calendar day; equal endpoints mean one candidate minute, and a window may not exceed 1,440 minutes.
 - The persisted “分析过程” is a server-owned execution receipt, not hidden chain-of-thought. It may list only stages, tools, and techniques that actually ran, plus a provider-explicit reasoning summary after server-side safety filtering.
 - `canConfirmExactMinute` is always `false`. Never write `profiles.active_birth_time` automatically.
+- A missing, timed-out, failed, or non-discriminating VedAstro result blocks public range disclosure but must not discard the Job or its durable local artifacts. Never expose raw provider payloads or internal provider/technique traces.
 
 ## Implementation truth and reference gap
 
diff --git a/skills/birth-time-rectification/references/failure-policy.md b/skills/birth-time-rectification/references/failure-policy.md
index 4bb64a71..d6e621f2 100644
--- a/skills/birth-time-rectification/references/failure-policy.md
+++ b/skills/birth-time-rectification/references/failure-policy.md
@@ -17,14 +17,15 @@ A month-dated event is not a failure. Refine it only when date-sensitivity diagn
 - LODO retention below `0.8` blocks the public range, as does LOEO below `0.8`.
 - A missing active-domain required layer or an unclassified missing layer blocks publication. Missing optional layers such as `KP_cusps`, or reference-only D60, do not make the calculation fail and must not be presented as completed evidence.
 - LOEO/LODO are same-Case sensitivity checks. Until prospective sticky partitioning and calibration exist, the absence of per-Case independent holdout is a deferred safety boundary, not a passed validation.
+- For `v5_agent`, a missing, timed-out, exceptional, incomplete, tied, or non-discriminating minute-sensitive VedAstro snapshot blocks public range disclosure. SearchEvents failure blocks validation completeness; SearchEvents disagreement is diagnostic only and must not veto, choose, or reverse the local V5 candidate.
 
 ## System failures
 
-Preserve the existing Job and persistence guarantees: claim/lease, idempotency, completed-job replay, and atomic completion. A renderer or extraction failure must not cause partial artifact writes, duplicate completion, profile mutation, or a different replay result.
+Preserve the existing Job and persistence guarantees: claim/lease, idempotency, completed-job replay, and atomic completion. A renderer, extraction, or VedAstro post-validation failure must not cause partial artifact writes, duplicate completion, profile mutation, a different replay result, or loss of completed local scoring artifacts.
 
 Do not recover a failed gate by loading an arbitrary external repository, adding provenance-based weight, inventing manual `supports/conflicts` scores, choosing a unique minute, or writing a profile birth time.
 
-Never log raw sensitive answers to ordinary telemetry. Persist user text only in the approved Turn/evidence stores required by the product contract.
+Never log raw sensitive answers to ordinary telemetry. Persist user text only in the approved Turn/evidence stores required by the product contract. Never expose or persist raw VedAstro provider payloads in public output or the analysis receipt.
 
 
 ## Analysis receipt failures
diff --git a/skills/birth-time-rectification/references/output-contract.md b/skills/birth-time-rectification/references/output-contract.md
index 651f1b1e..752055f7 100644
--- a/skills/birth-time-rectification/references/output-contract.md
+++ b/skills/birth-time-rectification/references/output-contract.md
@@ -37,7 +37,7 @@ Reject multi-question transitions such as “另外”, “还有”, “同时
 1. it differs materially from the previous Snapshot's primary range; or
 2. it is the first Snapshot to pass the public stability gate.
 
-The no-repeat rule takes precedence: it must be `null` for an unchanged range, insufficient event/domain coverage, LOEO or LODO retention below `0.8`, failed date/neighbor stability, a missing active-domain required or unclassified technique layer, an internal unstable Snapshot, or a repeated equivalent calculation. Missing optional `KP_cusps` and reference-only D60 do not block by themselves. Never state or imply a unique or representative birth minute.
+The no-repeat rule takes precedence: it must be `null` for an unchanged range, insufficient event/domain coverage, LOEO or LODO retention below `0.8`, failed date/neighbor stability, a missing active-domain required or unclassified technique layer, an internal unstable Snapshot, or a repeated equivalent calculation. In `v5_agent`, it must also be `null` when the required VedAstro primary/runner-up post-validation is missing, timed out, failed, tied, incomplete, or unable to distinguish the pair. Missing optional `KP_cusps` and reference-only D60 do not block by themselves. Never state or imply a unique or representative birth minute.
 
 Do not describe LOEO/LODO as an independent holdout, prospective validation, or calibrated accuracy result. Per-Case independent holdout remains deferred until sticky partitioning and calibration exist.
 
@@ -59,4 +59,4 @@ The public projection may contain only:
 
 Do not infer missing phases from the final Job phase, and do not label a capability as executed merely because the deployment supports it. If no safe provider summary exists, omit it; never create a substitute or expose hidden chain-of-thought.
 
-The receipt must exclude scores, weights, contribution matrices, internal IDs and field names, candidate minutes, tool arguments or raw results, prompts, model/provider internals, and sensitive user wording. Provenance may support audit linkage only and must never be rendered as added evidence strength. D60 is never displayed. Historical messages without a receipt remain valid, and `v4_legacy`/`v5_shadow` keep their established visible reply semantics.
+The receipt must exclude scores, weights, contribution matrices, internal IDs and field names, candidate minutes, tool arguments or raw results, prompts, model/provider internals, raw VedAstro requests/responses, internal provider or technique traces, and sensitive user wording. It may state only that an allowlisted read-only post-validation ran and whether the public gate passed. Provenance may support audit linkage only and must never be rendered as added evidence strength. D60 is never displayed. Historical messages without a receipt remain valid, and `v4_legacy`/`v5_shadow` keep their established visible reply semantics.
diff --git a/skills/birth-time-rectification/references/technique-policy.md b/skills/birth-time-rectification/references/technique-policy.md
index 0a6c9914..22b33b27 100644
--- a/skills/birth-time-rectification/references/technique-policy.md
+++ b/skills/birth-time-rectification/references/technique-policy.md
@@ -21,6 +21,13 @@ Only server-reported available layers may be described as used. Missing, blocked
 
 LOEO/LODO reuse the same Case matrix after subtracting one event or domain. They are not prospective or independent holdout validation. Per-Case independent holdout remains deferred because no sticky train/holdout partition or calibrated acceptance threshold exists; do not claim it is complete.
 
+## VedAstro post-validation
+
+- This read-only check is available only in `v5_agent`, after the local stability and range-eligibility gates pass, and only for the server-selected primary and runner-up. It does not rescore candidates or replace `rectification-v5-matrix-scoring-1`.
+- Minute-sensitive snapshots may test whether the pair is distinguishable. SearchEvents is bounded supporting evidence only and must never select or reverse the final candidate.
+- Missing, timed-out, exceptional, incomplete, tied, or non-discriminating provider results fail closed for public range disclosure. They do not invalidate or delete the local Snapshot, diagnostics, or Job artifacts.
+- VedAstro can never authorize a unique-minute claim or profile write. Public output and receipts must exclude raw provider requests/responses and internal provider or technique traces.
+
 ## Technique boundaries
 
 - Dasha and dated evidence can frame comparison only when present in server results.
diff --git a/tests/test_rectification_v5_vedastro_validation.py b/tests/test_rectification_v5_vedastro_validation.py
new file mode 100644
index 00000000..e9d3e4eb
--- /dev/null
+++ b/tests/test_rectification_v5_vedastro_validation.py
@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+import pytest
+
+from scripts.jyotish_api_server import (
+    API_COMMAND_MAP,
+    TECHNIQUE_EXAMPLE_ENDPOINTS,
+    BadRequest,
+    JyotishAPIHandler,
+)
+
+
+def request(candidate_times=None):
+    events = [
+        {
+            "id": "00000000-0000-4000-8000-000000000001",
+            "domain": "education",
+            "event_kind": "education_milestone",
+            "date_start": "2016-09-01",
+            "date_end": "2016-09-30",
+            "precision": "month",
+            "summary": "private education summary that must not be returned",
+        },
+        {
+            "id": "00000000-0000-4000-8000-000000000002",
+            "domain": "career",
+            "event_kind": "career_change",
+            "date_start": "2020-05-01",
+            "date_end": "2020-05-01",
+            "precision": "day",
+            "summary": "private career summary that must not be returned",
+        },
+        {
+            "id": "00000000-0000-4000-8000-000000000003",
+            "domain": "career",
+            "event_kind": "career_change",
+            "date_start": "2021-06-01",
+            "date_end": "2021-06-01",
+            "precision": "day",
+            "summary": "newer career event wins the bounded selection",
+        },
+        {
+            "id": "00000000-0000-4000-8000-000000000004",
+            "domain": "relationship",
+            "event_kind": "relationship_change",
+            "date_start": "2022-01-01",
+            "date_end": "2022-12-31",
+            "precision": "year",
+            "summary": "private relationship summary that must not be returned",
+        },
+        {
+            "id": "00000000-0000-4000-8000-000000000005",
+            "domain": "finance",
+            "event_kind": "finance_change",
+            "date_start": "2023-03-01",
+            "date_end": "2023-03-31",
+            "precision": "month",
+            "summary": "private finance summary that must not be returned",
+        },
+        {
+            "id": "00000000-0000-4000-8000-000000000006",
+            "domain": "health_pressure",
+            "event_kind": "self_health_event",
+            "date_start": "2024-04-01",
+            "date_end": "2024-04-30",
+            "precision": "month",
+            "summary": "private health summary that must not be returned",
+        },
+    ]
+    return {
+        "birth_date": "1997-08-08",
+        "start_time": "05:00",
+        "end_time": "05:30",
+        "lat": 36.419,
+        "lon": 114.213,
+        "tz": 8,
+        "events": events,
+        "candidate_times": candidate_times if candidate_times is not None else ["05:13", "05:14"],
+    }
+
+
+def minute_snapshot(case, *, same=False):
+    minute = case["minute"]
+    suffix = "same" if same else str(minute)
+    return {
+        "available": True,
+        "status": "ok",
+        "source": "vedastro_official",
+        "layers": {
+            "ascendant_house_boundaries": {
+                "status": "ok",
+                "fingerprint": f"asc-{suffix}",
+                "ascendant": {"sign": "Leo", "degree_in_sign": minute / 10},
+                "houses": {"House1": {}},
+            },
+            "D9": {"status": "ok", "fingerprint": f"d9-{suffix}", "houses": {"House1": {}}, "planets": {}},
+            "D10": {"status": "ok", "fingerprint": f"d10-{suffix}", "houses": {"House1": {}}, "planets": {}},
+            "dasha_boundaries": {"status": "ok", "fingerprint": f"dasha-{suffix}", "boundary_count": 3},
+            "kp_cusp_sub_lord": {"status": "unsupported", "reason": "not available"},
+        },
+        "raw_request": {"api_key": "secret"},
+        "raw_response": {"private": True},
+    }
+
+
+def test_registry_exposes_independent_vedastro_validation_endpoint():
+    endpoint = "/api/rectification/v5/vedastro-validate"
+    assert API_COMMAND_MAP["rectification-v5-vedastro-validate"] == endpoint
+    assert endpoint in TECHNIQUE_EXAMPLE_ENDPOINTS
+
+
+def test_requires_exactly_two_distinct_candidate_times_before_running_vedastro():
+    handler = object.__new__(JyotishAPIHandler)
+    for candidate_times in ([], ["05:13"], ["05:13", "05:14", "05:15"], ["05:13", "05:13"]):
+        with pytest.raises(BadRequest, match="candidate_times"):
+            handler._compute_rectification_v5_vedastro_validate(request(candidate_times))
+
+
+def test_passes_only_when_official_layers_discriminate_and_primary_is_strictly_better(monkeypatch):
+    range_calls = []
+
+    class Adapter:
+        @staticmethod
+        def run_rectification_minute_snapshot_for_case(case, case_id="user_chart"):
+            return minute_snapshot(case)
+
+        @staticmethod
+        def run_range_scan_for_case(case, domain, start, end, case_id="user_chart"):
+            range_calls.append((case["minute"], domain, start, end))
+            lift = 3 if case["minute"] == 13 else 1
+            return {
+                "available": True,
+                "status": "ok",
+                "event_count": lift,
+                "top_event": {"event_id": f"event-{domain}"},
+                "evidence_ledger": [{"signal_lift": lift}],
+                "raw_response": {"must_not": "leak"},
+            }
+
+    monkeypatch.setattr("scripts.jyotish_api_server._load_local_module", lambda name: Adapter)
+    monkeypatch.setenv("VEDASTRO_API_KEY", "must-not-leak")
+
+    result = object.__new__(JyotishAPIHandler)._compute_rectification_v5_vedastro_validate(request())
+
+    assert result["status"] == "pass"
+    assert result["passed"] is True
+    assert result["can_confirm_exact_minute"] is False
+    assert result["candidate_times"] == {"primary": "05:13", "runner_up": "05:14"}
+    assert result["minute_sensitive_validation"]["discriminated"] is True
+    assert result["event_validation"]["search_events_primary_supports_local_winner"] is True
+    assert result["event_validation"]["supported_event_count"] == 3
+    assert len(range_calls) == 6
+    assert {call[1] for call in range_calls} == {"career", "marriage", "wealth"}
+    serialized = str(result)
+    assert "private" not in serialized
+    assert "raw_request" not in serialized
+    assert "raw_response" not in serialized
+    assert "must-not-leak" not in serialized
+
+
+@pytest.mark.parametrize("mutation", ["missing_source", "missing_layer"])
+def test_missing_official_minute_response_cannot_pass(monkeypatch, mutation):
+    class Adapter:
+        @staticmethod
+        def run_rectification_minute_snapshot_for_case(case, case_id="user_chart"):
+            report = minute_snapshot(case)
+            if mutation == "missing_source":
+                report.pop("source")
+            else:
+                report["layers"].pop("D10")
+            return report
+
+        @staticmethod
+        def run_range_scan_for_case(case, domain, start, end, case_id="user_chart"):
+            lift = 3 if case["minute"] == 13 else 1
+            return {
+                "available": True,
+                "status": "ok",
+                "event_count": lift,
+                "top_event": {"event_id": f"event-{domain}"},
+                "evidence_ledger": [{"signal_lift": lift}],
+            }
+
+    monkeypatch.setattr("scripts.jyotish_api_server._load_local_module", lambda name: Adapter)
+    result = object.__new__(JyotishAPIHandler)._compute_rectification_v5_vedastro_validate(request())
+
+    assert result["status"] == "fail"
+    assert result["passed"] is False
+    assert result["can_confirm_exact_minute"] is False
+    assert "vedastro_official_response_missing" in result["blockers"]
+
+
+def test_identical_minute_layers_cannot_pass(monkeypatch):
+    class Adapter:
+        @staticmethod
+        def run_rectification_minute_snapshot_for_case(case, case_id="user_chart"):
+            return minute_snapshot(case, same=True)
+
+        @staticmethod
+        def run_range_scan_for_case(case, domain, start, end, case_id="user_chart"):
+            return {
+                "available": True,
+                "status": "ok",
+                "event_count": 1,
+                "top_event": {"event_id": f"event-{domain}"},
+                "evidence_ledger": [{"signal_lift": 1}],
+            }
+
+    monkeypatch.setattr("scripts.jyotish_api_server._load_local_module", lambda name: Adapter)
+    result = object.__new__(JyotishAPIHandler)._compute_rectification_v5_vedastro_validate(request())
+
+    assert result["status"] == "fail"
+    assert result["passed"] is False
+    assert result["can_confirm_exact_minute"] is False
+    assert "vedastro_minute_sensitive_layers_not_discriminated" in result["blockers"]
+
+
+def test_search_events_disagreement_is_diagnostic_and_cannot_reverse_local_winner(monkeypatch):
+    class Adapter:
+        @staticmethod
+        def run_rectification_minute_snapshot_for_case(case, case_id="user_chart"):
+            return minute_snapshot(case)
+
+        @staticmethod
+        def run_range_scan_for_case(case, domain, start, end, case_id="user_chart"):
+            lift = 1 if case["minute"] == 13 else 3
+            return {
+                "available": True,
+                "status": "ok",
+                "event_count": lift,
+                "top_event": {"event_id": f"event-{domain}"},
+                "evidence_ledger": [{"signal_lift": lift}],
+            }
+
+    monkeypatch.setattr("scripts.jyotish_api_server._load_local_module", lambda name: Adapter)
+    result = object.__new__(JyotishAPIHandler)._compute_rectification_v5_vedastro_validate(request())
+
+    assert result["status"] == "pass"
+    assert result["passed"] is True
+    assert result["event_validation"]["search_events_primary_supports_local_winner"] is False
+    assert result["blockers"] == []
+    assert result["can_confirm_exact_minute"] is False
+
+
+def test_timeout_is_returned_as_safe_failure(monkeypatch):
+    class Adapter:
+        @staticmethod
+        def run_rectification_minute_snapshot_for_case(case, case_id="user_chart"):
+            raise TimeoutError("secret upstream URL and key")
+
+        @staticmethod
+        def run_range_scan_for_case(case, domain, start, end, case_id="user_chart"):
+            raise RuntimeError("secret raw response")
+
+    monkeypatch.setattr("scripts.jyotish_api_server._load_local_module", lambda name: Adapter)
+    result = object.__new__(JyotishAPIHandler)._compute_rectification_v5_vedastro_validate(request())
+
+    assert result["status"] == "fail"
+    assert result["passed"] is False
+    assert result["can_confirm_exact_minute"] is False
+    assert "vedastro_timeout" in result["blockers"]
+    assert "vedastro_exception" in result["blockers"]
+    assert "secret" not in str(result)

From 2be454dfcfaf3ad439f013eefa6aa16434c754e7 Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Thu, 30 Jul 2026 12:18:24 +0800
Subject: [PATCH 14/15] fix: recover staging deploy tree ownership

---
 deploy/sync-staging-tree.sh                   | 10 +++-
 .../tests/staging-backend-workflows.test.ts   | 56 +++++++++++++++++++
 2 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/deploy/sync-staging-tree.sh b/deploy/sync-staging-tree.sh
index 005766fa..b67623fc 100755
--- a/deploy/sync-staging-tree.sh
+++ b/deploy/sync-staging-tree.sh
@@ -6,7 +6,15 @@ if [ "$#" -ne 2 ] || [ ! -d "$1" ] || [ ! -d "$2" ]; then
   exit 1
 fi
 
-rsync -az --delete \
+destination_deploy="$2/deploy"
+if [ -d "$destination_deploy" ] && [ ! -w "$destination_deploy" ]; then
+  docker run --rm --network none --read-only --user 0:0 \
+    --cap-drop ALL --cap-add CHOWN --security-opt no-new-privileges \
+    -v "$destination_deploy:/destination" postgres:17-alpine \
+    chown -R "$(id -u):$(id -g)" /destination
+fi
+
+rsync -az --delete --no-owner --no-group \
   --exclude='/.git/' \
   --exclude='/.env*' \
   --exclude='/.docker/' \
diff --git a/frontend/tests/staging-backend-workflows.test.ts b/frontend/tests/staging-backend-workflows.test.ts
index a9bde16d..a5fc8777 100644
--- a/frontend/tests/staging-backend-workflows.test.ts
+++ b/frontend/tests/staging-backend-workflows.test.ts
@@ -153,6 +153,62 @@ test("live staging sync preserves env, state, incoming files, and encrypted back
   }
 });
 
+test("live staging sync repairs a non-writable deploy tree without preserving foreign ownership", () => {
+  const root = mkdtempSync(join(tmpdir(), "jyotisha-live-sync-permissions-"));
+  const source = join(root, "source");
+  const destination = join(root, "destination");
+  const destinationDeploy = join(destination, "deploy");
+  const mockBin = join(root, "bin");
+  const dockerLog = join(root, "docker.log");
+  mkdirSync(join(source, "deploy"), { recursive: true });
+  mkdirSync(destinationDeploy, { recursive: true });
+  mkdirSync(mockBin);
+  writeFileSync(join(source, "deploy", "current.txt"), "new\n");
+  writeFileSync(join(destinationDeploy, "stale.txt"), "old\n");
+  writeFileSync(
+    join(mockBin, "docker"),
+    [
+      "#!/usr/bin/env bash",
+      "set -euo pipefail",
+      "printf '%s\\n' \"$*\" >\"$DOCKER_LOG\"",
+      'chmod -R u+rwX "$REPAIR_DESTINATION"',
+      "",
+    ].join("\n"),
+  );
+  chmodSync(join(mockBin, "docker"), 0o755);
+  chmodSync(destinationDeploy, 0o555);
+
+  try {
+    const result = spawnSync(
+      "bash",
+      [fileURLToPath(syncScript), source, destination],
+      {
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          PATH: `${mockBin}:${process.env.PATH ?? ""}`,
+          DOCKER_LOG: dockerLog,
+          REPAIR_DESTINATION: destinationDeploy,
+        },
+      },
+    );
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(existsSync(join(destinationDeploy, "stale.txt")), false);
+    assert.equal(
+      readFileSync(join(destinationDeploy, "current.txt"), "utf8"),
+      "new\n",
+    );
+    const invocation = readFileSync(dockerLog, "utf8");
+    assert.match(invocation, /--network none --read-only --user 0:0/);
+    assert.match(invocation, /--cap-drop ALL --cap-add CHOWN/);
+    assert.match(invocation, /postgres:17-alpine chown -R/);
+    assert.match(read(syncScript), /--no-owner --no-group/);
+  } finally {
+    if (existsSync(destinationDeploy)) chmodSync(destinationDeploy, 0o755);
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("all staging mutations share Actions serialization and one host lock", () => {
   const deployment = read(deployWorkflow);
   const migration = read(migrationWorkflow);

From 3d8c3ce6a353d6f75a14fff2760dec89249d136e Mon Sep 17 00:00:00 2001
From: Jesse_Chen <chen.yue@mevixaga.com>
Date: Thu, 30 Jul 2026 12:21:37 +0800
Subject: [PATCH 15/15] fix: harden staging ownership recovery

---
 deploy/sync-staging-tree.sh                   |  5 ++--
 .../tests/staging-backend-workflows.test.ts   | 26 ++++++++++++-------
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/deploy/sync-staging-tree.sh b/deploy/sync-staging-tree.sh
index b67623fc..ccda6697 100755
--- a/deploy/sync-staging-tree.sh
+++ b/deploy/sync-staging-tree.sh
@@ -7,11 +7,12 @@ if [ "$#" -ne 2 ] || [ ! -d "$1" ] || [ ! -d "$2" ]; then
 fi
 
 destination_deploy="$2/deploy"
-if [ -d "$destination_deploy" ] && [ ! -w "$destination_deploy" ]; then
-  docker run --rm --network none --read-only --user 0:0 \
+if [ -d "$destination_deploy" ]; then
+  docker run --rm --pull never --network none --read-only --user 0:0 \
     --cap-drop ALL --cap-add CHOWN --security-opt no-new-privileges \
     -v "$destination_deploy:/destination" postgres:17-alpine \
     chown -R "$(id -u):$(id -g)" /destination
+  chmod -R u+rwX "$destination_deploy"
 fi
 
 rsync -az --delete --no-owner --no-group \
diff --git a/frontend/tests/staging-backend-workflows.test.ts b/frontend/tests/staging-backend-workflows.test.ts
index a5fc8777..2e17807c 100644
--- a/frontend/tests/staging-backend-workflows.test.ts
+++ b/frontend/tests/staging-backend-workflows.test.ts
@@ -153,7 +153,7 @@ test("live staging sync preserves env, state, incoming files, and encrypted back
   }
 });
 
-test("live staging sync repairs a non-writable deploy tree without preserving foreign ownership", () => {
+test("live staging sync repairs nested deploy-tree drift without preserving foreign ownership", () => {
   const root = mkdtempSync(join(tmpdir(), "jyotisha-live-sync-permissions-"));
   const source = join(root, "source");
   const destination = join(root, "destination");
@@ -163,20 +163,21 @@ test("live staging sync repairs a non-writable deploy tree without preserving fo
   mkdirSync(join(source, "deploy"), { recursive: true });
   mkdirSync(destinationDeploy, { recursive: true });
   mkdirSync(mockBin);
-  writeFileSync(join(source, "deploy", "current.txt"), "new\n");
-  writeFileSync(join(destinationDeploy, "stale.txt"), "old\n");
+  mkdirSync(join(source, "deploy", "postgres"), { recursive: true });
+  mkdirSync(join(destinationDeploy, "postgres"), { recursive: true });
+  writeFileSync(join(source, "deploy", "postgres", "current.txt"), "new\n");
+  writeFileSync(join(destinationDeploy, "postgres", "stale.txt"), "old\n");
   writeFileSync(
     join(mockBin, "docker"),
     [
       "#!/usr/bin/env bash",
       "set -euo pipefail",
       "printf '%s\\n' \"$*\" >\"$DOCKER_LOG\"",
-      'chmod -R u+rwX "$REPAIR_DESTINATION"',
       "",
     ].join("\n"),
   );
   chmodSync(join(mockBin, "docker"), 0o755);
-  chmodSync(destinationDeploy, 0o555);
+  chmodSync(join(destinationDeploy, "postgres"), 0o555);
 
   try {
     const result = spawnSync(
@@ -188,23 +189,28 @@ test("live staging sync repairs a non-writable deploy tree without preserving fo
           ...process.env,
           PATH: `${mockBin}:${process.env.PATH ?? ""}`,
           DOCKER_LOG: dockerLog,
-          REPAIR_DESTINATION: destinationDeploy,
         },
       },
     );
     assert.equal(result.status, 0, result.stderr);
-    assert.equal(existsSync(join(destinationDeploy, "stale.txt")), false);
     assert.equal(
-      readFileSync(join(destinationDeploy, "current.txt"), "utf8"),
+      existsSync(join(destinationDeploy, "postgres", "stale.txt")),
+      false,
+    );
+    assert.equal(
+      readFileSync(join(destinationDeploy, "postgres", "current.txt"), "utf8"),
       "new\n",
     );
     const invocation = readFileSync(dockerLog, "utf8");
-    assert.match(invocation, /--network none --read-only --user 0:0/);
+    assert.match(invocation, /--pull never --network none --read-only --user 0:0/);
     assert.match(invocation, /--cap-drop ALL --cap-add CHOWN/);
     assert.match(invocation, /postgres:17-alpine chown -R/);
+    assert.match(read(syncScript), /chmod -R u\+rwX/);
     assert.match(read(syncScript), /--no-owner --no-group/);
   } finally {
-    if (existsSync(destinationDeploy)) chmodSync(destinationDeploy, 0o755);
+    if (existsSync(join(destinationDeploy, "postgres"))) {
+      chmodSync(join(destinationDeploy, "postgres"), 0o755);
+    }
     rmSync(root, { recursive: true, force: true });
   }
 });