@akagilnc/pi-workflow-roles 0.1.3391 → 0.1.3403

package/dist/grok/production-host.js

@@ -8584,16 +8584,8 @@ function runIdentity(context) {
   if (typeof headerId === "string" && headerId.length > 0) return headerId;
   throw new Error("\u63D0\u4EA4\u8D26\u9700\u8981\u5DF2\u53D7\u7406\u7684 run \u8EAB\u4EFD");
 }
-function latestUserAttemptId(entries) {
-  const ordered = [...entries];
-  for (let index = ordered.length - 1; index >= 0; index -= 1) {
-    const entry = ordered[index];
-    if (entry?.message?.role === "user" && typeof entry.id === "string") return entry.id;
-  }
-  return void 0;
-}
 function attemptIdentity(context, runId) {
-  return latestUserAttemptId(context.sessionManager.getEntries?.() ?? []) ?? context.sessionManager.getHeader?.()?.id ?? context.sessionManager.getLeafId?.() ?? `${runId}:initial`;
+  return context.sessionManager.getHeader?.()?.id ?? context.sessionManager.getLeafId?.() ?? `${runId}:initial`;
 }
 function submissionRecordFile(cwd, runId, home) {
   const ledgerHome = resolveActivationLedgerHome(home);

package/dist/public-cli/main.js

@@ -24326,14 +24326,6 @@ var init_run_terminal_artifacts = __esm({
 });
 
 // src/submission-ledger.ts
-function latestUserAttemptId(entries) {
-  const ordered = [...entries];
-  for (let index = ordered.length - 1; index >= 0; index -= 1) {
-    const entry = ordered[index];
-    if (entry?.message?.role === "user" && typeof entry.id === "string") return entry.id;
-  }
-  return void 0;
-}
 function isAcceptedProjection(value) {
   if (typeof value !== "object" || value === null) return false;
   const candidate = value;
@@ -24372,17 +24364,13 @@ async function readSealedSubmission(cwd, runId, home) {
   }
   return void 0;
 }
-async function readAuditEscalationSubmission(cwd, runId, home, currentAttemptId) {
+async function readAuditEscalationSubmission(cwd, runId, home) {
   const { owned } = await readOwnedSubmissionRecords(cwd, runId, home);
-  const latestAttemptId = currentAttemptId ?? owned.at(-1)?.subject?.attemptId;
-  if (typeof latestAttemptId !== "string") return void 0;
   for (let index = owned.length - 1; index >= 0; index -= 1) {
     const record4 = owned[index];
-    if (record4?.subject?.attemptId !== latestAttemptId) continue;
     if (record4?.kind !== "outcome") continue;
     const payload = record4.payload;
-    if (payload?.type !== "outcome") continue;
-    if (payload.outcome !== "audit-escalation") return void 0;
+    if (payload?.type !== "outcome" || payload.outcome !== "audit-escalation") continue;
     if (isAuditEscalationTerminalProjection(payload.projection)) return payload.projection;
   }
   return void 0;
@@ -24956,27 +24944,28 @@ function sealedLedgerHome(admitted) {
 async function sealedLedgerOutcome(admitted) {
   return readSealedSubmission(admitted.projectRoot, admitted.runId, sealedLedgerHome(admitted));
 }
-async function hasSealedAcceptedProjection(admitted) {
-  return await sealedLedgerOutcome(admitted) !== void 0;
-}
-async function auditEscalationLedgerOutcome(admitted, role, authority) {
-  let currentAttemptId;
-  if (role === "coder" || role === "fixer") {
-    const entries = await readBoundSessionEntries(coordinatesFromAdmitted(authority, admitted).sessionFile);
-    currentAttemptId = latestUserAttemptId(entries);
+async function sealedAcceptanceRedispatchDisposition(admitted) {
+  try {
+    if (await sealedLedgerOutcome(admitted) !== void 0) {
+      return { kind: "block", reason: "sealed-accepted" };
+    }
+    return { kind: "allow" };
+  } catch (cause) {
+    return { kind: "block", reason: "authority-failed", cause };
   }
+}
+async function auditEscalationLedgerOutcome(admitted, role) {
   const projection = await readAuditEscalationSubmission(
     admitted.projectRoot,
     admitted.runId,
-    sealedLedgerHome(admitted),
-    currentAttemptId
+    sealedLedgerHome(admitted)
   );
   if (projection?.role !== role) return void 0;
   return projection;
 }
-async function closedLedgerOutcome(admitted, role, authority) {
+async function closedLedgerOutcome(admitted, role) {
   const sealed = await sealedLedgerOutcome(admitted);
-  return sealed?.role === role ? sealed : auditEscalationLedgerOutcome(admitted, role, authority);
+  return sealed?.role === role ? sealed : auditEscalationLedgerOutcome(admitted, role);
 }
 function coordinatesFromAdmitted(authority, admitted) {
   return authority.decode(admitted.principal);
@@ -26301,7 +26290,7 @@ async function readLawfulJudgeRoleOutcome(admitted, authority) {
       decisiveFacts: judgeDecisiveFacts(details, sealed.status)
     };
   }
-  return auditEscalationLedgerOutcome(admitted, "judge", authority);
+  return auditEscalationLedgerOutcome(admitted, "judge");
 }
 async function settleLawfulJudgeTerminalResult(admitted, authority) {
   const roleOutcome = await readLawfulJudgeRoleOutcome(admitted, authority);
@@ -26328,7 +26317,7 @@ async function trySettleJudgeTerminalResult(admitted, authority) {
   return settleLawfulJudgeTerminalResult(admitted, authority);
 }
 async function settleLawfulCoderTerminalResult(admitted, authority, options = {}) {
-  const ledgerOutcome = await closedLedgerOutcome(admitted, "coder", authority);
+  const ledgerOutcome = await closedLedgerOutcome(admitted, "coder");
   if (ledgerOutcome === void 0) return void 0;
   let roleOutcome = ledgerOutcome;
   let output;
@@ -26448,7 +26437,7 @@ async function publishFixerArtifacts(admitted, roleOutcome, coordinates, options
   ];
 }
 async function settleLawfulFixerTerminalResult(admitted, authority, options) {
-  const ledgerOutcome = await closedLedgerOutcome(admitted, "fixer", authority);
+  const ledgerOutcome = await closedLedgerOutcome(admitted, "fixer");
   if (ledgerOutcome === void 0) return void 0;
   let roleOutcome = ledgerOutcome;
   let output;
@@ -26655,7 +26644,7 @@ async function settleLawfulDoctorTerminalResult(admitted, authority) {
   const { sessionDirectory, sessionFile } = coordinates;
   const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
   if (sealed?.role !== "doctor") {
-    const escalation = await auditEscalationLedgerOutcome(admitted, "doctor", authority);
+    const escalation = await auditEscalationLedgerOutcome(admitted, "doctor");
     if (escalation === void 0) return void 0;
     const artifacts2 = await publishDoctorArtifacts(admitted, escalation, coordinates);
     return withOptionalGateProjection(
@@ -26719,7 +26708,7 @@ async function settleLawfulSeatAcceptedTerminalResult(admitted, authority, spec)
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
   const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-  const roleOutcome = await closedLedgerOutcome(admitted, spec.role, authority);
+  const roleOutcome = await closedLedgerOutcome(admitted, spec.role);
   if (roleOutcome?.kind === "audit_escalation") {
     const navigator2 = extractNavigatorFact(entries);
     return withOptionalGateProjection(
@@ -27955,36 +27944,21 @@ async function runWithAutoResumeLoop(options) {
         return result2;
       }
     }
-    if (options.shouldStopAutoResume !== void 0) {
-      let failClosed;
-      let sealedStop = false;
-      try {
-        sealedStop = await options.shouldStopAutoResume();
-      } catch (authorityError) {
-        failClosed = {
-          cause: authorityError,
-          endReason: "sealed-acceptance authority failed closed"
-        };
-      }
-      if (failClosed === void 0 && sealedStop) {
-        if (result2 !== void 0) {
-          const terminal = result2.terminal;
-          if (terminal !== void 0) presentTerminal(terminal, options.io);
+    if (options.sealedAcceptanceDisposition !== void 0) {
+      const disposition = await options.sealedAcceptanceDisposition();
+      if (disposition.kind === "block") {
+        if (disposition.reason === "sealed-accepted" && result2 !== void 0) {
+          const terminal2 = result2.terminal;
+          if (terminal2 !== void 0) presentTerminal(terminal2, options.io);
           return result2;
         }
-        failClosed = {
-          cause: lastThrownError,
-          endReason: "sealed accepted projection already present"
-        };
-      }
-      if (failClosed !== void 0) {
         const terminal = dispatchExceptionFailureTerminal({
           role: options.admitted.role,
           runId: options.admitted.runId,
-          causeError: failClosed.cause,
+          causeError: disposition.reason === "authority-failed" ? disposition.cause : lastThrownError,
           errorFiles: retainedErrorFiles,
           autoResumeAttempts,
-          endReason: failClosed.endReason,
+          endReason: disposition.reason === "authority-failed" ? "sealed-acceptance authority failed closed" : "sealed accepted projection already present",
           everyAttemptThrew
         });
         await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
@@ -28338,7 +28312,7 @@ async function runPostAdmissionResumable(input) {
     autoResumeLimit: env.autoResumeLimit,
     buildInitialPayload: buildInitialRequest,
     buildResumePayload: buildResumeRequest,
-    shouldStopAutoResume: async () => hasSealedAcceptedProjection(admitted),
+    sealedAcceptanceDisposition: () => sealedAcceptanceRedispatchDisposition(admitted),
     dispatch: (request, lease, _isFirst, attemptIo) => dispatchPostAdmissionTurn({
       admitted,
       env: {
@@ -28370,22 +28344,15 @@ async function runPostAdmissionManualResume(input) {
       };
     }
   } catch (error) {
-    let failClosed;
-    try {
-      if (await hasSealedAcceptedProjection(admitted)) {
-        failClosed = { cause: error };
-      }
-    } catch (authorityError) {
-      failClosed = { cause: authorityError };
-    }
-    if (failClosed !== void 0) {
+    const disposition = await sealedAcceptanceRedispatchDisposition(admitted);
+    if (disposition.kind === "block") {
       return await presentControlledFailure2(
         admitted,
         {
           timedOut: false,
           code: null,
           stderr: "",
-          thrown: failClosed.cause
+          thrown: disposition.reason === "authority-failed" ? disposition.cause : error
         },
         adapters,
         env.principalAuthority,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.3391",
+  "version": "0.1.3403",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/public-cli/auto-resume.ts

@@ -31,7 +31,11 @@ import {
 } from "./run-lifecycle.ts";
 import { parseAutoResumeLimit } from "./config.ts";
 import { isLawfulTypedTerminalOutcome, formatTerminalResult, type TerminalArtifactRef, type TerminalResult, type TerminalRoleName } from "./terminal.ts";
-import { presentFailureTerminal, presentStructuralRejection } from "./settlement.ts";
+import {
+  presentFailureTerminal,
+  presentStructuralRejection,
+  type SealedAcceptanceRedispatchDisposition,
+} from "./settlement.ts";
 import type { CliIo } from "./cli-io.ts";
 
 const dummyIo: CliIo = { stdout: () => {}, stderr: () => {} };
@@ -343,11 +347,12 @@ export async function runWithAutoResumeLoop<
   buildResumePayload: () => TPayload;
   dispatch: (payload: TPayload, lease: RunWriterLease, isFirst: boolean, attemptIo: CliIo) => Promise<T>;
   /**
-   * After a non-lawful terminal or dispatch throw, stop further auto-resume when a unique sealed
-   * accepted projection is already readable (publication miss must not redispatch
-   * and destroy the sealed read — #648 / #599 alignment).
+   * After a non-lawful terminal or dispatch throw, consult settlement-owned
+   * sealed-acceptance redispatch disposition (#672 / ADR 0080). Publication
+   * miss must not redispatch and destroy the sealed read (#648 / #599).
+   * Loop presents entry-specific terminals; it must not rebuild the gate.
    */
-  shouldStopAutoResume?: () => Promise<boolean>;
+  sealedAcceptanceDisposition?: () => Promise<SealedAcceptanceRedispatchDisposition>;
 }): Promise<T> {
   // #422 single-point resolution + domain validation. NaN would bypass every
   // `attempts >= limit` comparison (always false) — reject here, before any dispatch.
@@ -431,42 +436,30 @@ export async function runWithAutoResumeLoop<
       }
     }
 
-    // One sealed ledger authority before any redispatch (#648): shared for
-    // non-lawful return and direct throw. Authority throw fail-closes with
-    // preserved cause — never wash into unsealed redispatch. Only the sealed=true
-    // projection differs (present returned terminal vs throw-path synthetic).
-    // Fail-closed decision is independent of cause value: `throw undefined` is
-    // legal JS and must not fail open. One cause + endReason → one presentation.
-    if (options.shouldStopAutoResume !== undefined) {
-      let failClosed: { cause: unknown; endReason: string } | undefined;
-      let sealedStop = false;
-      try {
-        sealedStop = await options.shouldStopAutoResume();
-      } catch (authorityError) {
-        failClosed = {
-          cause: authorityError,
-          endReason: "sealed-acceptance authority failed closed",
-        };
-      }
-      if (failClosed === undefined && sealedStop) {
-        if (result !== undefined) {
+    // Settlement-owned sealed disposition before any redispatch (#648 / #672):
+    // shared for non-lawful return and direct throw. Only entry presentation
+    // differs (present returned terminal vs throw-path synthetic).
+    if (options.sealedAcceptanceDisposition !== undefined) {
+      const disposition = await options.sealedAcceptanceDisposition();
+      if (disposition.kind === "block") {
+        if (disposition.reason === "sealed-accepted" && result !== undefined) {
           const terminal = (result as { terminal?: TerminalResult }).terminal;
           if (terminal !== undefined) presentTerminal(terminal, options.io);
           return result;
         }
-        failClosed = {
-          cause: lastThrownError,
-          endReason: "sealed accepted projection already present",
-        };
-      }
-      if (failClosed !== undefined) {
         const terminal = dispatchExceptionFailureTerminal({
           role: options.admitted.role,
           runId: options.admitted.runId,
-          causeError: failClosed.cause,
+          causeError:
+            disposition.reason === "authority-failed"
+              ? disposition.cause
+              : lastThrownError,
           errorFiles: retainedErrorFiles,
           autoResumeAttempts,
-          endReason: failClosed.endReason,
+          endReason:
+            disposition.reason === "authority-failed"
+              ? "sealed-acceptance authority failed closed"
+              : "sealed accepted projection already present",
           everyAttemptThrew,
         });
         await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);

package/src/public-cli/post-admission.ts

@@ -57,7 +57,7 @@ import {
   resolveAuditedRunnerFailureResolution,
   resolveControlledFailureResumeObservation,
   settleFailureTerminalResult,
-  hasSealedAcceptedProjection,
+  sealedAcceptanceRedispatchDisposition,
 } from "./settlement.ts";
 import type { CliIo } from "./cli-io.ts";
 import type { AdmittedRoleInvocation } from "./invocation.ts";
@@ -547,8 +547,8 @@ export async function runPostAdmissionResumable<
     autoResumeLimit: env.autoResumeLimit,
     buildInitialPayload: buildInitialRequest,
     buildResumePayload: buildResumeRequest,
-    shouldStopAutoResume: async () =>
-      hasSealedAcceptedProjection(admitted),
+    sealedAcceptanceDisposition: () =>
+      sealedAcceptanceRedispatchDisposition(admitted),
     dispatch: (request, lease, _isFirst, attemptIo) =>
       dispatchPostAdmissionTurn({
         admitted,
@@ -614,27 +614,21 @@ export async function runPostAdmissionManualResume<
       };
     }
   } catch (error) {
-    // Sealed accepted + publication/settle throw must fail closed without redispatch
-    // (#648 / #599): do not treat "sealed + publish threw" as "not sealed".
-    // Ledger authority failure also fail-closes with preserved cause (never wash to unsealed).
-    // Fail-closed decision is independent of cause value: `throw undefined` is legal JS
-    // and must not fail open. One cause → one presentation (settle vs authority).
-    let failClosed: { cause: unknown } | undefined;
-    try {
-      if (await hasSealedAcceptedProjection(admitted)) {
-        failClosed = { cause: error };
-      }
-    } catch (authorityError) {
-      failClosed = { cause: authorityError };
-    }
-    if (failClosed !== undefined) {
+    // Settlement-owned sealed disposition (#648 / #599 / #672): sealed accepted +
+    // publication/settle throw fail closed without redispatch; authority failure
+    // preserves true cause. Manual resume only presents — does not rebuild the gate.
+    const disposition = await sealedAcceptanceRedispatchDisposition(admitted);
+    if (disposition.kind === "block") {
       return (await presentControlledFailure(
         admitted,
         {
           timedOut: false,
           code: null,
           stderr: "",
-          thrown: failClosed.cause,
+          thrown:
+            disposition.reason === "authority-failed"
+              ? disposition.cause
+              : error,
         },
         adapters,
         env.principalAuthority,

package/src/public-cli/settlement.ts

@@ -13,7 +13,6 @@ import {
 } from "../analyst-gate-cycles-read.ts";
 import { readSitianRecords, resolveSitianRecordPath, sitianReport } from "../sitian-facade.ts";
 import {
-  latestUserAttemptId,
   readAuditEscalationSubmission,
   readLatestSubmissionOutcome,
   readSealedSubmission,
@@ -164,32 +163,41 @@ async function sealedLedgerOutcome(admitted: AdmittedRoleInvocation): Promise<Ex
 }
 
 /**
- * Shared sealed-accepted detection for all resumable adapters (#648).
- * Ledger projection is the sole authority — not optional per-role adapter wiring.
+ * Shared sealed-acceptance redispatch disposition for resume entrypoints
+ * (#648 sealed authority; #672 / ADR 0080 single-settlement-disposition).
+ * Owns the fail-closed gate auto and manual resume previously rebuilt beside
+ * the shared sealed query: sealed → block; authority throw → block with
+ * 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.
  */
-export async function hasSealedAcceptedProjection(
+export type SealedAcceptanceRedispatchDisposition =
+  | { readonly kind: "allow" }
+  | { readonly kind: "block"; readonly reason: "sealed-accepted" }
+  | { readonly kind: "block"; readonly reason: "authority-failed"; readonly cause: unknown };
+
+export async function sealedAcceptanceRedispatchDisposition(
   admitted: AdmittedRoleInvocation,
-): Promise<boolean> {
-  // Ledger authority must not wash read failure into "unsealed" (#648).
-  // Callers treat throw as fail-closed: preserve true cause, never redispatch.
-  return (await sealedLedgerOutcome(admitted)) !== undefined;
+): Promise<SealedAcceptanceRedispatchDisposition> {
+  try {
+    if ((await sealedLedgerOutcome(admitted)) !== undefined) {
+      return { kind: "block", reason: "sealed-accepted" };
+    }
+    return { kind: "allow" };
+  } catch (cause) {
+    // Ledger authority must not wash read failure into "unsealed" (#648).
+    return { kind: "block", reason: "authority-failed", cause };
+  }
 }
 
 async function auditEscalationLedgerOutcome(
   admitted: AdmittedRoleInvocation,
   role: TerminalRoleName,
-  authority: DurablePrincipalAuthority,
 ): Promise<Extract<TerminalRoleOutcome, { kind: "audit_escalation" }> | undefined> {
-  let currentAttemptId: string | undefined;
-  if (role === "coder" || role === "fixer") {
-    const entries = await readBoundSessionEntries(coordinatesFromAdmitted(authority, admitted).sessionFile);
-    currentAttemptId = latestUserAttemptId(entries);
-  }
   const projection = await readAuditEscalationSubmission(
     admitted.projectRoot,
     admitted.runId,
     sealedLedgerHome(admitted),
-    currentAttemptId,
   );
   if (projection?.role !== role) return undefined;
   return projection;
@@ -198,12 +206,11 @@ async function auditEscalationLedgerOutcome(
 async function closedLedgerOutcome(
   admitted: AdmittedRoleInvocation,
   role: TerminalRoleName,
-  authority: DurablePrincipalAuthority,
 ): Promise<Extract<TerminalRoleOutcome, { kind: "accepted" | "audit_escalation" }> | undefined> {
   const sealed = await sealedLedgerOutcome(admitted);
   return sealed?.role === role
     ? sealed
-    : auditEscalationLedgerOutcome(admitted, role, authority);
+    : auditEscalationLedgerOutcome(admitted, role);
 }
 
 /** Transitional host-session reads remain only for non-sealed failure and audit evidence. */
@@ -2513,7 +2520,7 @@ export async function readLawfulJudgeRoleOutcome(
     };
   }
   // Non-final: consume ledger audit-escalation projection (no JSONL accepted rebuild).
-  return auditEscalationLedgerOutcome(admitted, "judge", authority);
+  return auditEscalationLedgerOutcome(admitted, "judge");
 }
 
 /**
@@ -2590,7 +2597,7 @@ async function settleLawfulCoderTerminalResult(
     readonly methodProvenance?: PackagedMethodSkillProvenance;
   } = {},
 ): Promise<TerminalResult | undefined> {
-  const ledgerOutcome = await closedLedgerOutcome(admitted, "coder", authority);
+  const ledgerOutcome = await closedLedgerOutcome(admitted, "coder");
   if (ledgerOutcome === undefined) return undefined;
   let roleOutcome: TerminalRoleOutcome = ledgerOutcome;
   let output: CoderOutput | undefined;
@@ -2778,7 +2785,7 @@ async function settleLawfulFixerTerminalResult(
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult | undefined> {
-  const ledgerOutcome = await closedLedgerOutcome(admitted, "fixer", authority);
+  const ledgerOutcome = await closedLedgerOutcome(admitted, "fixer");
   if (ledgerOutcome === undefined) return undefined;
   let roleOutcome: TerminalRoleOutcome = ledgerOutcome;
   let output: FixerOutput | undefined;
@@ -3071,7 +3078,7 @@ async function settleLawfulDoctorTerminalResult(
   const { sessionDirectory, sessionFile } = coordinates;
   const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
   if (sealed?.role !== "doctor") {
-    const escalation = await auditEscalationLedgerOutcome(admitted, "doctor", authority);
+    const escalation = await auditEscalationLedgerOutcome(admitted, "doctor");
     if (escalation === undefined) return undefined;
     const artifacts = await publishDoctorArtifacts(admitted, escalation, coordinates);
     return withOptionalGateProjection(
@@ -3196,7 +3203,7 @@ async function settleLawfulSeatAcceptedTerminalResult(
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
   const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-  const roleOutcome = await closedLedgerOutcome(admitted, spec.role as TerminalRoleName, authority);
+  const roleOutcome = await closedLedgerOutcome(admitted, spec.role as TerminalRoleName);
   if (roleOutcome?.kind === "audit_escalation") {
     const navigator = extractNavigatorFact(entries);
     return withOptionalGateProjection(

package/src/submission-ledger.ts

@@ -56,22 +56,8 @@ function runIdentity(context: HostContext): string {
   throw new Error("提交账需要已受理的 run 身份");
 }
 
-export function latestUserAttemptId(
-  entries: Iterable<{ readonly id?: unknown; readonly message?: { readonly role?: unknown } }>,
-): string | undefined {
-  const ordered = [...entries];
-  for (let index = ordered.length - 1; index >= 0; index -= 1) {
-    const entry = ordered[index];
-    if (entry?.message?.role === "user" && typeof entry.id === "string") return entry.id;
-  }
-  return undefined;
-}
-
 function attemptIdentity(context: HostContext, runId: string): string {
-  return latestUserAttemptId(context.sessionManager.getEntries?.() ?? [])
-    ?? context.sessionManager.getHeader?.()?.id
-    ?? context.sessionManager.getLeafId?.()
-    ?? `${runId}:initial`;
+  return context.sessionManager.getHeader?.()?.id ?? context.sessionManager.getLeafId?.() ?? `${runId}:initial`;
 }
 
 function isAcceptedProjection(value: unknown): value is Extract<TerminalRoleOutcome, { kind: "accepted" }> {
@@ -139,18 +125,13 @@ export async function readAuditEscalationSubmission(
   cwd: string,
   runId: string,
   home?: string,
-  currentAttemptId?: string,
 ): Promise<AuditEscalationSubmissionProjection | undefined> {
   const { owned } = await readOwnedSubmissionRecords(cwd, runId, home);
-  const latestAttemptId = currentAttemptId ?? (owned.at(-1)?.subject as { attemptId?: unknown } | undefined)?.attemptId;
-  if (typeof latestAttemptId !== "string") return undefined;
   for (let index = owned.length - 1; index >= 0; index -= 1) {
     const record = owned[index];
-    if ((record?.subject as { attemptId?: unknown } | undefined)?.attemptId !== latestAttemptId) continue;
     if (record?.kind !== "outcome") continue;
     const payload = record.payload as Partial<Extract<SubmissionLedgerEvent, { type: "outcome" }>> | undefined;
-    if (payload?.type !== "outcome") continue;
-    if (payload.outcome !== "audit-escalation") return undefined;
+    if (payload?.type !== "outcome" || payload.outcome !== "audit-escalation") continue;
     if (isAuditEscalationTerminalProjection(payload.projection)) return payload.projection;
   }
   return undefined;