@akagilnc/pi-workflow-roles 0.1.5797 → 0.1.5820

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

@@ -1425,18 +1425,29 @@ async function runEngineDetourOnce(input) {
 function isEngineDetourFailure(result) {
   return result.code !== 0 || result.stdout.trim() === "";
 }
-function engineDetourFailureDiagnostic(result) {
-  if (result.stderr.trim().length > 0) return result.stderr;
-  if (result.stdout.trim() === "") return ENGINE_DETOUR_EMPTY_STDOUT_DIAGNOSTIC;
-  const rows = result.stdout.split("\n");
-  let lastRow = "";
-  for (let index = rows.length - 1; index >= 0; index -= 1) {
-    if (rows[index].trim() !== "") {
-      lastRow = rows[index];
-      break;
-    }
+function engineDetourFailureSeatText(result) {
+  const parts = [];
+  if (result.stdout.length > 0) parts.push(result.stdout);
+  if (result.stderr.length > 0) parts.push(result.stderr);
+  let text = "";
+  if (parts.length > 0) {
+    text = parts[0];
+    for (let index = 1; index < parts.length; index += 1) {
+      if (!text.endsWith("\n")) text += "\n";
+      text += parts[index];
+    }
+  }
+  const append = (line2) => {
+    if (text.length > 0 && !text.endsWith("\n")) text += "\n";
+    text += line2;
+  };
+  if (result.code !== 0) {
+    append(`\u52B3\u52A1\u5F15\u64CE\u4EE5 code ${result.code} \u9000\u51FA`);
+  }
+  if (result.stdout.trim() === "") {
+    append(ENGINE_DETOUR_EMPTY_STDOUT_DIAGNOSTIC);
   }
-  return `\u52B3\u52A1\u5F15\u64CE\u4EE5 code ${result.code} \u9000\u51FA\uFF1A${lastRow}`;
+  return text.length > 0 ? text : ENGINE_DETOUR_EMPTY_STDOUT_DIAGNOSTIC;
 }
 function engineNameFromEnv() {
   return normalizeEngineName(
@@ -1524,43 +1535,10 @@ function withTerminatingOutputDeclarations(schema) {
   object.required = preserved;
   return object;
 }
-function isInfrastructureFailureDeclaration(parameters) {
-  if (!isRecord(parameters)) return false;
-  if (!Object.hasOwn(parameters, INFRASTRUCTURE_FAILURE_DECLARATION_KEY)) return false;
-  const declaration = parameters[INFRASTRUCTURE_FAILURE_DECLARATION_KEY];
-  if (!isRecord(declaration)) return false;
-  const diagnostic = declaration[INFRASTRUCTURE_FAILURE_DIAGNOSTIC_KEY];
-  return typeof diagnostic === "string" && diagnostic.trim().length > 0;
-}
-function infrastructureFailureDiagnostic(parameters) {
-  if (!isInfrastructureFailureDeclaration(parameters)) return void 0;
-  const declaration = parameters[INFRASTRUCTURE_FAILURE_DECLARATION_KEY];
-  const diagnostic = declaration[INFRASTRUCTURE_FAILURE_DIAGNOSTIC_KEY];
-  return typeof diagnostic === "string" ? diagnostic.trim() : void 0;
-}
-function infrastructureFailureError(diagnostic) {
-  const error = new Error(diagnostic);
-  error.name = "InfrastructureFailure";
-  return error;
-}
-function failOnInfrastructureFailureDeclaration(parameters, hostActions, ctx, toolCallId, bounceInfrastructureDeclaration) {
-  const diagnostic = infrastructureFailureDiagnostic(parameters);
-  if (diagnostic === void 0) return;
-  if (bounceInfrastructureDeclaration !== void 0) {
-    const bounce = bounceInfrastructureDeclaration(parameters, toolCallId, ctx);
-    if (bounce !== void 0) throw bounce;
-  }
-  hostActions.failInfrastructure(
-    infrastructureFailureError(diagnostic),
-    ctx,
-    toolCallId
-  );
-}
 var INFRASTRUCTURE_FAILURE_DECLARATION_KEY, INFRASTRUCTURE_FAILURE_DIAGNOSTIC_KEY, infrastructureFailureNested, infrastructureFailureDeclarationSchema;
 var init_terminating_infrastructure = __esm({
   "src/package-contracts/terminating-infrastructure.ts"() {
     "use strict";
-    init_unknown_value();
     INFRASTRUCTURE_FAILURE_DECLARATION_KEY = "infrastructureFailure";
     INFRASTRUCTURE_FAILURE_DIAGNOSTIC_KEY = "diagnostic";
     infrastructureFailureNested = Type2.Object(
@@ -3095,20 +3073,6 @@ var init_readable_gate_item = __esm({
 });
 
 // src/submission-errors.ts
-function serializeReceipt(receipt) {
-  return readableGateItem(receipt);
-}
-function gatekeeperNonPassMessage(result) {
-  if (result.status === "continue") {
-    return serializeReceipt(result.receipt);
-  }
-  if (result.status === "transport_failure") {
-    const head = `\u95E8\u4E0B\u7701 ${result.status}\uFF08${result.stage}\uFF09\uFF1A${result.reason}`;
-    return result.submission === void 0 ? head : `${head}
-${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";
 }
@@ -3121,20 +3085,12 @@ function receivedDiscriminator(receipt, field) {
   if (!Object.hasOwn(receipt, field)) return void 0;
   return receipt[field];
 }
-var GatekeeperDecisionError, WorkerCommitReminderError, WorkerPrefixReminderError, WorkerUnfinishedReasonReminderError, ParentQueueReaskError;
+var WorkerCommitReminderError, WorkerPrefixReminderError, WorkerUnfinishedReasonReminderError, ParentQueueReaskError;
 var init_submission_errors = __esm({
   "src/submission-errors.ts"() {
     "use strict";
     init_readable_gate_item();
     init_unknown_value();
-    GatekeeperDecisionError = class extends Error {
-      result;
-      constructor(result, message) {
-        super(message ?? gatekeeperNonPassMessage(result));
-        this.name = "GatekeeperDecisionError";
-        this.result = result;
-      }
-    };
     WorkerCommitReminderError = class extends Error {
       code = "worker_commit_reminder";
       constructor() {
@@ -3692,7 +3648,6 @@ var init_gatekeeper_role = __esm({
     init_run_terminal_artifacts();
     init_unknown_value();
     init_serialize_thrown_value();
-    init_submission_errors();
     GATE_OFFICER_BY_SUBJECT = {
       worker_completion: "inspector",
       judge_compliance: "auditor",
@@ -4472,13 +4427,10 @@ function isCorrectableSubmissionError(error) {
   return error instanceof CorrectableSubmissionError;
 }
 function isCorrectableExecuteError(error) {
-  return isCorrectableSubmissionError(error) || error instanceof GatekeeperDecisionError || error instanceof ParentQueueReaskError || error instanceof WorkerCommitReminderError || error instanceof WorkerPrefixReminderError || error instanceof WorkerUnfinishedReasonReminderError;
+  return isCorrectableSubmissionError(error) || error instanceof ParentQueueReaskError || error instanceof WorkerCommitReminderError || error instanceof WorkerPrefixReminderError || error instanceof WorkerUnfinishedReasonReminderError;
 }
 function projectCorrectableExecuteRejection(error) {
   const diagnostic = errorText(error);
-  if (error instanceof GatekeeperDecisionError) {
-    return { diagnostic, details: { ...error.result } };
-  }
   if (error instanceof WorkerCommitReminderError || error instanceof WorkerPrefixReminderError || error instanceof WorkerUnfinishedReasonReminderError) {
     return { diagnostic, details: { code: error.code } };
   }
@@ -8232,11 +8184,7 @@ function admittedForLiveTicketReport(runDirectory, authority) {
     ...ticketNumber === void 0 ? {} : { ticketNumber }
   };
 }
-async function reportTicketFromHostContext(context, rawTicketNumber, authority = piDurablePrincipalAuthority) {
-  const ticketNumber = readDeclaredTicketNumber(rawTicketNumber);
-  if (ticketNumber === void 0) {
-    throw new Error("ak_report_ticket requires an identifiable ticketNumber");
-  }
+async function reportTicketFromHostContext(context, ticketNumber, authority = piDurablePrincipalAuthority) {
   const runDirectory = runDirectoryFromHostContext(context);
   if (runDirectory === void 0) {
     throw new Error("ak_report_ticket requires a per-turn run directory");
@@ -8272,7 +8220,7 @@ async function reportTicketFromHostContext(context, rawTicketNumber, authority =
     relocated: relocation !== void 0
   };
 }
-function registerReportTicketTool(roleHost) {
+function registerReportTicketTool(roleHost, hostActions) {
   if (roleHost.getAllTools().some((tool) => tool.name === REPORT_TICKET_TOOL_NAME)) return;
   roleHost.registerTool({
     name: REPORT_TICKET_TOOL_NAME,
@@ -8280,13 +8228,21 @@ function registerReportTicketTool(roleHost) {
     description: REPORT_TICKET_TOOL_DESCRIPTION,
     promptSnippet: "\u5DF2\u77E5\u7968\u53F7\u65F6\u7ACB\u5373\u7533\u62A5\uFF0C\u5305\u5F53\u573A\u5F52\u4F4D",
     parameters: reportTicketArgsSchema,
-    async execute(_toolCallId, parameters, _signal, _onUpdate, ctx) {
+    async execute(toolCallId, parameters, _signal, _onUpdate, ctx) {
       const raw = isRecord(parameters) ? parameters.ticketNumber : void 0;
-      const details = await reportTicketFromHostContext(ctx, raw);
-      return {
-        content: [],
-        details
-      };
+      const ticketNumber = readDeclaredTicketNumber(raw);
+      if (ticketNumber === void 0) {
+        throw new Error("ak_report_ticket requires an identifiable ticketNumber");
+      }
+      try {
+        const details = await reportTicketFromHostContext(ctx, ticketNumber);
+        return {
+          content: [],
+          details
+        };
+      } catch (error) {
+        hostActions.failInfrastructure(error, ctx, toolCallId);
+      }
     }
   });
 }
@@ -8479,6 +8435,14 @@ async function readAttemptScopedSubmissionRows(cwd, runId, attemptId, homeOrScop
   const { owned } = await readOwnedSubmissionRecords(cwd, runId, scope);
   return mapOwnedToSubmissionRows(owned.filter((record) => recordAttemptId(record) === attemptId));
 }
+async function readSubmissionAttemptId(cwd, runId, toolCallId, homeOrScope) {
+  const { owned } = await readOwnedSubmissionRecords(cwd, runId, resolveReadScope(homeOrScope));
+  const record = owned.find((candidate) => {
+    const payload = candidate.payload;
+    return payload?.toolCallId === toolCallId;
+  });
+  return record === void 0 ? void 0 : recordAttemptId(record);
+}
 async function readRecordedSubmissions(cwd, runId, homeOrScope) {
   return (await readRecordedSubmissionRows(cwd, runId, homeOrScope)).map((row) => row.accepted);
 }
@@ -8602,89 +8566,82 @@ function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (er
       host.registerTool({
         ...tool,
         async execute(toolCallId, params, signal, update, context) {
-          const typedTicket = isRecord(params) ? readDeclaredTicketNumber(params.ticketNumber) : void 0;
-          if (typedTicket !== void 0) {
-            await reportTicketFromHostContext(context, typedTicket);
-          }
-          const runId = runIdentity(context);
-          const attemptId = attemptIdentity(context, runId);
-          const state = await stateFor(context, runId);
-          const append = (event) => appendFor(context, runId, attemptId, event);
-          append({
-            type: "candidate",
-            attemptId,
-            toolCallId,
-            toolName: tool.name,
-            sequence: ++state.sequence,
-            role,
-            params
-          });
+          let toolThrew = false;
           let result;
+          let closed;
           try {
-            const reviewEscalate = tool.name === REVIEW_SUBMISSION_OUTPUT_TOOL_NAME && infrastructureFailureDiagnostic(params) !== void 0 && isRecord(params) && params.status === "escalate";
-            if (!reviewEscalate) {
-              failOnInfrastructureFailureDeclaration(
-                params,
-                {
-                  failInfrastructure(error, ctx) {
-                    failInfrastructure2(error, ctx);
-                  }
-                },
-                context,
-                toolCallId,
-                tool.bounceInfrastructureDeclaration
-              );
+            const typedTicket = isRecord(params) ? readDeclaredTicketNumber(params.ticketNumber) : void 0;
+            if (typedTicket !== void 0) {
+              await reportTicketFromHostContext(context, typedTicket);
             }
-            result = await tool.execute(toolCallId, params, signal, update, context);
-          } catch (error) {
-            if (isCorrectableExecuteError(error)) {
-              append({
-                type: "outcome",
-                attemptId,
-                toolCallId,
-                outcome: "correctable-rejection",
-                code: "typed-bounce",
-                diagnostic: errorText(error),
-                role,
-                accepted: params
-              });
-              throw error;
-            } else {
-              append({
-                type: "outcome",
-                attemptId,
-                toolCallId,
-                outcome: "infrastructure",
-                diagnostic: errorText(error),
-                role,
-                accepted: params
-              });
+            const runId = runIdentity(context);
+            const attemptId = attemptIdentity(context, runId);
+            const state = await stateFor(context, runId);
+            const append = (event) => appendFor(context, runId, attemptId, event);
+            append({
+              type: "candidate",
+              attemptId,
+              toolCallId,
+              toolName: tool.name,
+              sequence: ++state.sequence,
+              role,
+              params
+            });
+            try {
+              result = await tool.execute(toolCallId, params, signal, update, context);
+            } catch (error) {
+              if (isCorrectableExecuteError(error)) {
+                append({
+                  type: "outcome",
+                  attemptId,
+                  toolCallId,
+                  outcome: "correctable-rejection",
+                  code: "typed-bounce",
+                  diagnostic: errorText(error),
+                  role,
+                  accepted: params
+                });
+              } else {
+                append({
+                  type: "outcome",
+                  attemptId,
+                  toolCallId,
+                  outcome: "infrastructure",
+                  diagnostic: errorText(error),
+                  role,
+                  accepted: params
+                });
+              }
+              toolThrew = true;
               throw error;
             }
+            if (result.terminate === false) return result;
+            closed = {
+              role,
+              kind: "accepted",
+              accepted: params
+            };
+            const sealHead = captureWorktreeHead(context.cwd);
+            append({
+              type: "sealed",
+              attemptId,
+              toolCallId,
+              role,
+              accepted: params
+            });
+            const rawLens = typeof host.getFlag === "function" ? host.getFlag("ak-review-lens") : void 0;
+            landTicketProgressForSealedSubmission({
+              context,
+              role,
+              accepted: params,
+              sealHead,
+              ...rawLens === "completeness" || rawLens === "correctness" ? { lens: rawLens } : {}
+            });
+          } catch (error) {
+            if (toolThrew) throw error;
+            return failInfrastructure2(error, context, toolCallId);
           }
-          if (result.terminate === false) return result;
-          const closed = {
-            role,
-            kind: "accepted",
-            accepted: params
-          };
-          const sealHead = captureWorktreeHead(context.cwd);
-          append({
-            type: "sealed",
-            attemptId,
-            toolCallId,
-            role,
-            accepted: params
-          });
-          const rawLens = typeof host.getFlag === "function" ? host.getFlag("ak-review-lens") : void 0;
-          landTicketProgressForSealedSubmission({
-            context,
-            role,
-            accepted: params,
-            sealHead,
-            ...rawLens === "completeness" || rawLens === "correctness" ? { lens: rawLens } : {}
-          });
-          await projectClosure(closed, context);
+          await projectClosure(closed, context, toolCallId);
           return result;
         }
       });
@@ -8701,9 +8658,7 @@ var init_submission_ledger = __esm({
     init_sitian_facade();
     init_run_lifecycle();
     init_submission_correctable_error();
-    init_terminating_infrastructure();
     init_report_ticket_tool();
-    init_review_submission();
     init_run_ticket_number();
     init_ticket_progress();
     init_unknown_value();
@@ -12053,11 +12008,21 @@ async function runJudgeGates(input) {
     if (await input.gateAlreadyConverged(subject)) continue;
     const pass = await input.runGate(subject);
     const received = pass?.status;
-    if (pass === void 0 || (typeof received !== "string" || !REVIEW_QUEUE_STATUSES.has(received) && received !== "needs_reask")) {
-      throw new Error("judge gate returned no conclusion");
+    if (pass === void 0 || (typeof received !== "string" || !REVIEW_QUEUE_STATUSES.has(received) && received !== "needs_reask" && received !== "transport_failure" && received !== "no_receipt")) {
+      return {
+        status: "needs_reask",
+        passes: [{
+          subject,
+          status: "needs_reask",
+          receipt: pass?.receipt ?? { reason: "judge gate returned no conclusion" },
+          ...pass?.runId === void 0 ? {} : { runId: pass.runId },
+          ...pass?.runDirectory === void 0 ? {} : { runDirectory: pass.runDirectory },
+          ...pass?.terminal === void 0 ? {} : { terminal: pass.terminal }
+        }]
+      };
     }
     const status = received;
-    if (status === "needs_reask") {
+    if (status === "needs_reask" || status === "transport_failure" || status === "no_receipt") {
       return {
         status,
         passes: [{
@@ -12066,7 +12031,8 @@ async function runJudgeGates(input) {
           receipt: pass.receipt,
           ...pass.runId === void 0 ? {} : { runId: pass.runId },
           ...pass.runDirectory === void 0 ? {} : { runDirectory: pass.runDirectory },
-          ...pass.terminal === void 0 ? {} : { terminal: pass.terminal }
+          ...pass.terminal === void 0 ? {} : { terminal: pass.terminal },
+          ...pass.reason === void 0 ? {} : { reason: pass.reason }
         }]
       };
     }
@@ -12075,7 +12041,8 @@ async function runJudgeGates(input) {
       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 (status === "continue" || status === "escalate") return { status, passes };
   }
@@ -12188,6 +12155,17 @@ function createDefaultGateOfficerSummon(options) {
     });
   };
 }
+function presentGateOutcome(fields) {
+  return {
+    status: fields.status,
+    officer: fields.officer,
+    receipt: fields.receipt,
+    ...typeof fields.runId === "string" && fields.runId.trim() !== "" ? { runId: fields.runId } : {},
+    ...typeof fields.runDirectory === "string" && fields.runDirectory.trim() !== "" ? { runDirectory: fields.runDirectory } : {},
+    ...fields.terminal === void 0 ? {} : { terminal: fields.terminal },
+    ...fields.reason === void 0 ? {} : { reason: fields.reason }
+  };
+}
 async function requireSubmissionGate(options) {
   let reask;
   let reasksSpent = 0;
@@ -12205,7 +12183,7 @@ async function requireSubmissionGate(options) {
       ...reask === void 0 ? {} : { reask }
     });
     const gatekeeper = projected.result;
-    if (projected.summoned !== void 0 && options.toolCallId.trim() !== "" && (gatekeeper.status === "converged" || gatekeeper.status === "continue" || gatekeeper.status === "escalate" || gatekeeper.status === "needs_reask" || gatekeeper.status === "transport_failure")) {
+    if (projected.summoned !== void 0 && options.toolCallId.trim() !== "" && (gatekeeper.status === "converged" || gatekeeper.status === "continue" || gatekeeper.status === "escalate" || gatekeeper.status === "needs_reask" || gatekeeper.status === "transport_failure" || gatekeeper.status === "no_receipt")) {
       const officerRunDirectory = await directoryForSummonedOfficer(
         projected.officer,
         projected.summoned
@@ -12215,61 +12193,69 @@ async function requireSubmissionGate(options) {
       }
     }
     if (gatekeeper.status === "converged") {
-      return {
+      return presentGateOutcome({
         status: "converged",
         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 } : {},
-        // Keep the officer terminal for escalate / unsettled surfaces; parent
-        // finals do not project other-seat tables (#1195).
-        ...projected.summoned?.terminal === void 0 ? {} : { terminal: projected.summoned.terminal }
-      };
+        runId: gatekeeper.runId,
+        runDirectory: projected.summoned?.runDirectory,
+        terminal: projected.summoned?.terminal
+      });
     }
     if (gatekeeper.status === "continue") {
-      return {
+      return presentGateOutcome({
         status: "continue",
         officer: projected.officer,
         receipt: gatekeeper.receipt,
-        ...typeof gatekeeper.runId === "string" && gatekeeper.runId.trim() !== "" ? { runId: gatekeeper.runId } : {}
-      };
+        runId: gatekeeper.runId
+      });
     }
     if (gatekeeper.status === "needs_reask") {
       const nestedIncomplete = projected.summoned?.terminal?.roleOutcome.kind === "accepted" && projected.summoned.terminal.roleOutcome.decisiveFacts?.directionUnsettled === true;
       if (nestedIncomplete || reasksSpent >= reaskLimit) {
-        return {
+        return presentGateOutcome({
           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 }
-        };
+          runId: gatekeeper.runId,
+          runDirectory: projected.summoned?.runDirectory,
+          terminal: projected.summoned?.terminal
+        });
       }
       reasksSpent += 1;
       reask = officerConclusionReask(gatekeeper.receivedStatus);
       continue;
     }
     if (gatekeeper.status === "transport_failure") {
-      const failure = Object.assign(new Error(gatekeeper.reason), {
-        name: "GatekeeperTransportFailure",
-        ...gatekeeper.submission === void 0 ? {} : { submission: gatekeeper.submission }
+      return presentGateOutcome({
+        status: "transport_failure",
+        officer: projected.officer,
+        receipt: gatekeeper.submission ?? { reason: gatekeeper.reason },
+        reason: gatekeeper.reason,
+        runId: projected.summoned?.terminal?.runId,
+        runDirectory: projected.summoned?.runDirectory,
+        terminal: projected.summoned?.terminal
       });
-      options.hostActions.failInfrastructure(failure, options.context, options.toolCallId);
     }
     if (gatekeeper.status === "escalate") {
-      return {
+      return presentGateOutcome({
         status: "escalate",
         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 } : {},
-        // Keep the actual officer terminal so callers resume that seat.
-        ...projected.summoned?.terminal === void 0 ? {} : { terminal: projected.summoned.terminal }
-      };
+        runId: gatekeeper.runId,
+        runDirectory: projected.summoned?.runDirectory,
+        terminal: projected.summoned?.terminal
+      });
     }
-    options.hostActions.bindSubmissionNonPass(options.toolCallId, gatekeeper);
-    throw new GatekeeperDecisionError(gatekeeper);
+    return presentGateOutcome({
+      status: "no_receipt",
+      officer: projected.officer,
+      receipt: gatekeeper.facts ?? { reason: gatekeeper.reason },
+      reason: gatekeeper.reason,
+      runId: projected.summoned?.terminal?.runId,
+      runDirectory: projected.summoned?.runDirectory,
+      terminal: projected.summoned?.terminal
+    });
   }
 }
 var init_submission_gate = __esm({
@@ -14295,6 +14281,7 @@ __export(instruction_seat_run_exports, {
   NOTARY_FIXED_DISPATCH: () => NOTARY_FIXED_DISPATCH,
   buildInstructionSeatTurnRequest: () => buildInstructionSeatTurnRequest,
   continueParentAfterChild: () => continueParentAfterChild,
+  presentAuditedOriginalOfUnsettledOfficer: () => presentAuditedOriginalOfUnsettledOfficer,
   resolveReviewSeatDialogueBody: () => resolveReviewSeatDialogueBody,
   runPublicInstructionSeat: () => runPublicInstructionSeat,
   runPublicInstructionSeatResume: () => runPublicInstructionSeatResume
@@ -14358,6 +14345,60 @@ async function presentUnsettledOfficer(officer, io, runDirectory) {
   await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, runDirectory);
   return terminal;
 }
+async function presentAuditedOriginalVolume(turn, io) {
+  const admitted = turn.admitted;
+  if (turn.terminal === void 0 || admitted === void 0) return;
+  await presentTerminal(
+    turn.terminal,
+    { ...io, omitFailureStderrDiagnostic: true },
+    admitted.runDirectory
+  );
+}
+async function incompleteAuditWithoutOfficerVolume(turn, admitted, io, diagnostic) {
+  await presentAuditedOriginalVolume(turn, io);
+  io.stderr(diagnostic);
+  return { exitCode: 1, admitted };
+}
+async function presentAuditedOriginalOfOfficer(officer, presentedRunId, env, io) {
+  if (!GATE_CHILD_ROLES.has(officer.role)) return;
+  const audited = officer.correlationId;
+  if (audited === void 0 || audited === presentedRunId) return;
+  const auditedSource = admittedSourceRunPath(officer);
+  const parent = await loadResumablePublicRole(
+    env.home,
+    audited,
+    env.principalAuthority,
+    auditedSource === void 0 ? void 0 : { runDirectory: auditedSource }
+  );
+  if (!AUDITED_ROLES.has(parent.admitted.role)) return;
+  const sealId = readAdmittedAuditedSubmissionToolCallId(officer.runDirectory);
+  const courtAttemptId = sealId === void 0 ? (await readCurrentCourt(parent.admitted.runDirectory))?.courtAttemptId : await readSubmissionAttemptId(
+    parent.admitted.projectRoot,
+    parent.admitted.runId,
+    sealId,
+    ledgerReadScope(parent.admitted)
+  );
+  if (sealId !== void 0 && courtAttemptId === void 0) return;
+  const terminal = await trySettlePublicSeat(
+    parent.admitted,
+    env.principalAuthority,
+    {
+      ...courtAttemptId === void 0 ? {} : { courtAttemptId },
+      previewOnly: true,
+      ...packageFaultScope(parent.admitted, env, io)
+    }
+  );
+  if (terminal?.roleOutcome.kind !== "accepted") return;
+  await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, parent.admitted.runDirectory);
+}
+function leavesAuditedVerdictUnsettled(result) {
+  const outcome = result.terminal?.roleOutcome;
+  return result.exitCode !== 0 || outcome?.kind === "no_receipt" || outcome?.decisiveFacts?.directionUnsettled === true;
+}
+async function presentAuditedOriginalOfUnsettledOfficer(result, env, io) {
+  if (result.admitted === void 0 || !leavesAuditedVerdictUnsettled(result)) return;
+  await presentAuditedOriginalOfOfficer(result.admitted, void 0, env, io);
+}
 async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io, message = unreadablePostSubmissionStatus(admitted, terminal)) {
   if (message === void 0) return void 0;
   const next = withUnreadableReask(env);
@@ -15224,7 +15265,7 @@ async function queueConclusionFromChild(child, env, io) {
     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 } } };
+    return { stop: { exitCode: 0, admitted: child, ...terminal === void 0 ? {} : { terminal } } };
   }
   let current = child;
   let budgetEnv = envForCourtContinue(env);
@@ -15246,7 +15287,7 @@ async function queueConclusionFromChild(child, env, io) {
       officerConclusionReask(status)
     );
     if (reasked === void 0 || isUnreadableReaskExhausted(reasked)) {
-      return { stop: { exitCode: 0, ...terminal === void 0 ? {} : { terminal } } };
+      return { stop: { exitCode: 0, admitted: current, ...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) {
@@ -15282,6 +15323,9 @@ async function continueParentAfterChild(parentRunId, child, env, io) {
   const resolved = await queueConclusionFromChild(child, env, io);
   if (resolved !== void 0 && "stop" in resolved) {
     const stopped = resolved.stop;
+    if (stopped.admitted !== void 0 && (leavesAuditedVerdictUnsettled(stopped) || heldUnreadableTerminal(stopped.terminal))) {
+      await presentAuditedOriginalOfOfficer(stopped.admitted, void 0, env, io);
+    }
     if (stopped.exitCode === 0 && heldUnreadableTerminal(stopped.terminal) && stopped.terminal !== void 0 && stopped.admitted !== void 0) {
       const terminal = await presentUnsettledOfficer(
         stopped.terminal,
@@ -15449,20 +15493,27 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         }, envForCourtContinue(env), io);
       }
       if (decision.status === "received") {
-        if (lastSummon?.terminal === void 0) {
-          throw new Error("doctor audit kept an unreadable reply with no terminal");
+        if (lastSummon?.terminal !== void 0) {
+          await presentAuditedOriginalVolume(turn, io);
+          const officerAdmitted = lastSummon.admitted;
+          const officerDir = officerAdmitted?.runDirectory ?? lastSummon.runDirectory ?? admitted.runDirectory;
+          const terminal = await presentUnsettledOfficer(lastSummon.terminal, io, officerDir);
+          return {
+            exitCode: 0,
+            ...officerAdmitted === void 0 ? { admitted } : { admitted: officerAdmitted },
+            terminal
+          };
         }
-        const officerAdmitted = lastSummon.admitted;
-        const officerDir = officerAdmitted?.runDirectory ?? lastSummon.runDirectory ?? admitted.runDirectory;
-        const terminal = await presentUnsettledOfficer(lastSummon.terminal, io, officerDir);
-        return {
-          exitCode: 0,
-          ...officerAdmitted === void 0 ? { admitted } : { admitted: officerAdmitted },
-          terminal
-        };
+        return incompleteAuditWithoutOfficerVolume(
+          turn,
+          admitted,
+          io,
+          "doctor audit kept an unreadable reply with no terminal"
+        );
       }
       if (decision.status !== "converged") {
         if (lastSummon?.terminal !== void 0) {
+          await presentAuditedOriginalVolume(turn, io);
           await presentTerminal(lastSummon.terminal, { ...io, omitFailureStderrDiagnostic: true }, lastSummon.admitted?.runDirectory ?? admitted.runDirectory);
           return {
             exitCode: lastSummon.exitCode,
@@ -15470,7 +15521,8 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
             terminal: lastSummon.terminal
           };
         }
-        throw new Error(`doctor audit did not converge: ${decision.status}`);
+        const diagnostic = decision.status === "transport_failure" && "diagnostic" in decision && typeof decision.diagnostic === "string" ? decision.diagnostic : `doctor audit did not converge: ${decision.status}`;
+        return incompleteAuditWithoutOfficerVolume(turn, admitted, io, diagnostic);
       }
     }
   } else {
@@ -15489,14 +15541,7 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
       submission: accepted,
       summonOfficer,
       ...env.autoResumeLimit === void 0 ? {} : { autoResumeLimit: env.autoResumeLimit },
-      ...env.signal === void 0 ? {} : { signal: env.signal },
-      hostActions: {
-        failInfrastructure(error) {
-          throw error;
-        },
-        bindSubmissionNonPass() {
-        }
-      }
+      ...env.signal === void 0 ? {} : { signal: env.signal }
     });
     if (admitted.role === "judge") {
       const judgeGateOrder = JUDGE_GATES.map(gateOfficerForSubject);
@@ -15511,45 +15556,83 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         chain = { status: "converged", passes: [] };
       } else {
         const pass = await runGate(subject);
-        if (pass === void 0) throw new Error("audit gate returned no conclusion");
-        chain = {
-          status: pass.status,
-          passes: [{
-            subject,
+        if (pass === void 0) {
+          chain = {
+            status: "needs_reask",
+            passes: [{
+              subject,
+              status: "needs_reask",
+              receipt: { reason: "audit gate returned no conclusion" }
+            }]
+          };
+        } else {
+          chain = {
             status: pass.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: [{
+              subject,
+              status: pass.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 },
+              ...pass.reason === void 0 ? {} : { reason: pass.reason }
+            }]
+          };
+        }
       }
     }
-    if (chain.status === "needs_reask") {
+    if (chain.status === "needs_reask" || chain.status === "transport_failure" || chain.status === "no_receipt") {
       const pass = chain.passes.at(-1);
       const officerTerminal = pass?.terminal;
-      if (officerTerminal === void 0) throw new Error("unreadable audit has no terminal result");
       const officerRunDirectory = pass?.runDirectory;
       const officerRunId = pass?.runId ?? (officerRunDirectory === void 0 ? void 0 : runIdFromRunDirectory(officerRunDirectory));
-      if (officerRunId === void 0) throw new Error("unreadable audit has no resumable run identity");
-      const officer = await loadResumablePublicRole(
-        env.home,
-        officerRunId,
-        env.principalAuthority,
-        officerRunDirectory === void 0 ? void 0 : { runDirectory: officerRunDirectory }
-      );
-      const terminal = await presentUnsettledOfficer(
-        officerTerminal,
+      if (officerTerminal !== void 0 && officerRunId !== void 0) {
+        await presentAuditedOriginalVolume(turn, io);
+        const officer = await loadResumablePublicRole(
+          env.home,
+          officerRunId,
+          env.principalAuthority,
+          officerRunDirectory === void 0 ? void 0 : { runDirectory: officerRunDirectory }
+        );
+        await presentAuditedOriginalOfOfficer(officer.admitted, admitted.runId, env, io);
+        if (chain.status === "needs_reask" || chain.status === "no_receipt") {
+          const terminal = await presentUnsettledOfficer(
+            officerTerminal,
+            io,
+            officer.admitted.runDirectory
+          );
+          return { exitCode: 0, admitted: officer.admitted, terminal };
+        }
+        await presentTerminal(
+          officerTerminal,
+          { ...io, omitFailureStderrDiagnostic: true },
+          officer.admitted.runDirectory
+        );
+        return {
+          exitCode: officerTerminal.roleOutcome.kind === "failure" ? 1 : 0,
+          admitted: officer.admitted,
+          terminal: officerTerminal
+        };
+      }
+      return incompleteAuditWithoutOfficerVolume(
+        turn,
+        admitted,
         io,
-        officer.admitted.runDirectory
+        pass?.reason ?? (chain.status === "transport_failure" ? "audit officer transport failure with no presentable volume" : chain.status === "no_receipt" ? "audit officer no_receipt with no presentable volume" : "unreadable audit has no terminal result")
       );
-      return { exitCode: 0, admitted: officer.admitted, terminal };
     }
     if (chain.status === "escalate") {
       const escalation = chain.passes.at(-1);
       const escalatedRunDirectory = escalation?.runDirectory;
       const escalatedRunId = escalation?.runId ?? (escalatedRunDirectory === void 0 ? void 0 : runIdFromRunDirectory(escalatedRunDirectory));
-      if (escalatedRunId === void 0) throw new Error("escalated audit has no resumable run identity");
+      if (escalatedRunId === void 0) {
+        return incompleteAuditWithoutOfficerVolume(
+          turn,
+          admitted,
+          io,
+          "escalated audit has no resumable run identity"
+        );
+      }
       const officer = await loadResumablePublicRole(
         env.home,
         escalatedRunId,
@@ -15564,7 +15647,14 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
           { ...await readCurrentCourt(officer.admitted.runDirectory), ...packageFaultScope(officer.admitted, env, io) }
         );
       }
-      if (terminal === void 0) throw new Error("escalated audit has no terminal result");
+      if (terminal === void 0) {
+        return incompleteAuditWithoutOfficerVolume(
+          turn,
+          officer.admitted,
+          io,
+          "escalated audit has no terminal result"
+        );
+      }
       await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, officer.admitted.runDirectory);
       return { exitCode: 0, admitted: officer.admitted, terminal };
     }
@@ -18866,19 +18956,19 @@ async function runAkRole(argv, env) {
         parts.credentials,
         invocationFromParsed(parsed)
       );
-      const result = await runPublicInstructionSeatResume(
-        resumeRequest,
-        createRoleEnvironment(env, {
-          role: seatRole,
-          home,
-          agentDir: parts.agentDir,
-          cwd: parts.cwd,
-          credentials: parts.credentials,
-          seat,
-          config: parts.config
-        }),
-        io
-      );
+      const resumeEnv = createRoleEnvironment(env, {
+        role: seatRole,
+        home,
+        agentDir: parts.agentDir,
+        cwd: parts.cwd,
+        credentials: parts.credentials,
+        seat,
+        config: parts.config
+      });
+      const result = await runPublicInstructionSeatResume(resumeRequest, resumeEnv, io);
+      if (result.admitted?.runId === resumeRequest.runId) {
+        await presentAuditedOriginalOfUnsettledOfficer(result, resumeEnv, io);
+      }
       let current = result;
       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;
@@ -19502,9 +19592,11 @@ async function projectAuditorTerminal(summoned) {
   const outcome = summoned.terminal?.roleOutcome;
   if (outcome === void 0) {
     const detail = summoned.stderr?.trim();
-    throw new Error(
-      detail && detail.length > 0 ? `Auditor public summon produced no terminal (exit ${summoned.exitCode}: ${detail})` : `Auditor public summon produced no terminal (exit ${summoned.exitCode})`
-    );
+    return {
+      status: "transport_failure",
+      diagnostic: detail && detail.length > 0 ? `Auditor public summon produced no terminal (exit ${summoned.exitCode}: ${detail})` : `Auditor public summon produced no terminal (exit ${summoned.exitCode})`,
+      ...summoned.terminal === void 0 ? {} : { terminal: summoned.terminal }
+    };
   }
   const usage = await usageFromSummonedSession(summoned);
   if (outcome.kind === "no_receipt") {
@@ -21065,6 +21157,7 @@ init_engine_material();
 init_engine_detour();
 init_engine_detour_usage();
 init_run_terminal_artifacts();
+init_serialize_thrown_value();
 import { Type as Type18 } from "typebox";
 var engineDetourArgsSchema = Type18.Object(
   {
@@ -21085,6 +21178,27 @@ function isCallerCancellation(error, signal) {
 function asError(error, fallback) {
   return error instanceof Error ? error : new Error(String(error).trim() || fallback);
 }
+function engineFailureResult(input) {
+  const details = {
+    tool: ENGINE_DETOUR_TOOL_NAME,
+    ...input.code === void 0 ? {} : { code: input.code },
+    ...input.stdout === void 0 ? {} : { stdout: input.stdout },
+    ...input.stderr === void 0 ? {} : { stderr: input.stderr },
+    ...input.errorCode === void 0 ? {} : { errorCode: input.errorCode },
+    ...input.ledgerError === void 0 ? {} : { ledgerError: input.ledgerError }
+  };
+  let text = input.text;
+  if (input.ledgerError !== void 0 && input.ledgerError.length > 0) {
+    if (text.length > 0 && !text.endsWith("\n")) text += "\n";
+    text += input.ledgerError;
+  }
+  return {
+    content: [{ type: "text", text }],
+    details,
+    // Identified detour failure is a tool error, not a seat-run death (#1213).
+    isError: true
+  };
+}
 function createEngineDetourToolDefinition(input) {
   const engineName = input.engineName;
   const engineModel = input.engineModel;
@@ -21098,13 +21212,6 @@ function createEngineDetourToolDefinition(input) {
     async execute(toolCallId, params, signal, _onUpdate, ctx) {
       const args = params;
       const argv = Array.isArray(args.argv) ? args.argv : [];
-      if (argv.length === 0 || argv.some((part) => typeof part !== "string" || part.length === 0)) {
-        input.fail(
-          new Error("\u52B3\u52A1\u5F15\u64CE argv \u987B\u4E3A\u975E\u7A7A\u5B57\u7B26\u4E32\u6570\u7EC4"),
-          toolCallId,
-          ctx
-        );
-      }
       const sessionParent = ctx.sessionManager?.getSessionFile?.();
       const startedAt = Date.now();
       const runDirectory = typeof ctx.runDirectory === "string" && ctx.runDirectory.length > 0 ? ctx.runDirectory : void 0;
@@ -21125,25 +21232,21 @@ function createEngineDetourToolDefinition(input) {
           ...observed2.stdoutByteLength === void 0 ? {} : { stdoutByteLength: observed2.stdoutByteLength }
         });
       };
-      const failAfterLedger = (engineCause, observed2, aggregateMessage) => {
+      const recordCallOrLedgerError = (observed2) => {
         try {
           recordCall(observed2);
+          return void 0;
         } catch (recordError) {
-          input.fail(
-            new AggregateError(
-              [
-                engineCause,
-                asError(recordError, "engine detour usage ledger write failed")
-              ],
-              aggregateMessage,
-              { cause: engineCause }
-            ),
-            toolCallId,
-            ctx
-          );
+          return serializeThrownValue(recordError);
         }
-        input.fail(engineCause, toolCallId, ctx);
       };
+      if (argv.length === 0 || argv.some((part) => typeof part !== "string" || part.length === 0)) {
+        const ledgerError = recordCallOrLedgerError({});
+        return engineFailureResult({
+          text: "\u52B3\u52A1\u5F15\u64CE argv \u987B\u4E3A\u975E\u7A7A\u5B57\u7B26\u4E32\u6570\u7EC4",
+          ...ledgerError === void 0 ? {} : { ledgerError }
+        });
+      }
       let result;
       try {
         result = await runEngineDetourOnce({
@@ -21153,20 +21256,26 @@ function createEngineDetourToolDefinition(input) {
         });
       } catch (error) {
         if (isCallerCancellation(error, signal)) throw error;
-        return failAfterLedger(
-          asError(error, "\u52B3\u52A1\u5F15\u64CE spawn \u5931\u8D25"),
-          {},
-          "engine detour spawn and usage ledger both failed"
-        );
+        const engineError = asError(error, "\u52B3\u52A1\u5F15\u64CE spawn \u5931\u8D25");
+        const ledgerError = recordCallOrLedgerError({});
+        const errno = typeof engineError.code === "string" ? engineError.code : void 0;
+        return engineFailureResult({
+          text: engineError.message,
+          ...errno === void 0 ? {} : { errorCode: errno },
+          ...ledgerError === void 0 ? {} : { ledgerError }
+        });
       }
       const stdoutByteLength = engineDetourStdoutByteLength(result.stdout);
       const observed = { code: result.code, stdoutByteLength };
       if (isEngineDetourFailure(result)) {
-        return failAfterLedger(
-          new Error(engineDetourFailureDiagnostic(result)),
-          observed,
-          "engine detour child-close and usage ledger both failed"
-        );
+        const ledgerError = recordCallOrLedgerError(observed);
+        return engineFailureResult({
+          text: engineDetourFailureSeatText(result),
+          code: result.code,
+          stdout: result.stdout,
+          stderr: result.stderr,
+          ...ledgerError === void 0 ? {} : { ledgerError }
+        });
       }
       recordCall(observed);
       return {
@@ -21180,7 +21289,7 @@ function createEngineDetourToolDefinition(input) {
     }
   };
 }
-function registerEngineDetourTool(roleHost, hostActions) {
+function registerEngineDetourTool(roleHost) {
   const getFlag = (name) => roleHost.getFlag(name);
   const engineName = resolveEngineName(getFlag);
   if (engineName === void 0) {
@@ -21189,10 +21298,7 @@ function registerEngineDetourTool(roleHost, hostActions) {
   const engineModel = resolveEngineModel(getFlag);
   const definition = createEngineDetourToolDefinition({
     engineName,
-    ...engineModel === void 0 ? {} : { engineModel },
-    fail(error, toolCallId, ctx) {
-      hostActions.failInfrastructure(error, ctx, toolCallId);
-    }
+    ...engineModel === void 0 ? {} : { engineModel }
   });
   roleHost.registerTool(definition);
   return true;
@@ -23137,7 +23243,7 @@ function publicNavigatorSettlement(role, phase, event) {
   }
   return { kind: "accepted", role, phase, ...status === void 0 ? {} : { status } };
 }
-async function projectClosedSubmissionLifecycle(closed, context, phase, recordAccepted, settle) {
+async function projectClosedSubmissionLifecycle(closed, context, phase, recordAccepted, settle, failRecord) {
   recordAccepted();
   const closure = {
     toolName: navigatorOutputTool(closed.role),
@@ -23148,10 +23254,14 @@ async function projectClosedSubmissionLifecycle(closed, context, phase, recordAc
   try {
     navigator = await settle(publicNavigatorSettlement(closed.role, phase, closure));
   } finally {
-    context.sessionManager.appendCustomEntry?.("ak-role-submission-closure", {
-      ...closure,
-      ...navigator === void 0 ? {} : { navigator }
-    });
+    try {
+      context.sessionManager.appendCustomEntry?.("ak-role-submission-closure", {
+        ...closure,
+        ...navigator === void 0 ? {} : { navigator }
+      });
+    } catch (error) {
+      failRecord(error);
+    }
   }
 }
 function createFiledOfficerRuntime(roleHost, spec, dependencies) {
@@ -23339,30 +23449,28 @@ function readDiaristRunCoordinates(ctx) {
   };
 }
 var DIARIST_BOUNDS_REASK = "\u8FB9\u754C\u65E0\u6CD5\u4F7F\u7528\u3002\u591A\u7968\u8BF7\u9010\u7968\u91CD\u4EA4 ticketSessions\uFF0C\u5355\u7968\u91CD\u4EA4 sessions\uFF1B\u6BCF\u5377 path + ranges\uFF0C\u6BCF\u7AEF\u4EE5\u539F\u751F id \u6216\u672C\u8F6E\u884C\u53F7\u4E8C\u9009\u4E00\u6307\u540D\u3002";
-function createDiaristRoleRuntime(roleHost, dependencies) {
+function createDiaristRoleRuntime(roleHost, dependencies, hostActions) {
   return createFiledOfficerRuntime(
     roleHost,
     {
       role: "diarist",
       tool: DIARIST_TOOL_SPEC,
       soulTag: "diarist",
-      beforeAccept: async ({ parameters, ctx }) => {
+      beforeAccept: async ({ toolCallId, parameters, ctx }) => {
         const submitted = isRecord(parameters) ? parameters : void 0;
         const status = submitted?.status;
         if (status !== "completed") return parameters;
         const assertion = readDiaristTicketAssertion(submitted);
         const ticketNumber = assertion.kind === "ticket" ? assertion.ticketNumber : void 0;
-        if (ticketNumber !== void 0) {
-          await reportTicketFromHostContext(ctx, ticketNumber);
-        }
-        const coords = readDiaristRunCoordinates(ctx);
-        const multiTicket = submitted?.ticketSessions != null;
-        const singleSessions = submitted && !multiTicket ? projectDiaristSessions(parameters) : void 0;
-        const ticketSessions = submitted && multiTicket ? projectDiaristTicketSessions(submitted) : singleSessions === void 0 ? void 0 : [{ ticketNumber: ticketNumber ?? null, sessions: singleSessions }];
-        if (ticketSessions === void 0) {
-          throw new ParentQueueReaskError(DIARIST_BOUNDS_REASK);
-        }
         try {
+          if (ticketNumber !== void 0) await reportTicketFromHostContext(ctx, ticketNumber);
+          const coords = readDiaristRunCoordinates(ctx);
+          const multiTicket = submitted?.ticketSessions != null;
+          const singleSessions = submitted && !multiTicket ? projectDiaristSessions(parameters) : void 0;
+          const ticketSessions = submitted && multiTicket ? projectDiaristTicketSessions(submitted) : singleSessions === void 0 ? void 0 : [{ ticketNumber: ticketNumber ?? null, sessions: singleSessions }];
+          if (ticketSessions === void 0) {
+            throw new ParentQueueReaskError(DIARIST_BOUNDS_REASK);
+          }
           await commitDiaristProjection({
             cwd: coords.projectRoot,
             home: coords.home,
@@ -23377,7 +23485,7 @@ function createDiaristRoleRuntime(roleHost, dependencies) {
 ${error.message}`
             );
           }
-          throw error;
+          hostActions.failInfrastructure(error, ctx, toolCallId);
         }
         return parameters;
       }
@@ -23464,8 +23572,8 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
         }
         return entries;
       }, [])),
-      failInfrastructure,
-      async (closed, context) => projectClosedSubmission(closed, context)
+      (error, ctx, toolCallId) => hostActions.failInfrastructure(error, ctx, toolCallId),
+      async (closed, context, toolCallId) => projectClosedSubmission(closed, context, toolCallId)
     );
     roleHost.registerFlag(ROLE_FLAG.name, ROLE_FLAG.definition);
     for (const flag of REVIEWER_TRANSPORT_FLAGS) {
@@ -23503,7 +23611,6 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
     let navigatorSessionParent;
     let navigatorCwd;
     const pendingInfrastructureFailures = /* @__PURE__ */ new Map();
-    const pendingSubmissionNonPassByToolCallId = /* @__PURE__ */ new Map();
     let engineDetourRegistered = false;
     let receiptDelivery = createReceiptDeliveryPolicy(deliveryLimit);
     let noReceiptRecorded = false;
@@ -23576,13 +23683,14 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
       await pending;
       return pendingNavigatorPresentation?.event;
     };
-    projectClosedSubmission = async (closed, context) => {
+    projectClosedSubmission = async (closed, context, toolCallId) => {
       await projectClosedSubmissionLifecycle(
         closed,
         context,
         navigatorPhase(roleHost, closed.role),
         () => receiptDelivery.recordAccepted(),
-        settleNavigatorProjection
+        settleNavigatorProjection,
+        (error) => hostActions.failInfrastructure(error, context, toolCallId)
       );
     };
     roleHost.on("input", (event, ctx) => {
@@ -23684,14 +23792,18 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
         }
       }
       const settlement = isRoleInfrastructureFailure || outputClassification?.kind === "infrastructure" ? publicNavigatorSettlement(role, navigatorPhase(roleHost, role), classified) : void 0;
-      await settleNavigatorProjection(settlement);
-      if (infrastructureDetails !== void 0) {
-        return { isError: true };
+      let projectionFailure;
+      try {
+        await settleNavigatorProjection(settlement);
+      } catch (error) {
+        if (infrastructureDetails === void 0) throw error;
+        projectionFailure = errorText(error);
       }
-      const submissionNonPass = pendingSubmissionNonPassByToolCallId.get(event.toolCallId);
-      if (submissionNonPass !== void 0) {
-        pendingSubmissionNonPassByToolCallId.delete(event.toolCallId);
-        return { details: submissionNonPass, isError: true };
+      if (infrastructureDetails !== void 0) {
+        return {
+          isError: true,
+          details: projectionFailure === void 0 ? infrastructureDetails : { ...infrastructureDetails, projectionFailure }
+        };
       }
     });
     roleHost.on("agent_end", async (event, ctx) => {
@@ -23707,15 +23819,17 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
         const prose = lastAssistantProse(event.messages);
         if (prose !== void 0 && prose.trim() !== "") {
           const accepted = { prose };
+          const toolCallId = `navigator-prose-exit:${randomUUID7()}`;
           await sealAcceptedSubmission({
             context: ctx,
             role: "navigator",
             accepted,
-            toolCallId: `navigator-prose-exit:${randomUUID7()}`
+            toolCallId
           });
           await projectClosedSubmission(
             { role: "navigator", kind: "accepted", accepted },
-            ctx
+            ctx,
+            toolCallId
           );
           return;
         }
@@ -23817,7 +23931,6 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
         pendingNavigatorSettlement = void 0;
         disposeNavigatorAttendanceNonBlocking(attendanceToDispose);
         pendingInfrastructureFailures.clear();
-        pendingSubmissionNonPassByToolCallId.clear();
       }
     });
     const hostActions = {
@@ -23826,9 +23939,6 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
           pendingInfrastructureFailures.set(toolCallId, buildPendingInfrastructureFailure(error));
         }
         failInfrastructure(error, ctx);
-      },
-      bindSubmissionNonPass(toolCallId, result) {
-        pendingSubmissionNonPassByToolCallId.set(toolCallId, result);
       }
     };
     const requireRoleSoul = (role) => dependencies.loadRoleSoul(role);
@@ -23908,7 +24018,8 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
       roleHost,
       {
         loadSoul: () => requireRoleSoul("diarist")
-      }
+      },
+      hostActions
     );
     const secretariat = createSecretariatRoleRuntime(roleHost, {
       loadSoul: () => requireRoleSoul("secretariat")
@@ -24006,7 +24117,6 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
       navigatorDeliveryClosed = false;
       pendingNavigatorSettlement = void 0;
       pendingInfrastructureFailures.clear();
-      pendingSubmissionNonPassByToolCallId.clear();
       navigatorWorkContext = void 0;
       envelopeHost.startKeepalive(ctx);
       const rawRole = roleHost.getFlag(ROLE_FLAG.name);
@@ -24122,13 +24232,13 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
           }
         }
         await executeActivationStage(entry.role, activationStage(entry.role, activateByRole), { clock, writeTrace });
-        registerReportTicketTool(roleHost);
+        registerReportTicketTool(roleHost, hostActions);
         roleHost.setActiveTools([
           .../* @__PURE__ */ new Set([...roleHost.getActiveTools(), REPORT_TICKET_TOOL_NAME])
         ]);
         roleReferenceMaterials = await dependencies.loadRoleReferenceMaterials?.(entry.role) ?? "";
         if (!engineDetourRegistered) {
-          engineDetourRegistered = registerEngineDetourTool(roleHost, hostActions);
+          engineDetourRegistered = registerEngineDetourTool(roleHost);
         }
         if (secretariat.claimsEngineDetour === true && engineDetourRegistered) {
           roleHost.setActiveTools([
@@ -24372,19 +24482,6 @@ async function prepareRoleEnvelope(options) {
   )(envelope);
   const token = randomUUID9();
   const server = createServer((socket) => serveSocket(socket));
-  function rememberProjectedRejection(details, toolCallId, content) {
-    if (typeof details !== "object" || details === null) return;
-    const record = details;
-    if (record.cause === "infrastructure") return;
-    if (record.kind === "role_infrastructure_failure") return;
-    const code = typeof record.code === "string" && record.code.length > 0 ? record.code : record.status === "continue" || record.status === "escalate" || record.status === "no_receipt" ? record.status : void 0;
-    if (code === void 0) return;
-    rejection = {
-      code,
-      toolCallIds: [toolCallId],
-      message: textDiagnostic(content) ?? code
-    };
-  }
   function textDiagnostic(content) {
     const text = content.filter((part) => part.type === "text").map((part) => part.text).join("\n\n");
     return text.trim().length > 0 ? text : void 0;
@@ -24455,7 +24552,6 @@ async function prepareRoleEnvelope(options) {
     sessionEntries.push(toolResultEntry);
     if (projected.isError) {
       rememberInfrastructureFailure(projected.details, projected.content);
-      rememberProjectedRejection(projected.details, toolCallId, projected.content);
     }
     await emit("tool_execution_end", { toolCallId, toolName, isError: projected.isError });
     return projected;
@@ -24501,7 +24597,7 @@ async function prepareRoleEnvelope(options) {
       const projected = await projectToolResult(toolCallId, name, {
         content: result.content,
         details: result.details,
-        isError: false
+        isError: result.isError === true
       });
       if (result.terminate === false) {
         rejection = {
@@ -24514,18 +24610,31 @@ async function prepareRoleEnvelope(options) {
     } catch (error) {
       let content;
       let details;
-      if (isCorrectableExecuteError(error)) {
-        const projected2 = projectCorrectableExecuteRejection(error);
-        content = [{ type: "text", text: projected2.diagnostic }];
-        details = projected2.details;
+      const correctable = isCorrectableExecuteError(error) ? projectCorrectableExecuteRejection(error) : void 0;
+      if (correctable !== void 0) {
+        content = [{ type: "text", text: correctable.diagnostic }];
+        details = correctable.details;
       } else {
-        ({ content, details } = declareRoundInfrastructureFailure(error));
+        const diagnostic = errorText(error);
+        content = [{ type: "text", text: diagnostic }];
+        details = {
+          code: typeof error?.code === "string" ? error.code : "ak-tool-execution-failed",
+          error: serializeThrownValue(error)
+        };
       }
       const projected = await projectToolResult(toolCallId, name, {
         content,
         details,
         isError: true
       });
+      if (correctable !== void 0) {
+        const code = typeof correctable.details.code === "string" && correctable.details.code.length > 0 ? correctable.details.code : "correctable-submission-error";
+        rejection = {
+          code,
+          toolCallIds: [toolCallId],
+          message: textDiagnostic(projected.content) ?? correctable.diagnostic
+        };
+      }
       return { content: projected.content, isError: projected.isError };
     }
   }