import { createHash } from "node:crypto";
import {
  conversationalRectificationCommandSchema,
  conversationalRectificationTurnSchema,
  type ConversationalRectificationCommand,
  type RectificationFollowUp,
  type ConversationalRectificationTurn,
} from "./contracts.ts";
import { ConversationalRectificationError } from "./errors.ts";
import { extractLifeEventEvidence } from "./evidence-extractor.ts";
import {
  declaredBirthInputSchema,
  privateCandidateSchema,
  validationReceiptSchema,
  type DeclaredBirthInput,
  type LifeEventEvidence,
  type PrivateCandidate,
  type ValidationReceipt,
} from "./persistence-contracts.ts";
import {
  generateRectificationNarrative,
  type RectificationConversationMessage,
  type RectificationNarrativeGenerator,
  type RectificationNarrativeResult,
} from "./narrative-agent.ts";
import {
  projectRectificationTechnicalPacket,
  type RectificationEvidenceDomain,
  type RectificationTechnicalPacket,
} from "./technical-packet.ts";
import {
  convergenceNotes,
  nextPlateauCount,
  shouldCompleteBoundedResult,
} from "./convergence.ts";
import { RECTIFICATION_POLICY } from "../rectification-policy.ts";
import type { ConversationalRectificationBilling } from "./billing.ts";
import {
  projectLegacyCaseForConversationalImport,
  type LegacyConversationalImportSource,
} from "./legacy-import.ts";
import type {
  ConversationalRectificationStore,
  LifeEventEvidenceInput,
  LoadedConversationalRectificationCase,
  PrivateCandidateInput,
  StoredConversationalRectificationCase,
} from "./store.ts";

type CommandOf<Type extends ConversationalRectificationCommand["type"]> = Extract<
  ConversationalRectificationCommand,
  { readonly type: Type }
>;

export type ComputedConversationalRectificationPacket = Readonly<{
  packet: RectificationTechnicalPacket;
  resultId: string | null;
}>;

export type ConversationalRectificationProfile = Readonly<{
  declaredBirthInput: unknown;
  revisionOfCaseId: string | null;
  legacyCaseId?: string | null;
}>;

export type ConversationalRectificationPacketBuildInput = Readonly<{
  userId: string;
  caseId: string;
  asOfDate: string;
  declaredBirthInput: DeclaredBirthInput;
  privateCandidate: PrivateCandidateInput | null;
  evidence: ReadonlyArray<LifeEventEvidenceInput>;
  preserveCandidateRange?: true;
}>;

export type ConversationalRectificationServicePorts = Readonly<{
  store: Pick<ConversationalRectificationStore,
    "createCaseWithFirstTurn" | "loadCase" | "loadActionReceipt" | "saveTurn" | "pause" | "abandon" | "confirm">
    & Partial<Pick<ConversationalRectificationStore, "importLegacy">>;
  billing: Pick<ConversationalRectificationBilling, "reserve" | "complete" | "release">;
  rectificationPriceCredits: number;
  allowNewCaseCreation?: boolean;
  loadDeclaredProfile(userId: string): Promise<ConversationalRectificationProfile>;
  loadLegacyCase?(
    userId: string,
    legacyCaseId: string,
  ): Promise<LegacyConversationalImportSource | null>;
  buildTechnicalPacket(
    input: ConversationalRectificationPacketBuildInput,
  ): Promise<ComputedConversationalRectificationPacket>;
  loadConversationMessages?(
    userId: string,
    caseId: string,
  ): Promise<ReadonlyArray<RectificationConversationMessage>>;
  narrativeGenerator: RectificationNarrativeGenerator;
  asOfDate(): string;
}>;

export type ConversationalRectificationService = Readonly<{
  importLegacyCase(
    userId: string,
    legacyCaseId: string,
    actionId: string,
    pendingConsultationQuestion?: string | null,
  ): Promise<ConversationalRectificationTurn>;
  start(userId: string, command: CommandOf<"start">): Promise<ConversationalRectificationTurn>;
  resume(userId: string, command: CommandOf<"resume">): Promise<ConversationalRectificationTurn>;
  answer(userId: string, command: CommandOf<"answer">): Promise<ConversationalRectificationTurn>;
  regenerate(userId: string, command: CommandOf<"regenerate">): Promise<ConversationalRectificationTurn>;
  pause(userId: string, command: CommandOf<"pause">): Promise<ConversationalRectificationTurn>;
  abandon(userId: string, command: CommandOf<"abandon">): Promise<ConversationalRectificationTurn>;
  confirm(userId: string, command: CommandOf<"confirm">): Promise<ConversationalRectificationTurn>;
}>;

export type ConversationalRectificationTelemetryOutcome = Readonly<{
  billingState: "not_applicable" | "charged" | "released" | "migration_waived" | "unchanged" | "unknown";
  caseStatus: ConversationalRectificationTurn["status"] | null;
}>;

const telemetryOutcomes = new WeakMap<
  ConversationalRectificationService,
  () => ConversationalRectificationTelemetryOutcome
>();

export function conversationalRectificationTelemetryOutcome(
  service: ConversationalRectificationService,
): ConversationalRectificationTelemetryOutcome | null {
  return telemetryOutcomes.get(service)?.() ?? null;
}

const transitionValidatorVersion = "conversational-rectification-orchestrator-v1";
const explicitDirectionChangePattern = /(?:都不符合|都不是|不符合|换(?:个|一)?(?:方向|领域)|其他方向|别的方向|不想(?:谈|说|回答)|拒绝回答)/;
const genericUncertaintyPattern = /(?:不知道|不确定)/;
const contextualRelativeMonthPattern = /(?:来年|次年|第二年|翌年|同年|当年|那年)\s*(\d{1,2})\s*月份?/;
const contextualBareMonthDayPattern = /^\s*(\d{1,2})\s*月\s*(\d{1,2})\s*(?:日|号)\s*[。.]?\s*$/;
const contextualBareDayPattern = /^\s*(\d{1,2})\s*(?:日|号)\s*[。.]?\s*$/;
const affirmativeAnswerPattern = /^\s*(?:是(?:的)?|对(?:的)?|没错|正确|确认|就是|嗯+|没问题)\s*[。.!！,，]?\s*$/u;
const negativeAnswerPattern = /^\s*(?:不是|不对|错了|并不是|否)\s*[。.!！,，]?\s*$/u;

export function evidencePredatesBirthDate(
  evidence: Pick<LifeEventEvidence, "dateValue" | "datePrecision">,
  birthDate: string,
): boolean {
  if (!evidence.dateValue) return false;
  const boundary = evidence.datePrecision === "year"
    ? birthDate.slice(0, 4)
    : evidence.datePrecision === "month"
      ? birthDate.slice(0, 7)
      : evidence.datePrecision === "day"
        ? birthDate
        : null;
  return boundary !== null && evidence.dateValue < boundary;
}

function evidencePostdatesAsOfDate(
  evidence: Pick<LifeEventEvidence, "dateValue" | "datePrecision">,
  asOfDate: string,
): boolean {
  if (!evidence.dateValue) return false;
  const boundary = evidence.datePrecision === "year"
    ? asOfDate.slice(0, 4)
    : evidence.datePrecision === "month"
      ? asOfDate.slice(0, 7)
      : evidence.datePrecision === "day"
        ? asOfDate
        : null;
  return boundary !== null && evidence.dateValue > boundary;
}

function evidenceForDeclaredBirthDate(
  evidence: readonly LifeEventEvidence[],
  birthDate: string,
): readonly LifeEventEvidence[] {
  return evidence.map((item) => item.scoreable === true
    && evidencePredatesBirthDate(item, birthDate)
    ? { ...item, extractionStatus: "needs_clarification" as const, scoreable: false }
    : item);
}

function safeFailure(error: unknown): ConversationalRectificationError {
  return error instanceof ConversationalRectificationError
    ? error
    : new ConversationalRectificationError("service_unavailable");
}

function parseCommand<Type extends ConversationalRectificationCommand["type"]>(
  type: Type,
  value: unknown,
): CommandOf<Type> {
  const parsed = conversationalRectificationCommandSchema.safeParse(value);
  if (!parsed.success || parsed.data.type !== type) {
    throw new ConversationalRectificationError("invalid_command");
  }
  return parsed.data as CommandOf<Type>;
}

type MutableCommand = Extract<ConversationalRectificationCommand, {
  readonly type: "answer" | "regenerate" | "pause" | "abandon" | "confirm";
}>;

function commandFingerprint(command: MutableCommand): string {
  const identity = command.type === "answer"
    ? [command.type, command.caseId, command.actionId, command.turnVersion,
        command.domain ?? null, command.answer, command.correctsEvidenceId ?? null]
    : command.type === "confirm"
      ? [command.type, command.caseId, command.actionId, command.turnVersion, command.time]
      : [command.type, command.caseId, command.actionId, command.turnVersion];
  return createHash("sha256").update(JSON.stringify(identity), "utf8").digest("hex");
}

function sameDeclaredBirthInput(
  left: unknown,
  right: unknown,
): boolean {
  const leftParsed = declaredBirthInputSchema.safeParse(left);
  const rightParsed = declaredBirthInputSchema.safeParse(right);
  return leftParsed.success
    && rightParsed.success
    && stableJson(leftParsed.data) === stableJson(rightParsed.data);
}

function stableJson(value: unknown): string {
  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
  if (value !== null && typeof value === "object") {
    return `{${Object.entries(value as Record<string, unknown>)
      .sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey))
      .map(([key, nested]) => `${JSON.stringify(key)}:${stableJson(nested)}`)
      .join(",")}}`;
  }
  return JSON.stringify(value);
}

function visibleEvidenceSummary(value: string): string {
  const cleaned = value.replace(/(?:发生时间|事件详情)\s*[:：]\s*/g, "").trim();
  return cleaned || value;
}

function publicTurn(value: StoredConversationalRectificationCase): ConversationalRectificationTurn {
  const parsed = conversationalRectificationTurnSchema.safeParse(value.latestTurn);
  if (!parsed.success) throw new ConversationalRectificationError("store_unavailable");
  const evidenceDomains = new Map(
    effectiveLifeEventEvidence(value.eventEvidence ?? []).map((item) => [item.id, item.domain]),
  );
  return {
    ...parsed.data,
    evidenceRecap: parsed.data.evidenceRecap.map((item) => ({
      ...item,
      summary: visibleEvidenceSummary(item.summary),
      ...(item.domain ? {} : evidenceDomains.get(item.id)
        ? { domain: evidenceDomains.get(item.id) }
        : {}),
    })),
  };
}

function transitionReceipt(modelId = "deterministic-rectification-transition"): ValidationReceipt {
  return validationReceiptSchema.parse({
    modelId,
    schemaValidated: true,
    validatorVersion: transitionValidatorVersion,
    retryCount: 0,
    fallbackUsed: false,
    issues: [],
  });
}

function latestReceipt(value: LoadedConversationalRectificationCase): ValidationReceipt {
  const receipt = value.validationReceipts.at(-1);
  const parsed = validationReceiptSchema.safeParse(receipt);
  if (!parsed.success) throw new ConversationalRectificationError("store_unavailable");
  return parsed.data;
}

export function effectiveLifeEventEvidence<
  Evidence extends Readonly<{
    id: string;
    correctsEvidenceIds?: readonly string[];
  }>,
>(evidence: ReadonlyArray<Evidence>): ReadonlyArray<Evidence> {
  const correctedIds = new Set<string>();
  for (const item of evidence) {
    for (const correctedId of item.correctsEvidenceIds ?? []) correctedIds.add(correctedId);
  }
  return evidence.filter((item) => !correctedIds.has(item.id));
}

function normalizedEventSemantics(value: string): string {
  return value
    .normalize("NFKC")
    .toLocaleLowerCase("zh-CN")
    .replace(/^(?:我|本人|其实|准确(?:的是)?|更正(?:为|成|：|:)*)+/u, "")
    .replace(/[\p{P}\p{S}\s]+/gu, "");
}

const scoringEvidenceDomains = new Set<RectificationEvidenceDomain>([
  "career",
  "education",
  "finance",
  "health_pressure",
  "relocation",
  "relationship",
]);

function hasScoringEvidenceDomain(item: Pick<LifeEventEvidenceInput, "domain">): boolean {
  return scoringEvidenceDomains.has(item.domain);
}

function uniqueScoreableLifeEventEvidence(
  evidence: ReadonlyArray<LifeEventEvidenceInput>,
  birthDate: string,
): ReadonlyArray<LifeEventEvidenceInput> {
  const seen = new Set<string>();
  return effectiveLifeEventEvidence(evidence)
    .filter((item) => item.scoreable === true
      && hasScoringEvidenceDomain(item)
      && item.extractionStatus !== "needs_clarification"
      && !evidencePredatesBirthDate(item, birthDate))
    .filter((item) => {
      const identity = [
        item.dateValue ?? "",
        item.domain,
        normalizedEventSemantics(item.eventSummary),
      ].join("|");
      if (seen.has(identity)) return false;
      seen.add(identity);
      return true;
    });
}

function evidenceRecap(evidence: ReadonlyArray<LifeEventEvidenceInput>) {
  return effectiveLifeEventEvidence(evidence).slice(-20).map((item) => ({
    id: item.id,
    summary: visibleEvidenceSummary(item.eventSummary),
    dateLabel: item.dateValue
      ? item.scoreable === false && item.extractionStatus !== "needs_clarification"
        ? `${item.dateValue}（未来，仅作背景）`
        : item.dateValue
      : "日期待补充",
    domain: item.domain,
    ...((item.correctsEvidenceIds?.length ?? 0) > 0 ? { isCorrection: true } : {}),
  }));
}

function narrativeConversationContext(input: Readonly<{
  recentConversation?: ReadonlyArray<RectificationConversationMessage>;
  latestUserText: string;
  previousAssistantNarrative?: string;
  previousEvidencePrompt?: string;
  previousFollowUp?: RectificationFollowUp;
  allEvidence: ReadonlyArray<LifeEventEvidenceInput>;
  newEvidence: ReadonlyArray<LifeEventEvidenceInput>;
}>) {
  const activeEvidence = effectiveLifeEventEvidence(input.allEvidence);
  const activeIds = new Set(activeEvidence.map((item) => item.id));
  return {
    recentConversation: input.recentConversation,
    latestUserText: input.latestUserText.trim().slice(0, 4_000),
    previousAssistantNarrative: input.previousAssistantNarrative,
    previousEvidencePrompt: input.previousEvidencePrompt,
    previousFollowUp: input.previousFollowUp,
    latestEvidence: evidenceRecap(input.newEvidence).map((item) => ({
      id: item.id,
      dateLabel: item.dateLabel,
      summary: item.summary,
      domain: item.domain,
    })),
    eventLedger: input.allEvidence.slice(-40).map((item) => ({
      id: item.id,
      rawText: item.rawText,
      dateLabel: item.dateValue ?? "日期待补充",
      summary: visibleEvidenceSummary(item.eventSummary),
      domain: item.domain,
      extractionStatus: item.extractionStatus,
      active: activeIds.has(item.id),
      correctsEvidenceIds: [...(item.correctsEvidenceIds ?? [])],
    })),
    unresolvedEvidence: activeEvidence
      .filter((item) => item.extractionStatus === "needs_clarification")
      .slice(-20)
      .map((item) => ({
        id: item.id,
        rawText: item.rawText,
        summary: visibleEvidenceSummary(item.eventSummary),
        domain: item.domain,
        dateLabel: item.dateValue ?? "日期待补充",
      })),
  };
}

function exactTechnicalReceipt(packet: RectificationTechnicalPacket) {
  const projected = projectRectificationTechnicalPacket(packet);
  return {
    calculationVersion: projected.technicalReceipt.calculationVersion,
    stableLayers: projected.technicalReceipt.stableLayers,
    sensitiveLayers: projected.technicalReceipt.sensitiveLayers,
    candidateDifferenceRefs: projected.technicalReceipt.candidateDifferenceRefs,
  };
}

function actionsFor(status: "active" | "confirming") {
  if (status === "confirming") {
    return ["answer", "pause", "abandon", "confirm"] as const;
  }
  return ["answer", "pause", "abandon"] as const;
}

function confirmationGatedPacket(
  packet: RectificationTechnicalPacket,
  scoreableEventCount: number,
  scoreableDomainCount: number,
): RectificationTechnicalPacket {
  if (packet.candidate.status !== "ready_for_confirmation"
    || (scoreableEventCount >= RECTIFICATION_POLICY.minConfirmationEvents
      && scoreableDomainCount >= RECTIFICATION_POLICY.minConfirmationDomains)) return packet;
  return {
    ...packet,
    candidate: { ...packet.candidate, status: "pending_validation" },
    useBoundary: `当前候选仍需至少 ${RECTIFICATION_POLICY.minConfirmationEvents} 条时间明确、覆盖 ${RECTIFICATION_POLICY.minConfirmationDomains} 个领域的真实经历验证，不能作为已经校正完成的出生分钟。`,
  };
}

function scoreableDomains(
  evidence: ReadonlyArray<LifeEventEvidenceInput>,
): Set<RectificationEvidenceDomain> {
  return new Set(evidence.map((item) => item.domain));
}

function turnFromNarrative(input: {
  readonly caseId: string;
  readonly turnVersion: number;
  readonly pendingConsultationQuestion: string | null;
  readonly packet: RectificationTechnicalPacket;
  readonly narrative: RectificationNarrativeResult;
  readonly evidence: ReadonlyArray<LifeEventEvidenceInput>;
}): ConversationalRectificationTurn {
  const projected = projectRectificationTechnicalPacket(input.packet);
  const status = projected.candidate.status === "ready_for_confirmation" ? "confirming" : "active";
  const evidenceRequest = input.narrative.output.evidenceRequest
    ? {
        domains: input.narrative.output.evidenceRequest.domains,
        datePrecision: input.narrative.output.evidenceRequest.datePrecision,
        freeTextAllowed: true as const,
        prompt: input.narrative.output.evidenceRequest.prompt,
        followUp: input.narrative.output.evidenceRequest.followUp,
      }
    : null;
  const candidate = {
    status: projected.candidate.status,
    representativeTime: projected.candidate.representativeTime,
    rangeStart: projected.candidate.rangeStart,
    rangeEnd: projected.candidate.rangeEnd,
  };
  const parsed = conversationalRectificationTurnSchema.safeParse({
    caseId: input.caseId,
    journeyProtocol: "conversational-evidence-v3",
    status,
    turnVersion: input.turnVersion,
    narrative: input.narrative.narrative,
    candidate,
    technicalReceipt: exactTechnicalReceipt(input.packet),
    evidenceRequest,
    evidenceRecap: evidenceRecap(input.evidence),
    actions: actionsFor(status),
    pendingConsultationQuestion: input.pendingConsultationQuestion,
  });
  if (!parsed.success) throw new ConversationalRectificationError("service_unavailable");
  return parsed.data;
}

function boundedResultTurn(
  input: Parameters<typeof turnFromNarrative>[0],
): ConversationalRectificationTurn {
  const turn = turnFromNarrative(input);
  return conversationalRectificationTurnSchema.parse({
    ...turn,
    status: "completed",
    candidate: { ...turn.candidate, status: "pending_validation" },
    evidenceRequest: null,
    actions: turn.pendingConsultationQuestion ? ["continue_original_question"] : [],
  });
}

function privateCandidateFromPacket(input: {
  readonly packet: RectificationTechnicalPacket;
  readonly resultId: string | null;
  readonly iteration: number;
  readonly forceCollecting?: boolean;
  readonly notes?: readonly string[];
}): PrivateCandidate {
  const packet = input.packet;
  const parsed = privateCandidateSchema.safeParse({
    resultId: input.resultId,
    representativeTime: packet.candidate.representativeTime,
    rangeStart: packet.candidate.range.startTime,
    rangeEnd: packet.candidate.range.endTime,
    calculationVersion: packet.calculationVersion,
    candidateWeights: Object.entries(packet.candidateWeights)
      .sort(([left], [right]) => left.localeCompare(right))
      .map(([, weight]) => weight),
    candidateModelRefs: packet.candidateModelRefs,
    d1Stability: packet.d1Stability,
    boundaryDistanceMinutes: packet.boundaryDistanceMinutes,
    supportedSensitiveLayers: packet.supportedSensitiveLayers,
    scoredHistoricalEvidence: packet.scoredHistoricalEvidence,
    suggestedDomains: packet.suggestedDomains.map((item) => item.domain),
    futureWindows: packet.futureWindows,
    workingState: {
      phase: input.forceCollecting
        ? "collecting_evidence"
        : packet.candidate.status === "ready_for_confirmation" ? "ready" : "collecting_evidence",
      iteration: input.iteration,
      notes: [...(input.notes ?? [])],
    },
  });
  if (!parsed.success) throw new ConversationalRectificationError("service_unavailable");
  return parsed.data;
}

function changedTurn(input: {
  readonly current: LoadedConversationalRectificationCase;
  readonly status: "paused" | "abandoned" | "completed";
  readonly narrative: string;
  readonly receipt?: ValidationReceipt;
}): { readonly turn: ConversationalRectificationTurn; readonly receipt: ValidationReceipt } {
  const current = input.current.latestTurn;
  const actions = input.status === "paused"
    ? ["answer", "abandon"]
    : input.status === "completed" && current.pendingConsultationQuestion
      ? ["continue_original_question"]
      : [];
  const candidate = input.status === "completed"
    ? { ...current.candidate, status: "confirmed" as const }
    : current.candidate;
  const parsed = conversationalRectificationTurnSchema.safeParse({
    ...current,
    status: input.status,
    turnVersion: input.current.turnVersion + 1,
    narrative: input.narrative,
    candidate,
    evidenceRequest: input.status === "completed" ? null : current.evidenceRequest,
    actions,
  });
  if (!parsed.success) throw new ConversationalRectificationError("service_unavailable");
  return { turn: parsed.data, receipt: input.receipt ?? transitionReceipt() };
}

function midpointOfRange(range: Readonly<{ startTime: string; endTime: string }>): string {
  const minute = (value: string) => {
    const [hour = 0, part = 0] = value.split(":").map(Number);
    return hour * 60 + part;
  };
  const clock = (value: number) => {
    const normalized = ((value % 1_440) + 1_440) % 1_440;
    return `${String(Math.floor(normalized / 60)).padStart(2, "0")}:${String(normalized % 60).padStart(2, "0")}`;
  };
  const start = minute(range.startTime);
  let end = minute(range.endTime);
  if (end < start) end += 1_440;
  return clock(Math.round((start + end) / 2));
}

type CorrectionResetReason =
  | "needs_clarification"
  | "non_scoreable"
  | "direction_change";

function nonScoringTurn(input: {
  readonly current: LoadedConversationalRectificationCase;
  readonly newEvidence: ReadonlyArray<LifeEventEvidenceInput>;
  readonly latestUserText: string;
  readonly authoredNarrative?: RectificationNarrativeResult | null;
  readonly followUpOverride?: RectificationFollowUp;
  readonly correctionReset?: Readonly<{
    packet: RectificationTechnicalPacket;
    reason: CorrectionResetReason;
  }>;
}): { readonly turn: ConversationalRectificationTurn; readonly receipt: ValidationReceipt } {
  const allEvidence = [...input.current.eventEvidence, ...input.newEvidence];
  const latestIncomplete = input.newEvidence
    .filter((item) => item.extractionStatus === "needs_clarification")
    .at(-1);
  const authoredNarrative = input.authoredNarrative;
  const latestSummary = input.newEvidence.at(-1)?.eventSummary;
  const fallbackSubject = latestSummary && latestSummary !== "事件内容待补充"
    ? latestSummary
    : input.latestUserText.trim().slice(0, 80);
  const narrative = authoredNarrative?.narrative
    ?? `我收到了你这轮关于“${fallbackSubject || "这段经历"}”的补充，但这次分析暂时没有完成。内容会保留，你可以继续补充它的时间和经过，或直接说下一件已经发生的经历。`;
  const status = input.correctionReset
    ? "active" as const
    : input.current.status === "confirming" ? "confirming" as const : "active" as const;
  const actions = actionsFor(status);
  const clarificationFollowUp = latestIncomplete?.dateValue === null
    && latestIncomplete.eventSummary !== "事件内容待补充"
    ? { kind: "event_date" as const, evidenceId: latestIncomplete.id }
    : latestIncomplete?.dateValue
      && latestIncomplete.eventSummary === "事件内容待补充"
      ? { kind: "event_detail" as const, evidenceId: latestIncomplete.id }
      : null;
    const authoredRequest = authoredNarrative?.output.evidenceRequest;
    const priorRequest = input.current.latestTurn.evidenceRequest;
  const evidenceRequest = status === "confirming" && priorRequest === null
    ? null
    : authoredRequest
      ? {
          domains: authoredRequest.domains,
          datePrecision: authoredRequest.datePrecision,
          freeTextAllowed: true as const,
          prompt: authoredRequest.prompt,
          followUp: input.followUpOverride ?? authoredRequest.followUp,
        }
      : priorRequest
        ? {
            ...priorRequest,
            followUp: input.followUpOverride ?? clarificationFollowUp ?? priorRequest.followUp,
          }
        : null;
  const parsed = conversationalRectificationTurnSchema.safeParse({
    ...input.current.latestTurn,
    status,
    turnVersion: input.current.turnVersion + 1,
    narrative,
    evidenceRequest,
    evidenceRecap: evidenceRecap(allEvidence),
    actions,
    ...(input.correctionReset ? {
      candidate: {
        ...projectRectificationTechnicalPacket(input.correctionReset.packet).candidate,
        status: "pending_validation" as const,
      },
      technicalReceipt: exactTechnicalReceipt(input.correctionReset.packet),
    } : {}),
  });
  if (!parsed.success) throw new ConversationalRectificationError("service_unavailable");
  return {
    turn: parsed.data,
    receipt: authoredNarrative
      ? validationReceiptSchema.parse(authoredNarrative.validationReceipt)
      : validationReceiptSchema.parse({
          modelId: "deterministic-evidence-failure-continuation",
          schemaValidated: false,
          validatorVersion: transitionValidatorVersion,
          retryCount: 0,
          fallbackUsed: true,
          issues: ["technical_or_narrative_generation_failed"],
        }),
  };
}

function requireLoaded(
  value: LoadedConversationalRectificationCase | null,
): LoadedConversationalRectificationCase {
  if (!value) throw new ConversationalRectificationError("case_not_found");
  return value;
}

function requireExactVersion(current: LoadedConversationalRectificationCase, expected: number) {
  if (current.turnVersion !== expected) throw new ConversationalRectificationError("stale_turn");
}

function requireMutable(current: LoadedConversationalRectificationCase) {
  if (!(["active", "paused", "confirming"] as const).includes(
    current.status as "active" | "paused" | "confirming",
  )) {
    throw new ConversationalRectificationError("invalid_transition");
  }
}

export function createConversationalRectificationService(
  ports: ConversationalRectificationServicePorts,
): ConversationalRectificationService {
  let lastTelemetryOutcome: ConversationalRectificationTelemetryOutcome = {
    billingState: "not_applicable",
    caseStatus: null,
  };
  function resetTelemetryOutcome() {
    lastTelemetryOutcome = { billingState: "not_applicable", caseStatus: null };
  }
  function observeCase(
    value: LoadedConversationalRectificationCase | StoredConversationalRectificationCase,
    billingState: ConversationalRectificationTelemetryOutcome["billingState"] = "unchanged",
  ) {
    lastTelemetryOutcome = { billingState, caseStatus: publicTurn(value).status };
  }

  async function load(userId: string, caseId: string) {
    try {
      const current = requireLoaded(await ports.store.loadCase({ userId, caseId }));
      observeCase(current);
      return current;
    } catch (error) {
      throw safeFailure(error);
    }
  }

  async function replayMutation(
    userId: string,
    command: MutableCommand,
    actionKind: "save_turn" | "pause" | "abandon" | "confirm",
    fingerprint: string,
  ): Promise<ConversationalRectificationTurn | null> {
    try {
      const receipt = await ports.store.loadActionReceipt({
        userId,
        caseId: command.caseId,
        expectedVersion: command.turnVersion,
        actionId: command.actionId,
        actionKind,
        commandFingerprint: fingerprint,
      });
      if (!receipt) return null;
      observeCase(receipt);
      return publicTurn(receipt);
    } catch (error) {
      throw safeFailure(error);
    }
  }

  async function importLegacyCase(
    userId: string,
    legacyCaseId: string,
    actionId: string,
    pendingConsultationQuestion: string | null = null,
  ): Promise<ConversationalRectificationTurn> {
    resetTelemetryOutcome();
    const importer = ports.store.importLegacy;
    const loadLegacy = ports.loadLegacyCase;
    if (!importer || !loadLegacy) {
      throw new ConversationalRectificationError("service_unavailable");
    }

    try {
      const existingByAction = await ports.store.loadCase({ userId, caseId: actionId });
      if (existingByAction) {
        observeCase(existingByAction);
        if (existingByAction.importedFromCaseId !== legacyCaseId
          || existingByAction.billingState !== "migration_waived"
          || existingByAction.pendingConsultationQuestion !== pendingConsultationQuestion) {
          throw new ConversationalRectificationError("action_conflict");
        }
        return publicTurn(existingByAction);
      }
      const current = await ports.store.loadCase({ userId });
      if (current?.importedFromCaseId === legacyCaseId
        && current.billingState === "migration_waived"
        && current.pendingConsultationQuestion === pendingConsultationQuestion) {
        observeCase(current);
        return publicTurn(current);
      }
      if (current?.importedFromCaseId === legacyCaseId
        && current.billingState === "migration_waived") {
        throw new ConversationalRectificationError("action_conflict");
      }
      if (ports.allowNewCaseCreation === false) {
        throw new ConversationalRectificationError("service_unavailable");
      }

      const legacy = await loadLegacy(userId, legacyCaseId);
      if (!legacy) throw new ConversationalRectificationError("case_not_found");
      const projected = projectLegacyCaseForConversationalImport({
        source: legacy,
        asOfDate: ports.asOfDate(),
        expectedUserId: userId,
      });
      const rangeSeed = privateCandidateSchema.parse({
        resultId: null,
        representativeTime: midpointOfRange(projected.currentRange),
        rangeStart: projected.currentRange.startTime,
        rangeEnd: projected.currentRange.endTime,
        calculationVersion: "legacy-import-range-v1",
        workingState: { phase: "collecting_evidence", iteration: 0, notes: [] },
      });
      const computed = await ports.buildTechnicalPacket({
        userId,
        caseId: actionId,
        asOfDate: ports.asOfDate(),
        declaredBirthInput: projected.declaredBirthInput,
        privateCandidate: rangeSeed,
        evidence: projected.evidence,
        preserveCandidateRange: true,
      });
      const gatedPacket = confirmationGatedPacket(computed.packet, 0, 0);
      const narrative = await generateRectificationNarrative({
        phase: "first",
        packet: gatedPacket,
        generator: ports.narrativeGenerator,
      });
      const privateCandidate = privateCandidateFromPacket({
        packet: gatedPacket,
        resultId: null,
        iteration: 0,
        forceCollecting: true,
      });
      const firstTurn = turnFromNarrative({
        caseId: actionId,
        turnVersion: 0,
        pendingConsultationQuestion,
        packet: gatedPacket,
        narrative,
        evidence: projected.evidence,
      });
      const imported = await importer.call(ports.store, {
        userId,
        caseId: actionId,
        expectedVersion: projected.expectedVersion,
        actionId,
        legacyCaseId,
        price: ports.rectificationPriceCredits,
        pendingConsultationQuestion,
        declaredBirthInput: projected.declaredBirthInput,
        evidence: projected.evidence,
        firstTurn,
        validationReceipt: narrative.validationReceipt,
        privateCandidate,
      });
      observeCase(imported, "migration_waived");
      return publicTurn(imported);
    } catch (error) {
      if (error instanceof ConversationalRectificationError
        && error.code === "action_conflict") {
        try {
          const winner = await ports.store.loadCase({ userId });
          if (winner?.importedFromCaseId === legacyCaseId
            && winner.billingState === "migration_waived"
            && winner.pendingConsultationQuestion === pendingConsultationQuestion) {
            observeCase(winner);
            return publicTurn(winner);
          }
        } catch {
          // Preserve the original stable conflict below.
        }
      }
      throw safeFailure(error);
    }
  }

  function contextualizedAnswer(
    command: CommandOf<"answer">,
    current: LoadedConversationalRectificationCase,
  ): string {
    const followUp = current.latestTurn.evidenceRequest?.followUp;
    if (followUp?.kind !== "event_date" && followUp?.kind !== "event_detail") {
      return command.answer;
    }
    const activeEvidence = effectiveLifeEventEvidence(current.eventEvidence);
    const target = followUp.evidenceId
      ? activeEvidence.find((item) => item.id === followUp.evidenceId)
      : null;
    const anchor = target?.dateValue
      ? target
      : activeEvidence.filter((item) => item.dateValue !== null).at(-1);
    const anchorYear = Number(anchor?.dateValue?.slice(0, 4));
    if (!Number.isInteger(anchorYear)) return command.answer;

    const bareMonthDay = followUp.kind === "event_date"
      ? command.answer.match(contextualBareMonthDayPattern)
      : null;
    if (bareMonthDay) {
      return `${anchorYear}年${Number(bareMonthDay[1])}月${Number(bareMonthDay[2])}号`;
    }
    const bareDay = followUp.kind === "event_date"
      ? command.answer.match(contextualBareDayPattern)
      : null;
    const anchorMonth = Number(anchor?.dateValue?.slice(5, 7));
    if (bareDay && Number.isInteger(anchorMonth)) {
      return `${anchorYear}年${anchorMonth}月${Number(bareDay[1])}号`;
    }

    const match = command.answer.match(contextualRelativeMonthPattern);
    if (!match) return command.answer;
    const month = Number(match[1]);
    if (month < 1 || month > 12) return command.answer;
    const sameYear = /(?:同年|当年|那年)/.test(match[0]);
    return command.answer.replace(match[0], `${sameYear ? anchorYear : anchorYear + 1}年${month}月`);
  }

  async function conversationContext(input: Readonly<{
    userId: string;
    current: LoadedConversationalRectificationCase;
    latestUserText: string;
    allEvidence: ReadonlyArray<LifeEventEvidenceInput>;
    newEvidence: ReadonlyArray<LifeEventEvidenceInput>;
  }>) {
    let recentConversation: ReadonlyArray<RectificationConversationMessage> = [{
      role: "assistant",
      text: input.current.latestTurn.narrative,
    }];
    if (ports.loadConversationMessages) {
      try {
        const loaded = await ports.loadConversationMessages(input.userId, input.current.caseId);
        if (loaded.length > 0) recentConversation = loaded;
      } catch {
        // Conversation history improves continuity but must not make a turn unavailable.
      }
    }
    return narrativeConversationContext({
      recentConversation: [...recentConversation, { role: "user", text: input.latestUserText }],
      latestUserText: input.latestUserText,
      previousAssistantNarrative: input.current.latestTurn.narrative,
      previousEvidencePrompt: input.current.latestTurn.evidenceRequest?.prompt,
      previousFollowUp: input.current.latestTurn.evidenceRequest?.followUp,
      allEvidence: input.allEvidence,
      newEvidence: input.newEvidence,
    });
  }

  type StructuredFollowUpResolution =
    | Readonly<{ kind: "confirmed"; evidence: readonly LifeEventEvidence[] }>
    | Readonly<{ kind: "rejected"; evidence: readonly []; followUp: RectificationFollowUp }>
    | null;

  function resolveStructuredFollowUp(
    command: CommandOf<"answer">,
    current: LoadedConversationalRectificationCase,
  ): StructuredFollowUpResolution {
    const followUp = current.latestTurn.evidenceRequest?.followUp;
    if (followUp?.kind !== "event_date"
      || followUp.answerMode !== "yes_no"
      || !followUp.evidenceId
      || !followUp.proposedDate) {
      return null;
    }
    const target = effectiveLifeEventEvidence(current.eventEvidence)
      .find((item) => item.id === followUp.evidenceId);
    if (!target) return null;

    if (negativeAnswerPattern.test(command.answer)) {
      return {
        kind: "rejected",
        evidence: [],
        followUp: {
          kind: "event_date",
          evidenceId: target.id,
          answerMode: "free_text",
          proposedDate: null,
        },
      };
    }
    if (!affirmativeAnswerPattern.test(command.answer)) return null;

    const merged = extractLifeEventEvidence({
      rawText: `${followUp.proposedDate.value} ${target.eventSummary}`,
      sourceTurnId: command.actionId,
      asOfDate: ports.asOfDate(),
      correctsEvidenceId: target.id,
    });
    if (merged.length !== 1) return null;
    return {
      kind: "confirmed",
      evidence: merged.map((item) => ({
        ...item,
        rawText: `${target.rawText}\n确认：${command.answer}`,
        eventSummary: target.eventSummary,
        domain: target.domain,
        correctsEvidenceIds: [target.id],
      })),
    };
  }

  async function extractedEvidence(
    command: CommandOf<"answer">,
    current: LoadedConversationalRectificationCase,
  ): Promise<readonly LifeEventEvidence[]> {
    let extracted: readonly LifeEventEvidence[];
    try {
      const answerForExtraction = contextualizedAnswer(command, current);
      if ((affirmativeAnswerPattern.test(command.answer) || negativeAnswerPattern.test(command.answer))
        && answerForExtraction === command.answer) {
        return [];
      }
      extracted = extractLifeEventEvidence({
        rawText: answerForExtraction,
        sourceTurnId: command.actionId,
        asOfDate: ports.asOfDate(),
        correctsEvidenceId: command.correctsEvidenceId,
      }).map((item) => ({
        ...item,
        rawText: command.answer,
        correctsEvidenceIds: [...item.correctsEvidenceIds],
        domain: item.domain === "other" && command.domain && command.domain !== "other"
          ? command.domain
          : item.domain,
      }));
    } catch {
      throw new ConversationalRectificationError("invalid_command");
    }
    if (extracted.length > 20) throw new ConversationalRectificationError("invalid_command");
    if (command.correctsEvidenceId && extracted.length !== 1) {
      throw new ConversationalRectificationError("invalid_command");
    }
    const ambiguous = extracted.length === 1 && extracted[0]?.domain === "other"
      ? extracted[0]
      : null;
    if (ambiguous && ports.narrativeGenerator.classifyEvidenceDomain) {
      try {
        const domain = await ports.narrativeGenerator.classifyEvidenceDomain({
          text: command.answer,
          recentEvidence: effectiveLifeEventEvidence(current.eventEvidence).slice(-6).map((item) => ({
            summary: item.eventSummary,
            domain: item.domain,
          })),
        }, { signal: AbortSignal.timeout(8_000) });
        if (domain && domain !== "other") {
          return [{ ...ambiguous, domain }];
        }
      } catch {
        // Semantic classification is advisory. Keep the deterministic fallback
        // instead of blocking the user's event when the model is unavailable.
      }
    }
    return extracted;
  }

  function completeLatestClarification(input: Readonly<{
    command: CommandOf<"answer">;
    current: LoadedConversationalRectificationCase;
    extracted: readonly LifeEventEvidence[];
  }>): readonly LifeEventEvidence[] {
    if (input.command.correctsEvidenceId || input.extracted.length !== 1) return input.extracted;
    const activeEvidence = effectiveLifeEventEvidence(input.current.eventEvidence);
    const declaredFollowUp = input.current.latestTurn.evidenceRequest?.followUp;
    const supplied = input.extracted[0];
    if (declaredFollowUp?.kind === "new_event") return input.extracted;
    const followUp = declaredFollowUp;
    const pending = followUp?.evidenceId
      ? activeEvidence.find((item) => item.id === followUp.evidenceId)
      : activeEvidence.filter((item) => item.extractionStatus === "needs_clarification").at(-1);
    if (!pending || !supplied) return input.extracted;

    const pendingHasSummary = pending.eventSummary !== "事件内容待补充";
    const suppliedHasSummary = supplied.eventSummary !== "事件内容待补充";
    const suppliedMatchesPending = !suppliedHasSummary
      || supplied.domain === "other"
      || supplied.domain === pending.domain;
    const fillsMissingDate = followUp?.kind !== "event_detail"
      && pending.dateValue === null
      && supplied.dateValue !== null
      && !evidencePostdatesAsOfDate(supplied, ports.asOfDate())
      && pendingHasSummary
      && suppliedMatchesPending;
    const refinesKnownDate = followUp?.kind === "event_date"
      && pending.dateValue !== null
      && supplied.dateValue !== null
      && supplied.dateValue.startsWith(`${pending.dateValue}-`)
      && !evidencePostdatesAsOfDate(supplied, ports.asOfDate())
      && pendingHasSummary
      && suppliedMatchesPending;
    const fillsMissingSummary = followUp?.kind !== "event_date"
      && pending.dateValue !== null
      && supplied.dateValue === null
      && !pendingHasSummary
      && suppliedHasSummary;
    const addsEventDetail = followUp?.kind === "event_detail"
      && pending.dateValue !== null
      && suppliedHasSummary
      && (supplied.dateValue === null || supplied.dateValue === pending.dateValue);
    if (!fillsMissingDate && !refinesKnownDate && !fillsMissingSummary && !addsEventDetail) {
      return input.extracted;
    }

    const dateValue = supplied.dateValue ?? pending.dateValue;
    const summary = fillsMissingDate || refinesKnownDate
      ? pending.eventSummary
      : addsEventDetail
      ? [...new Set([pending.eventSummary, supplied.eventSummary])].join("；")
      : suppliedHasSummary ? supplied.eventSummary : pending.eventSummary;
    if (!dateValue || summary === "事件内容待补充") return input.extracted;
    // Re-parse the original event as one dated sentence. Detail replies may
    // contain punctuation that the extractor treats as separate boundaries;
    // apply the composed summary after deriving the single event metadata.
    const merged = extractLifeEventEvidence({
      rawText: `${dateValue} ${pending.eventSummary}`,
      sourceTurnId: input.command.actionId,
      asOfDate: ports.asOfDate(),
      correctsEvidenceId: pending.id,
    });
    if (merged.length !== 1) return input.extracted;
    return merged.map((item) => ({
      ...item,
      rawText: `${pending.rawText}\n补充：${input.command.answer}`,
      eventSummary: summary,
      domain: pending.domain === "other" ? item.domain : pending.domain,
      correctsEvidenceIds: [...item.correctsEvidenceIds],
    }));
  }

  const service: ConversationalRectificationService = Object.freeze({
    importLegacyCase,
    async start(userId, rawCommand) {
      resetTelemetryOutcome();
      const command = parseCommand("start", rawCommand);
      let profile: ConversationalRectificationProfile;
      try {
        profile = await ports.loadDeclaredProfile(userId);
      } catch (error) {
        throw safeFailure(error);
      }
      const declared = declaredBirthInputSchema.safeParse(profile.declaredBirthInput);
      if (!declared.success) throw new ConversationalRectificationError("profile_incomplete");

      if (profile.legacyCaseId) {
        return importLegacyCase(
          userId,
          profile.legacyCaseId,
          command.actionId,
          command.pendingConsultationQuestion ?? null,
        );
      }

      let price: number;
      try {
        price = ports.rectificationPriceCredits;
      } catch {
        throw new ConversationalRectificationError("service_unavailable");
      }
      if (!Number.isSafeInteger(price) || price < 1 || price > 1_000_000) {
        throw new ConversationalRectificationError("service_unavailable");
      }

      const caseId = command.actionId;
      let existing: LoadedConversationalRectificationCase | null;
      try {
        existing = await ports.store.loadCase({ userId, caseId });
      } catch (error) {
        throw safeFailure(error);
      }
      if (existing) {
        observeCase(existing);
        if (existing.pendingConsultationQuestion !== (command.pendingConsultationQuestion ?? null)) {
          throw new ConversationalRectificationError("action_conflict");
        }
        if (existing.billingState === "reserved") {
          try {
            await ports.billing.complete({
              userId,
              caseId,
              expectedVersion: 0,
              actionId: command.actionId,
            });
            observeCase(existing, "charged");
          } catch (error) {
            try {
              await ports.billing.release({
                userId,
                caseId,
                expectedVersion: 0,
                actionId: command.actionId,
                price,
              });
              observeCase(existing, "released");
            } catch {
              throw new ConversationalRectificationError("billing_failed");
            }
            throw safeFailure(error);
          }
        } else if (existing.billingState !== "charged"
          && existing.billingState !== "migration_waived") {
          throw new ConversationalRectificationError("billing_failed");
        }
        return publicTurn(existing);
      }

      // A new action id is not a new rectification session. The durable
      // reserve RPC rejects a second unfinished case for the same account,
      // so resolve that invariant before spending time or credits. This is
      // intentionally limited to the same declared birth input; a changed
      // profile must not silently continue an old calculation.
      let existingForUser: LoadedConversationalRectificationCase | null;
      try {
        existingForUser = await ports.store.loadCase({ userId });
      } catch (error) {
        throw safeFailure(error);
      }
      if (existingForUser && existingForUser.caseId !== caseId) {
        observeCase(existingForUser);
        if (sameDeclaredBirthInput(existingForUser.declaredBirthInput, declared.data)) {
          return publicTurn(existingForUser);
        }
        throw new ConversationalRectificationError("action_conflict");
      }
      if (ports.allowNewCaseCreation === false) {
        throw new ConversationalRectificationError("service_unavailable");
      }

      let reserved = false;
      try {
        const reservation = await ports.billing.reserve({
          userId,
          caseId,
          expectedVersion: 0,
          actionId: command.actionId,
          price,
        });
        reserved = reservation.billingState === "reserved";
        if (reserved) lastTelemetryOutcome = { billingState: "unknown", caseStatus: null };
        const computed = await ports.buildTechnicalPacket({
          userId,
          caseId,
          asOfDate: ports.asOfDate(),
          declaredBirthInput: declared.data,
          privateCandidate: null,
          evidence: [],
        });
        const gatedPacket = confirmationGatedPacket(computed.packet, 0, 0);
        const narrative = await generateRectificationNarrative({
          phase: "first",
          packet: gatedPacket,
          generator: ports.narrativeGenerator,
        });
        const privateCandidate = privateCandidateFromPacket({
          packet: gatedPacket,
          resultId: null,
          iteration: 0,
          forceCollecting: true,
        });
        const firstTurn = turnFromNarrative({
          caseId,
          turnVersion: 0,
          pendingConsultationQuestion: command.pendingConsultationQuestion ?? null,
          packet: gatedPacket,
          narrative,
          evidence: [],
        });
        const created = await ports.store.createCaseWithFirstTurn({
          userId,
          caseId,
          expectedVersion: 0,
          actionId: command.actionId,
          revisionOfCaseId: profile.revisionOfCaseId,
          pendingConsultationQuestion: command.pendingConsultationQuestion ?? null,
          declaredBirthInput: declared.data,
          firstTurn,
          validationReceipt: narrative.validationReceipt,
          privateCandidate,
        });
        observeCase(created, "unknown");
        await ports.billing.complete({
          userId,
          caseId,
          expectedVersion: 0,
          actionId: command.actionId,
        });
        observeCase(created, "charged");
        return publicTurn(created);
      } catch (error) {
        const failure = safeFailure(error);
        if (reserved) {
          try {
            await ports.billing.release({
              userId,
              caseId,
              expectedVersion: 0,
              actionId: command.actionId,
              price,
            });
            lastTelemetryOutcome = {
              billingState: "released",
              caseStatus: lastTelemetryOutcome.caseStatus,
            };
          } catch {
            throw new ConversationalRectificationError("billing_failed");
          }
        }
        // A concurrent start can win between the account-level read above
        // and the reserve/create RPC. Re-read the account after releasing our
        // reservation and return the winner when it uses the same profile.
        if (failure.code === "action_conflict") {
          try {
            const winner = await ports.store.loadCase({ userId });
            if (winner && sameDeclaredBirthInput(winner.declaredBirthInput, declared.data)) {
              observeCase(winner);
              return publicTurn(winner);
            }
          } catch {
            // Preserve the original stable conflict below.
          }
        }
        throw failure;
      }
    },

    async resume(userId, rawCommand) {
      resetTelemetryOutcome();
      const command = parseCommand("resume", rawCommand);
      const current = await load(userId, command.caseId);
      return publicTurn(current);
    },

    async answer(userId, rawCommand) {
      resetTelemetryOutcome();
      const command = parseCommand("answer", rawCommand);
      const fingerprint = commandFingerprint(command);
      const receipt = await replayMutation(userId, command, "save_turn", fingerprint);
      if (receipt) return receipt;
      const current = await load(userId, command.caseId);
      requireMutable(current);
      const structuredFollowUp = resolveStructuredFollowUp(command, current);
      const extracted = structuredFollowUp?.kind === "confirmed"
        ? structuredFollowUp.evidence
        : structuredFollowUp?.kind === "rejected"
          ? structuredFollowUp.evidence
          : await extractedEvidence(command, current);
      const evidence = evidenceForDeclaredBirthDate(
        structuredFollowUp?.kind === "confirmed"
          ? extracted
          : completeLatestClarification({ command, current, extracted }),
        current.declaredBirthInput.birthDate,
      );

      if (current.turnVersion === command.turnVersion + 1) {
        try {
          const replayed = await ports.store.saveTurn({
            userId,
            caseId: command.caseId,
            expectedVersion: command.turnVersion,
            actionId: command.actionId,
            commandFingerprint: fingerprint,
            userMessage: command.answer,
            turn: current.latestTurn,
            evidence,
            validationReceipt: latestReceipt(current),
            privateCandidate: current.privateCandidate,
          });
          return publicTurn(replayed);
        } catch (error) {
          throw safeFailure(error);
        }
      }
      requireExactVersion(current, command.turnVersion);

      if (command.correctsEvidenceId
        && !effectiveLifeEventEvidence(current.eventEvidence)
          .some((item) => item.id === command.correctsEvidenceId)) {
        throw new ConversationalRectificationError("action_conflict");
      }

      const scoreableEvidence = evidence.filter((item) => item.scoreable === true
        && hasScoringEvidenceDomain(item)
        && item.extractionStatus !== "needs_clarification");
      const explicitDirectionChange = explicitDirectionChangePattern.test(command.answer);
      const directionChange = explicitDirectionChange
        || (scoreableEvidence.length === 0 && genericUncertaintyPattern.test(command.answer));
      const allScoreable = uniqueScoreableLifeEventEvidence(
        [...current.eventEvidence, ...evidence],
        current.declaredBirthInput.birthDate,
      );

      if (command.correctsEvidenceId) {
        try {
          const computed = await ports.buildTechnicalPacket({
            userId,
            caseId: command.caseId,
            asOfDate: ports.asOfDate(),
            declaredBirthInput: current.declaredBirthInput,
            // A correction invalidates any range narrowed by the retired fact.
            // Rebuild from the user's declared/baseline range so eliminated
            // minutes can re-enter the deterministic scan.
            privateCandidate: null,
            evidence: allScoreable,
          });
          const gatedPacket = confirmationGatedPacket(
            computed.packet,
            allScoreable.length,
            scoreableDomains(allScoreable).size,
          );
          const replacement = evidence[0];
          if (!replacement) throw new ConversationalRectificationError("invalid_command");
          const resetReason: CorrectionResetReason | null = directionChange
            ? "direction_change"
            : replacement.extractionStatus === "needs_clarification"
              ? "needs_clarification"
              : replacement.scoreable !== true ? "non_scoreable" : null;
          if (resetReason) {
            const authoredNarrative = await generateRectificationNarrative({
              phase: "intermediate",
              packet: gatedPacket,
              generator: ports.narrativeGenerator,
              context: await conversationContext({
                userId,
                current,
                latestUserText: command.answer,
                allEvidence: [...current.eventEvidence, ...evidence],
                newEvidence: evidence,
              }),
            });
            const next = nonScoringTurn({
              current,
              newEvidence: evidence,
              latestUserText: command.answer,
              authoredNarrative,
              correctionReset: { packet: computed.packet, reason: resetReason },
            });
            const privateCandidate = privateCandidateFromPacket({
              packet: gatedPacket,
              resultId: null,
              iteration: (current.privateCandidate.workingState?.iteration ?? 0) + 1,
              forceCollecting: true,
            });
            const saved = await ports.store.saveTurn({
              userId,
              caseId: command.caseId,
              expectedVersion: command.turnVersion,
              actionId: command.actionId,
              commandFingerprint: fingerprint,
              userMessage: command.answer,
              turn: next.turn,
              evidence,
              validationReceipt: next.receipt,
              privateCandidate,
            });
            return publicTurn(saved);
          }

          const plateauCount = nextPlateauCount(current.privateCandidate, gatedPacket);
          const answeredDomains = scoreableDomains(allScoreable);
          const boundedResult = shouldCompleteBoundedResult({
            packet: gatedPacket,
            scoreableEventCount: allScoreable.length,
            scoreableDomainCount: answeredDomains.size,
            answeredDomains,
            plateauCount,
          });
          const phase = boundedResult || gatedPacket.candidate.status === "ready_for_confirmation"
            ? "final" as const
            : "intermediate" as const;
          const narrative = await generateRectificationNarrative({
            phase,
            packet: gatedPacket,
            generator: ports.narrativeGenerator,
            context: await conversationContext({
              userId,
              current,
              latestUserText: command.answer,
              allEvidence: [...current.eventEvidence, ...evidence],
              newEvidence: evidence,
            }),
          });
          const privateCandidate = privateCandidateFromPacket({
            packet: gatedPacket,
            resultId: gatedPacket.candidate.status === "ready_for_confirmation"
              ? computed.resultId
              : null,
            iteration: (current.privateCandidate.workingState?.iteration ?? 0) + 1,
            notes: convergenceNotes(current.privateCandidate, plateauCount),
            forceCollecting: boundedResult || gatedPacket.candidate.status !== "ready_for_confirmation",
          });
          const turnInput = {
            caseId: command.caseId,
            turnVersion: command.turnVersion + 1,
            pendingConsultationQuestion: current.pendingConsultationQuestion,
            packet: gatedPacket,
            narrative,
            evidence: [...current.eventEvidence, ...evidence],
          };
          const turn = boundedResult ? boundedResultTurn(turnInput) : turnFromNarrative(turnInput);
          const saved = await ports.store.saveTurn({
            userId,
            caseId: command.caseId,
            expectedVersion: command.turnVersion,
            actionId: command.actionId,
            commandFingerprint: fingerprint,
            userMessage: command.answer,
            turn,
            evidence,
            validationReceipt: narrative.validationReceipt,
            privateCandidate,
          });
          return publicTurn(saved);
        } catch (error) {
          throw safeFailure(error);
        }
      }
      if (directionChange || scoreableEvidence.length === 0) {
        let authoredNarrative: RectificationNarrativeResult | null = null;
        try {
          const computed = await ports.buildTechnicalPacket({
            userId,
            caseId: command.caseId,
            asOfDate: ports.asOfDate(),
            declaredBirthInput: current.declaredBirthInput,
            privateCandidate: current.privateCandidate,
            evidence: allScoreable,
          });
          const gatedPacket = confirmationGatedPacket(
            computed.packet,
            allScoreable.length,
            scoreableDomains(allScoreable).size,
          );
          authoredNarrative = await generateRectificationNarrative({
            phase: "intermediate",
            packet: gatedPacket,
            generator: ports.narrativeGenerator,
            context: await conversationContext({
              userId,
              current,
              latestUserText: command.answer,
              allEvidence: [...current.eventEvidence, ...evidence],
              newEvidence: evidence,
            }),
          });
        } catch (error) {
          console.warn("[rectification-non-scoring-narrative-fallback]", JSON.stringify({
            error: error instanceof Error ? error.name : "UnknownError",
          }));
        }
        const next = nonScoringTurn({
          current,
          newEvidence: evidence,
          latestUserText: command.answer,
          authoredNarrative,
          followUpOverride: structuredFollowUp?.kind === "rejected"
            ? structuredFollowUp.followUp
            : undefined,
        });
        try {
          const saved = await ports.store.saveTurn({
            userId,
            caseId: command.caseId,
            expectedVersion: command.turnVersion,
            actionId: command.actionId,
            commandFingerprint: fingerprint,
            userMessage: command.answer,
            turn: next.turn,
            evidence,
            validationReceipt: next.receipt,
            privateCandidate: current.privateCandidate,
          });
          return publicTurn(saved);
        } catch (error) {
          throw safeFailure(error);
        }
      }

      try {
        const computed = await ports.buildTechnicalPacket({
          userId,
          caseId: command.caseId,
          asOfDate: ports.asOfDate(),
          declaredBirthInput: current.declaredBirthInput,
          privateCandidate: current.privateCandidate,
          evidence: allScoreable,
        });
        const gatedPacket = confirmationGatedPacket(
          computed.packet,
          allScoreable.length,
          scoreableDomains(allScoreable).size,
        );
        const plateauCount = nextPlateauCount(current.privateCandidate, gatedPacket);
        const answeredDomains = scoreableDomains(allScoreable);
        const boundedResult = shouldCompleteBoundedResult({
          packet: gatedPacket,
          scoreableEventCount: allScoreable.length,
          scoreableDomainCount: answeredDomains.size,
          answeredDomains,
          plateauCount,
        });
        const phase = boundedResult || gatedPacket.candidate.status === "ready_for_confirmation"
          ? "final" as const
          : "intermediate" as const;
        const narrative = await generateRectificationNarrative({
          phase,
          packet: gatedPacket,
          generator: ports.narrativeGenerator,
          context: await conversationContext({
            userId,
            current,
            latestUserText: command.answer,
            allEvidence: [...current.eventEvidence, ...evidence],
            newEvidence: evidence,
          }),
        });
        const privateCandidate = privateCandidateFromPacket({
          packet: gatedPacket,
          resultId: gatedPacket.candidate.status === "ready_for_confirmation"
            ? computed.resultId
            : null,
          iteration: (current.privateCandidate.workingState?.iteration ?? 0) + 1,
          notes: convergenceNotes(current.privateCandidate, plateauCount),
          forceCollecting: boundedResult || gatedPacket.candidate.status !== "ready_for_confirmation",
        });
        const turnInput = {
          caseId: command.caseId,
          turnVersion: command.turnVersion + 1,
          pendingConsultationQuestion: current.pendingConsultationQuestion,
          packet: gatedPacket,
          narrative,
          evidence: [...current.eventEvidence, ...evidence],
        };
        const narratedTurn = boundedResult ? boundedResultTurn(turnInput) : turnFromNarrative(turnInput);
        const saved = await ports.store.saveTurn({
          userId,
          caseId: command.caseId,
          expectedVersion: command.turnVersion,
          actionId: command.actionId,
          commandFingerprint: fingerprint,
          userMessage: command.answer,
          turn: narratedTurn,
          evidence,
          validationReceipt: narrative.validationReceipt,
          privateCandidate,
        });
        return publicTurn(saved);
      } catch (error) {
        throw safeFailure(error);
      }
    },

    async regenerate(userId, rawCommand) {
      resetTelemetryOutcome();
      const command = parseCommand("regenerate", rawCommand);
      const fingerprint = commandFingerprint(command);
      const receipt = await replayMutation(userId, command, "save_turn", fingerprint);
      if (receipt) return receipt;
      const current = await load(userId, command.caseId);
      requireMutable(current);
      requireExactVersion(current, command.turnVersion);
      if (!current.latestTurn.actions.includes("answer")) {
        throw new ConversationalRectificationError("invalid_transition");
      }

      try {
        const activeEvidence = effectiveLifeEventEvidence(current.eventEvidence);
        const latestEvidence = activeEvidence.at(-1);
        const scoreableEvidence = uniqueScoreableLifeEventEvidence(
          current.eventEvidence,
          current.declaredBirthInput.birthDate,
        );
        const computed = await ports.buildTechnicalPacket({
          userId,
          caseId: command.caseId,
          asOfDate: ports.asOfDate(),
          declaredBirthInput: current.declaredBirthInput,
          privateCandidate: current.privateCandidate,
          evidence: scoreableEvidence,
          preserveCandidateRange: true,
        });
        const gatedPacket = confirmationGatedPacket(
          computed.packet,
          scoreableEvidence.length,
          scoreableDomains(scoreableEvidence).size,
        );
        const phase = gatedPacket.candidate.status === "ready_for_confirmation"
          ? "final" as const
          : activeEvidence.length === 0 ? "first" as const : "intermediate" as const;
        const narrative = await generateRectificationNarrative({
          phase,
          packet: gatedPacket,
          generator: ports.narrativeGenerator,
          context: latestEvidence ? await conversationContext({
            userId,
            current,
            latestUserText: latestEvidence.rawText,
            allEvidence: current.eventEvidence,
            newEvidence: [latestEvidence],
          }) : undefined,
        });
        const turn = turnFromNarrative({
          caseId: command.caseId,
          turnVersion: command.turnVersion + 1,
          pendingConsultationQuestion: current.pendingConsultationQuestion,
          packet: gatedPacket,
          narrative,
          evidence: current.eventEvidence,
        });
        const saved = await ports.store.saveTurn({
          userId,
          caseId: command.caseId,
          expectedVersion: command.turnVersion,
          actionId: command.actionId,
          commandFingerprint: fingerprint,
          userMessage: null,
          turn,
          evidence: [],
          validationReceipt: narrative.validationReceipt,
          privateCandidate: current.privateCandidate,
        });
        return publicTurn(saved);
      } catch (error) {
        throw safeFailure(error);
      }
    },

    async pause(userId, rawCommand) {
      resetTelemetryOutcome();
      const command = parseCommand("pause", rawCommand);
      const fingerprint = commandFingerprint(command);
      const receipt = await replayMutation(userId, command, "pause", fingerprint);
      if (receipt) return receipt;
      const current = await load(userId, command.caseId);
      if (current.turnVersion === command.turnVersion + 1 && current.status === "paused") {
        try {
          const replayed = await ports.store.pause({
            userId,
            caseId: command.caseId,
            expectedVersion: command.turnVersion,
            actionId: command.actionId,
            commandFingerprint: fingerprint,
            turn: current.latestTurn,
            validationReceipt: latestReceipt(current),
          });
          return publicTurn(replayed);
        } catch (error) {
          throw safeFailure(error);
        }
      }
      requireExactVersion(current, command.turnVersion);
      if (current.status !== "active" && current.status !== "confirming") {
        throw new ConversationalRectificationError("invalid_transition");
      }
      const next = changedTurn({
        current,
        status: "paused",
        narrative: current.latestTurn.narrative,
      });
      try {
        return publicTurn(await ports.store.pause({
          userId,
          caseId: command.caseId,
          expectedVersion: command.turnVersion,
          actionId: command.actionId,
          commandFingerprint: fingerprint,
          turn: next.turn,
          validationReceipt: next.receipt,
        }));
      } catch (error) {
        throw safeFailure(error);
      }
    },

    async abandon(userId, rawCommand) {
      resetTelemetryOutcome();
      const command = parseCommand("abandon", rawCommand);
      const fingerprint = commandFingerprint(command);
      const receipt = await replayMutation(userId, command, "abandon", fingerprint);
      if (receipt) return receipt;
      const current = await load(userId, command.caseId);
      if (current.turnVersion === command.turnVersion + 1 && current.status === "abandoned") {
        try {
          return publicTurn(await ports.store.abandon({
            userId,
            caseId: command.caseId,
            expectedVersion: command.turnVersion,
            actionId: command.actionId,
            commandFingerprint: fingerprint,
            turn: current.latestTurn,
            validationReceipt: latestReceipt(current),
          }));
        } catch (error) {
          throw safeFailure(error);
        }
      }
      requireExactVersion(current, command.turnVersion);
      requireMutable(current);
      const next = changedTurn({
        current,
        status: "abandoned",
        narrative: current.latestTurn.narrative,
      });
      try {
        return publicTurn(await ports.store.abandon({
          userId,
          caseId: command.caseId,
          expectedVersion: command.turnVersion,
          actionId: command.actionId,
          commandFingerprint: fingerprint,
          turn: next.turn,
          validationReceipt: next.receipt,
        }));
      } catch (error) {
        throw safeFailure(error);
      }
    },

    async confirm(userId, rawCommand) {
      resetTelemetryOutcome();
      const command = parseCommand("confirm", rawCommand);
      const fingerprint = commandFingerprint(command);
      const receipt = await replayMutation(userId, command, "confirm", fingerprint);
      if (receipt) return receipt;
      const current = await load(userId, command.caseId);
      if (current.turnVersion === command.turnVersion + 1 && current.status === "completed") {
        const resultId = current.privateCandidate.resultId;
        if (!resultId) throw new ConversationalRectificationError("candidate_changed");
        try {
          return publicTurn(await ports.store.confirm({
            userId,
            caseId: command.caseId,
            expectedVersion: command.turnVersion,
            actionId: command.actionId,
            commandFingerprint: fingerprint,
            resultId,
            time: command.time,
            calculationVersion: current.privateCandidate.calculationVersion,
            turn: current.latestTurn,
            validationReceipt: latestReceipt(current),
          }));
        } catch (error) {
          throw safeFailure(error);
        }
      }
      requireExactVersion(current, command.turnVersion);
      const resultId = current.privateCandidate.resultId;
      if (current.status !== "confirming"
        || current.latestTurn.candidate.status !== "ready_for_confirmation"
        || !resultId
        || current.privateCandidate.representativeTime !== command.time
        || current.latestTurn.candidate.representativeTime !== command.time) {
        throw new ConversationalRectificationError("candidate_changed");
      }
      const next = changedTurn({
        current,
        status: "completed",
        narrative: current.latestTurn.narrative,
      });
      try {
        return publicTurn(await ports.store.confirm({
          userId,
          caseId: command.caseId,
          expectedVersion: command.turnVersion,
          actionId: command.actionId,
          commandFingerprint: fingerprint,
          resultId,
          time: command.time,
          calculationVersion: current.privateCandidate.calculationVersion,
          turn: next.turn,
          validationReceipt: next.receipt,
        }));
      } catch (error) {
        throw safeFailure(error);
      }
    },
  });
  telemetryOutcomes.set(service, () => lastTelemetryOutcome);
  return service;
}