diff --git a/deploy/README.md b/deploy/README.md
index 3b36b0af..67dc5ce7 100644
--- a/deploy/README.md
+++ b/deploy/README.md
@@ -413,11 +413,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
@@ -441,9 +444,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 c276877b..10ef3fd6 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, "=")
@@ -146,6 +150,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/deploy/sync-staging-tree.sh b/deploy/sync-staging-tree.sh
index 005766fa..ccda6697 100755
--- a/deploy/sync-staging-tree.sh
+++ b/deploy/sync-staging-tree.sh
@@ -6,7 +6,16 @@ if [ "$#" -ne 2 ] || [ ! -d "$1" ] || [ ! -d "$2" ]; then
   exit 1
 fi
 
-rsync -az --delete \
+destination_deploy="$2/deploy"
+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 \
   --exclude='/.git/' \
   --exclude='/.env*' \
   --exclude='/.docker/' \
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/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/app/globals.css b/frontend/src/app/globals.css
index 853985d8..30f01106 100644
--- a/frontend/src/app/globals.css
+++ b/frontend/src/app/globals.css
@@ -607,6 +607,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); }
@@ -1555,6 +1605,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 53b64b3b..f59d8402 100644
--- a/frontend/src/components/rectification-v4-panel.tsx
+++ b/frontend/src/components/rectification-v4-panel.tsx
@@ -1,12 +1,13 @@
 "use client";
 
-import { ArrowUp } from "lucide-react";
+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,11 +30,142 @@ 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",
+): "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,
   pendingConsultationQuestion?: string | null,
-): readonly ChatMessageView[] {
+): readonly RectificationChatMessageView[] {
   if (!data) {
     return [{
       role: "assistant",
@@ -43,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",
@@ -53,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({
@@ -68,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({
@@ -85,6 +229,7 @@ export function rectificationV4ChatMessages(
       text: `根据目前这些经历，可以先把范围稳定缩小到 ${primary.startTime}–${primary.endTime}。这是候选范围，不是已确认的出生分钟；你可以保存它，也可以继续补充经历。`,
       renderKey: `rectification-range-${caseValue.version}`,
       state: "settled",
+      analysisTrace: terminalTrace,
     });
   }
 
@@ -94,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",
     });
@@ -110,6 +256,7 @@ export function rectificationV4ChatMessages(
       text: "进度已经保存。准备好后，我们可以从这里继续。",
       renderKey: `rectification-paused-${caseValue.version}`,
       state: "settled",
+      analysisTrace: terminalTrace,
     });
   } else if (caseValue.status === "abandoned") {
     messages.push({
@@ -117,6 +264,7 @@ export function rectificationV4ChatMessages(
       text: "这次校正已经结束，原出生时间没有被改写。",
       renderKey: `rectification-abandoned-${caseValue.version}`,
       state: "settled",
+      analysisTrace: terminalTrace,
     });
   }
 
@@ -129,6 +277,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 +296,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 +329,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 +365,74 @@ 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}>
+                {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
+                      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..d6d314bd 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";
 
@@ -23,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;
@@ -30,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);
@@ -46,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;
   }, []);
@@ -73,7 +87,6 @@ export function useRectificationV4(input: {
         }
         if (mounted.current) {
           setData(result);
-          setJob(result.job);
           setHandoff(nextHandoff);
         }
       } catch (caught) {
@@ -86,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);
@@ -111,7 +131,6 @@ export function useRectificationV4(input: {
       const result = await operation();
       if (mounted.current) {
         setData(result);
-        setJob(result.job);
       }
       return result;
     } catch (caught) {
@@ -136,6 +155,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/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/src/lib/conversational-rectification/evidence-extractor.ts b/frontend/src/lib/conversational-rectification/evidence-extractor.ts
index d7ecd277..b9df6abf 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,83 @@ 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"],
+};
+
+const familyRelatedPeople = new Set<ModelAssistedEventExtraction["relatedPerson"]>([
+  "father",
+  "mother",
+  "grandparent",
+  "sibling",
+]);
+const explicitFamilySubjectMarkers = [
+  "父亲", "爸爸", "老爸", "母亲", "妈妈", "老妈",
+  "爷爷", "奶奶", "外公", "外婆", "祖父", "祖母", "外祖父", "外祖母",
+  "兄弟", "姐妹", "家里老人", "家中老人",
+] as const;
+
+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;
+  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";
+  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..569a390c 100644
--- a/frontend/src/lib/rectification-agent/contracts.ts
+++ b/frontend/src/lib/rectification-agent/contracts.ts
@@ -1,10 +1,13 @@
 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}$/);
 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,
@@ -70,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,
@@ -85,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();
@@ -136,6 +287,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/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..9f433547 100644
--- a/frontend/src/lib/rectification-agent/opportunity-builder.ts
+++ b/frontend/src/lib/rectification-agent/opportunity-builder.ts
@@ -1,8 +1,28 @@
 import { createHash } from "node:crypto";
 import type { CandidateSnapshot, EvidenceDomain, LifeEventRevision, RectificationV4Turn } from "../rectification-v4/contracts.ts";
-import type { DiagnosticsSummary, QuestionOpportunity } from "./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";
 
-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: (anchor: string | null) => string;
+  keywords: RegExp;
+  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 },
+};
 
 function stableUuid(value: string): string {
   const hex = createHash("sha256").update(value).digest("hex").slice(0, 32).split("");
@@ -21,7 +41,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 +51,30 @@ 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 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 +84,124 @@ 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 latestEvent = chronologicalEvents(input.events).at(-1);
+  const latestContext = input.turns.at(-1)?.answer ?? latestEvent?.rawText ?? "";
   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 = 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: 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: 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 : scoreableDomains.size < 2 ? 1 : .15,
+      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..13073858 100644
--- a/frontend/src/lib/rectification-agent/orchestrator.ts
+++ b/frontend/src/lib/rectification-agent/orchestrator.ts
@@ -1,9 +1,10 @@
 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";
 import { evidenceSetHash } from "../rectification-v4/fingerprints.ts";
 import { latestEventRevisions, scoreableEvents } from "../rectification-v4/evidence-ledger.ts";
 import { projectLegacyV4Turn } from "../rectification-v4/legacy-projector.ts";
@@ -16,18 +17,93 @@ import { recordRectificationAgentTelemetry } from "./telemetry.ts";
 import {
   candidateFeatureSnapshotSchema,
   diagnosticsSummarySchema,
+  vedAstroPostValidationSchema,
   validateRectificationDecision,
   type AgentRun,
   type CandidateFeatureSnapshot,
   type DiagnosticsSummary,
-  type PublicMessage,
+  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: "扫描候选分钟",
+  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;
@@ -40,23 +116,65 @@ 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 reconciliation = claimed.turn.answer ? reconcileV4Evidence({
+  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,
     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);
@@ -64,15 +182,21 @@ 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,
       leaveOneOutRetentionRate: scored.robustness.leaveOneOutRetentionRate,
+      leaveOneDomainOutRetentionRate: scored.robustness.leaveOneDomainOutRetentionRate,
       dateSensitivityRetentionRate: scored.robustness.dateSensitivityRetentionRate,
       calculationSpecHashMatched: scored.calculationSpecHash === claimed.case.calculationSpecHash,
     };
@@ -80,7 +204,8 @@ export async function processRectificationAgentTurn(input: Readonly<{
       clusters,
       robustness,
       scoreableEventCount: scoreable.length,
-      scoreableDomainCount: domains.size,
+      scoreableDomains: [...domains],
+      missingTechniqueLayers: scored.missingLayers,
     });
     snapshot = {
       id: scored.resultId,
@@ -94,7 +219,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({
@@ -148,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,
@@ -167,21 +336,31 @@ 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,
     turns: claimed.turns,
     snapshot,
     diagnostics,
+    targetDisposition: reconciliation.targetDisposition,
     retryTargetEventIds: reconciliation.unansweredTargetEventId ? [reconciliation.unansweredTargetEventId] : [],
   });
-  await input.onPhase?.("reasoning");
+  await enterPhase("reasoning");
   const reasoned = await runBoundedReasoner({
     caseValue: claimed.case,
     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;
@@ -225,7 +404,7 @@ export async function processRectificationAgentTurn(input: Readonly<{
     selectedOpportunity,
   };
 
-  await input.onPhase?.("rendering");
+  await enterPhase("rendering");
   const legacyProjection = projectLegacyV4Turn({
     events,
     newEvents: extracted,
@@ -234,21 +413,41 @@ 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,
       acceptedEvents: extracted,
       pendingEvidence: reconciliation.pending,
       snapshot,
+      previousSnapshot: claimed.case.latestSnapshot,
       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,
     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..a493161f 100644
--- a/frontend/src/lib/rectification-agent/reasoner-agent.ts
+++ b/frontend/src/lib/rectification-agent/reasoner-agent.ts
@@ -3,7 +3,9 @@ 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 { 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";
 import {
@@ -18,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 };
@@ -34,11 +64,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: 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: {
+      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;
@@ -51,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;
@@ -72,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");
@@ -116,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;
@@ -131,21 +222,23 @@ 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);
+  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);
@@ -155,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");
     }
@@ -165,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-agent/renderer-agent.ts b/frontend/src/lib/rectification-agent/renderer-agent.ts
index 553c779c..c5ef92c7 100644
--- a/frontend/src/lib/rectification-agent/renderer-agent.ts
+++ b/frontend/src/lib/rectification-agent/renderer-agent.ts
@@ -1,47 +1,198 @@
 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 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 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 {
   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 };
+function matchingAnchorFragment(question: string, anchor: string): string | null {
+  const normalizedQuestion = normalized(question);
+  const normalizedAnchor = normalized(anchor);
+  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 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[] {
+  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();
+  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");
+  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) {
+    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");
+    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 = visibleTextSafetyIssues(parsed.acknowledgement).length > 0
+    || bannedAcknowledgement.test(parsed.acknowledgement)
+    || overinterpretedAcknowledgement.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 && visibleTextSafetyIssues(parsed.limitation).length === 0 ? 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 +204,30 @@ 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 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 {
@@ -69,3 +236,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/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..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,14 +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,
-        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,
-        })),
-      }),
+      body: JSON.stringify(rectificationRequestBody(calculationSpec, events)),
     });
     const payload: unknown = await response.json();
     if (!response.ok) throw new Error(`rectification_v5_engine_${response.status}`);
@@ -115,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/src/lib/rectification-v4/case-service.ts b/frontend/src/lib/rectification-v4/case-service.ts
index 886c63c9..b187c891 100644
--- a/frontend/src/lib/rectification-v4/case-service.ts
+++ b/frontend/src/lib/rectification-v4/case-service.ts
@@ -7,23 +7,41 @@ 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 { 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";
 
-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([
+    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],
     };
   }
 
@@ -45,8 +63,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",
@@ -87,6 +105,53 @@ 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 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: {
       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/contracts.ts b/frontend/src/lib/rectification-v4/contracts.ts
index 4d18165c..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();
 
@@ -270,11 +307,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/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 dba76a92..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) {
@@ -15,6 +29,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/src/lib/rectification-v4/extraction.ts b/frontend/src/lib/rectification-v4/extraction.ts
index e6ecb0c2..998df44d 100644
--- a/frontend/src/lib/rectification-v4/extraction.ts
+++ b/frontend/src/lib/rectification-v4/extraction.ts
@@ -10,13 +10,32 @@ 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",
   "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;
@@ -92,6 +111,7 @@ function subjectRevision(answer: string, target: LifeEventRevision, existing: re
     summary: target.summary,
     rawText: answer,
     dateRange: target.dateRange,
+    ...eventDateProvenance(target),
     scoreability,
   }, { now });
 }
@@ -100,6 +120,7 @@ export type ReconciledV4Evidence = Readonly<{
   revisions: readonly LifeEventRevision[];
   pending: readonly PendingEvidence[];
   unansweredTargetEventId: string | null;
+  targetDisposition: TargetDisposition;
 }>;
 
 export function reconcileV4Evidence(input: {
@@ -109,13 +130,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;
 
@@ -138,8 +162,10 @@ 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);
           targetResolved = true;
         }
       }
@@ -147,17 +173,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 +207,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/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/memory-store.ts b/frontend/src/lib/rectification-v4/memory-store.ts
index aef2c457..bee09ec4 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,25 @@ 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;
+      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 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);
@@ -91,6 +110,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);
@@ -188,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 812d3dcc..37151885 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,7 +46,18 @@ 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>;
+  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;
@@ -78,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 045bd25e..4928bea5 100644
--- a/frontend/src/lib/rectification-v4/supabase-store.ts
+++ b/frontend/src/lib/rectification-v4/supabase-store.ts
@@ -1,12 +1,15 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
+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,
@@ -21,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);
 }
@@ -87,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,
@@ -104,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),
@@ -170,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[]> {
@@ -182,6 +210,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);
@@ -199,6 +242,21 @@ 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)
+        .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 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,
@@ -222,6 +280,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,
@@ -281,6 +352,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/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/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/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/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/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-component.test.ts b/frontend/tests/conversational-rectification-component.test.ts
index 667c1e43..74288ad8 100644
--- a/frontend/tests/conversational-rectification-component.test.ts
+++ b/frontend/tests/conversational-rectification-component.test.ts
@@ -1,7 +1,13 @@
 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,
+  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";
@@ -55,6 +61,7 @@ function response(overrides: Record<string, unknown> = {}): RectificationV4ApiRe
     },
     job: null,
     events: [],
+    analysis: [],
     turns: [{
       id: "00000000-0000-4000-8000-000000000903",
       caseId: id,
@@ -68,7 +75,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", () => {
@@ -87,6 +115,18 @@ 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, /aria-label="重新生成回答"/);
+  assert.match(component, /<details className="rectification-analysis">/);
+  assert.match(component, /<span>分析过程<\/span>/);
+  assert.match(
+    component,
+    /<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\(\)/);
   assert.match(component, /controller\.answer\(answer, props\.selectedModelId \|\| null\)/);
   assert.match(wrapper, /<RectificationV4Panel \{\.\.\.props\} \/>/);
   assert.match(page, /\{!rectificationSurfaceOpen && \(\s*<div className=\{`conversation/);
@@ -96,6 +136,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);
 
@@ -106,10 +182,124 @@ 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);
-  assert.equal(messages.at(-1)?.role, "assistant");
-  assert.equal(messages.at(-1)?.state, "thinking");
+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 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", () => {
+  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/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/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/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",
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..c72cc79d 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,
@@ -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"],
@@ -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 () => {
@@ -331,16 +361,93 @@ 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);
 });
+
+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?.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);
+    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..37a37672
--- /dev/null
+++ b/frontend/tests/rectification-agent-v6.test.ts
@@ -0,0 +1,435 @@
+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, leaveOneDomainOutRetentionRate: .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("外地上大学不会被换词提升为迁居问题", () => {
+  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: "离家去外地上大学",
+    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("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",
+    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);
+  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-analysis-trace.test.ts b/frontend/tests/rectification-analysis-trace.test.ts
new file mode 100644
index 00000000..7cf53024
--- /dev/null
+++ b/frontend/tests/rectification-analysis-trace.test.ts
@@ -0,0 +1,524 @@
+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,
+  CandidateMinute,
+  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 { 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",
+  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, rangeReadyCandidates);
+        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("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({
+    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-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-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..3bb8580d
--- /dev/null
+++ b/frontend/tests/rectification-provenance.test.ts
@@ -0,0 +1,136 @@
+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);
+});
+
+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-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
new file mode 100644
index 00000000..24bd11d1
--- /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, leaveOneDomainOutRetentionRate: 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/frontend/tests/rectification-v4-domain.test.ts b/frontend/tests/rectification-v4-domain.test.ts
index ee33c936..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);
@@ -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-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-replay.test.ts b/frontend/tests/rectification-v4-replay.test.ts
index 5081ffbb..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();
@@ -73,32 +76,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 +97,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..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({
@@ -93,14 +97,42 @@ 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);
 }));
 
 test("V5 shadow runs and persists V5 artifacts but keeps the legacy visible projection", 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年9月离家去外地上大学",
+  });
+  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];
+  const run = [...store.agentRuns.values()][0];
+  assert.ok(queued?.job && event && run);
+  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, 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();
@@ -116,13 +148,11 @@ test("V5 shadow runs and persists V5 artifacts but keeps the legacy visible proj
   assert.equal(await worker.runOnce(), true);
   const done = await service.loadCase(userId, created.case.id);
   const event = done?.events[0];
-  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.ok(queued?.job && event);
   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 ?? "", /我记下了/);
+  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 () => {
@@ -145,3 +175,87 @@ 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();
+  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({
+    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 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);
+  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(realizationCalls, 1);
+  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);
+    });
+  }
+});
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/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/frontend/tests/staging-backend-workflows.test.ts b/frontend/tests/staging-backend-workflows.test.ts
index 14718d20..828d0d06 100644
--- a/frontend/tests/staging-backend-workflows.test.ts
+++ b/frontend/tests/staging-backend-workflows.test.ts
@@ -161,6 +161,68 @@ test("live staging sync preserves env, state, incoming files, and encrypted back
   }
 });
 
+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");
+  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);
+  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\"",
+      "",
+    ].join("\n"),
+  );
+  chmodSync(join(mockBin, "docker"), 0o755);
+  chmodSync(join(destinationDeploy, "postgres"), 0o555);
+
+  try {
+    const result = spawnSync(
+      "bash",
+      [fileURLToPath(syncScript), source, destination],
+      {
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          PATH: `${mockBin}:${process.env.PATH ?? ""}`,
+          DOCKER_LOG: dockerLog,
+        },
+      },
+    );
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(
+      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, /--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(join(destinationDeploy, "postgres"))) {
+      chmodSync(join(destinationDeploy, "postgres"), 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);
@@ -464,7 +526,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");
@@ -497,6 +559,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 },
@@ -511,7 +576,8 @@ test("public rectification rollout rewrites only rollout gates 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"),
   );
@@ -543,7 +609,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 });
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/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/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 6f119573..578d0e15 100644
--- a/scripts/rectification/scoring_service.py
+++ b/scripts/rectification/scoring_service.py
@@ -150,13 +150,27 @@ def score_from_matrix(request: RectificationRequest, built: dict[str, Any]) -> l
 
 
 def calculation_spec(request: RectificationRequest) -> dict[str, Any]:
-    return {
+    def json_number(value: float) -> int | float:
+        return int(value) if value.is_integer() else value
+
+    spec = {
         "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,
     }
+    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 68b08205..cc04463d 100644
--- a/skills/birth-time-rectification/SKILL.md
+++ b/skills/birth-time-rectification/SKILL.md
@@ -1,36 +1,87 @@
 ---
 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, 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
+
+- 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.
+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, 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.
+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.
+
+
+## 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/event-schema.md b/skills/birth-time-rectification/references/event-schema.md
index bdb6038a..9bdbea0c 100644
--- a/skills/birth-time-rectification/references/event-schema.md
+++ b/skills/birth-time-rectification/references/event-schema.md
@@ -1,3 +1,31 @@
 # 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.
+
+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`.
+- 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..d6e621f2 100644
--- a/skills/birth-time-rectification/references/failure-policy.md
+++ b/skills/birth-time-rectification/references/failure-policy.md
@@ -1,3 +1,37 @@
 # 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.
+
+- 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, 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 expose or persist raw VedAstro provider payloads in public output or the analysis receipt.
+
+
+## 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 95e57758..752055f7 100644
--- a/skills/birth-time-rectification/references/output-contract.md
+++ b/skills/birth-time-rectification/references/output-contract.md
@@ -1,3 +1,62 @@
 # 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, 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.
+
+## 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, 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/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..c88af13d 100644
--- a/skills/birth-time-rectification/references/question-policy.md
+++ b/skills/birth-time-rectification/references/question-policy.md
@@ -1,3 +1,48 @@
 # 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.
+
+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.
+- 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.
+- 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
+
+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..22b33b27 100644
--- a/skills/birth-time-rectification/references/technique-policy.md
+++ b/skills/birth-time-rectification/references/technique-policy.md
@@ -1,3 +1,51 @@
 # 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`, 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, 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.
+- 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.
+
+## 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.
+- 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.
+
+
+## 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.
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"]
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 76bd1224..2ed2bd5f 100644
--- a/tests/test_rectification_v5_services.py
+++ b/tests/test_rectification_v5_services.py
@@ -4,9 +4,16 @@ 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 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,
@@ -17,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,
@@ -38,6 +52,59 @@ 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_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))
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)