@akagilnc/pi-workflow-roles 0.1.5252 → 0.1.5273

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

@@ -2839,7 +2839,6 @@ var init_host_descriptions = __esm({
           modelFlag: "--model"
         }),
         modelPassing: "argv",
-        boundResume: "session/load",
         sessionBindingFile: "grok-acp-session.json"
       }),
       /**
@@ -2857,7 +2856,6 @@ var init_host_descriptions = __esm({
           thinkingFlag: "--reasoning"
         }),
         modelPassing: "set_model",
-        boundResume: "session/load",
         sessionBindingFile: "hermes-acp-session.json",
         seatProfileSoul: Object.freeze({
           flag: "-p",
@@ -3764,7 +3762,6 @@ __export(durable_principal_exports, {
   issuePiDurablePrincipalCoordinates: () => issuePiDurablePrincipalCoordinates,
   piDurablePrincipalAuthority: () => piDurablePrincipalAuthority
 });
-import { lstat } from "node:fs/promises";
 import { join as join9 } from "node:path";
 function encode(coordinates) {
   return coordinates;
@@ -3817,15 +3814,6 @@ var init_durable_principal = __esm({
           sessionDirectory: record4.sessionDirectory,
           sessionFile: typeof record4.sessionFile === "string" && record4.sessionFile.trim() !== "" ? record4.sessionFile : join9(record4.sessionDirectory, "session.jsonl")
         };
-      },
-      async isAvailable(principal) {
-        const { sessionFile } = this.decode(principal);
-        try {
-          const stat2 = await lstat(sessionFile);
-          return stat2.isFile() && !stat2.isSymbolicLink();
-        } catch {
-          return false;
-        }
       }
     };
   }
@@ -4427,8 +4415,8 @@ function formatTerminalResult(result) {
       `diagnostic	${encodeTerminalField(result.roleOutcome.diagnostic)}`
     );
   }
-  if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation") {
-    const facts = result.roleOutcome.decisiveFacts ?? {};
+  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)) {
       if (value === void 0) continue;
       const rendered = typeof value === "string" ? value : JSON.stringify(value);
@@ -5841,7 +5829,7 @@ var init_ticket_provenance = __esm({
 
 // src/notary-source-run.ts
 import { dirname as dirname12, isAbsolute as isAbsolute5, join as join17, resolve as resolve10, basename as basename6 } from "node:path";
-import { lstat as lstat2, realpath as realpath3 } from "node:fs/promises";
+import { lstat, realpath as realpath3 } from "node:fs/promises";
 async function readRetainedIdentity(runDirectory) {
   try {
     return await readRoleRunIdentity(runDirectory);
@@ -5869,7 +5857,7 @@ async function requireRunDirectory(candidate, display) {
   }
   let stat2;
   try {
-    stat2 = await lstat2(real);
+    stat2 = await lstat(real);
   } catch (error) {
     throw new NotarySourceRunError(
       `notary --source-run is not a readable run directory: ${display}`,
@@ -7033,7 +7021,7 @@ var init_option_definitions = __esm({
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
 import {
-  lstat as lstat3,
+  lstat as lstat2,
   mkdtemp as mkdtemp2,
   readFile as readFile13,
   realpath as realpath4,
@@ -7595,7 +7583,7 @@ async function readRegularFileAttachment(sourcePath) {
   const absolute = isAbsolute6(sourcePath) ? sourcePath : resolve11(sourcePath);
   let st;
   try {
-    st = await lstat3(absolute);
+    st = await lstat2(absolute);
   } catch (error) {
     throw new CliUsageError(
       `attachment is not a readable regular file: ${sourcePath}`,
@@ -12578,12 +12566,6 @@ function createSessionIdentityAuthority(authority, sessionBindingFile) {
     }
   };
 }
-function resolveHostAwareSessionAvailability(host, principalAuthority) {
-  if (host === void 0 || host === DEFAULT_ROLE_TURN_HOST) {
-    return (principal) => principalAuthority.isAvailable(principal);
-  }
-  return async (principal) => await readStoredHostSessionId(host, principalAuthority, principal) !== void 0;
-}
 async function readStoredHostSessionId(host, authority, principal) {
   if (host === void 0 || host === DEFAULT_ROLE_TURN_HOST) return void 0;
   const description = lookupHostDescription(host) ?? lookupHeadlessHostDescription(host);
@@ -12883,9 +12865,9 @@ var init_host_session_record = __esm({
 // src/public-cli/auto-resume.ts
 import { constants as fsConstants2 } from "node:fs";
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { lstat as lstat5, mkdir as mkdir3, open } from "node:fs/promises";
+import { lstat as lstat4, mkdir as mkdir3, open } from "node:fs/promises";
 import { join as join31 } from "node:path";
-async function persistReturnedRunState(admitted, authority, options) {
+async function persistReturnedRunState(admitted, options) {
   if (options?.lawful === true) {
     await markRunTerminal(admitted.runDirectory);
     return;
@@ -12895,10 +12877,8 @@ async function persistReturnedRunState(admitted, authority, options) {
   });
   const typedHttp429 = resumeObservation.typedHttp429;
   if (admitted.principal !== void 0 && typedHttp429 !== void 0) {
-    if (await authority.isAvailable(admitted.principal)) {
-      await markRunResumable(admitted.runDirectory, typedHttp429);
-      return;
-    }
+    await markRunResumable(admitted.runDirectory, typedHttp429);
+    return;
   }
   await markRunTerminal(admitted.runDirectory);
 }
@@ -12920,20 +12900,20 @@ async function finalizeExceptionRunBestEffort(runDirectory, io) {
   }
 }
 async function ensureRealArtifactsDirectory(runDirectory) {
-  const runStat = await lstat5(runDirectory);
+  const runStat = await lstat4(runDirectory);
   if (runStat.isSymbolicLink() || !runStat.isDirectory()) {
     throw new Error("run artifact retention: run directory is not a real directory");
   }
   const artifactsDir = roleRunArtifactsDirectory(runDirectory);
   try {
-    const existing = await lstat5(artifactsDir);
+    const existing = await lstat4(artifactsDir);
     if (existing.isSymbolicLink() || !existing.isDirectory()) {
       throw new Error("run artifact retention: artifacts path is not a real directory");
     }
   } catch (error) {
     if (!isMissingPathError5(error)) throw error;
     await mkdir3(artifactsDir, { recursive: true });
-    const created = await lstat5(artifactsDir);
+    const created = await lstat4(artifactsDir);
     if (created.isSymbolicLink() || !created.isDirectory()) {
       throw new Error("run artifact retention: artifacts directory is not a real directory");
     }
@@ -13064,7 +13044,6 @@ function dispatchExceptionFailureTerminal(input) {
 async function runWithAutoResumeLoop(options) {
   const limit = options.autoResumeLimit ?? AUTO_RESUME_LIMIT;
   parseAutoResumeLimit(limit);
-  const isPrincipalAvailable = options.isPrincipalAvailable ?? ((principal) => options.principalAuthority.isAvailable(principal));
   let autoResumeAttempts = 0;
   let isFirst = true;
   let currentPayload = options.buildInitialPayload();
@@ -13072,6 +13051,9 @@ async function runWithAutoResumeLoop(options) {
   let lastThrownError;
   let everyAttemptThrew = true;
   const retainedErrorFiles = [];
+  const failedAttempts = [];
+  let stoppedResult;
+  let endReason;
   while (true) {
     let result;
     let turnStartedBeforeThrow = false;
@@ -13080,6 +13062,11 @@ async function runWithAutoResumeLoop(options) {
       result = await options.dispatch(currentPayload, lease, isFirst, dummyIo);
     } catch (error) {
       lastThrownError = error;
+      const failedAttempt = {
+        attempt: dispatchOrdinal,
+        diagnostic: describeErrorIdentity(unwrapTurnDispatchedFailure(error))
+      };
+      failedAttempts.push(failedAttempt);
       turnStartedBeforeThrow = error instanceof TurnDispatchedFailure;
       const attempt = dispatchOrdinal;
       try {
@@ -13091,6 +13078,7 @@ async function runWithAutoResumeLoop(options) {
           error
         );
         retainedErrorFiles.push(file);
+        failedAttempt.errorFile = file;
         options.io.stderr(
           `dispatch attempt ${attempt} threw (${describeErrorIdentity(error)}); full error retained at ${file}
 `
@@ -13111,100 +13099,30 @@ async function runWithAutoResumeLoop(options) {
     dispatchOrdinal += 1;
     if (result !== void 0) {
       everyAttemptThrew = false;
-      const terminal = result.terminal;
-      if (terminal !== void 0) {
-        terminal.autoResumeCount = autoResumeAttempts;
-      }
-      const lawful = terminal !== void 0 && isLawfulTypedTerminalOutcome(terminal.roleOutcome);
-      if (lawful) {
-        if (terminal !== void 0) {
-          options.io.stdout(formatTerminalResult(terminal));
+      const terminal2 = result.terminal;
+      if (terminal2 !== void 0) {
+        terminal2.autoResumeCount = autoResumeAttempts;
+        if (terminal2.roleOutcome.kind === "failure") {
+          failedAttempts.push({
+            attempt: dispatchOrdinal - 1,
+            diagnostic: terminal2.roleOutcome.diagnostic,
+            decisiveFacts: terminal2.roleOutcome.decisiveFacts
+          });
         }
-        return result;
       }
-      if (result.skipAutoResume === true) {
-        if (terminal !== void 0) presentTerminal(terminal, options.io);
-        return result;
-      }
-      if (processCancelSignalName(options.signal) !== void 0) {
-        if (terminal !== void 0) presentTerminal(terminal, options.io);
-        return result;
-      }
-    }
-    if (result !== void 0) {
-      const terminal = result.terminal;
-      if (autoResumeAttempts >= limit) {
-        if (terminal !== void 0) presentTerminal(terminal, options.io);
-        return result;
-      }
-      if (result.turnDispatched === true && !await isPrincipalAvailable(options.admitted.principal)) {
-        if (terminal !== void 0) presentTerminal(terminal, options.io);
-        return result;
+      if (terminal2 !== void 0 && isLawfulTypedTerminalOutcome(terminal2.roleOutcome) || result.skipAutoResume === true || autoResumeAttempts >= limit || processCancelSignalName(options.signal) !== void 0) {
+        stoppedResult = result;
+        break;
       }
     } else {
       if (autoResumeAttempts >= limit) {
-        const terminal = await attachDispatchExceptionTerminal(
-          options.admitted,
-          dispatchExceptionFailureTerminal({
-            role: options.admitted.role,
-            runId: options.admitted.runId,
-            causeError: lastThrownError,
-            errorFiles: retainedErrorFiles,
-            autoResumeAttempts,
-            endReason: "auto-resume budget exhausted",
-            everyAttemptThrew
-          }),
-          options.io
-        );
-        await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
-        presentTerminal(terminal, options.io);
-        return {
-          exitCode: 1,
-          terminal
-        };
+        endReason = "auto-resume budget exhausted";
+        break;
       }
       const cancelName = processCancelSignalName(options.signal);
       if (cancelName !== void 0) {
-        const terminal = await attachDispatchExceptionTerminal(
-          options.admitted,
-          dispatchExceptionFailureTerminal({
-            role: options.admitted.role,
-            runId: options.admitted.runId,
-            causeError: lastThrownError,
-            errorFiles: retainedErrorFiles,
-            autoResumeAttempts,
-            endReason: `ak-role terminated by ${cancelName}`,
-            everyAttemptThrew
-          }),
-          options.io
-        );
-        await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
-        presentTerminal(terminal, options.io);
-        return {
-          exitCode: 1,
-          terminal
-        };
-      }
-      if (!await isPrincipalAvailable(options.admitted.principal)) {
-        const terminal = await attachDispatchExceptionTerminal(
-          options.admitted,
-          dispatchExceptionFailureTerminal({
-            role: options.admitted.role,
-            runId: options.admitted.runId,
-            causeError: lastThrownError,
-            errorFiles: retainedErrorFiles,
-            autoResumeAttempts,
-            endReason: "session principal unavailable before further resume",
-            everyAttemptThrew
-          }),
-          options.io
-        );
-        await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
-        presentTerminal(terminal, options.io);
-        return {
-          exitCode: 1,
-          terminal
-        };
+        endReason = `ak-role terminated by ${cancelName}`;
+        break;
       }
     }
     autoResumeAttempts++;
@@ -13213,6 +13131,34 @@ async function runWithAutoResumeLoop(options) {
       isFirst = false;
     }
   }
+  const terminal = stoppedResult === void 0 ? await attachDispatchExceptionTerminal(
+    options.admitted,
+    dispatchExceptionFailureTerminal({
+      role: options.admitted.role,
+      runId: options.admitted.runId,
+      causeError: lastThrownError,
+      errorFiles: retainedErrorFiles,
+      autoResumeAttempts,
+      endReason,
+      everyAttemptThrew
+    }),
+    options.io
+  ) : stoppedResult.terminal;
+  if (stoppedResult === void 0) {
+    await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
+  }
+  const complete = terminal !== void 0 && failedAttempts.length > 0 ? { ...terminal, roleOutcome: {
+    ...terminal.roleOutcome,
+    decisiveFacts: { ...terminal.roleOutcome.decisiveFacts, failedAttempts }
+  } } : terminal;
+  if (complete !== void 0) {
+    if (isLawfulTypedTerminalOutcome(complete.roleOutcome)) {
+      options.io.stdout(formatTerminalResult(complete));
+    } else {
+      presentTerminal(complete, options.io);
+    }
+  }
+  return stoppedResult === void 0 ? { exitCode: 1, terminal: complete } : { ...stoppedResult, ...complete === void 0 ? {} : { terminal: complete } };
 }
 var dummyIo, TurnDispatchedFailure, DISPATCH_ERROR_RETENTION_ENTRY_TYPE;
 var init_auto_resume = __esm({
@@ -13381,14 +13327,9 @@ async function presentControlledFailure2(admitted, failureInput, adapters, autho
     ...failureInput.knownDiagnostic === void 0 ? {} : { knownDiagnostic: failureInput.knownDiagnostic },
     ...session === void 0 ? {} : { session }
   });
-  let resumable = false;
-  const typedHttp429 = resumeObservation.typedHttp429;
-  if (admitted.principal !== void 0) {
-    const sessionPrincipalAvailable = await authority.isAvailable(admitted.principal);
-    resumable = sessionPrincipalAvailable && typedHttp429 !== void 0;
-  }
+  const resumable = admitted.principal !== void 0 && resumeObservation.typedHttp429 !== void 0;
   if (persistRunState && !failureInput.skipRunStateWrite) {
-    await persistReturnedRunState(admitted, authority);
+    await persistReturnedRunState(admitted);
   }
   let publishedErrorPath;
   let terminal;
@@ -13433,7 +13374,7 @@ async function settleDeferredPersist(admitted, authority, adapters, io, result)
   const { needsPersist: _needsPersist, ...settledResult } = result;
   const lawful = isLawfulTypedTerminalOutcome(result.terminal.roleOutcome);
   try {
-    await persistReturnedRunState(admitted, authority, lawful ? { lawful: true } : void 0);
+    await persistReturnedRunState(admitted, lawful ? { lawful: true } : void 0);
     return settledResult;
   } catch (error) {
     const failed = await settleAfterTurnStarted(
@@ -13711,7 +13652,7 @@ async function dispatchPostAdmissionTurn(input) {
       }
       if (persistRunState) {
         try {
-          await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
+          await persistReturnedRunState(admitted, { lawful: true });
         } catch (error) {
           await recordBestEffortPostDispatchDiagnostic(
             admitted,
@@ -13796,7 +13737,7 @@ async function dispatchPostAdmissionTurn(input) {
     }
     if (persistRunState) {
       try {
-        await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
+        await persistReturnedRunState(admitted, { lawful: true });
       } catch (error) {
         await recordBestEffortPostDispatchDiagnostic(
           admitted,
@@ -14013,10 +13954,6 @@ async function runPostAdmissionSeatResume(input) {
       return await runWithAutoResumeLoop({
         admitted: loaded.admitted,
         principalAuthority: env.principalAuthority,
-        isPrincipalAvailable: resolveHostAwareSessionAvailability(
-          env.host,
-          env.principalAuthority
-        ),
         io: input.io,
         sessionAppender: env.sessionAppender,
         autoResumeLimit: env.autoResumeLimit,
@@ -14204,7 +14141,6 @@ async function runPostAdmissionResumable(input) {
   return runWithAutoResumeLoop({
     admitted,
     principalAuthority: env.principalAuthority,
-    isPrincipalAvailable: resolveHostAwareSessionAvailability(env.host, env.principalAuthority),
     io,
     sessionAppender: env.sessionAppender,
     autoResumeLimit: env.autoResumeLimit,
@@ -14326,7 +14262,7 @@ var init_seat_ticket_binding = __esm({
 
 // src/public-cli/machine-method-skills.ts
 import { accessSync, constants as constants2, statSync as statSync4 } from "node:fs";
-import { lstat as lstat6, mkdir as mkdir4, symlink } from "node:fs/promises";
+import { lstat as lstat5, mkdir as mkdir4, symlink } from "node:fs/promises";
 import { join as join33 } from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 function skillRoot(home) {
@@ -14356,7 +14292,7 @@ function linkedSkillRoot(home, host) {
 }
 async function occupied(path) {
   try {
-    await lstat6(path);
+    await lstat5(path);
     return true;
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
@@ -15441,7 +15377,7 @@ async function runPublicInstructionSeatResume(request, env, io) {
   };
   let binding;
   try {
-    const loaded = await loadResumablePublicRole(env.home, request.runId, env.principalAuthority, true);
+    const loaded = await loadResumablePublicRole(env.home, request.runId, env.principalAuthority);
     binding = loaded.admitted.role === "auditor" ? await readAuditorResumeBinding(loaded.admitted.runDirectory) : void 0;
   } catch (error) {
     if (!(error instanceof CliUsageError)) throw error;
@@ -15484,7 +15420,7 @@ async function queueConclusionFromChild(child, env, io) {
   }
 }
 async function continueParentAfterChild(parentRunId, child, env, io) {
-  const loaded = await loadResumablePublicRole(env.home, parentRunId, env.principalAuthority, true);
+  const loaded = await loadResumablePublicRole(env.home, parentRunId, env.principalAuthority);
   if (loaded.run.state !== "admitted" && !AUDITED_ROLES.has(loaded.admitted.role)) {
     return runPublicInstructionSeatResume({ runId: parentRunId }, env, io);
   }
@@ -15679,7 +15615,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
       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, true);
+      const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority);
       const terminal2 = await trySettlePublicSeat(officer.admitted, env.principalAuthority, void 0);
       if (terminal2 === void 0) throw new Error("escalated audit has no terminal result");
       io.stdout(formatTerminalResult(terminal2));
@@ -19603,7 +19539,6 @@ __export(run_lifecycle_exports, {
   describeErrorIdentity: () => describeErrorIdentity,
   findLatestRunIdForSeatTicket: () => findLatestRunIdForSeatTicket,
   findRunDirectoryById: () => findRunDirectoryById,
-  isDurablePrincipalAvailable: () => isDurablePrincipalAvailable,
   isV1ResumableProvider: () => isV1ResumableProvider,
   loadResumablePublicRole: () => loadResumablePublicRole,
   markRunAdmitted: () => markRunAdmitted,
@@ -19623,7 +19558,7 @@ __export(run_lifecycle_exports, {
   renderResumeCommand: () => renderResumeCommand,
   writeRoleRunState: () => writeRoleRunState
 });
-import { chmod, lstat as lstat7, open as open3, readdir as readdir7, readFile as readFile22, unlink as unlink5, writeFile as writeFile9 } from "node:fs/promises";
+import { chmod, lstat as lstat6, open as open3, readdir as readdir7, readFile as readFile22, unlink as unlink5, writeFile as writeFile9 } from "node:fs/promises";
 import { basename as basename10, join as join40 } from "node:path";
 function buildAutoResumeContinuationPrompt(options) {
   return appendEngineSessionMaterial(
@@ -19937,9 +19872,6 @@ async function clearCurrentCourt(runDirectory, expectedCourtAttemptId) {
     ...current.resumable === void 0 ? {} : { resumable: current.resumable }
   });
 }
-async function isDurablePrincipalAvailable(principal, authority) {
-  return authority.isAvailable(principal);
-}
 function describeErrorIdentity(error) {
   const candidate = error;
   const name = typeof candidate?.name === "string" && candidate.name !== "" ? candidate.name : typeof error;
@@ -20181,7 +20113,7 @@ async function runHasFormedSessionPrincipal(runDirectory) {
   if (disk === void 0) return false;
   const sessionFile = typeof disk.principalWire.sessionFile === "string" && disk.principalWire.sessionFile.trim() !== "" ? disk.principalWire.sessionFile : join40(disk.principalWire.sessionDirectory, "session.jsonl");
   try {
-    const stat2 = await lstat7(sessionFile);
+    const stat2 = await lstat6(sessionFile);
     return stat2.isFile() && !stat2.isSymbolicLink();
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return false;
@@ -20273,7 +20205,7 @@ function restoredTicketFields(fields) {
     ...fields.courtTicketNumbers === void 0 ? {} : { courtTicketNumbers: fields.courtTicketNumbers }
   };
 }
-async function loadResumableRunRecord(home, runId, authority, allowUnformedAdmitted = false) {
+async function loadResumableRunRecord(home, runId, authority) {
   const runDirectory = await findRunDirectoryById(home, runId);
   if (runDirectory === void 0) {
     throw new CliUsageError(`unknown role run id: ${runId}`);
@@ -20287,11 +20219,6 @@ async function loadResumableRunRecord(home, runId, authority, allowUnformedAdmit
     throw new CliUsageError(`unknown role run id: ${runId}`);
   }
   const { run, principal } = materialized;
-  if (!(allowUnformedAdmitted && run.state === "admitted") && !await isDurablePrincipalAvailable(principal, authority)) {
-    throw new CliUsageError(
-      `role run Pi session principal is unavailable: ${runId}`
-    );
-  }
   let instruction = "";
   let instructionEmpty = true;
   let attachments = [];
@@ -20568,8 +20495,8 @@ async function peekRoleRunRole(home, runId) {
   const run = await readRoleRunIdentity(runDirectory);
   return run?.role;
 }
-async function loadResumablePublicRole(home, runId, authority, allowUnformedAdmitted = false) {
-  const loaded = await loadResumableRunRecord(home, runId, authority, allowUnformedAdmitted);
+async function loadResumablePublicRole(home, runId, authority) {
+  const loaded = await loadResumableRunRecord(home, runId, authority);
   return seatLoadedResult(loaded, admitResumedRole(loaded));
 }
 function admitResumedRole(loaded) {
@@ -21649,9 +21576,14 @@ function createNativeNavigatorSessionFactory(deps) {
           }
           if (outcome.kind === "failure") {
             providerFailure = navigatorProviderFailureFromPublicTerminal(outcome);
+            const failedAttempts = outcome.decisiveFacts.failedAttempts;
+            const attemptReasons = Array.isArray(failedAttempts) ? failedAttempts.map((entry, index) => {
+              const fact = entry !== null && typeof entry === "object" ? entry : void 0;
+              return `${typeof fact?.attempt === "number" ? fact.attempt + 1 : index + 1}: ${typeof fact?.diagnostic === "string" ? fact.diagnostic : outcome.diagnostic}`;
+            }) : [];
             throw navigatorUnavailableError(
               providerFailure.source,
-              new Error(outcome.diagnostic),
+              new Error(attemptReasons.length > 0 ? attemptReasons.join("\n") : outcome.diagnostic),
               providerFailure.cause
             );
           }
@@ -26424,297 +26356,307 @@ function createHeadlessRoleTurnHost(config) {
     try {
       const explicitHostSessionId = request.continuation.kind === "resume" ? request.continuation.hostSessionId : void 0;
       let sessionId = explicitHostSessionId !== void 0 && explicitHostSessionId !== "" ? explicitHostSessionId : await config.sessionIdentity.load(request.principal);
-      let sessionKind = request.continuation.kind === "resume" && sessionId !== void 0 && sessionId !== "" ? "resume" : "new";
-      if (sessionKind === "new" && !codex) {
-        sessionId = randomUUID10();
-        await config.sessionIdentity.bind(request.principal, sessionId);
-      }
-      const env = { ...process.env, ...config.env ?? {} };
-      const systemPromptPath = join47(request.runDirectory, "headless-system-prompt.txt");
-      await writeFile11(systemPromptPath, systemPrompt, "utf8");
-      let mcpConfigPath;
-      let outputSchemaPath;
-      if (codex) {
-        if (prepared.terminatingToolName !== NAVIGATOR_OUTPUT_TOOL_NAME) {
-          outputSchemaPath = join47(request.runDirectory, "headless-output-schema.json");
+      if (request.continuation.kind === "resume" && (sessionId === void 0 || sessionId === "")) {
+        outcome = failure(
+          "session",
+          "HeadlessSessionFailure",
+          "session-id-missing",
+          void 0,
+          "resume requires a bound session id"
+        );
+      } else {
+        let sessionKind = request.continuation.kind === "resume" ? "resume" : "new";
+        if (sessionKind === "new" && !codex) {
+          sessionId = randomUUID10();
+          await config.sessionIdentity.bind(request.principal, sessionId);
+        }
+        const env = { ...process.env, ...config.env ?? {} };
+        const systemPromptPath = join47(request.runDirectory, "headless-system-prompt.txt");
+        await writeFile11(systemPromptPath, systemPrompt, "utf8");
+        let mcpConfigPath;
+        let outputSchemaPath;
+        if (codex) {
+          if (prepared.terminatingToolName !== NAVIGATOR_OUTPUT_TOOL_NAME) {
+            outputSchemaPath = join47(request.runDirectory, "headless-output-schema.json");
+            await writeFile11(
+              outputSchemaPath,
+              `${JSON.stringify(closeJsonSchemaForCodex(prepared.jsonSchema), null, 2)}
+`,
+              "utf8"
+            );
+          }
+        } else {
+          mcpConfigPath = join47(request.runDirectory, "headless-mcp-config.json");
           await writeFile11(
-            outputSchemaPath,
-            `${JSON.stringify(closeJsonSchemaForCodex(prepared.jsonSchema), null, 2)}
+            mcpConfigPath,
+            `${JSON.stringify(headlessMcpConfigDocument(prepared.mcpServers), null, 2)}
 `,
             "utf8"
           );
         }
-      } else {
-        mcpConfigPath = join47(request.runDirectory, "headless-mcp-config.json");
-        await writeFile11(
-          mcpConfigPath,
-          `${JSON.stringify(headlessMcpConfigDocument(prepared.mcpServers), null, 2)}
-`,
-          "utf8"
-        );
-      }
-      const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
-      let exitedSessionId;
-      try {
-        outcome = await driveExternalRoleTurnRounds(prepared, request, {
-          roundLimitName: "HeadlessRoundLimit",
-          currentSessionId: () => sessionId,
-          afterRetry() {
-            sessionKind = "resume";
-          },
-          async runRound({ prompt, abortSignal }) {
-            let args;
-            try {
-              const gitCommonDir = codex ? resolveGitCommonDir(request.cwd) : void 0;
-              args = buildTurnArgs({
-                description: config.description,
-                systemPromptPath,
-                // #959: navigator prose exit — no closed JSON schema on claude either.
-                ...prepared.terminatingToolName === NAVIGATOR_OUTPUT_TOOL_NAME ? {} : { jsonSchema: prepared.jsonSchema },
-                mcpServers: prepared.mcpServers,
-                ...mcpConfigPath === void 0 ? {} : { mcpConfigPath },
-                ...outputSchemaPath === void 0 ? {} : { outputSchemaPath },
-                ...request.model?.model !== void 0 ? { model: request.model.model } : {},
-                ...request.model?.thinking !== void 0 ? { effort: request.model.thinking } : {},
-                sessionId,
-                sessionKind,
-                cwd: request.cwd,
-                ...gitCommonDir === void 0 ? {} : { writableRoots: [gitCommonDir] }
-              });
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              return {
-                status: "terminal",
-                result: failure("session", "HeadlessArgvFailure", "argv-failed", { diagnostic: message }, message)
-              };
-            }
-            const codexObserver = codex ? createCodexExecTurnObserver() : void 0;
-            let pointerRecorded = false;
-            let codexIdObserved = false;
-            if (sessionId !== void 0 && sessionId !== "") {
-              pointerRecorded = recordNativeSessionPointer({
-                host: config.hostName,
-                sessionId,
-                cwd: request.cwd,
-                sessionParent,
-                home: request.home
-              }) !== void 0;
-            }
-            let spawned;
-            let childExited = false;
-            try {
-              spawned = await spawnHeadlessTurn({
-                onClose() {
-                  childExited = true;
-                },
-                binary: config.binary,
-                args,
-                cwd: request.cwd,
-                env,
-                stdin: prompt,
-                ...abortSignal === void 0 ? {} : { signal: abortSignal },
-                ...request.timeoutMs === void 0 ? {} : { timeoutMs: request.timeoutMs },
-                onStdoutLine(line2) {
-                  const trimmed = line2.trim();
-                  if (trimmed === "") return;
-                  let event;
-                  try {
-                    event = JSON.parse(trimmed);
-                  } catch {
-                    return;
-                  }
-                  codexObserver?.observe(event);
-                  if (!codex && typeof event === "object" && event !== null && "session_id" in event && typeof event.session_id === "string" && event.session_id !== "" && event.session_id !== sessionId) {
-                    sessionId = event.session_id;
-                    recordNativeSessionPointer({ host: config.hostName, sessionId, cwd: request.cwd, sessionParent, home: request.home });
-                  }
-                  if (codex && !codexIdObserved) {
-                    const tid = codexObserver?.result().threadId;
-                    if (tid !== void 0 && tid !== "") {
-                      codexIdObserved = true;
-                      pointerRecorded = recordNativeSessionPointer({
-                        host: config.hostName,
-                        sessionId: tid,
-                        cwd: request.cwd,
-                        sessionParent,
-                        home: request.home
-                      }) !== void 0;
-                    }
-                  }
-                }
-              });
-              const roundSessionId = (codex ? codexObserver?.result().threadId : void 0) ?? sessionId;
-              exitedSessionId = roundSessionId;
-              if (codex && roundSessionId !== void 0 && roundSessionId !== "" && !pointerRecorded) {
-                recordNativeSessionPointer({ host: config.hostName, sessionId: roundSessionId, cwd: request.cwd, sessionParent, home: request.home });
-              }
-            } catch (error) {
-              if (childExited) exitedSessionId = (codex ? codexObserver?.result().threadId : void 0) ?? sessionId;
-              if (isHostAbortedError(error)) throw error;
-              const message = error instanceof Error ? error.message : String(error);
-              const observedHostFailure = codexObserver?.result().failureDiagnostic;
-              if (observedHostFailure !== void 0) {
+        const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
+        let exitedSessionId;
+        try {
+          outcome = await driveExternalRoleTurnRounds(prepared, request, {
+            roundLimitName: "HeadlessRoundLimit",
+            currentSessionId: () => sessionId,
+            afterRetry() {
+              sessionKind = "resume";
+            },
+            async runRound({ prompt, abortSignal }) {
+              let args;
+              try {
+                const gitCommonDir = codex ? resolveGitCommonDir(request.cwd) : void 0;
+                args = buildTurnArgs({
+                  description: config.description,
+                  systemPromptPath,
+                  // #959: navigator prose exit — no closed JSON schema on claude either.
+                  ...prepared.terminatingToolName === NAVIGATOR_OUTPUT_TOOL_NAME ? {} : { jsonSchema: prepared.jsonSchema },
+                  mcpServers: prepared.mcpServers,
+                  ...mcpConfigPath === void 0 ? {} : { mcpConfigPath },
+                  ...outputSchemaPath === void 0 ? {} : { outputSchemaPath },
+                  ...request.model?.model !== void 0 ? { model: request.model.model } : {},
+                  ...request.model?.thinking !== void 0 ? { effort: request.model.thinking } : {},
+                  sessionId,
+                  sessionKind,
+                  cwd: request.cwd,
+                  ...gitCommonDir === void 0 ? {} : { writableRoots: [gitCommonDir] }
+                });
+              } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
                 return {
                   status: "terminal",
-                  result: failure("output", "HeadlessCliError", "codex-turn-failed", {
-                    diagnostic: observedHostFailure,
-                    sessionRecordDiagnostic: message,
-                    sessionId
-                  }, observedHostFailure)
+                  result: failure("session", "HeadlessArgvFailure", "argv-failed", { diagnostic: message }, message)
                 };
               }
-              return {
-                status: "terminal",
-                result: failure("activation", "HeadlessSpawnFailure", "spawn-failed", {
-                  diagnostic: message,
-                  binary: config.binary
-                }, message)
-              };
-            }
-            if (spawned.timedOut) {
-              return terminalFromSpawned(spawned, {
-                cause: "timeout",
-                identity: { name: "HeadlessTimeout", code: "timeout" },
-                details: { sessionId }
-              });
-            }
-            if (codex) {
-              const observation = codexObserver.result();
-              if (observation.threadId !== void 0 && observation.threadId !== "") {
-                sessionId = observation.threadId;
-              }
-              let sessionBindingDiagnostic;
-              const hostFailed = observation.failureDiagnostic !== void 0 || spawned.code !== 0 && spawned.code !== null;
-              if (hostFailed && observation.threadId !== void 0 && observation.threadId !== "") {
-                try {
-                  await config.sessionIdentity.bind(request.principal, observation.threadId);
-                } catch (error) {
-                  sessionBindingDiagnostic = error instanceof Error ? error.message : String(error);
-                }
-              }
-              if (observation.failureDiagnostic !== void 0) {
-                return terminalFromSpawned(spawned, {
-                  cause: "output",
-                  identity: { name: "HeadlessCliError", code: "codex-turn-failed" },
-                  diagnostic: observation.failureDiagnostic,
-                  details: {
-                    sessionId,
-                    exitCode: spawned.code,
-                    ...sessionBindingDiagnostic === void 0 ? {} : { sessionBindingDiagnostic }
-                  }
-                });
+              const codexObserver = codex ? createCodexExecTurnObserver() : void 0;
+              let pointerRecorded = false;
+              let codexIdObserved = false;
+              if (sessionId !== void 0 && sessionId !== "") {
+                pointerRecorded = recordNativeSessionPointer({
+                  host: config.hostName,
+                  sessionId,
+                  cwd: request.cwd,
+                  sessionParent,
+                  home: request.home
+                }) !== void 0;
               }
-              if (spawned.code !== 0 && spawned.code !== null) {
-                return terminalFromSpawned(spawned, {
-                  cause: "output",
-                  identity: { name: "HeadlessCliError", code: "codex-nonzero-exit" },
-                  diagnostic: spawned.stderr.trim() || `codex exec exited ${String(spawned.code)}`,
-                  details: {
-                    sessionId,
-                    exitCode: spawned.code,
-                    ...sessionBindingDiagnostic === void 0 ? {} : { sessionBindingDiagnostic }
+              let spawned;
+              let childExited = false;
+              try {
+                spawned = await spawnHeadlessTurn({
+                  onClose() {
+                    childExited = true;
+                  },
+                  binary: config.binary,
+                  args,
+                  cwd: request.cwd,
+                  env,
+                  stdin: prompt,
+                  ...abortSignal === void 0 ? {} : { signal: abortSignal },
+                  ...request.timeoutMs === void 0 ? {} : { timeoutMs: request.timeoutMs },
+                  onStdoutLine(line2) {
+                    const trimmed = line2.trim();
+                    if (trimmed === "") return;
+                    let event;
+                    try {
+                      event = JSON.parse(trimmed);
+                    } catch {
+                      return;
+                    }
+                    codexObserver?.observe(event);
+                    if (!codex && typeof event === "object" && event !== null && "session_id" in event && typeof event.session_id === "string" && event.session_id !== "" && event.session_id !== sessionId) {
+                      sessionId = event.session_id;
+                      recordNativeSessionPointer({ host: config.hostName, sessionId, cwd: request.cwd, sessionParent, home: request.home });
+                    }
+                    if (codex && !codexIdObserved) {
+                      const tid = codexObserver?.result().threadId;
+                      if (tid !== void 0 && tid !== "") {
+                        codexIdObserved = true;
+                        pointerRecorded = recordNativeSessionPointer({
+                          host: config.hostName,
+                          sessionId: tid,
+                          cwd: request.cwd,
+                          sessionParent,
+                          home: request.home
+                        }) !== void 0;
+                      }
+                    }
                   }
                 });
+                const roundSessionId = (codex ? codexObserver?.result().threadId : void 0) ?? sessionId;
+                exitedSessionId = roundSessionId;
+                if (codex && roundSessionId !== void 0 && roundSessionId !== "" && !pointerRecorded) {
+                  recordNativeSessionPointer({ host: config.hostName, sessionId: roundSessionId, cwd: request.cwd, sessionParent, home: request.home });
+                }
+              } catch (error) {
+                if (childExited) exitedSessionId = (codex ? codexObserver?.result().threadId : void 0) ?? sessionId;
+                if (isHostAbortedError(error)) throw error;
+                const message = error instanceof Error ? error.message : String(error);
+                const observedHostFailure = codexObserver?.result().failureDiagnostic;
+                if (observedHostFailure !== void 0) {
+                  return {
+                    status: "terminal",
+                    result: failure("output", "HeadlessCliError", "codex-turn-failed", {
+                      diagnostic: observedHostFailure,
+                      sessionRecordDiagnostic: message,
+                      sessionId
+                    }, observedHostFailure)
+                  };
+                }
+                return {
+                  status: "terminal",
+                  result: failure("activation", "HeadlessSpawnFailure", "spawn-failed", {
+                    diagnostic: message,
+                    binary: config.binary
+                  }, message)
+                };
               }
-              if (observation.threadId === void 0 || observation.threadId === "") {
-                return terminalFromSpawned(spawned, {
-                  cause: "session",
-                  identity: { name: "HeadlessMissingThreadId", code: "missing-thread-id" },
-                  diagnostic: "codex exec emitted no thread.started thread_id",
-                  details: { sessionId, exitCode: spawned.code }
-                });
-              }
-              sessionId = observation.threadId;
-              await config.sessionIdentity.bind(request.principal, sessionId);
-              if (!observation.turnCompleted) {
-                return terminalFromSpawned(spawned, {
-                  cause: "output",
-                  identity: { name: "HeadlessCliError", code: "codex-missing-terminal-event" },
-                  diagnostic: "codex exec exited without turn.completed",
-                  details: { sessionId, exitCode: spawned.code }
-                });
-              }
-              if (observation.finalMessage === void 0) {
+              if (spawned.timedOut) {
                 return terminalFromSpawned(spawned, {
-                  cause: "output",
-                  identity: { name: "HeadlessEmptyOutput", code: "empty-stdout" },
-                  diagnostic: spawned.stderr.trim() || "codex exec produced no agent_message",
-                  details: { sessionId, exitCode: spawned.code }
+                  cause: "timeout",
+                  identity: { name: "HeadlessTimeout", code: "timeout" },
+                  details: { sessionId }
                 });
               }
-              if (prepared.terminatingToolName === NAVIGATOR_OUTPUT_TOOL_NAME) {
-                if (observation.finalMessage.trim() === "") {
+              if (codex) {
+                const observation = codexObserver.result();
+                if (observation.threadId !== void 0 && observation.threadId !== "") {
+                  sessionId = observation.threadId;
+                }
+                let sessionBindingDiagnostic;
+                const hostFailed = observation.failureDiagnostic !== void 0 || spawned.code !== 0 && spawned.code !== null;
+                if (hostFailed && observation.threadId !== void 0 && observation.threadId !== "") {
+                  try {
+                    await config.sessionIdentity.bind(request.principal, observation.threadId);
+                  } catch (error) {
+                    sessionBindingDiagnostic = error instanceof Error ? error.message : String(error);
+                  }
+                }
+                if (observation.failureDiagnostic !== void 0) {
+                  return terminalFromSpawned(spawned, {
+                    cause: "output",
+                    identity: { name: "HeadlessCliError", code: "codex-turn-failed" },
+                    diagnostic: observation.failureDiagnostic,
+                    details: {
+                      sessionId,
+                      exitCode: spawned.code,
+                      ...sessionBindingDiagnostic === void 0 ? {} : { sessionBindingDiagnostic }
+                    }
+                  });
+                }
+                if (spawned.code !== 0 && spawned.code !== null) {
+                  return terminalFromSpawned(spawned, {
+                    cause: "output",
+                    identity: { name: "HeadlessCliError", code: "codex-nonzero-exit" },
+                    diagnostic: spawned.stderr.trim() || `codex exec exited ${String(spawned.code)}`,
+                    details: {
+                      sessionId,
+                      exitCode: spawned.code,
+                      ...sessionBindingDiagnostic === void 0 ? {} : { sessionBindingDiagnostic }
+                    }
+                  });
+                }
+                if (observation.threadId === void 0 || observation.threadId === "") {
+                  return terminalFromSpawned(spawned, {
+                    cause: "session",
+                    identity: { name: "HeadlessMissingThreadId", code: "missing-thread-id" },
+                    diagnostic: "codex exec emitted no thread.started thread_id",
+                    details: { sessionId, exitCode: spawned.code }
+                  });
+                }
+                sessionId = observation.threadId;
+                await config.sessionIdentity.bind(request.principal, sessionId);
+                if (!observation.turnCompleted) {
+                  return terminalFromSpawned(spawned, {
+                    cause: "output",
+                    identity: { name: "HeadlessCliError", code: "codex-missing-terminal-event" },
+                    diagnostic: "codex exec exited without turn.completed",
+                    details: { sessionId, exitCode: spawned.code }
+                  });
+                }
+                if (observation.finalMessage === void 0) {
                   return terminalFromSpawned(spawned, {
                     cause: "output",
                     identity: { name: "HeadlessEmptyOutput", code: "empty-stdout" },
-                    diagnostic: spawned.stderr.trim() || "codex exec produced empty agent_message",
+                    diagnostic: spawned.stderr.trim() || "codex exec produced no agent_message",
                     details: { sessionId, exitCode: spawned.code }
                   });
                 }
-                await prepared.ingestStructuredOutput({ prose: observation.finalMessage });
+                if (prepared.terminatingToolName === NAVIGATOR_OUTPUT_TOOL_NAME) {
+                  if (observation.finalMessage.trim() === "") {
+                    return terminalFromSpawned(spawned, {
+                      cause: "output",
+                      identity: { name: "HeadlessEmptyOutput", code: "empty-stdout" },
+                      diagnostic: spawned.stderr.trim() || "codex exec produced empty agent_message",
+                      details: { sessionId, exitCode: spawned.code }
+                    });
+                  }
+                  await prepared.ingestStructuredOutput({ prose: observation.finalMessage });
+                  return { status: "delivered", stderr: spawned.stderr };
+                }
+                let receipt;
+                try {
+                  receipt = JSON.parse(observation.finalMessage);
+                } catch {
+                  return terminalFromSpawned(spawned, {
+                    cause: "output",
+                    identity: { name: "HeadlessEmptyOutput", code: "unparseable-final-message" },
+                    diagnostic: "codex final agent_message was not JSON",
+                    details: { sessionId, exitCode: spawned.code }
+                  });
+                }
+                await prepared.ingestStructuredOutput(receipt);
                 return { status: "delivered", stderr: spawned.stderr };
               }
-              let receipt;
-              try {
-                receipt = JSON.parse(observation.finalMessage);
-              } catch {
+              const envelope = parseHeadlessCliStdout(spawned.stdout);
+              if (envelope === void 0) {
                 return terminalFromSpawned(spawned, {
                   cause: "output",
-                  identity: { name: "HeadlessEmptyOutput", code: "unparseable-final-message" },
-                  diagnostic: "codex final agent_message was not JSON",
+                  identity: { name: "HeadlessEmptyOutput", code: "empty-stdout" },
+                  diagnostic: spawned.stderr.length > 0 ? spawned.stderr : "headless CLI produced no parseable result",
                   details: { sessionId, exitCode: spawned.code }
                 });
               }
-              await prepared.ingestStructuredOutput(receipt);
+              if (typeof envelope.session_id === "string" && envelope.session_id !== "") {
+                sessionId = envelope.session_id;
+                await config.sessionIdentity.bind(request.principal, sessionId);
+              }
+              if (envelope.is_error === true || typeof envelope.subtype === "string" && envelope.subtype.startsWith("error_")) {
+                const errorCode = typeof envelope.subtype === "string" && envelope.subtype.startsWith("error_") ? envelope.subtype : envelope.is_error === true ? "is_error" : "cli-error";
+                const diagnostic = typeof envelope.result === "string" ? envelope.result : Array.isArray(envelope.errors) ? envelope.errors.map(String).join("\n") : spawned.stderr.length > 0 ? spawned.stderr : "headless CLI reported is_error";
+                return terminalFromSpawned(spawned, {
+                  cause: "output",
+                  identity: { name: "HeadlessCliError", code: errorCode },
+                  diagnostic,
+                  details: {
+                    sessionId,
+                    subtype: envelope.subtype,
+                    errors: envelope.errors,
+                    exitCode: spawned.code
+                  }
+                });
+              }
+              if (envelope.structured_output !== void 0) {
+                await prepared.ingestStructuredOutput(envelope.structured_output);
+              } else if (prepared.terminatingToolName === NAVIGATOR_OUTPUT_TOOL_NAME && typeof envelope.result === "string" && envelope.result.trim() !== "") {
+                await prepared.ingestStructuredOutput({ prose: envelope.result });
+              }
               return { status: "delivered", stderr: spawned.stderr };
             }
-            const envelope = parseHeadlessCliStdout(spawned.stdout);
-            if (envelope === void 0) {
-              return terminalFromSpawned(spawned, {
-                cause: "output",
-                identity: { name: "HeadlessEmptyOutput", code: "empty-stdout" },
-                diagnostic: spawned.stderr.length > 0 ? spawned.stderr : "headless CLI produced no parseable result",
-                details: { sessionId, exitCode: spawned.code }
-              });
-            }
-            if (typeof envelope.session_id === "string" && envelope.session_id !== "") {
-              sessionId = envelope.session_id;
-              await config.sessionIdentity.bind(request.principal, sessionId);
-            }
-            if (envelope.is_error === true || typeof envelope.subtype === "string" && envelope.subtype.startsWith("error_")) {
-              const errorCode = typeof envelope.subtype === "string" && envelope.subtype.startsWith("error_") ? envelope.subtype : envelope.is_error === true ? "is_error" : "cli-error";
-              const diagnostic = typeof envelope.result === "string" ? envelope.result : Array.isArray(envelope.errors) ? envelope.errors.map(String).join("\n") : spawned.stderr.length > 0 ? spawned.stderr : "headless CLI reported is_error";
-              return terminalFromSpawned(spawned, {
-                cause: "output",
-                identity: { name: "HeadlessCliError", code: errorCode },
-                diagnostic,
-                details: {
-                  sessionId,
-                  subtype: envelope.subtype,
-                  errors: envelope.errors,
-                  exitCode: spawned.code
-                }
-              });
-            }
-            if (envelope.structured_output !== void 0) {
-              await prepared.ingestStructuredOutput(envelope.structured_output);
-            } else if (prepared.terminatingToolName === NAVIGATOR_OUTPUT_TOOL_NAME && typeof envelope.result === "string" && envelope.result.trim() !== "") {
-              await prepared.ingestStructuredOutput({ prose: envelope.result });
-            }
-            return { status: "delivered", stderr: spawned.stderr };
-          }
-        });
-      } finally {
-        if (exitedSessionId !== void 0 && exitedSessionId !== "") copyAndRecordHostDossier({
-          host: config.hostName,
-          sessionId: exitedSessionId,
-          cwd: request.cwd,
-          sessionDirectory: join47(request.runDirectory, "session"),
-          sessionParent,
-          continuation: request.continuation,
-          ...request.model !== void 0 ? { model: request.model } : {},
-          ...request.home !== void 0 ? { home: request.home } : {}
-        });
+          });
+        } finally {
+          if (exitedSessionId !== void 0 && exitedSessionId !== "") copyAndRecordHostDossier({
+            host: config.hostName,
+            sessionId: exitedSessionId,
+            cwd: request.cwd,
+            sessionDirectory: join47(request.runDirectory, "session"),
+            sessionParent,
+            continuation: request.continuation,
+            ...request.model !== void 0 ? { model: request.model } : {},
+            ...request.home !== void 0 ? { home: request.home } : {}
+          });
+        }
       }
     } finally {
       try {