@akagilnc/pi-workflow-roles 0.1.5375 → 0.1.5406

package/dist/public-cli/instruction-seat-run.js

@@ -6,13 +6,16 @@
 import { dirname, resolve } from "node:path";
 import { isUnboundRunDirectory } from "../role-run-placement.js";
 import { AUDITOR_DOSSIER_PROMPT } from "../compliance-transport.js";
-import { bookDirectOfficerRunPointer } from "../archivist-record-pointer.js";
+import { bookDirectOfficerRunPointer, readDirectOfficerRunPointer } from "../archivist-record-pointer.js";
 import { createPiDoctorAuditor } from "../doctor-auditor.js";
 import { officerConclusionReask, gateOfficerForSubject } from "../gatekeeper-role.js";
+import { receivedDiscriminator } from "../submission-errors.js";
+import { REVIEW_QUEUE_STATUSES } from "../review-submission.js";
 import { runJudgeGates } from "../judge-role.js";
 import { WORKER_DONE_STATUSES } from "../worker-submission-contracts.js";
 import { SECRETARIAT_GATE_OFFICER_ENTRY_TYPE } from "../secretariat-contracts.js";
 import { readableGateItem } from "../readable-gate-item.js";
+import { deliveryLimitFromConfig } from "../receipt-delivery-policy.js";
 import { runIdFromRunDirectory } from "../run-terminal-artifacts.js";
 import { createDefaultGateOfficerSummon, requireSubmissionGate } from "../submission-gate.js";
 import { readRecordedSubmissionRows } from "../submission-ledger.js";
@@ -27,17 +30,16 @@ import { readAuditorResumeBinding } from "../auditor-soul.js";
 import { CliUsageError } from "./cli-errors.js";
 import { admitPublicRole, bindAdmittedTicketNumber, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedSourceRunPath, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, withPreparedAttachments, } from "./invocation.js";
 import { presentControlledFailure, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
-import { buildAutoResumeContinuationPrompt, loadResumablePublicRole, markRunAdmitted, parentRunPathFromGatePointerInstruction, } from "./run-lifecycle.js";
+import { buildAutoResumeContinuationPrompt, loadResumablePublicRole, markRunAdmitted, parentRunPathFromGatePointerInstruction, readCurrentCourt, } from "./run-lifecycle.js";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
 import { presentStructuralRejection, readBoundSessionEntries, seatKnownFailureResolver, attachPostAuditProjection, trySettlePublicSeat, } from "./settlement.js";
 import { warnMissingMethodSkills } from "./machine-method-skills.js";
-import { formatTerminalResult, isLawfulTypedTerminalOutcome, } from "./terminal.js";
-import { admittedSeatTurnDetails, projectPublicTurnAxes, projectRoleTurnRequest, requiredMethodSkills, } from "./turn-request.js";
+import { coalesceSubmissionRows, formatTerminalResult, isLawfulTypedTerminalOutcome, } from "./terminal.js";
+import { admittedSeatTurnDetails, projectRoleTurnRequest, requiredMethodSkills, } from "./turn-request.js";
 import { invokeCourtDiarist, latestPayloadEscalated, } from "./countersign-run.js";
 import { isRecord, errorText } from "../unknown-value.js";
 const AUDITED_ROLES = new Set(["judge", "fixer", "coder", "secretariat", "countersign", "doctor"]);
 const SECRETARIAT_STATUS_REASK = "secretariatStatus 不是 converged、escalate 之一。请重新交卷，secretariatStatus 写明其一。";
-const COUNTERSIGN_STATUS_REASK = "status 不是 converged、continue、escalate 三态之一。请重新交卷，status 写明其一。";
 const WORKER_ROUTING_STATUSES = new Set([
     "planned", "completed", "refused", "partially_completed", "unfinished",
 ]);
@@ -46,8 +48,7 @@ const DOCTOR_ROUTING_STATUSES = new Set(["completed", "refused"]);
 const DOCTOR_STATUS_REASK = "status 不是 completed、refused 之一。请重新交卷，status 写明其一。";
 const POST_SUBMISSION_ROUTING = {
     judge: {
-        statuses: new Set(["converged", "continue", "escalate"]),
-        reask: "status 不是 converged、continue、escalate 三态之一。请重新交卷，status 写明其一。",
+        statuses: REVIEW_QUEUE_STATUSES,
     },
     coder: {
         statuses: WORKER_ROUTING_STATUSES,
@@ -75,18 +76,88 @@ function unreadablePostSubmissionStatus(admitted, terminal) {
     if (route === undefined)
         return undefined;
     const payload = terminal.roleOutcome.payloads?.at(-1);
-    const status = isRecord(payload)
-        ? payload.status
-        : undefined;
+    const status = receivedDiscriminator(payload, "status");
     return typeof status === "string" && route.statuses.has(status)
         ? undefined
-        : route.reask;
+        : route.reask ?? officerConclusionReask(status);
+}
+/**
+ * One more unreadable-status reask. This loop has its own counter and reads
+ * the same autoResumeLimit as the other loops. Exhaustion is not a readable
+ * status: the caller presents the volumes already in hand and does not advance
+ * review. ADR 0007 audit continues are not this shape.
+ */
+function withUnreadableReask(env) {
+    const spent = env.unreadableReasksSpent ?? 0;
+    if (spent >= deliveryLimitFromConfig(env.autoResumeLimit))
+        return undefined;
+    return { ...env, unreadableReasksSpent: spent + 1 };
+}
+/** Budget spent on an unreadable status. Distinct from "status is readable". */
+const UNREADABLE_REASK_EXHAUSTED = { unreadableReaskExhausted: true };
+function isUnreadableReaskExhausted(value) {
+    return value === UNREADABLE_REASK_EXHAUSTED;
+}
+function presentOriginalVolume(held, terminal, io) {
+    // The held buffer was formatted before direction facts were attached.
+    if (terminal?.roleOutcome.decisiveFacts?.directionUnsettled === true) {
+        io.stdout(formatTerminalResult(terminal));
+        return;
+    }
+    if (held.length > 0) {
+        for (const value of held)
+            io.stdout(value);
+        return;
+    }
+    if (terminal !== undefined)
+        io.stdout(formatTerminalResult(terminal));
+}
+/** Runtime fact beside the original volume. Payloads stay as submitted. */
+function withUnsettledDirection(parent, officer) {
+    const outcome = parent.roleOutcome;
+    if (outcome.kind !== "accepted" && outcome.kind !== "audit_escalation")
+        return parent;
+    const officerOutcome = officer?.roleOutcome;
+    const officerPayloads = coalesceSubmissionRows(officer?.submissions, officerOutcome !== undefined && officerOutcome.kind !== "no_receipt"
+        ? officerOutcome.payloads
+        : undefined);
+    return {
+        ...parent,
+        roleOutcome: {
+            ...outcome,
+            decisiveFacts: {
+                ...(outcome.decisiveFacts ?? {}),
+                directionUnsettled: true,
+                subsequentAudit: "incomplete",
+                ...(officerOutcome === undefined ? {} : { officerRole: officerOutcome.role }),
+                ...(officer?.runId === undefined ? {} : { officerRunId: officer.runId }),
+                ...(officerPayloads.length === 0 ? {} : { officerPayloads }),
+            },
+        },
+    };
+}
+function heldUnreadableTerminal(terminal) {
+    if (terminal?.roleOutcome.kind !== "accepted")
+        return false;
+    if (latestPayloadEscalated(terminal.roleOutcome))
+        return false;
+    const status = latestQueueStatus(terminal);
+    return typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status);
+}
+function presentUnsettledAudit(parent, officer, io) {
+    const terminal = withUnsettledDirection(parent, officer);
+    io.stdout(formatTerminalResult(terminal));
+    if (officer !== undefined)
+        io.stdout(formatTerminalResult(officer));
+    return terminal;
 }
-async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io) {
-    const message = unreadablePostSubmissionStatus(admitted, terminal);
+async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io, message = unreadablePostSubmissionStatus(admitted, terminal)) {
     if (message === undefined)
         return undefined;
-    return runPublicInstructionSeatResume({ runId: admitted.runId, message }, { ...env, autoResumeLimit: 0 }, io);
+    const next = withUnreadableReask(env);
+    if (next === undefined)
+        return UNREADABLE_REASK_EXHAUSTED;
+    return runPublicInstructionSeatResume({ runId: admitted.runId, message }, next, io);
 }
 function roleRecord(role) {
     const record = packagedRoleMetadata(role);
@@ -234,6 +305,13 @@ async function dispatchAdmitted(admitted, env, io) {
     };
     const result = await execute(env);
     const unreadableReask = await reaskUnreadablePostSubmissionStatus(admitted, result.terminal, env, io);
+    if (isUnreadableReaskExhausted(unreadableReask)) {
+        const terminal = result.terminal === undefined
+            ? undefined
+            : withUnsettledDirection(result.terminal);
+        presentOriginalVolume(held, terminal, io);
+        return terminal === undefined ? result : { ...result, terminal };
+    }
     if (unreadableReask !== undefined)
         return unreadableReask;
     if (AUDITED_ROLES.has(admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
@@ -389,20 +467,14 @@ async function runCountersignBody(parsed, env, io) {
                 await persistAdmittedSourceRunPath(admitted, gateParentRunPath);
                 admitted = { ...admitted, sourceRunPath: gateParentRunPath };
             }
-            const turnProjection = {
-                ...projectPublicTurnAxes(env),
-                ...(env.correlationId === undefined || env.correlationId.trim() === ""
-                    ? {}
-                    : { correlationId: env.correlationId }),
-                continuation: {
-                    kind: "initial",
-                    prompt: (env.reviewReask ?? env.gateReviewInstruction)
-                        ?? buildInstructionTransportPrompt(admitted, engineSessionMaterialFromOptions({
-                            ...pickEngineAxis(env),
-                            packageRoot: env.packageRoot,
-                        })),
-                },
-            };
+            const turnProjection = roleTurnOptions(env, admitted, {
+                kind: "initial",
+                prompt: (env.reviewReask ?? env.gateReviewInstruction)
+                    ?? buildInstructionTransportPrompt(admitted, engineSessionMaterialFromOptions({
+                        ...pickEngineAxis(env),
+                        packageRoot: env.packageRoot,
+                    })),
+            });
             const turnRequest = buildInstructionSeatTurnRequest(admitted, turnProjection);
             const result = await runPostAdmissionOneShot({
                 admitted,
@@ -679,13 +751,37 @@ export async function runPublicInstructionSeatResume(request, env, io) {
             },
             afterAdmittedLoad: async (admitted) => {
                 await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
-                return { kind: "continue", adapters: seatAdapters(admitted, env) };
+                const adapters = seatAdapters(admitted, env);
+                if ((env.unreadableReasksSpent ?? 0) === 0 && env.reviewReask === undefined) {
+                    return { kind: "continue", adapters };
+                }
+                const original = await adapters.trySettle(admitted, env.principalAuthority, await readCurrentCourt(admitted.runDirectory));
+                const unsettled = POST_SUBMISSION_ROUTING[admitted.role] === undefined
+                    ? heldUnreadableTerminal(original)
+                    : unreadablePostSubmissionStatus(admitted, original) !== undefined;
+                // Select this reask's existing subject before dispatch. The common
+                // settlement then keeps it only when no fresh receipt supersedes it;
+                // actual failures still take their normal failure path.
+                return {
+                    kind: "continue",
+                    adapters: original === undefined || !unsettled ? adapters : {
+                        ...adapters,
+                        trySettle: async (seat, authority, scope) => await adapters.trySettle(seat, authority, scope) ?? original,
+                    },
+                };
             },
             ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
         });
         const unreadableReask = result.admitted === undefined
             ? undefined
             : await reaskUnreadablePostSubmissionStatus(result.admitted, result.terminal, env, io);
+        if (isUnreadableReaskExhausted(unreadableReask)) {
+            const terminal = result.terminal === undefined
+                ? undefined
+                : withUnsettledDirection(result.terminal);
+            presentOriginalVolume(held, terminal, io);
+            return terminal === undefined ? result : { ...result, terminal };
+        }
         if (unreadableReask !== undefined)
             return unreadableReask;
         if (result.admitted !== undefined && AUDITED_ROLES.has(result.admitted.role)
@@ -716,31 +812,49 @@ export async function runPublicInstructionSeatResume(request, env, io) {
     }
     return resume();
 }
-const QUEUE_CONCLUSIONS = new Set(["converged", "continue", "escalate"]);
 const GATE_CHILD_ROLES = new Set(["notary", "auditor", "inspector", "countersign"]);
 /**
  * A gate child's conclusion outside the three states goes back to that child.
- * The words are the existing officer re-ask. A host failure stops here.
+ * The words are the existing officer re-ask. Each reask spends this loop's own
+ * copy of the configured ceiling; exhaustion keeps the terminal already in hand.
+ * A host failure stops here.
+ * Countersign already spends that ceiling inside its own seat, or the summoning
+ * gate does. This loop does not open a second one for the same conclusion.
  */
 async function queueConclusionFromChild(child, env, io) {
     if (!GATE_CHILD_ROLES.has(child.role))
         return undefined;
+    if (child.role === "countersign") {
+        const terminal = await trySettlePublicSeat(child, env.principalAuthority, await readCurrentCourt(child.runDirectory));
+        const status = latestQueueStatus(terminal);
+        if (terminal !== undefined && typeof status === "string" && REVIEW_QUEUE_STATUSES.has(status)) {
+            return { admitted: child, terminal, status };
+        }
+        return { stop: { exitCode: 0, ...(terminal === undefined ? {} : { terminal }) } };
+    }
     let current = child;
+    // Notary, auditor, and inspector have no seat-local status reask. This loop
+    // is their one budget. The child resume keeps the caller's env so delivery,
+    // failure recovery, and other reask loops stay separate.
+    let budgetEnv = { ...env, unreadableReasksSpent: 0 };
     for (;;) {
-        const terminal = await trySettlePublicSeat(current, env.principalAuthority, undefined);
+        const terminal = await trySettlePublicSeat(current, env.principalAuthority, await readCurrentCourt(current.runDirectory));
         const status = latestQueueStatus(terminal);
-        if (terminal !== undefined && status !== undefined && QUEUE_CONCLUSIONS.has(status)) {
+        if (terminal !== undefined && typeof status === "string" && REVIEW_QUEUE_STATUSES.has(status)) {
             return { admitted: current, terminal, status };
         }
-        const reasked = await runPublicInstructionSeatResume({
-            runId: current.runId,
-            message: officerConclusionReask(status),
-        }, env, io);
-        if (reasked.exitCode !== 0 || reasked.admitted === undefined || reasked.terminal === undefined) {
+        const reasked = await reaskUnreadablePostSubmissionStatus(current, terminal, budgetEnv, io, officerConclusionReask(status));
+        if (reasked === undefined || isUnreadableReaskExhausted(reasked)) {
+            return { stop: { exitCode: 0, ...(terminal === undefined ? {} : { terminal }) } };
+        }
+        budgetEnv = withUnreadableReask(budgetEnv);
+        if (reasked.exitCode !== 0 || reasked.admitted === undefined || reasked.terminal === undefined
+            || reasked.terminal.roleOutcome.kind === "no_receipt"
+            || reasked.terminal.roleOutcome.decisiveFacts?.directionUnsettled === true) {
             return { stop: reasked };
         }
         const reaskedStatus = latestQueueStatus(reasked.terminal);
-        if (reaskedStatus !== undefined && QUEUE_CONCLUSIONS.has(reaskedStatus)) {
+        if (typeof reaskedStatus === "string" && REVIEW_QUEUE_STATUSES.has(reaskedStatus)) {
             return { admitted: reasked.admitted, terminal: reasked.terminal, status: reaskedStatus };
         }
         if (latestPayloadEscalated(reasked.terminal.roleOutcome))
@@ -756,8 +870,20 @@ export async function continueParentAfterChild(parentRunId, child, env, io) {
     }
     const admitted = loaded.admitted;
     const resolved = await queueConclusionFromChild(child, env, io);
-    if (resolved !== undefined && "stop" in resolved)
-        return resolved.stop;
+    if (resolved !== undefined && "stop" in resolved) {
+        const stopped = resolved.stop;
+        if (stopped.exitCode === 0
+            && heldUnreadableTerminal(stopped.terminal)
+            && stopped.terminal !== undefined) {
+            const parentTerminal = await trySettlePublicSeat(admitted, env.principalAuthority, undefined);
+            if (parentTerminal?.roleOutcome.kind === "accepted"
+                || parentTerminal?.roleOutcome.kind === "audit_escalation") {
+                const terminal = presentUnsettledAudit(parentTerminal, stopped.terminal, io);
+                return { exitCode: 0, admitted, terminal };
+            }
+        }
+        return stopped;
+    }
     if (resolved !== undefined && resolved.status === "escalate") {
         return { exitCode: 0, admitted: resolved.admitted, terminal: resolved.terminal };
     }
@@ -766,19 +892,50 @@ export async function continueParentAfterChild(parentRunId, child, env, io) {
             const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, undefined);
             if (terminal?.roleOutcome.kind !== "accepted")
                 throw new Error("pending submission is not recorded");
-            return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, resolved.admitted.role, latestQueuePayload(resolved.terminal), resolved.admitted.runId);
+            return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, resolved.admitted, latestQueuePayload(resolved.terminal));
         }
         return runPublicInstructionSeatResume({
             runId: parentRunId,
             message: readableGateItem(latestQueuePayload(resolved.terminal)),
-        }, { ...env, autoResumeLimit: 0 }, io);
+        }, { ...env, unreadableReasksSpent: 0 }, io);
     }
     const result = await dispatchAdmitted(admitted, env, { ...io, omitFailureStderrDiagnostic: true });
     showResumeErrorPointer(io, result.exitCode, result.terminal);
     return result;
 }
+/**
+ * A gate is already passed only when an officer run reviewed this submission
+ * and its latest queue word is converged. The resumed seat's role is not itself
+ * a pass. Unknown or unreadable evidence does not skip the gate.
+ */
+async function officerPassedCurrentSubmission(input) {
+    const { env, officer } = input;
+    const pointer = await readDirectOfficerRunPointer(input.parentSessionFile, officer);
+    if (pointer?.runDirectory === undefined)
+        return false;
+    if (pointer.submissionToolCallId !== input.toolCallId)
+        return false;
+    const officerRunId = runIdFromRunDirectory(pointer.runDirectory);
+    if (officerRunId === undefined)
+        return false;
+    let admitted;
+    try {
+        const loaded = await loadResumablePublicRole(env.home, officerRunId, env.principalAuthority);
+        admitted = loaded.admitted;
+    }
+    catch {
+        return false;
+    }
+    if (admitted.role !== officer)
+        return false;
+    // A summon binding identifies the requested review, not its outcome. An open
+    // court (including a failed host turn) must not borrow a previous court's seal.
+    const court = await readCurrentCourt(admitted.runDirectory);
+    const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, court);
+    return latestQueueStatus(terminal) === "converged";
+}
 /** Finished submissions enter the existing audit gate after their tool call has returned. */
-async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, passedRunId) {
+async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt) {
     const admitted = turn.admitted;
     if (admitted === undefined || !AUDITED_ROLES.has(admitted.role)
         || turn.terminal?.roleOutcome.kind !== "accepted")
@@ -789,11 +946,30 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
     const record = isRecord(accepted)
         ? accepted : undefined;
     const status = admitted.role === "secretariat" ? record?.secretariatStatus : record?.status;
+    // A gate summon already owns this conclusion's reasks. The seat must not
+    // start another budget on the same run (parentRunPath is that summon).
+    const gateOwnsStatusReask = typeof env.parentRunPath === "string" && env.parentRunPath.trim() !== "";
     if (admitted.role === "secretariat" && status !== "converged" && status !== "escalate") {
-        return runPublicInstructionSeatResume({ runId: admitted.runId, message: SECRETARIAT_STATUS_REASK }, { ...env, autoResumeLimit: 0 }, io);
+        if (gateOwnsStatusReask)
+            return turn;
+        const next = withUnreadableReask(env);
+        if (next === undefined) {
+            const terminal = withUnsettledDirection(turn.terminal);
+            io.stdout(formatTerminalResult(terminal));
+            return { ...turn, terminal };
+        }
+        return runPublicInstructionSeatResume({ runId: admitted.runId, message: SECRETARIAT_STATUS_REASK }, next, io);
     }
-    if (admitted.role === "countersign" && (typeof status !== "string" || !QUEUE_CONCLUSIONS.has(status))) {
-        return runPublicInstructionSeatResume({ runId: admitted.runId, message: COUNTERSIGN_STATUS_REASK }, { ...env, autoResumeLimit: 0 }, io);
+    if (admitted.role === "countersign" && (typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status))) {
+        if (gateOwnsStatusReask)
+            return turn;
+        const next = withUnreadableReask(env);
+        if (next === undefined) {
+            const terminal = withUnsettledDirection(turn.terminal);
+            io.stdout(formatTerminalResult(terminal));
+            return { ...turn, terminal };
+        }
+        return runPublicInstructionSeatResume({ runId: admitted.runId, message: officerConclusionReask(status) }, next, io);
     }
     // Self-escalation is a valid open routing state for these seats only.
     // Doctor's declared domain is completed|refused — an open "escalate" must
@@ -830,11 +1006,18 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
         },
         abort() { },
     };
+    const passedThisSubmission = (officer) => officerPassedCurrentSubmission({
+        env,
+        parentSessionFile: sessionFile,
+        officer,
+        toolCallId,
+    });
     if (admitted.role === "doctor") {
-        if (passedOfficer !== "auditor") {
+        if (!await passedThisSubmission("auditor")) {
             let lastSummon;
             const decision = await createPiDoctorAuditor()({
                 context, submission: accepted,
+                ...(env.autoResumeLimit === undefined ? {} : { autoResumeLimit: env.autoResumeLimit }),
                 ...(env.signal === undefined ? {} : { signal: env.signal }),
                 summonAuditor: async (subject, sourceRunDirectory, signal, reask, submission) => {
                     const summoned = await summonPublicRole({
@@ -854,6 +1037,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
                     if (officerSession !== undefined) {
                         bookDirectOfficerRunPointer({
                             parentSessionFile: sessionFile, officer: "auditor", sessionFile: officerSession,
+                            submissionToolCallId: toolCallId,
                             ...(summoned.runDirectory === undefined ? {} : { runDirectory: summoned.runDirectory }),
                         });
                     }
@@ -864,7 +1048,16 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
             if (decision.status === "continue") {
                 return runPublicInstructionSeatResume({
                     runId: admitted.runId, message: readableGateItem(decision.receipt ?? decision.violations),
-                }, { ...env, autoResumeLimit: 0 }, io);
+                }, { ...env, unreadableReasksSpent: 0 }, io);
+            }
+            if (decision.status === "received") {
+                if (lastSummon?.terminal === undefined) {
+                    throw new Error("doctor audit kept an unreadable reply with no terminal");
+                }
+                if (turn.terminal === undefined)
+                    throw new Error("doctor submission has no terminal");
+                const terminal = presentUnsettledAudit(turn.terminal, lastSummon.terminal, io);
+                return { exitCode: 0, admitted, terminal };
             }
             if (decision.status !== "converged") {
                 if (lastSummon?.terminal !== undefined) {
@@ -886,13 +1079,14 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
             ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
         });
         let chain;
-        let officerRunId = passedRunId;
+        let officerRunId = resumedOfficer?.runId;
         const runGate = (subject) => requireSubmissionGate({
             context,
             subject,
             toolCallId,
             submission: accepted,
             summonOfficer,
+            ...(env.autoResumeLimit === undefined ? {} : { autoResumeLimit: env.autoResumeLimit }),
             ...(env.signal === undefined ? {} : { signal: env.signal }),
             hostActions: {
                 failInfrastructure(error) { throw error; },
@@ -901,8 +1095,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
         });
         if (admitted.role === "judge") {
             chain = await runJudgeGates({
-                gateAlreadyConverged: async (subject) => passedOfficer === "auditor"
-                    || (passedOfficer === "notary" && subject.kind === "judge_draft"),
+                gateAlreadyConverged: async (subject) => passedThisSubmission(gateOfficerForSubject(subject)),
                 runGate,
             });
         }
@@ -913,7 +1106,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
                     ? { kind: "secretariat_verdict" }
                     : { kind: "countersign_verdict" };
             const officer = gateOfficerForSubject(subject);
-            if (passedOfficer === officer) {
+            if (await passedThisSubmission(officer)) {
                 chain = { status: "converged", passes: [] };
             }
             else {
@@ -929,10 +1122,20 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
                             receipt: pass.receipt,
                             ...(pass.runId === undefined ? {} : { runId: pass.runId }),
                             ...(pass.runDirectory === undefined ? {} : { runDirectory: pass.runDirectory }),
+                            ...(pass.terminal === undefined ? {} : { terminal: pass.terminal }),
                         }],
                 };
             }
         }
+        if (chain.status === "needs_reask") {
+            const officerTerminal = chain.passes.at(-1)?.terminal;
+            if (officerTerminal === undefined)
+                throw new Error("unreadable audit has no terminal result");
+            if (turn.terminal === undefined)
+                throw new Error("audited submission has no terminal");
+            const terminal = presentUnsettledAudit(turn.terminal, officerTerminal, io);
+            return { exitCode: 0, admitted, terminal };
+        }
         if (chain.status === "escalate") {
             const escalation = chain.passes.at(-1);
             const escalatedRunId = escalation?.runId
@@ -941,7 +1144,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
             if (escalatedRunId === undefined)
                 throw new Error("escalated audit has no resumable run identity");
             const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority);
-            const terminal = await trySettlePublicSeat(officer.admitted, env.principalAuthority, undefined);
+            const terminal = await trySettlePublicSeat(officer.admitted, env.principalAuthority, await readCurrentCourt(officer.admitted.runDirectory));
             if (terminal === undefined)
                 throw new Error("escalated audit has no terminal result");
             io.stdout(formatTerminalResult(terminal));
@@ -951,7 +1154,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
             return runPublicInstructionSeatResume({
                 runId: admitted.runId,
                 message: readableGateItem(chain.passes.at(-1)?.receipt),
-            }, { ...env, autoResumeLimit: 0 }, io);
+            }, { ...env, unreadableReasksSpent: 0 }, io);
         }
         if (admitted.role === "secretariat") {
             const pass = chain.passes.at(-1);