@akagilnc/pi-workflow-roles 0.1.3932 → 0.1.3975

package/dist/doctor-contracts.js

@@ -6,64 +6,45 @@ const DOCTOR_EVIDENCE_TOOL_NAME = "ak_doctor_evidence";
 const DOCTOR_OUTPUT_TOOL_NAME = "ak_doctor_output";
 const DOCTOR_ACCEPTED_TEXT = "\u592A\u533B\u7F72\u56DE\u6267\u5DF2\u63A5\u53D7";
 const DOCTOR_ACCEPTED_AUDIT_NO_RECEIPT_TEXT = "\u592A\u533B\u7F72\u56DE\u6267\u5DF2\u63A5\u53D7\uFF1B\u5BA1\u8BA1\u65E0\u56DE\u6267";
-const DOCTOR_OUTPUT_TOOL_DESCRIPTION = "\u63D0\u4EA4\u552F\u4E00\u7EC8\u5C40\u5355\u6848\u8BC1\u8BCD\uFF1Bcompleted \u5141\u8BB8\u7A7A findings\uFF1Bruntime \u8865\u8BB0\u6D3E\u751F\u6210\u672C\u5165\u56DE\u6267\u3002";
+const DOCTOR_OUTPUT_TOOL_DESCRIPTION = "\u63D0\u4EA4\u552F\u4E00\u7EC8\u5C40\u5355\u6848\u8BC1\u8BCD\uFF1Bcompleted \u5141\u8BB8\u7A7A findings\u3002";
 const DOCTOR_TARGET_KINDS = ["law", "gate", "template", "station", "seat"];
-const nonblank = Type.String({ minLength: 1, pattern: "\\S" });
-const count = Type.Object({ count: Type.Integer({ minimum: 0 }), sources: Type.Array(nonblank) }, { additionalProperties: false });
-const evidenceIds = Type.Array(nonblank, { minItems: 1 });
-const guardrail = Type.Object({ answer: Type.Boolean(), evidenceIds, explanation: nonblank }, { additionalProperties: false });
+const nonblank = Type.Optional(Type.String());
+const evidenceIds = Type.Optional(Type.Array(Type.String()));
+const guardrail = Type.Object({ answer: Type.Optional(Type.Boolean()), evidenceIds, explanation: nonblank }, { additionalProperties: true });
 const lastRealBite = Type.Union([
-  Type.Object({ kind: Type.Literal("actual"), targetKey: nonblank, evidenceId: nonblank }, { additionalProperties: false }),
-  Type.Object({ kind: Type.Literal("noRealBite"), targetKey: nonblank, eligibleEvidenceIds: evidenceIds }, { additionalProperties: false })
+  Type.Object({ kind: Type.Optional(Type.Literal("actual")), targetKey: nonblank, evidenceId: nonblank }, { additionalProperties: true }),
+  Type.Object({ kind: Type.Optional(Type.Literal("noRealBite")), targetKey: nonblank, eligibleEvidenceIds: evidenceIds }, { additionalProperties: true })
 ]);
 const assetKinds = DOCTOR_TARGET_KINDS;
 const findingBody = {
   evidenceIds,
-  disposition: Type.Union([Type.Literal("keep"), Type.Literal("thin"), Type.Literal("delete")]),
-  guardrails: Type.Object({ reproducibleFailure: guardrail, owningSeamOrInvariant: guardrail, deletionOrSimplificationSuffices: guardrail }, { additionalProperties: true }),
-  prescription: Type.Object({ kind: Type.Union([Type.Literal("retain"), Type.Literal("delete"), Type.Literal("simplify"), Type.Literal("patch"), Type.Literal("addMechanism")]), recommendation: nonblank, necessityExplanation: Type.Optional(nonblank) }, { additionalProperties: false }),
-  lastRealBite
+  disposition: Type.Optional(Type.Union([Type.Literal("keep"), Type.Literal("thin"), Type.Literal("delete")])),
+  guardrails: Type.Optional(Type.Object({ reproducibleFailure: guardrail, owningSeamOrInvariant: guardrail, deletionOrSimplificationSuffices: guardrail }, { additionalProperties: true })),
+  prescription: Type.Optional(Type.Object({ kind: Type.Optional(Type.Union([Type.Literal("retain"), Type.Literal("delete"), Type.Literal("simplify"), Type.Literal("patch"), Type.Literal("addMechanism")])), recommendation: nonblank, necessityExplanation: nonblank }, { additionalProperties: true })),
+  lastRealBite: Type.Optional(lastRealBite)
 };
 const finding = Type.Union([
-  Type.Object({ targetKey: nonblank, observation: nonblank, evidenceIds }, { additionalProperties: false }),
-  Type.Object({ targetKey: nonblank, targetKind: Type.Union(assetKinds.map((kind) => Type.Literal(kind))), assetEvidence: Type.Object({ targetKey: nonblank, targetKind: Type.Union(assetKinds.map((kind) => Type.Literal(kind))), evidenceId: nonblank }, { additionalProperties: false }), ...findingBody }, { additionalProperties: false })
+  Type.Object({ targetKey: nonblank, observation: nonblank, evidenceIds }, { additionalProperties: true }),
+  Type.Object({ targetKey: nonblank, targetKind: Type.Optional(Type.Union(assetKinds.map((kind) => Type.Literal(kind)))), assetEvidence: Type.Optional(Type.Object({ targetKey: nonblank, targetKind: Type.Optional(Type.Union(assetKinds.map((kind) => Type.Literal(kind)))), evidenceId: nonblank }, { additionalProperties: true })), ...findingBody }, { additionalProperties: true })
 ]);
-const caseIdentity = Type.Object({ issueNumber: Type.Integer({ minimum: 1 }), runsPath: nonblank }, { additionalProperties: false });
-const cost = Type.Object({
-  invocations: count,
-  legs: count,
-  modelApiTurns: count,
-  outputTokens: count,
-  toolCalls: count,
-  retries: Type.Object({ count: Type.Integer({ minimum: 0 }), sources: Type.Array(nonblank), evidence: Type.Literal("literal run-dir naming") }, { additionalProperties: false }),
-  statuses: Type.Array(Type.Object({ source: nonblank, status: nonblank }, { additionalProperties: false })),
-  commits: Type.Array(Type.Object({ source: nonblank, commit: nonblank }, { additionalProperties: false })),
-  sessions: Type.Array(Type.Union([
-    Type.Object({ source: nonblank, startedAt: nonblank, endedAt: nonblank, wallMilliseconds: Type.Number({ minimum: 0 }), completion: Type.Literal("accepted") }, { additionalProperties: false }),
-    Type.Object({ source: nonblank, startedAt: Type.Optional(nonblank), endedAt: Type.Optional(nonblank), wallMilliseconds: Type.Optional(Type.Number({ minimum: 0 })), completion: Type.Literal("incomplete"), degradationReason: Type.Optional(nonblank) }, { additionalProperties: false })
-  ])),
-  outputBytes: Type.Object({ count: Type.Integer({ minimum: 0 }), sources: Type.Array(nonblank), payload: Type.Literal("raw JSONL bytes"), providerWireBytes: Type.Literal("unavailable") }, { additionalProperties: false })
-}, { additionalProperties: false });
+const caseIdentity = Type.Object({ issueNumber: Type.Optional(Type.Integer()), runsPath: nonblank }, { additionalProperties: true });
+const DOCTOR_STATUS_DESCRIPTION = "completed | refused \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\uFF1Bcompleted \u5141\u8BB8\u7A7A findings\uFF1Brefused \u4EC5\u5F53\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u6848\u8BC1\u8BCD";
 const doctorSubmissionVariants = Type.Union([
   Type.Object({
-    status: Type.Literal("completed", { description: "completed \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\uFF1B\u5141\u8BB8\u7A7A findings\uFF1Bruntime \u8865\u8BB0\u6D3E\u751F\u6210\u672C\u5165\u56DE\u6267" }),
+    status: Type.Unknown({ description: DOCTOR_STATUS_DESCRIPTION }),
     case: Type.Unsafe({ ...caseIdentity, description: "\u7559\u5B58\u592A\u533B\u7F72\u6848\u8EAB\u4EFD" }),
     findings: Type.Array(finding, { description: "\u53EF\u7A7A\u6216\u4EC5\u542B\u975E\u5904\u65B9\u6848\u89C2\u5BDF\uFF1B\u7F3A\u53EF\u590D\u7528\u8D44\u4EA7\u6216 bounded-bite \u8BC1\u636E\u53EA\u6392\u9664\u5BF9\u5E94\u8D44\u4EA7\u5904\u65B9" })
   }, { additionalProperties: false, description: "\u5355\u6848\u8BC1\u8BCD\uFF0C\u4E0D\u8981\u6C42\u4EFB\u4F55\u5904\u65B9\u6216\u53EF\u590D\u7528 finding" }),
   Type.Object({
-    status: Type.Literal("refused", { description: "refused \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\uFF1B\u4EC5\u5F53\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u6848\u8BC1\u8BCD" }),
-    reason: Type.String({ minLength: 1, description: "\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u8BC1\u8BCD\u7684\u539F\u56E0" }),
-    missingEvidence: Type.Array(Type.Object({ need: nonblank, targetKeys: Type.Array(nonblank, { minItems: 1 }) }, { additionalProperties: false }), { minItems: 1, description: "\u5982\u5B9E\u8BC1\u8BCD\u6240\u9700\u800C\u5C1A\u7F3A\u7684\u8BC1\u636E" })
+    status: Type.Unknown({ description: DOCTOR_STATUS_DESCRIPTION }),
+    reason: Type.String({ description: "\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u8BC1\u8BCD\u7684\u539F\u56E0" }),
+    missingEvidence: Type.Array(Type.Object({ need: nonblank, targetKeys: evidenceIds }, { additionalProperties: true }), { description: "\u5982\u5B9E\u8BC1\u8BCD\u6240\u9700\u800C\u5C1A\u7F3A\u7684\u8BC1\u636E" })
   }, { additionalProperties: false, description: "\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u6848\u8BC1\u8BCD" })
 ]);
 const doctorSubmissionSchema = withInfrastructureFailureDeclaration(
   openToolObjectFromUnion(doctorSubmissionVariants)
 );
-const doctorOutputSchema = Type.Union([
-  Type.Object({ status: Type.Literal("completed"), case: caseIdentity, findings: Type.Array(finding), cost }, { additionalProperties: false }),
-  doctorSubmissionVariants.anyOf[1]
-]);
-const doctorEvidenceReadSchema = Type.Object({ evidenceId: Type.String({ minLength: 1, description: "\u5F85\u8BFB\u7559\u5B58\u8BC1\u636E\u6807\u8BC6" }), offset: Type.Optional(Type.Integer({ minimum: 0, description: "\u8D77\u59CB\u5B57\u8282\u504F\u79FB\uFF08\u4ECE 0 \u8BA1\uFF09" })), limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 4096, description: "\u8FD4\u56DE\u5B57\u8282\u4E0A\u9650" })) }, { additionalProperties: false });
+const doctorEvidenceReadSchema = Type.Object({ evidenceId: Type.String({ minLength: 1, description: "\u5F85\u8BFB\u7559\u5B58\u8BC1\u636E\u6807\u8BC6" }), offset: Type.Optional(Type.Integer({ minimum: 0, description: "\u8D77\u59CB\u5B57\u8282\u504F\u79FB\uFF08\u4ECE 0 \u8BA1\uFF09" })), limit: Type.Optional(Type.Integer({ minimum: 1, description: "\u8FD4\u56DE\u5B57\u8282\u6570\uFF08\u65E0\u4E0A\u9650\uFF09" })) }, { additionalProperties: true });
 class DoctorSubmissionContractError extends Error {
   name = "DoctorSubmissionContractError";
 }
@@ -79,15 +60,10 @@ function read(value, key) {
   }
 }
 function validateDoctorSubmissionShape(value) {
-  const status = read(value, "status");
-  if (status !== "completed" && status !== "refused") throw new DoctorSubmissionContractError("\u592A\u533B\u7F72\u4EA4\u5377\u65E0\u5DF2\u8BC6\u522B\u7684\u6267\u884C\u72B6\u6001");
   return value;
 }
 function validateRecordedDoctorOutput(value) {
-  const output = validateDoctorSubmissionShape(value);
-  const status = read(output, "status");
-  if (status === "completed" && read(output, "cost") === void 0) throw new DoctorSubmissionContractError("completed \u592A\u533B\u7F72\u56DE\u6267\u7F3A\u5C11 runtime \u6301\u6709\u7684 cost \u8BC1\u8BCD");
-  return output;
+  return value;
 }
 class DoctorEvidenceStore {
   constructor(patient) {
@@ -97,12 +73,16 @@ class DoctorEvidenceStore {
   patient;
   entries;
   coverage = /* @__PURE__ */ new Map();
-  read(evidenceId, offset = 0, limit = 4096) {
+  // #836 A6.5: no 4096 hard cap — limit only bounds the requested window when provided.
+  read(evidenceId, offset = 0, limit) {
     const entry = this.entries.get(evidenceId);
     if (!entry) throw new Error(`\u8BC1\u636E ID \u672A\u51C6\u5165\uFF1A${evidenceId}`);
-    if (!Number.isInteger(offset) || offset < 0 || !Number.isInteger(limit) || limit < 1 || limit > 4096) throw new Error("\u8BC1\u636E\u5206\u9875\u53C2\u6570\u65E0\u6548");
+    if (!Number.isInteger(offset) || offset < 0) throw new Error("\u8BC1\u636E\u5206\u9875\u53C2\u6570\u65E0\u6548");
     if (offset > entry.contentLength) throw new Error("\u8BC1\u636E offset \u8D85\u51FA\u5185\u5BB9");
-    const end = Math.min(entry.contentLength, offset + limit);
+    const window = limit === void 0 ? entry.contentLength - offset : !Number.isInteger(limit) || limit < 1 ? (() => {
+      throw new Error("\u8BC1\u636E\u5206\u9875\u53C2\u6570\u65E0\u6548");
+    })() : limit;
+    const end = Math.min(entry.contentLength, offset + window);
     const ranges = [...this.coverage.get(evidenceId) ?? [], [offset, end]].sort((a, b) => a[0] - b[0]);
     const merged = [];
     for (const range of ranges) {
@@ -111,7 +91,16 @@ class DoctorEvidenceStore {
       else merged.push([...range]);
     }
     this.coverage.set(evidenceId, merged);
-    return { evidenceId, kind: entry.kind, offset, content: entry.content.slice(offset, end), nextOffset: end < entry.contentLength ? end : null, contentLength: entry.contentLength, byteLength: entry.byteLength, sha256: entry.sha256 };
+    return {
+      evidenceId,
+      kind: entry.kind,
+      offset,
+      content: entry.content.slice(offset, end),
+      nextOffset: end < entry.contentLength ? end : null,
+      contentLength: entry.contentLength,
+      byteLength: entry.byteLength,
+      sha256: entry.sha256
+    };
   }
   hasRead(id) {
     const entry = this.entries.get(id);
@@ -122,65 +111,8 @@ class DoctorEvidenceStore {
     return [...this.coverage.keys()].sort().map((evidenceId) => ({ evidenceId, fullyRead: this.hasRead(evidenceId) }));
   }
 }
-function validateDoctorOutput(value, patient, store) {
-  const output = validateDoctorSubmissionShape(value);
-  const lawfulTargets = /* @__PURE__ */ new Set(["case", ...patient.cost.invocations.sources]);
-  const assertTarget = (targetKey) => {
-    if (typeof targetKey === "string" && !lawfulTargets.has(targetKey)) throw new DoctorSubmissionContractError(`targetKey \u4E0D\u662F\u5408\u6CD5\u6848\u76EE\u6807\uFF1A${targetKey}`);
-  };
-  const readCitations = (ids, label) => {
-    if (!Array.isArray(ids)) return;
-    for (const id of ids) if (typeof id === "string" && (!store.entries.has(id) || !store.hasRead(id))) throw new DoctorSubmissionContractError(`${label} \u987B\u5F15\u7528\u5DF2\u51C6\u5165/\u5DF2\u8BFB\u8BC1\u636E\uFF1A${id}`);
-  };
-  if (read(output, "status") === "refused") {
-    const missingEvidence = read(output, "missingEvidence");
-    if (Array.isArray(missingEvidence)) for (const missing of missingEvidence) {
-      const targets = read(missing, "targetKeys");
-      if (Array.isArray(targets)) for (const target of targets) assertTarget(target);
-    }
-    return output;
-  }
-  const identity = read(output, "case");
-  const issueNumber = read(identity, "issueNumber");
-  const runsPath = read(identity, "runsPath");
-  if (issueNumber !== void 0 && issueNumber !== patient.identity.issueNumber || runsPath !== void 0 && runsPath !== patient.identity.runsPath) throw new DoctorSubmissionContractError("\u592A\u533B\u7F72\u4EA4\u5377 case \u987B\u7B49\u4E8E\u5DF2\u6FC0\u6D3B\u6848\u8EAB\u4EFD");
-  const findings = read(output, "findings");
-  if (!Array.isArray(findings)) return output;
-  for (const finding2 of findings) {
-    const targetKey = read(finding2, "targetKey");
-    readCitations(read(finding2, "evidenceIds"), "finding");
-    const assetEvidence = read(finding2, "assetEvidence");
-    if (!isRecord(assetEvidence)) {
-      assertTarget(targetKey);
-      continue;
-    }
-    const assetTargetKey = read(assetEvidence, "targetKey");
-    const assetTargetKind = read(assetEvidence, "targetKind");
-    const assetEvidenceId = read(assetEvidence, "evidenceId");
-    if (typeof assetTargetKey === "string" && assetTargetKey !== targetKey) throw new DoctorSubmissionContractError("\u7C7B\u578B\u5316\u8D44\u4EA7\u8BC1\u636E\u987B\u786E\u7ACB finding \u7684 targetKey");
-    if (typeof assetTargetKind === "string" && assetTargetKind !== read(finding2, "targetKind")) throw new DoctorSubmissionContractError("\u7C7B\u578B\u5316\u8D44\u4EA7\u8BC1\u636E\u987B\u786E\u7ACB finding \u7684 targetKind");
-    if (typeof assetEvidenceId === "string") readCitations([assetEvidenceId], "asset evidence");
-    const guardrails = read(finding2, "guardrails");
-    for (const key of ["reproducibleFailure", "owningSeamOrInvariant", "deletionOrSimplificationSuffices"]) readCitations(read(read(guardrails, key), "evidenceIds"), "guardrail");
-    const bite = read(finding2, "lastRealBite");
-    const biteKind = read(bite, "kind");
-    if (biteKind !== "actual" && biteKind !== "noRealBite") continue;
-    if (read(bite, "targetKey") !== targetKey) throw new DoctorSubmissionContractError("lastRealBite \u76EE\u6807\u4E0D\u5339\u914D");
-    if (biteKind === "actual") {
-      const evidenceId = read(bite, "evidenceId");
-      const entry = typeof evidenceId === "string" ? store.entries.get(evidenceId) : void 0;
-      if (!entry || entry.kind !== "session" || !store.hasRead(entry.id)) throw new DoctorSubmissionContractError("actual bite \u987B\u5F15\u7528\u5DF2\u51C6\u5165/\u5DF2\u8BFB\u7684\u7559\u5B58 session");
-    } else {
-      const eligible = patient.evidence.map((entry) => entry.id).sort();
-      const ids = read(bite, "eligibleEvidenceIds");
-      if (Array.isArray(ids)) {
-        const claimed = ids.filter((id) => typeof id === "string").sort();
-        if (canonicalJson(claimed) !== canonicalJson(eligible)) throw new DoctorSubmissionContractError("noRealBite \u987B\u8BC1\u660E\u5B8C\u6574\u7684\u5355\u6848\u5408\u683C\u8BC1\u636E\u5168\u96C6");
-        readCitations(eligible, "noRealBite");
-      }
-    }
-  }
-  return output;
+function validateDoctorOutput(value, _patient, _store) {
+  return validateDoctorSubmissionShape(value);
 }
 export {
   DOCTOR_ACCEPTED_AUDIT_NO_RECEIPT_TEXT,
@@ -192,7 +124,6 @@ export {
   DoctorEvidenceStore,
   DoctorSubmissionContractError,
   doctorEvidenceReadSchema,
-  doctorOutputSchema,
   doctorSubmissionSchema,
   validateDoctorOutput,
   validateDoctorSubmissionShape,

package/dist/doctor-evidence.js

@@ -86,14 +86,10 @@ function deriveSession(content, id) {
             if (facts.commit && facts.commit !== observedCommit) {
                 commits.push({ source: id, commit: facts.commit });
                 observedCommit = facts.commit;
-            }
-            statuses.length = 0;
+            } /* #836 B10.3: do not wipe earlier statuses or invent a code status sentence */
             if (facts.status !== undefined) {
                 statuses.push({ source: id, status: facts.status });
             }
-            else {
-                statuses.push({ source: id, status: "terminating receipt has no receipt-level status" });
-            }
         }
     }
     const acceptedAt = accepted && timestamp(accepted);

package/dist/engine-detour-tool.js

@@ -13,7 +13,7 @@ const engineDetourArgsSchema = Type.Object(
       description: "\u9996\u9879\u4E3A PATH \u4E2D\u7684\u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u5176\u4F59\u9879\u4E3A\u53C2\u6570\u3002"
     })
   },
-  { additionalProperties: false }
+  { additionalProperties: true }
 );
 function isCallerCancellation(error, signal) {
   if (signal?.aborted === true) return true;

package/dist/gatekeeper-role.js

@@ -1,4 +1,4 @@
-import { auditorRunDirectory, persistGateSubmissionCandidate, readLatestSubmissionArguments, } from "./auditor-dossier-tool.js";
+import { auditorRunDirectory } from "./auditor-dossier-tool.js";
 import { GatekeeperDecisionError } from "./submission-errors.js";
 import { INSPECTOR_OUTPUT_TOOL_NAME } from "./inspector-contracts.js";
 import { GATEKEEPER_OUTPUT_TOOL_NAME, gatekeeperDecisionSchema, gatekeeperOutputSchema, } from "./package-contracts/gatekeeper-output.js";
@@ -51,19 +51,12 @@ function failureReason(error) {
         return error.errors.map(failureReason).join("; ");
     return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
 }
-/** Serializable stand-in when the child tool call had no arguments object. */
-export const MISSING_ARGUMENTS_SUBMISSION = Object.freeze({ missing: "arguments" });
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/** Keep original decision bytes for the next reader; undefined becomes a serializable missing-args fact. */
+/** Original decision bytes — no sentinel replacement (#836). */
 function retainedReceipt(decision) {
-    // undefined must not be stored: JSON drops it and the missing-args fact vanishes.
-    // Through the real provider adapter an undefined root argument arrives as an
-    // empty object after serialization; that must also project a missing-args fact.
-    return decision === undefined || (isRecord(decision) && Object.keys(decision).length === 0)
-        ? MISSING_ARGUMENTS_SUBMISSION
-        : decision;
+    return decision;
 }
 function readRecord(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
@@ -92,63 +85,85 @@ function projectOfficerDecision(officer, decision, fallbackStatus) {
 }
 /**
  * Project a public-role terminal onto the gate queue surface.
- * Lifecycle facts (no_receipt / transport) stay loud; conclusion reads only
- * the status field. No unusable/unreadable judgment (#753).
+ * Host failure stays failure; recorded officer payloads ride beside it (#836 A.3).
+ * Multiple recorded payloads are all kept — code does not pick last-wins.
  */
+function officerPayloads(terminal) {
+    const outcome = terminal?.roleOutcome;
+    if (outcome !== undefined && (outcome.kind === "accepted" || outcome.kind === "audit_escalation")) {
+        return outcome.payloads ?? terminal?.submissions ?? [];
+    }
+    if (outcome?.kind === "failure")
+        return outcome.payloads ?? terminal?.submissions ?? [];
+    return terminal?.submissions ?? [];
+}
+function projectOfficerPayloads(officer, payloads, fallbackStatus) {
+    if (payloads.length === 0) {
+        return projectOfficerDecision(officer, undefined, fallbackStatus);
+    }
+    // Present every recorded payload; queue only the latest conclusion so a reask
+    // can converge (#836 呈现 ≠ 排队).
+    const queued = projectOfficerDecision(officer, payloads[payloads.length - 1], fallbackStatus);
+    if (payloads.length === 1)
+        return queued;
+    if (queued.status === "pass"
+        || queued.status === "bounce"
+        || queued.status === "escalate"
+        || queued.status === "needs_reask") {
+        return { ...queued, receipt: payloads };
+    }
+    return queued;
+}
 function projectOfficerTerminal(officer, summoned) {
     const terminal = summoned.terminal;
     const outcome = terminal?.roleOutcome;
+    const recorded = officerPayloads(terminal);
     if (outcome === undefined) {
-        const detail = summoned.stderr?.trim();
+        const detail = summoned.stderr ?? "";
         return {
             status: "transport_failure",
             stage: officer,
-            reason: detail && detail.length > 0
+            reason: detail.length > 0
                 ? `${gateSeatLabel(officer)} public summon exit ${summoned.exitCode}: ${detail}`
                 : `${gateSeatLabel(officer)} public summon produced no terminal (exit ${summoned.exitCode})`,
-            submission: summoned,
+            submission: recorded.length > 0 ? recorded : summoned,
         };
     }
     if (outcome.kind === "no_receipt") {
         return {
             status: "no_receipt",
             stage: officer,
-            reason: `${gateSeatLabel(officer)}未产生已接受回执即散局`,
+            reason: typeof outcome.status === "string" && outcome.status.length > 0
+                ? outcome.status
+                : "no_receipt",
             facts: outcome,
         };
     }
     if (outcome.kind === "failure") {
-        // Real provider/engine/disk failure — keep loud. Not a shape judgment.
         return {
             status: "transport_failure",
             stage: officer,
             reason: outcome.diagnostic,
-            submission: outcome.decisiveFacts,
+            submission: recorded.length > 0 ? recorded : outcome.decisiveFacts,
         };
     }
     if (outcome.kind === "audit_escalation") {
-        // Residual/compliance escalate face: queue as escalate, receipt as written.
-        // Nested officer escalate itself seals accepted+status escalate (no rewrite).
         return {
             status: "escalate",
             officer,
-            receipt: retainedReceipt(outcome.decisiveFacts),
+            receipt: recorded.length === 1 ? recorded[0] : recorded,
         };
     }
     if (outcome.kind === "accepted") {
-        // Prefer the officer's own decisiveFacts as the receipt body. outcome.status is
-        // only a fallback when facts have no status key (missing-args sentinel stays intact).
-        const facts = outcome.decisiveFacts;
-        if (isRecord(facts) && Object.keys(facts).length > 0) {
-            return projectOfficerDecision(officer, facts, outcome.status);
-        }
-        return projectOfficerDecision(officer, { status: outcome.status });
+        // outcome.status is the fixture/compat leaf: production settlement leaves
+        // it undefined once payloads are recorded, so this only matters when a
+        // caller still supplies status without any recorded payload (#836 hang).
+        return projectOfficerPayloads(officer, recorded, outcome.status);
     }
-    // Unknown terminal kind: still not a shape judgment — ask the speaker again.
     return {
         status: "needs_reask",
         officer,
-        receipt: retainedReceipt(outcome),
+        receipt: recorded.length > 0 ? recorded : retainedReceipt(outcome),
     };
 }
 /**
@@ -173,15 +188,12 @@ export async function projectGatekeeperRun(options) {
             },
         };
     }
-    // #632: Grok session.jsonl is header-only — freeze the in-memory tool-call leaf
-    // as a run artifact so dossier exploration still resolves. LLM→LLM resume does
-    // not ride this path: submission body goes verbatim on gateReviewInstruction (#786).
-    persistGateSubmissionCandidate(runDirectory, options.context);
-    const submission = readLatestSubmissionArguments(options.context);
+    // #836: officers receive the whole parent run directory pointer and find the
+    // submission themselves — code no longer picks latest toolCall leaf (A7.1–A7.3).
     let summoned;
     try {
         const summon = options.summonOfficer
-            ?? (async (nextOfficer, sourceRunDirectory, officerSignal, reask, nextSubmission) => {
+            ?? (async (nextOfficer, sourceRunDirectory, officerSignal, reask) => {
                 const { summonGateOfficer } = await import("./public-role-summons.js");
                 return summonGateOfficer({
                     officer: nextOfficer,
@@ -189,14 +201,13 @@ export async function projectGatekeeperRun(options) {
                     cwd: options.context.cwd ?? process.cwd(),
                     ...(officerSignal === undefined ? {} : { signal: officerSignal }),
                     ...(reask === undefined ? {} : { reask }),
-                    ...(nextSubmission === undefined ? {} : { submission: nextSubmission }),
                     ...(options.home === undefined ? {} : { home: options.home }),
                     ...(options.packageRoot === undefined ? {} : { packageRoot: options.packageRoot }),
                     ...(options.roleTurnHost === undefined ? {} : { roleTurnHost: options.roleTurnHost }),
                     ...(options.createRunId === undefined ? {} : { createRunId: options.createRunId }),
                 });
             });
-        summoned = await summon(officer, runDirectory, options.signal, options.reask, submission);
+        summoned = await summon(officer, runDirectory, options.signal, options.reask);
     }
     catch (error) {
         return {