@akagilnc/pi-workflow-roles 0.1.5382 → 0.1.5462

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

@@ -6,7 +6,7 @@
 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";
@@ -15,6 +15,7 @@ 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";
@@ -28,13 +29,14 @@ import { packagedAdmitsCountersign, packagedBindsBoardTicket, packagedRebindSour
 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 { presentControlledFailure, packageFaultNoteFor, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
+import { presentTerminal } from "./auto-resume.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 { presentStructuralRejection, readBoundSessionEntries, 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 { 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"]);
@@ -80,11 +82,81 @@ function unreadablePostSubmissionStatus(admitted, terminal) {
         ? undefined
         : route.reask ?? officerConclusionReask(status);
 }
-async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io) {
-    const message = unreadablePostSubmissionStatus(admitted, terminal);
+/**
+ * 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;
+}
+async function presentOriginalVolume(held, terminal, io, runDirectory) {
+    if (terminal !== undefined && runDirectory !== undefined) {
+        // Direction facts were attached after the held volume was formatted.
+        await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, runDirectory, terminal.roleOutcome.decisiveFacts?.directionUnsettled === true ? undefined : held);
+        return;
+    }
+    // No settled host report exists to preserve at this pre-result boundary.
+    for (const value of held)
+        io.stdout(value);
+}
+/** 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 = officer?.submissions !== undefined && officer.submissions.length > 0
+        ? officer.submissions
+        : officerOutcome !== undefined && officerOutcome.kind !== "no_receipt"
+            ? officerOutcome.payloads ?? []
+            : [];
+    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);
+}
+async function presentUnsettledAudit(parent, officer, io, runDirectory) {
+    const terminal = withUnsettledDirection(parent, officer);
+    await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, runDirectory);
+    if (officer !== undefined)
+        await presentTerminal(officer, { ...io, omitFailureStderrDiagnostic: true }, runDirectory);
+    return 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, summons: { instruction: message } }, next, io);
 }
 function roleRecord(role) {
     const record = packagedRoleMetadata(role);
@@ -108,10 +180,6 @@ function initialPrompt(admitted, env) {
         packageRoot: env.packageRoot,
     }));
 }
-function infraFailure(role) {
-    const resolveRunnerKnownFailure = seatKnownFailureResolver(role);
-    return resolveRunnerKnownFailure === undefined ? {} : { resolveRunnerKnownFailure };
-}
 function isBoardTicketSeat(seat) {
     return packagedBindsBoardTicket(seat.role);
 }
@@ -124,6 +192,9 @@ async function bindAndRelocateDiarist(admitted, authority, lease) {
     }
     return await relocateAdmittedRunToTicket(admitted, authority, lease);
 }
+function packageFaultScope(admitted, env, io) {
+    return { notePackageFault: packageFaultNoteFor(admitted, env, io) };
+}
 function seatAdapters(admitted, env) {
     const record = roleRecord(admitted.role);
     const present = "presentSettled" in record ? record.presentSettled : "default";
@@ -133,7 +204,6 @@ function seatAdapters(admitted, env) {
         ...(present === "typed"
             ? { shouldPresentSettled: (terminal) => isLawfulTypedTerminalOutcome(terminal.roleOutcome) }
             : {}),
-        ...infraFailure(admitted.role),
         ...(packagedBindsBoardTicket(admitted.role)
             ? {
                 beforeDispatch: async (seat, lease) => {
@@ -232,13 +302,19 @@ 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);
+        await presentOriginalVolume(held, terminal, io, admitted.runDirectory);
+        return terminal === undefined ? result : { ...result, terminal };
+    }
     if (unreadableReask !== undefined)
         return unreadableReask;
     if (AUDITED_ROLES.has(admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
         return auditSubmittedRole(result, env, io);
     }
-    for (const value of held)
-        io.stdout(value);
+    await presentOriginalVolume(held, result.terminal, io, admitted.runDirectory);
     return result;
 }
 /**
@@ -306,7 +382,11 @@ async function runOmittedLensBatch(argv, parsed, env, io) {
         },
         artifacts: terminals.flatMap((item) => item.artifacts),
     };
-    io.stdout(formatTerminalResult(terminal));
+    const childRunDirectory = children.completeness.admitted?.runDirectory ?? children.correctness.admitted?.runDirectory;
+    if (childRunDirectory !== undefined)
+        await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, childRunDirectory);
+    else
+        io.stdout(formatTerminalResult(terminal));
     return { exitCode: failed ? 1 : 0, terminal };
 }
 /**
@@ -387,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,
@@ -448,8 +522,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
         });
         if (result.terminal?.roleOutcome.kind === "accepted")
             return auditSubmittedRole(result, env, io);
-        for (const value of held)
-            io.stdout(value);
+        await presentOriginalVolume(held, result.terminal, io, result.admitted?.runDirectory);
         return result;
     }
     if ("parallelLenses" in record && record.parallelLenses === true) {
@@ -611,7 +684,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
             catch (error) {
                 return await presentControlledFailure(admitted, {
                     timedOut: false, code: null, stderr: "", thrown: error,
-                }, seatAdapters(admitted, env), env.principalAuthority, io);
+                }, seatAdapters(admitted, env), env.principalAuthority, io, true, packageFaultNoteFor(admitted, env, io));
             }
             if (outcome.admitted !== undefined && isUnboundRunDirectory(outcome.admitted.runDirectory)) {
                 await recordChildDiaristRun(admitted, outcome.admitted.runId);
@@ -620,12 +693,12 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
                 return await presentControlledFailure(admitted, {
                     timedOut: false, code: null, stderr: "",
                     thrown: new Error(outcome.failedWithoutEscalate.diagnostic),
-                }, seatAdapters(admitted, env), env.principalAuthority, io);
+                }, seatAdapters(admitted, env), env.principalAuthority, io, true, packageFaultNoteFor(admitted, env, io));
             }
             // The diarist's escalation pauses only the diarist's own run; call order
             // belongs to the caller, so the Secretariat still takes its own turn.
             if (outcome.identity.kind === "escalate" && outcome.terminal !== undefined) {
-                io.stdout(formatTerminalResult(outcome.terminal));
+                await presentTerminal(outcome.terminal, { ...io, omitFailureStderrDiagnostic: true }, outcome.admitted?.runDirectory ?? admitted.runDirectory);
             }
         }
         return dispatchAdmitted(admitted, env, io);
@@ -684,14 +757,20 @@ export async function runPublicInstructionSeatResume(request, env, io) {
         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);
+            await presentOriginalVolume(held, terminal, io, result.admitted?.runDirectory);
+            return terminal === undefined ? result : { ...result, terminal };
+        }
         if (unreadableReask !== undefined)
             return unreadableReask;
         if (result.admitted !== undefined && AUDITED_ROLES.has(result.admitted.role)
             && result.terminal?.roleOutcome.kind === "accepted") {
             return auditSubmittedRole(result, env, io);
         }
-        for (const value of held)
-            io.stdout(value);
+        await presentOriginalVolume(held, result.terminal, io, result.admitted?.runDirectory);
         return result;
     };
     let binding;
@@ -717,23 +796,42 @@ export async function runPublicInstructionSeatResume(request, env, io) {
 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), ...packageFaultScope(child, env, io) });
+        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), ...packageFaultScope(current, env, io) });
         const status = latestQueueStatus(terminal);
         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);
@@ -753,29 +851,72 @@ 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 = await presentUnsettledAudit(parentTerminal, stopped.terminal, io, admitted.runDirectory);
+                return { exitCode: 0, admitted, terminal };
+            }
+        }
+        return stopped;
+    }
     if (resolved !== undefined && resolved.status === "escalate") {
         return { exitCode: 0, admitted: resolved.admitted, terminal: resolved.terminal };
     }
     if (resolved !== undefined && (resolved.status === "continue" || resolved.status === "converged")) {
         if (AUDITED_ROLES.has(admitted.role) && resolved.status === "converged") {
-            const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, undefined);
+            const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, packageFaultScope(admitted, env, io));
             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);
+            summons: { instruction: readableGateItem(latestQueuePayload(resolved.terminal)) },
+        }, { ...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")
@@ -786,11 +927,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);
+            await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
+            return { ...turn, terminal };
+        }
+        return runPublicInstructionSeatResume({ runId: admitted.runId, summons: { instruction: SECRETARIAT_STATUS_REASK } }, next, io);
     }
     if (admitted.role === "countersign" && (typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status))) {
-        return runPublicInstructionSeatResume({ runId: admitted.runId, message: officerConclusionReask(status) }, { ...env, autoResumeLimit: 0 }, io);
+        if (gateOwnsStatusReask)
+            return turn;
+        const next = withUnreadableReask(env);
+        if (next === undefined) {
+            const terminal = withUnsettledDirection(turn.terminal);
+            await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
+            return { ...turn, terminal };
+        }
+        return runPublicInstructionSeatResume({ runId: admitted.runId, summons: { instruction: 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
@@ -802,7 +962,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
         || ((admitted.role === "fixer" || admitted.role === "coder")
             && (typeof status !== "string" || !WORKER_DONE_STATUSES.has(status)));
     if (skipAudit) {
-        io.stdout(formatTerminalResult(turn.terminal));
+        await presentTerminal(turn.terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
         return turn;
     }
     const rows = await readRecordedSubmissionRows(admitted.projectRoot, admitted.runId, env.home);
@@ -811,7 +971,9 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
     if (toolCallId === undefined)
         throw new Error("accepted submission has no tool call identity");
     const sessionFile = env.principalAuthority.decode(admitted.principal).sessionFile;
-    const entries = admitted.role === "doctor" ? await readBoundSessionEntries(sessionFile) : [];
+    const entries = admitted.role === "doctor"
+        ? await readBoundSessionEntries(sessionFile)
+        : [];
     const context = {
         cwd: admitted.projectRoot,
         mode: "print",
@@ -827,11 +989,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({
@@ -851,6 +1020,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 }),
                         });
                     }
@@ -860,12 +1030,21 @@ 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);
+                    runId: admitted.runId, summons: { instruction: readableGateItem(decision.receipt ?? decision.violations) },
+                }, { ...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 = await presentUnsettledAudit(turn.terminal, lastSummon.terminal, io, admitted.runDirectory);
+                return { exitCode: 0, admitted, terminal };
             }
             if (decision.status !== "converged") {
                 if (lastSummon?.terminal !== undefined) {
-                    io.stdout(formatTerminalResult(lastSummon.terminal));
+                    await presentTerminal(lastSummon.terminal, { ...io, omitFailureStderrDiagnostic: true }, lastSummon.admitted?.runDirectory ?? admitted.runDirectory);
                     return { exitCode: lastSummon.exitCode,
                         ...(lastSummon.admitted === undefined ? {} : { admitted: lastSummon.admitted }),
                         terminal: lastSummon.terminal };
@@ -883,13 +1062,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; },
@@ -898,8 +1078,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,
             });
         }
@@ -910,7 +1089,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 {
@@ -926,10 +1105,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 = await presentUnsettledAudit(turn.terminal, officerTerminal, io, admitted.runDirectory);
+            return { exitCode: 0, admitted, terminal };
+        }
         if (chain.status === "escalate") {
             const escalation = chain.passes.at(-1);
             const escalatedRunId = escalation?.runId
@@ -938,17 +1127,17 @@ 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), ...packageFaultScope(officer.admitted, env, io) });
             if (terminal === undefined)
                 throw new Error("escalated audit has no terminal result");
-            io.stdout(formatTerminalResult(terminal));
+            await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, officer.admitted.runDirectory);
             return { exitCode: 0, admitted: officer.admitted, terminal };
         }
         if (chain.status === "continue") {
             return runPublicInstructionSeatResume({
                 runId: admitted.runId,
-                message: readableGateItem(chain.passes.at(-1)?.receipt),
-            }, { ...env, autoResumeLimit: 0 }, io);
+                summons: { instruction: readableGateItem(chain.passes.at(-1)?.receipt) },
+            }, { ...env, unreadableReasksSpent: 0 }, io);
         }
         if (admitted.role === "secretariat") {
             const pass = chain.passes.at(-1);
@@ -966,8 +1155,8 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
     // settle would republish the same attempt.
     if (turn.terminal === undefined)
         throw new Error(`audited ${admitted.role} submission did not settle`);
-    const terminal = await attachPostAuditProjection(admitted, env.principalAuthority, turn.terminal);
+    const terminal = await attachPostAuditProjection(admitted, env.principalAuthority, turn.terminal, packageFaultScope(admitted, env, io));
     turn = { ...turn, terminal };
-    io.stdout(formatTerminalResult(terminal));
+    await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
     return turn;
 }