@akagilnc/pi-workflow-roles 0.1.5096 → 0.1.5124

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

@@ -14298,6 +14298,7 @@ __export(settlement_exports, {
   projectThrownFailureLeaf: () => projectThrownFailureLeaf,
   publishFailureArtifacts: () => publishFailureArtifacts,
   publishSeatAcceptedArtifacts: () => publishSeatAcceptedArtifacts,
+  publishedFailureErrorPath: () => publishedFailureErrorPath,
   raceNavigatorGrace: () => raceNavigatorGrace,
   readCollectorInfrastructureFailure: () => readCollectorInfrastructureFailure,
   readEngineDetourInfrastructureFailure: () => readEngineDetourInfrastructureFailure,
@@ -14306,6 +14307,7 @@ __export(settlement_exports, {
   resolveAuditedRunnerFailureResolution: () => resolveAuditedRunnerFailureResolution,
   resolveAuditedRunnerKnownFailure: () => resolveAuditedRunnerKnownFailure,
   resolveControlledFailureResumeObservation: () => resolveControlledFailureResumeObservation,
+  rewritePublishedFailureErrorPath: () => rewritePublishedFailureErrorPath,
   seatKnownFailureResolver: () => seatKnownFailureResolver,
   settleFailureTerminalResult: () => settleFailureTerminalResult,
   settleHostEndedNoReceipt: () => settleHostEndedNoReceipt,
@@ -14399,10 +14401,13 @@ function withSubmissions(terminal, submissions) {
 }
 async function attachRecordedSubmissions(admitted, terminal, scope) {
   void scope;
-  return withSubmissions(
+  const result = withSubmissions(
     terminal,
     await recordedSubmissionPayloads(admitted, void 0)
   );
+  const errorPath = privateFailureErrorPaths.get(terminal);
+  if (errorPath !== void 0) privateFailureErrorPaths.set(result, errorPath);
+  return result;
 }
 async function settleHostEndedNoReceipt(admitted, authority, scope) {
   const facts = noReceiptLifecycleFacts({
@@ -14434,6 +14439,18 @@ async function settleHostEndedNoReceipt(admitted, authority, scope) {
 function coordinatesFromAdmitted(authority, admitted) {
   return authority.decode(admitted.principal);
 }
+function publishedFailureErrorPath(terminal) {
+  return privateFailureErrorPaths.get(terminal);
+}
+function rewritePublishedFailureErrorPath(terminal, oldRunDirectory, newRunDirectory) {
+  const errorPath = privateFailureErrorPaths.get(terminal);
+  if (errorPath !== void 0) {
+    privateFailureErrorPaths.set(
+      terminal,
+      rewriteRunDirectoryPathValue(errorPath, oldRunDirectory, newRunDirectory)
+    );
+  }
+}
 function conciseChildDiagnostic(stderr, fallback) {
   const trimmed = stderr.trim();
   return trimmed.length > 0 ? stderr : fallback;
@@ -15955,7 +15972,7 @@ async function writeFailureJsonRetainingCause(preferredCandidates, uniqueFallbac
   error.publicationAttempts = issues;
   throw error;
 }
-async function publishFailureArtifacts(admitted, failure2, authority) {
+async function publishFailureArtifacts(admitted, failure2, authority, onErrorPublished) {
   const { sessionDirectory, sessionFile } = coordinatesFromAdmitted(authority, admitted);
   const { baseDir, attempt: baseAttempt } = await resolveFailureArtifactsBase(
     admitted.runDirectory
@@ -16017,6 +16034,7 @@ async function publishFailureArtifacts(admitted, failure2, authority) {
     errorPayloadBase,
     priorIssues
   );
+  onErrorPublished?.(errorWrite.path);
   const evidencePayload = {
     runId: admitted.runId,
     sessionDirectory,
@@ -16099,7 +16117,8 @@ async function settleFailureTerminalResult(admitted, failure2, authority, option
     }
   }
   const navigator = await extractNavigatorFactFromAdmittedSession(sessionFile);
-  const artifacts = await publishFailureArtifacts(admitted, failure2, authority);
+  const artifacts = await publishFailureArtifacts(admitted, failure2, authority, options.onErrorPublished);
+  const errorPath = artifacts.find((artifact) => artifact.kind === "error")?.path;
   const decisiveFacts = {
     ...failure2.cause === void 0 ? {} : { cause: failure2.cause },
     diagnostic: failure2.diagnostic
@@ -16121,7 +16140,7 @@ async function settleFailureTerminalResult(admitted, failure2, authority, option
       diagnostic: failure2.diagnostic,
       decisiveFacts
     };
-    return withOptionalGateProjection(
+    const terminal = await withOptionalGateProjection(
       {
         roleOutcome: roleOutcome2,
         navigator,
@@ -16131,6 +16150,8 @@ async function settleFailureTerminalResult(admitted, failure2, authority, option
       sessionDirectory,
       detourGateContext(admitted, options)
     );
+    if (errorPath !== void 0) privateFailureErrorPaths.set(terminal, errorPath);
+    return terminal;
   }
   const roleOutcome = {
     kind: "failure",
@@ -16159,6 +16180,7 @@ function presentFailureTerminal(terminal, io) {
   }
   io.stdout(formatTerminalResult(terminal));
   if (terminal.roleOutcome.kind === "failure") {
+    if (io.omitFailureStderrDiagnostic) return;
     io.stderr(formatFailureStderrDiagnostic({
       ...terminal.roleOutcome.cause === void 0 ? {} : { cause: terminal.roleOutcome.cause },
       diagnostic: terminal.roleOutcome.diagnostic
@@ -16207,7 +16229,7 @@ function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep2
     });
   });
 }
-var NAVIGATOR_POST_ROLE_GRACE_MS, COLLECTOR_INFRASTRUCTURE_TOOLS, COLLECTOR_INFRASTRUCTURE_FAILURE_SPEC, ENGINE_DETOUR_INFRASTRUCTURE_FAILURE_SPEC, RUNNER_FAILURE_POLICY, ATTEMPT_HISTORY_ENTRY_TYPE, EMPTY_ARTIFACT_FACE;
+var privateFailureErrorPaths, NAVIGATOR_POST_ROLE_GRACE_MS, COLLECTOR_INFRASTRUCTURE_TOOLS, COLLECTOR_INFRASTRUCTURE_FAILURE_SPEC, ENGINE_DETOUR_INFRASTRUCTURE_FAILURE_SPEC, RUNNER_FAILURE_POLICY, ATTEMPT_HISTORY_ENTRY_TYPE, EMPTY_ARTIFACT_FACE;
 var init_settlement = __esm({
   "src/public-cli/settlement.ts"() {
     "use strict";
@@ -16234,9 +16256,11 @@ var init_settlement = __esm({
     init_navigator_invocation_identity();
     init_receipt_delivery_policy();
     init_role_run_placement();
+    init_role_run_relocation();
     init_run_terminal_artifacts();
     init_invocation();
     init_terminal();
+    privateFailureErrorPaths = /* @__PURE__ */ new WeakMap();
     NAVIGATOR_POST_ROLE_GRACE_MS = 1e4;
     COLLECTOR_INFRASTRUCTURE_TOOLS = /* @__PURE__ */ new Set([
       COLLECTOR_OBSERVE_TOOL,
@@ -16879,6 +16903,11 @@ function projectRelocatedTurnIdentity(request, result, admitted, relocation) {
     }
   }
   if (result.terminal !== void 0) {
+    rewritePublishedFailureErrorPath(
+      result.terminal,
+      relocation.oldRunDirectory,
+      relocation.newRunDirectory
+    );
     for (const artifact of result.terminal.artifacts) {
       artifact.path = rewrite(artifact.path);
     }
@@ -16992,18 +17021,23 @@ async function presentControlledFailure2(admitted, failureInput, adapters, autho
   if (persistRunState && !failureInput.skipRunStateWrite) {
     await persistReturnedRunState(admitted, authority);
   }
-  const terminal = await attachRecordedSubmissions(
-    admitted,
-    await settleFailureTerminalResult(
-      admitted,
-      failure2,
-      authority,
-      {
-        ...resumable ? { resume: { command: renderResumeCommand(admitted.runId) } } : {},
-        ...failureInput.invocationScopeId === void 0 || failureInput.invocationScopeId.length === 0 ? {} : { invocationScopeId: failureInput.invocationScopeId }
+  let publishedErrorPath;
+  let terminal;
+  try {
+    const settled = await settleFailureTerminalResult(admitted, failure2, authority, {
+      ...resumable ? { resume: { command: renderResumeCommand(admitted.runId) } } : {},
+      ...failureInput.invocationScopeId === void 0 || failureInput.invocationScopeId.length === 0 ? {} : { invocationScopeId: failureInput.invocationScopeId },
+      onErrorPublished: (path) => {
+        publishedErrorPath = path;
       }
-    )
-  );
+    });
+    terminal = await attachRecordedSubmissions(admitted, settled);
+  } catch (error) {
+    if (io.omitFailureStderrDiagnostic && publishedErrorPath !== void 0) {
+      writeResumeFailurePointer(io, publishedErrorPath);
+    }
+    throw error;
+  }
   presentFailureTerminal(terminal, io);
   return {
     exitCode: exitCodeForTerminalOutcome(terminal.roleOutcome),
@@ -17097,7 +17131,10 @@ async function dispatchPostAdmissionTurn(input) {
       if (relocation !== void 0) {
         projectRelocatedTurnIdentity(request, result, admitted, relocation);
       }
-      if (adapters.afterDispatch !== void 0) await adapters.afterDispatch(admitted, lease);
+      const afterDispatchRelocation = adapters.afterDispatch === void 0 ? void 0 : await adapters.afterDispatch(admitted, lease);
+      if (afterDispatchRelocation !== void 0) {
+        projectRelocatedTurnIdentity(request, result, admitted, afterDispatchRelocation);
+      }
       return result;
     } catch (error) {
       if (result.terminal !== void 0) {
@@ -17544,16 +17581,28 @@ async function runPostAdmissionSeatResume(input) {
   try {
     loaded = await input.load(request);
   } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, input.io);
-      return { exitCode: 2 };
+    const usageError = error instanceof CliUsageError;
+    const recorded = await pointExistingRunFailure(
+      input.env.home,
+      request.runId,
+      input.env.principalAuthority,
+      input.io,
+      error
+    );
+    if (!recorded) {
+      if (usageError) {
+        presentStructuralRejection(error, input.io);
+        return { exitCode: 2 };
+      }
+      throw error;
     }
-    throw error;
+    return { exitCode: usageError ? 2 : 1 };
   }
   let adapters = input.adapters;
   if (input.afterAdmittedLoad !== void 0) {
     const prepared = await input.afterAdmittedLoad(loaded.admitted);
     if (prepared.kind === "terminal") {
+      showResumeErrorPointer(input.io, prepared.exitCode, prepared.terminal);
       return {
         exitCode: prepared.exitCode,
         admitted: prepared.admitted,
@@ -17679,22 +17728,110 @@ async function runPostAdmissionSeatResume(input) {
         })
       });
     }
-    return await runPostAdmissionManualResume({
+    const resumed = await runPostAdmissionManualResume({
       admitted: loaded.admitted,
       env,
-      io: input.io,
+      io: { ...input.io, omitFailureStderrDiagnostic: true },
       adapters,
       ...input.effectiveEngine === void 0 ? {} : { effectiveEngine: input.effectiveEngine },
       buildRequestAfterLease
     });
+    showResumeErrorPointer(input.io, resumed.exitCode, resumed.terminal);
+    return resumed;
   } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, input.io);
-      return { exitCode: 2 };
+    if (error instanceof TurnDispatchedFailure) throw error;
+    await presentResumeFailurePointer(
+      input.io,
+      error,
+      (failure2) => writeResumeDiagnosticFile(
+        loaded.admitted.runDirectory,
+        loaded.admitted.runId,
+        failure2,
+        loaded.admitted.role
+      )
+    );
+    return { exitCode: error instanceof CliUsageError ? 2 : 1 };
+  }
+}
+async function pointExistingRunFailure(home, runId, authority, io, thrown) {
+  let foundRunDirectory;
+  try {
+    foundRunDirectory = await findRunDirectoryById(home, runId);
+  } catch {
+    return false;
+  }
+  if (foundRunDirectory === void 0) return false;
+  const runDirectory = foundRunDirectory;
+  let record4;
+  try {
+    record4 = await readRoleRunState(runDirectory, authority);
+  } catch {
+    await presentResumeFailurePointer(
+      io,
+      thrown,
+      (failure2) => writeResumeDiagnosticFile(runDirectory, runId, failure2)
+    );
+    return true;
+  }
+  if (record4 === void 0) return false;
+  await presentResumeFailurePointer(
+    io,
+    thrown,
+    (failure2) => writeResumeDiagnosticFile(runDirectory, runId, failure2, record4.role)
+  );
+  return true;
+}
+async function presentLocatedResumeFailure(home, runId, authority, io, thrown) {
+  return await pointExistingRunFailure(home, runId, authority, io, thrown);
+}
+function writeResumeFailurePointer(io, errorPath) {
+  io.stderr(formatCliDiagnostic(`\u7EED\u8DD1\u5931\u8D25\uFF0C\u5F53\u6B21\u9519\u8BEF\u8BB0\u5F55\uFF1A${errorPath}`));
+}
+function showResumeErrorPointer(io, exitCode, terminal) {
+  if (exitCode === 0 || terminal === void 0) return;
+  const publishedError = terminal.artifacts.find((artifact) => artifact.kind === "error")?.path ?? publishedFailureErrorPath(terminal);
+  if (publishedError !== void 0) writeResumeFailurePointer(io, publishedError);
+}
+async function presentResumeFailurePointer(io, thrown, publish) {
+  const failure2 = classifyPostAdmissionFailure({
+    timedOut: false,
+    code: null,
+    stderr: "",
+    thrown
+  });
+  try {
+    writeResumeFailurePointer(io, await publish(failure2));
+  } catch (publishError) {
+    const cause = {
+      publishError: formatErrorCauseDetail(publishError)
+    };
+    if (thrown instanceof Error && thrown.cause !== void 0) {
+      cause.thrownCause = formatErrorCauseDetail(thrown.cause);
     }
-    throw error;
+    presentStructuralRejection({
+      message: thrown instanceof Error ? thrown.message : String(thrown),
+      cause
+    }, io);
   }
 }
+async function writeResumeDiagnosticFile(runDirectory, runId, failure2, role) {
+  const dir = await ensureRealArtifactsDirectory(runDirectory);
+  const path = join31(dir, `resume-diagnostic-${randomUUID6()}.json`);
+  await writeFile9(
+    path,
+    `${JSON.stringify({
+      runId,
+      ...role === void 0 ? {} : { role },
+      diagnostic: failure2.diagnostic,
+      ...failure2.cause === void 0 ? {} : { cause: failure2.cause },
+      ...failure2.identity === void 0 ? {} : { identity: failure2.identity },
+      ...failure2.details === void 0 ? {} : { details: failure2.details }
+    }, null, 2)}
+`,
+    { encoding: "utf8", flag: "wx" }
+  );
+  return path;
+}
 async function runPostAdmissionOneShot(input) {
   return await runPostAdmissionResumable({
     admitted: input.admitted,
@@ -18325,11 +18462,11 @@ function isBoardTicketSeat(seat) {
 }
 async function bindAndRelocateDiarist(admitted, authority, lease) {
   const boardTicket = await readBoardTicketNumber(admitted.runDirectory);
-  if (boardTicket === void 0) return;
+  if (boardTicket === void 0) return void 0;
   if (admitted.ticketNumber === void 0) {
     await bindAdmittedTicketNumber(admitted, boardTicket);
   }
-  await relocateAdmittedRunToTicket(admitted, authority, lease);
+  return await relocateAdmittedRunToTicket(admitted, authority, lease);
 }
 function seatAdapters(admitted, env) {
   const record4 = roleRecord(admitted.role);
@@ -18348,8 +18485,8 @@ function seatAdapters(admitted, env) {
         await bindAndRelocateDiarist(seat, env.principalAuthority, lease);
       },
       afterDispatch: async (seat, lease) => {
-        if (!isBoardTicketSeat(seat)) return;
-        await bindAndRelocateDiarist(seat, env.principalAuthority, lease);
+        if (!isBoardTicketSeat(seat)) return void 0;
+        return await bindAndRelocateDiarist(seat, env.principalAuthority, lease);
       }
     } : {}
   };
@@ -18911,7 +19048,9 @@ async function continueParentAfterChild(parentRunId, child, env, io) {
       return { exitCode: 0, admitted, terminal: refresh.terminal };
     }
   }
-  return dispatchAdmitted(admitted, env, io);
+  const result = await dispatchAdmitted(admitted, env, { ...io, omitFailureStderrDiagnostic: true });
+  showResumeErrorPointer(io, result.exitCode, result.terminal);
+  return result;
 }
 var init_instruction_seat_run = __esm({
   "src/public-cli/instruction-seat-run.ts"() {
@@ -21778,6 +21917,7 @@ function commandNeedsProcessCancel(argv) {
 }
 async function runAkRole(argv, env) {
   const io = env.io ?? defaultIo();
+  let resumeFailureContext;
   try {
     env = {
       ...env,
@@ -21850,11 +21990,16 @@ async function runAkRole(argv, env) {
       env = { ...env, freshSummons: true };
     }
     if (parsed.command === "resume") {
+      const resumeRequest = parseResumeRequest(parsed.args);
+      resumeFailureContext = {
+        home,
+        runId: resumeRequest.runId,
+        authority: env.principalAuthority ?? piDurablePrincipalAuthority
+      };
       const agentDir = resolveAgentDir(env, home);
       const cwd = env.cwd ?? process.cwd();
       const config = await loadAndValidateConfig(home, env.packageRoot);
       const credentials = env.credentials ?? await loadCredentialProviders(agentDir);
-      const resumeRequest = parseResumeRequest(parsed.args);
       const resumeRole = await peekRoleRunRole(home, resumeRequest.runId);
       const seatRole = resumeRole ?? "judge";
       const seat = resolveEffectiveSeat(
@@ -21879,6 +22024,11 @@ async function runAkRole(argv, env) {
       let current = result;
       while (current.exitCode === 0 && current.admitted?.correlationId !== void 0 && current.terminal?.roleOutcome.kind === "accepted" && !courtDiaristEscalated(current.terminal.roleOutcome)) {
         const parentRunId = current.admitted.correlationId;
+        resumeFailureContext = {
+          home,
+          runId: parentRunId,
+          authority: env.principalAuthority ?? piDurablePrincipalAuthority
+        };
         const parentRole = await peekRoleRunRole(home, parentRunId);
         if (parentRole === void 0) break;
         const parentSeat = resolveEffectiveSeat(config, parentRole, credentials, invocationFromParsed(parsed));
@@ -21921,6 +22071,18 @@ async function runAkRole(argv, env) {
     }
     throw new CliUsageError(`unknown command: ${parsed.command}`);
   } catch (error) {
+    if (resumeFailureContext !== void 0 && !(error instanceof TurnDispatchedFailure) && await presentLocatedResumeFailure(
+      resumeFailureContext.home,
+      resumeFailureContext.runId,
+      resumeFailureContext.authority,
+      io,
+      error
+    )) {
+      return {
+        exitCode: error instanceof CliUsageError ? 2 : 1,
+        ...error instanceof HostSelectionError ? { hostFailure: error.failure } : {}
+      };
+    }
     if (error instanceof HostSelectionError) {
       io.stderr(formatCliDiagnostic(formatHostSelectionFailure(error.failure)));
       return { exitCode: 1, hostFailure: error.failure };
@@ -21958,10 +22120,12 @@ var init_cli = __esm({
     init_registry();
     init_cli_errors();
     init_machine_method_skills();
+    init_post_admission();
     init_role_turn_host();
     init_role_turn_host_resolution();
     init_invocation();
     init_option_definitions();
+    init_auto_resume();
     init_instruction_seat_run();
     init_countersign_run();
     init_analyst_run();

package/dist/public-cli/cli.js

@@ -13,10 +13,12 @@ import { packagedModelParent } from "../packaged-role-registry.js";
 import { seatModelOnly } from "./registry.js";
 import { CliUsageError } from "./cli-errors.js";
 import { runMachineSkillSetup } from "./machine-method-skills.js";
+import { presentLocatedResumeFailure, } from "./post-admission.js";
 import { appendPiSessionCustomEntry } from "../pi/role-turn-host.js";
 import { composeRoleTurnHostAdapters, formatHostSelectionFailure, HostSelectionError, selectRoleTurnHost, } from "./role-turn-host-resolution.js";
 import { parseAnalystArgv, parsePublicSeatArgv, } from "./invocation.js";
 import { createTypedOptionConsumer, optionsForOwner, projectCommandHelp, projectOwnerOptions, PUBLIC_NAVIGATOR_HELP_NOTE, PUBLIC_ROLE_OPTION_OWNERS, renderHumanOwnerOptionLines, } from "./option-definitions.js";
+import { TurnDispatchedFailure } from "./auto-resume.js";
 import { continueParentAfterChild, runPublicInstructionSeat, runPublicInstructionSeatResume } from "./instruction-seat-run.js";
 import { courtDiaristEscalated } from "./countersign-run.js";
 import { runPublicAnalyst } from "./analyst-run.js";
@@ -727,6 +729,7 @@ export function commandNeedsProcessCancel(argv) {
 }
 export async function runAkRole(argv, env) {
     const io = env.io ?? defaultIo();
+    let resumeFailureContext;
     try {
         // Select the installed package identity once, before any role-owned Skill,
         // runtime entry, activation argv, or invocation provenance is derived.
@@ -820,11 +823,16 @@ export async function runAkRole(argv, env) {
         // must still exist. Seat and dispatch follow the durable admitted role.
         // #471: unique parser owns {runId, message?}; five role paths only consume it.
         if (parsed.command === "resume") {
+            const resumeRequest = parseResumeRequest(parsed.args);
+            resumeFailureContext = {
+                home,
+                runId: resumeRequest.runId,
+                authority: env.principalAuthority ?? piDurablePrincipalAuthority,
+            };
             const agentDir = resolveAgentDir(env, home);
             const cwd = env.cwd ?? process.cwd();
             const config = await loadAndValidateConfig(home, env.packageRoot);
             const credentials = env.credentials ?? (await loadCredentialProviders(agentDir));
-            const resumeRequest = parseResumeRequest(parsed.args);
             const resumeRole = await peekRoleRunRole(home, resumeRequest.runId);
             // Missing durable role keeps the judge seat table. The resume entry
             // itself is one function; it reads the stored run.
@@ -844,6 +852,11 @@ export async function runAkRole(argv, env) {
                 && current.terminal?.roleOutcome.kind === "accepted"
                 && !courtDiaristEscalated(current.terminal.roleOutcome)) {
                 const parentRunId = current.admitted.correlationId;
+                resumeFailureContext = {
+                    home,
+                    runId: parentRunId,
+                    authority: env.principalAuthority ?? piDurablePrincipalAuthority,
+                };
                 const parentRole = await peekRoleRunRole(home, parentRunId);
                 if (parentRole === undefined)
                     break;
@@ -875,6 +888,16 @@ export async function runAkRole(argv, env) {
         throw new CliUsageError(`unknown command: ${parsed.command}`);
     }
     catch (error) {
+        // A dispatched turn owns its settlement; only pre-dispatch resume failures
+        // fall through to the located-run diagnostic presenter here.
+        if (resumeFailureContext !== undefined
+            && !(error instanceof TurnDispatchedFailure)
+            && await presentLocatedResumeFailure(resumeFailureContext.home, resumeFailureContext.runId, resumeFailureContext.authority, io, error)) {
+            return {
+                exitCode: error instanceof CliUsageError ? 2 : 1,
+                ...(error instanceof HostSelectionError ? { hostFailure: error.failure } : {}),
+            };
+        }
         if (error instanceof HostSelectionError) {
             io.stderr(formatCliDiagnostic(formatHostSelectionFailure(error.failure)));
             return { exitCode: 1, hostFailure: error.failure };

package/dist/public-cli/instruction-seat-run.js

@@ -12,7 +12,7 @@ import { packagedAdmitsCountersign, packagedBindsBoardTicket, packagedRebindSour
 import { isAuditorSoulRole } from "../auditor-soul.js";
 import { CliUsageError } from "./cli-errors.js";
 import { admitPublicRole, bindAdmittedTicketNumber, bindCourtTicketNumbersOnAdmitted, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedSourceRunPath, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, withPreparedAttachments, } from "./invocation.js";
-import { presentControlledFailure, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
+import { presentControlledFailure, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
 import { buildAutoResumeContinuationPrompt, loadResumablePublicRole, markRunAdmitted, parentRunPathFromGatePointerInstruction, } from "./run-lifecycle.js";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
 import { presentStructuralRejection, seatKnownFailureResolver, trySettlePublicSeat, } from "./settlement.js";
@@ -52,11 +52,11 @@ function isBoardTicketSeat(seat) {
 async function bindAndRelocateDiarist(admitted, authority, lease) {
     const boardTicket = await readBoardTicketNumber(admitted.runDirectory);
     if (boardTicket === undefined)
-        return;
+        return undefined;
     if (admitted.ticketNumber === undefined) {
         await bindAdmittedTicketNumber(admitted, boardTicket);
     }
-    await relocateAdmittedRunToTicket(admitted, authority, lease);
+    return await relocateAdmittedRunToTicket(admitted, authority, lease);
 }
 function seatAdapters(admitted, env) {
     const record = roleRecord(admitted.role);
@@ -80,8 +80,8 @@ function seatAdapters(admitted, env) {
                 },
                 afterDispatch: async (seat, lease) => {
                     if (!isBoardTicketSeat(seat))
-                        return;
-                    await bindAndRelocateDiarist(seat, env.principalAuthority, lease);
+                        return undefined;
+                    return await bindAndRelocateDiarist(seat, env.principalAuthority, lease);
                 },
             }
             : {}),
@@ -655,5 +655,7 @@ export async function continueParentAfterChild(parentRunId, child, env, io) {
             return { exitCode: 0, admitted, terminal: refresh.terminal };
         }
     }
-    return dispatchAdmitted(admitted, env, io);
+    const result = await dispatchAdmitted(admitted, env, { ...io, omitFailureStderrDiagnostic: true });
+    showResumeErrorPointer(io, result.exitCode, result.terminal);
+    return result;
 }