@akagilnc/pi-workflow-roles 0.1.5375 → 0.1.5406

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

@@ -285,15 +285,6 @@ var init_judge_output = __esm({
   }
 });
 
-// src/package-contracts/reviewer-output.ts
-var REVIEWER_OUTPUT_TOOL_NAME;
-var init_reviewer_output = __esm({
-  "src/package-contracts/reviewer-output.ts"() {
-    "use strict";
-    REVIEWER_OUTPUT_TOOL_NAME = "ak_reviewer_output";
-  }
-});
-
 // src/open-tool-schema.ts
 import { Type as Type3 } from "typebox";
 function described(name, schema) {
@@ -317,8 +308,32 @@ var init_open_tool_schema = __esm({
   }
 });
 
-// src/package-contracts/gatekeeper-output.ts
+// src/package-contracts/reviewer-output.ts
 import { Type as Type4 } from "typebox";
+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_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 = Type4.Object({
+      status: Type4.Unknown({ description: REVIEWER_STATUS_DESCRIPTION }),
+      amendments: Type4.Unknown({ description: REVIEWER_AMENDMENTS_DESCRIPTION }),
+      diagnostic: Type4.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)
+    );
+  }
+});
+
+// src/package-contracts/gatekeeper-output.ts
+import { Type as Type5 } from "typebox";
 var GATEKEEPER_OUTPUT_TOOL_NAME, gatekeeperDecisionSchema, gatekeeperOutputSchema;
 var init_gatekeeper_output = __esm({
   "src/package-contracts/gatekeeper-output.ts"() {
@@ -328,14 +343,14 @@ var init_gatekeeper_output = __esm({
     init_unknown_value();
     GATEKEEPER_OUTPUT_TOOL_NAME = "ak_gatekeeper_output";
     gatekeeperDecisionSchema = openToolObject(
-      Type4.Object({
-        status: Type4.Unknown({
+      Type5.Object({
+        status: Type5.Unknown({
           description: "dispatch | pass"
         }),
-        officer: Type4.Unknown({
+        officer: Type5.Unknown({
           description: "status \u4E3A dispatch \u65F6\u4E3A inspector | notary"
         }),
-        findings: Type4.Unknown({
+        findings: Type5.Unknown({
           description: "status \u4E3A pass \u65F6\u53EF\u9009 string[] findings"
         })
       })
@@ -355,7 +370,7 @@ __export(navigator_output_exports, {
   projectLawfulNavigatorOutput: () => projectLawfulNavigatorOutput,
   validateRecordedNavigatorOutput: () => validateRecordedNavigatorOutput
 });
-import { Type as Type5 } from "typebox";
+import { Type as Type6 } from "typebox";
 function projectLawfulNavigatorOutput(value) {
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "string") return { prose: value };
@@ -397,8 +412,8 @@ var init_navigator_output = __esm({
     NAVIGATOR_OUTPUT_TOOL_NAME = "ak_navigator_output";
     navigatorOutputSchema = withTerminatingOutputDeclarations(
       openToolObject(
-        Type5.Object({
-          prose: Type5.Unknown({
+        Type6.Object({
+          prose: Type6.Unknown({
             description: "\u6E38\u5955\u4F7F\u6563\u6587\u5EFA\u8BAE\uFF0C\u539F\u6837\u5448\u73B0\u3002\u4E0D\u8981\u6C42 candidates/next \u7B49\u7ED3\u6784\u5316\u5B57\u6BB5\u3002"
           })
         })
@@ -408,7 +423,7 @@ var init_navigator_output = __esm({
 });
 
 // src/package-contracts/fixer-output.ts
-import { Type as Type6 } from "typebox";
+import { Type as Type7 } from "typebox";
 function validateFixerOutput(value, _phase) {
   return value;
 }
@@ -421,22 +436,22 @@ var init_fixer_output = __esm({
     FIXER_OUTPUT_TOOL_NAME = "ak_fixer_output";
     PARTIALLY_COMPLETED_DEFINITION = "partially_completed \u53EA\u80FD\u5728\u6709\u5408\u6CD5\u62D2\u7EDD\u9879\uFF08\u5B8C\u6210\u9879\u4E0E\u5408\u6CD5\u62D2\u7EDD\u9879\u5E76\u5B58\uFF09\u65F6\u7528\uFF0C\u522B\u7684\u60C5\u51B5\u4E0D\u51C6\u7528\u3002";
     FIXER_STATUS_DESCRIPTION = `planned | completed | refused | unfinished | partially_completed\u3002unfinished \u7F3A\u524D\u7F6E\u6216\u8FDD\u5BAA\u7EA6\u675F\u81F4\u672C\u5C40\u672A\u5B8C\u6210\u65F6\u53EF\u7528\uFF0C\u7F3A\u5F85\u51B3 owner \u51B3\u5B9A\u6216\u7B54\u590D\u5C5E\u7F3A\u524D\u7F6E\u3002${PARTIALLY_COMPLETED_DEFINITION}`;
-    fixerOutputObject = Type6.Object({
-      status: Type6.Unknown({ description: FIXER_STATUS_DESCRIPTION }),
-      report: Type6.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
-      remainingScope: Type6.Unknown({
+    fixerOutputObject = Type7.Object({
+      status: Type7.Unknown({ description: FIXER_STATUS_DESCRIPTION }),
+      report: Type7.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
+      remainingScope: Type7.Unknown({
         description: "\u672C\u5C40\u540E\u5269\u4F59\u5DE5\u4F5C\uFF1B\u4F9D\u6CD5\u4E0D\u80FD\u5B8C\u6210\u7684\u8303\u56F4\u4E5F\u5199\u6B64\u5904\u3002"
       }),
-      blocker: Type6.Unknown({
+      blocker: Type7.Unknown({
         description: "\u5408\u6CD5\u963B\u65AD\u5B8C\u6210\u7684 blocker\uFF0C\u539F\u6837\u7559\u5B58\u3002\u53EF\u5199 cause\uFF08authority_violation \u6216 prerequisite_unmet\uFF09\u3001evidence\uFF1Bprerequisite_unmet \u8FD8\u53EF\u5199 prerequisiteId\u3002"
       }),
-      reason: Type6.Unknown({
+      reason: Type7.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"
       }),
-      classResults: Type6.Unknown({
+      classResults: Type7.Unknown({
         description: "\u5404\u7C7B class \u7ED3\u7B97\uFF0C\u539F\u6837\u7559\u5B58\u3002\u5B8C\u6210\u9879\u7684 disposition \u4E3A completed\uFF0C\u53EF\u5199 name\u3001searchScope\u3001exceptions\uFF08where\u3001reason\uFF09\u3001commitSha\u3002\u62D2\u7EDD\u9879\u7684 disposition \u4E3A refused\uFF0C\u53EF\u5199 name\u3001remainingScope\u3001blocker\u3002"
       }),
-      testEvidence: Type6.Unknown({
+      testEvidence: Type7.Unknown({
         description: "\u6D4B\u8BD5\u8BC1\u636E\u6761\uFF1Bdiff \u542B\u6D4B\u8BD5\u6539\u52A8\u65F6\u63D0\u4EA4\uFF1B\u673A\u5668\u4E0D\u6838\u9A8C\u3002\u53EF\u5199 contract\uFF08\u6D4B\u8BD5\u6539\u52A8\u6240\u8BC1\u660E\u7684\u5951\u7EA6\uFF09\u3001minimumNecessaryCost\uFF08\u6D4B\u8BD5\u6539\u52A8\u7684\u4E00\u884C\u6700\u5C0F\u5FC5\u8981\u6210\u672C\uFF09\u3001measuredDuration\uFF08\u805A\u7126\u9A8C\u8BC1\u5B9E\u6D4B\u65F6\u957F\uFF09\u3002"
       })
     });
@@ -447,7 +462,7 @@ var init_fixer_output = __esm({
 });
 
 // src/package-contracts/fixer-packet.ts
-import { Type as Type7 } from "typebox";
+import { Type as Type8 } from "typebox";
 import { Value } from "typebox/value";
 function causeMessage(cause) {
   if (cause instanceof Error) return cause.message;
@@ -504,11 +519,11 @@ var init_fixer_packet = __esm({
     "use strict";
     init_unknown_value();
     FIXER_PREREQUISITE_ID_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._-]*$";
-    fixerPrerequisiteSchema = Type7.Object({
-      id: Type7.String({ pattern: FIXER_PREREQUISITE_ID_PATTERN }),
-      requirement: Type7.String({ pattern: "\\S" })
+    fixerPrerequisiteSchema = Type8.Object({
+      id: Type8.String({ pattern: FIXER_PREREQUISITE_ID_PATTERN }),
+      requirement: Type8.String({ pattern: "\\S" })
     });
-    fixerPrerequisitesSchema = Type7.Array(fixerPrerequisiteSchema);
+    fixerPrerequisitesSchema = Type8.Array(fixerPrerequisiteSchema);
     FixerPacketValidationError = class extends Error {
       code = "AK_INVALID_FIX_PACKET";
       constructor(cause) {
@@ -524,20 +539,34 @@ var init_fixer_packet = __esm({
 });
 
 // src/package-contracts/worker-output.ts
+import { Type as Type9 } from "typebox";
 function validateAcceptedCoderDetails(output) {
   return output;
 }
 function validateAcceptedWorkerDetails(output, roleLabel = "Coder") {
   return roleLabel === "Fixer" ? validateFixerOutput(output) : validateAcceptedCoderDetails(output);
 }
-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_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 = Type9.Object({
+      status: Type9.Unknown({ description: CODER_STATUS_DESCRIPTION }),
+      report: Type9.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
+      remainingScope: Type9.Unknown({ description: "\u672C\u5C40\u540E\u5269\u4F59\u5DE5\u4F5C" }),
+      reason: Type9.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)
+    );
   }
 });
 
@@ -549,7 +578,7 @@ var init_canonical_json = __esm({
 });
 
 // src/doctor-contracts.ts
-import { Type as Type8 } from "typebox";
+import { Type as Type10 } from "typebox";
 function validateDoctorSubmissionShape(value) {
   return value;
 }
@@ -575,25 +604,25 @@ var init_doctor_contracts = __esm({
     biteNone = "noRealBite";
     DOCTOR_BITE_KINDS = [biteActual, biteNone];
     DOCTOR_STATUS_DESCRIPTION = "completed | refused\u3002completed \u5141\u8BB8\u7A7A findings\uFF1Brefused \u4EC5\u5F53\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u6848\u8BC1\u8BCD";
-    doctorSubmissionObject = Type8.Object({
-      status: Type8.Unknown({ description: DOCTOR_STATUS_DESCRIPTION }),
-      case: Type8.Unknown({
+    doctorSubmissionObject = Type10.Object({
+      status: Type10.Unknown({ description: DOCTOR_STATUS_DESCRIPTION }),
+      case: Type10.Unknown({
         description: "\u7559\u5B58\u592A\u533B\u7F72\u6848\u8EAB\u4EFD\uFF0C\u539F\u6837\u7559\u5B58\uFF08\u5982 issueNumber\u3001runsPath\uFF09\u3002\u673A\u68B0\u5C42\u53E6\u6309\u7ED1\u5B9A run \u6295\u5F71\u6848\u8EAB\u4EFD\uFF0C\u4E0D\u5728\u672C\u5B57\u6BB5\u91CD\u5224\u3002"
       }),
-      findings: Type8.Unknown({
+      findings: Type10.Unknown({
         description: `\u9010\u6761\u8D44\u4EA7\u89C2\u5BDF\u4E0E\u5904\u65B9\uFF0C\u539F\u6837\u7559\u5B58\u3002\u4E00\u6761\u53EF\u542B targetKey\u3001targetKind\uFF08${DOCTOR_TARGET_KINDS.join(" | ")}\uFF09\u3001observation\u3001evidenceIds\u3001disposition\uFF08${DOCTOR_DISPOSITIONS.join(" | ")}\uFF09\u3001assetEvidence\uFF08targetKey\u3001targetKind\u3001evidenceId\uFF09\u3001guardrails\uFF08reproducibleFailure\u3001owningSeamOrInvariant\u3001deletionOrSimplificationSuffices\uFF0C\u5404\u9879\u53EF\u542B answer\u3001evidenceIds\u3001explanation\uFF09\u3001prescription\uFF08kind \u4E3A ${DOCTOR_PRESCRIPTION_KINDS.join(" | ")}\uFF0C\u53E6\u53EF\u5199 recommendation\u3001necessityExplanation\uFF09\u3001lastRealBite\uFF08kind \u4E3A ${DOCTOR_BITE_KINDS.join(" | ")}\uFF0C\u53E6\u53EF\u5199 targetKey\u3001evidenceId\u3001eligibleEvidenceIds\uFF09\u3002\u4E0D\u8981\u6C42\u4EFB\u4F55\u5904\u65B9\u6216\u53EF\u590D\u7528 finding\uFF1B\u7F3A\u53EF\u590D\u7528\u8D44\u4EA7\u6216 bounded-bite \u8BC1\u636E\u53EA\u6392\u9664\u5BF9\u5E94\u8D44\u4EA7\u5904\u65B9\u3002\u673A\u5668\u4E0D\u6838\u9A8C\u3002`
       }),
-      reason: Type8.Unknown({
+      reason: Type10.Unknown({
         description: "\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u8BC1\u8BCD\u7684\u539F\u56E0\uFF1B\u4EC5 refused \u65F6\u7528\u3002"
       }),
-      missingEvidence: Type8.Unknown({
+      missingEvidence: Type10.Unknown({
         description: "\u5982\u5B9E\u8BC1\u8BCD\u6240\u9700\u800C\u5C1A\u7F3A\u7684\u8BC1\u636E\uFF0C\u539F\u6837\u7559\u5B58\uFF08\u5982\u6BCF\u9879 need\u3001targetKeys\uFF09\u3002"
       })
     });
     doctorSubmissionSchema = withTerminatingOutputDeclarations(
       openToolObject(doctorSubmissionObject)
     );
-    doctorEvidenceReadSchema = Type8.Object({ evidenceId: Type8.String({ minLength: 1, description: "\u5F85\u8BFB\u7559\u5B58\u8BC1\u636E\u6807\u8BC6" }), offset: Type8.Optional(Type8.Integer({ minimum: 0, description: "\u8D77\u59CB\u5B57\u8282\u504F\u79FB\uFF08\u4ECE 0 \u8BA1\uFF09" })), limit: Type8.Optional(Type8.Integer({ minimum: 1, description: "\u8FD4\u56DE\u5B57\u8282\u6570\uFF08\u65E0\u4E0A\u9650\uFF09" })) }, { additionalProperties: true });
+    doctorEvidenceReadSchema = Type10.Object({ evidenceId: Type10.String({ minLength: 1, description: "\u5F85\u8BFB\u7559\u5B58\u8BC1\u636E\u6807\u8BC6" }), offset: Type10.Optional(Type10.Integer({ minimum: 0, description: "\u8D77\u59CB\u5B57\u8282\u504F\u79FB\uFF08\u4ECE 0 \u8BA1\uFF09" })), limit: Type10.Optional(Type10.Integer({ minimum: 1, description: "\u8FD4\u56DE\u5B57\u8282\u6570\uFF08\u65E0\u4E0A\u9650\uFF09" })) }, { additionalProperties: true });
     DoctorEvidenceStore = class {
       constructor(patient) {
         this.patient = patient;
@@ -662,7 +691,7 @@ var init_exact_utf8 = __esm({
 });
 
 // src/merger-contracts.ts
-import { Type as Type9 } from "typebox";
+import { Type as Type11 } from "typebox";
 function fail2(message = "Merger input violates its exact contract") {
   throw new MergerInputContractError(message);
 }
@@ -693,24 +722,24 @@ var init_merger_contracts = __esm({
     init_open_tool_schema();
     init_terminating_infrastructure();
     init_unknown_value();
-    materialSchema = Type9.Object({ bytesBase64: Type9.String(), sha256: Type9.String() });
-    checkSchema = Type9.Object({ name: Type9.String({ minLength: 1 }), argv: Type9.Array(Type9.String({ minLength: 1 }), { minItems: 1 }) });
-    mergerInputSchema = Type9.Object({
-      attemptId: Type9.String({ minLength: 1, description: "\u5BF9\u8D26 attempt \u8EAB\u4EFD\uFF08transport\uFF09" }),
-      targetObjectId: Type9.String({ description: "\u6750\u6599\uFF1Atarget parent OID\uFF1B\u53EF\u7A7A" }),
-      sourceObjectId: Type9.String({ description: "\u6750\u6599\uFF1Asource parent OID\uFF1B\u53EF\u7A7A" }),
-      materials: Type9.Object({ task: materialSchema, authority: materialSchema, targetIntent: materialSchema, sourceIntent: materialSchema }),
-      expectedConflictPaths: Type9.Array(Type9.String(), { description: "\u6750\u6599\uFF1A\u5F53\u524D\u672A\u5408\u5E76\u8DEF\u5F84\uFF1B\u53EF\u7A7A" }),
-      resolutionScope: Type9.Array(Type9.String(), { description: "\u6750\u6599\uFF1A\u89E3\u6790\u8303\u56F4\u63D0\u793A\uFF1B\u53EF\u7A7A" }),
-      authorizedChecks: Type9.Array(checkSchema)
+    materialSchema = Type11.Object({ bytesBase64: Type11.String(), sha256: Type11.String() });
+    checkSchema = Type11.Object({ name: Type11.String({ minLength: 1 }), argv: Type11.Array(Type11.String({ minLength: 1 }), { minItems: 1 }) });
+    mergerInputSchema = Type11.Object({
+      attemptId: Type11.String({ minLength: 1, description: "\u5BF9\u8D26 attempt \u8EAB\u4EFD\uFF08transport\uFF09" }),
+      targetObjectId: Type11.String({ description: "\u6750\u6599\uFF1Atarget parent OID\uFF1B\u53EF\u7A7A" }),
+      sourceObjectId: Type11.String({ description: "\u6750\u6599\uFF1Asource parent OID\uFF1B\u53EF\u7A7A" }),
+      materials: Type11.Object({ task: materialSchema, authority: materialSchema, targetIntent: materialSchema, sourceIntent: materialSchema }),
+      expectedConflictPaths: Type11.Array(Type11.String(), { description: "\u6750\u6599\uFF1A\u5F53\u524D\u672A\u5408\u5E76\u8DEF\u5F84\uFF1B\u53EF\u7A7A" }),
+      resolutionScope: Type11.Array(Type11.String(), { description: "\u6750\u6599\uFF1A\u89E3\u6790\u8303\u56F4\u63D0\u793A\uFF1B\u53EF\u7A7A" }),
+      authorizedChecks: Type11.Array(checkSchema)
     });
     MERGER_STATUS_DESCRIPTION = "completed | escalate";
-    mergerOutputObject = Type9.Object({
-      status: Type9.Unknown({ description: MERGER_STATUS_DESCRIPTION }),
-      attemptId: Type9.Unknown({ description: "\u5DF2\u53D7\u7406\u5408\u5E76 attempt \u8EAB\u4EFD" }),
-      report: Type9.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
-      mergeCommitId: Type9.Unknown({ description: "\u5B8C\u6210\u5408\u5E76 commit object ID" }),
-      diagnosis: Type9.Unknown({
+    mergerOutputObject = Type11.Object({
+      status: Type11.Unknown({ description: MERGER_STATUS_DESCRIPTION }),
+      attemptId: Type11.Unknown({ description: "\u5DF2\u53D7\u7406\u5408\u5E76 attempt \u8EAB\u4EFD" }),
+      report: Type11.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
+      mergeCommitId: Type11.Unknown({ description: "\u5B8C\u6210\u5408\u5E76 commit object ID" }),
+      diagnosis: Type11.Unknown({
         description: "\u5408\u5E76\u65E0\u6CD5\u6216\u4E0D\u5E94\u7531\u672C\u5E2D\u5B8C\u6210\u7684\u539F\u56E0\uFF08\u542B\u65E0\u8FDB\u884C\u4E2D\u5408\u5E76\u3001\u65E0\u6D3B\u53EF\u5E72\u3001\u9700\u65B0\u7684\u4EA7\u54C1/\u6743\u529B\u51B3\u5B9A\uFF09"
       })
     });
@@ -729,7 +758,7 @@ var init_merger_contracts = __esm({
 });
 
 // src/notary-contracts.ts
-var NOTARY_OUTPUT_TOOL_NAME, NOTARY_SOURCE_RUN_FLAG, NOTARY_TICKET_FLAG, notaryOutputSchema;
+var NOTARY_OUTPUT_TOOL_NAME, NOTARY_SOURCE_RUN_FLAG, NOTARY_TICKET_FLAG;
 var init_notary_contracts = __esm({
   "src/notary-contracts.ts"() {
     "use strict";
@@ -750,7 +779,6 @@ var init_notary_contracts = __esm({
         type: "string"
       }
     };
-    notaryOutputSchema = reviewSubmissionSchema;
   }
 });
 
@@ -766,12 +794,27 @@ var init_countersign_contracts = __esm({
 });
 
 // src/gleaner-left-contracts.ts
-var GLEANER_LEFT_OUTPUT_TOOL_NAME, GLEANER_LEFT_BASE_FLAG;
+import { Type as Type12 } from "typebox";
+var GLEANER_LEFT_OUTPUT_TOOL_NAME, gleanerLeftOutputSchema, GLEANER_LEFT_BASE_FLAG;
 var init_gleaner_left_contracts = __esm({
   "src/gleaner-left-contracts.ts"() {
     "use strict";
+    init_open_tool_schema();
+    init_terminating_infrastructure();
     init_unknown_value();
     GLEANER_LEFT_OUTPUT_TOOL_NAME = "ak_gleaner_left_output";
+    gleanerLeftOutputSchema = withTerminatingOutputDeclarations(
+      openToolObject(
+        Type12.Object({
+          status: Type12.Unknown({
+            description: "completed"
+          }),
+          findings: Type12.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"
+          })
+        })
+      )
+    );
     GLEANER_LEFT_BASE_FLAG = {
       name: "ak-gleaner-left-base",
       definition: {
@@ -801,14 +844,13 @@ var init_inspector_contracts = __esm({
 });
 
 // src/package-contracts/auditor-output.ts
-var AUDITOR_OUTPUT_TOOL_NAME, auditorOutputSchema;
+var AUDITOR_OUTPUT_TOOL_NAME;
 var init_auditor_output = __esm({
   "src/package-contracts/auditor-output.ts"() {
     "use strict";
     init_review_submission();
     init_unknown_value();
     AUDITOR_OUTPUT_TOOL_NAME = REVIEW_SUBMISSION_OUTPUT_TOOL_NAME;
-    auditorOutputSchema = reviewSubmissionSchema;
   }
 });
 
@@ -935,6 +977,7 @@ var init_run_ticket_number = __esm({
 });
 
 // src/diarist-contracts.ts
+import { Type as Type13 } from "typebox";
 function projectDiaristSessions(value) {
   const raw = value?.sessions;
   if (raw === void 0) return [];
@@ -954,23 +997,68 @@ function projectDiaristTicketSessions(value) {
   }
   return Array.from(perTicket, ([ticketNumber, sessions]) => ({ ticketNumber, sessions }));
 }
-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_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(
+        Type13.Object({
+          status: Type13.Unknown({
+            description: "completed | escalate"
+          }),
+          ticketNumber: Type13.Optional(
+            Type13.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: Type13.Unknown({
+            description: "status \u4E3A escalate \u65F6\uFF1A\u8BA4\u4E0D\u51FA\u672C\u5EAD\u5BF9\u8C61\u7684\u539F\u56E0"
+          }),
+          sessions: Type13.Optional(Type13.Unknown({ description: DIARIST_SESSIONS_DESCRIPTION })),
+          ticketSessions: Type13.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;
+import { Type as Type14 } from "typebox";
+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_terminating_infrastructure();
     SECRETARIAT_OUTPUT_TOOL_NAME = "ak_secretariat_output";
+    secretariatVerdictSchema = withTerminatingOutputDeclarations(
+      Type14.Object(
+        {
+          secretariatStatus: Type14.Unknown({
+            description: "converged | escalate"
+          }),
+          ticketNumber: Type14.Optional(
+            Type14.Unknown({ description: "\u672C\u7968\u53F7\uFF1B\u7F72\u65F6\u6307\u5411\u6700\u7EC8\u6B63\u6587\u6240\u5728\u7968" })
+          ),
+          note: Type14.Unknown({ description: "\u9644\u6CE8" }),
+          evidence: Type14.Optional(Type14.Unknown({ description: "\u7559\u5B58\u8BC1\u636E" })),
+          decisionGate: Type14.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";
   }
@@ -1740,6 +1828,9 @@ ${serializeReceipt(result.submission)}`;
   }
   return `\u95E8\u4E0B\u7701 ${result.status}\uFF08${result.stage}\uFF09\uFF1A${result.reason}`;
 }
+function isOneShotWorkerReminderCode(code) {
+  return code === "worker_commit_reminder" || code === "worker_prefix_reminder";
+}
 function unreadableDiscriminatorNotice(field, received) {
   if (received === void 0) return `\u8BFB\u4E0D\u51FA ${field}`;
   return `\u8BFB\u4E0D\u51FA ${field}\uFF1A${readableGateItem(received)}`;
@@ -1780,7 +1871,7 @@ var init_submission_errors = __esm({
     WorkerUnfinishedReasonReminderError = class extends Error {
       code = "worker_unfinished_reason_reminder";
       constructor() {
-        super("\u672C\u6B21 unfinished \u56DE\u6267\u672A\u542B reason\uFF1B\u672C\u63A5\u7F1D\u7F3A\u7531\u81F3\u591A\u6253\u56DE\u4E24\u6B21\u3002");
+        super("\u672C\u6B21 unfinished \u56DE\u6267\u672A\u542B reason\uFF1B\u8BF7\u8865\u4E0A reason \u540E\u518D\u4EA4\u3002");
         this.name = "WorkerUnfinishedReasonReminderError";
       }
     };
@@ -2438,6 +2529,23 @@ function markerMatchesExpectedIdentity(marker, expected) {
   }
   return true;
 }
+function packagedRoleOutputRejectionReason(message) {
+  if (typeof message.toolName !== "string") return void 0;
+  if (!PACKAGED_ROLE_OUTPUT_TOOLS.has(message.toolName) && message.toolName !== "ak_submission_output") {
+    return void 0;
+  }
+  if (message.isError !== true) return void 0;
+  if (classifyPackagedRoleTerminalResult(message).kind !== "nonterminal") return void 0;
+  const content = message.content;
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+      return part.text;
+    }
+    return "";
+  }).join("").trim();
+}
 function classifyPackagedRoleTerminalResult(message) {
   if (typeof message.toolName !== "string") return { kind: "nonterminal" };
   if (!PACKAGED_ROLE_OUTPUT_TOOLS.has(message.toolName) && message.toolName !== "ak_submission_output") return { kind: "nonterminal" };
@@ -3879,7 +3987,7 @@ __export(auditor_dossier_tool_exports, {
   createAuditorDossierTool: () => createAuditorDossierTool
 });
 import { dirname as dirname8, join as join12, resolve as resolve6 } from "node:path";
-import { Type as Type11 } from "typebox";
+import { Type as Type16 } from "typebox";
 function auditorRunDirectory(context) {
   const sessionFile = context.sessionManager?.getSessionFile?.();
   if (sessionFile === void 0) return void 0;
@@ -3891,7 +3999,7 @@ function createAuditorDossierTool(runDirectory) {
     description: "\u5B9A\u4F4D\u672C\u5BA1\u8BA1\u5E2D\u7ED1\u5B9A\u7684 run \u5377\u5B97\u53CA\u5176\u8BC1\u636E\u5165\u53E3\u3002",
     // #836 r16 class 3: execute() ignores `_params` entirely — a closed root
     // only rejects the role for saying more.
-    parameters: Type11.Object({}, { additionalProperties: true }),
+    parameters: Type16.Object({}, { additionalProperties: true }),
     async execute(_id, _params) {
       if (runDirectory === void 0) {
         return {
@@ -3922,6 +4030,161 @@ var init_auditor_dossier_tool = __esm({
   }
 });
 
+// src/collector-tool-schemas.ts
+import { Type as Type17 } from "typebox";
+var collectorOutputBaseSchema, collectorOutputArgsSchema;
+var init_collector_tool_schemas = __esm({
+  "src/collector-tool-schemas.ts"() {
+    "use strict";
+    init_open_tool_schema();
+    init_terminating_infrastructure();
+    collectorOutputBaseSchema = openToolObject(
+      Type17.Object({
+        groups: Type17.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: Type17.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, {
@@ -4108,7 +4371,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 };
@@ -4261,6 +4524,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();
@@ -4271,13 +4535,7 @@ var init_gatekeeper_role = __esm({
       countersign_verdict: "notary",
       secretariat_verdict: "countersign"
     };
-    GATEKEEPER_TOOL_SPEC = {
-      name: GATEKEEPER_OUTPUT_TOOL_NAME,
-      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
-    };
+    GATEKEEPER_TOOL_SPEC = roleSubmissionDeclaration("gatekeeper");
   }
 });
 
@@ -4315,6 +4573,13 @@ function formatTerminalResult(result) {
       `diagnostic	${encodeTerminalField(result.roleOutcome.diagnostic)}`
     );
   }
+  if (result.roleOutcome.kind === "accepted" && result.roleOutcome.decisiveFacts?.directionUnsettled === true) {
+    lines.push("fact	directionUnsettled	true");
+    const subsequent = result.roleOutcome.decisiveFacts.subsequentAudit;
+    if (typeof subsequent === "string") {
+      lines.push(`fact	subsequentAudit	${encodeTerminalField(subsequent)}`);
+    }
+  }
   if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation" || result.roleOutcome.decisiveFacts?.failedAttempts !== void 0) {
     const facts = result.roleOutcome.kind === "accepted" ? { failedAttempts: result.roleOutcome.decisiveFacts?.failedAttempts } : result.roleOutcome.decisiveFacts ?? {};
     for (const [key, value] of Object.entries(facts)) {
@@ -4373,7 +4638,7 @@ function formatTerminalResult(result) {
       lines.push(`recorded-submission	${encodeTerminalField(rendered)}`);
     }
   } else {
-    const payloads = result.roleOutcome.kind === "accepted" || result.roleOutcome.kind === "audit_escalation" ? coalesceSubmissionRows(result.roleOutcome.payloads, result.submissions) : result.submissions ?? [];
+    const payloads = result.roleOutcome.kind === "accepted" || result.roleOutcome.kind === "audit_escalation" ? coalesceSubmissionRows(result.submissions, result.roleOutcome.payloads) : result.submissions ?? [];
     for (let i = payloads.length - 1; i >= 0; i -= 1) {
       const payload = payloads[i];
       const rendered = typeof payload === "string" ? payload : JSON.stringify(payload);
@@ -4389,87 +4654,311 @@ var init_terminal = __esm({
   }
 });
 
-// src/session-assistant-usage.ts
-var session_assistant_usage_exports = {};
-__export(session_assistant_usage_exports, {
-  readAssistantUsageFromSessionFile: () => readAssistantUsageFromSessionFile,
-  sessionFileFromPublicSummon: () => sessionFileFromPublicSummon,
-  usageFromPublicSummon: () => usageFromPublicSummon
-});
-import { join as join14 } from "node:path";
-async function readAssistantUsageFromSessionFile(sessionFile) {
-  const { readFile: readFile25 } = await import("node:fs/promises");
-  let text;
-  try {
-    text = await readFile25(sessionFile, "utf8");
-  } catch (error) {
-    if (error?.code === "ENOENT") return void 0;
-    throw error;
-  }
-  let rows;
-  try {
-    rows = text.trim().split("\n").filter(Boolean).map((line2) => JSON.parse(line2));
-  } catch (error) {
-    throw new Error(
-      `session usage parse failed (${sessionFile}): ${errorText(error)}`,
-      { cause: error }
-    );
+// src/receipt-delivery-policy.ts
+function receiptAttemptPointer(runPointer, invocationScopeId) {
+  const scope = invocationScopeId?.trim() ?? "";
+  if (scope.length > 0) return `invocation:${scope}`;
+  return `current:${runPointer}`;
+}
+function deliveryLimitFromConfig(value) {
+  return parseAutoResumeLimit(value ?? AUTO_RESUME_LIMIT);
+}
+function deliveryLimitFromEnv(env) {
+  const raw = env[RECEIPT_DELIVERY_LIMIT_ENV];
+  if (raw === void 0 || raw.trim() === "") return deliveryLimitFromConfig(void 0);
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed)) return deliveryLimitFromConfig(void 0);
+  return deliveryLimitFromConfig(parsed);
+}
+function deliveryTurnsFact(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new TypeError("deliveryTurns must be a non-negative integer");
   }
-  let total = 0;
-  let input = 0;
-  let output = 0;
-  let cacheRead = 0;
-  let cacheWrite = 0;
-  let costInput = 0;
-  let costOutput = 0;
-  let costCacheRead = 0;
-  let costCacheWrite = 0;
-  let costTotal = 0;
-  let sawCost = false;
-  for (const row of rows) {
-    if (row.type !== "message" || row.message?.role !== "assistant") continue;
-    const usage = row.message.usage;
-    if (usage === void 0) continue;
-    total += usage.totalTokens ?? 0;
-    input += usage.input ?? 0;
-    output += usage.output ?? 0;
-    cacheRead += usage.cacheRead ?? 0;
-    cacheWrite += usage.cacheWrite ?? 0;
-    if (usage.cost !== void 0) {
-      sawCost = true;
-      costInput += usage.cost.input ?? 0;
-      costOutput += usage.cost.output ?? 0;
-      costCacheRead += usage.cost.cacheRead ?? 0;
-      costCacheWrite += usage.cost.cacheWrite ?? 0;
-      costTotal += usage.cost.total ?? 0;
-    }
+  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");
   }
-  if (total <= 0 && input <= 0 && output <= 0) return void 0;
-  const base = {
-    input,
-    output,
-    cacheRead,
-    cacheWrite,
-    totalTokens: total > 0 ? total : input + output + cacheRead + cacheWrite
+  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
   };
-  if (!sawCost) return base;
+}
+function noReceiptLifecycleFacts(input) {
   return {
-    ...base,
-    cost: {
-      input: costInput,
-      output: costOutput,
-      cacheRead: costCacheRead,
-      cacheWrite: costCacheWrite,
-      total: costTotal
-    }
+    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 sessionFileFromPublicSummon(summoned) {
-  if (typeof summoned.runDirectory === "string" && summoned.runDirectory.trim() !== "") {
-    return join14(summoned.runDirectory, "session", "session.jsonl");
-  }
-  const fromArtifacts = summoned.terminal?.artifacts?.map((a) => a.path).find((p) => typeof p === "string" && p.endsWith("session.jsonl"));
-  if (fromArtifacts !== void 0) return fromArtifacts;
+function createReceiptDeliveryPolicy(limit) {
+  const deliveryLimit = deliveryLimitFromConfig(limit);
+  let accepted = false;
+  let closed = false;
+  let terminalToolCalled = false;
+  let deliveryTurns = 0;
+  let budgetSpent = 0;
+  const rejectedReceipts = [];
+  const spend = () => {
+    if (budgetSpent < deliveryLimit) budgetSpent += 1;
+  };
+  return {
+    /** The effective ceiling this budget spends (#1132 — never re-read). */
+    limit: deliveryLimit,
+    recordAccepted() {
+      accepted = true;
+      terminalToolCalled = true;
+    },
+    /** Infrastructure owns terminality and must never trigger receipt催交. */
+    stopForInfrastructure() {
+      accepted = true;
+    },
+    /**
+     * Record the rejection this turn already produced.
+     * The fact does not spend a budget. The seam that sends the next prompt
+     * owns that count.
+     */
+    recordRejected(reason) {
+      terminalToolCalled = true;
+      rejectedReceipts.push({ reason, diagnosticAvailable: reason.trim() !== "" });
+    },
+    recordDeliveryRequest() {
+      deliveryTurns += 1;
+      spend();
+    },
+    /**
+     * Stop asking. The issued count stays whatever was actually sent (#1132 —
+     * do not fill the remainder up to the ceiling).
+     */
+    closeBudget() {
+      closed = true;
+    },
+    /**
+     * A nested session settled without an accepted receipt. Close so this layer
+     * does not open another prompt on that session. The issued count stays the
+     * larger of the two seams: a nested zero must not wipe prompts this layer
+     * already sent, and adding the two counts would bill one send twice.
+     */
+    recordNestedNoReceipt(facts) {
+      terminalToolCalled = terminalToolCalled || facts.terminalToolCalled;
+      rejectedReceipts.push(...facts.rejectedReceipts);
+      deliveryTurns = Math.max(deliveryTurns, facts.deliveryTurns);
+      closed = true;
+    },
+    nextAction() {
+      if (accepted) return "accepted";
+      if (closed) return "no-receipt";
+      return budgetSpent < deliveryLimit ? "request-delivery" : "no-receipt";
+    },
+    /** Delivery requests actually issued so far (#1132). */
+    issuedDeliveryRequests() {
+      return deliveryTurns;
+    },
+    /** Current typed delivery facts. No prose. */
+    deliveryState() {
+      return {
+        terminalToolCalled,
+        rejectedReceipts: rejectedReceipts.map((item) => ({ ...item })),
+        deliveryTurns,
+        acceptedReceipt: false
+      };
+    },
+    facts(binding) {
+      return noReceiptLifecycleFacts({ terminalToolCalled, rejectedReceipts: [...rejectedReceipts], deliveryTurns, ...binding });
+    },
+    /**
+     * Continue a public call after the in-memory policy was rebuilt.
+     * Sends already issued spend the same budget; copied rejections keep
+     * the fact and do not spend again.
+     */
+    continueIssued(prior) {
+      for (const receipt of prior.rejectedReceipts) {
+        this.recordRejected(receipt.reason);
+      }
+      if (prior.terminalToolCalled === true) terminalToolCalled = true;
+      for (let index = 0; index < prior.deliveryTurns; index += 1) {
+        this.recordDeliveryRequest();
+      }
+    }
+  };
+}
+function entryRecord(entry) {
+  return isRecord(entry) ? entry : void 0;
+}
+function customTypeOf(record, message) {
+  return record.customType ?? message?.customType;
+}
+function dataOf(record, message) {
+  return record.data ?? message?.details;
+}
+function scopeTag(record) {
+  const message = isRecord(record.message) ? record.message : void 0;
+  const customType = customTypeOf(record, message);
+  const data = dataOf(record, message);
+  if ((customType === RECEIPT_DELIVERY_REQUEST_ENTRY || customType === RECEIPT_REJECTION_ENTRY) && isRecord(data) && typeof data.invocationScopeId === "string" && data.invocationScopeId.trim() !== "") {
+    return data.invocationScopeId;
+  }
+  if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) return void 0;
+  try {
+    const facts = parseNoReceiptLifecycleFacts(data);
+    const prefix = "invocation:";
+    if (!facts.attemptPointer.startsWith(prefix)) return void 0;
+    const scope = facts.attemptPointer.slice(prefix.length);
+    return scope.trim() === "" ? void 0 : scope;
+  } catch {
+    return void 0;
+  }
+}
+function priorReceiptContinuation(entries, invocationScopeId) {
+  const pointer = receiptAttemptPointer("", invocationScopeId);
+  let entryTurns = 0;
+  let factTurns = 0;
+  let rejectedReceipts = [];
+  let snapshotTerminal = false;
+  for (const entry of entries) {
+    const record = entryRecord(entry);
+    if (record === void 0) continue;
+    const tagged = scopeTag(record);
+    if (tagged !== void 0) {
+      const message = isRecord(record.message) ? record.message : void 0;
+      const customType = customTypeOf(record, message);
+      if (tagged !== invocationScopeId) continue;
+      if (customType === RECEIPT_DELIVERY_REQUEST_ENTRY) entryTurns += 1;
+      if (customType === RECEIPT_REJECTION_ENTRY) {
+        const data = dataOf(record, message);
+        if (isRecord(data) && typeof data.reason === "string") rejectedReceipts.push({ reason: data.reason });
+      }
+      if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) continue;
+      try {
+        const facts = parseNoReceiptLifecycleFacts(dataOf(record, message));
+        if (facts.attemptPointer !== pointer) continue;
+        factTurns = Math.max(factTurns, facts.deliveryTurns);
+        if (facts.rejectedReceipts.length >= rejectedReceipts.length) {
+          rejectedReceipts = facts.rejectedReceipts.map(({ reason }) => ({ reason }));
+        }
+        snapshotTerminal ||= facts.terminalToolCalled;
+      } catch {
+      }
+      continue;
+    }
+  }
+  return {
+    deliveryTurns: Math.max(entryTurns, factTurns),
+    rejectedReceipts,
+    terminalToolCalled: snapshotTerminal || rejectedReceipts.length > 0
+  };
+}
+var NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_REQUEST_ENTRY, RECEIPT_REJECTION_ENTRY, RECEIPT_DELIVERY_LIMIT_ENV;
+var init_receipt_delivery_policy = __esm({
+  "src/receipt-delivery-policy.ts"() {
+    "use strict";
+    init_run_lifecycle();
+    init_config();
+    init_unknown_value();
+    NO_RECEIPT_LIFECYCLE_ENTRY_TYPE = "ak-no-receipt-lifecycle";
+    RECEIPT_DELIVERY_REQUEST_ENTRY = "ak-receipt-delivery-request";
+    RECEIPT_REJECTION_ENTRY = "ak-receipt-rejection";
+    RECEIPT_DELIVERY_LIMIT_ENV = "AK_ROLE_RECEIPT_DELIVERY_LIMIT";
+  }
+});
+
+// src/session-assistant-usage.ts
+var session_assistant_usage_exports = {};
+__export(session_assistant_usage_exports, {
+  readAssistantUsageFromSessionFile: () => readAssistantUsageFromSessionFile,
+  sessionFileFromPublicSummon: () => sessionFileFromPublicSummon,
+  usageFromPublicSummon: () => usageFromPublicSummon
+});
+import { join as join14 } from "node:path";
+async function readAssistantUsageFromSessionFile(sessionFile) {
+  const { readFile: readFile26 } = await import("node:fs/promises");
+  let text;
+  try {
+    text = await readFile26(sessionFile, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return void 0;
+    throw error;
+  }
+  let rows;
+  try {
+    rows = text.trim().split("\n").filter(Boolean).map((line2) => JSON.parse(line2));
+  } catch (error) {
+    throw new Error(
+      `session usage parse failed (${sessionFile}): ${errorText(error)}`,
+      { cause: error }
+    );
+  }
+  let total = 0;
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheWrite = 0;
+  let costInput = 0;
+  let costOutput = 0;
+  let costCacheRead = 0;
+  let costCacheWrite = 0;
+  let costTotal = 0;
+  let sawCost = false;
+  for (const row of rows) {
+    if (row.type !== "message" || row.message?.role !== "assistant") continue;
+    const usage = row.message.usage;
+    if (usage === void 0) continue;
+    total += usage.totalTokens ?? 0;
+    input += usage.input ?? 0;
+    output += usage.output ?? 0;
+    cacheRead += usage.cacheRead ?? 0;
+    cacheWrite += usage.cacheWrite ?? 0;
+    if (usage.cost !== void 0) {
+      sawCost = true;
+      costInput += usage.cost.input ?? 0;
+      costOutput += usage.cost.output ?? 0;
+      costCacheRead += usage.cost.cacheRead ?? 0;
+      costCacheWrite += usage.cost.cacheWrite ?? 0;
+      costTotal += usage.cost.total ?? 0;
+    }
+  }
+  if (total <= 0 && input <= 0 && output <= 0) return void 0;
+  const base = {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    totalTokens: total > 0 ? total : input + output + cacheRead + cacheWrite
+  };
+  if (!sawCost) return base;
+  return {
+    ...base,
+    cost: {
+      input: costInput,
+      output: costOutput,
+      cacheRead: costCacheRead,
+      cacheWrite: costCacheWrite,
+      total: costTotal
+    }
+  };
+}
+function sessionFileFromPublicSummon(summoned) {
+  if (typeof summoned.runDirectory === "string" && summoned.runDirectory.trim() !== "") {
+    return join14(summoned.runDirectory, "session", "session.jsonl");
+  }
+  const fromArtifacts = summoned.terminal?.artifacts?.map((a) => a.path).find((p) => typeof p === "string" && p.endsWith("session.jsonl"));
+  if (fromArtifacts !== void 0) return fromArtifacts;
   const outcome = summoned.terminal?.roleOutcome;
   if (outcome === void 0) return void 0;
   const facts = outcome.decisiveFacts;
@@ -4906,6 +5395,8 @@ function createPiRoleTurnHost(config) {
       else env.AK_ROLE_INVOCATION_SCOPE = request.invocationScopeId;
       if (request.host === void 0 || request.host.trim() === "") delete env.AK_ROLE_HOST;
       else env.AK_ROLE_HOST = request.host.trim();
+      if (request.deliveryRequestLimit === void 0) delete env[RECEIPT_DELIVERY_LIMIT_ENV];
+      else env[RECEIPT_DELIVERY_LIMIT_ENV] = String(request.deliveryRequestLimit);
       applyEngineChildEnv(env, request.engine);
       if (typeof process.env.AK_ROLE_AUDITOR_SOURCE_RUN === "string" && process.env.AK_ROLE_AUDITOR_SOURCE_RUN.trim() !== "") {
         env.AK_ROLE_AUDITOR_SOURCE_RUN = process.env.AK_ROLE_AUDITOR_SOURCE_RUN;
@@ -4965,6 +5456,7 @@ var init_role_turn_host = __esm({
     init_engine_detour();
     init_role_activation_flags();
     init_user_dialogue_stdin();
+    init_receipt_delivery_policy();
     init_sitian_facade();
     INTERNAL_ROLE_ENTRYPOINT_RELATIVE2 = "extensions/role-runtime.ts";
     EXPLICIT_INTERNAL_LOAD_PROBE_ARGS = [
@@ -9046,10 +9538,10 @@ function pairGateRounds(volumes) {
   return rounds.sort((a, b) => a.officerStartedAt.localeCompare(b.officerStartedAt)).map((round, index) => ({ ...round, roundIndex: index + 1 }));
 }
 async function resolveOfficerSessionFromPointerFile(pointerPath) {
-  const { readFile: readFile25 } = await import("node:fs/promises");
+  const { readFile: readFile26 } = await import("node:fs/promises");
   let raw;
   try {
-    raw = JSON.parse(await readFile25(pointerPath, "utf8"));
+    raw = JSON.parse(await readFile26(pointerPath, "utf8"));
   } catch (error) {
     throw new Error(
       `direct officer run pointer unreadable in ${pointerPath}: ${errorText(error)}`,
@@ -9929,9 +10421,7 @@ function runDirectoryFromSessionDirectory(sessionDirectory) {
 function sessionFileFromSessionDirectory(sessionDirectory) {
   return join26(sessionDirectory, "session.jsonl");
 }
-function mintEngineDetourInvocationScope(input) {
-  const engine = input.effectiveEngine?.trim();
-  if (engine === void 0 || engine.length === 0) return void 0;
+function mintEngineDetourInvocationScope(_input) {
   return randomUUID4();
 }
 function withEngineDetourInvocationScope(request, invocationScopeId) {
@@ -10021,101 +10511,6 @@ var init_dossier_resolution = __esm({
   }
 });
 
-// src/receipt-delivery-policy.ts
-function parseNoReceiptLifecycleFacts(input) {
-  if (!isRecord(input) || typeof input.terminalToolCalled !== "boolean" || input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT || input.sessionCompletion !== "settled-without-accepted-receipt" || input.acceptedReceipt !== false || typeof input.runPointer !== "string" || input.runPointer.trim() === "" || typeof input.attemptPointer !== "string" || input.attemptPointer.trim() === "" || !Array.isArray(input.rejectedReceipts) || !input.rejectedReceipts.every((item) => isRecord(item) && typeof item.reason === "string")) {
-    throw new TypeError("malformed no-receipt lifecycle facts");
-  }
-  return {
-    terminalToolCalled: input.terminalToolCalled,
-    rejectedReceipts: input.rejectedReceipts.map((item) => ({
-      reason: item.reason,
-      diagnosticAvailable: item.reason.trim() !== ""
-    })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
-    sessionCompletion: "settled-without-accepted-receipt",
-    runPointer: input.runPointer,
-    attemptPointer: input.attemptPointer,
-    acceptedReceipt: false
-  };
-}
-function noReceiptLifecycleFacts(input) {
-  if (input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT) {
-    throw new TypeError("no-receipt lifecycle requires an exhausted delivery budget");
-  }
-  return {
-    terminalToolCalled: input.terminalToolCalled,
-    rejectedReceipts: input.rejectedReceipts.map(({ reason }) => ({
-      reason,
-      diagnosticAvailable: reason.trim() !== ""
-    })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
-    sessionCompletion: "settled-without-accepted-receipt",
-    runPointer: input.runPointer,
-    attemptPointer: input.attemptPointer,
-    acceptedReceipt: false
-  };
-}
-function createReceiptDeliveryPolicy() {
-  let accepted = false;
-  let terminalToolCalled = false;
-  let deliveryTurns = 0;
-  const rejectedReceipts = [];
-  return {
-    recordAccepted() {
-      accepted = true;
-      terminalToolCalled = true;
-    },
-    /** Infrastructure owns terminality and must never trigger receipt催交. */
-    stopForInfrastructure() {
-      accepted = true;
-    },
-    recordRejected(reason) {
-      terminalToolCalled = true;
-      rejectedReceipts.push({ reason, diagnosticAvailable: reason.trim() !== "" });
-      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
-    },
-    recordDeliveryRequest() {
-      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
-    },
-    /**
-     * A nested session settled without an accepted receipt after spending its own
-     * delivery budget. Adopt its facts and close this budget: another prompt would
-     * open an independent session, not a delivery request on the settled one.
-     */
-    recordNestedNoReceipt(facts) {
-      terminalToolCalled = terminalToolCalled || facts.terminalToolCalled;
-      rejectedReceipts.push(...facts.rejectedReceipts);
-      deliveryTurns = RECEIPT_DELIVERY_TURN_LIMIT;
-    },
-    nextAction() {
-      if (accepted) return "accepted";
-      return deliveryTurns < RECEIPT_DELIVERY_TURN_LIMIT ? "request-delivery" : "no-receipt";
-    },
-    /** Current typed delivery facts. No prose. */
-    deliveryState() {
-      return {
-        terminalToolCalled,
-        rejectedReceipts: rejectedReceipts.map((item) => ({ ...item })),
-        deliveryTurns,
-        acceptedReceipt: false
-      };
-    },
-    facts(binding) {
-      return noReceiptLifecycleFacts({ terminalToolCalled, rejectedReceipts: [...rejectedReceipts], deliveryTurns, ...binding });
-    }
-  };
-}
-var RECEIPT_DELIVERY_TURN_LIMIT, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE;
-var init_receipt_delivery_policy = __esm({
-  "src/receipt-delivery-policy.ts"() {
-    "use strict";
-    init_unknown_value();
-    RECEIPT_DELIVERY_TURN_LIMIT = 2;
-    NO_RECEIPT_LIFECYCLE_ENTRY_TYPE = "ak-no-receipt-lifecycle";
-  }
-});
-
 // src/public-cli/settlement.ts
 var settlement_exports = {};
 __export(settlement_exports, {
@@ -10258,13 +10653,76 @@ async function attachRecordedSubmissions(admitted, terminal, scope) {
   if (errorPath !== void 0) privateFailureErrorPaths.set(result, errorPath);
   return result;
 }
-async function settleHostEndedNoReceipt(admitted, authority, scope) {
+function lifecycleFactsFromEntry(entry) {
+  const customType = entry.customType ?? entry.message?.customType;
+  if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) return void 0;
+  return entry.data ?? entry.message?.details;
+}
+async function readCurrentAttemptNoReceiptFacts(admitted, authority, scope) {
+  const { sessionFile } = coordinatesFromAdmitted(authority, admitted);
+  const entries = await readBoundSessionEntries(sessionFile).catch(() => void 0);
+  if (entries === void 0) return void 0;
+  const scopeId = scope?.invocationScopeId?.trim() ?? "";
+  if (scopeId.length > 0) {
+    const pointer = receiptAttemptPointer(admitted.runDirectory, scopeId);
+    let selected;
+    for (const entry of entries) {
+      const raw2 = lifecycleFactsFromEntry(entry);
+      if (raw2 === void 0) continue;
+      try {
+        const facts2 = parseNoReceiptLifecycleFacts(raw2);
+        if (facts2.runPointer !== admitted.runDirectory) continue;
+        if (facts2.attemptPointer !== pointer) continue;
+        if (selected === void 0 || facts2.deliveryTurns >= selected.deliveryTurns) {
+          selected = facts2;
+        }
+      } catch {
+      }
+    }
+    return selected;
+  }
+  let attemptStart = 0;
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    if (entries[index]?.type === "message" && entries[index]?.message?.role === "user") {
+      attemptStart = index;
+      break;
+    }
+  }
+  const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry) => lifecycleFactsFromEntry(entry) !== void 0);
+  const raw = lifecycleEntry === void 0 ? void 0 : lifecycleFactsFromEntry(lifecycleEntry);
+  if (raw === void 0) return void 0;
+  let facts;
+  try {
+    facts = parseNoReceiptLifecycleFacts(raw);
+  } catch {
+    return void 0;
+  }
+  if (facts.runPointer !== admitted.runDirectory) return void 0;
+  if (facts.attemptPointer !== receiptAttemptPointer(admitted.runDirectory)) return void 0;
+  return facts;
+}
+async function settleHostEndedNoReceipt(admitted, authority, scope, issuedDeliveryRequests = 0) {
+  const scopeId = scope?.invocationScopeId?.trim() ?? "";
+  const persisted = scopeId.length > 0 ? void 0 : await readCurrentAttemptNoReceiptFacts(admitted, authority, scope);
+  let terminalToolCalled = persisted?.terminalToolCalled ?? false;
+  let rejectedReceipts = persisted?.rejectedReceipts ?? [];
+  let recordedTurns = persisted?.deliveryTurns ?? 0;
+  if (scopeId.length > 0) {
+    const { sessionFile } = coordinatesFromAdmitted(authority, admitted);
+    const entries = await readBoundSessionEntries(sessionFile).catch(() => void 0);
+    if (entries !== void 0) {
+      const prior = priorReceiptContinuation(entries, scopeId);
+      terminalToolCalled = prior.terminalToolCalled;
+      rejectedReceipts = prior.rejectedReceipts;
+      recordedTurns = prior.deliveryTurns;
+    }
+  }
   const facts = noReceiptLifecycleFacts({
-    terminalToolCalled: false,
-    rejectedReceipts: [],
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
+    terminalToolCalled,
+    rejectedReceipts,
+    deliveryTurns: Math.max(issuedDeliveryRequests, recordedTurns),
     runPointer: admitted.runDirectory,
-    attemptPointer: `current:${admitted.runDirectory}`
+    attemptPointer: receiptAttemptPointer(admitted.runDirectory, scope?.invocationScopeId)
   });
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   await clearOppositeTerminalArtifactFace(admitted.runDirectory);
@@ -11837,44 +12295,26 @@ async function settleFailureTerminalResult(admitted, failure, authority, options
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
   if (failure.cause === "output") {
-    const entries = await readBoundSessionEntries(sessionFile).catch(() => void 0);
-    if (entries !== void 0) {
-      let attemptStart = 0;
-      for (let index = entries.length - 1; index >= 0; index -= 1) {
-        if (entries[index]?.type === "message" && entries[index]?.message?.role === "user") {
-          attemptStart = index;
-          break;
-        }
-      }
-      const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry) => entry.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE || entry.message?.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE);
-      const raw = lifecycleEntry?.data ?? lifecycleEntry?.message?.details;
-      if (raw !== void 0) {
-        let facts;
-        try {
-          facts = parseNoReceiptLifecycleFacts(raw);
-        } catch {
-        }
-        if (facts !== void 0 && facts.runPointer === admitted.runDirectory && facts.attemptPointer === `current:${admitted.runDirectory}`) {
-          let decisiveFacts2 = facts;
-          await clearOppositeTerminalArtifactFace(admitted.runDirectory);
-          return withOptionalGateProjection(
-            {
-              roleOutcome: {
-                kind: "no_receipt",
-                role: admitted.role,
-                status: "no-accepted-receipt",
-                ...facts,
-                decisiveFacts: decisiveFacts2
-              },
-              navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
-              artifacts: [],
-              runId: admitted.runId
-            },
-            sessionDirectory,
-            detourGateContext(admitted, options)
-          );
-        }
-      }
+    const facts = await readCurrentAttemptNoReceiptFacts(admitted, authority, options);
+    if (facts !== void 0) {
+      const decisiveFacts2 = facts;
+      await clearOppositeTerminalArtifactFace(admitted.runDirectory);
+      return withOptionalGateProjection(
+        {
+          roleOutcome: {
+            kind: "no_receipt",
+            role: admitted.role,
+            status: "no-accepted-receipt",
+            ...facts,
+            decisiveFacts: decisiveFacts2
+          },
+          navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
+          artifacts: [],
+          runId: admitted.runId
+        },
+        sessionDirectory,
+        detourGateContext(admitted, options)
+      );
     }
   }
   const navigator = await extractNavigatorFactFromAdmittedSession(sessionFile);
@@ -12044,16 +12484,19 @@ var init_settlement = __esm({
 
 // src/archivist-record-pointer.ts
 import { mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { readFile as readFile17 } from "node:fs/promises";
 import { dirname as dirname17, join as join28 } from "node:path";
 function bookDirectOfficerRunPointer(options) {
   const nest = join28(dirname17(options.parentSessionFile), "auditor-roles");
   mkdirSync2(nest, { recursive: true });
+  const submissionToolCallId = options.submissionToolCallId?.trim() ?? "";
   const pointer = {
     version: 1,
     kind: DIRECT_OFFICER_RUN_POINTER_KIND,
     officer: options.officer,
     sessionFile: options.sessionFile,
-    ...options.runDirectory !== void 0 && options.runDirectory.trim() !== "" ? { runDirectory: options.runDirectory } : {}
+    ...options.runDirectory !== void 0 && options.runDirectory.trim() !== "" ? { runDirectory: options.runDirectory } : {},
+    ...submissionToolCallId === "" ? {} : { submissionToolCallId }
   };
   writeFileSync(
     join28(nest, `${options.officer}.pointer.json`),
@@ -12063,10 +12506,36 @@ function bookDirectOfficerRunPointer(options) {
   );
   return pointer;
 }
+async function readDirectOfficerRunPointer(parentSessionFile, officer) {
+  try {
+    const raw = JSON.parse(await readFile17(
+      join28(dirname17(parentSessionFile), "auditor-roles", `${officer}.pointer.json`),
+      "utf8"
+    ));
+    if (!isRecord(raw) || raw.kind !== DIRECT_OFFICER_RUN_POINTER_KIND || raw.version !== 1) {
+      return void 0;
+    }
+    if (raw.officer !== officer) return void 0;
+    if (typeof raw.sessionFile !== "string" || raw.sessionFile.trim() === "") return void 0;
+    const runDirectory = typeof raw.runDirectory === "string" && raw.runDirectory.trim() !== "" ? raw.runDirectory : void 0;
+    const submissionToolCallId = typeof raw.submissionToolCallId === "string" && raw.submissionToolCallId.trim() !== "" ? raw.submissionToolCallId : void 0;
+    return {
+      version: 1,
+      kind: DIRECT_OFFICER_RUN_POINTER_KIND,
+      officer,
+      sessionFile: raw.sessionFile,
+      ...runDirectory === void 0 ? {} : { runDirectory },
+      ...submissionToolCallId === void 0 ? {} : { submissionToolCallId }
+    };
+  } catch {
+    return void 0;
+  }
+}
 var DIRECT_OFFICER_RUN_POINTER_KIND;
 var init_archivist_record_pointer = __esm({
   "src/archivist-record-pointer.ts"() {
     "use strict";
+    init_unknown_value();
     DIRECT_OFFICER_RUN_POINTER_KIND = "direct-officer-run-pointer";
   }
 });
@@ -12084,6 +12553,7 @@ function createPiDoctorAuditor() {
       submission: options.submission,
       ...auditorRunDirectory(options.context) === void 0 ? {} : { runDirectory: auditorRunDirectory(options.context) },
       ...options.signal === void 0 ? {} : { signal: options.signal },
+      ...options.autoResumeLimit === void 0 ? {} : { autoResumeLimit: options.autoResumeLimit },
       ...options.summonAuditor === void 0 ? {} : { summonAuditor: options.summonAuditor }
     });
   };
@@ -12098,16 +12568,56 @@ var init_doctor_auditor = __esm({
   }
 });
 
+// src/filed-submission.ts
+function registerFiledSubmissionTool(roleHost, tool, options) {
+  roleHost.registerTool({
+    name: tool.name,
+    label: tool.label,
+    description: tool.description,
+    ...tool.promptSnippet === void 0 ? {} : { promptSnippet: tool.promptSnippet },
+    parameters: tool.parameters,
+    async execute(toolCallId, parameters, signal, _onUpdate, ctx) {
+      const blocked = options.readyError();
+      if (blocked !== void 0) throw new Error(blocked);
+      const projected = options.beforeAccept === void 0 ? void 0 : await options.beforeAccept({ toolCallId, parameters, signal, ctx });
+      return {
+        content: [],
+        details: projected === void 0 ? parameters : projected,
+        terminate: true
+      };
+    }
+  });
+}
+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,
@@ -12128,16 +12638,8 @@ function createJudgeRoleRuntime(pi, dependencies) {
       if (soul.length === 0) throw new Error("Judge soul is empty");
       if (!lifecycleRegistered) {
         lifecycleRegistered = true;
-        pi.registerTool({
-          name: JUDGE_OUTPUT_TOOL_NAME,
-          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: judgeVerdictSchema,
-          async execute(toolCallId, parameters, signal, _onUpdate, ctx) {
-            if (soul === void 0) throw new Error("\u5927\u7406\u5BFA\u804C\u5206\u672A\u88C5\u8F7D");
-            return { content: [], details: parameters, terminate: true };
-          }
+        registerFiledSubmissionTool(pi, roleSubmissionDeclaration("judge"), {
+          readyError: () => soul === void 0 ? "\u5927\u7406\u5BFA\u804C\u5206\u672A\u88C5\u8F7D" : void 0
         });
         pi.on("before_agent_start", (event) => {
           if (soul === void 0) throw new Error("\u5927\u7406\u5BFA\u804C\u5206\u672A\u88C5\u8F7D");
@@ -12153,19 +12655,20 @@ ${soul}
     }
   };
 }
-var JUDGE_GATES, judgeVerdictSchema;
+var JUDGE_GATES;
 var init_judge_role = __esm({
   "src/judge-role.ts"() {
     "use strict";
     init_host_contracts();
     init_review_submission();
+    init_filed_submission();
+    init_role_submission_declarations();
     init_gatekeeper_role();
     init_judge_output();
     JUDGE_GATES = [
       { kind: "judge_draft" },
       { kind: "judge_compliance" }
     ];
-    judgeVerdictSchema = reviewSubmissionSchema;
   }
 });
 
@@ -12188,11 +12691,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;
@@ -12220,7 +12722,7 @@ function createDefaultGateOfficerSummon(options) {
     });
   };
 }
-function bookDirectOfficerPointer(context, officer, result, summoned) {
+function bookDirectOfficerPointer(context, officer, result, summoned, toolCallId) {
   if (result.status !== "converged" && result.status !== "continue" && result.status !== "escalate" && result.status !== "needs_reask" && result.status !== "transport_failure") {
     return;
   }
@@ -12234,11 +12736,14 @@ function bookDirectOfficerPointer(context, officer, result, summoned) {
     parentSessionFile: parentFile,
     officer,
     sessionFile,
-    ...typeof summoned.runDirectory === "string" && summoned.runDirectory.trim() !== "" ? { runDirectory: summoned.runDirectory } : {}
+    ...typeof summoned.runDirectory === "string" && summoned.runDirectory.trim() !== "" ? { runDirectory: summoned.runDirectory } : {},
+    ...toolCallId.trim() === "" ? {} : { submissionToolCallId: toolCallId }
   });
 }
 async function requireSubmissionGate(options) {
   let reask;
+  let reasksSpent = 0;
+  const reaskLimit = deliveryLimitFromConfig(options.autoResumeLimit);
   const summonOfficer = options.summonOfficer ?? createDefaultGateOfficerSummon({
     cwd: options.context.cwd ?? process.cwd()
   });
@@ -12258,7 +12763,8 @@ async function requireSubmissionGate(options) {
           options.context,
           projected.officer,
           gatekeeper,
-          projected.summoned
+          projected.summoned,
+          options.toolCallId
         );
       } catch (error) {
         options.hostActions.failInfrastructure(error, options.context, options.toolCallId);
@@ -12281,6 +12787,17 @@ async function requireSubmissionGate(options) {
       };
     }
     if (gatekeeper.status === "needs_reask") {
+      if (reasksSpent >= reaskLimit) {
+        return {
+          status: "needs_reask",
+          officer: projected.officer,
+          receipt: gatekeeper.receipt,
+          ...typeof gatekeeper.runId === "string" && gatekeeper.runId.trim() !== "" ? { runId: gatekeeper.runId } : {},
+          ...typeof projected.summoned?.runDirectory === "string" && projected.summoned.runDirectory.trim() !== "" ? { runDirectory: projected.summoned.runDirectory } : {},
+          ...projected.summoned?.terminal === void 0 ? {} : { terminal: projected.summoned.terminal }
+        };
+      }
+      reasksSpent += 1;
       reask = officerConclusionReask(gatekeeper.receivedStatus);
       continue;
     }
@@ -12309,6 +12826,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();
   }
@@ -12488,7 +13007,8 @@ function projectRoleTurnRequest(admitted, roleDetails, options) {
     ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
     ...options.courtAttemptId === void 0 || options.courtAttemptId.length === 0 ? {} : { courtAttemptId: options.courtAttemptId },
     ...options.invocationScopeId === void 0 || options.invocationScopeId.length === 0 ? {} : { invocationScopeId: options.invocationScopeId },
-    ...options.stationChild === void 0 ? {} : { stationChild: options.stationChild }
+    ...options.stationChild === void 0 ? {} : { stationChild: options.stationChild },
+    ...options.deliveryRequestLimit === void 0 ? {} : { deliveryRequestLimit: options.deliveryRequestLimit }
   };
 }
 function packagedSettleSkill(admitted) {
@@ -12566,7 +13086,7 @@ var init_turn_request = __esm({
 });
 
 // src/session-identity.ts
-import { mkdir as mkdir3, readFile as readFile17, rename as rename3, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile18, rename as rename3, writeFile as writeFile6 } from "node:fs/promises";
 import { dirname as dirname18, join as join30 } from "node:path";
 function createSessionIdentityAuthority(authority, sessionBindingFile) {
   const bindingPath = (principal) => join30(authority.decode(principal).sessionDirectory, sessionBindingFile);
@@ -12576,7 +13096,7 @@ function createSessionIdentityAuthority(authority, sessionBindingFile) {
     },
     async load(principal) {
       try {
-        const value = JSON.parse(await readFile17(bindingPath(principal), "utf8"));
+        const value = JSON.parse(await readFile18(bindingPath(principal), "utf8"));
         if (typeof value !== "object" || value === null || typeof value.sessionId !== "string") {
           throw new Error("durable session binding is invalid");
         }
@@ -13412,8 +13932,203 @@ async function settleDeferredPersist(admitted, authority, adapters, io, result)
       io,
       true
     );
-    return { ...failed, turnDispatched: true, skipAutoResume: true };
+    return {
+      ...failed,
+      turnDispatched: true,
+      skipAutoResume: true
+    };
+  }
+}
+function settlementScopeForTurn(request) {
+  const hasCourt = request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0;
+  const hasScope = request.invocationScopeId !== void 0 && request.invocationScopeId.length > 0;
+  if (!hasCourt && !hasScope) return void 0;
+  return {
+    ...hasCourt ? { courtAttemptId: request.courtAttemptId } : {},
+    ...hasScope ? { invocationScopeId: request.invocationScopeId } : {}
+  };
+}
+async function buildReceiptDeliveryRequest(input) {
+  const { admitted, env, request, receiptDelivery } = input;
+  const hostSessionId = await readStoredHostSessionId(
+    env.host,
+    env.principalAuthority,
+    admitted.principal
+  );
+  return {
+    ...request,
+    continuation: {
+      kind: "resume",
+      prompt: JSON.stringify({
+        ...receiptDelivery.deliveryState(),
+        deliveryTurns: receiptDelivery.issuedDeliveryRequests() + 1
+      }),
+      ...hostSessionId === void 0 ? {} : { hostSessionId }
+    },
+    deliveryRequestLimit: receiptDelivery.limit
+  };
+}
+async function settleCompletedHostTurn(input) {
+  const { admitted, env, io, adapters, shouldPresent, request, result, persistRunState, deferredPersist } = input;
+  const finishAfterTurn = input.finishAfterTurn;
+  let stderrLogWriteFailure;
+  try {
+    await writeFile7(
+      join33(admitted.runDirectory, "stderr.log"),
+      result.stderr,
+      "utf8"
+    );
+  } catch (error) {
+    stderrLogWriteFailure = error;
+    await recordBestEffortPostDispatchDiagnostic(
+      admitted,
+      env,
+      `stderr.log write failed (best-effort continue): ${describeErrorIdentity(error)}`,
+      io
+    );
+  }
+  const courtScope = settlementScopeForTurn(request);
+  let settled;
+  let settledOutcome;
+  let hostSignalFailed = false;
+  let resolution;
+  try {
+    const sessionFile = admitted.principal !== void 0 ? env.principalAuthority.decode(admitted.principal).sessionFile : "";
+    const runnerKnownFailure = adapters.resolveRunnerKnownFailure !== void 0 && sessionFile !== "" ? await adapters.resolveRunnerKnownFailure({ result, sessionFile }) : result.knownFailure;
+    resolution = await resolveAuditedRunnerFailureResolution({
+      runner: runnerKnownFailure,
+      sessionFile,
+      credential: void 0,
+      runDirectory: admitted.runDirectory
+    });
+    const processCancelName = processCancelSignalName(env.signal);
+    const directHostFailureSignal = result.timedOut || result.knownFailure !== void 0 || runnerKnownFailure !== void 0 || processCancelName !== void 0;
+    hostSignalFailed = directHostFailureSignal || result.code !== null && result.code !== 0 || resolution.knownFailure !== void 0;
+    settled = await adapters.trySettle(admitted, env.principalAuthority, courtScope);
+    if (settled !== void 0) {
+      settled = await attachRecordedSubmissions(admitted, settled, courtScope);
+    }
+    const settledIsFreshThisAttempt = settled === void 0 || settled.roleOutcome.kind !== "accepted" && settled.roleOutcome.kind !== "audit_escalation" ? true : await attemptProducedFreshSubmission(admitted, courtScope);
+    const staleAcceptanceOutranksRealFailure = !settledIsFreshThisAttempt && hostSignalFailed;
+    const cancelAfterSettle = processCancelSignalName(env.signal);
+    if (settled !== void 0 && shouldPresent(settled) && !directHostFailureSignal && !staleAcceptanceOutranksRealFailure && stderrLogWriteFailure === void 0 && cancelAfterSettle === void 0) {
+      if (settled.roleOutcome.kind === "accepted" && request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0) {
+        try {
+          await clearCurrentCourt(admitted.runDirectory, request.courtAttemptId);
+        } catch (error) {
+          await recordBestEffortPostDispatchDiagnostic(
+            admitted,
+            env,
+            `current-court cleanup failed after accepted settlement (best-effort continue): ${describeErrorIdentity(error)}`,
+            io
+          );
+        }
+      }
+      settledOutcome = {
+        exitCode: exitCodeForTerminalOutcome(settled.roleOutcome),
+        admitted,
+        terminal: settled,
+        turnDispatched: true
+      };
+    }
+  } catch (error) {
+    const settledFailure = await settleAfterTurnStarted(
+      admitted,
+      withEngineDetourInvocationScope({
+        timedOut: false,
+        code: result.code,
+        stderr: result.stderr,
+        thrown: error
+      }, request.invocationScopeId),
+      adapters,
+      env.principalAuthority,
+      io,
+      persistRunState
+    );
+    return { kind: "settled", outcome: await finishAfterTurn({ ...settledFailure, turnDispatched: true, ...deferredPersist }) };
+  }
+  if (settledOutcome !== void 0) {
+    const lateCancel = processCancelSignalName(env.signal);
+    if (lateCancel !== void 0) {
+      return { kind: "settled", outcome: await finishAfterTurn(
+        await settleProcessCancelAfterTurn({
+          admitted,
+          cancelName: lateCancel,
+          result,
+          adapters,
+          env,
+          io,
+          persistRunState,
+          deferredPersist,
+          invocationScopeId: request.invocationScopeId
+        })
+      ) };
+    }
+    if (persistRunState) {
+      try {
+        await persistReturnedRunState(admitted, { lawful: true });
+      } catch (error) {
+        await recordBestEffortPostDispatchDiagnostic(
+          admitted,
+          env,
+          `run-state persistence failed beside host terminal (best-effort continue): ${describeErrorIdentity(error)}`,
+          io
+        );
+      }
+    }
+    return { kind: "settled", outcome: await finishAfterTurn({ ...settledOutcome, ...deferredPersist }) };
+  }
+  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;
@@ -13421,6 +14136,9 @@ async function dispatchPostAdmissionTurn(input) {
   const deferredPersist = persistRunState ? {} : { needsPersist: true };
   const shouldPresent = adapters.shouldPresentSettled ?? ((terminal) => isLawfulTypedTerminalOutcome(terminal.roleOutcome));
   let afterDispatchApplied = false;
+  const receiptDelivery = input.receiptDelivery ?? createReceiptDeliveryPolicy(env.autoResumeLimit);
+  let turnDispatched = false;
+  const akSeamDeliversReceipt = env.host !== void 0 && env.host !== "" && env.host !== DEFAULT_ROLE_TURN_HOST;
   const finishAfterTurn = async (result) => {
     if (afterDispatchApplied) return result;
     afterDispatchApplied = true;
@@ -13518,7 +14236,7 @@ async function dispatchPostAdmissionTurn(input) {
           return { exitCode: 0, admitted, terminal: paused, skipAutoResume: true };
         }
       } catch (error) {
-        const settled2 = await presentControlledFailure2(
+        const settled = await presentControlledFailure2(
           admitted,
           withEngineDetourInvocationScope({
             timedOut: false,
@@ -13531,7 +14249,7 @@ async function dispatchPostAdmissionTurn(input) {
           io,
           persistRunState
         );
-        return { ...settled2, ...deferredPersist };
+        return { ...settled, ...deferredPersist };
       }
     }
     let turnRequest = {
@@ -13555,10 +14273,11 @@ async function dispatchPostAdmissionTurn(input) {
     let result;
     try {
       recordRunStart(admitted.runDirectory);
+      turnDispatched = true;
       result = await env.roleTurnHost.executeTurn(turnRequest);
     } catch (error) {
       const processCancelName = processCancelSignalName(env.signal);
-      const settled2 = await settleAfterTurnStarted(
+      const settled = await settleAfterTurnStarted(
         admitted,
         withEngineDetourInvocationScope({
           timedOut: false,
@@ -13573,175 +14292,111 @@ async function dispatchPostAdmissionTurn(input) {
       );
       return await finishAfterTurn(
         withProcessCancelSkipAutoResume(
-          { ...settled2, turnDispatched: true, ...deferredPersist },
+          { ...settled, turnDispatched: true, ...deferredPersist },
           env.signal
         )
       );
     }
-    let stderrLogWriteFailure;
-    try {
-      await writeFile7(
-        join33(admitted.runDirectory, "stderr.log"),
-        result.stderr,
-        "utf8"
-      );
-    } catch (error) {
-      stderrLogWriteFailure = error;
-      await recordBestEffortPostDispatchDiagnostic(
-        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
-      });
-      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),
+    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,
-          terminal: settled,
-          turnDispatched: true
+          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 }
         };
-      }
-    } 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(
+        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,
-        withEngineDetourInvocationScope({
-          timedOut: false,
-          code: result.code,
-          stderr: result.stderr,
-          thrown: stderrLogWriteFailure
-        }, request.invocationScopeId),
+        env,
+        // Only the final Terminal presents; intermediate delivery attempts stay quiet.
+        io: { ...io, stdout: () => {
+        } },
         adapters,
-        env.principalAuthority,
-        io,
-        persistRunState
-      );
-      return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
+        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
+      });
+      if (deliveryTurn.kind === "settled") {
+        if (persistRunState && deliveryTurn.outcome.terminal !== void 0) {
+          try {
+            await persistReturnedRunState(admitted, {
+              lawful: isLawfulTypedTerminalOutcome(deliveryTurn.outcome.terminal.roleOutcome)
+            });
+          } catch (error) {
+            await recordBestEffortPostDispatchDiagnostic(
+              admitted,
+              env,
+              `run-state persistence failed beside\u50AC\u4EA4 terminal (best-effort continue): ${describeErrorIdentity(error)}`,
+              io
+            );
+          }
+        }
+        return await finishAfterTurn(deliveryTurn.outcome);
+      }
     }
+    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) {
@@ -13778,6 +14433,11 @@ async function dispatchPostAdmissionTurn(input) {
       turnDispatched: true,
       ...deferredPersist
     });
+  } catch (error) {
+    if (turnDispatched && !(error instanceof TurnDispatchedFailure)) {
+      throw new TurnDispatchedFailure(error);
+    }
+    throw error;
   } finally {
     if (lease !== void 0) {
       try {
@@ -13823,7 +14483,9 @@ function resumeTurnRequestProjectionOptions(admitted, request, env, summonsPrepa
       prompt
     },
     ...request.message === void 0 ? {} : { courtAttemptId: randomUUID7() },
-    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild }
+    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild },
+    // #1132: one configured ceiling, already resolved by the caller (#422).
+    deliveryRequestLimit: deliveryLimitFromConfig(env.autoResumeLimit)
   };
 }
 function roleTurnOptions(env, admitted, continuation) {
@@ -13833,7 +14495,9 @@ function roleTurnOptions(env, admitted, continuation) {
     ...env.host === void 0 ? {} : { host: env.host },
     ...correlationId === void 0 || correlationId.trim() === "" ? {} : { correlationId },
     continuation,
-    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild }
+    ...env.stationChild === void 0 ? {} : { stationChild: env.stationChild },
+    // #1132: one configured ceiling, already resolved by the caller (#422).
+    deliveryRequestLimit: deliveryLimitFromConfig(env.autoResumeLimit)
   };
 }
 async function dispatchAfterWriterLease(input) {
@@ -13851,6 +14515,7 @@ async function dispatchAfterWriterLease(input) {
 async function runSettledAutoResumeLoop(input) {
   const adapters = withOnceSuccessfulBeforeDispatch(input.adapters);
   const dispatchEnv = input.dispatchEnv ?? input.env;
+  const receiptDelivery = createReceiptDeliveryPolicy(input.env.autoResumeLimit);
   return runWithAutoResumeLoop({
     admitted: input.admitted,
     principalAuthority: input.env.principalAuthority,
@@ -13872,6 +14537,7 @@ async function runSettledAutoResumeLoop(input) {
           ...lease === void 0 ? {} : { lease },
           adapters,
           persistRunState: false,
+          receiptDelivery,
           ...input.effectiveEngine === void 0 ? {} : { effectiveEngine: input.effectiveEngine }
         });
         return settleDeferredPersist(
@@ -14234,12 +14900,14 @@ var init_post_admission = __esm({
     init_activation_ledger_topology();
     init_engine_material();
     init_session_identity();
+    init_receipt_delivery_policy();
     init_role_run_relocation();
     init_packaged_role_registry();
     init_engine_detour_usage();
     init_run_lifecycle();
     init_process_cancel();
     init_activation_ledger_topology();
+    init_host_descriptions();
     init_host_session_record();
     init_settlement();
     init_terminal();
@@ -14385,15 +15053,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 }
+      }
+    }
+  };
 }
-async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io) {
-  const message = unreadablePostSubmissionStatus(admitted, terminal);
+function heldUnreadableTerminal(terminal) {
+  if (terminal?.roleOutcome.kind !== "accepted") return false;
+  if (latestPayloadEscalated(terminal.roleOutcome)) return false;
+  const status = latestQueueStatus(terminal);
+  return typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status);
+}
+function presentUnsettledAudit(parent, officer, io) {
+  const terminal = withUnsettledDirection(parent, officer);
+  io.stdout(formatTerminalResult(terminal));
+  if (officer !== void 0) io.stdout(formatTerminalResult(officer));
+  return terminal;
+}
+async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io, message = unreadablePostSubmissionStatus(admitted, terminal)) {
   if (message === void 0) return void 0;
+  const next = withUnreadableReask(env);
+  if (next === void 0) return UNREADABLE_REASK_EXHAUSTED;
   return runPublicInstructionSeatResume(
     { runId: admitted.runId, message },
-    { ...env, autoResumeLimit: 0 },
+    next,
     io
   );
 }
@@ -14547,6 +15270,11 @@ async function dispatchAdmitted(admitted, env, io) {
     env,
     io
   );
+  if (isUnreadableReaskExhausted(unreadableReask)) {
+    const terminal = result.terminal === void 0 ? void 0 : withUnsettledDirection(result.terminal);
+    presentOriginalVolume(held, terminal, io);
+    return terminal === void 0 ? result : { ...result, terminal };
+  }
   if (unreadableReask !== void 0) return unreadableReask;
   if (AUDITED_ROLES.has(admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
     return auditSubmittedRole(result, env, io);
@@ -14678,20 +15406,16 @@ async function runCountersignBody(parsed, env, io) {
         await persistAdmittedSourceRunPath(admitted, gateParentRunPath);
         admitted = { ...admitted, sourceRunPath: gateParentRunPath };
       }
-      const turnProjection = {
-        ...projectPublicTurnAxes(env),
-        ...env.correlationId === void 0 || env.correlationId.trim() === "" ? {} : { correlationId: env.correlationId },
-        continuation: {
-          kind: "initial",
-          prompt: env.reviewReask ?? env.gateReviewInstruction ?? buildInstructionTransportPrompt(
-            admitted,
-            engineSessionMaterialFromOptions({
-              ...pickEngineAxis(env),
-              packageRoot: env.packageRoot
-            })
-          )
-        }
-      };
+      const turnProjection = roleTurnOptions(env, admitted, {
+        kind: "initial",
+        prompt: env.reviewReask ?? env.gateReviewInstruction ?? buildInstructionTransportPrompt(
+          admitted,
+          engineSessionMaterialFromOptions({
+            ...pickEngineAxis(env),
+            packageRoot: env.packageRoot
+          })
+        )
+      });
       const turnRequest = buildInstructionSeatTurnRequest(admitted, turnProjection);
       const result = await runPostAdmissionOneShot({
         admitted,
@@ -14960,7 +15684,23 @@ async function runPublicInstructionSeatResume(request, env, io) {
       },
       afterAdmittedLoad: async (admitted) => {
         await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
-        return { kind: "continue", adapters: seatAdapters(admitted, env) };
+        const adapters = seatAdapters(admitted, env);
+        if ((env.unreadableReasksSpent ?? 0) === 0 && env.reviewReask === void 0) {
+          return { kind: "continue", adapters };
+        }
+        const original = await adapters.trySettle(
+          admitted,
+          env.principalAuthority,
+          await readCurrentCourt(admitted.runDirectory)
+        );
+        const unsettled = POST_SUBMISSION_ROUTING[admitted.role] === void 0 ? heldUnreadableTerminal(original) : unreadablePostSubmissionStatus(admitted, original) !== void 0;
+        return {
+          kind: "continue",
+          adapters: original === void 0 || !unsettled ? adapters : {
+            ...adapters,
+            trySettle: async (seat, authority, scope) => await adapters.trySettle(seat, authority, scope) ?? original
+          }
+        };
       },
       ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
     });
@@ -14970,6 +15710,11 @@ async function runPublicInstructionSeatResume(request, env, io) {
       env,
       io
     );
+    if (isUnreadableReaskExhausted(unreadableReask)) {
+      const terminal = result.terminal === void 0 ? void 0 : withUnsettledDirection(result.terminal);
+      presentOriginalVolume(held, terminal, io);
+      return terminal === void 0 ? result : { ...result, terminal };
+    }
     if (unreadableReask !== void 0) return unreadableReask;
     if (result.admitted !== void 0 && AUDITED_ROLES.has(result.admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
       return auditSubmittedRole(result, env, io);
@@ -14995,26 +15740,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 };
@@ -15028,7 +15793,17 @@ async function continueParentAfterChild(parentRunId, child, env, io) {
   }
   const admitted = loaded.admitted;
   const resolved = await queueConclusionFromChild(child, env, io);
-  if (resolved !== void 0 && "stop" in resolved) return resolved.stop;
+  if (resolved !== void 0 && "stop" in resolved) {
+    const stopped = resolved.stop;
+    if (stopped.exitCode === 0 && heldUnreadableTerminal(stopped.terminal) && stopped.terminal !== void 0) {
+      const parentTerminal = await trySettlePublicSeat(admitted, env.principalAuthority, void 0);
+      if (parentTerminal?.roleOutcome.kind === "accepted" || parentTerminal?.roleOutcome.kind === "audit_escalation") {
+        const terminal = presentUnsettledAudit(parentTerminal, stopped.terminal, io);
+        return { exitCode: 0, admitted, terminal };
+      }
+    }
+    return stopped;
+  }
   if (resolved !== void 0 && resolved.status === "escalate") {
     return { exitCode: 0, admitted: resolved.admitted, terminal: resolved.terminal };
   }
@@ -15036,37 +15811,67 @@ async function continueParentAfterChild(parentRunId, child, env, io) {
     if (AUDITED_ROLES.has(admitted.role) && resolved.status === "converged") {
       const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, void 0);
       if (terminal?.roleOutcome.kind !== "accepted") throw new Error("pending submission is not recorded");
-      return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, resolved.admitted.role, latestQueuePayload(resolved.terminal), resolved.admitted.runId);
+      return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, resolved.admitted, latestQueuePayload(resolved.terminal));
     }
     return runPublicInstructionSeatResume({
       runId: parentRunId,
       message: readableGateItem(latestQueuePayload(resolved.terminal))
-    }, { ...env, autoResumeLimit: 0 }, io);
+    }, { ...env, unreadableReasksSpent: 0 }, io);
   }
   const result = await dispatchAdmitted(admitted, env, { ...io, omitFailureStderrDiagnostic: true });
   showResumeErrorPointer(io, result.exitCode, result.terminal);
   return result;
 }
-async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, passedRunId) {
+async function officerPassedCurrentSubmission(input) {
+  const { env, officer } = input;
+  const pointer = await readDirectOfficerRunPointer(input.parentSessionFile, officer);
+  if (pointer?.runDirectory === void 0) return false;
+  if (pointer.submissionToolCallId !== input.toolCallId) return false;
+  const officerRunId = runIdFromRunDirectory(pointer.runDirectory);
+  if (officerRunId === void 0) return false;
+  let admitted;
+  try {
+    const loaded = await loadResumablePublicRole(
+      env.home,
+      officerRunId,
+      env.principalAuthority
+    );
+    admitted = loaded.admitted;
+  } catch {
+    return false;
+  }
+  if (admitted.role !== officer) return false;
+  const court = await readCurrentCourt(admitted.runDirectory);
+  const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, court);
+  return latestQueueStatus(terminal) === "converged";
+}
+async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt) {
   const admitted = turn.admitted;
   if (admitted === void 0 || !AUDITED_ROLES.has(admitted.role) || turn.terminal?.roleOutcome.kind !== "accepted") return turn;
   const accepted = turn.terminal.roleOutcome.payloads?.at(-1);
   if (accepted === void 0) throw new Error("accepted submission has no payload");
   const record = isRecord(accepted) ? accepted : void 0;
   const status = admitted.role === "secretariat" ? record?.secretariatStatus : record?.status;
+  const gateOwnsStatusReask = typeof env.parentRunPath === "string" && env.parentRunPath.trim() !== "";
   if (admitted.role === "secretariat" && status !== "converged" && status !== "escalate") {
-    return runPublicInstructionSeatResume(
-      { runId: admitted.runId, message: SECRETARIAT_STATUS_REASK },
-      { ...env, autoResumeLimit: 0 },
-      io
-    );
+    if (gateOwnsStatusReask) return turn;
+    const next = withUnreadableReask(env);
+    if (next === void 0) {
+      const terminal2 = withUnsettledDirection(turn.terminal);
+      io.stdout(formatTerminalResult(terminal2));
+      return { ...turn, terminal: terminal2 };
+    }
+    return runPublicInstructionSeatResume({ runId: admitted.runId, message: SECRETARIAT_STATUS_REASK }, next, io);
   }
-  if (admitted.role === "countersign" && (typeof status !== "string" || !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));
@@ -15096,12 +15901,19 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
     abort() {
     }
   };
+  const passedThisSubmission = (officer) => officerPassedCurrentSubmission({
+    env,
+    parentSessionFile: sessionFile,
+    officer,
+    toolCallId
+  });
   if (admitted.role === "doctor") {
-    if (passedOfficer !== "auditor") {
+    if (!await passedThisSubmission("auditor")) {
       let lastSummon;
       const decision = await createPiDoctorAuditor()({
         context,
         submission: accepted,
+        ...env.autoResumeLimit === void 0 ? {} : { autoResumeLimit: env.autoResumeLimit },
         ...env.signal === void 0 ? {} : { signal: env.signal },
         summonAuditor: async (subject, sourceRunDirectory, signal, reask, submission) => {
           const summoned = await summonPublicRole({
@@ -15130,6 +15942,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
               parentSessionFile: sessionFile,
               officer: "auditor",
               sessionFile: officerSession,
+              submissionToolCallId: toolCallId,
               ...summoned.runDirectory === void 0 ? {} : { runDirectory: summoned.runDirectory }
             });
           }
@@ -15141,7 +15954,15 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
         return runPublicInstructionSeatResume({
           runId: admitted.runId,
           message: readableGateItem(decision.receipt ?? decision.violations)
-        }, { ...env, autoResumeLimit: 0 }, io);
+        }, { ...env, unreadableReasksSpent: 0 }, io);
+      }
+      if (decision.status === "received") {
+        if (lastSummon?.terminal === void 0) {
+          throw new Error("doctor audit kept an unreadable reply with no terminal");
+        }
+        if (turn.terminal === void 0) throw new Error("doctor submission has no terminal");
+        const terminal2 = presentUnsettledAudit(turn.terminal, lastSummon.terminal, io);
+        return { exitCode: 0, admitted, terminal: terminal2 };
       }
       if (decision.status !== "converged") {
         if (lastSummon?.terminal !== void 0) {
@@ -15164,13 +15985,14 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
       ...env.hostAdapters === void 0 ? {} : { hostAdapters: env.hostAdapters }
     });
     let chain;
-    let officerRunId = passedRunId;
+    let officerRunId = resumedOfficer?.runId;
     const runGate = (subject) => requireSubmissionGate({
       context,
       subject,
       toolCallId,
       submission: accepted,
       summonOfficer,
+      ...env.autoResumeLimit === void 0 ? {} : { autoResumeLimit: env.autoResumeLimit },
       ...env.signal === void 0 ? {} : { signal: env.signal },
       hostActions: {
         failInfrastructure(error) {
@@ -15182,13 +16004,13 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
     });
     if (admitted.role === "judge") {
       chain = await runJudgeGates({
-        gateAlreadyConverged: async (subject) => passedOfficer === "auditor" || passedOfficer === "notary" && subject.kind === "judge_draft",
+        gateAlreadyConverged: async (subject) => passedThisSubmission(gateOfficerForSubject(subject)),
         runGate
       });
     } else {
       const subject = admitted.role === "fixer" || admitted.role === "coder" ? { kind: "worker_completion" } : admitted.role === "secretariat" ? { kind: "secretariat_verdict" } : { kind: "countersign_verdict" };
       const officer = gateOfficerForSubject(subject);
-      if (passedOfficer === officer) {
+      if (await passedThisSubmission(officer)) {
         chain = { status: "converged", passes: [] };
       } else {
         const pass = await runGate(subject);
@@ -15201,17 +16023,29 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
             status: pass.status,
             receipt: pass.receipt,
             ...pass.runId === void 0 ? {} : { runId: pass.runId },
-            ...pass.runDirectory === void 0 ? {} : { runDirectory: pass.runDirectory }
+            ...pass.runDirectory === void 0 ? {} : { runDirectory: pass.runDirectory },
+            ...pass.terminal === void 0 ? {} : { terminal: pass.terminal }
           }]
         };
       }
     }
+    if (chain.status === "needs_reask") {
+      const officerTerminal = chain.passes.at(-1)?.terminal;
+      if (officerTerminal === void 0) throw new Error("unreadable audit has no terminal result");
+      if (turn.terminal === void 0) throw new Error("audited submission has no terminal");
+      const terminal2 = presentUnsettledAudit(turn.terminal, officerTerminal, io);
+      return { exitCode: 0, admitted, terminal: terminal2 };
+    }
     if (chain.status === "escalate") {
       const escalation = chain.passes.at(-1);
       const escalatedRunId = escalation?.runId ?? (escalation?.runDirectory === void 0 ? void 0 : runIdFromRunDirectory(escalation.runDirectory));
       if (escalatedRunId === void 0) throw new Error("escalated audit has no resumable run identity");
       const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority);
-      const terminal2 = await trySettlePublicSeat(officer.admitted, env.principalAuthority, void 0);
+      const terminal2 = await trySettlePublicSeat(
+        officer.admitted,
+        env.principalAuthority,
+        await readCurrentCourt(officer.admitted.runDirectory)
+      );
       if (terminal2 === void 0) throw new Error("escalated audit has no terminal result");
       io.stdout(formatTerminalResult(terminal2));
       return { exitCode: 0, admitted: officer.admitted, terminal: terminal2 };
@@ -15220,7 +16054,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
       return runPublicInstructionSeatResume({
         runId: admitted.runId,
         message: readableGateItem(chain.passes.at(-1)?.receipt)
-      }, { ...env, autoResumeLimit: 0 }, io);
+      }, { ...env, unreadableReasksSpent: 0 }, io);
     }
     if (admitted.role === "secretariat") {
       const pass = chain.passes.at(-1);
@@ -15240,7 +16074,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";
@@ -15249,10 +16083,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();
@@ -15277,7 +16114,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",
@@ -15290,8 +16126,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,
@@ -15312,7 +16147,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"]);
   }
 });
@@ -15352,7 +16187,7 @@ var init_analyst_book_key = __esm({
 });
 
 // src/analyst-index.ts
-import { open as open2, readFile as readFile18, unlink as unlink4 } from "node:fs/promises";
+import { open as open2, readFile as readFile19, unlink as unlink4 } from "node:fs/promises";
 import { dirname as dirname21, join as join34 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 async function withAnalystLibraryIndexLock(ledgerHome, fn) {
@@ -15476,7 +16311,7 @@ async function readAnalystLibraryIndexPage(ledgerHome) {
   const path = analystLibraryIndexPath(ledgerHome);
   let raw;
   try {
-    raw = await readFile18(path, "utf8");
+    raw = await readFile19(path, "utf8");
   } catch (error) {
     if (isMissingPathError(error)) return void 0;
     throw error;
@@ -15679,7 +16514,7 @@ var init_analyst_cohort = __esm({
 });
 
 // src/analyst-ledger.ts
-import { readdir as readdir6, readFile as readFile19 } from "node:fs/promises";
+import { readdir as readdir6, readFile as readFile20 } from "node:fs/promises";
 import { basename as basename9, join as join35 } from "node:path";
 async function readExistingRunLifecycleState(runDirectory) {
   return (await readRoleRunIdentity(runDirectory))?.state;
@@ -15729,7 +16564,7 @@ async function listLedgerBookNames(booksRoot) {
 async function readInvocationScopeFields(runDirectory) {
   let raw;
   try {
-    raw = await readFile19(join35(runDirectory, "invocation.json"), "utf8");
+    raw = await readFile20(join35(runDirectory, "invocation.json"), "utf8");
   } catch (error) {
     if (isMissingPathError(error)) return void 0;
     throw error;
@@ -15762,7 +16597,7 @@ function decideIssueScope(input) {
 }
 async function resolveSessionFile(runDirectory) {
   try {
-    const raw = await readFile19(join35(runDirectory, "invocation.json"), "utf8");
+    const raw = await readFile20(join35(runDirectory, "invocation.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (isRecord(parsed) && typeof parsed.sessionFile === "string" && parsed.sessionFile.trim() !== "") {
       return parsed.sessionFile;
@@ -17022,8 +17857,8 @@ var init_analyst_model_groups = __esm({
 });
 
 // src/analyst-entry.ts
-import { readFile as readFile20 } from "node:fs/promises";
-import { Type as Type12 } from "typebox";
+import { readFile as readFile21 } from "node:fs/promises";
+import { Type as Type18 } from "typebox";
 function cachedPageMatchesRequestedScope(page, input) {
   if (page.bookKey !== input.bookKey) return false;
   const requestedTicket = input.ticketNumber ?? input.issueNumber;
@@ -17050,7 +17885,7 @@ async function readOrComputeAnalystIssuePage(input, options) {
     ...issueNumber === void 0 && input.bookKey === void 0 ? { scopeRootIdentity: projectRoot } : {}
   });
   try {
-    const raw = await readFile20(pagePath, "utf8");
+    const raw = await readFile21(pagePath, "utf8");
     const page = JSON.parse(raw);
     if (cachedPageMatchesRequestedScope(page, { bookKey, ...input })) {
       const ghostScan = await scanAnalystIssueRuns({
@@ -17151,7 +17986,7 @@ async function runAnalystModelGroupsMode(input, home) {
       scopeRootIdentity: projectRoot
     });
     try {
-      const raw = await readFile20(pagePath, "utf8");
+      const raw = await readFile21(pagePath, "utf8");
       JSON.parse(raw);
     } catch (error) {
       if (!isMissingPathError(error)) {
@@ -17228,16 +18063,16 @@ var init_analyst_entry = __esm({
         }
       }
     };
-    analystSweepModeInputSchema = Type12.Object(
+    analystSweepModeInputSchema = Type18.Object(
       {
-        mode: Type12.Literal("sweep"),
-        mergedPullRequests: Type12.Array(
-          Type12.Object(
+        mode: Type18.Literal("sweep"),
+        mergedPullRequests: Type18.Array(
+          Type18.Object(
             {
-              projectRoot: Type12.String(),
+              projectRoot: Type18.String(),
               /** 排除后改动行数 — omit or 0 → typed 空缺; finite ≥ 0 only. */
-              changedLines: Type12.Optional(
-                Type12.Number({ minimum: 0, maximum: Number.MAX_VALUE })
+              changedLines: Type18.Optional(
+                Type18.Number({ minimum: 0, maximum: Number.MAX_VALUE })
               )
             }
           )
@@ -17248,7 +18083,7 @@ var init_analyst_entry = __esm({
 });
 
 // src/public-cli/analyst-run.ts
-import { readFile as readFile21 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 import { isAbsolute as isAbsolute9, resolve as resolve15 } from "node:path";
 import { Value as Value3 } from "typebox/value";
 function resolveAnalystIssueBookKeyFromCwd(cwd = process.cwd()) {
@@ -17302,7 +18137,7 @@ async function buildAnalystSweepModeInputFromAttachmentPaths(attachmentPaths) {
   const absolute = isAbsolute9(sourcePath) ? sourcePath : resolve15(sourcePath);
   let bytes;
   try {
-    bytes = await readFile21(absolute);
+    bytes = await readFile22(absolute);
   } catch (error) {
     throw new CliUsageError(
       `analyst sweep attachment is not a readable regular file: ${sourcePath}`,
@@ -18190,7 +19025,7 @@ async function runAkRole(argv, env) {
         io
       );
       let current = result;
-      while (current.exitCode === 0 && current.admitted?.correlationId !== void 0 && current.terminal?.roleOutcome.kind === "accepted" && !latestPayloadEscalated(current.terminal.roleOutcome)) {
+      while (current.exitCode === 0 && current.admitted?.correlationId !== void 0 && current.terminal?.roleOutcome.kind === "accepted" && current.terminal.roleOutcome.decisiveFacts?.directionUnsettled !== true && !latestPayloadEscalated(current.terminal.roleOutcome)) {
         const parentRunId = current.admitted.correlationId;
         resumeFailureContext = {
           home,
@@ -18936,10 +19771,14 @@ async function runComplianceAudit(options) {
     });
   });
   let reask;
+  let reasksSpent = 0;
+  const reaskLimit = deliveryLimitFromConfig(options.autoResumeLimit);
   for (; ; ) {
     const summoned = await summon(subject, runDirectory, options.signal, reask, submission);
     const decision = await projectAuditorTerminal(summoned);
     if (decision.status === "received") {
+      if (reasksSpent >= reaskLimit) return decision;
+      reasksSpent += 1;
       reask = officerConclusionReask(receivedDiscriminator(decision.reply, "status"));
       continue;
     }
@@ -18955,6 +19794,7 @@ var init_compliance_transport = __esm({
     init_submission_errors();
     init_terminal();
     init_readable_gate_item();
+    init_receipt_delivery_policy();
     init_unknown_value();
     AUDITOR_DOSSIER_PROMPT = "\u5377\u5B97\u6307\u9488\uFF1A";
     AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE = "ak_auditor_parent_attempt_binding";
@@ -19094,7 +19934,7 @@ __export(run_lifecycle_exports, {
   renderResumeCommand: () => renderResumeCommand,
   writeRoleRunState: () => writeRoleRunState
 });
-import { chmod, lstat as lstat6, open as open3, readdir as readdir7, readFile as readFile22, unlink as unlink5, writeFile as writeFile8 } from "node:fs/promises";
+import { chmod, lstat as lstat6, open as open3, readdir as readdir7, readFile as readFile23, unlink as unlink5, writeFile as writeFile8 } from "node:fs/promises";
 import { basename as basename10, join as join39 } from "node:path";
 function buildAutoResumeContinuationPrompt(options) {
   return appendEngineSessionMaterial(
@@ -19171,7 +20011,7 @@ function parseCurrentCourtState(raw) {
 async function readRoleRunStateRaw(runDirectory) {
   let raw;
   try {
-    raw = JSON.parse(await readFile22(join39(runDirectory, RUN_STATE_FILE), "utf8"));
+    raw = JSON.parse(await readFile23(join39(runDirectory, RUN_STATE_FILE), "utf8"));
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
     throw error;
@@ -19429,7 +20269,7 @@ function isProcessAlive(pid) {
 async function autopsyWriterLock(lockPath) {
   let content;
   try {
-    content = await readFile22(lockPath, "utf8");
+    content = await readFile23(lockPath, "utf8");
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return { verdict: "absent" };
     return { verdict: "unknown", reason: "unreadable", readFailure: error };
@@ -19626,7 +20466,7 @@ async function readRunParentPath(runDirectory) {
   let raw;
   try {
     raw = JSON.parse(
-      await readFile22(join39(runDirectory, "admitted-request.json"), "utf8")
+      await readFile23(join39(runDirectory, "admitted-request.json"), "utf8")
     );
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
@@ -19741,7 +20581,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let sourceRun;
   try {
     const raw = JSON.parse(
-      await readFile22(run.admittedRequestPath, "utf8")
+      await readFile23(run.admittedRequestPath, "utf8")
     );
     if (isRecord(raw)) {
       const record = raw;
@@ -19863,7 +20703,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let model;
   try {
     const invocationRaw = JSON.parse(
-      await readFile22(join39(run.runDirectory, "invocation.json"), "utf8")
+      await readFile23(join39(run.runDirectory, "invocation.json"), "utf8")
     );
     if (isRecord(invocationRaw)) {
       const rec = invocationRaw;
@@ -20614,7 +21454,7 @@ init_host_descriptions();
 import { randomUUID as randomUUID11 } from "node:crypto";
 
 // src/role-runtime-dependencies.ts
-import { readFile as readFile24 } from "node:fs/promises";
+import { readFile as readFile25 } from "node:fs/promises";
 init_doctor_evidence();
 
 // src/navigator-attendance.ts
@@ -20623,7 +21463,7 @@ init_packaged_role_registry();
 init_activation_ledger_topology();
 import { resolve as resolve17 } from "node:path";
 import "@earendil-works/pi-coding-agent";
-import { Type as Type13 } from "typebox";
+import { Type as Type19 } from "typebox";
 
 // src/navigator-public-session.ts
 init_sitian_facade();
@@ -20632,7 +21472,7 @@ import { basename as basename11 } from "node:path";
 
 // src/navigator-session-contracts.ts
 init_unknown_value();
-import { Type as Type10 } from "typebox";
+import { Type as Type15 } from "typebox";
 import { Value as Value2 } from "typebox/value";
 var NAVIGATOR_PREPARE_TOOL_NAME = "ak_navigator_prepare";
 var NAVIGATOR_UNAVAILABLE_KEYS = /* @__PURE__ */ new Set([
@@ -20737,26 +21577,26 @@ function navigatorProviderFailureFromPublicTerminal(outcome) {
   if (typed !== void 0) return { source: typed, cause: typed };
   return { source: "unknown", cause: "unknown" };
 }
-var navigatorProviderFailureSchema = Type10.Object({
-  source: Type10.Union([
-    Type10.Literal("context"),
-    Type10.Literal("session"),
-    Type10.Literal("model"),
-    Type10.Literal("thinking"),
-    Type10.Literal("auth"),
-    Type10.Literal("quota"),
-    Type10.Literal("transport"),
-    Type10.Literal("unknown")
+var navigatorProviderFailureSchema = Type15.Object({
+  source: Type15.Union([
+    Type15.Literal("context"),
+    Type15.Literal("session"),
+    Type15.Literal("model"),
+    Type15.Literal("thinking"),
+    Type15.Literal("auth"),
+    Type15.Literal("quota"),
+    Type15.Literal("transport"),
+    Type15.Literal("unknown")
   ]),
-  cause: Type10.Union([
-    Type10.Literal("context"),
-    Type10.Literal("session"),
-    Type10.Literal("model"),
-    Type10.Literal("thinking"),
-    Type10.Literal("auth"),
-    Type10.Literal("quota"),
-    Type10.Literal("transport"),
-    Type10.Literal("unknown")
+  cause: Type15.Union([
+    Type15.Literal("context"),
+    Type15.Literal("session"),
+    Type15.Literal("model"),
+    Type15.Literal("thinking"),
+    Type15.Literal("auth"),
+    Type15.Literal("quota"),
+    Type15.Literal("transport"),
+    Type15.Literal("unknown")
   ])
 }, { additionalProperties: false });
 function parseNavigatorModelSetting(value) {
@@ -21138,8 +21978,8 @@ function resolveNavigatorAuthorityMaterial(roleInput, fileAuthority) {
   return void 0;
 }
 var NAVIGATOR_TARGETS = PACKAGED_ROLE_REGISTRY.map(({ role, phases }) => ({ role, phases }));
-var prepareSchema = Type13.Object({
-  prose: Type13.Optional(Type13.Unknown({
+var prepareSchema = Type19.Object({
+  prose: Type19.Optional(Type19.Unknown({
     description: "\u6E38\u5955\u4F7F\u6563\u6587\u5EFA\u8BAE\uFF0C\u539F\u6837\u5448\u73B0\u3002\u4E0D\u8981\u6C42 candidates/next \u7ED3\u6784\u3002"
   }))
 }, { additionalProperties: true });
@@ -21341,8 +22181,8 @@ function createNavigatorAttendance(options) {
     try {
       try {
         if (disposed) throw navigatorUnavailableError("session", new Error("Navigator attendance was disposed"));
-        const delivery = createReceiptDeliveryPolicy();
-        const promptAllowingRejectedPrepare = async (text, deliveryRequest) => {
+        const delivery = createReceiptDeliveryPolicy(options.deliveryRequestLimit);
+        const promptAllowingRejectedPrepare = async (text) => {
           await persistNavigatorWorkBase(activeSession.recordPointer(), { subject, authority });
           const entryStart = activeSession.entries().length;
           prepareBatchRejected = false;
@@ -21369,17 +22209,15 @@ function createNavigatorAttendance(options) {
             delivery.recordNestedNoReceipt(sessionNoReceipt);
             return;
           }
-          if (deliveryRequest && output === void 0) delivery.recordDeliveryRequest();
         };
-        await promptAllowingRejectedPrepare(request, false);
+        await promptAllowingRejectedPrepare(request);
         if (boundSettlement !== void 0) {
           while (output === void 0 && prepareBatchRejected && delivery.nextAction() === "request-delivery") {
-            await promptAllowingRejectedPrepare(JSON.stringify(delivery.deliveryState()), true);
+            delivery.recordDeliveryRequest();
+            await promptAllowingRejectedPrepare(JSON.stringify(delivery.deliveryState()));
           }
           if (output === void 0 && delivery.nextAction() === "request-delivery") {
-            while (delivery.nextAction() === "request-delivery") {
-              delivery.recordDeliveryRequest();
-            }
+            delivery.closeBudget();
           }
           if (output === void 0 && delivery.nextAction() === "no-receipt" && activeSession.providerFailure?.() === void 0) {
             const facts = delivery.facts({ runPointer: activeSession.recordPointer(), attemptPointer: invocationId });
@@ -21577,7 +22415,7 @@ function createNavigatorAttendance(options) {
 init_doctor_evidence();
 init_unknown_value();
 init_host_contracts();
-import { readFile as readFile23 } from "node:fs/promises";
+import { readFile as readFile24 } from "node:fs/promises";
 import { resolve as resolve18 } from "node:path";
 init_notary_source_run();
 init_packaged_role_registry();
@@ -21591,7 +22429,7 @@ function navigatorInputReference(getFlag, role) {
 async function loadNavigatorWorkContext(options) {
   const reference = navigatorInputReference(options.getFlag, options.role);
   const subjectMode = packagedNavigatorSubject(options.role);
-  const input = reference === void 0 || subjectMode === "case" || subjectMode === "source-run" ? void 0 : await readFile23(reference, "utf8");
+  const input = reference === void 0 || subjectMode === "case" || subjectMode === "source-run" ? void 0 : await readFile24(reference, "utf8");
   const subjectRoot = subjectPath(reference ?? options.context.sessionManager.getSessionDir(), options.context.cwd);
   let subjectKey = reference === void 0 ? subjectRoot : navigatorSubjectKeyForInput(subjectRoot, reference, options.context.cwd);
   let subject = input ?? `work subject: ${subjectKey}`;
@@ -21648,7 +22486,7 @@ async function loadNavigatorWorkContext(options) {
   let authorityMaterial;
   for (const path of authorityFiles) {
     try {
-      const content = await readFile23(path, "utf8");
+      const content = await readFile24(path, "utf8");
       if (content.trim() !== "") {
         authorityMaterial = content;
         break;
@@ -21676,24 +22514,25 @@ init_notary_source_run();
 init_host_contracts();
 init_sitian_facade();
 init_submission_ledger();
+init_filed_submission();
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { readFileSync as readFileSync6, writeSync as writeSync2 } from "node:fs";
 import { join as join43 } from "node:path";
 import { Value as Value4 } from "typebox/value";
 
 // src/activation-trace.ts
-import { Type as Type14 } from "typebox";
-var causeSchema = Type14.Object({
-  identity: Type14.String({ minLength: 1 }),
-  name: Type14.String({ minLength: 1 }),
-  message: Type14.String(),
-  evidenceId: Type14.Optional(Type14.String({ minLength: 1 }))
+import { Type as Type20 } from "typebox";
+var causeSchema = Type20.Object({
+  identity: Type20.String({ minLength: 1 }),
+  name: Type20.String({ minLength: 1 }),
+  message: Type20.String(),
+  evidenceId: Type20.Optional(Type20.String({ minLength: 1 }))
 }, { additionalProperties: false });
-var activationTraceRecordSchema = Type14.Object({
-  role: Type14.String({ minLength: 1 }),
-  stageId: Type14.String({ pattern: "^[a-z][a-z0-9-]*$" }),
-  status: Type14.Literal("failed"),
-  timestamp: Type14.String({ format: "date-time" }),
+var activationTraceRecordSchema = Type20.Object({
+  role: Type20.String({ minLength: 1 }),
+  stageId: Type20.String({ pattern: "^[a-z][a-z0-9-]*$" }),
+  status: Type20.Literal("failed"),
+  timestamp: Type20.String({ format: "date-time" }),
   cause: causeSchema
 }, { additionalProperties: false });
 var activationCauseEvidence = 0;
@@ -21857,10 +22696,10 @@ init_engine_material();
 init_engine_detour();
 init_engine_detour_usage();
 init_run_terminal_artifacts();
-import { Type as Type15 } from "typebox";
-var engineDetourArgsSchema = Type15.Object(
+import { Type as Type21 } from "typebox";
+var engineDetourArgsSchema = Type21.Object(
   {
-    argv: Type15.Array(Type15.String({ minLength: 1 }), {
+    argv: Type21.Array(Type21.String({ minLength: 1 }), {
       minItems: 1,
       description: "\u9996\u9879\u4E3A PATH \u4E2D\u7684\u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u5176\u4F59\u9879\u4E3A\u53C2\u6570\u3002"
     })
@@ -21994,28 +22833,10 @@ function registerEngineDetourTool(roleHost, hostActions) {
 init_receipt_delivery_policy();
 
 // src/collector-role.ts
+init_filed_submission();
+init_role_submission_declarations();
 init_collector_config();
 init_collector_output();
-
-// src/collector-tool-schemas.ts
-init_open_tool_schema();
-init_terminating_infrastructure();
-import { Type as Type16 } from "typebox";
-var collectorOutputBaseSchema = openToolObject(
-  Type16.Object({
-    groups: Type16.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: Type16.Unknown({
-      description: "\u672A\u5B8C\u6210\u539F\u56E0\uFF1B\u53D6\u8BC1\u53D7\u9650\u65F6\u5982\u5B9E\u62A5\u544A\u3002"
-    })
-  })
-);
-var collectorOutputArgsSchema = withTerminatingOutputDeclarations(
-  collectorOutputBaseSchema
-);
-
-// src/collector-role.ts
 var COLLECTOR_REQUIRED_TOOLS = [COLLECTOR_OUTPUT_TOOL];
 var COLLECTOR_CONSTRUCTION_TOOLS = Object.freeze(["write", "edit"]);
 var COLLECTOR_TRANSPORT_FLAGS = Object.freeze([
@@ -22041,7 +22862,6 @@ var COLLECTOR_TRANSPORT_FLAGS = Object.freeze([
     })
   })
 ]);
-var outputSchema = collectorOutputArgsSchema;
 function buildMethodContext(activation) {
   const lines = [
     "<collector_method>",
@@ -22113,27 +22933,16 @@ function createCollectorRoleRuntime(pi, dependencies) {
     registerBusinessTools(getActivation) {
       if (toolsRegistered) return;
       toolsRegistered = true;
-      pi.registerTool({
-        name: COLLECTOR_OUTPUT_TOOL,
-        label: "\u901A\u8FDB\u53F8\u8F93\u51FA",
-        description: "\u63D0\u4EA4\u901A\u8FDB\u53F8\u56DE\u6267\u3002",
-        promptSnippet: "\u63D0\u4EA4\u901A\u8FDB\u53F8\u56DE\u6267",
-        parameters: outputSchema,
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-          const activation = getActivation();
-          if (activation === void 0) throw new Error("\u901A\u8FDB\u53F8\u672A\u6FC0\u6D3B");
-          return {
-            content: [],
-            details: params,
-            terminate: true
-          };
-        }
+      registerFiledSubmissionTool(pi, roleSubmissionDeclaration("collector"), {
+        readyError: () => getActivation() === void 0 ? "\u901A\u8FDB\u53F8\u672A\u6FC0\u6D3B" : void 0
       });
     }
   };
 }
 
 // src/doctor-role.ts
+init_filed_submission();
+init_role_submission_declarations();
 init_compliance_transport();
 init_dossier_resolution();
 init_doctor_contracts();
@@ -22180,17 +22989,20 @@ function createDoctorRoleRuntime(pi, dependencies, host) {
         const details = activation.store.read(params.evidenceId, params.offset, params.limit);
         return { content: [{ type: "text", text: JSON.stringify(details) }], details };
       } });
-      pi.registerTool({ name: DOCTOR_OUTPUT_TOOL_NAME, label: "\u592A\u533B\u7F72\u8F93\u51FA", description: DOCTOR_OUTPUT_TOOL_DESCRIPTION, parameters: doctorSubmissionSchema, async execute(id, params, _signal, _update, ctx) {
-        if (!activation) throw new Error("\u592A\u533B\u7F72\u672A\u6FC0\u6D3B");
-        const active2 = activation;
-        const testimony = validateDoctorOutput(params, active2.patient, active2.store);
-        try {
-          appendCandidate(ctx, { version: 1, testimony, cost: active2.patient.cost, readRecord: active2.store.readRecord(), patientIdentity: active2.patient.identity });
-        } catch (error) {
-          host.failInfrastructure(error, ctx, id);
+      registerFiledSubmissionTool(pi, roleSubmissionDeclaration("doctor"), {
+        readyError: () => activation === void 0 ? "\u592A\u533B\u7F72\u672A\u6FC0\u6D3B" : void 0,
+        beforeAccept: async ({ toolCallId, parameters, ctx }) => {
+          if (activation === void 0) throw new Error("\u592A\u533B\u7F72\u672A\u6FC0\u6D3B");
+          const active2 = activation;
+          const testimony = validateDoctorOutput(parameters, active2.patient, active2.store);
+          try {
+            appendCandidate(ctx, { version: 1, testimony, cost: active2.patient.cost, readRecord: active2.store.readRecord(), patientIdentity: active2.patient.identity });
+          } catch (error) {
+            host.failInfrastructure(error, ctx, toolCallId);
+          }
+          return testimony;
         }
-        return { content: [], details: testimony, terminate: true };
-      } });
+      });
       pi.on("before_agent_start", (event) => {
         if (!activation) throw new Error("\u592A\u533B\u7F72\u672A\u6FC0\u6D3B");
         const catalog = { version: activation.patient.version, identity: activation.patient.identity, admittedMetrics: { cost: activation.patient.cost }, lawfulTargetKeys: ["case", ...activation.patient.cost.invocations.sources], evidence: activation.patient.evidence.map(({ id, kind, sha256, byteLength, contentLength }) => ({ id, kind, sha256, byteLength, contentLength })) };
@@ -22215,6 +23027,8 @@ ${JSON.stringify(catalog)}
 }
 
 // src/notary-role.ts
+init_filed_submission();
+init_role_submission_declarations();
 init_notary_contracts();
 function readNotaryTicketFlag(flag) {
   if (flag === void 0) return void 0;
@@ -22282,22 +23096,8 @@ function createNotaryRoleRuntime(pi, dependencies, host) {
       };
       if (!registered) {
         registered = true;
-        pi.registerTool({
-          name: NOTARY_OUTPUT_TOOL_NAME,
-          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: notaryOutputSchema,
-          async execute(toolCallId, parameters, _signal, _onUpdate, ctx) {
-            if (activation === void 0) {
-              throw new Error("\u7B26\u5B9D\u90CE\u672A\u6FC0\u6D3B");
-            }
-            return {
-              content: [],
-              details: parameters,
-              terminate: true
-            };
-          }
+        registerFiledSubmissionTool(pi, roleSubmissionDeclaration("notary"), {
+          readyError: () => activation === void 0 ? "\u7B26\u5B9D\u90CE\u672A\u6FC0\u6D3B" : void 0
         });
         pi.on("before_agent_start", (event) => {
           if (activation === void 0) {
@@ -22330,128 +23130,41 @@ init_notary_contracts();
 
 // src/countersign-role.ts
 init_review_submission();
+init_role_submission_declarations();
 init_countersign_contracts();
 init_countersign_contracts();
-var countersignVerdictSchema = reviewSubmissionSchema;
-var COUNTERSIGN_TOOL_SPEC = {
-  name: COUNTERSIGN_OUTPUT_TOOL_NAME,
-  label: "\u7ED9\u4E8B\u4E2D\u8F93\u51FA",
-  description: "\u7ED9\u4E8B\u4E2D\u51B3\u8BAE\u3002",
-  promptSnippet: "\u7ED9\u4E8B\u4E2D\u51B3\u8BAE",
-  parameters: countersignVerdictSchema
-};
+var COUNTERSIGN_TOOL_SPEC = roleSubmissionDeclaration("countersign");
 
 // src/gleaner-left-role.ts
-init_open_tool_schema();
-init_terminating_infrastructure();
 init_gleaner_left_contracts();
+init_role_submission_declarations();
 init_gleaner_left_contracts();
-import { Type as Type17 } from "typebox";
-var gleanerLeftOutputSchema = withTerminatingOutputDeclarations(
-  openToolObject(
-    Type17.Object({
-      status: Type17.Unknown({
-        description: "completed"
-      }),
-      findings: Type17.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"
-      })
-    })
-  )
-);
-var GLEANER_LEFT_TOOL_SPEC = {
-  name: GLEANER_LEFT_OUTPUT_TOOL_NAME,
-  label: "\u5DE6\u62FE\u9057\u8F93\u51FA",
-  description: "\u5DE6\u62FE\u9057\u5F39\u7AE0\u3002",
-  promptSnippet: "\u5DE6\u62FE\u9057\u5F39\u7AE0",
-  parameters: gleanerLeftOutputSchema
-};
+var GLEANER_LEFT_TOOL_SPEC = roleSubmissionDeclaration("gleaner-left");
 
 // src/role-runtime.ts
 init_gleaner_left_contracts();
 
 // src/inspector-role.ts
 init_review_submission();
+init_role_submission_declarations();
 init_inspector_contracts();
-var inspectorOutputSchema = reviewSubmissionSchema;
-var INSPECTOR_TOOL_SPEC = {
-  name: INSPECTOR_OUTPUT_TOOL_NAME,
-  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: inspectorOutputSchema
-};
+var INSPECTOR_TOOL_SPEC = roleSubmissionDeclaration("inspector");
 
 // src/role-runtime.ts
 init_inspector_contracts();
 
 // src/diarist-role.ts
-init_open_tool_schema();
-init_terminating_infrastructure();
 init_diarist_contracts();
+init_role_submission_declarations();
 init_diarist_contracts();
-import { Type as Type18 } from "typebox";
-var 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";
-var diaristOutputSchema = withTerminatingOutputDeclarations(
-  openToolObject(
-    Type18.Object({
-      status: Type18.Unknown({
-        description: "completed | escalate"
-      }),
-      ticketNumber: Type18.Optional(
-        Type18.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: Type18.Unknown({
-        description: "status \u4E3A escalate \u65F6\uFF1A\u8BA4\u4E0D\u51FA\u672C\u5EAD\u5BF9\u8C61\u7684\u539F\u56E0"
-      }),
-      sessions: Type18.Optional(Type18.Unknown({ description: DIARIST_SESSIONS_DESCRIPTION })),
-      ticketSessions: Type18.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`
-      })
-    })
-  )
-);
-var DIARIST_TOOL_SPEC = {
-  name: DIARIST_OUTPUT_TOOL_NAME,
-  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
-};
+var DIARIST_TOOL_SPEC = roleSubmissionDeclaration("diarist");
 
 // src/secretariat-role.ts
-init_terminating_infrastructure();
 init_secretariat_contracts();
+init_role_submission_declarations();
 init_secretariat_contracts();
-import { Type as Type19 } from "typebox";
-var secretariatVerdictSchema = withTerminatingOutputDeclarations(
-  Type19.Object(
-    {
-      secretariatStatus: Type19.Unknown({
-        description: "converged | escalate"
-      }),
-      ticketNumber: Type19.Optional(
-        Type19.Unknown({ description: "\u672C\u7968\u53F7\uFF1B\u7F72\u65F6\u6307\u5411\u6700\u7EC8\u6B63\u6587\u6240\u5728\u7968" })
-      ),
-      note: Type19.Unknown({ description: "\u9644\u6CE8" }),
-      evidence: Type19.Optional(Type19.Unknown({ description: "\u7559\u5B58\u8BC1\u636E" })),
-      decisionGate: Type19.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 = [];
-var SECRETARIAT_OUTPUT_TOOL_SPEC = {
-  name: SECRETARIAT_OUTPUT_TOOL_NAME,
-  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
-};
+init_secretariat_contracts();
+var SECRETARIAT_OUTPUT_TOOL_SPEC = roleSubmissionDeclaration("secretariat");
 
 // src/role-runtime.ts
 init_secretariat_contracts();
@@ -22469,24 +23182,13 @@ init_invocation();
 init_gatekeeper_role();
 
 // src/navigator-role.ts
-init_navigator_output();
-var NAVIGATOR_TOOL_SPEC = {
-  name: NAVIGATOR_OUTPUT_TOOL_NAME,
-  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
-};
+init_role_submission_declarations();
+var NAVIGATOR_TOOL_SPEC = roleSubmissionDeclaration("navigator");
 
 // src/auditor-role.ts
 init_auditor_output();
-var AUDITOR_TOOL_SPEC = {
-  name: AUDITOR_OUTPUT_TOOL_NAME,
-  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: auditorOutputSchema
-};
+init_role_submission_declarations();
+var AUDITOR_TOOL_SPEC = roleSubmissionDeclaration("auditor");
 
 // src/role-runtime.ts
 init_navigator_invocation_identity();
@@ -22496,22 +23198,9 @@ init_packaged_role_registry();
 init_judge_role();
 
 // src/reviewer-role.ts
-init_open_tool_schema();
-init_terminating_infrastructure();
+init_filed_submission();
+init_role_submission_declarations();
 init_reviewer_output();
-import { Type as Type20 } from "typebox";
-var 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";
-var 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";
-var reviewerOutputObject = Type20.Object({
-  status: Type20.Unknown({ description: REVIEWER_STATUS_DESCRIPTION }),
-  amendments: Type20.Unknown({ description: REVIEWER_AMENDMENTS_DESCRIPTION }),
-  diagnostic: Type20.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"
-  })
-});
-var reviewerOutputSchema = withTerminatingOutputDeclarations(
-  openToolObject(reviewerOutputObject)
-);
 function createReviewerRoleRuntime(pi, dependencies, _hostActions) {
   let soul;
   let registered = false;
@@ -22523,20 +23212,8 @@ function createReviewerRoleRuntime(pi, dependencies, _hostActions) {
       fixedBaseRevision = admitted.baseRevision;
       if (!registered) {
         registered = true;
-        pi.registerTool({
-          name: REVIEWER_OUTPUT_TOOL_NAME,
-          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,
-          async execute(_id, parameters) {
-            if (!soul) throw new Error("\u5FA1\u53F2\u53F0\u8F93\u5165\u672A\u88C5\u8F7D");
-            return {
-              content: [],
-              details: parameters,
-              terminate: true
-            };
-          }
+        registerFiledSubmissionTool(pi, roleSubmissionDeclaration("reviewer"), {
+          readyError: () => soul === void 0 || soul.length === 0 ? "\u5FA1\u53F2\u53F0\u8F93\u5165\u672A\u88C5\u8F7D" : void 0
         });
       }
       const activatedSoul = soul;
@@ -22550,18 +23227,18 @@ function createReviewerRoleRuntime(pi, dependencies, _hostActions) {
 }
 
 // src/worker-role.ts
-init_open_tool_schema();
-init_terminating_infrastructure();
 init_worker_output();
 init_fixer_output();
+init_filed_submission();
+init_role_submission_declarations();
 init_fixer_packet();
-import { Type as Type21 } from "typebox";
 
 // src/worker-submission-gates.ts
 init_archivist_record_entry();
 init_sitian_facade();
 init_submission_errors();
 init_worker_submission_contracts();
+init_receipt_delivery_policy();
 init_unknown_value();
 init_submission_errors();
 init_worker_submission_contracts();
@@ -22572,11 +23249,11 @@ var WORKER_SUBMISSION_GATE_RECORD_KIND = WORKER_SUBMISSION_GATE_KIND;
 var WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
 var WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE = "commit-reminder-bounce";
 var WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE = "prefix-reminder-bounce";
+var WORKER_UNFINISHED_REASON_BOUNCE_ENTRY_TYPE = "unfinished-reason-bounce";
 var HOOK_MARKER = "ak-roles: worker-submission-gates reference-transaction";
 var HOOKS_DIR = "ak-roles-hooks";
 var HOOK_FILE = "reference-transaction";
 var PLATFORM_PREFIX = /^[A-Za-z][A-Za-z0-9_-]*:/;
-var UNFINISHED_REASON_BOUNCE_LIMIT = 2;
 function git2(cwd, args) {
   return execFileSync3("git", args, {
     cwd,
@@ -22676,10 +23353,11 @@ function unfinishedReasonPresent(details) {
   if (!isRecord(details)) return false;
   return containsWrittenReason(details.reason);
 }
-function readGateState(session) {
+function readGateState(session, invocationScopeId) {
   let baseline;
   let reminded = false;
   let prefixReminded = false;
+  let unfinishedReasonBounces = 0;
   for (const entry of session.getEntries()) {
     if (entry.type !== "custom") continue;
     if (entry.customType === WORKER_COMMIT_BASELINE_ENTRY_TYPE) {
@@ -22691,9 +23369,11 @@ function readGateState(session) {
       reminded = true;
     } else if (entry.customType === WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE) {
       prefixReminded = true;
+    } else if (entry.customType === WORKER_UNFINISHED_REASON_BOUNCE_ENTRY_TYPE && invocationScopeId !== void 0 && isRecord(entry.data) && entry.data.invocationScopeId === invocationScopeId) {
+      unfinishedReasonBounces += 1;
     }
   }
-  return { baseline, reminded, prefixReminded };
+  return { baseline, reminded, prefixReminded, unfinishedReasonBounces };
 }
 function isAncestor(cwd, ancestor, descendant) {
   try {
@@ -22724,9 +23404,11 @@ function createWorkerSubmissionGate(options = {}) {
   let reminded = false;
   let prefixReminded = false;
   let unfinishedReasonBounces = 0;
+  let invocationScopeId;
   let record;
   let sessionParent;
   const explicitHome = typeof options.home === "string" && options.home.length > 0 ? options.home : void 0;
+  const unfinishedReasonBounceLimit = deliveryLimitFromConfig(options.unfinishedReasonBounceLimit);
   const head = (cwd) => {
     try {
       return git2(cwd, ["rev-parse", "HEAD"]);
@@ -22747,7 +23429,8 @@ function createWorkerSubmissionGate(options = {}) {
     });
   };
   return {
-    arm(cwd, parent) {
+    arm(cwd, parent, scope) {
+      invocationScopeId = scope;
       uninstallPackageWorkerHooks(cwd);
       root = cwd;
       sessionParent = parent.getSessionFile();
@@ -22756,7 +23439,8 @@ function createWorkerSubmissionGate(options = {}) {
         kind: WORKER_SUBMISSION_GATE_RECORD_KIND,
         parent
       });
-      const prior = readGateState(record);
+      const prior = readGateState(record, invocationScopeId);
+      unfinishedReasonBounces = prior.unfinishedReasonBounces;
       if (prior.baseline !== void 0) {
         baseline = prior.baseline;
         reminded = prior.reminded;
@@ -22778,7 +23462,11 @@ function createWorkerSubmissionGate(options = {}) {
     },
     assertAcceptable(status, details) {
       if (status === "unfinished" && !unfinishedReasonPresent(details)) {
-        if (unfinishedReasonBounces < UNFINISHED_REASON_BOUNCE_LIMIT) {
+        if (unfinishedReasonBounces < unfinishedReasonBounceLimit) {
+          record?.appendCustomEntry(WORKER_UNFINISHED_REASON_BOUNCE_ENTRY_TYPE, {
+            version: 1,
+            invocationScopeId
+          });
           unfinishedReasonBounces += 1;
           throw new WorkerUnfinishedReasonReminderError();
         }
@@ -22812,6 +23500,9 @@ function createWorkerSubmissionGate(options = {}) {
   };
 }
 
+// src/worker-role.ts
+init_receipt_delivery_policy();
+
 // src/fixer-bash-seatbelt.ts
 var FIXER_BASH_FORBIDDEN_LITERALS = [
   "rm -rf",
@@ -22828,18 +23519,7 @@ function fixerBashSeatbeltDenyReason(matched) {
 
 // src/worker-role.ts
 init_unknown_value();
-var 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}`;
-var coderOutputObject = Type21.Object({
-  status: Type21.Unknown({ description: CODER_STATUS_DESCRIPTION }),
-  report: Type21.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
-  remainingScope: Type21.Unknown({ description: "\u672C\u5C40\u540E\u5269\u4F59\u5DE5\u4F5C" }),
-  reason: Type21.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"
-  })
-});
-var coderOutputSchema = withTerminatingOutputDeclarations(
-  openToolObject(coderOutputObject)
-);
+init_worker_output();
 var FIXER_FLAG_DEFINITIONS = {
   packet: {
     name: "ak-fix-packet",
@@ -22879,6 +23559,28 @@ function validateWorkerOutput(output, phase, roleLabel) {
   if (roleLabel === "Fixer") return validateFixerOutput(output, phase);
   return validateAcceptedWorkerDetails(output, "Coder");
 }
+function registerWorkerSubmission(pi, role, options) {
+  registerFiledSubmissionTool(pi, roleSubmissionDeclaration(role), {
+    readyError: () => options.ready() ? void 0 : options.notReady,
+    beforeAccept: async ({ toolCallId, parameters, ctx }) => {
+      const phase = options.phase();
+      if (phase === void 0) throw new Error(options.notReady);
+      const output = options.project(parameters, phase);
+      const status = workerStatusOf(output);
+      if (status !== void 0) {
+        assertAcceptableThroughHost(
+          options.submissionGate,
+          status,
+          output,
+          options.hostActions,
+          ctx,
+          toolCallId
+        );
+      }
+      return output;
+    }
+  });
+}
 function assertAcceptableThroughHost(submissionGate, status, details, hostActions, ctx, toolCallId) {
   try {
     submissionGate.assertAcceptable(status, details);
@@ -22889,14 +23591,16 @@ function assertAcceptableThroughHost(submissionGate, status, details, hostAction
     hostActions.failInfrastructure(error, ctx, toolCallId);
   }
 }
-function createFixerRoleRuntime(pi, dependencies, hostActions) {
+function createFixerRoleRuntime(pi, dependencies, hostActions, options) {
   let soul;
   let packet;
   let packetPath;
   let prerequisitesPath;
   let phase;
   let lifecycleRegistered = false;
-  const submissionGate = createWorkerSubmissionGate();
+  const submissionGate = createWorkerSubmissionGate({
+    unfinishedReasonBounceLimit: options?.unfinishedReasonBounceLimit ?? deliveryLimitFromEnv(process.env)
+  });
   pi.registerFlag(
     FIXER_FLAG_DEFINITIONS.packet.name,
     FIXER_FLAG_DEFINITIONS.packet.definition
@@ -22940,30 +23644,13 @@ function createFixerRoleRuntime(pi, dependencies, hostActions) {
       packet = Object.freeze({ instructions, prerequisites });
       if (!lifecycleRegistered) {
         lifecycleRegistered = true;
-        pi.registerTool({
-          name: FIXER_OUTPUT_TOOL_NAME,
-          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,
-          async execute(toolCallId, parameters, _signal, _onUpdate, ctx) {
-            if (packet === void 0 || phase === void 0) {
-              throw new Error("\u4FEE\u5185\u53F8\u4FEE\u7406\u5305\u4E0E\u9636\u6BB5\u672A\u88C5\u8F7D");
-            }
-            const output = deepFreeze2(validateFixerOutput(parameters, phase));
-            const status = workerStatusOf(output);
-            if (status !== void 0) {
-              assertAcceptableThroughHost(
-                submissionGate,
-                status,
-                output,
-                hostActions,
-                ctx,
-                toolCallId
-              );
-            }
-            return { content: [], details: output, terminate: true };
-          }
+        registerWorkerSubmission(pi, "fixer", {
+          notReady: "\u4FEE\u5185\u53F8\u4FEE\u7406\u5305\u4E0E\u9636\u6BB5\u672A\u88C5\u8F7D",
+          ready: () => packet !== void 0 && phase !== void 0,
+          phase: () => phase,
+          project: (parameters, current) => deepFreeze2(validateFixerOutput(parameters, current)),
+          submissionGate,
+          hostActions
         });
         pi.on("tool_call", (event) => {
           if (event.toolName !== "bash") return;
@@ -23002,17 +23689,19 @@ ${packetPath}
         });
       }
     },
-    armSubmissionGate(cwd, parent) {
-      submissionGate.arm(cwd, parent);
+    armSubmissionGate(cwd, parent, invocationScopeId) {
+      submissionGate.arm(cwd, parent, invocationScopeId);
     }
   };
 }
-function createCoderRoleRuntime(pi, dependencies, hostActions) {
+function createCoderRoleRuntime(pi, dependencies, hostActions, options) {
   let soul;
   let task;
   let phase;
   let lifecycleRegistered = false;
-  const submissionGate = createWorkerSubmissionGate();
+  const submissionGate = createWorkerSubmissionGate({
+    unfinishedReasonBounceLimit: options?.unfinishedReasonBounceLimit ?? deliveryLimitFromEnv(process.env)
+  });
   pi.registerFlag("ak-coder-task", {
     description: "Markdown task assigned to the coder role",
     type: "string"
@@ -23040,30 +23729,13 @@ function createCoderRoleRuntime(pi, dependencies, hostActions) {
       if (task.length === 0) throw new Error("Coder task is empty");
       if (!lifecycleRegistered) {
         lifecycleRegistered = true;
-        pi.registerTool({
-          name: CODER_OUTPUT_TOOL_NAME,
-          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,
-          async execute(toolCallId, parameters, _signal, _onUpdate, ctx2) {
-            if (task === void 0 || phase === void 0) {
-              throw new Error("\u5C06\u4F5C\u76D1\u4EFB\u52A1\u4E0E\u9636\u6BB5\u672A\u88C5\u8F7D");
-            }
-            const output = validateWorkerOutput(parameters, phase, "Coder");
-            const status = workerStatusOf(output);
-            if (status !== void 0) {
-              assertAcceptableThroughHost(
-                submissionGate,
-                status,
-                output,
-                hostActions,
-                ctx2,
-                toolCallId
-              );
-            }
-            return { content: [], details: output, terminate: true };
-          }
+        registerWorkerSubmission(pi, "coder", {
+          notReady: "\u5C06\u4F5C\u76D1\u4EFB\u52A1\u4E0E\u9636\u6BB5\u672A\u88C5\u8F7D",
+          ready: () => task !== void 0 && phase !== void 0,
+          phase: () => phase,
+          project: (parameters, current) => validateWorkerOutput(parameters, current, "Coder"),
+          submissionGate,
+          hostActions
         });
         pi.on("before_agent_start", (event, ctx2) => {
           if (soul === void 0) throw new Error("\u5C06\u4F5C\u76D1\u804C\u5206\u672A\u88C5\u8F7D");
@@ -23085,8 +23757,8 @@ ${task ?? ""}
         });
       }
     },
-    armSubmissionGate(cwd, parent) {
-      submissionGate.arm(cwd, parent);
+    armSubmissionGate(cwd, parent, invocationScopeId) {
+      submissionGate.arm(cwd, parent, invocationScopeId);
     }
   };
 }
@@ -23099,6 +23771,8 @@ init_merger_contracts();
 
 // src/merger-role.ts
 init_merger_contracts();
+init_filed_submission();
+init_role_submission_declarations();
 init_exact_utf8();
 var MERGER_INPUT_FLAG = { name: "ak-merger-input", definition: { description: "Path to Merger assignment materials JSON", type: "string" } };
 function materialText(input, key) {
@@ -23118,16 +23792,8 @@ function createMergerRoleRuntime(pi, dependencies) {
       activation = { soul, input };
       if (!registered) {
         registered = true;
-        pi.registerTool({
-          name: MERGER_OUTPUT_TOOL_NAME,
-          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,
-          async execute(_id, params, _signal, _update, _ctx) {
-            if (!activation) throw new Error("\u6821\u4E66\u90CE\u672A\u6FC0\u6D3B");
-            return { content: [], details: params, terminate: true };
-          }
+        registerFiledSubmissionTool(pi, roleSubmissionDeclaration("merger"), {
+          readyError: () => activation === void 0 ? "\u6821\u4E66\u90CE\u672A\u6FC0\u6D3B" : void 0
         });
         pi.on("before_agent_start", (event) => {
           if (!activation) throw new Error("\u6821\u4E66\u90CE\u672A\u6FC0\u6D3B");
@@ -23396,21 +24062,9 @@ function createFiledOfficerRuntime(roleHost, spec, dependencies) {
       soul = loaded;
       if (!registered) {
         registered = true;
-        roleHost.registerTool({
-          name: spec.tool.name,
-          label: spec.tool.label,
-          description: spec.tool.description,
-          promptSnippet: spec.tool.promptSnippet,
-          parameters: spec.tool.parameters,
-          async execute(toolCallId, parameters, signal, _onUpdate, ctx) {
-            if (soul === void 0) throw new Error(`${spec.role} \u804C\u5206\u672A\u88C5\u8F7D`);
-            const projected = spec.beforeAccept === void 0 ? void 0 : await spec.beforeAccept({ toolCallId, parameters, signal, ctx });
-            return {
-              content: [],
-              details: projected === void 0 ? parameters : projected,
-              terminate: true
-            };
-          }
+        registerFiledSubmissionTool(roleHost, spec.tool, {
+          readyError: () => soul === void 0 ? `${spec.role} \u804C\u5206\u672A\u88C5\u8F7D` : void 0,
+          ...spec.beforeAccept === void 0 ? {} : { beforeAccept: spec.beforeAccept }
         });
         roleHost.on("before_agent_start", (event) => {
           if (soul === void 0) throw new Error(`${spec.role} \u804C\u5206\u672A\u88C5\u8F7D`);
@@ -23695,7 +24349,8 @@ function lastAssistantProse(messages) {
   }
   return void 0;
 }
-function createRoleRuntimeExtension(dependencies) {
+function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
+  const deliveryLimit = deliveryRequestLimit === void 0 ? deliveryLimitFromEnv(process.env) : deliveryLimitFromConfig(deliveryRequestLimit);
   return (envelopeHost) => {
     let projectClosedSubmission = async () => {
       throw new Error("\u89D2\u8272\u7EC8\u5C40\u6295\u5C04\u63A5\u7F1D\u5C1A\u672A\u521D\u59CB\u5316");
@@ -23752,7 +24407,7 @@ function createRoleRuntimeExtension(dependencies) {
     const pendingInfrastructureFailures = /* @__PURE__ */ new Map();
     const pendingSubmissionNonPassByToolCallId = /* @__PURE__ */ new Map();
     let engineDetourRegistered = false;
-    let receiptDelivery = createReceiptDeliveryPolicy();
+    let receiptDelivery = createReceiptDeliveryPolicy(deliveryLimit);
     let noReceiptRecorded = false;
     let priorFetch;
     let fetchWrapped = false;
@@ -23915,7 +24570,7 @@ function createRoleRuntimeExtension(dependencies) {
         }
       };
     });
-    roleHost.on("tool_result", async (event) => {
+    roleHost.on("tool_result", async (event, ctx) => {
       const role = selectedRole;
       if (role === void 0) return;
       const pendingInfra = pendingInfrastructureFailures.get(event.toolCallId);
@@ -23927,9 +24582,17 @@ function createRoleRuntimeExtension(dependencies) {
       const outputClassification = isOutputTool ? classifyPackagedRoleTerminalResult(classified) : void 0;
       if (isRoleInfrastructureFailure || outputClassification?.kind === "infrastructure") {
         receiptDelivery.stopForInfrastructure();
-      } else if (isOutputTool && outputClassification?.kind === "nonterminal" && event.isError) {
-        const reason = (event.content ?? []).map((part) => part.type === "text" && "text" in part ? part.text : "").join("").trim();
-        receiptDelivery.recordRejected(reason);
+      } else if (isOutputTool) {
+        const reason = packagedRoleOutputRejectionReason(classified);
+        if (reason !== void 0) {
+          receiptDelivery.recordRejected(reason);
+          if (ctx.invocationScopeId !== void 0) {
+            envelopeHost.appendEntry(RECEIPT_REJECTION_ENTRY, {
+              invocationScopeId: ctx.invocationScopeId,
+              reason
+            });
+          }
+        }
       }
       const settlement = isRoleInfrastructureFailure || outputClassification?.kind === "infrastructure" ? publicNavigatorSettlement(role, navigatorPhase(roleHost, role), classified) : void 0;
       await settleNavigatorProjection(settlement);
@@ -23971,10 +24634,11 @@ function createRoleRuntimeExtension(dependencies) {
           const runPointer = runDirectoryFromHostContext(ctx);
           if (runPointer !== void 0) {
             noReceiptRecorded = true;
-            while (receiptDelivery.nextAction() === "request-delivery") {
-              receiptDelivery.recordDeliveryRequest();
-            }
-            const facts = receiptDelivery.facts({ runPointer, attemptPointer: `current:${runPointer}` });
+            receiptDelivery.closeBudget();
+            const facts = receiptDelivery.facts({
+              runPointer,
+              attemptPointer: receiptAttemptPointer(runPointer, ctx.invocationScopeId)
+            });
             envelopeHost.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
             try {
               sitianReport({
@@ -23993,7 +24657,11 @@ function createRoleRuntimeExtension(dependencies) {
       }
       if (receiptDelivery.nextAction() === "request-delivery") {
         receiptDelivery.recordDeliveryRequest();
-        envelopeHost.appendEntry("ak-receipt-delivery-request");
+        const scopeId = ctx.invocationScopeId?.trim() ?? "";
+        envelopeHost.appendEntry(
+          RECEIPT_DELIVERY_REQUEST_ENTRY,
+          scopeId.length > 0 ? { invocationScopeId: scopeId } : void 0
+        );
         try {
           sitianReport({
             level: "event",
@@ -24014,7 +24682,10 @@ function createRoleRuntimeExtension(dependencies) {
         const runPointer = runDirectoryFromHostContext(ctx);
         if (runPointer !== void 0) {
           noReceiptRecorded = true;
-          const facts = receiptDelivery.facts({ runPointer, attemptPointer: `current:${runPointer}` });
+          const facts = receiptDelivery.facts({
+            runPointer,
+            attemptPointer: receiptAttemptPointer(runPointer, ctx.invocationScopeId)
+          });
           envelopeHost.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
           try {
             sitianReport({
@@ -24101,7 +24772,8 @@ function createRoleRuntimeExtension(dependencies) {
           return dependencies.loadFixPacket(path);
         }
       },
-      hostActions
+      hostActions,
+      { unfinishedReasonBounceLimit: deliveryLimit }
     );
     const coder = createCoderRoleRuntime(
       roleHost,
@@ -24114,7 +24786,8 @@ function createRoleRuntimeExtension(dependencies) {
           return dependencies.loadCoderTask(path);
         }
       },
-      hostActions
+      hostActions,
+      { unfinishedReasonBounceLimit: deliveryLimit }
     );
     const reviewer = createReviewerRoleRuntime(
       roleHost,
@@ -24297,7 +24970,7 @@ function createRoleRuntimeExtension(dependencies) {
       roleReferenceMaterials = "";
       activeReviewerParent = void 0;
       activeCollector = void 0;
-      receiptDelivery = createReceiptDeliveryPolicy();
+      receiptDelivery = createReceiptDeliveryPolicy(deliveryLimit);
       noReceiptRecorded = false;
       pendingNavigatorPresentation = void 0;
       navigatorActivation += 1;
@@ -24343,6 +25016,12 @@ function createRoleRuntimeExtension(dependencies) {
       try {
         resolveBookKeyFromGit(ctx.cwd);
         durableSessionPointer(ctx.sessionManager);
+        const scopeId = ctx.invocationScopeId?.trim() ?? "";
+        if (scopeId.length > 0) {
+          receiptDelivery.continueIssued(
+            priorReceiptContinuation(ctx.sessionManager.getEntries(), scopeId)
+          );
+        }
         const isStationChild = roleHost.getFlag(STATION_CHILD_FLAG.name) === true;
         if (dependencies.createNavigatorAttendance !== void 0 && entry.outputTool !== NAVIGATOR_TOOL_SPEC.name && !isStationChild) {
           navigatorSessionParent = ctx.sessionManager.getSessionFile();
@@ -24406,6 +25085,7 @@ function createRoleRuntimeExtension(dependencies) {
             subject: work.subject,
             authority: work.authority,
             invocationId,
+            deliveryRequestLimit: deliveryLimit,
             ...contextError === void 0 ? {} : { contextError },
             onEvent: (navigatorEvent, report) => {
               if (activation === navigatorActivation && !navigatorDeliveryClosed) {
@@ -24429,7 +25109,7 @@ function createRoleRuntimeExtension(dependencies) {
         }
         if ("worker" in entry && entry.worker === true) {
           const workerArms = { coder, fixer };
-          workerArms[entry.role].armSubmissionGate(ctx.cwd, ctx.sessionManager);
+          workerArms[entry.role].armSubmissionGate(ctx.cwd, ctx.sessionManager, ctx.invocationScopeId);
         }
         admitted = true;
       } catch (error) {
@@ -24459,11 +25139,11 @@ function createRoleRuntimeDependencies(packageRoot) {
     packageRoot,
     loadRoleReferenceMaterials: loadPackagedRoleReferenceMaterials,
     loadRoleSoul: loadRegisteredRoleSoul,
-    loadFixPacket: (path) => readFile24(path, "utf8"),
-    loadCoderTask: (path) => readFile24(path, "utf8"),
+    loadFixPacket: (path) => readFile25(path, "utf8"),
+    loadCoderTask: (path) => readFile25(path, "utf8"),
     loadDoctorCase,
     loadNotarySourceRun: loadNotarySourceRunLocator,
-    loadMergerInput: async (path) => JSON.parse(await readFile24(path, "utf8")),
+    loadMergerInput: async (path) => JSON.parse(await readFile25(path, "utf8")),
     loadNavigatorWorkContext: (options) => loadNavigatorWorkContext({
       context: options.context,
       role: options.role,
@@ -24478,6 +25158,7 @@ function createRoleRuntimeDependencies(packageRoot) {
       authority: options.authority,
       invocationId: options.invocationId,
       createSession: navigatorSessionFactory,
+      ...options.deliveryRequestLimit === void 0 ? {} : { deliveryRequestLimit: options.deliveryRequestLimit },
       ...options.contextError === void 0 ? {} : { contextError: options.contextError },
       onEvent: options.onEvent
     })
@@ -24487,6 +25168,7 @@ function createRoleRuntimeDependencies(packageRoot) {
 // src/role-envelope.ts
 init_engine_detour();
 init_packaged_role_registry();
+init_receipt_delivery_policy();
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { appendFile as appendFile3, mkdir as mkdir5, writeFile as writeFile9 } from "node:fs/promises";
 import { createServer } from "node:net";
@@ -24672,7 +25354,10 @@ async function prepareRoleEnvelope(options) {
     stopKeepalive() {
     }
   };
-  createRoleRuntimeExtension(options.dependencies)(envelope);
+  createRoleRuntimeExtension(
+    options.dependencies,
+    deliveryLimitFromConfig(options.request.deliveryRequestLimit)
+  )(envelope);
   const token = randomUUID9();
   const server = createServer((socket) => serveSocket(socket));
   function rememberProjectedRejection(details, toolCallId, content) {
@@ -25064,8 +25749,9 @@ import { writeFile as writeFile10 } from "node:fs/promises";
 import { dirname as dirname26, isAbsolute as isAbsolute12, join as join45, resolve as resolve21 } from "node:path";
 
 // src/external-host-turn-loop.ts
+init_receipt_delivery_policy();
+init_submission_errors();
 init_unknown_value();
-var EXTERNAL_ROLE_TURN_ROUND_LIMIT = 8;
 function mergeRoleTurnAbortSignals(prepared, request) {
   if (request === void 0) return prepared;
   if (prepared === void 0) return request;
@@ -25114,7 +25800,10 @@ async function driveExternalRoleTurnRounds(prepared, request, driver) {
   let prompt = prepared.prompt;
   const abortSignal = mergeRoleTurnAbortSignals(prepared.abortSignal, request.signal);
   let stderr = "";
-  for (let attempt = 0; attempt < EXTERNAL_ROLE_TURN_ROUND_LIMIT; attempt += 1) {
+  const countedReaskLimit = deliveryLimitFromConfig(request.deliveryRequestLimit);
+  const exemptReminders = /* @__PURE__ */ new Set();
+  let countedReasks = 0;
+  for (let attempt = 0; ; attempt += 1) {
     if (abortSignal?.aborted) return settleHostAborted(prepared, driver.currentSessionId());
     let round;
     try {
@@ -25135,14 +25824,22 @@ async function driveExternalRoleTurnRounds(prepared, request, driver) {
       return { code: 0, stderr, timedOut: false };
     }
     if ("failure" in closure) return asFailure(closure.failure, stderr);
+    const reminderCode = closure.retry.code;
+    const exempt = isOneShotWorkerReminderCode(reminderCode) && !exemptReminders.has(reminderCode);
+    if (exempt) exemptReminders.add(reminderCode);
+    else {
+      countedReasks += 1;
+      if (countedReasks > countedReaskLimit) {
+        return asFailure({
+          cause: "output",
+          identity: { name: driver.roundLimitName, code: "round-retry-limit" },
+          ...driver.currentSessionId() === void 0 ? {} : { details: { sessionId: driver.currentSessionId() } }
+        });
+      }
+    }
     prompt = closure.retry.message;
     driver.afterRetry?.();
   }
-  return asFailure({
-    cause: "output",
-    identity: { name: driver.roundLimitName, code: "round-retry-limit" },
-    ...driver.currentSessionId() === void 0 ? {} : { details: { sessionId: driver.currentSessionId() } }
-  });
 }
 function createSerializedRoleTurnHost(execute) {
   let serial = Promise.resolve();