@sublang/playbook 15.1.0 → 17.0.0

package/reference/sdlc/code.playbook/bin/run.js

@@ -16,10 +16,12 @@ import { createTmuxPlayRuntime } from "@sublang/cligent/tmux-play";
 import {
   assertPlaybookEffectLedger,
   emptyPlaybookEffectLedger,
+  isPlaybookEffectLedgerMonotonicExtension,
 } from "../../../../src/xstate-runtime.js";
 import {
   assertPlaybookCaptainShellSnapshot,
   createPlaybookCaptainShell,
+  projectUnresolvedEffects,
 } from "../playbook-captain.js";
 import {
   adapterSdkFailureLines,
@@ -53,6 +55,7 @@ import {
   assertCaptainSessionExecutionCompatible,
   assertCaptainSessionsDirectoryUsable,
   createCaptainSessionStore,
+  isUncertainTurnDiscardable,
   projectCaptainSessionStructure,
   SESSION_ID_PATTERN,
   validateCaptainSessionExecutionProjection,
@@ -306,7 +309,7 @@ export async function runPlaybookRun(options = {}) {
       if (!args.retryUncertain) {
         const releaseError = await releaseLease(lease);
         lease = undefined;
-        await reportUncertainSession(stderr, sessionId);
+        await reportUncertainSession(stderr, sessionId, !isUncertainTurnDiscardable(priorRecord));
         if (releaseError !== undefined) {
           await writeStream(
             stderr,
@@ -791,11 +794,12 @@ export async function driveHeadlessCaptainTurn({
   const replies = [];
   let shell;
   let host;
+  let createdHost;
   let baselineSnapshot;
   let uncertainRecord;
   try {
     try {
-      const created = await createCaptainSessionHost({
+      const created = createdHost = await createCaptainSessionHost({
         config,
         sessionId,
         cwd,
@@ -895,6 +899,11 @@ export async function driveHeadlessCaptainTurn({
           : cleanupFailure;
       }
     }
+    try {
+      if (createdHost?.getInterruptedSettlement(uncertainRecord?.uncertain?.attemptId)) {
+        await writeStream(stderr, 'The latest work is saved. Continue this session with a new instruction.\n');
+      }
+    } catch { /* Preserve the original turn or cleanup error. */ }
     throw error;
   }
 }
@@ -961,54 +970,82 @@ function isCaptainSessionHostCleanupIncomplete(error) {
   );
 }
 
-function reconcileWholeTurnReplaySnapshot(snapshot, ledger, catalog) {
-  const checkpoint = assertPlaybookEffectLedger(snapshot.effectLedger);
+export function restoreInterruptedProgress(record, ledger) {
+  const base = record.snapshot;
+  const progress = record.uncertain.progress;
   const current = assertPlaybookEffectLedger(ledger);
-  const checkpointBoundaryCount = checkpoint.boundaries.length;
-  const currentPrefix = current.boundaries.slice(0, checkpointBoundaryCount);
-  if (!isDeepStrictEqual(currentPrefix, checkpoint.boundaries)) {
-    throw new Error(
-      "Captain uncertain turn repository-effect reconciliation cannot restore a changed pre-turn boundary",
-    );
-  }
-  if (
-    !isDeepStrictEqual(current.logicalOperations, checkpoint.logicalOperations)
-  ) {
-    throw new Error(
-      "Captain uncertain turn repository-effect reconciliation found deferred logical-operation progress and cannot replay the Boss turn",
-    );
+  if (!isPlaybookEffectLedgerMonotonicExtension(base.effectLedger, current)) {
+    throw new Error('Captain recovery evidence changed incompatibly');
   }
-  const suffix = current.boundaries.slice(checkpointBoundaryCount);
-  const blocking = suffix.find(
-    (boundary) => boundary.physicalReceipt?.classification !== "unchanged",
-  );
-  if (blocking !== undefined) {
-    const classification =
-      blocking.physicalReceipt?.classification ?? "incomplete";
-    throw new Error(
-      `Captain uncertain turn repository-effect boundary ${JSON.stringify(blocking.boundaryId)} is ${classification}; whole-turn replay remains parked for reconciliation`,
-    );
+  const steps = progress?.steps ?? [];
+  const saved = progress?.snapshot;
+  const changedBoundaries = current.boundaries.filter((boundary, index) => !isDeepStrictEqual(boundary, base.effectLedger.boundaries[index]));
+  const changedOperations = current.logicalOperations.filter((operation, index) => !isDeepStrictEqual(operation, base.effectLedger.logicalOperations[index]));
+  const noWork = isUncertainTurnDiscardable(record);
+  const completion = steps.findLast((step) => step.kind === 'completion');
+  const facts = steps.map((step) => {
+    const name = `/${record.structuralProjection.catalog[step.playbookId].command}`;
+    if (step.kind === 'completion') return `${name} ${step.result.terminalOutcome?.kind === 'failure' ? 'stopped with a failure' : 'finished'}. ${step.result.description ?? 'No result description was supplied.'}`;
+    if (step.kind === 'answer') return `Captain selected the original task as the answer for ${name}. Questions: ${step.result.questions.map(({ question }) => JSON.stringify(question)).join('; ')}. Answer: ${JSON.stringify(step.result.instruction)}.`;
+    if (step.kind === 'preparation') return step.result === undefined
+      ? `Captain started preparation for ${name}; it may have used tools. No result was saved.`
+      : `Captain preparation for ${name}: ${step.result.summary}`;
+    return `${name} ${step.kind} call: ${step.result === undefined ? 'started; no result was saved' : step.result?.status === undefined ? 'result saved' : `returned ${step.result.status}`}.`;
+  });
+  const completedRoots = steps.filter((step) => step.kind === 'completion' && step.result.retention !== 'keep').map((step) => ({ kind: 'clear', rootPlaybookId: step.playbookId }));
+  const report = {
+    retentionUpdates: completedRoots,
+    effects: projectUnresolvedEffects(current, [
+      ...changedBoundaries.map(({ boundaryId }) => ({ kind: 'boundary', boundaryId })),
+      ...changedOperations.map(({ operationId }) => ({ kind: 'logical-operation', operationId })),
+    ]),
+    text: [noWork
+      ? 'The last message was not processed. Your previous position and pending questions are restored; no work was repeated.'
+      : saved
+        ? completion && !saved.frames?.length
+          ? 'The completed run is restored; no work was repeated.'
+          : 'The run stopped. Its saved position is restored; no work was repeated. Choose how to continue. Before repeating unfinished work, confirm that the earlier worker has stopped and check any outside actions it may have taken.'
+        : 'The exact stopping point was not saved. Files and repository evidence are preserved; no work was repeated. Check the saved work and stop any earlier worker before starting another attempt.', ...facts].join('\n\n'),
+  };
+  if (noWork) return { snapshot: base, report };
+  if (saved) {
+    if (!isPlaybookEffectLedgerMonotonicExtension(saved.effectLedger, current)) throw new Error('Saved step evidence changed incompatibly');
+    const frames = saved.frames?.map((frame) => {
+      const checkpoint = frame.runtime.recoveryCheckpoint;
+      const step = steps.find((entry) => entry.id === checkpoint?.id && entry.runtimeSessionId === frame.sessionId && entry.playbookId === frame.playbookId && entry.stateId === checkpoint?.stateId);
+      const { failedEffectAttempt: priorAttempt, ...runtime } = frame.runtime;
+      const interrupted = step !== undefined && checkpoint?.id === progress.positionStepId;
+      const attempts = interrupted && priorAttempt
+        ? new Set(current.boundaries.filter(({ sequence }) => sequence > priorAttempt.boundaryPrefix).map(({ attemptId }) => attemptId)) : undefined;
+      const failedEffectAttempt = attempts === undefined ? priorAttempt : attempts.size > 1 ? undefined
+        : { boundaryPrefix: priorAttempt.boundaryPrefix, attemptId: attempts.values().next().value ?? null };
+      return { ...frame, runtime: { ...runtime, effectLedger: current,
+        ...(failedEffectAttempt === undefined ? {} : { failedEffectAttempt }),
+        ...(step?.result === undefined || !interrupted ? {} : { recoveryCheckpoint: { ...checkpoint, result: step.result } }),
+      } };
+    });
+    return { snapshot: assertPlaybookCaptainShellSnapshot({ ...saved, effectLedger: current, ...(frames ? { frames } : {}) }), report };
   }
-  const frames =
-    snapshot.mode !== "engaged.parked"
-      ? undefined
-      : snapshot.frames.map((frame) => {
-          if (catalog[frame.playbookId]?.artifactSchema !== 3) {
-            throw new Error(
-              `Captain uncertain turn cannot rebase frame ${JSON.stringify(frame.playbookId)} without exact artifact-schema authority`,
-            );
-          }
-          return {
-            ...frame,
-            runtime: { ...frame.runtime, effectLedger: current },
-          };
-        });
+  const owners = new Set([...changedBoundaries, ...changedOperations, ...(progress?.steps ?? [])].map((entry) => entry.runtimeSessionId));
+  const clears = Object.entries(record.retainedGenerations ?? {})
+    .filter(([, generation]) => generation.frames.some((frame) => owners.has(frame.sessionId) || owners.has(frame.runtime.retainedEffectSourceSessionId)))
+    .map(([rootPlaybookId]) => ({ kind: 'clear', rootPlaybookId }));
+  const { frames, pendingBossQuestions, lastError, retainedEffectReconciliation, ...chat } = base;
+  return {
+    snapshot: assertPlaybookCaptainShellSnapshot({ ...chat, mode: 'chat', effectLedger: current }),
+    report: { ...report, retentionUpdates: [...completedRoots, ...clears], unresolvedEffects: report.effects },
+  };
+}
 
-  return assertPlaybookCaptainShellSnapshot({
-    ...snapshot,
-    effectLedger: current,
-    ...(frames === undefined ? {} : { frames }),
-  });
+// A drained turn can retain its actual stopped stack without replaying work.
+// This runs inside the shared Captain boundary, before any host can dispose it.
+export async function settleInterruptedRecovery(shell, lease) {
+  if (typeof lease.read !== 'function') return;
+  const record = await lease.read();
+  if (!record?.uncertain?.progress) return;
+  const settlement = shell.exportSettlement();
+  if (!settlement) return;
+  return { attemptId: record.uncertain.attemptId, record: await lease.settle({ attemptId: record.uncertain.attemptId, ...settlement }) };
 }
 
 export async function createCaptainSessionHost({
@@ -1057,37 +1094,22 @@ export async function createCaptainSessionHost({
   }
   const currentEffectLedger = () =>
     effectLedgerSnapshotFromCapabilities(hostCapabilities);
+  const interrupted = reconcileUncertainTurnReplay && typeof sessionLease.read === 'function'
+    ? await sessionLease.read() : undefined;
   let sourceSnapshot = restoreSnapshot;
-  if (
-    sourceSnapshot !== undefined &&
-    !isDeepStrictEqual(sourceSnapshot.effectLedger, currentEffectLedger())
-  ) {
-    const recovered =
-      typeof sessionLease.read === "function"
-        ? await sessionLease.read()
-        : undefined;
-    if (
-      recovered?.state === "settled" &&
-      isDeepStrictEqual(recovered.snapshot.effectLedger, currentEffectLedger())
-    ) {
-      sourceSnapshot = recovered.snapshot;
+  let interruptedReport;
+  if (interrupted) {
+    const restored = restoreInterruptedProgress(interrupted, currentEffectLedger());
+    sourceSnapshot = restored.snapshot;
+    interruptedReport = restored.report;
+  } else if (sourceSnapshot && !isDeepStrictEqual(sourceSnapshot.effectLedger, currentEffectLedger())) {
+    const recovered = await sessionLease.read?.();
+    if (recovered?.state !== 'settled' || !isDeepStrictEqual(recovered.snapshot.effectLedger, currentEffectLedger())) {
+      throw new Error('Captain session effect ledger requires reconciliation before source-state restoration');
     }
+    sourceSnapshot = recovered.snapshot;
   }
-  if (sourceSnapshot !== undefined && reconcileUncertainTurnReplay) {
-    sourceSnapshot = reconcileWholeTurnReplaySnapshot(
-      sourceSnapshot,
-      currentEffectLedger(),
-      config.catalog,
-    );
-  } else if (
-    sourceSnapshot !== undefined &&
-    !isDeepStrictEqual(sourceSnapshot.effectLedger, currentEffectLedger())
-  ) {
-    throw new Error(
-      "Captain session effect ledger requires reconciliation before source-state restoration",
-    );
-  }
-  if (sourceSnapshot !== undefined && typeof sessionLease.consumeHints === "function") {
+  if (sourceSnapshot !== undefined && !interrupted && typeof sessionLease.consumeHints === "function") {
     sourceSnapshot = attachSessionHints(sourceSnapshot, await sessionLease.consumeHints());
   }
   const bufferedRecords = [];
@@ -1104,8 +1126,12 @@ export async function createCaptainSessionHost({
     else await forwardRecord(record);
   } }];
   const shell = createPlaybookCaptainShell(captainOptionsFromConfig(config), {
+    abortPreparation: (reason) => host?.abortActiveTurn(typeof reason === 'string' ? reason : 'Captain preparation exceeded its 150-second limit'),
     loadModule,
     hostCapabilities,
+    ...(typeof sessionLease.recordProgress === 'function' ? {
+      recordProgress: (change) => sessionLease.recordProgress(change),
+    } : {}),
     continuity: {
       async beforeCall(participantId) { sessionLease.clearHint?.(participantId); await sessionLease.assertOwner(); },
       acknowledged(participantId, token) { sessionLease.acknowledgeHint?.(participantId, token); },
@@ -1122,8 +1148,9 @@ export async function createCaptainSessionHost({
       : {}),
   });
   let host;
+  let interruptedSettlement;
   try {
-    const captain = captainHostBoundary(shell, sourceSnapshot);
+    const captain = captainHostBoundary(shell, sourceSnapshot, sessionLease, (record) => { interruptedSettlement = record; });
     host = await createHostRuntime({
       captain,
       captainConfig: projectHostAgent(
@@ -1147,7 +1174,7 @@ export async function createCaptainSessionHost({
     }
     if (
       sourceSnapshot !== undefined &&
-      !isDeepStrictEqual(snapshot, sourceSnapshot)
+      !isDeepStrictEqual(snapshot, assertPlaybookCaptainShellSnapshot(sourceSnapshot))
     ) {
       throw new Error("restored Captain snapshot changed before the Boss turn");
     }
@@ -1163,7 +1190,8 @@ export async function createCaptainSessionHost({
     }
     presentationReady = true;
     for (const record of bufferedRecords) await forwardRecord(record);
-    return { shell, host, snapshot, reconcileRepositoryEffects };
+    if (interruptedReport) shell.selectInterruptedReport(interrupted.uncertain.input, interruptedReport);
+    return { shell, host, snapshot, reconcileRepositoryEffects, getInterruptedSettlement: (attemptId) => attemptId !== undefined && interruptedSettlement?.attemptId === attemptId ? interruptedSettlement.record : undefined };
   } catch (error) {
     let cleanupError;
     try {
@@ -1215,13 +1243,26 @@ export async function installRetainedGenerationsForLaunch({
 
 // PBCLI-20: restoration enters through the host's one init boundary. The
 // restored shell is fresh and receives restore instead of init, never both.
-function captainHostBoundary(shell, restoreSnapshot) {
+function captainHostBoundary(shell, restoreSnapshot, sessionLease, onInterrupted) {
   return {
     init: (session) =>
       restoreSnapshot === undefined
         ? shell.init(session)
         : shell.restore(session, restoreSnapshot),
-    handleBossTurn: (turn, context) => shell.handleBossTurn(turn, context),
+    async handleBossTurn(turn, context) {
+      onInterrupted(undefined);
+      try {
+        const result = await shell.handleBossTurn(turn, context);
+        context.signal.throwIfAborted();
+        return result;
+      } catch (error) {
+        try { onInterrupted(await settleInterruptedRecovery(shell, sessionLease)); }
+        catch (settlementError) {
+          throw new AggregateError([error, settlementError], `Captain turn stopped (${message(error)}) and its state could not be saved (${message(settlementError)})`);
+        }
+        throw error;
+      }
+    },
     prepareDispose: () => shell.prepareDispose?.(),
     dispose: () => shell.dispose?.(),
   };
@@ -1718,14 +1759,16 @@ async function reportHeadlessReplay(channel, status) {
   await channel.flushWarning();
 }
 
-async function reportUncertainSession(stderr, sessionId) {
+async function reportUncertainSession(stderr, sessionId, hasRecordedWork = false) {
   await writeStream(
     stderr,
     [
       `playbook run: Captain session ${JSON.stringify(sessionId)} has an uncertain turn and will not be replayed automatically`,
-      "Retry may duplicate external effects from the interrupted attempt; discard abandons that attempted turn.",
+      hasRecordedWork
+        ? "Retry restores and reports the saved work without running it. Discard is unavailable because work or repository evidence was recorded."
+        : "Retry restores and reports without running work. Discard abandons the attempted turn only when no work was recorded.",
       `playbook run --session ${sessionId} --retry-uncertain`,
-      `playbook run --session ${sessionId} --discard-uncertain`,
+      ...(hasRecordedWork ? [] : [`playbook run --session ${sessionId} --discard-uncertain`]),
       "",
     ].join("\n"),
   );
@@ -1827,15 +1870,15 @@ function runHelpText(userConfigPath) {
     "An ordinary continued run restores that stored structure and working",
     "directory, then reads current config and overlays for model, effort,",
     "and fast mode.",
-    "Uncertain retry instead uses its exact recorded input and settings.",
+    "Uncertain retry only restores and reports; later work uses current settings.",
     "",
     "Options:",
     "  --with <path>    overlay a generic config fragment (repeatable)",
     "  --no-provision   do not provision thin filesystem registry engines",
     "  --continue       prefer this working directory, else global newest",
     "  --session <id>   reply to one durable Captain session UUID",
-    "  --retry-uncertain retry that session's exact recorded uncertain input",
-    "  --discard-uncertain discard that session's uncertain attempt",
+    "  --retry-uncertain restore and report interrupted work without running it",
+    "  --discard-uncertain discard only an attempt with no recorded work",
     '  --json           print exactly {"sessionId", "reply"}',
     "  --verbose        print Captain telemetry topics to stderr",
     "  -h, --help       print this help without reading input or config",

package/reference/sdlc/code.playbook/bin/session-host.js

@@ -2,10 +2,12 @@
 // SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
 
 import { randomUUID } from 'node:crypto';
-import { createCaptainSessionStore, projectCaptainSessionStructure } from './session-store.js';
+import { createCaptainSessionStore, isUncertainTurnDiscardable, projectCaptainSessionStructure } from './session-store.js';
 import { createCaptainSessionHost, executionConfigFromPlan, installRetainedGenerationsForLaunch, validateFrozenExecutionConfig } from './run.js';
 import { createReplayRecordObserver } from './replay-observer.js';
 
+const RECOVERY_REOPEN = "This controller stopped with an uncertain turn. Dispose it, reopen with mode: 'recover', then call recover() without new input.";
+
 /** Own one session lease and the same durable turn transaction as the CLIs. */
 export async function openSessionHost(options) {
   const store = options.store ?? createCaptainSessionStore({ sessionsDir: options.sessionsDir });
@@ -19,9 +21,10 @@ export async function openSessionHost(options) {
     let record = await lease.read();
     if (record !== undefined) await lease.assertContinuable({ cwd: options.cwd });
     record = await lease.recoverUnresolvedEffectAbandonment();
+    if (options.mode === 'recover') retryPending = record?.state === 'uncertain';
     if (options.mode === 'new' && record !== undefined) throw new Error('session already exists');
     if (options.mode !== 'new' && options.sessionId && record === undefined) throw new Error('session does not exist');
-    if (record?.state === 'uncertain' && !retryPending) throw new Error('session has an uncertain turn; select Retry or Discard');
+    if (record?.state === 'uncertain' && !retryPending) throw new Error(isUncertainTurnDiscardable(record) ? 'session has an uncertain turn; select Retry or Discard' : 'session has recorded work or repository evidence; select Retry to restore and report it');
     if (retryPending && record?.state !== 'uncertain') throw new Error('session has no uncertain turn to retry');
     const cwd = options.cwd ?? record?.cwd ?? process.cwd();
     const selected = retryPending ? record.uncertain.attemptedExecutionProjection : options.config ?? (options.plan ? executionConfigFromPlan(options.plan) : record?.lastAppliedExecutionProjection);
@@ -43,16 +46,20 @@ export async function openSessionHost(options) {
     await installRetainedGenerationsForLaunch({ lease, shell: created.shell, ...(record === undefined ? { freshBoundary: { cwd, structuralProjection: structure, executionProjection: config, snapshot: created.snapshot } } : {}), retainedGenerations: record?.retainedGenerations ?? {}, reconcileRepositoryEffects: created.reconcileRepositoryEffects });
     record = await lease.read();
     await replay.flushStoredRecords();
-    const execute = async (input, retry, actionId, shellActionId) => {
+    const assertIdle = () => {
       if (closed || closing) throw new Error('session host is closing');
       if (active) throw new Error('session turn is already active');
+    };
+    const execute = async (input, retry, actionId, shellActionId) => {
+      assertIdle();
+      let attemptId;
       const operation = (async () => {
         let prior = await lease.read();
         if (retry) {
           if (prior?.state !== 'uncertain') throw new Error('session has no uncertain turn to retry');
           input = prior.uncertain.input;
-          if (!retryPending) throw new Error('retry requires reopening the uncertain checkpoint');
-        } else if (prior?.state !== 'settled') throw new Error('session has an uncertain turn; select Retry or Discard');
+          if (!retryPending) throw new Error(RECOVERY_REOPEN);
+        } else if (prior?.state !== 'settled') throw new Error(RECOVERY_REOPEN);
         if (actionId === undefined && shellActionId === undefined && (typeof input !== 'string' || input.trim().length === 0)) throw new Error('session input must be nonempty');
         await created.reconcileRepositoryEffects();
         // The selection is made after reconciliation, so the advertised
@@ -66,7 +73,7 @@ export async function openSessionHost(options) {
           input = created.shell.submitShellAction(shellActionId);
         }
         terminal = undefined; replies = [];
-        const attemptId = options.createAttemptId?.() ?? randomUUID();
+        attemptId = options.createAttemptId?.() ?? randomUUID();
         const marked = retry ? await lease.beginRetry({ expectedAttemptId: prior.uncertain.attemptId, nextAttemptId: attemptId }) : await lease.beginTurn({ input, attemptId, attemptedExecutionProjection: config });
         retryPending = false;
         await replay.flushStoredRecords();
@@ -80,10 +87,23 @@ export async function openSessionHost(options) {
         await replay.flushStoredRecords();
         await options.onCheckpoint?.(record);
         return record;
-      })();
+      })().catch(async (error) => {
+        try {
+          const parked = created.getInterruptedSettlement(attemptId);
+          if (parked?.state === 'settled') {
+            record = parked;
+            await replay.flushStoredRecords();
+            await options.onCheckpoint?.(record);
+          }
+        } catch (reportError) {
+          throw new AggregateError([error, reportError], 'Captain turn stopped and its saved state could not be reported');
+        }
+        throw error;
+      });
       active = operation;
       try { return await operation; } finally { active = undefined; }
     };
+
     const dispose = () => {
       if (closed) return Promise.resolve();
       if (closing) return closing;
@@ -94,7 +114,19 @@ export async function openSessionHost(options) {
       })();
       return closing;
     };
-    return Object.freeze({ sessionId, host: created.host, shell: created.shell, lease, read: () => lease.read(), handleBossTurn: (input) => execute(input, false), listRuntimeActions: () => created.shell.describeRuntimeActions?.() ?? Object.freeze([]), submitRuntimeAction: (actionId) => execute(undefined, false, actionId), listShellActions: () => created.shell.describeShellActions?.() ?? Object.freeze([]), submitShellAction: (actionId) => execute(undefined, false, undefined, actionId), retry: () => execute(undefined, true), dispose });
+    const recover = async (input) => {
+      assertIdle();
+      const prior = await lease.read();
+      assertIdle();
+      if (prior?.state === 'uncertain' && !retryPending) throw new Error(RECOVERY_REOPEN);
+      if (retryPending) {
+        if (input !== undefined) throw new Error('Restore and report the interrupted run before supplying new input');
+        return execute(undefined, true);
+      }
+      if (typeof input !== 'string' || !input.trim()) throw new Error('Recovery of a paused task requires a Boss instruction');
+      return execute(input, false);
+    };
+    return Object.freeze({ sessionId, host: created.host, shell: created.shell, lease, read: () => lease.read(), handleBossTurn: (input) => execute(input, false), recover, listRuntimeActions: () => created.shell.describeRuntimeActions?.() ?? Object.freeze([]), submitRuntimeAction: (actionId) => execute(undefined, false, actionId), listShellActions: () => created.shell.describeShellActions?.() ?? Object.freeze([]), submitShellAction: (actionId) => execute(undefined, false, undefined, actionId), retry: () => execute(undefined, true), dispose });
   } catch (cause) {
     const failures = [cause];
     let disposed = true;