@akagilnc/pi-workflow-roles 0.1.3452 → 0.1.3471

package/src/public-cli/settlement.ts

@@ -12,9 +12,7 @@ import {
   type AnalystGateCycleRound,
 } from "../analyst-gate-cycles-read.ts";
 import { readSitianRecords, resolveSitianRecordPath, sitianReport } from "../sitian-facade.ts";
-import {
-  resolveTicketSeatMemoryNestDirectories,
-} from "../ticket-seat-memory.ts";
+
 import {
   readAuditEscalationSubmission,
   readLatestSubmissionOutcome,
@@ -161,8 +159,33 @@ function sealedLedgerHome(admitted: AdmittedRoleInvocation): string {
   return homeFromRunDirectory(admitted.runDirectory);
 }
 
-async function sealedLedgerOutcome(admitted: AdmittedRoleInvocation): Promise<Extract<TerminalRoleOutcome, { kind: "accepted" }> | undefined> {
-  return readSealedSubmission(admitted.projectRoot, admitted.runId, sealedLedgerHome(admitted));
+/**
+ * Court-turn settlement scope (#637 same-ticket re-summons).
+ * When courtAttemptId is set, ledger reads only that attempt so a prior seal
+ * cannot present as this turn's result. Omit for manual resume idempotent
+ * run-scoped sealed reads (no new court).
+ */
+export type SettlementCourtScope = {
+  readonly courtAttemptId?: string;
+};
+
+function ledgerReadScope(
+  admitted: AdmittedRoleInvocation,
+  scope?: SettlementCourtScope,
+): { home: string; attemptId?: string } {
+  return {
+    home: sealedLedgerHome(admitted),
+    ...(scope?.courtAttemptId === undefined || scope.courtAttemptId.length === 0
+      ? {}
+      : { attemptId: scope.courtAttemptId }),
+  };
+}
+
+async function sealedLedgerOutcome(
+  admitted: AdmittedRoleInvocation,
+  scope?: SettlementCourtScope,
+): Promise<Extract<TerminalRoleOutcome, { kind: "accepted" }> | undefined> {
+  return readSealedSubmission(admitted.projectRoot, admitted.runId, ledgerReadScope(admitted, scope));
 }
 
 /**
@@ -173,6 +196,7 @@ async function sealedLedgerOutcome(admitted: AdmittedRoleInvocation): Promise<Ex
  * preserved cause; otherwise allow. Callers present entry-specific terminals;
  * they must not re-derive this judgment. Ledger projection remains the sole
  * seal truth — this is disposition over that read, not a second state.
+ * Always run-scoped (no court attempt filter): any retained seal blocks bare resume.
  */
 export type SealedAcceptanceRedispatchDisposition =
   | { readonly kind: "allow" }
@@ -196,11 +220,12 @@ export async function sealedAcceptanceRedispatchDisposition(
 async function auditEscalationLedgerOutcome(
   admitted: AdmittedRoleInvocation,
   role: TerminalRoleName,
+  scope?: SettlementCourtScope,
 ): Promise<Extract<TerminalRoleOutcome, { kind: "audit_escalation" }> | undefined> {
   const projection = await readAuditEscalationSubmission(
     admitted.projectRoot,
     admitted.runId,
-    sealedLedgerHome(admitted),
+    ledgerReadScope(admitted, scope),
   );
   if (projection?.role !== role) return undefined;
   return projection;
@@ -209,11 +234,12 @@ async function auditEscalationLedgerOutcome(
 async function closedLedgerOutcome(
   admitted: AdmittedRoleInvocation,
   role: TerminalRoleName,
+  scope?: SettlementCourtScope,
 ): Promise<Extract<TerminalRoleOutcome, { kind: "accepted" | "audit_escalation" }> | undefined> {
-  const sealed = await sealedLedgerOutcome(admitted);
+  const sealed = await sealedLedgerOutcome(admitted, scope);
   return sealed?.role === role
     ? sealed
-    : auditEscalationLedgerOutcome(admitted, role);
+    : auditEscalationLedgerOutcome(admitted, role, scope);
 }
 
 /** Transitional host-session reads remain only for non-sealed failure and audit evidence. */
@@ -449,8 +475,7 @@ function flattenThrownFailureLeaves(error: unknown): unknown[] {
 
 /**
  * Project one thrown value into a ControlledFailure leaf.
- * Sole owner for thrown-leaf identity/diagnostic mapping (last-host write concurrent
- * facts reuse this — do not fork a second leaf mapper).
+ * Sole owner for thrown-leaf identity/diagnostic mapping.
  * AggregateError nesting is handled by classifyThrownFailure.
  */
 export function projectThrownFailureLeaf(error: unknown): ControlledFailure {
@@ -481,7 +506,7 @@ export function projectThrownFailureLeaf(error: unknown): ControlledFailure {
 }
 
 /**
- * Concurrent thrown failures (host + cleanup / last-host write, etc.):
+ * Concurrent thrown failures (host + cleanup, etc.):
  * primary leaf owns cause/diagnostic/identity; remaining leaves stay as
  * details.concurrentFailures so neither fact covers the other.
  */
@@ -1008,16 +1033,7 @@ async function loadBoundAuditorVolumes(
     latestParentUserIndex = i;
     break;
   }
-  const runDirectory = join(dirname(sessionFile), "..");
-  // #636: ticket-seat auditor memory nest via sole discovery helper.
-  const memoryNests = await resolveTicketSeatMemoryNestDirectories({
-    runDirectory,
-    seats: ["auditor"],
-  });
-  const childDirectories = [
-    join(dirname(sessionFile), "auditor-roles"),
-    ...memoryNests,
-  ];
+  const childDirectories = [join(dirname(sessionFile), "auditor-roles")];
   // Auto-resume seam (owner A): stale check must ignore resume envelope and
   // prioritize retention. Previous `attemptEntryIndex < latest` discarded the
   // first attempt's child after resume advanced latest, losing retentionFailure
@@ -1043,9 +1059,8 @@ async function loadBoundAuditorVolumes(
       }
       const header = entries.find((entry) => entry.type === "session");
       if (!isRecord(header)) continue;
-      // Ticket-seat continuous memory keeps the first parent's header.parentSession;
-      // binding.parent.sessionFile is the per-summons authority (#636).
-      // Each binding owns only its interval — never whole-volume provider/compliance.
+      // Parent-attempt binding owns its interval on multi-attempt volumes
+      // (never whole-volume provider/compliance).
       const bindingIndexes: number[] = [];
       for (let i = 0; i < entries.length; i += 1) {
         const entry = entries[i];
@@ -2366,9 +2381,8 @@ export function projectTerminalGateFact(
 }
 
 /**
- * Read gate facts from the run's session/auditor-roles nest and, when the run
- * carries a ticket, from #636 ticket-seat memory nests via the sole nested-volume
- * reader (#446/#478). Missing directories → undefined (no-gate zero change).
+ * Read gate facts from the run's session/auditor-roles nest (#446/#478).
+ * Missing directories → undefined (no-gate zero change).
  * Damaged discovered volumes propagate — never wash to "no gate".
  */
 export async function extractGateFactFromSessionDirectory(
@@ -2378,15 +2392,7 @@ export async function extractGateFactFromSessionDirectory(
     readonly parentSessionFile?: string;
   } = {},
 ): Promise<TerminalGateFact | undefined> {
-  const runDirectory = options.runDirectory ?? join(sessionDirectory, "..");
-  const memoryNests = await resolveTicketSeatMemoryNestDirectories({
-    runDirectory,
-    seats: ["inspector", "notary"],
-  });
-  const directories = [
-    join(sessionDirectory, "auditor-roles"),
-    ...memoryNests,
-  ];
+  const directories = [join(sessionDirectory, "auditor-roles")];
   const parentSessionFile =
     options.parentSessionFile ?? join(sessionDirectory, "session.jsonl");
   const rounds = await readAnalystGateCyclesFromAuditorRoles(directories, {
@@ -3384,11 +3390,12 @@ async function settleLawfulSeatAcceptedTerminalResult(
     | AdmittedNavigatorInvocation,
   authority: DurablePrincipalAuthority,
   spec: SeatAcceptedSettlementSpec,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
   const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-  const roleOutcome = await closedLedgerOutcome(admitted, spec.role as TerminalRoleName);
+  const roleOutcome = await closedLedgerOutcome(admitted, spec.role as TerminalRoleName, scope);
   if (roleOutcome?.kind === "audit_escalation") {
     const navigator = extractNavigatorFact(entries);
     return withOptionalGateProjection(
@@ -3490,6 +3497,7 @@ export type LawfulNotaryRoleOutcome = {
 async function settleLawfulNotaryTerminalResult(
   admitted: AdmittedNotaryInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
   return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
     role: "notary",
@@ -3506,15 +3514,16 @@ async function settleLawfulNotaryTerminalResult(
       };
       return accepted;
     },
-  });
+  }, scope);
 }
 
 /** Settle a lawful Notary Terminal from the admitted session. */
 export async function settleNotaryTerminalResult(
   admitted: AdmittedNotaryInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulNotaryTerminalResult(admitted, authority);
+  const settled = await settleLawfulNotaryTerminalResult(admitted, authority, scope);
   if (settled === undefined) {
     throw new Error(
       "Notary Role run completed without a lawful typed terminal result",
@@ -3527,8 +3536,9 @@ export async function settleNotaryTerminalResult(
 export async function trySettleNotaryTerminalResult(
   admitted: AdmittedNotaryInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulNotaryTerminalResult(admitted, authority);
+  return settleLawfulNotaryTerminalResult(admitted, authority, scope);
 }
 
 /** Lawful Countersign accepted outcome (署/封驳/上呈, #572 / ADR 0074). */
@@ -3542,6 +3552,7 @@ export type LawfulCountersignRoleOutcome = {
 async function settleLawfulCountersignTerminalResult(
   admitted: AdmittedCountersignInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
   return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
     role: "countersign",
@@ -3558,15 +3569,16 @@ async function settleLawfulCountersignTerminalResult(
       };
       return accepted;
     },
-  });
+  }, scope);
 }
 
 /** Settle a lawful Countersign Terminal from the admitted session. */
 export async function settleCountersignTerminalResult(
   admitted: AdmittedCountersignInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulCountersignTerminalResult(admitted, authority);
+  const settled = await settleLawfulCountersignTerminalResult(admitted, authority, scope);
   if (settled === undefined) {
     throw new Error(
       "Countersign Role run completed without a lawful typed terminal result",
@@ -3579,8 +3591,9 @@ export async function settleCountersignTerminalResult(
 export async function trySettleCountersignTerminalResult(
   admitted: AdmittedCountersignInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulCountersignTerminalResult(admitted, authority);
+  return settleLawfulCountersignTerminalResult(admitted, authority, scope);
 }
 
 /** Lawful Gleaner-Left accepted outcome (completed 弹章, #502). */
@@ -3594,6 +3607,7 @@ export type LawfulGleanerLeftRoleOutcome = {
 async function settleLawfulGleanerLeftTerminalResult(
   admitted: AdmittedGleanerLeftInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
   return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
     role: "gleaner-left",
@@ -3610,15 +3624,16 @@ async function settleLawfulGleanerLeftTerminalResult(
       };
       return accepted;
     },
-  });
+  }, scope);
 }
 
 /** Settle a lawful Gleaner-Left Terminal from the admitted session. */
 export async function settleGleanerLeftTerminalResult(
   admitted: AdmittedGleanerLeftInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulGleanerLeftTerminalResult(admitted, authority);
+  const settled = await settleLawfulGleanerLeftTerminalResult(admitted, authority, scope);
   if (settled === undefined) {
     throw new Error(
       "Gleaner-Left Role run completed without a lawful typed terminal result",
@@ -3631,8 +3646,9 @@ export async function settleGleanerLeftTerminalResult(
 export async function trySettleGleanerLeftTerminalResult(
   admitted: AdmittedGleanerLeftInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulGleanerLeftTerminalResult(admitted, authority);
+  return settleLawfulGleanerLeftTerminalResult(admitted, authority, scope);
 }
 
 /** Lawful Inspector accepted outcome (pass/bounce/escalate). */
@@ -3646,6 +3662,7 @@ export type LawfulInspectorRoleOutcome = {
 async function settleLawfulInspectorTerminalResult(
   admitted: AdmittedInspectorInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
   return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
     role: "inspector",
@@ -3662,14 +3679,15 @@ async function settleLawfulInspectorTerminalResult(
       };
       return accepted;
     },
-  });
+  }, scope);
 }
 
 export async function trySettleInspectorTerminalResult(
   admitted: AdmittedInspectorInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulInspectorTerminalResult(admitted, authority);
+  return settleLawfulInspectorTerminalResult(admitted, authority, scope);
 }
 
 /** Lawful Gatekeeper accepted outcome (dispatch | pass, #639). */
@@ -3683,6 +3701,7 @@ export type LawfulGatekeeperRoleOutcome = {
 async function settleLawfulGatekeeperTerminalResult(
   admitted: AdmittedGatekeeperInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
   return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
     role: "gatekeeper",
@@ -3699,15 +3718,16 @@ async function settleLawfulGatekeeperTerminalResult(
       };
       return accepted;
     },
-  });
+  }, scope);
 }
 
 /** Try to settle a lawful Gatekeeper Terminal; undefined only for genuine absence. */
 export async function trySettleGatekeeperTerminalResult(
   admitted: AdmittedGatekeeperInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulGatekeeperTerminalResult(admitted, authority);
+  return settleLawfulGatekeeperTerminalResult(admitted, authority, scope);
 }
 
 /** Lawful Navigator accepted outcome (route advice, #639). */
@@ -3721,6 +3741,7 @@ export type LawfulNavigatorRoleOutcome = {
 async function settleLawfulNavigatorTerminalResult(
   admitted: AdmittedNavigatorInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
   return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
     role: "navigator",
@@ -3737,15 +3758,16 @@ async function settleLawfulNavigatorTerminalResult(
       };
       return accepted;
     },
-  });
+  }, scope);
 }
 
 /** Try to settle a lawful Navigator Terminal; undefined only for genuine absence. */
 export async function trySettleNavigatorTerminalResult(
   admitted: AdmittedNavigatorInvocation,
   authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulNavigatorTerminalResult(admitted, authority);
+  return settleLawfulNavigatorTerminalResult(admitted, authority, scope);
 }
 
 /** Try to settle a lawful Coder Terminal; undefined only for genuine absence. */

package/src/run-ticket-number.ts

@@ -0,0 +1,53 @@
+/**
+ * Typed ticketNumber reader for a retained run's durable pages.
+ * admitted-request.json first, invocation.json fallback. Missing page (ENOENT)
+ * → try next / undefined; damage and non-ENOENT IO failures propagate.
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+function isEnoent(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    (error as NodeJS.ErrnoException).code === "ENOENT"
+  );
+}
+
+function ticketFromRecord(record: Record<string, unknown>): number | undefined {
+  const ticketNumber = record.ticketNumber;
+  if (
+    typeof ticketNumber === "number" &&
+    Number.isSafeInteger(ticketNumber) &&
+    ticketNumber >= 1
+  ) {
+    return ticketNumber;
+  }
+  return undefined;
+}
+
+async function readPageTicketNumber(
+  runDirectory: string,
+  page: "admitted-request.json" | "invocation.json",
+): Promise<number | undefined> {
+  try {
+    const raw = JSON.parse(await readFile(join(runDirectory, page), "utf8")) as unknown;
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      return undefined;
+    }
+    return ticketFromRecord(raw as Record<string, unknown>);
+  } catch (error) {
+    if (isEnoent(error)) return undefined;
+    throw error;
+  }
+}
+
+/** Sole reader of ticketNumber from a retained run's admitted then invocation pages. */
+export async function readRunTicketNumber(
+  runDirectory: string,
+): Promise<number | undefined> {
+  return (
+    (await readPageTicketNumber(runDirectory, "admitted-request.json")) ??
+    (await readPageTicketNumber(runDirectory, "invocation.json"))
+  );
+}

package/src/submission-ledger.ts

@@ -56,7 +56,17 @@ function runIdentity(context: HostContext): string {
   throw new Error("提交账需要已受理的 run 身份");
 }
 
+/**
+ * Court-turn attempt identity (#637 same-ticket re-summons).
+ * AK_ROLE_COURT_ATTEMPT is injected only for a new court turn on an already-retained
+ * run (forceContinuation / summons). Manual resume and first mint omit it so the
+ * session-stable id keeps sole-final + sealed-idempotent semantics.
+ */
+export const COURT_ATTEMPT_ENV = "AK_ROLE_COURT_ATTEMPT" as const;
+
 function attemptIdentity(context: HostContext, runId: string): string {
+  const courtAttempt = process.env[COURT_ATTEMPT_ENV];
+  if (typeof courtAttempt === "string" && courtAttempt.length > 0) return courtAttempt;
   return context.sessionManager.getHeader?.()?.id ?? context.sessionManager.getLeafId?.() ?? `${runId}:initial`;
 }
 
@@ -103,15 +113,54 @@ async function readOwnedSubmissionRecords(cwd: string, runId: string, home?: str
   };
 }
 
-/** Settlement read seam: typed sealed projection only, never host session JSONL. */
+/** Optional court-turn scope for settlement reads (#637). */
+export type SubmissionLedgerReadScope = {
+  readonly home?: string;
+  /** When set, only this court attempt's ledger rows participate. */
+  readonly attemptId?: string;
+};
+
+function resolveReadScope(
+  homeOrScope?: string | SubmissionLedgerReadScope,
+): SubmissionLedgerReadScope {
+  if (homeOrScope === undefined) return {};
+  if (typeof homeOrScope === "string") return { home: homeOrScope };
+  return homeOrScope;
+}
+
+function recordAttemptId(record: { subject?: unknown; payload?: unknown }): string | undefined {
+  if (typeof record.subject === "object" && record.subject !== null) {
+    const fromSubject = (record.subject as { attemptId?: unknown }).attemptId;
+    if (typeof fromSubject === "string" && fromSubject.length > 0) return fromSubject;
+  }
+  if (typeof record.payload === "object" && record.payload !== null) {
+    const fromPayload = (record.payload as { attemptId?: unknown }).attemptId;
+    if (typeof fromPayload === "string" && fromPayload.length > 0) return fromPayload;
+  }
+  return undefined;
+}
+
+function recordsForAttempt<T extends { subject?: unknown; payload?: unknown }>(
+  owned: readonly T[],
+  attemptId: string | undefined,
+): readonly T[] {
+  if (attemptId === undefined) return owned;
+  return owned.filter((record) => recordAttemptId(record) === attemptId);
+}
+
+/** Settlement read seam: typed sealed projection only, never host session JSONL.
+ * Omit attemptId for run-scoped latest sealed (manual resume idempotent).
+ * Pass attemptId for the current court turn so a prior seal cannot wash this turn. */
 export async function readSealedSubmission(
   cwd: string,
   runId: string,
-  home?: string,
+  homeOrScope?: string | SubmissionLedgerReadScope,
 ): Promise<SealedSubmissionProjection | undefined> {
-  const { owned } = await readOwnedSubmissionRecords(cwd, runId, home);
-  for (let index = owned.length - 1; index >= 0; index -= 1) {
-    const record = owned[index];
+  const scope = resolveReadScope(homeOrScope);
+  const { owned } = await readOwnedSubmissionRecords(cwd, runId, scope.home);
+  const scoped = recordsForAttempt(owned, scope.attemptId);
+  for (let index = scoped.length - 1; index >= 0; index -= 1) {
+    const record = scoped[index];
     if (record?.kind === "post-seal-anomaly") return undefined;
     if (record?.kind !== "sealed") continue;
     const payload = record.payload as Partial<Extract<SubmissionLedgerEvent, { type: "sealed" }>> | undefined;
@@ -124,11 +173,13 @@ export async function readSealedSubmission(
 export async function readAuditEscalationSubmission(
   cwd: string,
   runId: string,
-  home?: string,
+  homeOrScope?: string | SubmissionLedgerReadScope,
 ): Promise<AuditEscalationSubmissionProjection | undefined> {
-  const { owned } = await readOwnedSubmissionRecords(cwd, runId, home);
-  for (let index = owned.length - 1; index >= 0; index -= 1) {
-    const record = owned[index];
+  const scope = resolveReadScope(homeOrScope);
+  const { owned } = await readOwnedSubmissionRecords(cwd, runId, scope.home);
+  const scoped = recordsForAttempt(owned, scope.attemptId);
+  for (let index = scoped.length - 1; index >= 0; index -= 1) {
+    const record = scoped[index];
     if (record?.kind !== "outcome") continue;
     const payload = record.payload as Partial<Extract<SubmissionLedgerEvent, { type: "outcome" }>> | undefined;
     if (payload?.type !== "outcome" || payload.outcome !== "audit-escalation") continue;
@@ -143,11 +194,13 @@ export type LatestSubmissionOutcome = Extract<SubmissionLedgerEvent, { type: "ou
 export async function readLatestSubmissionOutcome(
   cwd: string,
   runId: string,
-  home?: string,
+  homeOrScope?: string | SubmissionLedgerReadScope,
 ): Promise<LatestSubmissionOutcome | undefined> {
-  const { owned } = await readOwnedSubmissionRecords(cwd, runId, home);
-  for (let index = owned.length - 1; index >= 0; index -= 1) {
-    const record = owned[index];
+  const scope = resolveReadScope(homeOrScope);
+  const { owned } = await readOwnedSubmissionRecords(cwd, runId, scope.home);
+  const scoped = recordsForAttempt(owned, scope.attemptId);
+  for (let index = scoped.length - 1; index >= 0; index -= 1) {
+    const record = scoped[index];
     if (record?.kind !== "outcome") continue;
     const payload = record.payload as Partial<LatestSubmissionOutcome> | undefined;
     if (payload?.type === "outcome" && typeof payload.outcome === "string") {
@@ -157,14 +210,27 @@ export async function readLatestSubmissionOutcome(
   return undefined;
 }
 
-type LedgerState = { prior?: RecordPointer; sealed: boolean; sequence: number };
+type LedgerState = { prior?: RecordPointer; sealedAttemptIds: Set<string>; sequence: number };
+
+function sealedAttemptIdFromRecord(record: { kind: string; payload?: unknown }): string | undefined {
+  if (record.kind !== "sealed") return undefined;
+  const payload = record.payload as Partial<Extract<SubmissionLedgerEvent, { type: "sealed" }>> | undefined;
+  return payload?.type === "sealed" && typeof payload.attemptId === "string" && payload.attemptId.length > 0
+    ? payload.attemptId
+    : undefined;
+}
 
 async function restoreState(cwd: string, runId: string, home?: string): Promise<LedgerState> {
   const { file, owned } = await readOwnedSubmissionRecords(cwd, runId, home);
   const last = owned.at(-1);
+  const sealedAttemptIds = new Set<string>();
+  for (const record of owned) {
+    const attemptId = sealedAttemptIdFromRecord(record);
+    if (attemptId !== undefined) sealedAttemptIds.add(attemptId);
+  }
   return {
     ...(last === undefined ? {} : { prior: { identity: last.identity, recordFile: file, kind: last.kind, level: last.level } }),
-    sealed: owned.some((record) => record.kind === "sealed"),
+    sealedAttemptIds,
     sequence: owned.reduce((maximum, record) => {
       const payload = record.payload as Partial<SubmissionLedgerEvent> | undefined;
       return payload?.type === "candidate" && typeof payload.sequence === "number" ? Math.max(maximum, payload.sequence) : maximum;
@@ -220,7 +286,9 @@ export function createSubmissionLedgerHost(
       const runId = runIdentity(context);
       const attemptId = attemptIdentity(context, runId);
       const state = await stateFor(context, runId);
-      if (state.sealed) appendFor(state, context, runId, attemptId, { type: "post-seal-anomaly", attemptId, toolCallId, toolName });
+      if (state.sealedAttemptIds.has(attemptId)) {
+        appendFor(state, context, runId, attemptId, { type: "post-seal-anomaly", attemptId, toolCallId, toolName });
+      }
     } catch (error) {
       failInfrastructure(error, context);
     }
@@ -261,7 +329,7 @@ export function createSubmissionLedgerHost(
       if (typeof status !== "string" || status.length === 0) throw new Error("提交账封账缺少 acceptedFacts.status");
       const projection: Extract<TerminalRoleOutcome, { kind: "accepted" }> = { kind: "accepted", role: candidate.role, status, decisiveFacts: details };
       appendFor(state, candidate.context, runId, attemptId, { type: "sealed", attemptId, toolCallId: candidate.toolCallId, accepted: candidate.result.details, projection });
-      state.sealed = true;
+      state.sealedAttemptIds.add(attemptId);
       await projectClosure(projection, context);
       context.abort();
     } catch (error) {
@@ -281,7 +349,7 @@ export function createSubmissionLedgerHost(
           const attemptId = attemptIdentity(context, runId);
           const state = await stateFor(context, runId);
           const append = (event: SubmissionLedgerEvent) => appendFor(state, context, runId, attemptId, event);
-          if (state.sealed) throw new Error("提交账已封账");
+          if (state.sealedAttemptIds.has(attemptId)) throw new Error("提交账已封账");
           // #541 / #575: shared infra-declaration fail lives on the ledger seam,
           // before any role execute or sole-final work (one owner for every seat).
           // #641 chain②: seats may opt into bouncing a machine-verified normal