@akagilnc/pi-workflow-roles 0.1.5382 → 0.1.5406

package/dist/public-cli/main.js

@@ -17500,6 +17500,13 @@ function formatTerminalResult(result) {
       `diagnostic	${encodeTerminalField(result.roleOutcome.diagnostic)}`
     );
   }
+  if (result.roleOutcome.kind === "accepted" && result.roleOutcome.decisiveFacts?.directionUnsettled === true) {
+    lines.push("fact	directionUnsettled	true");
+    const subsequent = result.roleOutcome.decisiveFacts.subsequentAudit;
+    if (typeof subsequent === "string") {
+      lines.push(`fact	subsequentAudit	${encodeTerminalField(subsequent)}`);
+    }
+  }
   if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation" || result.roleOutcome.decisiveFacts?.failedAttempts !== void 0) {
     const facts = result.roleOutcome.kind === "accepted" ? { failedAttempts: result.roleOutcome.decisiveFacts?.failedAttempts } : result.roleOutcome.decisiveFacts ?? {};
     for (const [key, value] of Object.entries(facts)) {
@@ -17558,7 +17565,7 @@ function formatTerminalResult(result) {
       lines.push(`recorded-submission	${encodeTerminalField(rendered)}`);
     }
   } else {
-    const payloads = result.roleOutcome.kind === "accepted" || result.roleOutcome.kind === "audit_escalation" ? coalesceSubmissionRows(result.roleOutcome.payloads, result.submissions) : result.submissions ?? [];
+    const payloads = result.roleOutcome.kind === "accepted" || result.roleOutcome.kind === "audit_escalation" ? coalesceSubmissionRows(result.submissions, result.roleOutcome.payloads) : result.submissions ?? [];
     for (let i = payloads.length - 1; i >= 0; i -= 1) {
       const payload = payloads[i];
       const rendered = typeof payload === "string" ? payload : JSON.stringify(payload);
@@ -17574,6 +17581,223 @@ var init_terminal = __esm({
   }
 });
 
+// src/receipt-delivery-policy.ts
+function receiptAttemptPointer(runPointer, invocationScopeId) {
+  const scope = invocationScopeId?.trim() ?? "";
+  if (scope.length > 0) return `invocation:${scope}`;
+  return `current:${runPointer}`;
+}
+function deliveryLimitFromConfig(value) {
+  return parseAutoResumeLimit(value ?? AUTO_RESUME_LIMIT);
+}
+function deliveryTurnsFact(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new TypeError("deliveryTurns must be a non-negative integer");
+  }
+  return value;
+}
+function parseNoReceiptLifecycleFacts(input) {
+  if (!isRecord(input) || typeof input.terminalToolCalled !== "boolean" || input.sessionCompletion !== "settled-without-accepted-receipt" || input.acceptedReceipt !== false || typeof input.runPointer !== "string" || input.runPointer.trim() === "" || typeof input.attemptPointer !== "string" || input.attemptPointer.trim() === "" || !Array.isArray(input.rejectedReceipts) || !input.rejectedReceipts.every((item) => isRecord(item) && typeof item.reason === "string")) {
+    throw new TypeError("malformed no-receipt lifecycle facts");
+  }
+  return {
+    terminalToolCalled: input.terminalToolCalled,
+    rejectedReceipts: input.rejectedReceipts.map((item) => ({
+      reason: item.reason,
+      diagnosticAvailable: item.reason.trim() !== ""
+    })),
+    deliveryTurns: deliveryTurnsFact(input.deliveryTurns),
+    sessionCompletion: "settled-without-accepted-receipt",
+    runPointer: input.runPointer,
+    attemptPointer: input.attemptPointer,
+    acceptedReceipt: false
+  };
+}
+function noReceiptLifecycleFacts(input) {
+  return {
+    terminalToolCalled: input.terminalToolCalled,
+    rejectedReceipts: input.rejectedReceipts.map(({ reason }) => ({
+      reason,
+      diagnosticAvailable: reason.trim() !== ""
+    })),
+    deliveryTurns: deliveryTurnsFact(input.deliveryTurns),
+    sessionCompletion: "settled-without-accepted-receipt",
+    runPointer: input.runPointer,
+    attemptPointer: input.attemptPointer,
+    acceptedReceipt: false
+  };
+}
+function createReceiptDeliveryPolicy(limit) {
+  const deliveryLimit = deliveryLimitFromConfig(limit);
+  let accepted = false;
+  let closed = false;
+  let terminalToolCalled = false;
+  let deliveryTurns = 0;
+  let budgetSpent = 0;
+  const rejectedReceipts = [];
+  const spend = () => {
+    if (budgetSpent < deliveryLimit) budgetSpent += 1;
+  };
+  return {
+    /** The effective ceiling this budget spends (#1132 — never re-read). */
+    limit: deliveryLimit,
+    recordAccepted() {
+      accepted = true;
+      terminalToolCalled = true;
+    },
+    /** Infrastructure owns terminality and must never trigger receipt催交. */
+    stopForInfrastructure() {
+      accepted = true;
+    },
+    /**
+     * Record the rejection this turn already produced.
+     * The fact does not spend a budget. The seam that sends the next prompt
+     * owns that count.
+     */
+    recordRejected(reason) {
+      terminalToolCalled = true;
+      rejectedReceipts.push({ reason, diagnosticAvailable: reason.trim() !== "" });
+    },
+    recordDeliveryRequest() {
+      deliveryTurns += 1;
+      spend();
+    },
+    /**
+     * Stop asking. The issued count stays whatever was actually sent (#1132 —
+     * do not fill the remainder up to the ceiling).
+     */
+    closeBudget() {
+      closed = true;
+    },
+    /**
+     * A nested session settled without an accepted receipt. Close so this layer
+     * does not open another prompt on that session. The issued count stays the
+     * larger of the two seams: a nested zero must not wipe prompts this layer
+     * already sent, and adding the two counts would bill one send twice.
+     */
+    recordNestedNoReceipt(facts) {
+      terminalToolCalled = terminalToolCalled || facts.terminalToolCalled;
+      rejectedReceipts.push(...facts.rejectedReceipts);
+      deliveryTurns = Math.max(deliveryTurns, facts.deliveryTurns);
+      closed = true;
+    },
+    nextAction() {
+      if (accepted) return "accepted";
+      if (closed) return "no-receipt";
+      return budgetSpent < deliveryLimit ? "request-delivery" : "no-receipt";
+    },
+    /** Delivery requests actually issued so far (#1132). */
+    issuedDeliveryRequests() {
+      return deliveryTurns;
+    },
+    /** Current typed delivery facts. No prose. */
+    deliveryState() {
+      return {
+        terminalToolCalled,
+        rejectedReceipts: rejectedReceipts.map((item) => ({ ...item })),
+        deliveryTurns,
+        acceptedReceipt: false
+      };
+    },
+    facts(binding) {
+      return noReceiptLifecycleFacts({ terminalToolCalled, rejectedReceipts: [...rejectedReceipts], deliveryTurns, ...binding });
+    },
+    /**
+     * Continue a public call after the in-memory policy was rebuilt.
+     * Sends already issued spend the same budget; copied rejections keep
+     * the fact and do not spend again.
+     */
+    continueIssued(prior) {
+      for (const receipt of prior.rejectedReceipts) {
+        this.recordRejected(receipt.reason);
+      }
+      if (prior.terminalToolCalled === true) terminalToolCalled = true;
+      for (let index = 0; index < prior.deliveryTurns; index += 1) {
+        this.recordDeliveryRequest();
+      }
+    }
+  };
+}
+function entryRecord(entry) {
+  return isRecord(entry) ? entry : void 0;
+}
+function customTypeOf(record, message) {
+  return record.customType ?? message?.customType;
+}
+function dataOf(record, message) {
+  return record.data ?? message?.details;
+}
+function scopeTag(record) {
+  const message = isRecord(record.message) ? record.message : void 0;
+  const customType = customTypeOf(record, message);
+  const data = dataOf(record, message);
+  if ((customType === RECEIPT_DELIVERY_REQUEST_ENTRY || customType === RECEIPT_REJECTION_ENTRY) && isRecord(data) && typeof data.invocationScopeId === "string" && data.invocationScopeId.trim() !== "") {
+    return data.invocationScopeId;
+  }
+  if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) return void 0;
+  try {
+    const facts = parseNoReceiptLifecycleFacts(data);
+    const prefix = "invocation:";
+    if (!facts.attemptPointer.startsWith(prefix)) return void 0;
+    const scope = facts.attemptPointer.slice(prefix.length);
+    return scope.trim() === "" ? void 0 : scope;
+  } catch {
+    return void 0;
+  }
+}
+function priorReceiptContinuation(entries, invocationScopeId) {
+  const pointer = receiptAttemptPointer("", invocationScopeId);
+  let entryTurns = 0;
+  let factTurns = 0;
+  let rejectedReceipts = [];
+  let snapshotTerminal = false;
+  for (const entry of entries) {
+    const record = entryRecord(entry);
+    if (record === void 0) continue;
+    const tagged = scopeTag(record);
+    if (tagged !== void 0) {
+      const message = isRecord(record.message) ? record.message : void 0;
+      const customType = customTypeOf(record, message);
+      if (tagged !== invocationScopeId) continue;
+      if (customType === RECEIPT_DELIVERY_REQUEST_ENTRY) entryTurns += 1;
+      if (customType === RECEIPT_REJECTION_ENTRY) {
+        const data = dataOf(record, message);
+        if (isRecord(data) && typeof data.reason === "string") rejectedReceipts.push({ reason: data.reason });
+      }
+      if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) continue;
+      try {
+        const facts = parseNoReceiptLifecycleFacts(dataOf(record, message));
+        if (facts.attemptPointer !== pointer) continue;
+        factTurns = Math.max(factTurns, facts.deliveryTurns);
+        if (facts.rejectedReceipts.length >= rejectedReceipts.length) {
+          rejectedReceipts = facts.rejectedReceipts.map(({ reason }) => ({ reason }));
+        }
+        snapshotTerminal ||= facts.terminalToolCalled;
+      } catch {
+      }
+      continue;
+    }
+  }
+  return {
+    deliveryTurns: Math.max(entryTurns, factTurns),
+    rejectedReceipts,
+    terminalToolCalled: snapshotTerminal || rejectedReceipts.length > 0
+  };
+}
+var NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_REQUEST_ENTRY, RECEIPT_REJECTION_ENTRY, RECEIPT_DELIVERY_LIMIT_ENV;
+var init_receipt_delivery_policy = __esm({
+  "src/receipt-delivery-policy.ts"() {
+    "use strict";
+    init_run_lifecycle();
+    init_config2();
+    init_unknown_value();
+    NO_RECEIPT_LIFECYCLE_ENTRY_TYPE = "ak-no-receipt-lifecycle";
+    RECEIPT_DELIVERY_REQUEST_ENTRY = "ak-receipt-delivery-request";
+    RECEIPT_REJECTION_ENTRY = "ak-receipt-rejection";
+    RECEIPT_DELIVERY_LIMIT_ENV = "AK_ROLE_RECEIPT_DELIVERY_LIMIT";
+  }
+});
+
 // src/session-assistant-usage.ts
 var session_assistant_usage_exports = {};
 __export(session_assistant_usage_exports, {
@@ -17583,10 +17807,10 @@ __export(session_assistant_usage_exports, {
 });
 import { join as join14 } from "node:path";
 async function readAssistantUsageFromSessionFile(sessionFile) {
-  const { readFile: readFile22 } = await import("node:fs/promises");
+  const { readFile: readFile23 } = await import("node:fs/promises");
   let text;
   try {
-    text = await readFile22(sessionFile, "utf8");
+    text = await readFile23(sessionFile, "utf8");
   } catch (error) {
     if (error?.code === "ENOENT") return void 0;
     throw error;
@@ -18207,6 +18431,8 @@ function createPiRoleTurnHost(config) {
       else env.AK_ROLE_INVOCATION_SCOPE = request.invocationScopeId;
       if (request.host === void 0 || request.host.trim() === "") delete env.AK_ROLE_HOST;
       else env.AK_ROLE_HOST = request.host.trim();
+      if (request.deliveryRequestLimit === void 0) delete env[RECEIPT_DELIVERY_LIMIT_ENV];
+      else env[RECEIPT_DELIVERY_LIMIT_ENV] = String(request.deliveryRequestLimit);
       applyEngineChildEnv(env, request.engine);
       if (typeof process.env.AK_ROLE_AUDITOR_SOURCE_RUN === "string" && process.env.AK_ROLE_AUDITOR_SOURCE_RUN.trim() !== "") {
         env.AK_ROLE_AUDITOR_SOURCE_RUN = process.env.AK_ROLE_AUDITOR_SOURCE_RUN;
@@ -18266,6 +18492,7 @@ var init_role_turn_host = __esm({
     init_engine_detour();
     init_role_activation_flags();
     init_user_dialogue_stdin();
+    init_receipt_delivery_policy();
     init_sitian_facade();
     INTERNAL_ROLE_ENTRYPOINT_RELATIVE2 = "extensions/role-runtime.ts";
     EXPLICIT_INTERNAL_LOAD_PROBE_ARGS = [
@@ -22086,10 +22313,10 @@ function pairGateRounds(volumes) {
   return rounds.sort((a, b) => a.officerStartedAt.localeCompare(b.officerStartedAt)).map((round, index) => ({ ...round, roundIndex: index + 1 }));
 }
 async function resolveOfficerSessionFromPointerFile(pointerPath) {
-  const { readFile: readFile22 } = await import("node:fs/promises");
+  const { readFile: readFile23 } = await import("node:fs/promises");
   let raw;
   try {
-    raw = JSON.parse(await readFile22(pointerPath, "utf8"));
+    raw = JSON.parse(await readFile23(pointerPath, "utf8"));
   } catch (error) {
     throw new Error(
       `direct officer run pointer unreadable in ${pointerPath}: ${errorText(error)}`,
@@ -22697,9 +22924,7 @@ function runDirectoryFromSessionDirectory(sessionDirectory) {
 function sessionFileFromSessionDirectory(sessionDirectory) {
   return join26(sessionDirectory, "session.jsonl");
 }
-function mintEngineDetourInvocationScope(input) {
-  const engine = input.effectiveEngine?.trim();
-  if (engine === void 0 || engine.length === 0) return void 0;
+function mintEngineDetourInvocationScope(_input) {
   return randomUUID3();
 }
 function withEngineDetourInvocationScope(request, invocationScopeId) {
@@ -22902,51 +23127,6 @@ var init_navigator_invocation_identity = __esm({
   }
 });
 
-// src/receipt-delivery-policy.ts
-function parseNoReceiptLifecycleFacts(input) {
-  if (!isRecord(input) || typeof input.terminalToolCalled !== "boolean" || input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT || input.sessionCompletion !== "settled-without-accepted-receipt" || input.acceptedReceipt !== false || typeof input.runPointer !== "string" || input.runPointer.trim() === "" || typeof input.attemptPointer !== "string" || input.attemptPointer.trim() === "" || !Array.isArray(input.rejectedReceipts) || !input.rejectedReceipts.every((item) => isRecord(item) && typeof item.reason === "string")) {
-    throw new TypeError("malformed no-receipt lifecycle facts");
-  }
-  return {
-    terminalToolCalled: input.terminalToolCalled,
-    rejectedReceipts: input.rejectedReceipts.map((item) => ({
-      reason: item.reason,
-      diagnosticAvailable: item.reason.trim() !== ""
-    })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
-    sessionCompletion: "settled-without-accepted-receipt",
-    runPointer: input.runPointer,
-    attemptPointer: input.attemptPointer,
-    acceptedReceipt: false
-  };
-}
-function noReceiptLifecycleFacts(input) {
-  if (input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT) {
-    throw new TypeError("no-receipt lifecycle requires an exhausted delivery budget");
-  }
-  return {
-    terminalToolCalled: input.terminalToolCalled,
-    rejectedReceipts: input.rejectedReceipts.map(({ reason }) => ({
-      reason,
-      diagnosticAvailable: reason.trim() !== ""
-    })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
-    sessionCompletion: "settled-without-accepted-receipt",
-    runPointer: input.runPointer,
-    attemptPointer: input.attemptPointer,
-    acceptedReceipt: false
-  };
-}
-var RECEIPT_DELIVERY_TURN_LIMIT, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE;
-var init_receipt_delivery_policy = __esm({
-  "src/receipt-delivery-policy.ts"() {
-    "use strict";
-    init_unknown_value();
-    RECEIPT_DELIVERY_TURN_LIMIT = 2;
-    NO_RECEIPT_LIFECYCLE_ENTRY_TYPE = "ak-no-receipt-lifecycle";
-  }
-});
-
 // src/public-cli/settlement.ts
 var settlement_exports = {};
 __export(settlement_exports, {
@@ -23089,13 +23269,76 @@ async function attachRecordedSubmissions(admitted, terminal, scope) {
   if (errorPath !== void 0) privateFailureErrorPaths.set(result, errorPath);
   return result;
 }
-async function settleHostEndedNoReceipt(admitted, authority, scope) {
+function lifecycleFactsFromEntry(entry) {
+  const customType = entry.customType ?? entry.message?.customType;
+  if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) return void 0;
+  return entry.data ?? entry.message?.details;
+}
+async function readCurrentAttemptNoReceiptFacts(admitted, authority, scope) {
+  const { sessionFile } = coordinatesFromAdmitted(authority, admitted);
+  const entries = await readBoundSessionEntries(sessionFile).catch(() => void 0);
+  if (entries === void 0) return void 0;
+  const scopeId = scope?.invocationScopeId?.trim() ?? "";
+  if (scopeId.length > 0) {
+    const pointer = receiptAttemptPointer(admitted.runDirectory, scopeId);
+    let selected;
+    for (const entry of entries) {
+      const raw2 = lifecycleFactsFromEntry(entry);
+      if (raw2 === void 0) continue;
+      try {
+        const facts2 = parseNoReceiptLifecycleFacts(raw2);
+        if (facts2.runPointer !== admitted.runDirectory) continue;
+        if (facts2.attemptPointer !== pointer) continue;
+        if (selected === void 0 || facts2.deliveryTurns >= selected.deliveryTurns) {
+          selected = facts2;
+        }
+      } catch {
+      }
+    }
+    return selected;
+  }
+  let attemptStart = 0;
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    if (entries[index]?.type === "message" && entries[index]?.message?.role === "user") {
+      attemptStart = index;
+      break;
+    }
+  }
+  const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry) => lifecycleFactsFromEntry(entry) !== void 0);
+  const raw = lifecycleEntry === void 0 ? void 0 : lifecycleFactsFromEntry(lifecycleEntry);
+  if (raw === void 0) return void 0;
+  let facts;
+  try {
+    facts = parseNoReceiptLifecycleFacts(raw);
+  } catch {
+    return void 0;
+  }
+  if (facts.runPointer !== admitted.runDirectory) return void 0;
+  if (facts.attemptPointer !== receiptAttemptPointer(admitted.runDirectory)) return void 0;
+  return facts;
+}
+async function settleHostEndedNoReceipt(admitted, authority, scope, issuedDeliveryRequests = 0) {
+  const scopeId = scope?.invocationScopeId?.trim() ?? "";
+  const persisted = scopeId.length > 0 ? void 0 : await readCurrentAttemptNoReceiptFacts(admitted, authority, scope);
+  let terminalToolCalled = persisted?.terminalToolCalled ?? false;
+  let rejectedReceipts = persisted?.rejectedReceipts ?? [];
+  let recordedTurns = persisted?.deliveryTurns ?? 0;
+  if (scopeId.length > 0) {
+    const { sessionFile } = coordinatesFromAdmitted(authority, admitted);
+    const entries = await readBoundSessionEntries(sessionFile).catch(() => void 0);
+    if (entries !== void 0) {
+      const prior = priorReceiptContinuation(entries, scopeId);
+      terminalToolCalled = prior.terminalToolCalled;
+      rejectedReceipts = prior.rejectedReceipts;
+      recordedTurns = prior.deliveryTurns;
+    }
+  }
   const facts = noReceiptLifecycleFacts({
-    terminalToolCalled: false,
-    rejectedReceipts: [],
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
+    terminalToolCalled,
+    rejectedReceipts,
+    deliveryTurns: Math.max(issuedDeliveryRequests, recordedTurns),
     runPointer: admitted.runDirectory,
-    attemptPointer: `current:${admitted.runDirectory}`
+    attemptPointer: receiptAttemptPointer(admitted.runDirectory, scope?.invocationScopeId)
   });
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   await clearOppositeTerminalArtifactFace(admitted.runDirectory);
@@ -24668,44 +24911,26 @@ async function settleFailureTerminalResult(admitted, failure, authority, options
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
   if (failure.cause === "output") {
-    const entries = await readBoundSessionEntries(sessionFile).catch(() => void 0);
-    if (entries !== void 0) {
-      let attemptStart = 0;
-      for (let index = entries.length - 1; index >= 0; index -= 1) {
-        if (entries[index]?.type === "message" && entries[index]?.message?.role === "user") {
-          attemptStart = index;
-          break;
-        }
-      }
-      const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry) => entry.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE || entry.message?.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE);
-      const raw = lifecycleEntry?.data ?? lifecycleEntry?.message?.details;
-      if (raw !== void 0) {
-        let facts;
-        try {
-          facts = parseNoReceiptLifecycleFacts(raw);
-        } catch {
-        }
-        if (facts !== void 0 && facts.runPointer === admitted.runDirectory && facts.attemptPointer === `current:${admitted.runDirectory}`) {
-          let decisiveFacts2 = facts;
-          await clearOppositeTerminalArtifactFace(admitted.runDirectory);
-          return withOptionalGateProjection(
-            {
-              roleOutcome: {
-                kind: "no_receipt",
-                role: admitted.role,
-                status: "no-accepted-receipt",
-                ...facts,
-                decisiveFacts: decisiveFacts2
-              },
-              navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
-              artifacts: [],
-              runId: admitted.runId
-            },
-            sessionDirectory,
-            detourGateContext(admitted, options)
-          );
-        }
-      }
+    const facts = await readCurrentAttemptNoReceiptFacts(admitted, authority, options);
+    if (facts !== void 0) {
+      const decisiveFacts2 = facts;
+      await clearOppositeTerminalArtifactFace(admitted.runDirectory);
+      return withOptionalGateProjection(
+        {
+          roleOutcome: {
+            kind: "no_receipt",
+            role: admitted.role,
+            status: "no-accepted-receipt",
+            ...facts,
+            decisiveFacts: decisiveFacts2
+          },
+          navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
+          artifacts: [],
+          runId: admitted.runId
+        },
+        sessionDirectory,
+        detourGateContext(admitted, options)
+      );
     }
   }
   const navigator = await extractNavigatorFactFromAdmittedSession(sessionFile);
@@ -24875,16 +25100,19 @@ var init_settlement = __esm({
 
 // src/archivist-record-pointer.ts
 import { mkdirSync as mkdirSync3, writeFileSync } from "node:fs";
+import { readFile as readFile16 } from "node:fs/promises";
 import { dirname as dirname16, join as join28 } from "node:path";
 function bookDirectOfficerRunPointer(options) {
   const nest = join28(dirname16(options.parentSessionFile), "auditor-roles");
   mkdirSync3(nest, { recursive: true });
+  const submissionToolCallId = options.submissionToolCallId?.trim() ?? "";
   const pointer = {
     version: 1,
     kind: DIRECT_OFFICER_RUN_POINTER_KIND,
     officer: options.officer,
     sessionFile: options.sessionFile,
-    ...options.runDirectory !== void 0 && options.runDirectory.trim() !== "" ? { runDirectory: options.runDirectory } : {}
+    ...options.runDirectory !== void 0 && options.runDirectory.trim() !== "" ? { runDirectory: options.runDirectory } : {},
+    ...submissionToolCallId === "" ? {} : { submissionToolCallId }
   };
   writeFileSync(
     join28(nest, `${options.officer}.pointer.json`),
@@ -24894,10 +25122,36 @@ function bookDirectOfficerRunPointer(options) {
   );
   return pointer;
 }
+async function readDirectOfficerRunPointer(parentSessionFile, officer) {
+  try {
+    const raw = JSON.parse(await readFile16(
+      join28(dirname16(parentSessionFile), "auditor-roles", `${officer}.pointer.json`),
+      "utf8"
+    ));
+    if (!isRecord(raw) || raw.kind !== DIRECT_OFFICER_RUN_POINTER_KIND || raw.version !== 1) {
+      return void 0;
+    }
+    if (raw.officer !== officer) return void 0;
+    if (typeof raw.sessionFile !== "string" || raw.sessionFile.trim() === "") return void 0;
+    const runDirectory = typeof raw.runDirectory === "string" && raw.runDirectory.trim() !== "" ? raw.runDirectory : void 0;
+    const submissionToolCallId = typeof raw.submissionToolCallId === "string" && raw.submissionToolCallId.trim() !== "" ? raw.submissionToolCallId : void 0;
+    return {
+      version: 1,
+      kind: DIRECT_OFFICER_RUN_POINTER_KIND,
+      officer,
+      sessionFile: raw.sessionFile,
+      ...runDirectory === void 0 ? {} : { runDirectory },
+      ...submissionToolCallId === void 0 ? {} : { submissionToolCallId }
+    };
+  } catch {
+    return void 0;
+  }
+}
 var DIRECT_OFFICER_RUN_POINTER_KIND;
 var init_archivist_record_pointer = __esm({
   "src/archivist-record-pointer.ts"() {
     "use strict";
+    init_unknown_value();
     DIRECT_OFFICER_RUN_POINTER_KIND = "direct-officer-run-pointer";
   }
 });
@@ -24915,6 +25169,7 @@ function createPiDoctorAuditor() {
       submission: options.submission,
       ...auditorRunDirectory(options.context) === void 0 ? {} : { runDirectory: auditorRunDirectory(options.context) },
       ...options.signal === void 0 ? {} : { signal: options.signal },
+      ...options.autoResumeLimit === void 0 ? {} : { autoResumeLimit: options.autoResumeLimit },
       ...options.summonAuditor === void 0 ? {} : { summonAuditor: options.summonAuditor }
     });
   };
@@ -24943,10 +25198,23 @@ async function runJudgeGates(input) {
     if (await input.gateAlreadyConverged(subject)) continue;
     const pass = await input.runGate(subject);
     const received = pass?.status;
-    if (pass === void 0 || typeof received !== "string" || !REVIEW_QUEUE_STATUSES.has(received)) {
+    if (pass === void 0 || (typeof received !== "string" || !REVIEW_QUEUE_STATUSES.has(received) && received !== "needs_reask")) {
       throw new Error("judge gate returned no conclusion");
     }
     const status = received;
+    if (status === "needs_reask") {
+      return {
+        status,
+        passes: [{
+          subject,
+          status,
+          receipt: pass.receipt,
+          ...pass.runId === void 0 ? {} : { runId: pass.runId },
+          ...pass.runDirectory === void 0 ? {} : { runDirectory: pass.runDirectory },
+          ...pass.terminal === void 0 ? {} : { terminal: pass.terminal }
+        }]
+      };
+    }
     passes.push({
       subject,
       status,
@@ -25025,7 +25293,7 @@ function createDefaultGateOfficerSummon(options) {
     });
   };
 }
-function bookDirectOfficerPointer(context, officer, result, summoned) {
+function bookDirectOfficerPointer(context, officer, result, summoned, toolCallId) {
   if (result.status !== "converged" && result.status !== "continue" && result.status !== "escalate" && result.status !== "needs_reask" && result.status !== "transport_failure") {
     return;
   }
@@ -25039,11 +25307,14 @@ function bookDirectOfficerPointer(context, officer, result, summoned) {
     parentSessionFile: parentFile,
     officer,
     sessionFile,
-    ...typeof summoned.runDirectory === "string" && summoned.runDirectory.trim() !== "" ? { runDirectory: summoned.runDirectory } : {}
+    ...typeof summoned.runDirectory === "string" && summoned.runDirectory.trim() !== "" ? { runDirectory: summoned.runDirectory } : {},
+    ...toolCallId.trim() === "" ? {} : { submissionToolCallId: toolCallId }
   });
 }
 async function requireSubmissionGate(options) {
   let reask;
+  let reasksSpent = 0;
+  const reaskLimit = deliveryLimitFromConfig(options.autoResumeLimit);
   const summonOfficer = options.summonOfficer ?? createDefaultGateOfficerSummon({
     cwd: options.context.cwd ?? process.cwd()
   });
@@ -25063,7 +25334,8 @@ async function requireSubmissionGate(options) {
           options.context,
           projected.officer,
           gatekeeper,
-          projected.summoned
+          projected.summoned,
+          options.toolCallId
         );
       } catch (error) {
         options.hostActions.failInfrastructure(error, options.context, options.toolCallId);
@@ -25086,6 +25358,17 @@ async function requireSubmissionGate(options) {
       };
     }
     if (gatekeeper.status === "needs_reask") {
+      if (reasksSpent >= reaskLimit) {
+        return {
+          status: "needs_reask",
+          officer: projected.officer,
+          receipt: gatekeeper.receipt,
+          ...typeof gatekeeper.runId === "string" && gatekeeper.runId.trim() !== "" ? { runId: gatekeeper.runId } : {},
+          ...typeof projected.summoned?.runDirectory === "string" && projected.summoned.runDirectory.trim() !== "" ? { runDirectory: projected.summoned.runDirectory } : {},
+          ...projected.summoned?.terminal === void 0 ? {} : { terminal: projected.summoned.terminal }
+        };
+      }
+      reasksSpent += 1;
       reask = officerConclusionReask(gatekeeper.receivedStatus);
       continue;
     }
@@ -25115,6 +25398,7 @@ var init_submission_gate = __esm({
     init_archivist_record_pointer();
     init_gatekeeper_role();
     init_submission_errors();
+    init_receipt_delivery_policy();
     init_session_assistant_usage();
     init_unknown_value();
   }
@@ -25172,7 +25456,8 @@ function projectRoleTurnRequest(admitted, roleDetails, options) {
     ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
     ...options.courtAttemptId === void 0 || options.courtAttemptId.length === 0 ? {} : { courtAttemptId: options.courtAttemptId },
     ...options.invocationScopeId === void 0 || options.invocationScopeId.length === 0 ? {} : { invocationScopeId: options.invocationScopeId },
-    ...options.stationChild === void 0 ? {} : { stationChild: options.stationChild }
+    ...options.stationChild === void 0 ? {} : { stationChild: options.stationChild },
+    ...options.deliveryRequestLimit === void 0 ? {} : { deliveryRequestLimit: options.deliveryRequestLimit }
   };
 }
 function packagedSettleSkill(admitted) {
@@ -25366,12 +25651,67 @@ function unreadablePostSubmissionStatus(admitted, terminal) {
   const status = receivedDiscriminator(payload, "status");
   return typeof status === "string" && route.statuses.has(status) ? void 0 : route.reask ?? officerConclusionReask(status);
 }
-async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io) {
-  const message = unreadablePostSubmissionStatus(admitted, terminal);
+function withUnreadableReask(env) {
+  const spent = env.unreadableReasksSpent ?? 0;
+  if (spent >= deliveryLimitFromConfig(env.autoResumeLimit)) return void 0;
+  return { ...env, unreadableReasksSpent: spent + 1 };
+}
+function isUnreadableReaskExhausted(value) {
+  return value === UNREADABLE_REASK_EXHAUSTED;
+}
+function presentOriginalVolume(held, terminal, io) {
+  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 !== void 0) io.stdout(formatTerminalResult(terminal));
+}
+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 !== void 0 && officerOutcome.kind !== "no_receipt" ? officerOutcome.payloads : void 0
+  );
+  return {
+    ...parent,
+    roleOutcome: {
+      ...outcome,
+      decisiveFacts: {
+        ...outcome.decisiveFacts ?? {},
+        directionUnsettled: true,
+        subsequentAudit: "incomplete",
+        ...officerOutcome === void 0 ? {} : { officerRole: officerOutcome.role },
+        ...officer?.runId === void 0 ? {} : { 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 !== void 0) io.stdout(formatTerminalResult(officer));
+  return terminal;
+}
+async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io, message = unreadablePostSubmissionStatus(admitted, terminal)) {
   if (message === void 0) return void 0;
+  const next = withUnreadableReask(env);
+  if (next === void 0) return UNREADABLE_REASK_EXHAUSTED;
   return runPublicInstructionSeatResume(
     { runId: admitted.runId, message },
-    { ...env, autoResumeLimit: 0 },
+    next,
     io
   );
 }
@@ -25525,6 +25865,11 @@ async function dispatchAdmitted(admitted, env, io) {
     env,
     io
   );
+  if (isUnreadableReaskExhausted(unreadableReask)) {
+    const terminal = result.terminal === void 0 ? void 0 : withUnsettledDirection(result.terminal);
+    presentOriginalVolume(held, terminal, io);
+    return terminal === void 0 ? result : { ...result, terminal };
+  }
   if (unreadableReask !== void 0) return unreadableReask;
   if (AUDITED_ROLES.has(admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
     return auditSubmittedRole(result, env, io);
@@ -25656,20 +26001,16 @@ async function runCountersignBody(parsed, env, io) {
         await persistAdmittedSourceRunPath(admitted, gateParentRunPath);
         admitted = { ...admitted, sourceRunPath: gateParentRunPath };
       }
-      const turnProjection = {
-        ...projectPublicTurnAxes(env),
-        ...env.correlationId === void 0 || 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,
@@ -25938,7 +26279,23 @@ 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 === void 0) {
+          return { kind: "continue", adapters };
+        }
+        const original = await adapters.trySettle(
+          admitted,
+          env.principalAuthority,
+          await readCurrentCourt(admitted.runDirectory)
+        );
+        const unsettled = POST_SUBMISSION_ROUTING[admitted.role] === void 0 ? heldUnreadableTerminal(original) : unreadablePostSubmissionStatus(admitted, original) !== void 0;
+        return {
+          kind: "continue",
+          adapters: original === void 0 || !unsettled ? adapters : {
+            ...adapters,
+            trySettle: async (seat, authority, scope) => await adapters.trySettle(seat, authority, scope) ?? original
+          }
+        };
       },
       ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
     });
@@ -25948,6 +26305,11 @@ async function runPublicInstructionSeatResume(request, env, io) {
       env,
       io
     );
+    if (isUnreadableReaskExhausted(unreadableReask)) {
+      const terminal = result.terminal === void 0 ? void 0 : withUnsettledDirection(result.terminal);
+      presentOriginalVolume(held, terminal, io);
+      return terminal === void 0 ? result : { ...result, terminal };
+    }
     if (unreadableReask !== void 0) return unreadableReask;
     if (result.admitted !== void 0 && AUDITED_ROLES.has(result.admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
       return auditSubmittedRole(result, env, io);
@@ -25973,22 +26335,42 @@ async function runPublicInstructionSeatResume(request, env, io) {
 }
 async function queueConclusionFromChild(child, env, io) {
   if (!GATE_CHILD_ROLES.has(child.role)) return void 0;
+  if (child.role === "countersign") {
+    const terminal = await trySettlePublicSeat(
+      child,
+      env.principalAuthority,
+      await readCurrentCourt(child.runDirectory)
+    );
+    const status = latestQueueStatus(terminal);
+    if (terminal !== void 0 && typeof status === "string" && REVIEW_QUEUE_STATUSES.has(status)) {
+      return { admitted: child, terminal, status };
+    }
+    return { stop: { exitCode: 0, ...terminal === void 0 ? {} : { terminal } } };
+  }
   let current = child;
+  let budgetEnv = { ...env, unreadableReasksSpent: 0 };
   for (; ; ) {
     const terminal = await trySettlePublicSeat(
       current,
       env.principalAuthority,
-      void 0
+      await readCurrentCourt(current.runDirectory)
     );
     const status = latestQueueStatus(terminal);
     if (terminal !== void 0 && 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 === void 0 || reasked.terminal === void 0) {
+    const reasked = await reaskUnreadablePostSubmissionStatus(
+      current,
+      terminal,
+      budgetEnv,
+      io,
+      officerConclusionReask(status)
+    );
+    if (reasked === void 0 || isUnreadableReaskExhausted(reasked)) {
+      return { stop: { exitCode: 0, ...terminal === void 0 ? {} : { terminal } } };
+    }
+    budgetEnv = withUnreadableReask(budgetEnv);
+    if (reasked.exitCode !== 0 || reasked.admitted === void 0 || reasked.terminal === void 0 || reasked.terminal.roleOutcome.kind === "no_receipt" || reasked.terminal.roleOutcome.decisiveFacts?.directionUnsettled === true) {
       return { stop: reasked };
     }
     const reaskedStatus = latestQueueStatus(reasked.terminal);
@@ -26006,7 +26388,17 @@ async function continueParentAfterChild(parentRunId, child, env, io) {
   }
   const admitted = loaded.admitted;
   const resolved = await queueConclusionFromChild(child, env, io);
-  if (resolved !== void 0 && "stop" in resolved) return resolved.stop;
+  if (resolved !== void 0 && "stop" in resolved) {
+    const stopped = resolved.stop;
+    if (stopped.exitCode === 0 && heldUnreadableTerminal(stopped.terminal) && stopped.terminal !== void 0) {
+      const parentTerminal = await trySettlePublicSeat(admitted, env.principalAuthority, void 0);
+      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 !== void 0 && resolved.status === "escalate") {
     return { exitCode: 0, admitted: resolved.admitted, terminal: resolved.terminal };
   }
@@ -26014,37 +26406,67 @@ async function continueParentAfterChild(parentRunId, child, env, io) {
     if (AUDITED_ROLES.has(admitted.role) && resolved.status === "converged") {
       const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, void 0);
       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;
 }
-async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, passedRunId) {
+async function officerPassedCurrentSubmission(input) {
+  const { env, officer } = input;
+  const pointer = await readDirectOfficerRunPointer(input.parentSessionFile, officer);
+  if (pointer?.runDirectory === void 0) return false;
+  if (pointer.submissionToolCallId !== input.toolCallId) return false;
+  const officerRunId = runIdFromRunDirectory(pointer.runDirectory);
+  if (officerRunId === void 0) 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;
+  const court = await readCurrentCourt(admitted.runDirectory);
+  const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, court);
+  return latestQueueStatus(terminal) === "converged";
+}
+async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt) {
   const admitted = turn.admitted;
   if (admitted === void 0 || !AUDITED_ROLES.has(admitted.role) || turn.terminal?.roleOutcome.kind !== "accepted") return turn;
   const accepted = turn.terminal.roleOutcome.payloads?.at(-1);
   if (accepted === void 0) throw new Error("accepted submission has no payload");
   const record = isRecord(accepted) ? accepted : void 0;
   const status = admitted.role === "secretariat" ? record?.secretariatStatus : record?.status;
+  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 === void 0) {
+      const terminal2 = withUnsettledDirection(turn.terminal);
+      io.stdout(formatTerminalResult(terminal2));
+      return { ...turn, terminal: terminal2 };
+    }
+    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 === void 0) {
+      const terminal2 = withUnsettledDirection(turn.terminal);
+      io.stdout(formatTerminalResult(terminal2));
+      return { ...turn, terminal: terminal2 };
+    }
+    return runPublicInstructionSeatResume({ runId: admitted.runId, message: officerConclusionReask(status) }, next, io);
   }
   const selfEscalationSkipsAudit = status === "escalate" && (admitted.role === "judge" || admitted.role === "secretariat" || admitted.role === "countersign");
   const skipAudit = selfEscalationSkipsAudit || (admitted.role === "fixer" || admitted.role === "coder") && (typeof status !== "string" || !WORKER_DONE_STATUSES.has(status));
@@ -26074,12 +26496,19 @@ 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 === void 0 ? {} : { autoResumeLimit: env.autoResumeLimit },
         ...env.signal === void 0 ? {} : { signal: env.signal },
         summonAuditor: async (subject, sourceRunDirectory, signal, reask, submission) => {
           const summoned = await summonPublicRole({
@@ -26108,6 +26537,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
               parentSessionFile: sessionFile,
               officer: "auditor",
               sessionFile: officerSession,
+              submissionToolCallId: toolCallId,
               ...summoned.runDirectory === void 0 ? {} : { runDirectory: summoned.runDirectory }
             });
           }
@@ -26119,7 +26549,15 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
         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 === void 0) {
+          throw new Error("doctor audit kept an unreadable reply with no terminal");
+        }
+        if (turn.terminal === void 0) throw new Error("doctor submission has no terminal");
+        const terminal2 = presentUnsettledAudit(turn.terminal, lastSummon.terminal, io);
+        return { exitCode: 0, admitted, terminal: terminal2 };
       }
       if (decision.status !== "converged") {
         if (lastSummon?.terminal !== void 0) {
@@ -26142,13 +26580,14 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
       ...env.hostAdapters === void 0 ? {} : { hostAdapters: env.hostAdapters }
     });
     let chain;
-    let officerRunId = passedRunId;
+    let officerRunId = resumedOfficer?.runId;
     const runGate = (subject) => requireSubmissionGate({
       context,
       subject,
       toolCallId,
       submission: accepted,
       summonOfficer,
+      ...env.autoResumeLimit === void 0 ? {} : { autoResumeLimit: env.autoResumeLimit },
       ...env.signal === void 0 ? {} : { signal: env.signal },
       hostActions: {
         failInfrastructure(error) {
@@ -26160,13 +26599,13 @@ 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
       });
     } else {
       const subject = admitted.role === "fixer" || admitted.role === "coder" ? { kind: "worker_completion" } : admitted.role === "secretariat" ? { kind: "secretariat_verdict" } : { kind: "countersign_verdict" };
       const officer = gateOfficerForSubject(subject);
-      if (passedOfficer === officer) {
+      if (await passedThisSubmission(officer)) {
         chain = { status: "converged", passes: [] };
       } else {
         const pass = await runGate(subject);
@@ -26179,17 +26618,29 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
             status: pass.status,
             receipt: pass.receipt,
             ...pass.runId === void 0 ? {} : { runId: pass.runId },
-            ...pass.runDirectory === void 0 ? {} : { runDirectory: pass.runDirectory }
+            ...pass.runDirectory === void 0 ? {} : { runDirectory: pass.runDirectory },
+            ...pass.terminal === void 0 ? {} : { terminal: pass.terminal }
           }]
         };
       }
     }
+    if (chain.status === "needs_reask") {
+      const officerTerminal = chain.passes.at(-1)?.terminal;
+      if (officerTerminal === void 0) throw new Error("unreadable audit has no terminal result");
+      if (turn.terminal === void 0) throw new Error("audited submission has no terminal");
+      const terminal2 = presentUnsettledAudit(turn.terminal, officerTerminal, io);
+      return { exitCode: 0, admitted, terminal: terminal2 };
+    }
     if (chain.status === "escalate") {
       const escalation = chain.passes.at(-1);
       const escalatedRunId = escalation?.runId ?? (escalation?.runDirectory === void 0 ? void 0 : runIdFromRunDirectory(escalation.runDirectory));
       if (escalatedRunId === void 0) throw new Error("escalated audit has no resumable run identity");
       const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority);
-      const terminal2 = await trySettlePublicSeat(officer.admitted, env.principalAuthority, void 0);
+      const terminal2 = await trySettlePublicSeat(
+        officer.admitted,
+        env.principalAuthority,
+        await readCurrentCourt(officer.admitted.runDirectory)
+      );
       if (terminal2 === void 0) throw new Error("escalated audit has no terminal result");
       io.stdout(formatTerminalResult(terminal2));
       return { exitCode: 0, admitted: officer.admitted, terminal: terminal2 };
@@ -26198,7 +26649,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);
@@ -26218,7 +26669,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
   io.stdout(formatTerminalResult(terminal));
   return turn;
 }
-var AUDITED_ROLES, SECRETARIAT_STATUS_REASK, WORKER_ROUTING_STATUSES, WORKER_STATUS_REASK, DOCTOR_ROUTING_STATUSES, DOCTOR_STATUS_REASK, POST_SUBMISSION_ROUTING, GATE_CHILD_ROLES;
+var AUDITED_ROLES, SECRETARIAT_STATUS_REASK, WORKER_ROUTING_STATUSES, WORKER_STATUS_REASK, DOCTOR_ROUTING_STATUSES, DOCTOR_STATUS_REASK, POST_SUBMISSION_ROUTING, UNREADABLE_REASK_EXHAUSTED, GATE_CHILD_ROLES;
 var init_instruction_seat_run = __esm({
   "src/public-cli/instruction-seat-run.ts"() {
     "use strict";
@@ -26233,6 +26684,7 @@ var init_instruction_seat_run = __esm({
     init_worker_submission_contracts();
     init_secretariat_contracts();
     init_readable_gate_item();
+    init_receipt_delivery_policy();
     init_run_terminal_artifacts();
     init_submission_gate();
     init_submission_ledger();
@@ -26290,6 +26742,7 @@ var init_instruction_seat_run = __esm({
         reask: DOCTOR_STATUS_REASK
       }
     };
+    UNREADABLE_REASK_EXHAUSTED = { unreadableReaskExhausted: true };
     GATE_CHILD_ROLES = /* @__PURE__ */ new Set(["notary", "auditor", "inspector", "countersign"]);
   }
 });
@@ -26910,10 +27363,14 @@ async function runComplianceAudit(options) {
     });
   });
   let reask;
+  let reasksSpent = 0;
+  const reaskLimit = deliveryLimitFromConfig(options.autoResumeLimit);
   for (; ; ) {
     const summoned = await summon(subject, runDirectory, options.signal, reask, submission);
     const decision = await projectAuditorTerminal(summoned);
     if (decision.status === "received") {
+      if (reasksSpent >= reaskLimit) return decision;
+      reasksSpent += 1;
       reask = officerConclusionReask(receivedDiscriminator(decision.reply, "status"));
       continue;
     }
@@ -26929,6 +27386,7 @@ var init_compliance_transport = __esm({
     init_submission_errors();
     init_terminal();
     init_readable_gate_item();
+    init_receipt_delivery_policy();
     init_unknown_value();
     AUDITOR_DOSSIER_PROMPT = "\u5377\u5B97\u6307\u9488\uFF1A";
     AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE = "ak_auditor_parent_attempt_binding";
@@ -27062,7 +27520,7 @@ __export(run_lifecycle_exports, {
   renderResumeCommand: () => renderResumeCommand,
   writeRoleRunState: () => writeRoleRunState
 });
-import { chmod, lstat as lstat5, open, readdir as readdir6, readFile as readFile16, unlink as unlink4, writeFile as writeFile5 } from "node:fs/promises";
+import { chmod, lstat as lstat5, open, readdir as readdir6, readFile as readFile17, unlink as unlink4, writeFile as writeFile5 } from "node:fs/promises";
 import { basename as basename8, join as join31 } from "node:path";
 function buildAutoResumeContinuationPrompt(options) {
   return appendEngineSessionMaterial(
@@ -27139,7 +27597,7 @@ function parseCurrentCourtState(raw) {
 async function readRoleRunStateRaw(runDirectory) {
   let raw;
   try {
-    raw = JSON.parse(await readFile16(join31(runDirectory, RUN_STATE_FILE), "utf8"));
+    raw = JSON.parse(await readFile17(join31(runDirectory, RUN_STATE_FILE), "utf8"));
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
     throw error;
@@ -27397,7 +27855,7 @@ function isProcessAlive(pid) {
 async function autopsyWriterLock(lockPath) {
   let content;
   try {
-    content = await readFile16(lockPath, "utf8");
+    content = await readFile17(lockPath, "utf8");
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return { verdict: "absent" };
     return { verdict: "unknown", reason: "unreadable", readFailure: error };
@@ -27594,7 +28052,7 @@ async function readRunParentPath(runDirectory) {
   let raw;
   try {
     raw = JSON.parse(
-      await readFile16(join31(runDirectory, "admitted-request.json"), "utf8")
+      await readFile17(join31(runDirectory, "admitted-request.json"), "utf8")
     );
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
@@ -27709,7 +28167,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let sourceRun;
   try {
     const raw = JSON.parse(
-      await readFile16(run.admittedRequestPath, "utf8")
+      await readFile17(run.admittedRequestPath, "utf8")
     );
     if (isRecord(raw)) {
       const record = raw;
@@ -27831,7 +28289,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let model;
   try {
     const invocationRaw = JSON.parse(
-      await readFile16(join31(run.runDirectory, "invocation.json"), "utf8")
+      await readFile17(join31(run.runDirectory, "invocation.json"), "utf8")
     );
     if (isRecord(invocationRaw)) {
       const rec = invocationRaw;
@@ -28196,7 +28654,7 @@ var init_run_lifecycle = __esm({
 });
 
 // src/session-identity.ts
-import { mkdir as mkdir3, readFile as readFile17, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile18, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
 import { dirname as dirname18, join as join32 } from "node:path";
 function createSessionIdentityAuthority(authority, sessionBindingFile) {
   const bindingPath = (principal) => join32(authority.decode(principal).sessionDirectory, sessionBindingFile);
@@ -28206,7 +28664,7 @@ function createSessionIdentityAuthority(authority, sessionBindingFile) {
     },
     async load(principal) {
       try {
-        const value = JSON.parse(await readFile17(bindingPath(principal), "utf8"));
+        const value = JSON.parse(await readFile18(bindingPath(principal), "utf8"));
         if (typeof value !== "object" || value === null || typeof value.sessionId !== "string") {
           throw new Error("durable session binding is invalid");
         }
@@ -28850,8 +29308,203 @@ async function settleDeferredPersist(admitted, authority, adapters, io, result)
       io,
       true
     );
-    return { ...failed, turnDispatched: true, skipAutoResume: true };
+    return {
+      ...failed,
+      turnDispatched: true,
+      skipAutoResume: true
+    };
+  }
+}
+function settlementScopeForTurn(request) {
+  const hasCourt = request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0;
+  const hasScope = request.invocationScopeId !== void 0 && request.invocationScopeId.length > 0;
+  if (!hasCourt && !hasScope) return void 0;
+  return {
+    ...hasCourt ? { courtAttemptId: request.courtAttemptId } : {},
+    ...hasScope ? { invocationScopeId: request.invocationScopeId } : {}
+  };
+}
+async function buildReceiptDeliveryRequest(input) {
+  const { admitted, env, request, receiptDelivery } = input;
+  const hostSessionId = await readStoredHostSessionId(
+    env.host,
+    env.principalAuthority,
+    admitted.principal
+  );
+  return {
+    ...request,
+    continuation: {
+      kind: "resume",
+      prompt: JSON.stringify({
+        ...receiptDelivery.deliveryState(),
+        deliveryTurns: receiptDelivery.issuedDeliveryRequests() + 1
+      }),
+      ...hostSessionId === void 0 ? {} : { hostSessionId }
+    },
+    deliveryRequestLimit: receiptDelivery.limit
+  };
+}
+async function settleCompletedHostTurn(input) {
+  const { admitted, env, io, adapters, shouldPresent, request, result, persistRunState, deferredPersist } = input;
+  const finishAfterTurn = input.finishAfterTurn;
+  let stderrLogWriteFailure;
+  try {
+    await writeFile7(
+      join35(admitted.runDirectory, "stderr.log"),
+      result.stderr,
+      "utf8"
+    );
+  } catch (error) {
+    stderrLogWriteFailure = error;
+    await recordBestEffortPostDispatchDiagnostic(
+      admitted,
+      env,
+      `stderr.log write failed (best-effort continue): ${describeErrorIdentity(error)}`,
+      io
+    );
+  }
+  const courtScope = settlementScopeForTurn(request);
+  let settled;
+  let settledOutcome;
+  let hostSignalFailed = false;
+  let resolution;
+  try {
+    const sessionFile = admitted.principal !== void 0 ? env.principalAuthority.decode(admitted.principal).sessionFile : "";
+    const runnerKnownFailure = adapters.resolveRunnerKnownFailure !== void 0 && sessionFile !== "" ? await adapters.resolveRunnerKnownFailure({ result, sessionFile }) : result.knownFailure;
+    resolution = await resolveAuditedRunnerFailureResolution({
+      runner: runnerKnownFailure,
+      sessionFile,
+      credential: void 0,
+      runDirectory: admitted.runDirectory
+    });
+    const processCancelName = processCancelSignalName(env.signal);
+    const directHostFailureSignal = result.timedOut || result.knownFailure !== void 0 || runnerKnownFailure !== void 0 || processCancelName !== void 0;
+    hostSignalFailed = directHostFailureSignal || result.code !== null && result.code !== 0 || resolution.knownFailure !== void 0;
+    settled = await adapters.trySettle(admitted, env.principalAuthority, courtScope);
+    if (settled !== void 0) {
+      settled = await attachRecordedSubmissions(admitted, settled, courtScope);
+    }
+    const settledIsFreshThisAttempt = settled === void 0 || settled.roleOutcome.kind !== "accepted" && settled.roleOutcome.kind !== "audit_escalation" ? true : await attemptProducedFreshSubmission(admitted, courtScope);
+    const staleAcceptanceOutranksRealFailure = !settledIsFreshThisAttempt && hostSignalFailed;
+    const cancelAfterSettle = processCancelSignalName(env.signal);
+    if (settled !== void 0 && shouldPresent(settled) && !directHostFailureSignal && !staleAcceptanceOutranksRealFailure && stderrLogWriteFailure === void 0 && cancelAfterSettle === void 0) {
+      if (settled.roleOutcome.kind === "accepted" && request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0) {
+        try {
+          await clearCurrentCourt(admitted.runDirectory, request.courtAttemptId);
+        } catch (error) {
+          await recordBestEffortPostDispatchDiagnostic(
+            admitted,
+            env,
+            `current-court cleanup failed after accepted settlement (best-effort continue): ${describeErrorIdentity(error)}`,
+            io
+          );
+        }
+      }
+      settledOutcome = {
+        exitCode: exitCodeForTerminalOutcome(settled.roleOutcome),
+        admitted,
+        terminal: settled,
+        turnDispatched: true
+      };
+    }
+  } catch (error) {
+    const settledFailure = await settleAfterTurnStarted(
+      admitted,
+      withEngineDetourInvocationScope({
+        timedOut: false,
+        code: result.code,
+        stderr: result.stderr,
+        thrown: error
+      }, request.invocationScopeId),
+      adapters,
+      env.principalAuthority,
+      io,
+      persistRunState
+    );
+    return { kind: "settled", outcome: await finishAfterTurn({ ...settledFailure, turnDispatched: true, ...deferredPersist }) };
+  }
+  if (settledOutcome !== void 0) {
+    const lateCancel = processCancelSignalName(env.signal);
+    if (lateCancel !== void 0) {
+      return { kind: "settled", outcome: await finishAfterTurn(
+        await settleProcessCancelAfterTurn({
+          admitted,
+          cancelName: lateCancel,
+          result,
+          adapters,
+          env,
+          io,
+          persistRunState,
+          deferredPersist,
+          invocationScopeId: request.invocationScopeId
+        })
+      ) };
+    }
+    if (persistRunState) {
+      try {
+        await persistReturnedRunState(admitted, { lawful: true });
+      } catch (error) {
+        await recordBestEffortPostDispatchDiagnostic(
+          admitted,
+          env,
+          `run-state persistence failed beside host terminal (best-effort continue): ${describeErrorIdentity(error)}`,
+          io
+        );
+      }
+    }
+    return { kind: "settled", outcome: await finishAfterTurn({ ...settledOutcome, ...deferredPersist }) };
+  }
+  if (hostSignalFailed) {
+    const resolutionInput = controlledFailureInputFromResolution(resolution);
+    const processCancelName = processCancelSignalName(env.signal);
+    const stderrLogWriteDetails = stderrLogWriteFailure === void 0 ? void 0 : { stderrLogWriteFailure: describeCaughtError(stderrLogWriteFailure) };
+    const failed = await settleAfterTurnStarted(
+      admitted,
+      withEngineDetourInvocationScope({
+        timedOut: result.timedOut,
+        code: result.code,
+        stderr: result.stderr,
+        ...resolutionInput,
+        ...processCancelName === void 0 ? {} : { knownDiagnostic: processCancelDiagnostic(processCancelName) },
+        // Secondary fact only — never the cause. Rides on whichever channel
+        // classification actually reads (knownFailure.details owns it when
+        // a knownFailure exists; the top-level knownDetails otherwise).
+        ...stderrLogWriteDetails === void 0 ? {} : resolutionInput.knownFailure !== void 0 ? {
+          knownFailure: {
+            ...resolutionInput.knownFailure,
+            details: { ...resolutionInput.knownFailure.details ?? {}, ...stderrLogWriteDetails }
+          }
+        } : { knownDetails: stderrLogWriteDetails }
+      }, request.invocationScopeId),
+      adapters,
+      env.principalAuthority,
+      io,
+      persistRunState
+    );
+    return { kind: "settled", outcome: await finishAfterTurn(
+      withProcessCancelSkipAutoResume(
+        { ...failed, turnDispatched: true, ...deferredPersist },
+        env.signal
+      )
+    ) };
+  }
+  if (stderrLogWriteFailure !== void 0) {
+    const failed = await settleAfterTurnStarted(
+      admitted,
+      withEngineDetourInvocationScope({
+        timedOut: false,
+        code: result.code,
+        stderr: result.stderr,
+        thrown: stderrLogWriteFailure
+      }, request.invocationScopeId),
+      adapters,
+      env.principalAuthority,
+      io,
+      persistRunState
+    );
+    return { kind: "settled", outcome: await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist }) };
   }
+  return { kind: "still-missing" };
 }
 async function dispatchPostAdmissionTurn(input) {
   const { admitted, env, io, request, lease, adapters, effectiveEngine } = input;
@@ -28859,6 +29512,9 @@ async function dispatchPostAdmissionTurn(input) {
   const deferredPersist = persistRunState ? {} : { needsPersist: true };
   const shouldPresent = adapters.shouldPresentSettled ?? ((terminal) => isLawfulTypedTerminalOutcome(terminal.roleOutcome));
   let afterDispatchApplied = false;
+  const receiptDelivery = input.receiptDelivery ?? createReceiptDeliveryPolicy(env.autoResumeLimit);
+  let turnDispatched = false;
+  const akSeamDeliversReceipt = env.host !== void 0 && env.host !== "" && env.host !== DEFAULT_ROLE_TURN_HOST;
   const finishAfterTurn = async (result) => {
     if (afterDispatchApplied) return result;
     afterDispatchApplied = true;
@@ -28956,7 +29612,7 @@ async function dispatchPostAdmissionTurn(input) {
           return { exitCode: 0, admitted, terminal: paused, skipAutoResume: true };
         }
       } catch (error) {
-        const settled2 = await presentControlledFailure2(
+        const settled = await presentControlledFailure2(
           admitted,
           withEngineDetourInvocationScope({
             timedOut: false,
@@ -28969,7 +29625,7 @@ async function dispatchPostAdmissionTurn(input) {
           io,
           persistRunState
         );
-        return { ...settled2, ...deferredPersist };
+        return { ...settled, ...deferredPersist };
       }
     }
     let turnRequest = {
@@ -28993,10 +29649,11 @@ async function dispatchPostAdmissionTurn(input) {
     let result;
     try {
       recordRunStart(admitted.runDirectory);
+      turnDispatched = true;
       result = await env.roleTurnHost.executeTurn(turnRequest);
     } catch (error) {
       const processCancelName = processCancelSignalName(env.signal);
-      const settled2 = await settleAfterTurnStarted(
+      const settled = await settleAfterTurnStarted(
         admitted,
         withEngineDetourInvocationScope({
           timedOut: false,
@@ -29011,175 +29668,111 @@ async function dispatchPostAdmissionTurn(input) {
       );
       return await finishAfterTurn(
         withProcessCancelSkipAutoResume(
-          { ...settled2, turnDispatched: true, ...deferredPersist },
+          { ...settled, turnDispatched: true, ...deferredPersist },
           env.signal
         )
       );
     }
-    let stderrLogWriteFailure;
-    try {
-      await writeFile7(
-        join35(admitted.runDirectory, "stderr.log"),
-        result.stderr,
-        "utf8"
-      );
-    } catch (error) {
-      stderrLogWriteFailure = error;
-      await recordBestEffortPostDispatchDiagnostic(
+    const settledTurn = await settleCompletedHostTurn({
+      admitted,
+      env,
+      io,
+      adapters,
+      shouldPresent,
+      request,
+      result,
+      persistRunState,
+      deferredPersist,
+      finishAfterTurn
+    });
+    if (settledTurn.kind === "settled") return settledTurn.outcome;
+    while (akSeamDeliversReceipt && receiptDelivery.nextAction() === "request-delivery") {
+      let deliveryResult;
+      let deliveryTurnRequest;
+      try {
+        const deliveryRequest = await buildReceiptDeliveryRequest({
+          admitted,
+          env,
+          // Host and the other axes already selected on this turn ride the
+          // shared projection. The pre-projection request does not have them.
+          request: turnRequest,
+          receiptDelivery
+        });
+        deliveryTurnRequest = {
+          ...deliveryRequest,
+          principal: admitted.principal,
+          runDirectory: admitted.runDirectory,
+          ...env.signal === void 0 ? {} : { signal: env.signal }
+        };
+        receiptDelivery.recordDeliveryRequest();
+        deliveryResult = await env.roleTurnHost.executeTurn(deliveryTurnRequest);
+      } catch (error) {
+        const settled = await settleAfterTurnStarted(
+          admitted,
+          withEngineDetourInvocationScope(
+            { timedOut: false, code: null, stderr: "", thrown: error },
+            request.invocationScopeId
+          ),
+          adapters,
+          env.principalAuthority,
+          io,
+          persistRunState
+        );
+        return await finishAfterTurn(
+          withProcessCancelSkipAutoResume(
+            {
+              ...settled,
+              turnDispatched: true,
+              ...deferredPersist
+            },
+            env.signal
+          )
+        );
+      }
+      const deliveryTurn = await settleCompletedHostTurn({
         admitted,
         env,
-        `stderr.log write failed (best-effort continue): ${describeErrorIdentity(error)}`,
-        io
-      );
-    }
-    const courtScope = (request.courtAttemptId === void 0 || request.courtAttemptId.length === 0) && (request.invocationScopeId === void 0 || request.invocationScopeId.length === 0) ? void 0 : {
-      ...request.courtAttemptId === void 0 || request.courtAttemptId.length === 0 ? {} : { courtAttemptId: request.courtAttemptId },
-      ...request.invocationScopeId === void 0 || request.invocationScopeId.length === 0 ? {} : { invocationScopeId: request.invocationScopeId }
-    };
-    let settled;
-    let settledOutcome;
-    let hostSignalFailed = false;
-    let resolution;
-    try {
-      const sessionFile = admitted.principal !== void 0 ? env.principalAuthority.decode(admitted.principal).sessionFile : "";
-      const runnerKnownFailure = adapters.resolveRunnerKnownFailure !== void 0 && sessionFile !== "" ? await adapters.resolveRunnerKnownFailure({ result, sessionFile }) : result.knownFailure;
-      resolution = await resolveAuditedRunnerFailureResolution({
-        runner: runnerKnownFailure,
-        sessionFile,
-        credential: void 0,
-        runDirectory: admitted.runDirectory
+        // Only the final Terminal presents; intermediate delivery attempts stay quiet.
+        io: { ...io, stdout: () => {
+        } },
+        adapters,
+        shouldPresent,
+        request: deliveryTurnRequest,
+        result: deliveryResult,
+        // Run-state terminal write belongs to the OUTERMOST turn only, so a
+        // still-silent delivery attempt never makes the run look lawfully terminal.
+        persistRunState: false,
+        deferredPersist,
+        finishAfterTurn
       });
-      const processCancelName = processCancelSignalName(env.signal);
-      const directHostFailureSignal = result.timedOut || result.knownFailure !== void 0 || runnerKnownFailure !== void 0 || processCancelName !== void 0;
-      hostSignalFailed = directHostFailureSignal || result.code !== null && result.code !== 0 || resolution.knownFailure !== void 0;
-      settled = await adapters.trySettle(admitted, env.principalAuthority, courtScope);
-      if (settled !== void 0) {
-        settled = await attachRecordedSubmissions(admitted, settled, courtScope);
-      }
-      const settledIsFreshThisAttempt = settled === void 0 || settled.roleOutcome.kind !== "accepted" && settled.roleOutcome.kind !== "audit_escalation" ? true : await attemptProducedFreshSubmission(admitted, courtScope);
-      const staleAcceptanceOutranksRealFailure = !settledIsFreshThisAttempt && hostSignalFailed;
-      const cancelAfterSettle = processCancelSignalName(env.signal);
-      if (settled !== void 0 && shouldPresent(settled) && !directHostFailureSignal && !staleAcceptanceOutranksRealFailure && stderrLogWriteFailure === void 0 && cancelAfterSettle === void 0) {
-        if (settled.roleOutcome.kind === "accepted" && request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0) {
+      if (deliveryTurn.kind === "settled") {
+        if (persistRunState && deliveryTurn.outcome.terminal !== void 0) {
           try {
-            await clearCurrentCourt(admitted.runDirectory, request.courtAttemptId);
+            await persistReturnedRunState(admitted, {
+              lawful: isLawfulTypedTerminalOutcome(deliveryTurn.outcome.terminal.roleOutcome)
+            });
           } catch (error) {
             await recordBestEffortPostDispatchDiagnostic(
               admitted,
               env,
-              `current-court cleanup failed after accepted settlement (best-effort continue): ${describeErrorIdentity(error)}`,
+              `run-state persistence failed beside\u50AC\u4EA4 terminal (best-effort continue): ${describeErrorIdentity(error)}`,
               io
             );
           }
         }
-        settledOutcome = {
-          exitCode: exitCodeForTerminalOutcome(settled.roleOutcome),
-          admitted,
-          terminal: settled,
-          turnDispatched: true
-        };
-      }
-    } catch (error) {
-      const settledFailure = await settleAfterTurnStarted(
-        admitted,
-        withEngineDetourInvocationScope({
-          timedOut: false,
-          code: result.code,
-          stderr: result.stderr,
-          thrown: error
-        }, request.invocationScopeId),
-        adapters,
-        env.principalAuthority,
-        io,
-        persistRunState
-      );
-      return await finishAfterTurn({ ...settledFailure, turnDispatched: true, ...deferredPersist });
-    }
-    if (settledOutcome !== void 0) {
-      const lateCancel = processCancelSignalName(env.signal);
-      if (lateCancel !== void 0) {
-        return await finishAfterTurn(
-          await settleProcessCancelAfterTurn({
-            admitted,
-            cancelName: lateCancel,
-            result,
-            adapters,
-            env,
-            io,
-            persistRunState,
-            deferredPersist,
-            invocationScopeId: request.invocationScopeId
-          })
-        );
-      }
-      if (persistRunState) {
-        try {
-          await persistReturnedRunState(admitted, { lawful: true });
-        } catch (error) {
-          await recordBestEffortPostDispatchDiagnostic(
-            admitted,
-            env,
-            `run-state persistence failed beside host terminal (best-effort continue): ${describeErrorIdentity(error)}`,
-            io
-          );
-        }
+        return await finishAfterTurn(deliveryTurn.outcome);
       }
-      return await finishAfterTurn({ ...settledOutcome, ...deferredPersist });
-    }
-    if (hostSignalFailed) {
-      const resolutionInput = controlledFailureInputFromResolution(resolution);
-      const processCancelName = processCancelSignalName(env.signal);
-      const stderrLogWriteDetails = stderrLogWriteFailure === void 0 ? void 0 : { stderrLogWriteFailure: describeCaughtError(stderrLogWriteFailure) };
-      const failed = await settleAfterTurnStarted(
-        admitted,
-        withEngineDetourInvocationScope({
-          timedOut: result.timedOut,
-          code: result.code,
-          stderr: result.stderr,
-          ...resolutionInput,
-          ...processCancelName === void 0 ? {} : { knownDiagnostic: processCancelDiagnostic(processCancelName) },
-          // Secondary fact only — never the cause. Rides on whichever channel
-          // classification actually reads (knownFailure.details owns it when
-          // a knownFailure exists; the top-level knownDetails otherwise).
-          ...stderrLogWriteDetails === void 0 ? {} : resolutionInput.knownFailure !== void 0 ? {
-            knownFailure: {
-              ...resolutionInput.knownFailure,
-              details: { ...resolutionInput.knownFailure.details ?? {}, ...stderrLogWriteDetails }
-            }
-          } : { knownDetails: stderrLogWriteDetails }
-        }, request.invocationScopeId),
-        adapters,
-        env.principalAuthority,
-        io,
-        persistRunState
-      );
-      return await finishAfterTurn(
-        withProcessCancelSkipAutoResume(
-          { ...failed, turnDispatched: true, ...deferredPersist },
-          env.signal
-        )
-      );
-    }
-    if (stderrLogWriteFailure !== void 0) {
-      const failed = await settleAfterTurnStarted(
-        admitted,
-        withEngineDetourInvocationScope({
-          timedOut: false,
-          code: result.code,
-          stderr: result.stderr,
-          thrown: stderrLogWriteFailure
-        }, request.invocationScopeId),
-        adapters,
-        env.principalAuthority,
-        io,
-        persistRunState
-      );
-      return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
     }
+    const noReceiptScope = settlementScopeForTurn(request);
     const noReceipt = await attachRecordedSubmissions(
       admitted,
-      await settleHostEndedNoReceipt(admitted, env.principalAuthority, courtScope),
-      courtScope
+      await settleHostEndedNoReceipt(
+        admitted,
+        env.principalAuthority,
+        noReceiptScope,
+        receiptDelivery.issuedDeliveryRequests()
+      ),
+      noReceiptScope
     );
     const noReceiptCancel = processCancelSignalName(env.signal);
     if (noReceiptCancel !== void 0) {
@@ -29216,6 +29809,11 @@ async function dispatchPostAdmissionTurn(input) {
       turnDispatched: true,
       ...deferredPersist
     });
+  } catch (error) {
+    if (turnDispatched && !(error instanceof TurnDispatchedFailure)) {
+      throw new TurnDispatchedFailure(error);
+    }
+    throw error;
   } finally {
     if (lease !== void 0) {
       try {
@@ -29261,7 +29859,9 @@ function resumeTurnRequestProjectionOptions(admitted, request, env, summonsPrepa
       prompt
     },
     ...request.message === void 0 ? {} : { courtAttemptId: randomUUID6() },
-    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild }
+    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild },
+    // #1132: one configured ceiling, already resolved by the caller (#422).
+    deliveryRequestLimit: deliveryLimitFromConfig(env.autoResumeLimit)
   };
 }
 function roleTurnOptions(env, admitted, continuation) {
@@ -29271,7 +29871,9 @@ function roleTurnOptions(env, admitted, continuation) {
     ...env.host === void 0 ? {} : { host: env.host },
     ...correlationId === void 0 || correlationId.trim() === "" ? {} : { correlationId },
     continuation,
-    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild }
+    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild },
+    // #1132: one configured ceiling, already resolved by the caller (#422).
+    deliveryRequestLimit: deliveryLimitFromConfig(env.autoResumeLimit)
   };
 }
 async function dispatchAfterWriterLease(input) {
@@ -29289,6 +29891,7 @@ async function dispatchAfterWriterLease(input) {
 async function runSettledAutoResumeLoop(input) {
   const adapters = withOnceSuccessfulBeforeDispatch(input.adapters);
   const dispatchEnv = input.dispatchEnv ?? input.env;
+  const receiptDelivery = createReceiptDeliveryPolicy(input.env.autoResumeLimit);
   return runWithAutoResumeLoop({
     admitted: input.admitted,
     principalAuthority: input.env.principalAuthority,
@@ -29310,6 +29913,7 @@ async function runSettledAutoResumeLoop(input) {
           ...lease === void 0 ? {} : { lease },
           adapters,
           persistRunState: false,
+          receiptDelivery,
           ...input.effectiveEngine === void 0 ? {} : { effectiveEngine: input.effectiveEngine }
         });
         return settleDeferredPersist(
@@ -29672,12 +30276,14 @@ var init_post_admission = __esm({
     init_activation_ledger_topology();
     init_engine_material();
     init_session_identity();
+    init_receipt_delivery_policy();
     init_role_run_relocation();
     init_packaged_role_registry();
     init_engine_detour_usage();
     init_run_lifecycle();
     init_process_cancel();
     init_activation_ledger_topology();
+    init_host_descriptions();
     init_host_session_record();
     init_settlement();
     init_terminal();
@@ -29743,7 +30349,7 @@ var init_atomic_write = __esm({
 });
 
 // src/analyst-index.ts
-import { open as open3, readFile as readFile18, unlink as unlink5 } from "node:fs/promises";
+import { open as open3, readFile as readFile19, unlink as unlink5 } from "node:fs/promises";
 import { dirname as dirname21, join as join37 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 async function withAnalystLibraryIndexLock(ledgerHome, fn) {
@@ -29867,7 +30473,7 @@ async function readAnalystLibraryIndexPage(ledgerHome) {
   const path = analystLibraryIndexPath(ledgerHome);
   let raw;
   try {
-    raw = await readFile18(path, "utf8");
+    raw = await readFile19(path, "utf8");
   } catch (error) {
     if (isMissingPathError(error)) return void 0;
     throw error;
@@ -30070,7 +30676,7 @@ var init_analyst_cohort = __esm({
 });
 
 // src/analyst-ledger.ts
-import { readdir as readdir7, readFile as readFile19 } from "node:fs/promises";
+import { readdir as readdir7, readFile as readFile20 } from "node:fs/promises";
 import { basename as basename9, join as join38 } from "node:path";
 async function readExistingRunLifecycleState(runDirectory) {
   return (await readRoleRunIdentity(runDirectory))?.state;
@@ -30120,7 +30726,7 @@ async function listLedgerBookNames(booksRoot) {
 async function readInvocationScopeFields(runDirectory) {
   let raw;
   try {
-    raw = await readFile19(join38(runDirectory, "invocation.json"), "utf8");
+    raw = await readFile20(join38(runDirectory, "invocation.json"), "utf8");
   } catch (error) {
     if (isMissingPathError(error)) return void 0;
     throw error;
@@ -30153,7 +30759,7 @@ function decideIssueScope(input) {
 }
 async function resolveSessionFile(runDirectory) {
   try {
-    const raw = await readFile19(join38(runDirectory, "invocation.json"), "utf8");
+    const raw = await readFile20(join38(runDirectory, "invocation.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (isRecord(parsed) && typeof parsed.sessionFile === "string" && parsed.sessionFile.trim() !== "") {
       return parsed.sessionFile;
@@ -31413,7 +32019,7 @@ var init_analyst_model_groups = __esm({
 });
 
 // src/analyst-entry.ts
-import { readFile as readFile20 } from "node:fs/promises";
+import { readFile as readFile21 } from "node:fs/promises";
 function cachedPageMatchesRequestedScope(page, input) {
   if (page.bookKey !== input.bookKey) return false;
   const requestedTicket = input.ticketNumber ?? input.issueNumber;
@@ -31440,7 +32046,7 @@ async function readOrComputeAnalystIssuePage(input, options) {
     ...issueNumber === void 0 && input.bookKey === void 0 ? { scopeRootIdentity: projectRoot } : {}
   });
   try {
-    const raw = await readFile20(pagePath, "utf8");
+    const raw = await readFile21(pagePath, "utf8");
     const page = JSON.parse(raw);
     if (cachedPageMatchesRequestedScope(page, { bookKey, ...input })) {
       const ghostScan = await scanAnalystIssueRuns({
@@ -31541,7 +32147,7 @@ async function runAnalystModelGroupsMode(input, home) {
       scopeRootIdentity: projectRoot
     });
     try {
-      const raw = await readFile20(pagePath, "utf8");
+      const raw = await readFile21(pagePath, "utf8");
       JSON.parse(raw);
     } catch (error) {
       if (!isMissingPathError(error)) {
@@ -31639,7 +32245,7 @@ var init_analyst_entry = __esm({
 });
 
 // src/public-cli/analyst-run.ts
-import { readFile as readFile21 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 import { isAbsolute as isAbsolute10, resolve as resolve13 } from "node:path";
 function resolveAnalystIssueBookKeyFromCwd(cwd = process.cwd()) {
   try {
@@ -31692,7 +32298,7 @@ async function buildAnalystSweepModeInputFromAttachmentPaths(attachmentPaths) {
   const absolute = isAbsolute10(sourcePath) ? sourcePath : resolve13(sourcePath);
   let bytes;
   try {
-    bytes = await readFile21(absolute);
+    bytes = await readFile22(absolute);
   } catch (error) {
     throw new CliUsageError(
       `analyst sweep attachment is not a readable regular file: ${sourcePath}`,
@@ -32581,7 +33187,7 @@ async function runAkRole(argv2, env) {
         io
       );
       let current = result;
-      while (current.exitCode === 0 && current.admitted?.correlationId !== void 0 && current.terminal?.roleOutcome.kind === "accepted" && !latestPayloadEscalated(current.terminal.roleOutcome)) {
+      while (current.exitCode === 0 && current.admitted?.correlationId !== void 0 && current.terminal?.roleOutcome.kind === "accepted" && current.terminal.roleOutcome.decisiveFacts?.directionUnsettled !== true && !latestPayloadEscalated(current.terminal.roleOutcome)) {
         const parentRunId = current.admitted.correlationId;
         resumeFailureContext = {
           home,