@akagilnc/pi-workflow-roles 0.1.5375 → 0.1.5406

package/dist/public-cli/main.js

@@ -8611,11 +8611,26 @@ var init_judge_output = __esm({
 });
 
 // src/package-contracts/reviewer-output.ts
-var REVIEWER_OUTPUT_TOOL_NAME;
+var REVIEWER_OUTPUT_TOOL_NAME, REVIEWER_AMENDMENTS_DESCRIPTION, REVIEWER_STATUS_DESCRIPTION, reviewerOutputObject, reviewerOutputSchema;
 var init_reviewer_output = __esm({
   "src/package-contracts/reviewer-output.ts"() {
     "use strict";
+    init_build();
+    init_open_tool_schema();
+    init_terminating_infrastructure();
     REVIEWER_OUTPUT_TOOL_NAME = "ak_reviewer_output";
+    REVIEWER_AMENDMENTS_DESCRIPTION = "\u5DF2\u8FD0\u884C lens \u7684 amendments \u627F\u8F7D candidates\u3001\u9010\u6761\u5904\u7F6E\u4E0E verdict \u7684\u5B8C\u6574\u62A5\u544A\uFF08\u975E\u4EC5 verdict \u884C\uFF09\uFF1B\u663E\u5F0F\u5355\u8F74\u65F6\u53E6\u4E00\u8F74\u53EF\u7701\u7565\uFF08completeness / correctness\uFF09\u3002hard-stop\uFF0Fusage error \u4E3A refused \u65F6\uFF0C\u5DF2\u4EA7\u51FA\u62A5\u544A\u4ECD\u7167\u5F55\u5BF9\u5E94 lens \u5B57\u6BB5\u3002";
+    REVIEWER_STATUS_DESCRIPTION = "completed | refused\u3002\u4E24\u79CD\u6B63\u5E38 lens verdict\uFF08completeness / correctness\uFF09\u5747 completed\uFF1Bhard-stop \u4E0E usage error \u4E3A refused\uFF08\u5DF2\u4EA7\u51FA\u62A5\u544A\u4ECD\u7167\u5F55\u8FDB\u6240\u9009 lens amendments\uFF09\u3002";
+    reviewerOutputObject = typebox_exports.Object({
+      status: typebox_exports.Unknown({ description: REVIEWER_STATUS_DESCRIPTION }),
+      amendments: typebox_exports.Unknown({ description: REVIEWER_AMENDMENTS_DESCRIPTION }),
+      diagnostic: typebox_exports.Unknown({
+        description: "\u62D2\u7EDD\u8BCA\u65AD\u8BF4\u660E\uFF1Bhard-stop\uFF0Fusage error \u539F\u56E0\u8FDB\u6B64\u5B57\u6BB5\uFF0C\u5DF2\u4EA7\u51FA\u62A5\u544A\u53E6\u7167\u5F55 amendments"
+      })
+    });
+    reviewerOutputSchema = withTerminatingOutputDeclarations(
+      openToolObject(reviewerOutputObject)
+    );
   }
 });
 
@@ -14644,14 +14659,28 @@ var init_fixer_packet = __esm({
 });
 
 // src/package-contracts/worker-output.ts
-var CODER_OUTPUT_TOOL_NAME;
+var CODER_OUTPUT_TOOL_NAME, CODER_STATUS_DESCRIPTION, coderOutputObject, coderOutputSchema;
 var init_worker_output = __esm({
   "src/package-contracts/worker-output.ts"() {
     "use strict";
+    init_build();
+    init_open_tool_schema();
     init_fixer_output();
     init_fixer_packet();
-    init_fixer_output();
+    init_terminating_infrastructure();
     CODER_OUTPUT_TOOL_NAME = "ak_coder_output";
+    CODER_STATUS_DESCRIPTION = `planned | completed | refused | partially_completed | unfinished\u3002unfinished\uFF1A\u7F3A\u524D\u7F6E\u6216\u8FDD\u5BAA\u7EA6\u675F\u81F4\u672C\u5C40\u672A\u5B8C\u6210\u3002${PARTIALLY_COMPLETED_DEFINITION}`;
+    coderOutputObject = typebox_exports.Object({
+      status: typebox_exports.Unknown({ description: CODER_STATUS_DESCRIPTION }),
+      report: typebox_exports.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
+      remainingScope: typebox_exports.Unknown({ description: "\u672C\u5C40\u540E\u5269\u4F59\u5DE5\u4F5C" }),
+      reason: typebox_exports.Unknown({
+        description: "\u963B\u65AD\u539F\u56E0\uFF1A\u7F3A\u524D\u7F6E\u6216\u8FDD\u5BAA\u7EA6\u675F\u3002\u7F3A\u5F85\u51B3 owner \u51B3\u5B9A\u6216\u7B54\u590D\u5C5E\u7F3A\u524D\u7F6E\u3002"
+      })
+    });
+    coderOutputSchema = withTerminatingOutputDeclarations(
+      openToolObject(coderOutputObject)
+    );
   }
 });
 
@@ -14663,7 +14692,7 @@ var init_canonical_json = __esm({
 });
 
 // src/doctor-contracts.ts
-var DOCTOR_OUTPUT_TOOL_NAME, DOCTOR_AUDIT_TOOL_NAME, DOCTOR_TARGET_KINDS, DOCTOR_DISPOSITIONS, DOCTOR_PRESCRIPTION_KINDS, biteActual, biteNone, DOCTOR_BITE_KINDS, DOCTOR_STATUS_DESCRIPTION, doctorSubmissionObject, doctorSubmissionSchema, doctorEvidenceReadSchema;
+var DOCTOR_OUTPUT_TOOL_NAME, DOCTOR_AUDIT_TOOL_NAME, DOCTOR_OUTPUT_TOOL_DESCRIPTION, DOCTOR_TARGET_KINDS, DOCTOR_DISPOSITIONS, DOCTOR_PRESCRIPTION_KINDS, biteActual, biteNone, DOCTOR_BITE_KINDS, DOCTOR_STATUS_DESCRIPTION, doctorSubmissionObject, doctorSubmissionSchema, doctorEvidenceReadSchema;
 var init_doctor_contracts = __esm({
   "src/doctor-contracts.ts"() {
     "use strict";
@@ -14674,6 +14703,7 @@ var init_doctor_contracts = __esm({
     init_unknown_value();
     DOCTOR_OUTPUT_TOOL_NAME = "ak_doctor_output";
     DOCTOR_AUDIT_TOOL_NAME = "ak_doctor_audit_decision";
+    DOCTOR_OUTPUT_TOOL_DESCRIPTION = "\u63D0\u4EA4\u552F\u4E00\u7EC8\u5C40\u5355\u6848\u8BC1\u8BCD\uFF1Bcompleted \u5141\u8BB8\u7A7A findings\u3002";
     DOCTOR_TARGET_KINDS = ["law", "gate", "template", "station", "seat"];
     DOCTOR_DISPOSITIONS = ["keep", "thin", "delete"];
     DOCTOR_PRESCRIPTION_KINDS = ["retain", "delete", "simplify", "patch", "addMechanism"];
@@ -14811,12 +14841,27 @@ var init_countersign_contracts = __esm({
 });
 
 // src/gleaner-left-contracts.ts
-var GLEANER_LEFT_OUTPUT_TOOL_NAME;
+var GLEANER_LEFT_OUTPUT_TOOL_NAME, gleanerLeftOutputSchema;
 var init_gleaner_left_contracts = __esm({
   "src/gleaner-left-contracts.ts"() {
     "use strict";
+    init_build();
+    init_open_tool_schema();
+    init_terminating_infrastructure();
     init_unknown_value();
     GLEANER_LEFT_OUTPUT_TOOL_NAME = "ak_gleaner_left_output";
+    gleanerLeftOutputSchema = withTerminatingOutputDeclarations(
+      openToolObject(
+        typebox_exports.Object({
+          status: typebox_exports.Unknown({
+            description: "completed"
+          }),
+          findings: typebox_exports.Unknown({
+            description: "\u5F39\u7AE0\u5217\u8868\uFF1B\u6BCF\u6761\u53EF\u542B pointer\uFF08\u6587\u4EF6/\u884C\u6307\u9488\uFF09\u4E0E statement\uFF08\u7591\u70B9\u9648\u8FF0\uFF09\uFF0C\u539F\u6837\u7559\u5B58\u3002\u7A7A\u5217\u8868\u5408\u6CD5\u5B8C\u5C40\uFF1B\u673A\u5668\u4E0D\u5224\u5F39\u7AE0\u662F\u5426\u6210\u7ACB\u3002"
+          })
+        })
+      )
+    );
   }
 });
 
@@ -14853,23 +14898,69 @@ var init_ticket_provenance_contracts = __esm({
 });
 
 // src/diarist-contracts.ts
-var DIARIST_OUTPUT_TOOL_NAME;
+var DIARIST_OUTPUT_TOOL_NAME, DIARIST_SESSIONS_DESCRIPTION, diaristOutputSchema;
 var init_diarist_contracts = __esm({
   "src/diarist-contracts.ts"() {
     "use strict";
+    init_build();
+    init_open_tool_schema();
+    init_terminating_infrastructure();
     init_ticket_provenance_contracts();
     init_run_ticket_number();
     init_unknown_value();
     DIARIST_OUTPUT_TOOL_NAME = "ak_diarist_output";
+    DIARIST_SESSIONS_DESCRIPTION = "\u5BF9\u8BDD\u8FB9\u754C\u3002\u6BCF\u5377\u542B path\uFF08\u4F1A\u8BDD\u5377\u7EDD\u5BF9\u6216\u53EF\u8BFB\u8DEF\u5F84\uFF09\u4E0E ranges\uFF08\u672C\u5377\u672C\u8F6E\u5404\u533A\u95F4\uFF09\u3002\u6BCF\u6BB5\u533A\u95F4\u542B from / to\uFF1B\u8D77\u70B9\u4E0E\u7EC8\u70B9\u5404\u5199 id\uFF08\u539F\u751F id\uFF09\u6216 line\uFF08\u672C\u8F6E\u884C\u53F7\uFF09\uFF0C\u4E8C\u9009\u4E00\u3002\u7A7A\u5217\u8868\uFF1D\u672C\u8F6E\u65E0\u5BF9\u8BDD\u53EF\u5212\u3002\u7AEF\u70B9\u65E0\u6CD5\u6307\u540D\u65F6\u8D70 reask\uFF0C\u4E0D\u4E2D\u6B62\u3002";
+    diaristOutputSchema = withTerminatingOutputDeclarations(
+      openToolObject(
+        typebox_exports.Object({
+          status: typebox_exports.Unknown({
+            description: "completed | escalate"
+          }),
+          ticketNumber: typebox_exports.Optional(
+            typebox_exports.Unknown({
+              description: "\u672C\u5EAD\u5BF9\u8C61\u7968\u53F7\uFF08\u6B63\u6574\u6570\uFF09\u6216 null/\u7701\u7565\uFF1D\u771F\u65E0\u7968\uFF1B\u4E0B\u6E38\u8D70 typed \u952E\uFF1B\u8BA4\u4E0D\u51FA\u7528 status=escalate\uFF0C\u4E0D\u6D17\u6210\u65E0\u5F55\u3002\u673A\u68B0\u5C42\u4E0D\u91CD\u5224\u3002"
+            })
+          ),
+          reason: typebox_exports.Unknown({
+            description: "status \u4E3A escalate \u65F6\uFF1A\u8BA4\u4E0D\u51FA\u672C\u5EAD\u5BF9\u8C61\u7684\u539F\u56E0"
+          }),
+          sessions: typebox_exports.Optional(typebox_exports.Unknown({ description: DIARIST_SESSIONS_DESCRIPTION })),
+          ticketSessions: typebox_exports.Unknown({
+            description: `\u591A\u7968\u5EAD\u9010\u7968\u5BF9\u8BDD\u8FB9\u754C\uFF1B\u6BCF\u7968\u542B ticketNumber\uFF08\u672C\u6761\u8FB9\u754C\u6240\u5F52\u7968\u53F7\uFF0C\u6B63\u6574\u6570\uFF09\u4E0E sessions\uFF08${DIARIST_SESSIONS_DESCRIPTION}\uFF09\u3002\u4E00\u6B21\u4EA4\u5377\u5404\u7968\u5404\u81EA\u5206\u5F55\u3002\u4E0E\u5355\u7968 sessions \u4E8C\u9009\u4E00\u3002`
+          })
+        })
+      )
+    );
   }
 });
 
 // src/secretariat-contracts.ts
-var SECRETARIAT_OUTPUT_TOOL_NAME, SECRETARIAT_GATE_OFFICER_ENTRY_TYPE, SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY;
+var SECRETARIAT_OUTPUT_TOOL_NAME, secretariatVerdictSchema, SECRETARIAT_GATE_OFFICER_ENTRY_TYPE, SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY;
 var init_secretariat_contracts = __esm({
   "src/secretariat-contracts.ts"() {
     "use strict";
+    init_build();
+    init_terminating_infrastructure();
     SECRETARIAT_OUTPUT_TOOL_NAME = "ak_secretariat_output";
+    secretariatVerdictSchema = withTerminatingOutputDeclarations(
+      typebox_exports.Object(
+        {
+          secretariatStatus: typebox_exports.Unknown({
+            description: "converged | escalate"
+          }),
+          ticketNumber: typebox_exports.Optional(
+            typebox_exports.Unknown({ description: "\u672C\u7968\u53F7\uFF1B\u7F72\u65F6\u6307\u5411\u6700\u7EC8\u6B63\u6587\u6240\u5728\u7968" })
+          ),
+          note: typebox_exports.Unknown({ description: "\u9644\u6CE8" }),
+          evidence: typebox_exports.Optional(typebox_exports.Unknown({ description: "\u7559\u5B58\u8BC1\u636E" })),
+          decisionGate: typebox_exports.Unknown({
+            description: "\u9700\u965B\u4E0B\u5904\u7F6E\u7684\u95EE\u9898\u4E0E\u9009\u9879\uFF1B\u53EF\u5199 question \u4E0E options\uFF0C\u539F\u6837\u7559\u5B58\u3002"
+          })
+        },
+        { additionalProperties: true }
+      )
+    );
+    secretariatVerdictSchema.required = [];
     SECRETARIAT_GATE_OFFICER_ENTRY_TYPE = "ak-secretariat-gate-officer";
     SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY = "countersignTerminal";
   }
@@ -16866,6 +16957,161 @@ var init_submission_errors = __esm({
   }
 });
 
+// src/collector-tool-schemas.ts
+var collectorOutputBaseSchema, collectorOutputArgsSchema;
+var init_collector_tool_schemas = __esm({
+  "src/collector-tool-schemas.ts"() {
+    "use strict";
+    init_build();
+    init_open_tool_schema();
+    init_terminating_infrastructure();
+    collectorOutputBaseSchema = openToolObject(
+      typebox_exports.Object({
+        groups: typebox_exports.Unsafe({
+          description: "\u6309\u673A\u5668\u8EAB\u4EFD\u5F52\u7EC4\u7684\u51FA\u5E2D\u3001\u6750\u6599\u4E0E\u9010\u6761 findings\uFF08LLM \u81EA\u884C\u4ECE\u5BBF\u4E3B CLI \u53D6\u8BC1\u6574\u7406\uFF1B\u4EE3\u7801\u4E0D\u4EE3\u6536\u4E0D\u5F52\u5E76\uFF09\u3002"
+        }),
+        unfinishedReasons: typebox_exports.Unknown({
+          description: "\u672A\u5B8C\u6210\u539F\u56E0\uFF1B\u53D6\u8BC1\u53D7\u9650\u65F6\u5982\u5B9E\u62A5\u544A\u3002"
+        })
+      })
+    );
+    collectorOutputArgsSchema = withTerminatingOutputDeclarations(
+      collectorOutputBaseSchema
+    );
+  }
+});
+
+// src/role-submission-declarations.ts
+function roleSubmissionDeclaration(role) {
+  const name = packagedRoleOutputTool(role);
+  if (name === void 0) throw new Error(`${role} output tool is not declared`);
+  const face = SUBMISSION_FACE[role];
+  return {
+    role,
+    name,
+    label: face.label,
+    description: face.description,
+    ..."promptSnippet" in face ? { promptSnippet: face.promptSnippet } : {},
+    parameters: face.parameters
+  };
+}
+var SUBMISSION_FACE;
+var init_role_submission_declarations = __esm({
+  "src/role-submission-declarations.ts"() {
+    "use strict";
+    init_packaged_role_registry();
+    init_review_submission();
+    init_collector_tool_schemas();
+    init_diarist_contracts();
+    init_doctor_contracts();
+    init_fixer_output();
+    init_gatekeeper_output();
+    init_gleaner_left_contracts();
+    init_merger_contracts();
+    init_navigator_output();
+    init_reviewer_output();
+    init_secretariat_contracts();
+    init_worker_output();
+    SUBMISSION_FACE = {
+      judge: {
+        label: "\u5927\u7406\u5BFA\u8F93\u51FA",
+        description: "\u63D0\u4EA4\u5927\u7406\u5BFA\u7EC8\u5C40\u5224\u8BCD\uFF1B\u4EA4\u5377\u8C03\u7528\u7ED3\u675F\u540E\uFF0C\u7531\u516C\u5F00\u8C03\u7528\u63A5\u7F1D\u6309\u5224\u8BCD\u72B6\u6001\u6267\u884C\u9002\u7528\u5BA1\u6838\u3002",
+        promptSnippet: "\u63D0\u4EA4\u5927\u7406\u5BFA\u7EC8\u5C40\u5224\u8BCD",
+        parameters: reviewSubmissionSchema
+      },
+      fixer: {
+        label: "\u4FEE\u5185\u53F8\u8F93\u51FA",
+        description: "\u63D0\u4EA4\u4FEE\u5185\u53F8\u7EC8\u5C40\u56DE\u6267\u3002",
+        promptSnippet: "\u63D0\u4EA4\u4FEE\u5185\u53F8\u7EC8\u5C40\u56DE\u6267",
+        parameters: fixerOutputSchema
+      },
+      coder: {
+        label: "\u5C06\u4F5C\u76D1\u8F93\u51FA",
+        description: "\u63D0\u4EA4\u5C06\u4F5C\u76D1\u7EC8\u5C40\u56DE\u6267\u3002",
+        promptSnippet: "\u63D0\u4EA4\u5C06\u4F5C\u76D1\u7EC8\u5C40\u56DE\u6267",
+        parameters: coderOutputSchema
+      },
+      reviewer: {
+        label: "\u5FA1\u53F2\u53F0\u8F93\u51FA",
+        description: "\u63D0\u4EA4\u5FA1\u53F2\u53F0\u7EC8\u5C40\u56DE\u6267\u3002",
+        promptSnippet: "\u63D0\u4EA4\u5FA1\u53F2\u53F0\u7EC8\u5C40\u56DE\u6267",
+        parameters: reviewerOutputSchema
+      },
+      collector: {
+        label: "\u901A\u8FDB\u53F8\u8F93\u51FA",
+        description: "\u63D0\u4EA4\u901A\u8FDB\u53F8\u56DE\u6267\u3002",
+        promptSnippet: "\u63D0\u4EA4\u901A\u8FDB\u53F8\u56DE\u6267",
+        parameters: collectorOutputArgsSchema
+      },
+      doctor: {
+        label: "\u592A\u533B\u7F72\u8F93\u51FA",
+        description: DOCTOR_OUTPUT_TOOL_DESCRIPTION,
+        parameters: doctorSubmissionSchema
+      },
+      merger: {
+        label: "\u5408\u5E76\u8F93\u51FA",
+        description: "\u63D0\u4EA4\u5408\u5E76\u7ED3\u679C\uFF1B\u8F93\u51FA\u5206\u652F\u4E3A completed \u4E0E escalate\u3002",
+        promptSnippet: "\u63D0\u4EA4\u5408\u5E76\u7ED3\u679C",
+        parameters: mergerOutputSchema
+      },
+      notary: {
+        label: "\u7B26\u5B9D\u90CE\u8F93\u51FA",
+        description: "\u63D0\u4EA4\u5F15\u6587\u4FDD\u771F\u4E0E\u7968\u9762\u5BF9\u9F50\u7684 converged/continue/escalate \u51B3\u8BAE\u3002",
+        promptSnippet: "\u63D0\u4EA4\u7B26\u5B9D\u90CE\u51B3\u8BAE",
+        parameters: reviewSubmissionSchema
+      },
+      countersign: {
+        label: "\u7ED9\u4E8B\u4E2D\u8F93\u51FA",
+        description: "\u7ED9\u4E8B\u4E2D\u51B3\u8BAE\u3002",
+        promptSnippet: "\u7ED9\u4E8B\u4E2D\u51B3\u8BAE",
+        parameters: reviewSubmissionSchema
+      },
+      secretariat: {
+        label: "\u4E2D\u4E66\u7701\u8F93\u51FA",
+        description: "\u4E2D\u4E66\u7701\u7EC8\u5C40\u56DE\u6267\u3002",
+        promptSnippet: "\u4E2D\u4E66\u7701\u7EC8\u5C40\u56DE\u6267",
+        parameters: secretariatVerdictSchema
+      },
+      "gleaner-left": {
+        label: "\u5DE6\u62FE\u9057\u8F93\u51FA",
+        description: "\u5DE6\u62FE\u9057\u5F39\u7AE0\u3002",
+        promptSnippet: "\u5DE6\u62FE\u9057\u5F39\u7AE0",
+        parameters: gleanerLeftOutputSchema
+      },
+      inspector: {
+        label: "\u53F0\u9662\u8F93\u51FA",
+        description: "\u53F0\u9662\u7EC8\u5C40\u56DE\u6267\uFF0C\u72B6\u6001\u4E3A converged\u3001continue \u6216 escalate\u3002",
+        promptSnippet: "\u53F0\u9662\u7EC8\u5C40\u56DE\u6267",
+        parameters: reviewSubmissionSchema
+      },
+      gatekeeper: {
+        label: "\u95E8\u4E0B\u7701\u51B3\u8BAE",
+        description: "\u95E8\u4E0B\u7701\u7EC8\u5C40\u51B3\u8BAE\u3002status \u4E3A dispatch \u6216 pass\u3002",
+        promptSnippet: "\u95E8\u4E0B\u7701\u51B3\u8BAE",
+        parameters: gatekeeperOutputSchema
+      },
+      navigator: {
+        label: "\u6E38\u5955\u4F7F\u5EFA\u8BAE",
+        description: "\u6E38\u5955\u4F7F\u7EC8\u5C40\u56DE\u6267\uFF1A\u6563\u6587\u5EFA\u8BAE\uFF0C\u539F\u6837\u5448\u73B0\u3002",
+        promptSnippet: "\u6E38\u5955\u4F7F\u5EFA\u8BAE",
+        parameters: navigatorOutputSchema
+      },
+      auditor: {
+        label: "\u5BA1\u5211\u9662\u8F93\u51FA",
+        description: "\u5BA1\u5211\u9662\u7EC8\u5C40\u56DE\u6267\uFF0Cstatus \u4E3A converged\u3001continue \u6216 escalate\u3002",
+        promptSnippet: "\u5BA1\u5211\u9662\u7EC8\u5C40\u56DE\u6267",
+        parameters: reviewSubmissionSchema
+      },
+      diarist: {
+        label: "\u8D77\u5C45\u90CE\u8F93\u51FA",
+        description: "\u8D77\u5C45\u90CE\u4EA4\u5355\u7968 sessions \u6216\u591A\u7968\u9010\u7968 ticketSessions \u8FB9\u754C\uFF1B\u8BA4\u4E0D\u51FA\u672C\u5EAD\u5BF9\u8C61\u5219 escalate\u3002",
+        promptSnippet: "\u8D77\u5C45\u90CE\u4EA4\u8FB9\u754C",
+        parameters: diaristOutputSchema
+      }
+    };
+  }
+});
+
 // src/run-terminal-artifacts.ts
 var run_terminal_artifacts_exports = {};
 __export(run_terminal_artifacts_exports, {
@@ -17052,7 +17298,7 @@ function reviewQueueStatus(status) {
 function projectOfficerDecision(officer, decision, fallbackStatus) {
   const receipt = retainedReceipt(decision);
   const record = isRecord(decision) ? decision : void 0;
-  const status = (record !== void 0 && typeof record.status === "string" ? record.status : void 0) ?? fallbackStatus;
+  const status = record !== void 0 && Object.hasOwn(record, "status") ? receivedDiscriminator(record, "status") : fallbackStatus;
   const queueStatus = typeof status === "string" ? reviewQueueStatus(status) : void 0;
   if (queueStatus === "converged") {
     return { status: "converged", officer, receipt };
@@ -17195,7 +17441,7 @@ async function projectGatekeeperRun(options) {
     summoned
   };
 }
-var GATE_OFFICER_BY_SUBJECT;
+var GATE_OFFICER_BY_SUBJECT, GATEKEEPER_TOOL_SPEC;
 var init_gatekeeper_role = __esm({
   "src/gatekeeper-role.ts"() {
     "use strict";
@@ -17205,6 +17451,7 @@ var init_gatekeeper_role = __esm({
     init_inspector_contracts();
     init_review_submission();
     init_gatekeeper_output();
+    init_role_submission_declarations();
     init_run_terminal_artifacts();
     init_unknown_value();
     init_submission_errors();
@@ -17215,6 +17462,7 @@ var init_gatekeeper_role = __esm({
       countersign_verdict: "notary",
       secretariat_verdict: "countersign"
     };
+    GATEKEEPER_TOOL_SPEC = roleSubmissionDeclaration("gatekeeper");
   }
 });
 
@@ -17252,6 +17500,13 @@ function formatTerminalResult(result) {
       `diagnostic	${encodeTerminalField(result.roleOutcome.diagnostic)}`
     );
   }
+  if (result.roleOutcome.kind === "accepted" && result.roleOutcome.decisiveFacts?.directionUnsettled === true) {
+    lines.push("fact	directionUnsettled	true");
+    const subsequent = result.roleOutcome.decisiveFacts.subsequentAudit;
+    if (typeof subsequent === "string") {
+      lines.push(`fact	subsequentAudit	${encodeTerminalField(subsequent)}`);
+    }
+  }
   if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation" || result.roleOutcome.decisiveFacts?.failedAttempts !== void 0) {
     const facts = result.roleOutcome.kind === "accepted" ? { failedAttempts: result.roleOutcome.decisiveFacts?.failedAttempts } : result.roleOutcome.decisiveFacts ?? {};
     for (const [key, value] of Object.entries(facts)) {
@@ -17310,7 +17565,7 @@ function formatTerminalResult(result) {
       lines.push(`recorded-submission	${encodeTerminalField(rendered)}`);
     }
   } else {
-    const payloads = result.roleOutcome.kind === "accepted" || result.roleOutcome.kind === "audit_escalation" ? coalesceSubmissionRows(result.roleOutcome.payloads, result.submissions) : result.submissions ?? [];
+    const payloads = result.roleOutcome.kind === "accepted" || result.roleOutcome.kind === "audit_escalation" ? coalesceSubmissionRows(result.submissions, result.roleOutcome.payloads) : result.submissions ?? [];
     for (let i = payloads.length - 1; i >= 0; i -= 1) {
       const payload = payloads[i];
       const rendered = typeof payload === "string" ? payload : JSON.stringify(payload);
@@ -17326,6 +17581,223 @@ var init_terminal = __esm({
   }
 });
 
+// src/receipt-delivery-policy.ts
+function receiptAttemptPointer(runPointer, invocationScopeId) {
+  const scope = invocationScopeId?.trim() ?? "";
+  if (scope.length > 0) return `invocation:${scope}`;
+  return `current:${runPointer}`;
+}
+function deliveryLimitFromConfig(value) {
+  return parseAutoResumeLimit(value ?? AUTO_RESUME_LIMIT);
+}
+function deliveryTurnsFact(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new TypeError("deliveryTurns must be a non-negative integer");
+  }
+  return value;
+}
+function parseNoReceiptLifecycleFacts(input) {
+  if (!isRecord(input) || typeof input.terminalToolCalled !== "boolean" || input.sessionCompletion !== "settled-without-accepted-receipt" || input.acceptedReceipt !== false || typeof input.runPointer !== "string" || input.runPointer.trim() === "" || typeof input.attemptPointer !== "string" || input.attemptPointer.trim() === "" || !Array.isArray(input.rejectedReceipts) || !input.rejectedReceipts.every((item) => isRecord(item) && typeof item.reason === "string")) {
+    throw new TypeError("malformed no-receipt lifecycle facts");
+  }
+  return {
+    terminalToolCalled: input.terminalToolCalled,
+    rejectedReceipts: input.rejectedReceipts.map((item) => ({
+      reason: item.reason,
+      diagnosticAvailable: item.reason.trim() !== ""
+    })),
+    deliveryTurns: deliveryTurnsFact(input.deliveryTurns),
+    sessionCompletion: "settled-without-accepted-receipt",
+    runPointer: input.runPointer,
+    attemptPointer: input.attemptPointer,
+    acceptedReceipt: false
+  };
+}
+function noReceiptLifecycleFacts(input) {
+  return {
+    terminalToolCalled: input.terminalToolCalled,
+    rejectedReceipts: input.rejectedReceipts.map(({ reason }) => ({
+      reason,
+      diagnosticAvailable: reason.trim() !== ""
+    })),
+    deliveryTurns: deliveryTurnsFact(input.deliveryTurns),
+    sessionCompletion: "settled-without-accepted-receipt",
+    runPointer: input.runPointer,
+    attemptPointer: input.attemptPointer,
+    acceptedReceipt: false
+  };
+}
+function createReceiptDeliveryPolicy(limit) {
+  const deliveryLimit = deliveryLimitFromConfig(limit);
+  let accepted = false;
+  let closed = false;
+  let terminalToolCalled = false;
+  let deliveryTurns = 0;
+  let budgetSpent = 0;
+  const rejectedReceipts = [];
+  const spend = () => {
+    if (budgetSpent < deliveryLimit) budgetSpent += 1;
+  };
+  return {
+    /** The effective ceiling this budget spends (#1132 — never re-read). */
+    limit: deliveryLimit,
+    recordAccepted() {
+      accepted = true;
+      terminalToolCalled = true;
+    },
+    /** Infrastructure owns terminality and must never trigger receipt催交. */
+    stopForInfrastructure() {
+      accepted = true;
+    },
+    /**
+     * Record the rejection this turn already produced.
+     * The fact does not spend a budget. The seam that sends the next prompt
+     * owns that count.
+     */
+    recordRejected(reason) {
+      terminalToolCalled = true;
+      rejectedReceipts.push({ reason, diagnosticAvailable: reason.trim() !== "" });
+    },
+    recordDeliveryRequest() {
+      deliveryTurns += 1;
+      spend();
+    },
+    /**
+     * Stop asking. The issued count stays whatever was actually sent (#1132 —
+     * do not fill the remainder up to the ceiling).
+     */
+    closeBudget() {
+      closed = true;
+    },
+    /**
+     * A nested session settled without an accepted receipt. Close so this layer
+     * does not open another prompt on that session. The issued count stays the
+     * larger of the two seams: a nested zero must not wipe prompts this layer
+     * already sent, and adding the two counts would bill one send twice.
+     */
+    recordNestedNoReceipt(facts) {
+      terminalToolCalled = terminalToolCalled || facts.terminalToolCalled;
+      rejectedReceipts.push(...facts.rejectedReceipts);
+      deliveryTurns = Math.max(deliveryTurns, facts.deliveryTurns);
+      closed = true;
+    },
+    nextAction() {
+      if (accepted) return "accepted";
+      if (closed) return "no-receipt";
+      return budgetSpent < deliveryLimit ? "request-delivery" : "no-receipt";
+    },
+    /** Delivery requests actually issued so far (#1132). */
+    issuedDeliveryRequests() {
+      return deliveryTurns;
+    },
+    /** Current typed delivery facts. No prose. */
+    deliveryState() {
+      return {
+        terminalToolCalled,
+        rejectedReceipts: rejectedReceipts.map((item) => ({ ...item })),
+        deliveryTurns,
+        acceptedReceipt: false
+      };
+    },
+    facts(binding) {
+      return noReceiptLifecycleFacts({ terminalToolCalled, rejectedReceipts: [...rejectedReceipts], deliveryTurns, ...binding });
+    },
+    /**
+     * Continue a public call after the in-memory policy was rebuilt.
+     * Sends already issued spend the same budget; copied rejections keep
+     * the fact and do not spend again.
+     */
+    continueIssued(prior) {
+      for (const receipt of prior.rejectedReceipts) {
+        this.recordRejected(receipt.reason);
+      }
+      if (prior.terminalToolCalled === true) terminalToolCalled = true;
+      for (let index = 0; index < prior.deliveryTurns; index += 1) {
+        this.recordDeliveryRequest();
+      }
+    }
+  };
+}
+function entryRecord(entry) {
+  return isRecord(entry) ? entry : void 0;
+}
+function customTypeOf(record, message) {
+  return record.customType ?? message?.customType;
+}
+function dataOf(record, message) {
+  return record.data ?? message?.details;
+}
+function scopeTag(record) {
+  const message = isRecord(record.message) ? record.message : void 0;
+  const customType = customTypeOf(record, message);
+  const data = dataOf(record, message);
+  if ((customType === RECEIPT_DELIVERY_REQUEST_ENTRY || customType === RECEIPT_REJECTION_ENTRY) && isRecord(data) && typeof data.invocationScopeId === "string" && data.invocationScopeId.trim() !== "") {
+    return data.invocationScopeId;
+  }
+  if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) return void 0;
+  try {
+    const facts = parseNoReceiptLifecycleFacts(data);
+    const prefix = "invocation:";
+    if (!facts.attemptPointer.startsWith(prefix)) return void 0;
+    const scope = facts.attemptPointer.slice(prefix.length);
+    return scope.trim() === "" ? void 0 : scope;
+  } catch {
+    return void 0;
+  }
+}
+function priorReceiptContinuation(entries, invocationScopeId) {
+  const pointer = receiptAttemptPointer("", invocationScopeId);
+  let entryTurns = 0;
+  let factTurns = 0;
+  let rejectedReceipts = [];
+  let snapshotTerminal = false;
+  for (const entry of entries) {
+    const record = entryRecord(entry);
+    if (record === void 0) continue;
+    const tagged = scopeTag(record);
+    if (tagged !== void 0) {
+      const message = isRecord(record.message) ? record.message : void 0;
+      const customType = customTypeOf(record, message);
+      if (tagged !== invocationScopeId) continue;
+      if (customType === RECEIPT_DELIVERY_REQUEST_ENTRY) entryTurns += 1;
+      if (customType === RECEIPT_REJECTION_ENTRY) {
+        const data = dataOf(record, message);
+        if (isRecord(data) && typeof data.reason === "string") rejectedReceipts.push({ reason: data.reason });
+      }
+      if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) continue;
+      try {
+        const facts = parseNoReceiptLifecycleFacts(dataOf(record, message));
+        if (facts.attemptPointer !== pointer) continue;
+        factTurns = Math.max(factTurns, facts.deliveryTurns);
+        if (facts.rejectedReceipts.length >= rejectedReceipts.length) {
+          rejectedReceipts = facts.rejectedReceipts.map(({ reason }) => ({ reason }));
+        }
+        snapshotTerminal ||= facts.terminalToolCalled;
+      } catch {
+      }
+      continue;
+    }
+  }
+  return {
+    deliveryTurns: Math.max(entryTurns, factTurns),
+    rejectedReceipts,
+    terminalToolCalled: snapshotTerminal || rejectedReceipts.length > 0
+  };
+}
+var NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_REQUEST_ENTRY, RECEIPT_REJECTION_ENTRY, RECEIPT_DELIVERY_LIMIT_ENV;
+var init_receipt_delivery_policy = __esm({
+  "src/receipt-delivery-policy.ts"() {
+    "use strict";
+    init_run_lifecycle();
+    init_config2();
+    init_unknown_value();
+    NO_RECEIPT_LIFECYCLE_ENTRY_TYPE = "ak-no-receipt-lifecycle";
+    RECEIPT_DELIVERY_REQUEST_ENTRY = "ak-receipt-delivery-request";
+    RECEIPT_REJECTION_ENTRY = "ak-receipt-rejection";
+    RECEIPT_DELIVERY_LIMIT_ENV = "AK_ROLE_RECEIPT_DELIVERY_LIMIT";
+  }
+});
+
 // src/session-assistant-usage.ts
 var session_assistant_usage_exports = {};
 __export(session_assistant_usage_exports, {
@@ -17335,10 +17807,10 @@ __export(session_assistant_usage_exports, {
 });
 import { join as join14 } from "node:path";
 async function readAssistantUsageFromSessionFile(sessionFile) {
-  const { readFile: readFile22 } = await import("node:fs/promises");
+  const { readFile: readFile23 } = await import("node:fs/promises");
   let text;
   try {
-    text = await readFile22(sessionFile, "utf8");
+    text = await readFile23(sessionFile, "utf8");
   } catch (error) {
     if (error?.code === "ENOENT") return void 0;
     throw error;
@@ -17959,6 +18431,8 @@ function createPiRoleTurnHost(config) {
       else env.AK_ROLE_INVOCATION_SCOPE = request.invocationScopeId;
       if (request.host === void 0 || request.host.trim() === "") delete env.AK_ROLE_HOST;
       else env.AK_ROLE_HOST = request.host.trim();
+      if (request.deliveryRequestLimit === void 0) delete env[RECEIPT_DELIVERY_LIMIT_ENV];
+      else env[RECEIPT_DELIVERY_LIMIT_ENV] = String(request.deliveryRequestLimit);
       applyEngineChildEnv(env, request.engine);
       if (typeof process.env.AK_ROLE_AUDITOR_SOURCE_RUN === "string" && process.env.AK_ROLE_AUDITOR_SOURCE_RUN.trim() !== "") {
         env.AK_ROLE_AUDITOR_SOURCE_RUN = process.env.AK_ROLE_AUDITOR_SOURCE_RUN;
@@ -18018,6 +18492,7 @@ var init_role_turn_host = __esm({
     init_engine_detour();
     init_role_activation_flags();
     init_user_dialogue_stdin();
+    init_receipt_delivery_policy();
     init_sitian_facade();
     INTERNAL_ROLE_ENTRYPOINT_RELATIVE2 = "extensions/role-runtime.ts";
     EXPLICIT_INTERNAL_LOAD_PROBE_ARGS = [
@@ -21838,10 +22313,10 @@ function pairGateRounds(volumes) {
   return rounds.sort((a, b) => a.officerStartedAt.localeCompare(b.officerStartedAt)).map((round, index) => ({ ...round, roundIndex: index + 1 }));
 }
 async function resolveOfficerSessionFromPointerFile(pointerPath) {
-  const { readFile: readFile22 } = await import("node:fs/promises");
+  const { readFile: readFile23 } = await import("node:fs/promises");
   let raw;
   try {
-    raw = JSON.parse(await readFile22(pointerPath, "utf8"));
+    raw = JSON.parse(await readFile23(pointerPath, "utf8"));
   } catch (error) {
     throw new Error(
       `direct officer run pointer unreadable in ${pointerPath}: ${errorText(error)}`,
@@ -22449,9 +22924,7 @@ function runDirectoryFromSessionDirectory(sessionDirectory) {
 function sessionFileFromSessionDirectory(sessionDirectory) {
   return join26(sessionDirectory, "session.jsonl");
 }
-function mintEngineDetourInvocationScope(input) {
-  const engine = input.effectiveEngine?.trim();
-  if (engine === void 0 || engine.length === 0) return void 0;
+function mintEngineDetourInvocationScope(_input) {
   return randomUUID3();
 }
 function withEngineDetourInvocationScope(request, invocationScopeId) {
@@ -22654,51 +23127,6 @@ var init_navigator_invocation_identity = __esm({
   }
 });
 
-// src/receipt-delivery-policy.ts
-function parseNoReceiptLifecycleFacts(input) {
-  if (!isRecord(input) || typeof input.terminalToolCalled !== "boolean" || input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT || input.sessionCompletion !== "settled-without-accepted-receipt" || input.acceptedReceipt !== false || typeof input.runPointer !== "string" || input.runPointer.trim() === "" || typeof input.attemptPointer !== "string" || input.attemptPointer.trim() === "" || !Array.isArray(input.rejectedReceipts) || !input.rejectedReceipts.every((item) => isRecord(item) && typeof item.reason === "string")) {
-    throw new TypeError("malformed no-receipt lifecycle facts");
-  }
-  return {
-    terminalToolCalled: input.terminalToolCalled,
-    rejectedReceipts: input.rejectedReceipts.map((item) => ({
-      reason: item.reason,
-      diagnosticAvailable: item.reason.trim() !== ""
-    })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
-    sessionCompletion: "settled-without-accepted-receipt",
-    runPointer: input.runPointer,
-    attemptPointer: input.attemptPointer,
-    acceptedReceipt: false
-  };
-}
-function noReceiptLifecycleFacts(input) {
-  if (input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT) {
-    throw new TypeError("no-receipt lifecycle requires an exhausted delivery budget");
-  }
-  return {
-    terminalToolCalled: input.terminalToolCalled,
-    rejectedReceipts: input.rejectedReceipts.map(({ reason }) => ({
-      reason,
-      diagnosticAvailable: reason.trim() !== ""
-    })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
-    sessionCompletion: "settled-without-accepted-receipt",
-    runPointer: input.runPointer,
-    attemptPointer: input.attemptPointer,
-    acceptedReceipt: false
-  };
-}
-var RECEIPT_DELIVERY_TURN_LIMIT, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE;
-var init_receipt_delivery_policy = __esm({
-  "src/receipt-delivery-policy.ts"() {
-    "use strict";
-    init_unknown_value();
-    RECEIPT_DELIVERY_TURN_LIMIT = 2;
-    NO_RECEIPT_LIFECYCLE_ENTRY_TYPE = "ak-no-receipt-lifecycle";
-  }
-});
-
 // src/public-cli/settlement.ts
 var settlement_exports = {};
 __export(settlement_exports, {
@@ -22841,13 +23269,76 @@ async function attachRecordedSubmissions(admitted, terminal, scope) {
   if (errorPath !== void 0) privateFailureErrorPaths.set(result, errorPath);
   return result;
 }
-async function settleHostEndedNoReceipt(admitted, authority, scope) {
+function lifecycleFactsFromEntry(entry) {
+  const customType = entry.customType ?? entry.message?.customType;
+  if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) return void 0;
+  return entry.data ?? entry.message?.details;
+}
+async function readCurrentAttemptNoReceiptFacts(admitted, authority, scope) {
+  const { sessionFile } = coordinatesFromAdmitted(authority, admitted);
+  const entries = await readBoundSessionEntries(sessionFile).catch(() => void 0);
+  if (entries === void 0) return void 0;
+  const scopeId = scope?.invocationScopeId?.trim() ?? "";
+  if (scopeId.length > 0) {
+    const pointer = receiptAttemptPointer(admitted.runDirectory, scopeId);
+    let selected;
+    for (const entry of entries) {
+      const raw2 = lifecycleFactsFromEntry(entry);
+      if (raw2 === void 0) continue;
+      try {
+        const facts2 = parseNoReceiptLifecycleFacts(raw2);
+        if (facts2.runPointer !== admitted.runDirectory) continue;
+        if (facts2.attemptPointer !== pointer) continue;
+        if (selected === void 0 || facts2.deliveryTurns >= selected.deliveryTurns) {
+          selected = facts2;
+        }
+      } catch {
+      }
+    }
+    return selected;
+  }
+  let attemptStart = 0;
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    if (entries[index]?.type === "message" && entries[index]?.message?.role === "user") {
+      attemptStart = index;
+      break;
+    }
+  }
+  const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry) => lifecycleFactsFromEntry(entry) !== void 0);
+  const raw = lifecycleEntry === void 0 ? void 0 : lifecycleFactsFromEntry(lifecycleEntry);
+  if (raw === void 0) return void 0;
+  let facts;
+  try {
+    facts = parseNoReceiptLifecycleFacts(raw);
+  } catch {
+    return void 0;
+  }
+  if (facts.runPointer !== admitted.runDirectory) return void 0;
+  if (facts.attemptPointer !== receiptAttemptPointer(admitted.runDirectory)) return void 0;
+  return facts;
+}
+async function settleHostEndedNoReceipt(admitted, authority, scope, issuedDeliveryRequests = 0) {
+  const scopeId = scope?.invocationScopeId?.trim() ?? "";
+  const persisted = scopeId.length > 0 ? void 0 : await readCurrentAttemptNoReceiptFacts(admitted, authority, scope);
+  let terminalToolCalled = persisted?.terminalToolCalled ?? false;
+  let rejectedReceipts = persisted?.rejectedReceipts ?? [];
+  let recordedTurns = persisted?.deliveryTurns ?? 0;
+  if (scopeId.length > 0) {
+    const { sessionFile } = coordinatesFromAdmitted(authority, admitted);
+    const entries = await readBoundSessionEntries(sessionFile).catch(() => void 0);
+    if (entries !== void 0) {
+      const prior = priorReceiptContinuation(entries, scopeId);
+      terminalToolCalled = prior.terminalToolCalled;
+      rejectedReceipts = prior.rejectedReceipts;
+      recordedTurns = prior.deliveryTurns;
+    }
+  }
   const facts = noReceiptLifecycleFacts({
-    terminalToolCalled: false,
-    rejectedReceipts: [],
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
+    terminalToolCalled,
+    rejectedReceipts,
+    deliveryTurns: Math.max(issuedDeliveryRequests, recordedTurns),
     runPointer: admitted.runDirectory,
-    attemptPointer: `current:${admitted.runDirectory}`
+    attemptPointer: receiptAttemptPointer(admitted.runDirectory, scope?.invocationScopeId)
   });
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   await clearOppositeTerminalArtifactFace(admitted.runDirectory);
@@ -24420,44 +24911,26 @@ async function settleFailureTerminalResult(admitted, failure, authority, options
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
   if (failure.cause === "output") {
-    const entries = await readBoundSessionEntries(sessionFile).catch(() => void 0);
-    if (entries !== void 0) {
-      let attemptStart = 0;
-      for (let index = entries.length - 1; index >= 0; index -= 1) {
-        if (entries[index]?.type === "message" && entries[index]?.message?.role === "user") {
-          attemptStart = index;
-          break;
-        }
-      }
-      const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry) => entry.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE || entry.message?.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE);
-      const raw = lifecycleEntry?.data ?? lifecycleEntry?.message?.details;
-      if (raw !== void 0) {
-        let facts;
-        try {
-          facts = parseNoReceiptLifecycleFacts(raw);
-        } catch {
-        }
-        if (facts !== void 0 && facts.runPointer === admitted.runDirectory && facts.attemptPointer === `current:${admitted.runDirectory}`) {
-          let decisiveFacts2 = facts;
-          await clearOppositeTerminalArtifactFace(admitted.runDirectory);
-          return withOptionalGateProjection(
-            {
-              roleOutcome: {
-                kind: "no_receipt",
-                role: admitted.role,
-                status: "no-accepted-receipt",
-                ...facts,
-                decisiveFacts: decisiveFacts2
-              },
-              navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
-              artifacts: [],
-              runId: admitted.runId
-            },
-            sessionDirectory,
-            detourGateContext(admitted, options)
-          );
-        }
-      }
+    const facts = await readCurrentAttemptNoReceiptFacts(admitted, authority, options);
+    if (facts !== void 0) {
+      const decisiveFacts2 = facts;
+      await clearOppositeTerminalArtifactFace(admitted.runDirectory);
+      return withOptionalGateProjection(
+        {
+          roleOutcome: {
+            kind: "no_receipt",
+            role: admitted.role,
+            status: "no-accepted-receipt",
+            ...facts,
+            decisiveFacts: decisiveFacts2
+          },
+          navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
+          artifacts: [],
+          runId: admitted.runId
+        },
+        sessionDirectory,
+        detourGateContext(admitted, options)
+      );
     }
   }
   const navigator = await extractNavigatorFactFromAdmittedSession(sessionFile);
@@ -24627,16 +25100,19 @@ var init_settlement = __esm({
 
 // src/archivist-record-pointer.ts
 import { mkdirSync as mkdirSync3, writeFileSync } from "node:fs";
+import { readFile as readFile16 } from "node:fs/promises";
 import { dirname as dirname16, join as join28 } from "node:path";
 function bookDirectOfficerRunPointer(options) {
   const nest = join28(dirname16(options.parentSessionFile), "auditor-roles");
   mkdirSync3(nest, { recursive: true });
+  const submissionToolCallId = options.submissionToolCallId?.trim() ?? "";
   const pointer = {
     version: 1,
     kind: DIRECT_OFFICER_RUN_POINTER_KIND,
     officer: options.officer,
     sessionFile: options.sessionFile,
-    ...options.runDirectory !== void 0 && options.runDirectory.trim() !== "" ? { runDirectory: options.runDirectory } : {}
+    ...options.runDirectory !== void 0 && options.runDirectory.trim() !== "" ? { runDirectory: options.runDirectory } : {},
+    ...submissionToolCallId === "" ? {} : { submissionToolCallId }
   };
   writeFileSync(
     join28(nest, `${options.officer}.pointer.json`),
@@ -24646,10 +25122,36 @@ function bookDirectOfficerRunPointer(options) {
   );
   return pointer;
 }
+async function readDirectOfficerRunPointer(parentSessionFile, officer) {
+  try {
+    const raw = JSON.parse(await readFile16(
+      join28(dirname16(parentSessionFile), "auditor-roles", `${officer}.pointer.json`),
+      "utf8"
+    ));
+    if (!isRecord(raw) || raw.kind !== DIRECT_OFFICER_RUN_POINTER_KIND || raw.version !== 1) {
+      return void 0;
+    }
+    if (raw.officer !== officer) return void 0;
+    if (typeof raw.sessionFile !== "string" || raw.sessionFile.trim() === "") return void 0;
+    const runDirectory = typeof raw.runDirectory === "string" && raw.runDirectory.trim() !== "" ? raw.runDirectory : void 0;
+    const submissionToolCallId = typeof raw.submissionToolCallId === "string" && raw.submissionToolCallId.trim() !== "" ? raw.submissionToolCallId : void 0;
+    return {
+      version: 1,
+      kind: DIRECT_OFFICER_RUN_POINTER_KIND,
+      officer,
+      sessionFile: raw.sessionFile,
+      ...runDirectory === void 0 ? {} : { runDirectory },
+      ...submissionToolCallId === void 0 ? {} : { submissionToolCallId }
+    };
+  } catch {
+    return void 0;
+  }
+}
 var DIRECT_OFFICER_RUN_POINTER_KIND;
 var init_archivist_record_pointer = __esm({
   "src/archivist-record-pointer.ts"() {
     "use strict";
+    init_unknown_value();
     DIRECT_OFFICER_RUN_POINTER_KIND = "direct-officer-run-pointer";
   }
 });
@@ -24667,6 +25169,7 @@ function createPiDoctorAuditor() {
       submission: options.submission,
       ...auditorRunDirectory(options.context) === void 0 ? {} : { runDirectory: auditorRunDirectory(options.context) },
       ...options.signal === void 0 ? {} : { signal: options.signal },
+      ...options.autoResumeLimit === void 0 ? {} : { autoResumeLimit: options.autoResumeLimit },
       ...options.summonAuditor === void 0 ? {} : { summonAuditor: options.summonAuditor }
     });
   };
@@ -24681,16 +25184,37 @@ var init_doctor_auditor = __esm({
   }
 });
 
+// src/filed-submission.ts
+var init_filed_submission = __esm({
+  "src/filed-submission.ts"() {
+    "use strict";
+  }
+});
+
 // src/judge-role.ts
 async function runJudgeGates(input) {
   const passes = [];
   for (const subject of JUDGE_GATES) {
     if (await input.gateAlreadyConverged(subject)) continue;
     const pass = await input.runGate(subject);
-    const status = pass?.status;
-    if (pass === void 0 || status !== "converged" && status !== "continue" && status !== "escalate") {
+    const received = pass?.status;
+    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,
@@ -24708,6 +25232,8 @@ var init_judge_role = __esm({
     "use strict";
     init_host_contracts();
     init_review_submission();
+    init_filed_submission();
+    init_role_submission_declarations();
     init_gatekeeper_role();
     init_judge_output();
     JUDGE_GATES = [
@@ -24736,11 +25262,10 @@ function latestQueueStatus(terminal) {
   if (outcome.kind === "audit_escalation") return "escalate";
   if (outcome.kind !== "accepted") return void 0;
   const latest = outcome.payloads?.[outcome.payloads.length - 1];
-  if (isRecord(latest)) {
-    const status = latest.status;
-    if (typeof status === "string" && status.trim() !== "") return status;
+  if (isRecord(latest) && Object.hasOwn(latest, "status")) {
+    return receivedDiscriminator(latest, "status");
   }
-  return typeof outcome.status === "string" && outcome.status.trim() !== "" ? outcome.status : void 0;
+  return outcome.status;
 }
 function latestQueuePayload(terminal) {
   const outcome = terminal?.roleOutcome;
@@ -24768,7 +25293,7 @@ function createDefaultGateOfficerSummon(options) {
     });
   };
 }
-function bookDirectOfficerPointer(context, officer, result, summoned) {
+function bookDirectOfficerPointer(context, officer, result, summoned, toolCallId) {
   if (result.status !== "converged" && result.status !== "continue" && result.status !== "escalate" && result.status !== "needs_reask" && result.status !== "transport_failure") {
     return;
   }
@@ -24782,11 +25307,14 @@ function bookDirectOfficerPointer(context, officer, result, summoned) {
     parentSessionFile: parentFile,
     officer,
     sessionFile,
-    ...typeof summoned.runDirectory === "string" && summoned.runDirectory.trim() !== "" ? { runDirectory: summoned.runDirectory } : {}
+    ...typeof summoned.runDirectory === "string" && summoned.runDirectory.trim() !== "" ? { runDirectory: summoned.runDirectory } : {},
+    ...toolCallId.trim() === "" ? {} : { submissionToolCallId: toolCallId }
   });
 }
 async function requireSubmissionGate(options) {
   let reask;
+  let reasksSpent = 0;
+  const reaskLimit = deliveryLimitFromConfig(options.autoResumeLimit);
   const summonOfficer = options.summonOfficer ?? createDefaultGateOfficerSummon({
     cwd: options.context.cwd ?? process.cwd()
   });
@@ -24806,7 +25334,8 @@ async function requireSubmissionGate(options) {
           options.context,
           projected.officer,
           gatekeeper,
-          projected.summoned
+          projected.summoned,
+          options.toolCallId
         );
       } catch (error) {
         options.hostActions.failInfrastructure(error, options.context, options.toolCallId);
@@ -24829,6 +25358,17 @@ async function requireSubmissionGate(options) {
       };
     }
     if (gatekeeper.status === "needs_reask") {
+      if (reasksSpent >= reaskLimit) {
+        return {
+          status: "needs_reask",
+          officer: projected.officer,
+          receipt: gatekeeper.receipt,
+          ...typeof gatekeeper.runId === "string" && gatekeeper.runId.trim() !== "" ? { runId: gatekeeper.runId } : {},
+          ...typeof projected.summoned?.runDirectory === "string" && projected.summoned.runDirectory.trim() !== "" ? { runDirectory: projected.summoned.runDirectory } : {},
+          ...projected.summoned?.terminal === void 0 ? {} : { terminal: projected.summoned.terminal }
+        };
+      }
+      reasksSpent += 1;
       reask = officerConclusionReask(gatekeeper.receivedStatus);
       continue;
     }
@@ -24857,6 +25397,8 @@ var init_submission_gate = __esm({
     "use strict";
     init_archivist_record_pointer();
     init_gatekeeper_role();
+    init_submission_errors();
+    init_receipt_delivery_policy();
     init_session_assistant_usage();
     init_unknown_value();
   }
@@ -24914,7 +25456,8 @@ function projectRoleTurnRequest(admitted, roleDetails, options) {
     ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
     ...options.courtAttemptId === void 0 || options.courtAttemptId.length === 0 ? {} : { courtAttemptId: options.courtAttemptId },
     ...options.invocationScopeId === void 0 || options.invocationScopeId.length === 0 ? {} : { invocationScopeId: options.invocationScopeId },
-    ...options.stationChild === void 0 ? {} : { stationChild: options.stationChild }
+    ...options.stationChild === void 0 ? {} : { stationChild: options.stationChild },
+    ...options.deliveryRequestLimit === void 0 ? {} : { deliveryRequestLimit: options.deliveryRequestLimit }
   };
 }
 function packagedSettleSkill(admitted) {
@@ -25105,15 +25648,70 @@ function unreadablePostSubmissionStatus(admitted, terminal) {
   const route = POST_SUBMISSION_ROUTING[admitted.role];
   if (route === void 0) return void 0;
   const payload = terminal.roleOutcome.payloads?.at(-1);
-  const status = isRecord(payload) ? payload.status : void 0;
-  return typeof status === "string" && route.statuses.has(status) ? void 0 : route.reask;
+  const status = receivedDiscriminator(payload, "status");
+  return typeof status === "string" && route.statuses.has(status) ? void 0 : route.reask ?? officerConclusionReask(status);
+}
+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) {
-  const message = unreadablePostSubmissionStatus(admitted, 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
   );
 }
@@ -25267,6 +25865,11 @@ async function dispatchAdmitted(admitted, env, io) {
     env,
     io
   );
+  if (isUnreadableReaskExhausted(unreadableReask)) {
+    const terminal = result.terminal === void 0 ? void 0 : withUnsettledDirection(result.terminal);
+    presentOriginalVolume(held, terminal, io);
+    return terminal === void 0 ? result : { ...result, terminal };
+  }
   if (unreadableReask !== void 0) return unreadableReask;
   if (AUDITED_ROLES.has(admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
     return auditSubmittedRole(result, env, io);
@@ -25398,20 +26001,16 @@ async function runCountersignBody(parsed, env, io) {
         await persistAdmittedSourceRunPath(admitted, gateParentRunPath);
         admitted = { ...admitted, sourceRunPath: gateParentRunPath };
       }
-      const turnProjection = {
-        ...projectPublicTurnAxes(env),
-        ...env.correlationId === void 0 || env.correlationId.trim() === "" ? {} : { correlationId: env.correlationId },
-        continuation: {
-          kind: "initial",
-          prompt: env.reviewReask ?? env.gateReviewInstruction ?? buildInstructionTransportPrompt(
-            admitted,
-            engineSessionMaterialFromOptions({
-              ...pickEngineAxis(env),
-              packageRoot: env.packageRoot
-            })
-          )
-        }
-      };
+      const turnProjection = roleTurnOptions(env, admitted, {
+        kind: "initial",
+        prompt: env.reviewReask ?? env.gateReviewInstruction ?? buildInstructionTransportPrompt(
+          admitted,
+          engineSessionMaterialFromOptions({
+            ...pickEngineAxis(env),
+            packageRoot: env.packageRoot
+          })
+        )
+      });
       const turnRequest = buildInstructionSeatTurnRequest(admitted, turnProjection);
       const result = await runPostAdmissionOneShot({
         admitted,
@@ -25680,7 +26279,23 @@ async function runPublicInstructionSeatResume(request, env, io) {
       },
       afterAdmittedLoad: async (admitted) => {
         await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
-        return { kind: "continue", adapters: seatAdapters(admitted, env) };
+        const adapters = seatAdapters(admitted, env);
+        if ((env.unreadableReasksSpent ?? 0) === 0 && env.reviewReask === void 0) {
+          return { kind: "continue", adapters };
+        }
+        const original = await adapters.trySettle(
+          admitted,
+          env.principalAuthority,
+          await readCurrentCourt(admitted.runDirectory)
+        );
+        const unsettled = POST_SUBMISSION_ROUTING[admitted.role] === void 0 ? heldUnreadableTerminal(original) : unreadablePostSubmissionStatus(admitted, original) !== void 0;
+        return {
+          kind: "continue",
+          adapters: original === void 0 || !unsettled ? adapters : {
+            ...adapters,
+            trySettle: async (seat, authority, scope) => await adapters.trySettle(seat, authority, scope) ?? original
+          }
+        };
       },
       ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
     });
@@ -25690,6 +26305,11 @@ async function runPublicInstructionSeatResume(request, env, io) {
       env,
       io
     );
+    if (isUnreadableReaskExhausted(unreadableReask)) {
+      const terminal = result.terminal === void 0 ? void 0 : withUnsettledDirection(result.terminal);
+      presentOriginalVolume(held, terminal, io);
+      return terminal === void 0 ? result : { ...result, terminal };
+    }
     if (unreadableReask !== void 0) return unreadableReask;
     if (result.admitted !== void 0 && AUDITED_ROLES.has(result.admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
       return auditSubmittedRole(result, env, io);
@@ -25715,26 +26335,46 @@ 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 && status !== void 0 && QUEUE_CONCLUSIONS.has(status)) {
+    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);
-    if (reaskedStatus !== void 0 && QUEUE_CONCLUSIONS.has(reaskedStatus)) {
+    if (typeof reaskedStatus === "string" && REVIEW_QUEUE_STATUSES.has(reaskedStatus)) {
       return { admitted: reasked.admitted, terminal: reasked.terminal, status: reaskedStatus };
     }
     if (latestPayloadEscalated(reasked.terminal.roleOutcome)) return { stop: reasked };
@@ -25748,7 +26388,17 @@ async function continueParentAfterChild(parentRunId, child, env, io) {
   }
   const admitted = loaded.admitted;
   const resolved = await queueConclusionFromChild(child, env, io);
-  if (resolved !== void 0 && "stop" in resolved) return resolved.stop;
+  if (resolved !== void 0 && "stop" in resolved) {
+    const stopped = resolved.stop;
+    if (stopped.exitCode === 0 && heldUnreadableTerminal(stopped.terminal) && stopped.terminal !== void 0) {
+      const parentTerminal = await trySettlePublicSeat(admitted, env.principalAuthority, void 0);
+      if (parentTerminal?.roleOutcome.kind === "accepted" || parentTerminal?.roleOutcome.kind === "audit_escalation") {
+        const terminal = presentUnsettledAudit(parentTerminal, stopped.terminal, io);
+        return { exitCode: 0, admitted, terminal };
+      }
+    }
+    return stopped;
+  }
   if (resolved !== void 0 && resolved.status === "escalate") {
     return { exitCode: 0, admitted: resolved.admitted, terminal: resolved.terminal };
   }
@@ -25756,37 +26406,67 @@ async function continueParentAfterChild(parentRunId, child, env, io) {
     if (AUDITED_ROLES.has(admitted.role) && resolved.status === "converged") {
       const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, void 0);
       if (terminal?.roleOutcome.kind !== "accepted") throw new Error("pending submission is not recorded");
-      return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, resolved.admitted.role, latestQueuePayload(resolved.terminal), resolved.admitted.runId);
+      return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, resolved.admitted, latestQueuePayload(resolved.terminal));
     }
     return runPublicInstructionSeatResume({
       runId: parentRunId,
       message: readableGateItem(latestQueuePayload(resolved.terminal))
-    }, { ...env, autoResumeLimit: 0 }, io);
+    }, { ...env, unreadableReasksSpent: 0 }, io);
   }
   const result = await dispatchAdmitted(admitted, env, { ...io, omitFailureStderrDiagnostic: true });
   showResumeErrorPointer(io, result.exitCode, result.terminal);
   return result;
 }
-async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, passedRunId) {
+async function officerPassedCurrentSubmission(input) {
+  const { env, officer } = input;
+  const pointer = await readDirectOfficerRunPointer(input.parentSessionFile, officer);
+  if (pointer?.runDirectory === void 0) return false;
+  if (pointer.submissionToolCallId !== input.toolCallId) return false;
+  const officerRunId = runIdFromRunDirectory(pointer.runDirectory);
+  if (officerRunId === void 0) return false;
+  let admitted;
+  try {
+    const loaded = await loadResumablePublicRole(
+      env.home,
+      officerRunId,
+      env.principalAuthority
+    );
+    admitted = loaded.admitted;
+  } catch {
+    return false;
+  }
+  if (admitted.role !== officer) return false;
+  const court = await readCurrentCourt(admitted.runDirectory);
+  const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, court);
+  return latestQueueStatus(terminal) === "converged";
+}
+async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt) {
   const admitted = turn.admitted;
   if (admitted === void 0 || !AUDITED_ROLES.has(admitted.role) || turn.terminal?.roleOutcome.kind !== "accepted") return turn;
   const accepted = turn.terminal.roleOutcome.payloads?.at(-1);
   if (accepted === void 0) throw new Error("accepted submission has no payload");
   const record = isRecord(accepted) ? accepted : void 0;
   const status = admitted.role === "secretariat" ? record?.secretariatStatus : record?.status;
+  const gateOwnsStatusReask = typeof env.parentRunPath === "string" && env.parentRunPath.trim() !== "";
   if (admitted.role === "secretariat" && status !== "converged" && status !== "escalate") {
-    return runPublicInstructionSeatResume(
-      { runId: admitted.runId, message: SECRETARIAT_STATUS_REASK },
-      { ...env, autoResumeLimit: 0 },
-      io
-    );
+    if (gateOwnsStatusReask) return turn;
+    const next = withUnreadableReask(env);
+    if (next === void 0) {
+      const terminal2 = withUnsettledDirection(turn.terminal);
+      io.stdout(formatTerminalResult(terminal2));
+      return { ...turn, terminal: terminal2 };
+    }
+    return runPublicInstructionSeatResume({ runId: admitted.runId, message: SECRETARIAT_STATUS_REASK }, next, io);
   }
-  if (admitted.role === "countersign" && (typeof status !== "string" || !QUEUE_CONCLUSIONS.has(status))) {
-    return runPublicInstructionSeatResume(
-      { runId: admitted.runId, message: COUNTERSIGN_STATUS_REASK },
-      { ...env, autoResumeLimit: 0 },
-      io
-    );
+  if (admitted.role === "countersign" && (typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status))) {
+    if (gateOwnsStatusReask) return turn;
+    const next = withUnreadableReask(env);
+    if (next === 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));
@@ -25816,12 +26496,19 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
     abort() {
     }
   };
+  const passedThisSubmission = (officer) => officerPassedCurrentSubmission({
+    env,
+    parentSessionFile: sessionFile,
+    officer,
+    toolCallId
+  });
   if (admitted.role === "doctor") {
-    if (passedOfficer !== "auditor") {
+    if (!await passedThisSubmission("auditor")) {
       let lastSummon;
       const decision = await createPiDoctorAuditor()({
         context,
         submission: accepted,
+        ...env.autoResumeLimit === void 0 ? {} : { autoResumeLimit: env.autoResumeLimit },
         ...env.signal === void 0 ? {} : { signal: env.signal },
         summonAuditor: async (subject, sourceRunDirectory, signal, reask, submission) => {
           const summoned = await summonPublicRole({
@@ -25850,6 +26537,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
               parentSessionFile: sessionFile,
               officer: "auditor",
               sessionFile: officerSession,
+              submissionToolCallId: toolCallId,
               ...summoned.runDirectory === void 0 ? {} : { runDirectory: summoned.runDirectory }
             });
           }
@@ -25861,7 +26549,15 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
         return runPublicInstructionSeatResume({
           runId: admitted.runId,
           message: readableGateItem(decision.receipt ?? decision.violations)
-        }, { ...env, autoResumeLimit: 0 }, io);
+        }, { ...env, unreadableReasksSpent: 0 }, io);
+      }
+      if (decision.status === "received") {
+        if (lastSummon?.terminal === void 0) {
+          throw new Error("doctor audit kept an unreadable reply with no terminal");
+        }
+        if (turn.terminal === void 0) throw new Error("doctor submission has no terminal");
+        const terminal2 = presentUnsettledAudit(turn.terminal, lastSummon.terminal, io);
+        return { exitCode: 0, admitted, terminal: terminal2 };
       }
       if (decision.status !== "converged") {
         if (lastSummon?.terminal !== void 0) {
@@ -25884,13 +26580,14 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
       ...env.hostAdapters === void 0 ? {} : { hostAdapters: env.hostAdapters }
     });
     let chain;
-    let officerRunId = passedRunId;
+    let officerRunId = resumedOfficer?.runId;
     const runGate = (subject) => requireSubmissionGate({
       context,
       subject,
       toolCallId,
       submission: accepted,
       summonOfficer,
+      ...env.autoResumeLimit === void 0 ? {} : { autoResumeLimit: env.autoResumeLimit },
       ...env.signal === void 0 ? {} : { signal: env.signal },
       hostActions: {
         failInfrastructure(error) {
@@ -25902,13 +26599,13 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
     });
     if (admitted.role === "judge") {
       chain = await runJudgeGates({
-        gateAlreadyConverged: async (subject) => passedOfficer === "auditor" || passedOfficer === "notary" && subject.kind === "judge_draft",
+        gateAlreadyConverged: async (subject) => passedThisSubmission(gateOfficerForSubject(subject)),
         runGate
       });
     } else {
       const subject = admitted.role === "fixer" || admitted.role === "coder" ? { kind: "worker_completion" } : admitted.role === "secretariat" ? { kind: "secretariat_verdict" } : { kind: "countersign_verdict" };
       const officer = gateOfficerForSubject(subject);
-      if (passedOfficer === officer) {
+      if (await passedThisSubmission(officer)) {
         chain = { status: "converged", passes: [] };
       } else {
         const pass = await runGate(subject);
@@ -25921,17 +26618,29 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
             status: pass.status,
             receipt: pass.receipt,
             ...pass.runId === void 0 ? {} : { runId: pass.runId },
-            ...pass.runDirectory === void 0 ? {} : { runDirectory: pass.runDirectory }
+            ...pass.runDirectory === void 0 ? {} : { runDirectory: pass.runDirectory },
+            ...pass.terminal === void 0 ? {} : { terminal: pass.terminal }
           }]
         };
       }
     }
+    if (chain.status === "needs_reask") {
+      const officerTerminal = chain.passes.at(-1)?.terminal;
+      if (officerTerminal === void 0) throw new Error("unreadable audit has no terminal result");
+      if (turn.terminal === void 0) throw new Error("audited submission has no terminal");
+      const terminal2 = presentUnsettledAudit(turn.terminal, officerTerminal, io);
+      return { exitCode: 0, admitted, terminal: terminal2 };
+    }
     if (chain.status === "escalate") {
       const escalation = chain.passes.at(-1);
       const escalatedRunId = escalation?.runId ?? (escalation?.runDirectory === void 0 ? void 0 : runIdFromRunDirectory(escalation.runDirectory));
       if (escalatedRunId === void 0) throw new Error("escalated audit has no resumable run identity");
       const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority);
-      const terminal2 = await trySettlePublicSeat(officer.admitted, env.principalAuthority, void 0);
+      const terminal2 = await trySettlePublicSeat(
+        officer.admitted,
+        env.principalAuthority,
+        await readCurrentCourt(officer.admitted.runDirectory)
+      );
       if (terminal2 === void 0) throw new Error("escalated audit has no terminal result");
       io.stdout(formatTerminalResult(terminal2));
       return { exitCode: 0, admitted: officer.admitted, terminal: terminal2 };
@@ -25940,7 +26649,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
       return runPublicInstructionSeatResume({
         runId: admitted.runId,
         message: readableGateItem(chain.passes.at(-1)?.receipt)
-      }, { ...env, autoResumeLimit: 0 }, io);
+      }, { ...env, unreadableReasksSpent: 0 }, io);
     }
     if (admitted.role === "secretariat") {
       const pass = chain.passes.at(-1);
@@ -25960,7 +26669,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
   io.stdout(formatTerminalResult(terminal));
   return turn;
 }
-var AUDITED_ROLES, SECRETARIAT_STATUS_REASK, COUNTERSIGN_STATUS_REASK, WORKER_ROUTING_STATUSES, WORKER_STATUS_REASK, DOCTOR_ROUTING_STATUSES, DOCTOR_STATUS_REASK, POST_SUBMISSION_ROUTING, QUEUE_CONCLUSIONS, 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";
@@ -25969,10 +26678,13 @@ var init_instruction_seat_run = __esm({
     init_archivist_record_pointer();
     init_doctor_auditor();
     init_gatekeeper_role();
+    init_submission_errors();
+    init_review_submission();
     init_judge_role();
     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();
@@ -25997,7 +26709,6 @@ var init_instruction_seat_run = __esm({
     init_unknown_value();
     AUDITED_ROLES = /* @__PURE__ */ new Set(["judge", "fixer", "coder", "secretariat", "countersign", "doctor"]);
     SECRETARIAT_STATUS_REASK = "secretariatStatus \u4E0D\u662F converged\u3001escalate \u4E4B\u4E00\u3002\u8BF7\u91CD\u65B0\u4EA4\u5377\uFF0CsecretariatStatus \u5199\u660E\u5176\u4E00\u3002";
-    COUNTERSIGN_STATUS_REASK = "status \u4E0D\u662F converged\u3001continue\u3001escalate \u4E09\u6001\u4E4B\u4E00\u3002\u8BF7\u91CD\u65B0\u4EA4\u5377\uFF0Cstatus \u5199\u660E\u5176\u4E00\u3002";
     WORKER_ROUTING_STATUSES = /* @__PURE__ */ new Set([
       "planned",
       "completed",
@@ -26010,8 +26721,7 @@ var init_instruction_seat_run = __esm({
     DOCTOR_STATUS_REASK = "status \u4E0D\u662F completed\u3001refused \u4E4B\u4E00\u3002\u8BF7\u91CD\u65B0\u4EA4\u5377\uFF0Cstatus \u5199\u660E\u5176\u4E00\u3002";
     POST_SUBMISSION_ROUTING = {
       judge: {
-        statuses: /* @__PURE__ */ new Set(["converged", "continue", "escalate"]),
-        reask: "status \u4E0D\u662F converged\u3001continue\u3001escalate \u4E09\u6001\u4E4B\u4E00\u3002\u8BF7\u91CD\u65B0\u4EA4\u5377\uFF0Cstatus \u5199\u660E\u5176\u4E00\u3002"
+        statuses: REVIEW_QUEUE_STATUSES
       },
       coder: {
         statuses: WORKER_ROUTING_STATUSES,
@@ -26032,7 +26742,7 @@ var init_instruction_seat_run = __esm({
         reask: DOCTOR_STATUS_REASK
       }
     };
-    QUEUE_CONCLUSIONS = /* @__PURE__ */ new Set(["converged", "continue", "escalate"]);
+    UNREADABLE_REASK_EXHAUSTED = { unreadableReaskExhausted: true };
     GATE_CHILD_ROLES = /* @__PURE__ */ new Set(["notary", "auditor", "inspector", "countersign"]);
   }
 });
@@ -26653,10 +27363,14 @@ async function runComplianceAudit(options) {
     });
   });
   let reask;
+  let reasksSpent = 0;
+  const reaskLimit = deliveryLimitFromConfig(options.autoResumeLimit);
   for (; ; ) {
     const summoned = await summon(subject, runDirectory, options.signal, reask, submission);
     const decision = await projectAuditorTerminal(summoned);
     if (decision.status === "received") {
+      if (reasksSpent >= reaskLimit) return decision;
+      reasksSpent += 1;
       reask = officerConclusionReask(receivedDiscriminator(decision.reply, "status"));
       continue;
     }
@@ -26672,6 +27386,7 @@ var init_compliance_transport = __esm({
     init_submission_errors();
     init_terminal();
     init_readable_gate_item();
+    init_receipt_delivery_policy();
     init_unknown_value();
     AUDITOR_DOSSIER_PROMPT = "\u5377\u5B97\u6307\u9488\uFF1A";
     AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE = "ak_auditor_parent_attempt_binding";
@@ -26805,7 +27520,7 @@ __export(run_lifecycle_exports, {
   renderResumeCommand: () => renderResumeCommand,
   writeRoleRunState: () => writeRoleRunState
 });
-import { chmod, lstat as lstat5, open, readdir as readdir6, readFile as readFile16, unlink as unlink4, writeFile as writeFile5 } from "node:fs/promises";
+import { chmod, lstat as lstat5, open, readdir as readdir6, readFile as readFile17, unlink as unlink4, writeFile as writeFile5 } from "node:fs/promises";
 import { basename as basename8, join as join31 } from "node:path";
 function buildAutoResumeContinuationPrompt(options) {
   return appendEngineSessionMaterial(
@@ -26882,7 +27597,7 @@ function parseCurrentCourtState(raw) {
 async function readRoleRunStateRaw(runDirectory) {
   let raw;
   try {
-    raw = JSON.parse(await readFile16(join31(runDirectory, RUN_STATE_FILE), "utf8"));
+    raw = JSON.parse(await readFile17(join31(runDirectory, RUN_STATE_FILE), "utf8"));
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
     throw error;
@@ -27140,7 +27855,7 @@ function isProcessAlive(pid) {
 async function autopsyWriterLock(lockPath) {
   let content;
   try {
-    content = await readFile16(lockPath, "utf8");
+    content = await readFile17(lockPath, "utf8");
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return { verdict: "absent" };
     return { verdict: "unknown", reason: "unreadable", readFailure: error };
@@ -27337,7 +28052,7 @@ async function readRunParentPath(runDirectory) {
   let raw;
   try {
     raw = JSON.parse(
-      await readFile16(join31(runDirectory, "admitted-request.json"), "utf8")
+      await readFile17(join31(runDirectory, "admitted-request.json"), "utf8")
     );
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
@@ -27452,7 +28167,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let sourceRun;
   try {
     const raw = JSON.parse(
-      await readFile16(run.admittedRequestPath, "utf8")
+      await readFile17(run.admittedRequestPath, "utf8")
     );
     if (isRecord(raw)) {
       const record = raw;
@@ -27574,7 +28289,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let model;
   try {
     const invocationRaw = JSON.parse(
-      await readFile16(join31(run.runDirectory, "invocation.json"), "utf8")
+      await readFile17(join31(run.runDirectory, "invocation.json"), "utf8")
     );
     if (isRecord(invocationRaw)) {
       const rec = invocationRaw;
@@ -27939,7 +28654,7 @@ var init_run_lifecycle = __esm({
 });
 
 // src/session-identity.ts
-import { mkdir as mkdir3, readFile as readFile17, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile18, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
 import { dirname as dirname18, join as join32 } from "node:path";
 function createSessionIdentityAuthority(authority, sessionBindingFile) {
   const bindingPath = (principal) => join32(authority.decode(principal).sessionDirectory, sessionBindingFile);
@@ -27949,7 +28664,7 @@ function createSessionIdentityAuthority(authority, sessionBindingFile) {
     },
     async load(principal) {
       try {
-        const value = JSON.parse(await readFile17(bindingPath(principal), "utf8"));
+        const value = JSON.parse(await readFile18(bindingPath(principal), "utf8"));
         if (typeof value !== "object" || value === null || typeof value.sessionId !== "string") {
           throw new Error("durable session binding is invalid");
         }
@@ -28593,15 +29308,213 @@ async function settleDeferredPersist(admitted, authority, adapters, io, result)
       io,
       true
     );
-    return { ...failed, turnDispatched: true, skipAutoResume: true };
+    return {
+      ...failed,
+      turnDispatched: true,
+      skipAutoResume: true
+    };
   }
 }
+function settlementScopeForTurn(request) {
+  const hasCourt = request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0;
+  const hasScope = request.invocationScopeId !== void 0 && request.invocationScopeId.length > 0;
+  if (!hasCourt && !hasScope) return void 0;
+  return {
+    ...hasCourt ? { courtAttemptId: request.courtAttemptId } : {},
+    ...hasScope ? { invocationScopeId: request.invocationScopeId } : {}
+  };
+}
+async function buildReceiptDeliveryRequest(input) {
+  const { admitted, env, request, receiptDelivery } = input;
+  const hostSessionId = await readStoredHostSessionId(
+    env.host,
+    env.principalAuthority,
+    admitted.principal
+  );
+  return {
+    ...request,
+    continuation: {
+      kind: "resume",
+      prompt: JSON.stringify({
+        ...receiptDelivery.deliveryState(),
+        deliveryTurns: receiptDelivery.issuedDeliveryRequests() + 1
+      }),
+      ...hostSessionId === void 0 ? {} : { hostSessionId }
+    },
+    deliveryRequestLimit: receiptDelivery.limit
+  };
+}
+async function settleCompletedHostTurn(input) {
+  const { admitted, env, io, adapters, shouldPresent, request, result, persistRunState, deferredPersist } = input;
+  const finishAfterTurn = input.finishAfterTurn;
+  let stderrLogWriteFailure;
+  try {
+    await writeFile7(
+      join35(admitted.runDirectory, "stderr.log"),
+      result.stderr,
+      "utf8"
+    );
+  } catch (error) {
+    stderrLogWriteFailure = error;
+    await recordBestEffortPostDispatchDiagnostic(
+      admitted,
+      env,
+      `stderr.log write failed (best-effort continue): ${describeErrorIdentity(error)}`,
+      io
+    );
+  }
+  const courtScope = settlementScopeForTurn(request);
+  let settled;
+  let settledOutcome;
+  let hostSignalFailed = false;
+  let resolution;
+  try {
+    const sessionFile = admitted.principal !== void 0 ? env.principalAuthority.decode(admitted.principal).sessionFile : "";
+    const runnerKnownFailure = adapters.resolveRunnerKnownFailure !== void 0 && sessionFile !== "" ? await adapters.resolveRunnerKnownFailure({ result, sessionFile }) : result.knownFailure;
+    resolution = await resolveAuditedRunnerFailureResolution({
+      runner: runnerKnownFailure,
+      sessionFile,
+      credential: void 0,
+      runDirectory: admitted.runDirectory
+    });
+    const processCancelName = processCancelSignalName(env.signal);
+    const directHostFailureSignal = result.timedOut || result.knownFailure !== void 0 || runnerKnownFailure !== void 0 || processCancelName !== void 0;
+    hostSignalFailed = directHostFailureSignal || result.code !== null && result.code !== 0 || resolution.knownFailure !== void 0;
+    settled = await adapters.trySettle(admitted, env.principalAuthority, courtScope);
+    if (settled !== void 0) {
+      settled = await attachRecordedSubmissions(admitted, settled, courtScope);
+    }
+    const settledIsFreshThisAttempt = settled === void 0 || settled.roleOutcome.kind !== "accepted" && settled.roleOutcome.kind !== "audit_escalation" ? true : await attemptProducedFreshSubmission(admitted, courtScope);
+    const staleAcceptanceOutranksRealFailure = !settledIsFreshThisAttempt && hostSignalFailed;
+    const cancelAfterSettle = processCancelSignalName(env.signal);
+    if (settled !== void 0 && shouldPresent(settled) && !directHostFailureSignal && !staleAcceptanceOutranksRealFailure && stderrLogWriteFailure === void 0 && cancelAfterSettle === void 0) {
+      if (settled.roleOutcome.kind === "accepted" && request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0) {
+        try {
+          await clearCurrentCourt(admitted.runDirectory, request.courtAttemptId);
+        } catch (error) {
+          await recordBestEffortPostDispatchDiagnostic(
+            admitted,
+            env,
+            `current-court cleanup failed after accepted settlement (best-effort continue): ${describeErrorIdentity(error)}`,
+            io
+          );
+        }
+      }
+      settledOutcome = {
+        exitCode: exitCodeForTerminalOutcome(settled.roleOutcome),
+        admitted,
+        terminal: settled,
+        turnDispatched: true
+      };
+    }
+  } catch (error) {
+    const settledFailure = await settleAfterTurnStarted(
+      admitted,
+      withEngineDetourInvocationScope({
+        timedOut: false,
+        code: result.code,
+        stderr: result.stderr,
+        thrown: error
+      }, request.invocationScopeId),
+      adapters,
+      env.principalAuthority,
+      io,
+      persistRunState
+    );
+    return { kind: "settled", outcome: await finishAfterTurn({ ...settledFailure, turnDispatched: true, ...deferredPersist }) };
+  }
+  if (settledOutcome !== void 0) {
+    const lateCancel = processCancelSignalName(env.signal);
+    if (lateCancel !== void 0) {
+      return { kind: "settled", outcome: await finishAfterTurn(
+        await settleProcessCancelAfterTurn({
+          admitted,
+          cancelName: lateCancel,
+          result,
+          adapters,
+          env,
+          io,
+          persistRunState,
+          deferredPersist,
+          invocationScopeId: request.invocationScopeId
+        })
+      ) };
+    }
+    if (persistRunState) {
+      try {
+        await persistReturnedRunState(admitted, { lawful: true });
+      } catch (error) {
+        await recordBestEffortPostDispatchDiagnostic(
+          admitted,
+          env,
+          `run-state persistence failed beside host terminal (best-effort continue): ${describeErrorIdentity(error)}`,
+          io
+        );
+      }
+    }
+    return { kind: "settled", outcome: await finishAfterTurn({ ...settledOutcome, ...deferredPersist }) };
+  }
+  if (hostSignalFailed) {
+    const resolutionInput = controlledFailureInputFromResolution(resolution);
+    const processCancelName = processCancelSignalName(env.signal);
+    const stderrLogWriteDetails = stderrLogWriteFailure === void 0 ? void 0 : { stderrLogWriteFailure: describeCaughtError(stderrLogWriteFailure) };
+    const failed = await settleAfterTurnStarted(
+      admitted,
+      withEngineDetourInvocationScope({
+        timedOut: result.timedOut,
+        code: result.code,
+        stderr: result.stderr,
+        ...resolutionInput,
+        ...processCancelName === void 0 ? {} : { knownDiagnostic: processCancelDiagnostic(processCancelName) },
+        // Secondary fact only — never the cause. Rides on whichever channel
+        // classification actually reads (knownFailure.details owns it when
+        // a knownFailure exists; the top-level knownDetails otherwise).
+        ...stderrLogWriteDetails === void 0 ? {} : resolutionInput.knownFailure !== void 0 ? {
+          knownFailure: {
+            ...resolutionInput.knownFailure,
+            details: { ...resolutionInput.knownFailure.details ?? {}, ...stderrLogWriteDetails }
+          }
+        } : { knownDetails: stderrLogWriteDetails }
+      }, request.invocationScopeId),
+      adapters,
+      env.principalAuthority,
+      io,
+      persistRunState
+    );
+    return { kind: "settled", outcome: await finishAfterTurn(
+      withProcessCancelSkipAutoResume(
+        { ...failed, turnDispatched: true, ...deferredPersist },
+        env.signal
+      )
+    ) };
+  }
+  if (stderrLogWriteFailure !== void 0) {
+    const failed = await settleAfterTurnStarted(
+      admitted,
+      withEngineDetourInvocationScope({
+        timedOut: false,
+        code: result.code,
+        stderr: result.stderr,
+        thrown: stderrLogWriteFailure
+      }, request.invocationScopeId),
+      adapters,
+      env.principalAuthority,
+      io,
+      persistRunState
+    );
+    return { kind: "settled", outcome: await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist }) };
+  }
+  return { kind: "still-missing" };
+}
 async function dispatchPostAdmissionTurn(input) {
   const { admitted, env, io, request, lease, adapters, effectiveEngine } = input;
   const persistRunState = input.persistRunState !== false;
   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;
@@ -28699,7 +29612,7 @@ async function dispatchPostAdmissionTurn(input) {
           return { exitCode: 0, admitted, terminal: paused, skipAutoResume: true };
         }
       } catch (error) {
-        const settled2 = await presentControlledFailure2(
+        const settled = await presentControlledFailure2(
           admitted,
           withEngineDetourInvocationScope({
             timedOut: false,
@@ -28712,7 +29625,7 @@ async function dispatchPostAdmissionTurn(input) {
           io,
           persistRunState
         );
-        return { ...settled2, ...deferredPersist };
+        return { ...settled, ...deferredPersist };
       }
     }
     let turnRequest = {
@@ -28736,10 +29649,11 @@ async function dispatchPostAdmissionTurn(input) {
     let result;
     try {
       recordRunStart(admitted.runDirectory);
+      turnDispatched = true;
       result = await env.roleTurnHost.executeTurn(turnRequest);
     } catch (error) {
       const processCancelName = processCancelSignalName(env.signal);
-      const settled2 = await settleAfterTurnStarted(
+      const settled = await settleAfterTurnStarted(
         admitted,
         withEngineDetourInvocationScope({
           timedOut: false,
@@ -28754,175 +29668,111 @@ async function dispatchPostAdmissionTurn(input) {
       );
       return await finishAfterTurn(
         withProcessCancelSkipAutoResume(
-          { ...settled2, turnDispatched: true, ...deferredPersist },
+          { ...settled, turnDispatched: true, ...deferredPersist },
           env.signal
         )
       );
     }
-    let stderrLogWriteFailure;
-    try {
-      await writeFile7(
-        join35(admitted.runDirectory, "stderr.log"),
-        result.stderr,
-        "utf8"
-      );
-    } catch (error) {
-      stderrLogWriteFailure = error;
-      await recordBestEffortPostDispatchDiagnostic(
+    const settledTurn = await settleCompletedHostTurn({
+      admitted,
+      env,
+      io,
+      adapters,
+      shouldPresent,
+      request,
+      result,
+      persistRunState,
+      deferredPersist,
+      finishAfterTurn
+    });
+    if (settledTurn.kind === "settled") return settledTurn.outcome;
+    while (akSeamDeliversReceipt && receiptDelivery.nextAction() === "request-delivery") {
+      let deliveryResult;
+      let deliveryTurnRequest;
+      try {
+        const deliveryRequest = await buildReceiptDeliveryRequest({
+          admitted,
+          env,
+          // Host and the other axes already selected on this turn ride the
+          // shared projection. The pre-projection request does not have them.
+          request: turnRequest,
+          receiptDelivery
+        });
+        deliveryTurnRequest = {
+          ...deliveryRequest,
+          principal: admitted.principal,
+          runDirectory: admitted.runDirectory,
+          ...env.signal === void 0 ? {} : { signal: env.signal }
+        };
+        receiptDelivery.recordDeliveryRequest();
+        deliveryResult = await env.roleTurnHost.executeTurn(deliveryTurnRequest);
+      } catch (error) {
+        const settled = await settleAfterTurnStarted(
+          admitted,
+          withEngineDetourInvocationScope(
+            { timedOut: false, code: null, stderr: "", thrown: error },
+            request.invocationScopeId
+          ),
+          adapters,
+          env.principalAuthority,
+          io,
+          persistRunState
+        );
+        return await finishAfterTurn(
+          withProcessCancelSkipAutoResume(
+            {
+              ...settled,
+              turnDispatched: true,
+              ...deferredPersist
+            },
+            env.signal
+          )
+        );
+      }
+      const deliveryTurn = await settleCompletedHostTurn({
         admitted,
         env,
-        `stderr.log write failed (best-effort continue): ${describeErrorIdentity(error)}`,
-        io
-      );
-    }
-    const courtScope = (request.courtAttemptId === void 0 || request.courtAttemptId.length === 0) && (request.invocationScopeId === void 0 || request.invocationScopeId.length === 0) ? void 0 : {
-      ...request.courtAttemptId === void 0 || request.courtAttemptId.length === 0 ? {} : { courtAttemptId: request.courtAttemptId },
-      ...request.invocationScopeId === void 0 || request.invocationScopeId.length === 0 ? {} : { invocationScopeId: request.invocationScopeId }
-    };
-    let settled;
-    let settledOutcome;
-    let hostSignalFailed = false;
-    let resolution;
-    try {
-      const sessionFile = admitted.principal !== void 0 ? env.principalAuthority.decode(admitted.principal).sessionFile : "";
-      const runnerKnownFailure = adapters.resolveRunnerKnownFailure !== void 0 && sessionFile !== "" ? await adapters.resolveRunnerKnownFailure({ result, sessionFile }) : result.knownFailure;
-      resolution = await resolveAuditedRunnerFailureResolution({
-        runner: runnerKnownFailure,
-        sessionFile,
-        credential: void 0,
-        runDirectory: admitted.runDirectory
+        // Only the final Terminal presents; intermediate delivery attempts stay quiet.
+        io: { ...io, stdout: () => {
+        } },
+        adapters,
+        shouldPresent,
+        request: deliveryTurnRequest,
+        result: deliveryResult,
+        // Run-state terminal write belongs to the OUTERMOST turn only, so a
+        // still-silent delivery attempt never makes the run look lawfully terminal.
+        persistRunState: false,
+        deferredPersist,
+        finishAfterTurn
       });
-      const processCancelName = processCancelSignalName(env.signal);
-      const directHostFailureSignal = result.timedOut || result.knownFailure !== void 0 || runnerKnownFailure !== void 0 || processCancelName !== void 0;
-      hostSignalFailed = directHostFailureSignal || result.code !== null && result.code !== 0 || resolution.knownFailure !== void 0;
-      settled = await adapters.trySettle(admitted, env.principalAuthority, courtScope);
-      if (settled !== void 0) {
-        settled = await attachRecordedSubmissions(admitted, settled, courtScope);
-      }
-      const settledIsFreshThisAttempt = settled === void 0 || settled.roleOutcome.kind !== "accepted" && settled.roleOutcome.kind !== "audit_escalation" ? true : await attemptProducedFreshSubmission(admitted, courtScope);
-      const staleAcceptanceOutranksRealFailure = !settledIsFreshThisAttempt && hostSignalFailed;
-      const cancelAfterSettle = processCancelSignalName(env.signal);
-      if (settled !== void 0 && shouldPresent(settled) && !directHostFailureSignal && !staleAcceptanceOutranksRealFailure && stderrLogWriteFailure === void 0 && cancelAfterSettle === void 0) {
-        if (settled.roleOutcome.kind === "accepted" && request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0) {
+      if (deliveryTurn.kind === "settled") {
+        if (persistRunState && deliveryTurn.outcome.terminal !== void 0) {
           try {
-            await clearCurrentCourt(admitted.runDirectory, request.courtAttemptId);
+            await persistReturnedRunState(admitted, {
+              lawful: isLawfulTypedTerminalOutcome(deliveryTurn.outcome.terminal.roleOutcome)
+            });
           } catch (error) {
             await recordBestEffortPostDispatchDiagnostic(
               admitted,
               env,
-              `current-court cleanup failed after accepted settlement (best-effort continue): ${describeErrorIdentity(error)}`,
+              `run-state persistence failed beside\u50AC\u4EA4 terminal (best-effort continue): ${describeErrorIdentity(error)}`,
               io
             );
           }
         }
-        settledOutcome = {
-          exitCode: exitCodeForTerminalOutcome(settled.roleOutcome),
-          admitted,
-          terminal: settled,
-          turnDispatched: true
-        };
+        return await finishAfterTurn(deliveryTurn.outcome);
       }
-    } 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({ ...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) {
@@ -28959,6 +29809,11 @@ async function dispatchPostAdmissionTurn(input) {
       turnDispatched: true,
       ...deferredPersist
     });
+  } catch (error) {
+    if (turnDispatched && !(error instanceof TurnDispatchedFailure)) {
+      throw new TurnDispatchedFailure(error);
+    }
+    throw error;
   } finally {
     if (lease !== void 0) {
       try {
@@ -29004,7 +29859,9 @@ function resumeTurnRequestProjectionOptions(admitted, request, env, summonsPrepa
       prompt
     },
     ...request.message === void 0 ? {} : { courtAttemptId: randomUUID6() },
-    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild }
+    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild },
+    // #1132: one configured ceiling, already resolved by the caller (#422).
+    deliveryRequestLimit: deliveryLimitFromConfig(env.autoResumeLimit)
   };
 }
 function roleTurnOptions(env, admitted, continuation) {
@@ -29014,7 +29871,9 @@ function roleTurnOptions(env, admitted, continuation) {
     ...env.host === void 0 ? {} : { host: env.host },
     ...correlationId === void 0 || correlationId.trim() === "" ? {} : { correlationId },
     continuation,
-    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild }
+    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild },
+    // #1132: one configured ceiling, already resolved by the caller (#422).
+    deliveryRequestLimit: deliveryLimitFromConfig(env.autoResumeLimit)
   };
 }
 async function dispatchAfterWriterLease(input) {
@@ -29032,6 +29891,7 @@ async function dispatchAfterWriterLease(input) {
 async function runSettledAutoResumeLoop(input) {
   const adapters = withOnceSuccessfulBeforeDispatch(input.adapters);
   const dispatchEnv = input.dispatchEnv ?? input.env;
+  const receiptDelivery = createReceiptDeliveryPolicy(input.env.autoResumeLimit);
   return runWithAutoResumeLoop({
     admitted: input.admitted,
     principalAuthority: input.env.principalAuthority,
@@ -29053,6 +29913,7 @@ async function runSettledAutoResumeLoop(input) {
           ...lease === void 0 ? {} : { lease },
           adapters,
           persistRunState: false,
+          receiptDelivery,
           ...input.effectiveEngine === void 0 ? {} : { effectiveEngine: input.effectiveEngine }
         });
         return settleDeferredPersist(
@@ -29415,12 +30276,14 @@ var init_post_admission = __esm({
     init_activation_ledger_topology();
     init_engine_material();
     init_session_identity();
+    init_receipt_delivery_policy();
     init_role_run_relocation();
     init_packaged_role_registry();
     init_engine_detour_usage();
     init_run_lifecycle();
     init_process_cancel();
     init_activation_ledger_topology();
+    init_host_descriptions();
     init_host_session_record();
     init_settlement();
     init_terminal();
@@ -29486,7 +30349,7 @@ var init_atomic_write = __esm({
 });
 
 // src/analyst-index.ts
-import { open as open3, readFile as readFile18, unlink as unlink5 } from "node:fs/promises";
+import { open as open3, readFile as readFile19, unlink as unlink5 } from "node:fs/promises";
 import { dirname as dirname21, join as join37 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 async function withAnalystLibraryIndexLock(ledgerHome, fn) {
@@ -29610,7 +30473,7 @@ async function readAnalystLibraryIndexPage(ledgerHome) {
   const path = analystLibraryIndexPath(ledgerHome);
   let raw;
   try {
-    raw = await readFile18(path, "utf8");
+    raw = await readFile19(path, "utf8");
   } catch (error) {
     if (isMissingPathError(error)) return void 0;
     throw error;
@@ -29813,7 +30676,7 @@ var init_analyst_cohort = __esm({
 });
 
 // src/analyst-ledger.ts
-import { readdir as readdir7, readFile as readFile19 } from "node:fs/promises";
+import { readdir as readdir7, readFile as readFile20 } from "node:fs/promises";
 import { basename as basename9, join as join38 } from "node:path";
 async function readExistingRunLifecycleState(runDirectory) {
   return (await readRoleRunIdentity(runDirectory))?.state;
@@ -29863,7 +30726,7 @@ async function listLedgerBookNames(booksRoot) {
 async function readInvocationScopeFields(runDirectory) {
   let raw;
   try {
-    raw = await readFile19(join38(runDirectory, "invocation.json"), "utf8");
+    raw = await readFile20(join38(runDirectory, "invocation.json"), "utf8");
   } catch (error) {
     if (isMissingPathError(error)) return void 0;
     throw error;
@@ -29896,7 +30759,7 @@ function decideIssueScope(input) {
 }
 async function resolveSessionFile(runDirectory) {
   try {
-    const raw = await readFile19(join38(runDirectory, "invocation.json"), "utf8");
+    const raw = await readFile20(join38(runDirectory, "invocation.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (isRecord(parsed) && typeof parsed.sessionFile === "string" && parsed.sessionFile.trim() !== "") {
       return parsed.sessionFile;
@@ -31156,7 +32019,7 @@ var init_analyst_model_groups = __esm({
 });
 
 // src/analyst-entry.ts
-import { readFile as readFile20 } from "node:fs/promises";
+import { readFile as readFile21 } from "node:fs/promises";
 function cachedPageMatchesRequestedScope(page, input) {
   if (page.bookKey !== input.bookKey) return false;
   const requestedTicket = input.ticketNumber ?? input.issueNumber;
@@ -31183,7 +32046,7 @@ async function readOrComputeAnalystIssuePage(input, options) {
     ...issueNumber === void 0 && input.bookKey === void 0 ? { scopeRootIdentity: projectRoot } : {}
   });
   try {
-    const raw = await readFile20(pagePath, "utf8");
+    const raw = await readFile21(pagePath, "utf8");
     const page = JSON.parse(raw);
     if (cachedPageMatchesRequestedScope(page, { bookKey, ...input })) {
       const ghostScan = await scanAnalystIssueRuns({
@@ -31284,7 +32147,7 @@ async function runAnalystModelGroupsMode(input, home) {
       scopeRootIdentity: projectRoot
     });
     try {
-      const raw = await readFile20(pagePath, "utf8");
+      const raw = await readFile21(pagePath, "utf8");
       JSON.parse(raw);
     } catch (error) {
       if (!isMissingPathError(error)) {
@@ -31382,7 +32245,7 @@ var init_analyst_entry = __esm({
 });
 
 // src/public-cli/analyst-run.ts
-import { readFile as readFile21 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 import { isAbsolute as isAbsolute10, resolve as resolve13 } from "node:path";
 function resolveAnalystIssueBookKeyFromCwd(cwd = process.cwd()) {
   try {
@@ -31435,7 +32298,7 @@ async function buildAnalystSweepModeInputFromAttachmentPaths(attachmentPaths) {
   const absolute = isAbsolute10(sourcePath) ? sourcePath : resolve13(sourcePath);
   let bytes;
   try {
-    bytes = await readFile21(absolute);
+    bytes = await readFile22(absolute);
   } catch (error) {
     throw new CliUsageError(
       `analyst sweep attachment is not a readable regular file: ${sourcePath}`,
@@ -32324,7 +33187,7 @@ async function runAkRole(argv2, env) {
         io
       );
       let current = result;
-      while (current.exitCode === 0 && current.admitted?.correlationId !== void 0 && current.terminal?.roleOutcome.kind === "accepted" && !latestPayloadEscalated(current.terminal.roleOutcome)) {
+      while (current.exitCode === 0 && current.admitted?.correlationId !== void 0 && current.terminal?.roleOutcome.kind === "accepted" && current.terminal.roleOutcome.decisiveFacts?.directionUnsettled !== true && !latestPayloadEscalated(current.terminal.roleOutcome)) {
         const parentRunId = current.admitted.correlationId;
         resumeFailureContext = {
           home,