@akagilnc/pi-workflow-roles 0.1.5382 → 0.1.5406

package/dist/headless-host/production-host.js

@@ -1828,6 +1828,9 @@ ${serializeReceipt(result.submission)}`;
   }
   return `\u95E8\u4E0B\u7701 ${result.status}\uFF08${result.stage}\uFF09\uFF1A${result.reason}`;
 }
+function isOneShotWorkerReminderCode(code) {
+  return code === "worker_commit_reminder" || code === "worker_prefix_reminder";
+}
 function unreadableDiscriminatorNotice(field, received) {
   if (received === void 0) return `\u8BFB\u4E0D\u51FA ${field}`;
   return `\u8BFB\u4E0D\u51FA ${field}\uFF1A${readableGateItem(received)}`;
@@ -1868,7 +1871,7 @@ var init_submission_errors = __esm({
     WorkerUnfinishedReasonReminderError = class extends Error {
       code = "worker_unfinished_reason_reminder";
       constructor() {
-        super("\u672C\u6B21 unfinished \u56DE\u6267\u672A\u542B reason\uFF1B\u672C\u63A5\u7F1D\u7F3A\u7531\u81F3\u591A\u6253\u56DE\u4E24\u6B21\u3002");
+        super("\u672C\u6B21 unfinished \u56DE\u6267\u672A\u542B reason\uFF1B\u8BF7\u8865\u4E0A reason \u540E\u518D\u4EA4\u3002");
         this.name = "WorkerUnfinishedReasonReminderError";
       }
     };
@@ -2526,6 +2529,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" };
@@ -4553,6 +4573,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)) {
@@ -4611,7 +4638,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);
@@ -4627,6 +4654,230 @@ 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 deliveryLimitFromEnv(env) {
+  const raw = env[RECEIPT_DELIVERY_LIMIT_ENV];
+  if (raw === void 0 || raw.trim() === "") return deliveryLimitFromConfig(void 0);
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed)) return deliveryLimitFromConfig(void 0);
+  return deliveryLimitFromConfig(parsed);
+}
+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_config();
+    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, {
@@ -4636,10 +4887,10 @@ __export(session_assistant_usage_exports, {
 });
 import { join as join14 } from "node:path";
 async function readAssistantUsageFromSessionFile(sessionFile) {
-  const { readFile: readFile25 } = await import("node:fs/promises");
+  const { readFile: readFile26 } = await import("node:fs/promises");
   let text;
   try {
-    text = await readFile25(sessionFile, "utf8");
+    text = await readFile26(sessionFile, "utf8");
   } catch (error) {
     if (error?.code === "ENOENT") return void 0;
     throw error;
@@ -5144,6 +5395,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;
@@ -5203,6 +5456,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 = [
@@ -9284,10 +9538,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: readFile25 } = await import("node:fs/promises");
+  const { readFile: readFile26 } = await import("node:fs/promises");
   let raw;
   try {
-    raw = JSON.parse(await readFile25(pointerPath, "utf8"));
+    raw = JSON.parse(await readFile26(pointerPath, "utf8"));
   } catch (error) {
     throw new Error(
       `direct officer run pointer unreadable in ${pointerPath}: ${errorText(error)}`,
@@ -10167,9 +10421,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 randomUUID4();
 }
 function withEngineDetourInvocationScope(request, invocationScopeId) {
@@ -10259,101 +10511,6 @@ var init_dossier_resolution = __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
-  };
-}
-function createReceiptDeliveryPolicy() {
-  let accepted = false;
-  let terminalToolCalled = false;
-  let deliveryTurns = 0;
-  const rejectedReceipts = [];
-  return {
-    recordAccepted() {
-      accepted = true;
-      terminalToolCalled = true;
-    },
-    /** Infrastructure owns terminality and must never trigger receipt催交. */
-    stopForInfrastructure() {
-      accepted = true;
-    },
-    recordRejected(reason) {
-      terminalToolCalled = true;
-      rejectedReceipts.push({ reason, diagnosticAvailable: reason.trim() !== "" });
-      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
-    },
-    recordDeliveryRequest() {
-      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
-    },
-    /**
-     * A nested session settled without an accepted receipt after spending its own
-     * delivery budget. Adopt its facts and close this budget: another prompt would
-     * open an independent session, not a delivery request on the settled one.
-     */
-    recordNestedNoReceipt(facts) {
-      terminalToolCalled = terminalToolCalled || facts.terminalToolCalled;
-      rejectedReceipts.push(...facts.rejectedReceipts);
-      deliveryTurns = RECEIPT_DELIVERY_TURN_LIMIT;
-    },
-    nextAction() {
-      if (accepted) return "accepted";
-      return deliveryTurns < RECEIPT_DELIVERY_TURN_LIMIT ? "request-delivery" : "no-receipt";
-    },
-    /** 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 });
-    }
-  };
-}
-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, {
@@ -10496,13 +10653,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);
@@ -12075,44 +12295,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);
@@ -12282,16 +12484,19 @@ var init_settlement = __esm({
 
 // src/archivist-record-pointer.ts
 import { mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { readFile as readFile17 } from "node:fs/promises";
 import { dirname as dirname17, join as join28 } from "node:path";
 function bookDirectOfficerRunPointer(options) {
   const nest = join28(dirname17(options.parentSessionFile), "auditor-roles");
   mkdirSync2(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`),
@@ -12301,10 +12506,36 @@ function bookDirectOfficerRunPointer(options) {
   );
   return pointer;
 }
+async function readDirectOfficerRunPointer(parentSessionFile, officer) {
+  try {
+    const raw = JSON.parse(await readFile17(
+      join28(dirname17(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";
   }
 });
@@ -12322,6 +12553,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 }
     });
   };
@@ -12369,10 +12601,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,
@@ -12477,7 +12722,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;
   }
@@ -12491,11 +12736,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()
   });
@@ -12515,7 +12763,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);
@@ -12538,6 +12787,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;
     }
@@ -12567,6 +12827,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();
   }
@@ -12746,7 +13007,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) {
@@ -12824,7 +13086,7 @@ var init_turn_request = __esm({
 });
 
 // src/session-identity.ts
-import { mkdir as mkdir3, readFile as readFile17, rename as rename3, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile18, rename as rename3, writeFile as writeFile6 } from "node:fs/promises";
 import { dirname as dirname18, join as join30 } from "node:path";
 function createSessionIdentityAuthority(authority, sessionBindingFile) {
   const bindingPath = (principal) => join30(authority.decode(principal).sessionDirectory, sessionBindingFile);
@@ -12834,7 +13096,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");
         }
@@ -13631,47 +13893,242 @@ async function presentControlledFailure2(admitted, failureInput, adapters, autho
     if (io.omitFailureStderrDiagnostic && publishedErrorPath !== void 0) {
       writeResumeFailurePointer(io, publishedErrorPath);
     }
-    throw error;
+    throw error;
+  }
+  presentFailureTerminal(terminal, io);
+  return {
+    exitCode: exitCodeForTerminalOutcome(terminal.roleOutcome),
+    admitted,
+    terminal
+  };
+}
+async function settleAfterTurnStarted(admitted, failureInput, adapters, authority, io, persistRunState) {
+  try {
+    return await presentControlledFailure2(
+      admitted,
+      failureInput,
+      adapters,
+      authority,
+      io,
+      persistRunState
+    );
+  } catch (error) {
+    throw new TurnDispatchedFailure(error);
+  }
+}
+async function settleDeferredPersist(admitted, authority, adapters, io, result) {
+  if (result.needsPersist !== true || result.terminal === void 0) return result;
+  const { needsPersist: _needsPersist, ...settledResult } = result;
+  const lawful = isLawfulTypedTerminalOutcome(result.terminal.roleOutcome);
+  try {
+    await persistReturnedRunState(admitted, lawful ? { lawful: true } : void 0);
+    return settledResult;
+  } catch (error) {
+    const failed = await settleAfterTurnStarted(
+      admitted,
+      { timedOut: false, code: null, stderr: "", thrown: error, skipRunStateWrite: true },
+      adapters,
+      authority,
+      io,
+      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(
+      join33(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 }) };
   }
-  presentFailureTerminal(terminal, io);
-  return {
-    exitCode: exitCodeForTerminalOutcome(terminal.roleOutcome),
-    admitted,
-    terminal
-  };
-}
-async function settleAfterTurnStarted(admitted, failureInput, adapters, authority, io, persistRunState) {
-  try {
-    return await presentControlledFailure2(
+  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,
-      failureInput,
+      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,
-      authority,
+      env.principalAuthority,
       io,
       persistRunState
     );
-  } catch (error) {
-    throw new TurnDispatchedFailure(error);
+    return { kind: "settled", outcome: await finishAfterTurn(
+      withProcessCancelSkipAutoResume(
+        { ...failed, turnDispatched: true, ...deferredPersist },
+        env.signal
+      )
+    ) };
   }
-}
-async function settleDeferredPersist(admitted, authority, adapters, io, result) {
-  if (result.needsPersist !== true || result.terminal === void 0) return result;
-  const { needsPersist: _needsPersist, ...settledResult } = result;
-  const lawful = isLawfulTypedTerminalOutcome(result.terminal.roleOutcome);
-  try {
-    await persistReturnedRunState(admitted, lawful ? { lawful: true } : void 0);
-    return settledResult;
-  } catch (error) {
+  if (stderrLogWriteFailure !== void 0) {
     const failed = await settleAfterTurnStarted(
       admitted,
-      { timedOut: false, code: null, stderr: "", thrown: error, skipRunStateWrite: true },
+      withEngineDetourInvocationScope({
+        timedOut: false,
+        code: result.code,
+        stderr: result.stderr,
+        thrown: stderrLogWriteFailure
+      }, request.invocationScopeId),
       adapters,
-      authority,
+      env.principalAuthority,
       io,
-      true
+      persistRunState
     );
-    return { ...failed, turnDispatched: true, skipAutoResume: true };
+    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;
@@ -13679,6 +14136,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;
@@ -13776,7 +14236,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,
@@ -13789,7 +14249,7 @@ async function dispatchPostAdmissionTurn(input) {
           io,
           persistRunState
         );
-        return { ...settled2, ...deferredPersist };
+        return { ...settled, ...deferredPersist };
       }
     }
     let turnRequest = {
@@ -13813,10 +14273,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,
@@ -13831,175 +14292,111 @@ async function dispatchPostAdmissionTurn(input) {
       );
       return await finishAfterTurn(
         withProcessCancelSkipAutoResume(
-          { ...settled2, turnDispatched: true, ...deferredPersist },
+          { ...settled, turnDispatched: true, ...deferredPersist },
           env.signal
         )
       );
     }
-    let stderrLogWriteFailure;
-    try {
-      await writeFile7(
-        join33(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) {
@@ -14036,6 +14433,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 {
@@ -14081,7 +14483,9 @@ function resumeTurnRequestProjectionOptions(admitted, request, env, summonsPrepa
       prompt
     },
     ...request.message === void 0 ? {} : { courtAttemptId: randomUUID7() },
-    ...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) {
@@ -14091,7 +14495,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) {
@@ -14109,6 +14515,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,
@@ -14130,6 +14537,7 @@ async function runSettledAutoResumeLoop(input) {
           ...lease === void 0 ? {} : { lease },
           adapters,
           persistRunState: false,
+          receiptDelivery,
           ...input.effectiveEngine === void 0 ? {} : { effectiveEngine: input.effectiveEngine }
         });
         return settleDeferredPersist(
@@ -14492,12 +14900,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();
@@ -14646,12 +15056,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
   );
 }
@@ -14805,6 +15270,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);
@@ -14936,20 +15406,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,
@@ -15218,7 +15684,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 }
     });
@@ -15228,6 +15710,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);
@@ -15253,22 +15740,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);
@@ -15286,7 +15793,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 };
   }
@@ -15294,37 +15811,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));
@@ -15354,12 +15901,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({
@@ -15388,6 +15942,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 }
             });
           }
@@ -15399,7 +15954,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) {
@@ -15422,13 +15985,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) {
@@ -15440,13 +16004,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);
@@ -15459,17 +16023,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 };
@@ -15478,7 +16054,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);
@@ -15498,7 +16074,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";
@@ -15513,6 +16089,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();
@@ -15570,6 +16147,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"]);
   }
 });
@@ -15609,7 +16187,7 @@ var init_analyst_book_key = __esm({
 });
 
 // src/analyst-index.ts
-import { open as open2, readFile as readFile18, unlink as unlink4 } from "node:fs/promises";
+import { open as open2, readFile as readFile19, unlink as unlink4 } from "node:fs/promises";
 import { dirname as dirname21, join as join34 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 async function withAnalystLibraryIndexLock(ledgerHome, fn) {
@@ -15733,7 +16311,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;
@@ -15936,7 +16514,7 @@ var init_analyst_cohort = __esm({
 });
 
 // src/analyst-ledger.ts
-import { readdir as readdir6, readFile as readFile19 } from "node:fs/promises";
+import { readdir as readdir6, readFile as readFile20 } from "node:fs/promises";
 import { basename as basename9, join as join35 } from "node:path";
 async function readExistingRunLifecycleState(runDirectory) {
   return (await readRoleRunIdentity(runDirectory))?.state;
@@ -15986,7 +16564,7 @@ async function listLedgerBookNames(booksRoot) {
 async function readInvocationScopeFields(runDirectory) {
   let raw;
   try {
-    raw = await readFile19(join35(runDirectory, "invocation.json"), "utf8");
+    raw = await readFile20(join35(runDirectory, "invocation.json"), "utf8");
   } catch (error) {
     if (isMissingPathError(error)) return void 0;
     throw error;
@@ -16019,7 +16597,7 @@ function decideIssueScope(input) {
 }
 async function resolveSessionFile(runDirectory) {
   try {
-    const raw = await readFile19(join35(runDirectory, "invocation.json"), "utf8");
+    const raw = await readFile20(join35(runDirectory, "invocation.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (isRecord(parsed) && typeof parsed.sessionFile === "string" && parsed.sessionFile.trim() !== "") {
       return parsed.sessionFile;
@@ -17279,7 +17857,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";
 import { Type as Type18 } from "typebox";
 function cachedPageMatchesRequestedScope(page, input) {
   if (page.bookKey !== input.bookKey) return false;
@@ -17307,7 +17885,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({
@@ -17408,7 +17986,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)) {
@@ -17505,7 +18083,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 isAbsolute9, resolve as resolve15 } from "node:path";
 import { Value as Value3 } from "typebox/value";
 function resolveAnalystIssueBookKeyFromCwd(cwd = process.cwd()) {
@@ -17559,7 +18137,7 @@ async function buildAnalystSweepModeInputFromAttachmentPaths(attachmentPaths) {
   const absolute = isAbsolute9(sourcePath) ? sourcePath : resolve15(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}`,
@@ -18447,7 +19025,7 @@ async function runAkRole(argv, 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,
@@ -19193,10 +19771,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;
     }
@@ -19212,6 +19794,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";
@@ -19351,7 +19934,7 @@ __export(run_lifecycle_exports, {
   renderResumeCommand: () => renderResumeCommand,
   writeRoleRunState: () => writeRoleRunState
 });
-import { chmod, lstat as lstat6, open as open3, readdir as readdir7, readFile as readFile22, unlink as unlink5, writeFile as writeFile8 } from "node:fs/promises";
+import { chmod, lstat as lstat6, open as open3, readdir as readdir7, readFile as readFile23, unlink as unlink5, writeFile as writeFile8 } from "node:fs/promises";
 import { basename as basename10, join as join39 } from "node:path";
 function buildAutoResumeContinuationPrompt(options) {
   return appendEngineSessionMaterial(
@@ -19428,7 +20011,7 @@ function parseCurrentCourtState(raw) {
 async function readRoleRunStateRaw(runDirectory) {
   let raw;
   try {
-    raw = JSON.parse(await readFile22(join39(runDirectory, RUN_STATE_FILE), "utf8"));
+    raw = JSON.parse(await readFile23(join39(runDirectory, RUN_STATE_FILE), "utf8"));
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
     throw error;
@@ -19686,7 +20269,7 @@ function isProcessAlive(pid) {
 async function autopsyWriterLock(lockPath) {
   let content;
   try {
-    content = await readFile22(lockPath, "utf8");
+    content = await readFile23(lockPath, "utf8");
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return { verdict: "absent" };
     return { verdict: "unknown", reason: "unreadable", readFailure: error };
@@ -19883,7 +20466,7 @@ async function readRunParentPath(runDirectory) {
   let raw;
   try {
     raw = JSON.parse(
-      await readFile22(join39(runDirectory, "admitted-request.json"), "utf8")
+      await readFile23(join39(runDirectory, "admitted-request.json"), "utf8")
     );
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
@@ -19998,7 +20581,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let sourceRun;
   try {
     const raw = JSON.parse(
-      await readFile22(run.admittedRequestPath, "utf8")
+      await readFile23(run.admittedRequestPath, "utf8")
     );
     if (isRecord(raw)) {
       const record = raw;
@@ -20120,7 +20703,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let model;
   try {
     const invocationRaw = JSON.parse(
-      await readFile22(join39(run.runDirectory, "invocation.json"), "utf8")
+      await readFile23(join39(run.runDirectory, "invocation.json"), "utf8")
     );
     if (isRecord(invocationRaw)) {
       const rec = invocationRaw;
@@ -20871,7 +21454,7 @@ init_host_descriptions();
 import { randomUUID as randomUUID11 } from "node:crypto";
 
 // src/role-runtime-dependencies.ts
-import { readFile as readFile24 } from "node:fs/promises";
+import { readFile as readFile25 } from "node:fs/promises";
 init_doctor_evidence();
 
 // src/navigator-attendance.ts
@@ -21598,8 +22181,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;
@@ -21626,17 +22209,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 });
@@ -21834,7 +22415,7 @@ function createNavigatorAttendance(options) {
 init_doctor_evidence();
 init_unknown_value();
 init_host_contracts();
-import { readFile as readFile23 } from "node:fs/promises";
+import { readFile as readFile24 } from "node:fs/promises";
 import { resolve as resolve18 } from "node:path";
 init_notary_source_run();
 init_packaged_role_registry();
@@ -21848,7 +22429,7 @@ function navigatorInputReference(getFlag, role) {
 async function loadNavigatorWorkContext(options) {
   const reference = navigatorInputReference(options.getFlag, options.role);
   const subjectMode = packagedNavigatorSubject(options.role);
-  const input = reference === void 0 || subjectMode === "case" || subjectMode === "source-run" ? void 0 : await readFile23(reference, "utf8");
+  const input = reference === void 0 || subjectMode === "case" || subjectMode === "source-run" ? void 0 : await readFile24(reference, "utf8");
   const subjectRoot = subjectPath(reference ?? options.context.sessionManager.getSessionDir(), options.context.cwd);
   let subjectKey = reference === void 0 ? subjectRoot : navigatorSubjectKeyForInput(subjectRoot, reference, options.context.cwd);
   let subject = input ?? `work subject: ${subjectKey}`;
@@ -21905,7 +22486,7 @@ async function loadNavigatorWorkContext(options) {
   let authorityMaterial;
   for (const path of authorityFiles) {
     try {
-      const content = await readFile23(path, "utf8");
+      const content = await readFile24(path, "utf8");
       if (content.trim() !== "") {
         authorityMaterial = content;
         break;
@@ -22657,6 +23238,7 @@ init_archivist_record_entry();
 init_sitian_facade();
 init_submission_errors();
 init_worker_submission_contracts();
+init_receipt_delivery_policy();
 init_unknown_value();
 init_submission_errors();
 init_worker_submission_contracts();
@@ -22667,11 +23249,11 @@ var WORKER_SUBMISSION_GATE_RECORD_KIND = WORKER_SUBMISSION_GATE_KIND;
 var WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
 var WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE = "commit-reminder-bounce";
 var WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE = "prefix-reminder-bounce";
+var WORKER_UNFINISHED_REASON_BOUNCE_ENTRY_TYPE = "unfinished-reason-bounce";
 var HOOK_MARKER = "ak-roles: worker-submission-gates reference-transaction";
 var HOOKS_DIR = "ak-roles-hooks";
 var HOOK_FILE = "reference-transaction";
 var PLATFORM_PREFIX = /^[A-Za-z][A-Za-z0-9_-]*:/;
-var UNFINISHED_REASON_BOUNCE_LIMIT = 2;
 function git2(cwd, args) {
   return execFileSync3("git", args, {
     cwd,
@@ -22771,10 +23353,11 @@ function unfinishedReasonPresent(details) {
   if (!isRecord(details)) return false;
   return containsWrittenReason(details.reason);
 }
-function readGateState(session) {
+function readGateState(session, invocationScopeId) {
   let baseline;
   let reminded = false;
   let prefixReminded = false;
+  let unfinishedReasonBounces = 0;
   for (const entry of session.getEntries()) {
     if (entry.type !== "custom") continue;
     if (entry.customType === WORKER_COMMIT_BASELINE_ENTRY_TYPE) {
@@ -22786,9 +23369,11 @@ function readGateState(session) {
       reminded = true;
     } else if (entry.customType === WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE) {
       prefixReminded = true;
+    } else if (entry.customType === WORKER_UNFINISHED_REASON_BOUNCE_ENTRY_TYPE && invocationScopeId !== void 0 && isRecord(entry.data) && entry.data.invocationScopeId === invocationScopeId) {
+      unfinishedReasonBounces += 1;
     }
   }
-  return { baseline, reminded, prefixReminded };
+  return { baseline, reminded, prefixReminded, unfinishedReasonBounces };
 }
 function isAncestor(cwd, ancestor, descendant) {
   try {
@@ -22819,9 +23404,11 @@ function createWorkerSubmissionGate(options = {}) {
   let reminded = false;
   let prefixReminded = false;
   let unfinishedReasonBounces = 0;
+  let invocationScopeId;
   let record;
   let sessionParent;
   const explicitHome = typeof options.home === "string" && options.home.length > 0 ? options.home : void 0;
+  const unfinishedReasonBounceLimit = deliveryLimitFromConfig(options.unfinishedReasonBounceLimit);
   const head = (cwd) => {
     try {
       return git2(cwd, ["rev-parse", "HEAD"]);
@@ -22842,7 +23429,8 @@ function createWorkerSubmissionGate(options = {}) {
     });
   };
   return {
-    arm(cwd, parent) {
+    arm(cwd, parent, scope) {
+      invocationScopeId = scope;
       uninstallPackageWorkerHooks(cwd);
       root = cwd;
       sessionParent = parent.getSessionFile();
@@ -22851,7 +23439,8 @@ function createWorkerSubmissionGate(options = {}) {
         kind: WORKER_SUBMISSION_GATE_RECORD_KIND,
         parent
       });
-      const prior = readGateState(record);
+      const prior = readGateState(record, invocationScopeId);
+      unfinishedReasonBounces = prior.unfinishedReasonBounces;
       if (prior.baseline !== void 0) {
         baseline = prior.baseline;
         reminded = prior.reminded;
@@ -22873,7 +23462,11 @@ function createWorkerSubmissionGate(options = {}) {
     },
     assertAcceptable(status, details) {
       if (status === "unfinished" && !unfinishedReasonPresent(details)) {
-        if (unfinishedReasonBounces < UNFINISHED_REASON_BOUNCE_LIMIT) {
+        if (unfinishedReasonBounces < unfinishedReasonBounceLimit) {
+          record?.appendCustomEntry(WORKER_UNFINISHED_REASON_BOUNCE_ENTRY_TYPE, {
+            version: 1,
+            invocationScopeId
+          });
           unfinishedReasonBounces += 1;
           throw new WorkerUnfinishedReasonReminderError();
         }
@@ -22907,6 +23500,9 @@ function createWorkerSubmissionGate(options = {}) {
   };
 }
 
+// src/worker-role.ts
+init_receipt_delivery_policy();
+
 // src/fixer-bash-seatbelt.ts
 var FIXER_BASH_FORBIDDEN_LITERALS = [
   "rm -rf",
@@ -22995,14 +23591,16 @@ function assertAcceptableThroughHost(submissionGate, status, details, hostAction
     hostActions.failInfrastructure(error, ctx, toolCallId);
   }
 }
-function createFixerRoleRuntime(pi, dependencies, hostActions) {
+function createFixerRoleRuntime(pi, dependencies, hostActions, options) {
   let soul;
   let packet;
   let packetPath;
   let prerequisitesPath;
   let phase;
   let lifecycleRegistered = false;
-  const submissionGate = createWorkerSubmissionGate();
+  const submissionGate = createWorkerSubmissionGate({
+    unfinishedReasonBounceLimit: options?.unfinishedReasonBounceLimit ?? deliveryLimitFromEnv(process.env)
+  });
   pi.registerFlag(
     FIXER_FLAG_DEFINITIONS.packet.name,
     FIXER_FLAG_DEFINITIONS.packet.definition
@@ -23091,17 +23689,19 @@ ${packetPath}
         });
       }
     },
-    armSubmissionGate(cwd, parent) {
-      submissionGate.arm(cwd, parent);
+    armSubmissionGate(cwd, parent, invocationScopeId) {
+      submissionGate.arm(cwd, parent, invocationScopeId);
     }
   };
 }
-function createCoderRoleRuntime(pi, dependencies, hostActions) {
+function createCoderRoleRuntime(pi, dependencies, hostActions, options) {
   let soul;
   let task;
   let phase;
   let lifecycleRegistered = false;
-  const submissionGate = createWorkerSubmissionGate();
+  const submissionGate = createWorkerSubmissionGate({
+    unfinishedReasonBounceLimit: options?.unfinishedReasonBounceLimit ?? deliveryLimitFromEnv(process.env)
+  });
   pi.registerFlag("ak-coder-task", {
     description: "Markdown task assigned to the coder role",
     type: "string"
@@ -23157,8 +23757,8 @@ ${task ?? ""}
         });
       }
     },
-    armSubmissionGate(cwd, parent) {
-      submissionGate.arm(cwd, parent);
+    armSubmissionGate(cwd, parent, invocationScopeId) {
+      submissionGate.arm(cwd, parent, invocationScopeId);
     }
   };
 }
@@ -23749,7 +24349,8 @@ function lastAssistantProse(messages) {
   }
   return void 0;
 }
-function createRoleRuntimeExtension(dependencies) {
+function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
+  const deliveryLimit = deliveryRequestLimit === void 0 ? deliveryLimitFromEnv(process.env) : deliveryLimitFromConfig(deliveryRequestLimit);
   return (envelopeHost) => {
     let projectClosedSubmission = async () => {
       throw new Error("\u89D2\u8272\u7EC8\u5C40\u6295\u5C04\u63A5\u7F1D\u5C1A\u672A\u521D\u59CB\u5316");
@@ -23806,7 +24407,7 @@ function createRoleRuntimeExtension(dependencies) {
     const pendingInfrastructureFailures = /* @__PURE__ */ new Map();
     const pendingSubmissionNonPassByToolCallId = /* @__PURE__ */ new Map();
     let engineDetourRegistered = false;
-    let receiptDelivery = createReceiptDeliveryPolicy();
+    let receiptDelivery = createReceiptDeliveryPolicy(deliveryLimit);
     let noReceiptRecorded = false;
     let priorFetch;
     let fetchWrapped = false;
@@ -23969,7 +24570,7 @@ function createRoleRuntimeExtension(dependencies) {
         }
       };
     });
-    roleHost.on("tool_result", async (event) => {
+    roleHost.on("tool_result", async (event, ctx) => {
       const role = selectedRole;
       if (role === void 0) return;
       const pendingInfra = pendingInfrastructureFailures.get(event.toolCallId);
@@ -23981,9 +24582,17 @@ function createRoleRuntimeExtension(dependencies) {
       const outputClassification = isOutputTool ? classifyPackagedRoleTerminalResult(classified) : void 0;
       if (isRoleInfrastructureFailure || outputClassification?.kind === "infrastructure") {
         receiptDelivery.stopForInfrastructure();
-      } else if (isOutputTool && outputClassification?.kind === "nonterminal" && event.isError) {
-        const reason = (event.content ?? []).map((part) => part.type === "text" && "text" in part ? part.text : "").join("").trim();
-        receiptDelivery.recordRejected(reason);
+      } else if (isOutputTool) {
+        const reason = packagedRoleOutputRejectionReason(classified);
+        if (reason !== void 0) {
+          receiptDelivery.recordRejected(reason);
+          if (ctx.invocationScopeId !== void 0) {
+            envelopeHost.appendEntry(RECEIPT_REJECTION_ENTRY, {
+              invocationScopeId: ctx.invocationScopeId,
+              reason
+            });
+          }
+        }
       }
       const settlement = isRoleInfrastructureFailure || outputClassification?.kind === "infrastructure" ? publicNavigatorSettlement(role, navigatorPhase(roleHost, role), classified) : void 0;
       await settleNavigatorProjection(settlement);
@@ -24025,10 +24634,11 @@ function createRoleRuntimeExtension(dependencies) {
           const runPointer = runDirectoryFromHostContext(ctx);
           if (runPointer !== void 0) {
             noReceiptRecorded = true;
-            while (receiptDelivery.nextAction() === "request-delivery") {
-              receiptDelivery.recordDeliveryRequest();
-            }
-            const facts = receiptDelivery.facts({ runPointer, attemptPointer: `current:${runPointer}` });
+            receiptDelivery.closeBudget();
+            const facts = receiptDelivery.facts({
+              runPointer,
+              attemptPointer: receiptAttemptPointer(runPointer, ctx.invocationScopeId)
+            });
             envelopeHost.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
             try {
               sitianReport({
@@ -24047,7 +24657,11 @@ function createRoleRuntimeExtension(dependencies) {
       }
       if (receiptDelivery.nextAction() === "request-delivery") {
         receiptDelivery.recordDeliveryRequest();
-        envelopeHost.appendEntry("ak-receipt-delivery-request");
+        const scopeId = ctx.invocationScopeId?.trim() ?? "";
+        envelopeHost.appendEntry(
+          RECEIPT_DELIVERY_REQUEST_ENTRY,
+          scopeId.length > 0 ? { invocationScopeId: scopeId } : void 0
+        );
         try {
           sitianReport({
             level: "event",
@@ -24068,7 +24682,10 @@ function createRoleRuntimeExtension(dependencies) {
         const runPointer = runDirectoryFromHostContext(ctx);
         if (runPointer !== void 0) {
           noReceiptRecorded = true;
-          const facts = receiptDelivery.facts({ runPointer, attemptPointer: `current:${runPointer}` });
+          const facts = receiptDelivery.facts({
+            runPointer,
+            attemptPointer: receiptAttemptPointer(runPointer, ctx.invocationScopeId)
+          });
           envelopeHost.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
           try {
             sitianReport({
@@ -24155,7 +24772,8 @@ function createRoleRuntimeExtension(dependencies) {
           return dependencies.loadFixPacket(path);
         }
       },
-      hostActions
+      hostActions,
+      { unfinishedReasonBounceLimit: deliveryLimit }
     );
     const coder = createCoderRoleRuntime(
       roleHost,
@@ -24168,7 +24786,8 @@ function createRoleRuntimeExtension(dependencies) {
           return dependencies.loadCoderTask(path);
         }
       },
-      hostActions
+      hostActions,
+      { unfinishedReasonBounceLimit: deliveryLimit }
     );
     const reviewer = createReviewerRoleRuntime(
       roleHost,
@@ -24351,7 +24970,7 @@ function createRoleRuntimeExtension(dependencies) {
       roleReferenceMaterials = "";
       activeReviewerParent = void 0;
       activeCollector = void 0;
-      receiptDelivery = createReceiptDeliveryPolicy();
+      receiptDelivery = createReceiptDeliveryPolicy(deliveryLimit);
       noReceiptRecorded = false;
       pendingNavigatorPresentation = void 0;
       navigatorActivation += 1;
@@ -24397,6 +25016,12 @@ function createRoleRuntimeExtension(dependencies) {
       try {
         resolveBookKeyFromGit(ctx.cwd);
         durableSessionPointer(ctx.sessionManager);
+        const scopeId = ctx.invocationScopeId?.trim() ?? "";
+        if (scopeId.length > 0) {
+          receiptDelivery.continueIssued(
+            priorReceiptContinuation(ctx.sessionManager.getEntries(), scopeId)
+          );
+        }
         const isStationChild = roleHost.getFlag(STATION_CHILD_FLAG.name) === true;
         if (dependencies.createNavigatorAttendance !== void 0 && entry.outputTool !== NAVIGATOR_TOOL_SPEC.name && !isStationChild) {
           navigatorSessionParent = ctx.sessionManager.getSessionFile();
@@ -24460,6 +25085,7 @@ function createRoleRuntimeExtension(dependencies) {
             subject: work.subject,
             authority: work.authority,
             invocationId,
+            deliveryRequestLimit: deliveryLimit,
             ...contextError === void 0 ? {} : { contextError },
             onEvent: (navigatorEvent, report) => {
               if (activation === navigatorActivation && !navigatorDeliveryClosed) {
@@ -24483,7 +25109,7 @@ function createRoleRuntimeExtension(dependencies) {
         }
         if ("worker" in entry && entry.worker === true) {
           const workerArms = { coder, fixer };
-          workerArms[entry.role].armSubmissionGate(ctx.cwd, ctx.sessionManager);
+          workerArms[entry.role].armSubmissionGate(ctx.cwd, ctx.sessionManager, ctx.invocationScopeId);
         }
         admitted = true;
       } catch (error) {
@@ -24513,11 +25139,11 @@ function createRoleRuntimeDependencies(packageRoot) {
     packageRoot,
     loadRoleReferenceMaterials: loadPackagedRoleReferenceMaterials,
     loadRoleSoul: loadRegisteredRoleSoul,
-    loadFixPacket: (path) => readFile24(path, "utf8"),
-    loadCoderTask: (path) => readFile24(path, "utf8"),
+    loadFixPacket: (path) => readFile25(path, "utf8"),
+    loadCoderTask: (path) => readFile25(path, "utf8"),
     loadDoctorCase,
     loadNotarySourceRun: loadNotarySourceRunLocator,
-    loadMergerInput: async (path) => JSON.parse(await readFile24(path, "utf8")),
+    loadMergerInput: async (path) => JSON.parse(await readFile25(path, "utf8")),
     loadNavigatorWorkContext: (options) => loadNavigatorWorkContext({
       context: options.context,
       role: options.role,
@@ -24532,6 +25158,7 @@ function createRoleRuntimeDependencies(packageRoot) {
       authority: options.authority,
       invocationId: options.invocationId,
       createSession: navigatorSessionFactory,
+      ...options.deliveryRequestLimit === void 0 ? {} : { deliveryRequestLimit: options.deliveryRequestLimit },
       ...options.contextError === void 0 ? {} : { contextError: options.contextError },
       onEvent: options.onEvent
     })
@@ -24541,6 +25168,7 @@ function createRoleRuntimeDependencies(packageRoot) {
 // src/role-envelope.ts
 init_engine_detour();
 init_packaged_role_registry();
+init_receipt_delivery_policy();
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { appendFile as appendFile3, mkdir as mkdir5, writeFile as writeFile9 } from "node:fs/promises";
 import { createServer } from "node:net";
@@ -24726,7 +25354,10 @@ async function prepareRoleEnvelope(options) {
     stopKeepalive() {
     }
   };
-  createRoleRuntimeExtension(options.dependencies)(envelope);
+  createRoleRuntimeExtension(
+    options.dependencies,
+    deliveryLimitFromConfig(options.request.deliveryRequestLimit)
+  )(envelope);
   const token = randomUUID9();
   const server = createServer((socket) => serveSocket(socket));
   function rememberProjectedRejection(details, toolCallId, content) {
@@ -25118,8 +25749,9 @@ import { writeFile as writeFile10 } from "node:fs/promises";
 import { dirname as dirname26, isAbsolute as isAbsolute12, join as join45, resolve as resolve21 } from "node:path";
 
 // src/external-host-turn-loop.ts
+init_receipt_delivery_policy();
+init_submission_errors();
 init_unknown_value();
-var EXTERNAL_ROLE_TURN_ROUND_LIMIT = 8;
 function mergeRoleTurnAbortSignals(prepared, request) {
   if (request === void 0) return prepared;
   if (prepared === void 0) return request;
@@ -25168,7 +25800,10 @@ async function driveExternalRoleTurnRounds(prepared, request, driver) {
   let prompt = prepared.prompt;
   const abortSignal = mergeRoleTurnAbortSignals(prepared.abortSignal, request.signal);
   let stderr = "";
-  for (let attempt = 0; attempt < EXTERNAL_ROLE_TURN_ROUND_LIMIT; attempt += 1) {
+  const countedReaskLimit = deliveryLimitFromConfig(request.deliveryRequestLimit);
+  const exemptReminders = /* @__PURE__ */ new Set();
+  let countedReasks = 0;
+  for (let attempt = 0; ; attempt += 1) {
     if (abortSignal?.aborted) return settleHostAborted(prepared, driver.currentSessionId());
     let round;
     try {
@@ -25189,14 +25824,22 @@ async function driveExternalRoleTurnRounds(prepared, request, driver) {
       return { code: 0, stderr, timedOut: false };
     }
     if ("failure" in closure) return asFailure(closure.failure, stderr);
+    const reminderCode = closure.retry.code;
+    const exempt = isOneShotWorkerReminderCode(reminderCode) && !exemptReminders.has(reminderCode);
+    if (exempt) exemptReminders.add(reminderCode);
+    else {
+      countedReasks += 1;
+      if (countedReasks > countedReaskLimit) {
+        return asFailure({
+          cause: "output",
+          identity: { name: driver.roundLimitName, code: "round-retry-limit" },
+          ...driver.currentSessionId() === void 0 ? {} : { details: { sessionId: driver.currentSessionId() } }
+        });
+      }
+    }
     prompt = closure.retry.message;
     driver.afterRetry?.();
   }
-  return asFailure({
-    cause: "output",
-    identity: { name: driver.roundLimitName, code: "round-retry-limit" },
-    ...driver.currentSessionId() === void 0 ? {} : { details: { sessionId: driver.currentSessionId() } }
-  });
 }
 function createSerializedRoleTurnHost(execute) {
   let serial = Promise.resolve();