@akagilnc/pi-workflow-roles 0.1.3891 → 0.1.3900

package/dist/public-cli/post-admission.js

@@ -40,6 +40,30 @@ async function readInvocationHost(runDirectory) {
         throw error;
     }
 }
+/**
+ * Factory-seat resume method-material face (#833): one authority for
+ * load → adapters / controlled-failure short-circuit. Seats only declare
+ * irreducible differences (loader, adapter factories, optional gate, knownCause).
+ */
+export async function resolveResumeMethodMaterialAdapters(input) {
+    if (input.shouldLoad === false) {
+        return { kind: "continue", adapters: input.emptyAdapters };
+    }
+    try {
+        const material = await input.loadMaterial();
+        return { kind: "continue", adapters: input.adaptersWith(material) };
+    }
+    catch (error) {
+        const terminal = await presentControlledFailure(input.admitted, {
+            timedOut: false,
+            code: null,
+            stderr: "",
+            thrown: error,
+            ...(input.knownCause === undefined ? {} : { knownCause: input.knownCause }),
+        }, input.emptyAdapters, input.authority, input.io);
+        return { kind: "terminal", ...terminal };
+    }
+}
 export async function presentControlledFailure(admitted, failureInput, adapters, authority, io) {
     const hasThrown = Object.hasOwn(failureInput, "thrown");
     const resumeObservation = await resolveControlledFailureResumeObservation({
@@ -219,7 +243,7 @@ export async function dispatchPostAdmissionTurn(input) {
             }, adapters, env.principalAuthority, io));
         }
         if (settled !== undefined && shouldPresent(settled)) {
-            // This court sealed — drop open-court pointer so bare resume is run-scoped idempotent.
+            // This court sealed — drop open-court pointer (bare resume no longer continues it).
             if (settled.roleOutcome.kind === "accepted" &&
                 request.courtAttemptId !== undefined &&
                 request.courtAttemptId.length > 0) {
@@ -326,6 +350,7 @@ export function resumeTurnRequestProjectionOptions(admitted, request, env, summo
             kind: "resume",
             prompt,
         },
+        ...(request.message === undefined ? {} : { courtAttemptId: randomUUID() }),
     };
 }
 function isAlreadyFrozenSummonsAttachment(runDirectory, attachmentPath) {
@@ -360,9 +385,10 @@ export async function prepareSummonsResumeMaterials(runDirectory, summons) {
 }
 /**
  * Shared manual-resume orchestration for seats whose continuation is the
- * package resume envelope (#599 / #633): load → structural rejection → seat
- * turn projection → runPostAdmissionManualResume. Seat-owned loader validation,
- * turn builder, and adapters stay on the seat.
+ * package resume envelope (#599 / #633): load once → structural rejection →
+ * optional seat afterAdmittedLoad (method material / controlled failure) →
+ * seat turn projection → runPostAdmissionManualResume. Seat-owned loader
+ * validation, turn builder, and adapters stay on the seat.
  *
  * Court open/recovery transaction (#637): under the existing writer lease,
  * read currentCourt, judge seal, clear (bound to the judged court id), freeze,
@@ -370,8 +396,8 @@ export async function prepareSummonsResumeMaterials(runDirectory, summons) {
  */
 export async function runPostAdmissionSeatResume(input) {
     let request = input.request;
-    // Load once for runDirectory / structural rejection; court identity is judged
-    // only after the writer lease is held (below).
+    // Load once for runDirectory / structural rejection / afterAdmittedLoad;
+    // court identity is judged only after the writer lease is held (below).
     let loaded;
     try {
         loaded = await input.load(request);
@@ -383,20 +409,28 @@ export async function runPostAdmissionSeatResume(input) {
         }
         throw error;
     }
-    // Entire court recovery / open path runs after lease. forceContinuation skips
-    // the pre-lease sealed short-circuit; when the after-lease builder leaves no
-    // courtAttemptId, manual resume still presents run-scoped sealed idempotence
-    // under the same held lease.
+    let adapters = input.adapters;
+    if (input.afterAdmittedLoad !== undefined) {
+        const prepared = await input.afterAdmittedLoad(loaded.admitted);
+        if (prepared.kind === "terminal") {
+            return {
+                exitCode: prepared.exitCode,
+                admitted: prepared.admitted,
+                terminal: prepared.terminal,
+            };
+        }
+        adapters = prepared.adapters;
+    }
+    // Court recovery / open under lease, then always dispatch (resume is pass-through).
     try {
         return await runPostAdmissionManualResume({
             admitted: loaded.admitted,
             env: input.env,
             io: input.io,
-            adapters: input.adapters,
+            adapters,
             ...(input.effectiveEngine === undefined
                 ? {}
                 : { effectiveEngine: input.effectiveEngine }),
-            forceContinuation: true,
             buildRequestAfterLease: async () => {
                 let openCourtAttemptId;
                 // Build uses the admitted judged under this lease (rehydrated when open
@@ -450,10 +484,11 @@ export async function runPostAdmissionSeatResume(input) {
                     }
                 }
                 let turnRequest = await input.buildTurnRequest(admittedForBuild, request);
-                // Court path only when continuing an open court or opening a new summons court.
-                // Bare resume with no open court (or cleared sealed pointer) keeps no
-                // courtAttemptId so run-scoped sealed idempotence can present under lease.
-                if (openCourtAttemptId !== undefined || request.summons !== undefined) {
+                // Open court continue, or new court for summons / message re-review
+                // (clause 0 新庭可再交卷; #833). Bare resume without open court omits id.
+                if (openCourtAttemptId !== undefined ||
+                    request.summons !== undefined ||
+                    request.message !== undefined) {
                     const courtAttemptId = openCourtAttemptId ??
                         (turnRequest.courtAttemptId !== undefined &&
                             turnRequest.courtAttemptId.length > 0
@@ -543,79 +578,15 @@ export async function runPostAdmissionResumable(input) {
     });
 }
 /**
- * Single authority for manual-resume run-scoped sealed-accepted presentation
- * (#599 / #648 / #672 / #637). Used both before lease (eager request path) and
- * after court-recovery builder under lease when no courtAttemptId remains.
- * Returns undefined to fall through to dispatch; never rebuilds the gate.
- */
-async function presentSealedAcceptedManualResumeIfAny(input) {
-    const { admitted, env, io, adapters, shouldPresent } = input;
-    try {
-        const existing = await adapters.trySettle(admitted, env.principalAuthority);
-        if (existing !== undefined &&
-            existing.roleOutcome.kind === "accepted" &&
-            shouldPresent(existing)) {
-            existing.autoResumeCount = 0;
-            io.stdout(formatTerminalResult(existing));
-            return {
-                exitCode: exitCodeForTerminalOutcome(existing.roleOutcome),
-                admitted,
-                terminal: existing,
-            };
-        }
-    }
-    catch (error) {
-        // Settlement-owned sealed disposition: sealed accepted + publication/settle
-        // throw fail closed without redispatch; authority failure preserves cause.
-        const disposition = await sealedAcceptanceRedispatchDisposition(admitted);
-        if (disposition.kind === "block") {
-            return (await presentControlledFailure(admitted, {
-                timedOut: false,
-                code: null,
-                stderr: "",
-                thrown: disposition.reason === "authority-failed"
-                    ? disposition.cause
-                    : error,
-            }, adapters, env.principalAuthority, io));
-        }
-        // Pre-dispatch settle failure without a sealed accepted projection is not
-        // proof of seal; fall through to dispatch so the attempt path can settle
-        // or fail honestly.
-    }
-    return undefined;
-}
-/**
- * Shared post-admission manual resume path: acquire writer lease and dispatch turn.
- * When the submission ledger is already sealed, project that accepted terminal
- * idempotently — do not dispatch a doomed turn that would append
- * post-seal-anomaly and erase the sealed read (#599; keep #416 open load).
- * Same-ticket re-summons (#637) pass forceContinuation + courtAttemptId so a new
- * court turn still runs with this summons' materials despite a prior sealed
- * acceptance, while submission-ledger sole-final stays per-attempt.
+ * Manual resume: lease + dispatch. Pass-through to the host — no sealed-accepted
+ * short-circuit (#833 / #416). Court open (summons / message / open court) is
+ * built under lease when using buildRequestAfterLease; sole-final stays per-attempt.
  */
 export async function runPostAdmissionManualResume(input) {
-    const { admitted, env, io, adapters, effectiveEngine, forceContinuation, buildRequestAfterLease, } = input;
+    const { admitted, env, io, adapters, effectiveEngine, buildRequestAfterLease, } = input;
     let request = input.request;
     // #617 DK-3: manual resume writes the live seat/env model (same as new legs).
     const effectiveModel = env.model;
-    const shouldPresent = adapters.shouldPresentSettled ??
-        ((terminal) => isLawfulTypedTerminalOutcome(terminal.roleOutcome));
-    const sealedIdempotenceInput = {
-        admitted,
-        env,
-        io,
-        adapters,
-        shouldPresent,
-    };
-    // Sealed accepted receipt only — audit_escalation / residual failure must not
-    // short-circuit; those still need a real continuation turn.
-    // Same-ticket re-summons / court recovery forceContinuation skips the pre-lease
-    // face; post-builder reuses the same presenter when no courtAttemptId remains.
-    if (forceContinuation !== true && request !== undefined) {
-        const presented = await presentSealedAcceptedManualResumeIfAny(sealedIdempotenceInput);
-        if (presented !== undefined)
-            return presented;
-    }
     let lease;
     let staleWriterLeaseReclaimed;
     try {
@@ -644,8 +615,8 @@ export async function runPostAdmissionManualResume(input) {
         throw error;
     }
     // Court open/recovery under held lease until dispatch owns release (finally
-    // below). Builder, sealed presenter, and any throw on this seam must release
-    // here — dispatch's finally only runs after handoff.
+    // below). Builder and any throw on this seam must release here — dispatch's
+    // finally only runs after handoff.
     let handedOffToDispatch = false;
     try {
         if (request === undefined) {
@@ -653,18 +624,6 @@ export async function runPostAdmissionManualResume(input) {
                 throw new Error("runPostAdmissionManualResume requires request or buildRequestAfterLease");
             }
             request = await buildRequestAfterLease();
-            if (request.courtAttemptId === undefined ||
-                request.courtAttemptId.length === 0) {
-                const presented = await presentSealedAcceptedManualResumeIfAny(sealedIdempotenceInput);
-                if (presented !== undefined) {
-                    return {
-                        ...presented,
-                        ...(staleWriterLeaseReclaimed === true
-                            ? { staleWriterLeaseReclaimed: true }
-                            : {}),
-                    };
-                }
-            }
         }
         handedOffToDispatch = true;
         const result = await dispatchPostAdmissionTurn({

package/dist/public-cli/run-lifecycle.js

@@ -417,9 +417,9 @@ export async function recordCurrentCourt(runDirectory, court) {
 }
 /**
  * Clear open court after this courtAttemptId seals, or when the open court is
- * already sealed and bare resume returns to run-scoped idempotence (#637).
- * When expectedCourtAttemptId is set, clear only if it still matches — never
- * drop a different court recorded under the writer lease after our judgment.
+ * already sealed (#637). When expectedCourtAttemptId is set, clear only if it
+ * still matches — never drop a different court recorded under the writer lease
+ * after our judgment.
  */
 export async function clearCurrentCourt(runDirectory, expectedCourtAttemptId) {
     const current = await readRoleRunStateDisk(runDirectory);

package/dist/public-cli/settlement.js

@@ -1810,8 +1810,8 @@ async function readLawfulSettlementEntries(sessionFile) {
  * Returns undefined for genuine absence (missing path / no lawful verdict).
  * Session-read failures propagate with typed identity.
  */
-export async function readLawfulJudgeRoleOutcome(admitted, authority) {
-    const sealed = await sealedLedgerOutcome(admitted);
+export async function readLawfulJudgeRoleOutcome(admitted, authority, scope) {
+    const sealed = await sealedLedgerOutcome(admitted, scope);
     if (sealed?.role === "judge") {
         const details = sealed.decisiveFacts;
         // sealed.status is the sole authority (written by acceptedFacts at seal).
@@ -1824,7 +1824,7 @@ export async function readLawfulJudgeRoleOutcome(admitted, authority) {
         };
     }
     // Non-final: consume ledger audit-escalation projection (no JSONL accepted rebuild).
-    return auditEscalationLedgerOutcome(admitted, "judge");
+    return auditEscalationLedgerOutcome(admitted, "judge", scope);
 }
 /**
  * Single lawful-settlement implementation (session → outcome/Navigator/artifacts).
@@ -1837,8 +1837,8 @@ export async function readLawfulJudgeRoleOutcome(admitted, authority) {
  * - Lawful outcome presence is decided before publication so a later write error
  *   cannot erase the fact that a lawful result already exists.
  */
-async function settleLawfulJudgeTerminalResult(admitted, authority) {
-    const roleOutcome = await readLawfulJudgeRoleOutcome(admitted, authority);
+async function settleLawfulJudgeTerminalResult(admitted, authority, scope) {
+    const roleOutcome = await readLawfulJudgeRoleOutcome(admitted, authority, scope);
     if (roleOutcome === undefined)
         return undefined;
     const coordinates = coordinatesFromAdmitted(authority, admitted);
@@ -1858,8 +1858,8 @@ async function settleLawfulJudgeTerminalResult(admitted, authority) {
  * Throws when no lawful outcome is present (tests/callers that require success).
  * Session-read and publication failures retain their typed identity.
  */
-export async function settleJudgeTerminalResult(admitted, authority) {
-    const settled = await settleLawfulJudgeTerminalResult(admitted, authority);
+export async function settleJudgeTerminalResult(admitted, authority, scope) {
+    const settled = await settleLawfulJudgeTerminalResult(admitted, authority, scope);
     if (settled === undefined) {
         throw new Error("Judge Role run completed without a lawful typed terminal result");
     }
@@ -1870,11 +1870,11 @@ export async function settleJudgeTerminalResult(admitted, authority) {
  * Returns undefined only for genuine absence (no lawful verdict / missing path).
  * Session malformation and publication exceptions propagate with typed identity.
  */
-export async function trySettleJudgeTerminalResult(admitted, authority) {
-    return settleLawfulJudgeTerminalResult(admitted, authority);
+export async function trySettleJudgeTerminalResult(admitted, authority, scope) {
+    return settleLawfulJudgeTerminalResult(admitted, authority, scope);
 }
-async function settleLawfulCoderTerminalResult(admitted, authority, options = {}) {
-    const ledgerOutcome = await closedLedgerOutcome(admitted, "coder");
+async function settleLawfulCoderTerminalResult(admitted, authority, options = {}, scope) {
+    const ledgerOutcome = await closedLedgerOutcome(admitted, "coder", scope);
     if (ledgerOutcome === undefined)
         return undefined;
     // #757: sealed facts pass through — no shape re-project / field drop.
@@ -1899,8 +1899,8 @@ async function settleLawfulCoderTerminalResult(admitted, authority, options = {}
     }, coordinates.sessionDirectory);
 }
 /** Settle a lawful Coder Terminal from the admitted session (shared #106 success interface). */
-export async function settleCoderTerminalResult(admitted, authority, options = {}) {
-    const settled = await settleLawfulCoderTerminalResult(admitted, authority, options);
+export async function settleCoderTerminalResult(admitted, authority, options = {}, scope) {
+    const settled = await settleLawfulCoderTerminalResult(admitted, authority, options, scope);
     if (settled === undefined) {
         throw new Error("Coder Role run completed without a lawful typed terminal result");
     }
@@ -1995,8 +1995,8 @@ export async function publishFixerArtifacts(admitted, roleOutcome, coordinates,
         { kind: "evidence", path: evidencePath },
     ];
 }
-async function settleLawfulFixerTerminalResult(admitted, authority, options) {
-    const ledgerOutcome = await closedLedgerOutcome(admitted, "fixer");
+async function settleLawfulFixerTerminalResult(admitted, authority, options, scope) {
+    const ledgerOutcome = await closedLedgerOutcome(admitted, "fixer", scope);
     if (ledgerOutcome === undefined)
         return undefined;
     // #757: sealed facts pass through — no shape re-project / field drop.
@@ -2027,8 +2027,8 @@ async function settleLawfulFixerTerminalResult(admitted, authority, options) {
     }, sessionDirectory);
 }
 /** Settle a lawful Fixer Terminal from the admitted session (shared #106 success interface). */
-export async function settleFixerTerminalResult(admitted, authority, options) {
-    const settled = await settleLawfulFixerTerminalResult(admitted, authority, options);
+export async function settleFixerTerminalResult(admitted, authority, options, scope) {
+    const settled = await settleLawfulFixerTerminalResult(admitted, authority, options, scope);
     if (settled === undefined) {
         throw new Error("Fixer Role run completed without a lawful typed terminal result");
     }
@@ -2068,11 +2068,11 @@ export async function publishCollectorArtifacts(admitted, roleOutcome, coordinat
         { kind: "evidence", path: evidencePath },
     ];
 }
-async function settleLawfulCollectorTerminalResult(admitted, authority) {
+async function settleLawfulCollectorTerminalResult(admitted, authority, scope) {
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     const { sessionDirectory, sessionFile } = coordinates;
     const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-    const roleOutcome = await sealedLedgerOutcome(admitted);
+    const roleOutcome = await sealedLedgerOutcome(admitted, scope);
     if (roleOutcome?.role !== "collector") {
         // Bounded to the current attempt so multi-attempt resume timeout/no-output
         // is not masked by a prior wait-tool residual (#633).
@@ -2122,16 +2122,16 @@ async function settleLawfulCollectorTerminalResult(admitted, authority) {
     }, sessionDirectory);
 }
 /** Settle a lawful Collector Terminal from the admitted session. */
-export async function settleCollectorTerminalResult(admitted, authority) {
-    const settled = await settleLawfulCollectorTerminalResult(admitted, authority);
+export async function settleCollectorTerminalResult(admitted, authority, scope) {
+    const settled = await settleLawfulCollectorTerminalResult(admitted, authority, scope);
     if (settled === undefined) {
         throw new Error("Collector Role run completed without a lawful typed terminal result");
     }
     return settled;
 }
 /** Try to settle a lawful Collector Terminal; undefined only for genuine absence. */
-export async function trySettleCollectorTerminalResult(admitted, authority) {
-    return settleLawfulCollectorTerminalResult(admitted, authority);
+export async function trySettleCollectorTerminalResult(admitted, authority, scope) {
+    return settleLawfulCollectorTerminalResult(admitted, authority, scope);
 }
 export async function publishDoctorArtifacts(admitted, roleOutcome, coordinates, options = {}) {
     await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
@@ -2167,13 +2167,13 @@ export async function publishDoctorArtifacts(admitted, roleOutcome, coordinates,
         { kind: "evidence", path: evidencePath },
     ];
 }
-async function settleLawfulDoctorTerminalResult(admitted, authority) {
-    const sealed = await sealedLedgerOutcome(admitted);
+async function settleLawfulDoctorTerminalResult(admitted, authority, scope) {
+    const sealed = await sealedLedgerOutcome(admitted, scope);
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     const { sessionDirectory, sessionFile } = coordinates;
     const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
     if (sealed?.role !== "doctor") {
-        const escalation = await auditEscalationLedgerOutcome(admitted, "doctor");
+        const escalation = await auditEscalationLedgerOutcome(admitted, "doctor", scope);
         if (escalation === undefined)
             return undefined;
         const artifacts = await publishDoctorArtifacts(admitted, escalation, coordinates);
@@ -2213,16 +2213,16 @@ async function settleLawfulDoctorTerminalResult(admitted, authority) {
     }, sessionDirectory);
 }
 /** Settle a lawful Doctor Terminal from the admitted session. */
-export async function settleDoctorTerminalResult(admitted, authority) {
-    const settled = await settleLawfulDoctorTerminalResult(admitted, authority);
+export async function settleDoctorTerminalResult(admitted, authority, scope) {
+    const settled = await settleLawfulDoctorTerminalResult(admitted, authority, scope);
     if (settled === undefined) {
         throw new Error("Doctor Role run completed without a lawful typed terminal result");
     }
     return settled;
 }
 /** Try to settle a lawful Doctor Terminal; undefined only for genuine absence. */
-export async function trySettleDoctorTerminalResult(admitted, authority) {
-    return settleLawfulDoctorTerminalResult(admitted, authority);
+export async function trySettleDoctorTerminalResult(admitted, authority, scope) {
+    return settleLawfulDoctorTerminalResult(admitted, authority, scope);
 }
 /** Latest top-level user message index; 0 when the session has none (initial attempt). */
 function currentAttemptStartIndex(entries) {
@@ -2388,12 +2388,12 @@ export async function trySettleAuditorTerminalResult(admitted, authority, scope)
     return settleLawfulAuditorTerminalResult(admitted, authority, scope);
 }
 /** Try to settle a lawful Coder Terminal; undefined only for genuine absence. */
-export async function trySettleCoderTerminalResult(admitted, authority, options = {}) {
-    return settleLawfulCoderTerminalResult(admitted, authority, options);
+export async function trySettleCoderTerminalResult(admitted, authority, options = {}, scope) {
+    return settleLawfulCoderTerminalResult(admitted, authority, options, scope);
 }
 /** Try to settle a lawful Fixer Terminal; undefined only for genuine absence. */
-export async function trySettleFixerTerminalResult(admitted, authority, options) {
-    return settleLawfulFixerTerminalResult(admitted, authority, options);
+export async function trySettleFixerTerminalResult(admitted, authority, options, scope) {
+    return settleLawfulFixerTerminalResult(admitted, authority, options, scope);
 }
 /**
  * Observe forced Reviewer code-review Skill expansions from the session.
@@ -2468,8 +2468,8 @@ export async function publishReviewerArtifacts(admitted, roleOutcome, coordinate
         { kind: "evidence", path: evidencePath },
     ];
 }
-async function settleLawfulReviewerTerminalResult(admitted, authority, options) {
-    const sealed = await sealedLedgerOutcome(admitted);
+async function settleLawfulReviewerTerminalResult(admitted, authority, options, scope) {
+    const sealed = await sealedLedgerOutcome(admitted, scope);
     if (sealed?.role !== "reviewer")
         return undefined;
     const coordinates = coordinatesFromAdmitted(authority, admitted);
@@ -2503,16 +2503,16 @@ async function settleLawfulReviewerTerminalResult(admitted, authority, options)
     }, sessionDirectory);
 }
 /** Settle a lawful Reviewer Terminal from the admitted session (shared #106 success interface). */
-export async function settleReviewerTerminalResult(admitted, authority, options) {
-    const settled = await settleLawfulReviewerTerminalResult(admitted, authority, options);
+export async function settleReviewerTerminalResult(admitted, authority, options, scope) {
+    const settled = await settleLawfulReviewerTerminalResult(admitted, authority, options, scope);
     if (settled === undefined) {
         throw new Error("Reviewer Role run completed without a lawful typed terminal result");
     }
     return settled;
 }
 /** Try to settle a lawful Reviewer Terminal; undefined only for genuine absence. */
-export async function trySettleReviewerTerminalResult(admitted, authority, options) {
-    return settleLawfulReviewerTerminalResult(admitted, authority, options);
+export async function trySettleReviewerTerminalResult(admitted, authority, options, scope) {
+    return settleLawfulReviewerTerminalResult(admitted, authority, options, scope);
 }
 /**
  * Observe forced Merger resolving-merge-conflicts Skill expansions from the session.
@@ -2579,14 +2579,14 @@ export async function publishMergerArtifacts(admitted, roleOutcome, coordinates,
         { kind: "evidence", path: evidencePath },
     ];
 }
-async function settleLawfulMergerTerminalResult(admitted, authority, options) {
+async function settleLawfulMergerTerminalResult(admitted, authority, options, scope) {
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     const { sessionDirectory, sessionFile } = coordinates;
     const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-    const roleOutcome = await sealedLedgerOutcome(admitted);
+    const roleOutcome = await sealedLedgerOutcome(admitted, scope);
     if (roleOutcome?.role !== "merger") {
         // Ledger owns 0041: a non-sole closed round is not residual-incomplete material.
-        const latestOutcome = await readLatestSubmissionOutcome(admitted.projectRoot, admitted.runId, sealedLedgerHome(admitted));
+        const latestOutcome = await readLatestSubmissionOutcome(admitted.projectRoot, admitted.runId, ledgerReadScope(admitted, scope));
         if (latestOutcome?.outcome === "correctable-rejection" && latestOutcome.code === "non-sole-round") {
             return undefined;
         }
@@ -2650,16 +2650,16 @@ async function settleLawfulMergerTerminalResult(admitted, authority, options) {
     }, sessionDirectory);
 }
 /** Settle a lawful Merger Terminal from the admitted session (shared #106 success interface). */
-export async function settleMergerTerminalResult(admitted, authority, options) {
-    const settled = await settleLawfulMergerTerminalResult(admitted, authority, options);
+export async function settleMergerTerminalResult(admitted, authority, options, scope) {
+    const settled = await settleLawfulMergerTerminalResult(admitted, authority, options, scope);
     if (settled === undefined) {
         throw new Error("Merger Role run completed without a lawful typed terminal result");
     }
     return settled;
 }
 /** Try to settle a lawful Merger Terminal; undefined only for genuine absence. */
-export async function trySettleMergerTerminalResult(admitted, authority, options) {
-    return settleLawfulMergerTerminalResult(admitted, authority, options);
+export async function trySettleMergerTerminalResult(admitted, authority, options, scope) {
+    return settleLawfulMergerTerminalResult(admitted, authority, options, scope);
 }
 function publicationAttemptFromError(path, error) {
     if (error instanceof Error) {

package/dist/public-cli/turn-request.js

@@ -21,5 +21,8 @@ export function projectRoleTurnRequest(admitted, roleDetails, options) {
             ? {}
             : { correlationId: options.correlationId }),
         ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+        ...(options.courtAttemptId === undefined || options.courtAttemptId.length === 0
+            ? {}
+            : { courtAttemptId: options.courtAttemptId }),
     };
 }

package/dist/submission-ledger.js

@@ -25,10 +25,10 @@ function runIdentity(context) {
     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.
+ * Court-turn attempt identity (#637 same-ticket re-summons / #833 message re-review).
+ * AK_ROLE_COURT_ATTEMPT is injected for a new court turn on an already-retained run
+ * (summons / message / open-court continue). Bare resume and first mint omit it so
+ * the session-stable id keeps sole-final per attempt.
  */
 export const COURT_ATTEMPT_ENV = "AK_ROLE_COURT_ATTEMPT";
 function attemptIdentity(context, runId) {
@@ -96,16 +96,15 @@ function recordsForAttempt(owned, attemptId) {
     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. */
+ * Omit attemptId for run-scoped latest sealed.
+ * Pass attemptId for the current court turn so a prior seal cannot wash this turn.
+ * post-seal-anomaly is forensic only — later turns must not erase an earlier seal (#833). */
 export async function readSealedSubmission(cwd, runId, homeOrScope) {
     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;

package/package.json

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

package/src/host-contracts.ts

@@ -179,9 +179,8 @@ export type RoleTurnRequest = {
   /** Set by post-admission only on a real host switch; never on same-host resume. */
   readonly hostTransition?: RoleTurnHostTransition;
   /**
-   * Same-ticket re-summons only (#637): opens a new court-turn attempt on the
-   * retained run so submission-ledger sole-final is per attempt, not forever.
-   * Manual resume never sets this — sealed idempotent short-circuit stays intact.
+   * Court-turn attempt (#637 / #833): sole-final per attempt. Open court, summons,
+   * and resume-with-message set this; bare resume without an open court omits it.
    */
   readonly courtAttemptId?: string;
 };