@akagilnc/pi-workflow-roles 0.1.5382 → 0.1.5406

package/dist/navigator-attendance.js

@@ -31,7 +31,10 @@ import {
 } from "./navigator-session-contracts.js";
 import { sitianReport } from "./sitian-facade.js";
 import { issueRoot, subjectPath } from "./work-subject-identity.js";
-import { createReceiptDeliveryPolicy, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE } from "./receipt-delivery-policy.js";
+import {
+  createReceiptDeliveryPolicy,
+  NO_RECEIPT_LIFECYCLE_ENTRY_TYPE
+} from "./receipt-delivery-policy.js";
 import { navigatorProseFromUnknown } from "./package-contracts/navigator-output.js";
 import { persistNavigatorWorkBase } from "./navigator-work-base.js";
 import { sha256Hex } from "./sha256.js";
@@ -250,8 +253,8 @@ function createNavigatorAttendance(options) {
     try {
       try {
         if (disposed) throw navigatorUnavailableError("session", new Error("Navigator attendance was disposed"));
-        const delivery = createReceiptDeliveryPolicy();
-        const promptAllowingRejectedPrepare = async (text, deliveryRequest) => {
+        const delivery = createReceiptDeliveryPolicy(options.deliveryRequestLimit);
+        const promptAllowingRejectedPrepare = async (text) => {
           await persistNavigatorWorkBase(activeSession.recordPointer(), { subject, authority });
           const entryStart = activeSession.entries().length;
           prepareBatchRejected = false;
@@ -278,17 +281,15 @@ function createNavigatorAttendance(options) {
             delivery.recordNestedNoReceipt(sessionNoReceipt);
             return;
           }
-          if (deliveryRequest && output === void 0) delivery.recordDeliveryRequest();
         };
-        await promptAllowingRejectedPrepare(request, false);
+        await promptAllowingRejectedPrepare(request);
         if (boundSettlement !== void 0) {
           while (output === void 0 && prepareBatchRejected && delivery.nextAction() === "request-delivery") {
-            await promptAllowingRejectedPrepare(JSON.stringify(delivery.deliveryState()), true);
+            delivery.recordDeliveryRequest();
+            await promptAllowingRejectedPrepare(JSON.stringify(delivery.deliveryState()));
           }
           if (output === void 0 && delivery.nextAction() === "request-delivery") {
-            while (delivery.nextAction() === "request-delivery") {
-              delivery.recordDeliveryRequest();
-            }
+            delivery.closeBudget();
           }
           if (output === void 0 && delivery.nextAction() === "no-receipt" && activeSession.providerFailure?.() === void 0) {
             const facts = delivery.facts({ runPointer: activeSession.recordPointer(), attemptPointer: invocationId });

package/dist/navigator-invocation-identity.js

@@ -86,6 +86,23 @@ function markerMatchesExpectedIdentity(marker, expected) {
   }
   return true;
 }
+function packagedRoleOutputRejectionReason(message) {
+  if (typeof message.toolName !== "string") return void 0;
+  if (!PACKAGED_ROLE_OUTPUT_TOOLS.has(message.toolName) && message.toolName !== "ak_submission_output") {
+    return void 0;
+  }
+  if (message.isError !== true) return void 0;
+  if (classifyPackagedRoleTerminalResult(message).kind !== "nonterminal") return void 0;
+  const content = message.content;
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+      return part.text;
+    }
+    return "";
+  }).join("").trim();
+}
 function classifyPackagedRoleTerminalResult(message) {
   if (typeof message.toolName !== "string") return { kind: "nonterminal" };
   if (!PACKAGED_ROLE_OUTPUT_TOOLS.has(message.toolName) && message.toolName !== "ak_submission_output") return { kind: "nonterminal" };
@@ -181,6 +198,7 @@ export {
   isNavigatorInfrastructureFailureFact,
   markerMatchesExpectedIdentity,
   mintNavigatorInvocationId,
+  packagedRoleOutputRejectionReason,
   parseInvocationMarkerIdentity,
   resolveLifecycleInvocationPrincipal
 };

package/dist/pi/role-turn-host.js

@@ -14,6 +14,7 @@ import { ExplicitInternalActivationError } from "../host-contracts.js";
 import { applyEngineChildEnv, ENGINE_MODEL_FLAG_NAME, normalizeEngineName } from "../engine-detour.js";
 import { projectActivationFlags } from "../role-activation-flags.js";
 import { encodeUserDialogueStdin } from "../user-dialogue-stdin.js";
+import { RECEIPT_DELIVERY_LIMIT_ENV } from "../receipt-delivery-policy.js";
 /** Package-relative Internal role entrypoint (ADR 0052; same path as public-cli registry). */
 const INTERNAL_ROLE_ENTRYPOINT_RELATIVE = "extensions/role-runtime.ts";
 export function resolveInternalRoleEntrypoint(packageRoot) {
@@ -307,6 +308,14 @@ export function createPiRoleTurnHost(config) {
                 delete env.AK_ROLE_HOST;
             else
                 env.AK_ROLE_HOST = request.host.trim();
+            // #1132: the one effective delivery-request ceiling travels to the child
+            // on its own env so the in-child role runtime and the worker submission
+            // gate count with the same configured number the AK seam resolved. Omit
+            // must not inherit a parent value (same rule as the other AK_ROLE_ axes).
+            if (request.deliveryRequestLimit === undefined)
+                delete env[RECEIPT_DELIVERY_LIMIT_ENV];
+            else
+                env[RECEIPT_DELIVERY_LIMIT_ENV] = String(request.deliveryRequestLimit);
             applyEngineChildEnv(env, request.engine);
             // Nested auditor dossier tool binds the parent run pointer when published.
             if (typeof process.env.AK_ROLE_AUDITOR_SOURCE_RUN === "string"

package/dist/public-cli/cli.js

@@ -846,6 +846,7 @@ export async function runAkRole(argv, env) {
             let current = result;
             while (current.exitCode === 0 && current.admitted?.correlationId !== undefined
                 && current.terminal?.roleOutcome.kind === "accepted"
+                && current.terminal.roleOutcome.decisiveFacts?.directionUnsettled !== true
                 && !latestPayloadEscalated(current.terminal.roleOutcome)) {
                 const parentRunId = current.admitted.correlationId;
                 resumeFailureContext = {

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";
@@ -29,12 +30,12 @@ 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"]);
@@ -80,11 +81,83 @@ 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;
+}
+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, 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);
@@ -232,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") {
@@ -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,
@@ -677,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)
@@ -717,23 +815,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));
+        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 && 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,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 };
     }
@@ -763,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")
@@ -786,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" || !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);
+            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
@@ -827,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({
@@ -851,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 }),
                         });
                     }
@@ -861,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) {
@@ -883,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; },
@@ -898,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,
             });
         }
@@ -910,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 {
@@ -926,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
@@ -938,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));
@@ -948,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);