@bastani/atomic 0.9.45-alpha.1 → 0.9.46-alpha.1

package/dist/builtin/subagents/src/extension/index.bundle.mjs

@@ -7785,6 +7785,9 @@ function splitKnownThinkingSuffix(model) {
     thinkingSuffix: `:${suffix}`
   };
 }
+function taskRecordModel(model) {
+  return model === undefined ? undefined : splitKnownThinkingSuffix(model).baseModel;
+}
 
 // dist/builtin/subagents/src/shared/formatters.ts
 function formatTokens(n) {
@@ -9818,6 +9821,14 @@ function resumeRunWorktree(child, setupHook) {
 }
 
 // dist/builtin/subagents/src/runs/foreground/subagent-child-records.ts
+function heldTaskExpands(held) {
+  return held.taskExpands ?? true;
+}
+function pendingMessagesOfResult(result) {
+  if (!result.pendingMessages?.length)
+    return;
+  return { messages: result.pendingMessages, taskExpands: result.pendingTaskExpands === true };
+}
 function subagentChildInheritance(options) {
   return {
     ...options.currentModel ? { model: options.currentModel } : {},
@@ -10741,8 +10752,8 @@ async function runAgentTask(input) {
       ...input.options.orchestratorIntercomTarget ? { orchestratorTarget: input.options.orchestratorIntercomTarget } : {},
       ...worktree ? { worktree } : {},
       ...terminalStatus ? { terminalStatus } : {},
-      ...heldMessages?.length ? { heldMessages: { taskId, messages: heldMessages } } : {},
-      ...launch ? { launch } : {},
+      ...heldMessages?.messages.length ? { heldMessages: { taskId, ...heldMessages } } : {},
+      ...launch ? { launch } : heldMessages?.taskExpands && input.options.resumeSession !== true && childSession.childSessionId === undefined ? { launch: subagentChildLaunch(input.task, input.intentTask, input.options) } : {},
       inherited: subagentChildInheritance(input.options)
     });
   };
@@ -10888,7 +10899,7 @@ ${launch.message}` : input.task,
         if (child.model !== undefined || child.thinking !== undefined)
           context.reportActivity({
             reportId: "terminal-model",
-            change: { kind: "model", model: child.model, thinking: child.thinking }
+            change: { kind: "model", model: taskRecordModel(child.model), thinking: child.thinking }
           });
         const stopped = takeSubagentChildStop(context.ref.taskId);
         const stoppedByControl = stopped !== undefined && child.status === "interrupted";
@@ -10901,11 +10912,11 @@ ${launch.message}` : input.task,
         if (endedForGood || child.status === "killed")
           forgetRunMembership(runId, index);
         if (!ownerClosed())
-          recordChild("terminal", stoppedByControl ? stopped : stoppedByStagePause ? SUBAGENT_CHILD_STAGE_PAUSED_STATUS : child.status, stoppedByControl || stoppedByStagePause ? child.pendingMessages : undefined);
+          recordChild("terminal", stoppedByControl ? stopped : stoppedByStagePause ? SUBAGENT_CHILD_STAGE_PAUSED_STATUS : child.status, stoppedByControl || stoppedByStagePause ? pendingMessagesOfResult(child) : undefined);
         else if (endedForGood)
           recordChild("terminal", SUBAGENT_CHILD_STAGE_CLOSED_STATUS);
         else if (child.pendingMessages?.length)
-          recordChild("running", undefined, child.pendingMessages);
+          recordChild("running", undefined, pendingMessagesOfResult(child));
         input.onTerminal?.(child);
         const text = input.outputText?.(child) ?? getSingleResultOutput(child);
         retainTaskOutput(child, text, context.ref);
@@ -11070,7 +11081,7 @@ async function runForegroundParallelTasks(input) {
     const sharedProgress = index === input.behaviors.findIndex((candidate) => candidate.progress) ? join12(input.paramsCwd, "progress.md") : undefined;
     const runOptions = {
       runningCapacity: input.runningCapacity,
-      getChildSessionOptions: input.ctx.getChildSessionOptions,
+      getChildSessionOptions: input.ctx.getChildSessionOptionsResolver?.() ?? input.ctx.getChildSessionOptions,
       resourceLoaderInheritanceSnapshot: input.resourceLoaderInheritanceSnapshot,
       cwd: taskCwd,
       signal: input.signal,
@@ -11186,6 +11197,7 @@ async function runForegroundParallelTasks(input) {
         taskResponse: response
       };
     }
+    const launchCwd = input.ctx.cwd;
     const launched = runOwnerlessChild({
       agent: task.agent,
       ...agentConfig ? { agentSource: agentConfig.source } : {},
@@ -11194,7 +11206,7 @@ async function runForegroundParallelTasks(input) {
       options: runOptions,
       recordChild: input.recordChild ?? { record() {} },
       schedule,
-      runSync: (childTask, options) => input.runtime.runSync(input.ctx.cwd, taskAgents, task.agent, childTask, options)
+      runSync: (childTask, options) => input.runtime.runSync(launchCwd, taskAgents, task.agent, childTask, options)
     }).result;
     return launched.finally(() => {
       if (input.foregroundControl?.currentIndex === index) {
@@ -11255,8 +11267,8 @@ function runOwnerlessChild(input) {
       ...input.options.orchestratorIntercomTarget ? { orchestratorTarget: input.options.orchestratorIntercomTarget } : {},
       ...worktree ? { worktree } : {},
       ...terminalStatus ? { terminalStatus } : {},
-      ...held?.length ? { heldMessages: { taskId: launchId, messages: held } } : {},
-      ...queuedLaunch ? { launch: queuedLaunch } : {},
+      ...held?.messages.length ? { heldMessages: { taskId: launchId, ...held } } : {},
+      ...queuedLaunch ? { launch: queuedLaunch } : held?.taskExpands && input.options.resumeSession !== true && childSession.childSessionId === undefined ? { launch: subagentChildLaunch(input.task, undefined, input.options) } : {},
       inherited: subagentChildInheritance(input.options)
     });
   };
@@ -11333,10 +11345,10 @@ ${resumed.message}` : input.task,
         forgetRunMembership(runId, index);
       if (ownerClosed) {
         parkRunWorktree(runId, index);
-        record("running", undefined, child.pendingMessages);
+        record("running", undefined, pendingMessagesOfResult(child));
         return child;
       }
-      record("terminal", stoppedByControl ? stopped : child.status, stoppedByControl ? child.pendingMessages : undefined);
+      record("terminal", stoppedByControl ? stopped : child.status, stoppedByControl ? pendingMessagesOfResult(child) : undefined);
       return child;
     } catch (error) {
       if (takeSubagentChildStop(launchId) !== undefined)
@@ -12849,24 +12861,41 @@ function statsFor(session, fallbackSessionId) {
     };
   }
 }
-function outputFor(session) {
-  return lastNonEmptyAssistantText(session?.messages, session?.getLastAssistantText());
+function messagesSinceLaunch(manager, launchLeafId) {
+  const branch = manager.getBranch();
+  const launchIndex = launchLeafId === null ? -1 : branch.findIndex((entry) => entry.id === launchLeafId);
+  if (launchLeafId !== null && launchIndex === -1)
+    return [];
+  return branch.slice(launchIndex + 1).flatMap((entry) => entry.type === "message" ? [entry.message] : []);
+}
+function outputFor(ownMessages) {
+  return lastNonEmptyAssistantText(ownMessages.filter((message) => message.role === "assistant"));
 }
-function cancelledEnvelope(session, spec, stats) {
+function noSuccessfulTurnCause(ownMessages) {
+  const ownTurns = ownMessages.flatMap((message) => message.role === "assistant" ? [message] : []);
+  if (ownTurns.some((turn) => turn.stopReason !== "error" && turn.stopReason !== "aborted"))
+    return;
+  const errorMessage = ownTurns.findLast((turn) => turn.errorMessage?.trim())?.errorMessage?.trim();
+  return errorMessage || "Child ended without completing an assistant turn of its own.";
+}
+function cancelledEnvelope(session, spec, stats, ownMessages) {
   return recoverCancelledChildOutput({
     progressPath: spec.progressPath,
-    assistantText: lastNonEmptyAssistantText(session?.messages, outputFor(session)),
+    assistantText: outputFor(ownMessages),
     toolCount: stats.toolCalls,
     sessionPath: session?.sessionFile ?? spec.sessionManager?.getSessionFile(),
     ...spec.progressArtifactPath ? { progressArtifactPath: spec.progressArtifactPath } : {},
     ...spec.outputArtifactPath ? { outputArtifactPath: spec.outputArtifactPath } : {}
   }).text;
 }
-function pendingMessagesOf(session, unsent) {
+var LITERAL_TEXT = { expandPromptTemplates: false };
+function pendingMessagesOf(session, unsent, taskLiteral) {
   const queued = session ? [...session.getSteeringMessages(), ...session.getFollowUpMessages()] : [];
   const [task, ...followUps] = unsent;
   const pending = task === undefined ? queued : [task, ...queued, ...followUps];
-  return pending.length > 0 ? { pendingMessages: pending } : {};
+  if (pending.length === 0)
+    return {};
+  return { pendingMessages: pending, ...task !== undefined && !taskLiteral ? { pendingTaskExpands: true } : {} };
 }
 function attemptStatus(termination) {
   if (termination === "interrupt" || termination === PARENT_CANCEL_CAUSE)
@@ -13073,14 +13102,11 @@ class SubagentControlRuntime {
             status: killed ? "killed" : "interrupted",
             ...waitResult === PARENT_CANCEL_CAUSE && !killed ? {
               cause: PARENT_CANCEL_CAUSE,
-              ...pendingMessagesOf(undefined, [
-                admitted.spec.task,
-                ...admitted.spec.resumeFollowUps ?? []
-              ])
+              ...pendingMessagesOf(undefined, [admitted.spec.task, ...admitted.spec.resumeFollowUps ?? []], admitted.spec.resumeTaskLiteral)
             } : {},
             stats,
             path: admitted.identity.path,
-            envelope: killed ? "Killed. This child cannot be resumed." : waitResult === PARENT_CANCEL_CAUSE ? cancelledEnvelope(undefined, admitted.spec, stats) : INTERRUPTED_ENVELOPE,
+            envelope: killed ? "Killed. This child cannot be resumed." : waitResult === PARENT_CANCEL_CAUSE ? cancelledEnvelope(undefined, admitted.spec, stats, []) : INTERRUPTED_ENVELOPE,
             ...effectiveModelId === undefined ? {} : { model: effectiveModelId },
             ...effectiveThinking === undefined ? {} : { thinking: effectiveThinking }
           };
@@ -13115,6 +13141,7 @@ class SubagentControlRuntime {
     const token = guard.token;
     this.attemptTokens.set(admitted.identity.path, token);
     let session;
+    let ownMessages = () => [];
     const executionEnded = new AbortController;
     let termination;
     const unsent = [admitted.spec.task, ...admitted.spec.resumeFollowUps ?? []];
@@ -13163,6 +13190,8 @@ class SubagentControlRuntime {
       admitted.spec.onChildSession?.(childSession);
       if (workflow)
         await sessionManager.markSessionInternal(workflow);
+      const launchLeafId = sessionManager.getLeafId();
+      ownMessages = () => messagesSinceLaunch(sessionManager, launchLeafId);
       let created;
       if (admitted.spec.testSession) {
         created = { session: createTestSession(sessionManager, admitted.spec) };
@@ -13281,7 +13310,7 @@ class SubagentControlRuntime {
       let activitySequence = 0;
       const reportModel = () => taskHooks?.reportActivity({
         reportId: `${activityPrefix}:model-${++activitySequence}`,
-        change: { kind: "model", model: effectiveModelId, thinking: effectiveThinking }
+        change: { kind: "model", model: taskRecordModel(effectiveModelId), thinking: effectiveThinking }
       });
       reportModel();
       unsubscribe = session.subscribe((event) => {
@@ -13355,21 +13384,23 @@ class SubagentControlRuntime {
       for (const followUp of admitted.spec.resumeFollowUps ?? []) {
         if (termination)
           break;
-        await session.followUp(followUp);
+        await session.followUp(followUp, undefined, LITERAL_TEXT);
         unsent.splice(1, 1);
       }
       if (!termination) {
         unsent.splice(0, 1);
-        await session.prompt(admitted.spec.task);
+        await session.prompt(admitted.spec.task, admitted.spec.resumeTaskLiteral ? LITERAL_TEXT : undefined);
       }
       await terminating;
       const stats = statsFor(session, admitted.identity.path);
       const sessionFile = session.sessionFile;
-      const output = outputFor(session);
-      const status = attemptStatus(termination);
+      const producedMessages = ownMessages();
+      const output = outputFor(producedMessages);
+      const noOutput = termination === undefined ? noSuccessfulTurnCause(producedMessages) : undefined;
+      const status = noOutput === undefined ? attemptStatus(termination) : "error";
       this.native.publishChildStatus(admitted.identity.path, nativeStatus(status));
       this.native.finishChildAttempt(token, nativeStatus(status));
-      const envelope = termination === PARENT_CANCEL_CAUSE ? cancelledEnvelope(session, admitted.spec, stats) : status === "interrupted" ? INTERRUPTED_ENVELOPE : boundedEnvelope(output || termination || "(no output)", undefined);
+      const envelope = termination === PARENT_CANCEL_CAUSE ? cancelledEnvelope(session, admitted.spec, stats, producedMessages) : status === "interrupted" ? INTERRUPTED_ENVELOPE : boundedEnvelope(output || noOutput || termination || "(no output)", undefined);
       if (status === "ok")
         return {
           status,
@@ -13386,7 +13417,10 @@ class SubagentControlRuntime {
       if (status === "interrupted")
         return {
           status: this.killedChildren.has(admitted.identity.path) ? "killed" : status,
-          ...termination === PARENT_CANCEL_CAUSE && !this.killedChildren.has(admitted.identity.path) ? { cause: PARENT_CANCEL_CAUSE, ...pendingMessagesOf(session, unsent) } : {},
+          ...termination === PARENT_CANCEL_CAUSE && !this.killedChildren.has(admitted.identity.path) ? {
+            cause: PARENT_CANCEL_CAUSE,
+            ...pendingMessagesOf(session, unsent, admitted.spec.resumeTaskLiteral)
+          } : {},
           stats,
           path: admitted.identity.path,
           envelope: this.killedChildren.has(admitted.identity.path) ? "Killed. This child cannot be resumed." : envelope,
@@ -13398,7 +13432,7 @@ class SubagentControlRuntime {
         };
       return {
         status,
-        cause: termination ?? "agent session ended without a successful completion",
+        cause: noOutput ?? termination ?? "agent session ended without a successful completion",
         stats,
         path: admitted.identity.path,
         envelope,
@@ -13419,10 +13453,13 @@ class SubagentControlRuntime {
       if (status === "interrupted")
         return {
           status: this.killedChildren.has(admitted.identity.path) ? "killed" : status,
-          ...termination === PARENT_CANCEL_CAUSE && !this.killedChildren.has(admitted.identity.path) ? { cause: PARENT_CANCEL_CAUSE, ...pendingMessagesOf(session, unsent) } : {},
+          ...termination === PARENT_CANCEL_CAUSE && !this.killedChildren.has(admitted.identity.path) ? {
+            cause: PARENT_CANCEL_CAUSE,
+            ...pendingMessagesOf(session, unsent, admitted.spec.resumeTaskLiteral)
+          } : {},
           stats,
           path: admitted.identity.path,
-          envelope: termination === PARENT_CANCEL_CAUSE && !this.killedChildren.has(admitted.identity.path) ? cancelledEnvelope(session, admitted.spec, stats) : this.killedChildren.has(admitted.identity.path) ? "Killed. This child cannot be resumed." : INTERRUPTED_ENVELOPE,
+          envelope: termination === PARENT_CANCEL_CAUSE && !this.killedChildren.has(admitted.identity.path) ? cancelledEnvelope(session, admitted.spec, stats, ownMessages()) : this.killedChildren.has(admitted.identity.path) ? "Killed. This child cannot be resumed." : INTERRUPTED_ENVELOPE,
           sessionFile: session?.sessionFile,
           ...effectiveModelId === undefined ? {} : { model: effectiveModelId },
           ...effectiveThinking === undefined ? {} : { thinking: effectiveThinking },
@@ -13893,7 +13930,10 @@ function resultFromOutcome(agent, task, outcome, startedAt, artifactPaths) {
     path: outcome.path,
     envelope: outcome.status === "killed" ? output : outcome.envelope,
     interrupted: status === "interrupted" ? true : undefined,
-    ...outcome.status === "interrupted" && outcome.pendingMessages ? { pendingMessages: outcome.pendingMessages } : {},
+    ...outcome.status === "interrupted" && outcome.pendingMessages ? {
+      pendingMessages: outcome.pendingMessages,
+      ...outcome.pendingTaskExpands ? { pendingTaskExpands: true } : {}
+    } : {},
     messages: [],
     usage: usageFromStats(outcome.stats),
     ...model === undefined ? {} : { model },
@@ -14007,6 +14047,7 @@ ${task}`);
     sessionManager: options.sessionManager,
     ...options.resumeSession ? { resumeSession: true } : {},
     ...options.resumeFollowUps?.length ? { resumeFollowUps: options.resumeFollowUps } : {},
+    ...options.resumeTaskLiteral ? { resumeTaskLiteral: true } : {},
     ...options.onChildSession ? { onChildSession: options.onChildSession } : {},
     ...options.onChildLaunch ? { onChildLaunch: options.onChildLaunch } : {},
     ...options.progressPath ? { progressPath: options.progressPath } : {},
@@ -14131,6 +14172,8 @@ ${task}`);
       }
       persistRequestedOutput(recovered, options, outputSnapshot);
       options.onDetachedExit?.(recovered);
+    }).catch((error) => {
+      console.error("atomic-subagents: detached child exit handling failed", error);
     });
     const continuedModel = running.currentModel ?? candidate;
     const continuedThinking = running.currentThinking;
@@ -14869,15 +14912,23 @@ function resumedPrompts(record, resume) {
     resume?.continuation,
     resume?.message ? undefined : prompt
   ]);
-  const held = record.heldMessages && record.heldMessages.taskId === record.taskId ? record.heldMessages.messages.filter((message) => !continuations.has(message)) : [];
+  const recorded = record.heldMessages && record.heldMessages.taskId === record.taskId ? record.heldMessages : undefined;
+  const held = recorded ? recorded.messages.filter((message) => !continuations.has(message)) : [];
+  const taskExpands = recorded !== undefined && heldTaskExpands(recorded) && held.length > 0 && held[0] === recorded.messages[0];
   const [task = prompt, ...followUps] = [...held, prompt, ...resume?.continuation ? [resume.continuation] : []];
-  return { task, followUps };
+  return { task, followUps, taskLiteral: !taskExpands };
 }
 function freshPrompts(record, launch, resume) {
-  const held = record.heldMessages && record.heldMessages.taskId === record.taskId ? record.heldMessages.messages : [];
-  return { task: resume?.message ? `${launch.task}
+  const recorded = record.heldMessages && record.heldMessages.taskId === record.taskId ? record.heldMessages : undefined;
+  const held = recorded?.messages ?? [];
+  const heldTask = recorded !== undefined && held[0] === launch.task && heldTaskExpands(recorded);
+  return {
+    task: resume?.message ? `${launch.task}
 
-${resume.message}` : launch.task, followUps: held };
+${resume.message}` : launch.task,
+    followUps: heldTask ? held.slice(1) : held,
+    taskLiteral: false
+  };
 }
 function rediscoverAgent(deps, cwd, name, source) {
   const scopes = source ? ["both", "user", "project"] : [resolveExecutionAgentScope(undefined)];
@@ -14901,7 +14952,7 @@ async function relaunchChild(deps, ctx, record, hold, release, onReopened, resum
   const host = ctx.getAgentTaskHost?.();
   const queued = record.taskId && host ? takeStoppedQueuedSubagentChild(record.taskId) : undefined;
   if (queued && host)
-    return startQueuedChild(deps, ctx, host, record, queued, hold, release, resume);
+    return startedFresh(await startQueuedChild(deps, ctx, host, record, queued, hold, release, resume));
   const queuedOwnerless = record.taskId && !host ? takeStoppedQueuedOwnerlessChild(record.taskId) : undefined;
   const ownerSignal = host ? undefined : ctx.getCurrentSessionSignal?.() ?? ctx.sessionSignal;
   if (queuedOwnerless) {
@@ -14915,7 +14966,7 @@ async function relaunchChild(deps, ctx, record, hold, release, onReopened, resum
       ...resume?.message ? { message: resume.message } : {},
       ...supervisorAuthorization ? { supervisorAuthorization } : {}
     });
-    return ownerlessRelaunched(deps, record, launched, recordChild, release, hold, supervisorAuthorization, ctx);
+    return startedFresh(await ownerlessRelaunched(deps, record, launched, recordChild, release, hold, supervisorAuthorization, ctx));
   }
   if (!existsSync15(record.cwd))
     return unrestorable(`its working directory no longer exists: ${record.cwd}`);
@@ -14970,7 +15021,7 @@ async function relaunchChild(deps, ctx, record, hold, release, onReopened, resum
   const prompts = fresh ? freshPrompts(record, fresh, resume) : resumedPrompts(record, resume);
   const options = {
     runningCapacity: deps.config.parallel?.runningCapacity,
-    getChildSessionOptions: ctx.getChildSessionOptions,
+    getChildSessionOptions: ctx.getChildSessionOptionsResolver?.() ?? ctx.getChildSessionOptions,
     resourceLoaderInheritanceSnapshot: deps.pi.getResourceLoaderInheritanceSnapshot?.(),
     cwd: record.cwd,
     runId: record.runId,
@@ -14983,6 +15034,7 @@ async function relaunchChild(deps, ctx, record, hold, release, onReopened, resum
     ...fresh?.maxOutput ? { maxOutput: fresh.maxOutput } : {},
     ...fresh?.share === undefined ? {} : { share: fresh.share },
     ...prompts.followUps.length > 0 ? { resumeFollowUps: prompts.followUps } : {},
+    ...prompts.taskLiteral ? { resumeTaskLiteral: true } : {},
     intercomEvents: deps.pi.events,
     parentDepth: getCurrentSubagentDepth(ctx),
     workflowStageSubagentGuard: isWorkflowStageOrchestrationContext(ctx),
@@ -15004,6 +15056,7 @@ async function relaunchChild(deps, ctx, record, hold, release, onReopened, resum
   const runtime = resolveSubagentExecutorRuntimeDeps(deps.runtime);
   const schedule = subagentChildSchedule(record.runId, record.index);
   if (!host) {
+    const launchCwd = ctx.cwd;
     const launched = runOwnerlessChild({
       agent: agent.name,
       agentSource: agent.source,
@@ -15014,9 +15067,10 @@ async function relaunchChild(deps, ctx, record, hold, release, onReopened, resum
       ...ownerSignal ? { ownerSignal } : {},
       recordChild,
       ...schedule ? { schedule } : {},
-      runSync: (task, childOptions) => runtime.runSync(ctx.cwd, [agent], agent.name, task, childOptions)
+      runSync: (task, childOptions) => runtime.runSync(launchCwd, [agent], agent.name, task, childOptions)
     });
-    return ownerlessRelaunched(deps, record, launched, recordChild, release, hold, supervisorAuthorization, ctx);
+    const outcome = await ownerlessRelaunched(deps, record, launched, recordChild, release, hold, supervisorAuthorization, ctx);
+    return fresh ? startedFresh(outcome) : outcome;
   }
   const response = await runAgentTask({
     host,
@@ -15037,7 +15091,11 @@ async function relaunchChild(deps, ctx, record, hold, release, onReopened, resum
       hold?.release();
     }
   });
-  return relaunched(deps, record, response, recordChild, release, supervisorAuthorization, intercomGroup);
+  const outcome = await relaunched(deps, record, response, recordChild, release, supervisorAuthorization, intercomGroup);
+  return fresh ? startedFresh(outcome) : outcome;
+}
+function startedFresh(outcome) {
+  return outcome.kind === "restored" ? { ...outcome, fresh: true } : outcome;
 }
 async function startQueuedChild(deps, ctx, host, record, queued, hold, release, resume) {
   const supervisorAuthorization = queued.usesIntercom ? hold?.authorization : undefined;
@@ -15243,12 +15301,13 @@ function subagentChildRestoreNotices(outcomes) {
         `${childLabel(outcome.record, outcome.childId)} did not survive the restart and could not be restored: ${outcome.reason}. It is gone: do not send it Intercom messages or wait for its result. Launch a fresh subagent if its work is still needed.`
       ];
     const label = childLabel(outcome.record, outcome.record.childId);
+    const how = outcome.fresh ? "started fresh with its task, since it had not started before the restart," : "relaunched from its own session";
     if (outcome.intercomLive === false)
       return [
-        `${label} was relaunched from its own session as task ${outcome.taskId}, but it did not reconnect to Intercom. Treat it as unreachable until it reconnects; its result will still arrive as a task completion.`
+        `${label} was ${how} as task ${outcome.taskId}, but it did not reconnect to Intercom. Treat it as unreachable until it reconnects; its result will still arrive as a task completion.`
       ];
     return [
-      `${label} was interrupted by the restart and has been relaunched from its own session as task ${outcome.taskId}${outcome.intercomLive ? "; it is live on Intercom under the same name" : ""}.`
+      `${label} was interrupted by the restart and has been ${how} as task ${outcome.taskId}${outcome.intercomLive ? "; it is live on Intercom under the same name" : ""}.`
     ];
   });
 }
@@ -16485,6 +16544,26 @@ class SubagentForkContextError extends Error {
 function resolveSubagentContext(value) {
   return value === "fork" ? "fork" : "fresh";
 }
+function settledForkLeaf(branch, leafId) {
+  const answered = new Set;
+  for (let index = branch.length - 1;index >= 0; index--) {
+    const entry = branch[index];
+    if (entry.type !== "message")
+      continue;
+    const message = entry.message;
+    if (message.role === "toolResult") {
+      answered.add(message.toolCallId);
+      continue;
+    }
+    if (message.role === "user")
+      return leafId;
+    if (message.role !== "assistant")
+      continue;
+    const inFlight = message.content.some((block) => block.type === "toolCall" && !answered.has(block.id));
+    return inFlight ? entry.parentId : leafId;
+  }
+  return leafId;
+}
 function createForkContextResolver(sessionManager, requestedContext) {
   if (resolveSubagentContext(requestedContext) !== "fork") {
     return { sessionManagerForIndex: async () => {
@@ -16494,7 +16573,10 @@ function createForkContextResolver(sessionManager, requestedContext) {
   const parentSessionId = sessionManager.getSessionId();
   const store = sessionManager.getSessionStore();
   const cwd = sessionManager.getCwd();
-  const leafId = sessionManager.getLeafId();
+  const parentLeafId = sessionManager.getLeafId();
+  if (parentLeafId === null)
+    throw new SubagentForkContextError(parentSessionId, "no_leaf");
+  const leafId = settledForkLeaf(sessionManager.getBranch(), parentLeafId);
   if (leafId === null)
     throw new SubagentForkContextError(parentSessionId, "no_leaf");
   const children = new Map;
@@ -16724,13 +16806,15 @@ async function routeSubagentModel(input) {
     signal: input.signal,
     selection: route.routerSelection
   });
+  const { modelRegistry } = ctx;
+  const launchProvider = ctx.model?.provider;
   return {
     ...route,
     allowsModel: fallbackRoute.allowsModel,
     allowsCandidate: (candidate, defaultEffort) => {
-      const normalized = resolveModelCandidate(candidate, ctx.modelRegistry.getAvailable().map(toModelInfo), ctx.model?.provider);
+      const normalized = resolveModelCandidate(candidate, modelRegistry.getAvailable().map(toModelInfo), launchProvider);
       const { baseModel, thinkingSuffix } = splitKnownThinkingSuffix(normalized);
-      const model = ctx.modelRegistry.getAvailable().find((m) => `${m.provider}/${m.id}` === baseModel);
+      const model = modelRegistry.getAvailable().find((m) => `${m.provider}/${m.id}` === baseModel);
       return model !== undefined && fallbackRoute.allowsModel(model, thinkingSuffix.slice(1) || defaultEffort);
     }
   };
@@ -16892,11 +16976,12 @@ async function runParallelPath(data, deps) {
         taskTexts[i] = wrapForkTask(taskTexts[i]);
       }
     }
+    const detachedNotificationScope = { orchestrationContext: ctx.orchestrationContext };
     const results = await runForegroundParallelTasks({
       wait: params.wait,
       schedule: params[BURST_EXECUTION_SCHEDULE],
       onDetachedExit: (index, result) => {
-        if (workflowStageAcceptsDetachedNotification(ctx)) {
+        if (workflowStageAcceptsDetachedNotification(detachedNotificationScope)) {
           notifyDetachedForegroundChildExit({
             pi: deps.pi,
             runId,
@@ -17173,12 +17258,13 @@ async function runSinglePath(data, deps) {
     };
   }
   const forwardSingleUpdate = createForwardSingleUpdate(onUpdate, foregroundControl, params.agent, 0);
+  const detachedNotificationScope = { orchestrationContext: ctx.orchestrationContext };
   let r;
   try {
     const supervisorAuthorization = await requestSupervisorAuthorization(deps.pi.events, childIntercomTarget, ctx.getChildSessionOptions?.({ tools: agentConfig.tools }));
     const runOptions = {
       runningCapacity: deps.config.parallel?.runningCapacity,
-      getChildSessionOptions: ctx.getChildSessionOptions,
+      getChildSessionOptions: ctx.getChildSessionOptionsResolver?.() ?? ctx.getChildSessionOptions,
       resourceLoaderInheritanceSnapshot: deps.pi.getResourceLoaderInheritanceSnapshot?.(),
       cwd: effectiveCwd,
       signal,
@@ -17214,7 +17300,7 @@ async function runSinglePath(data, deps) {
       },
       onDetachedExit: (result) => {
         cleanupTransientProgress(progressDir, artifactConfig.enabled);
-        if (result && workflowStageAcceptsDetachedNotification(ctx)) {
+        if (result && workflowStageAcceptsDetachedNotification(detachedNotificationScope)) {
           notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "single", index: 0, result });
         }
       },
@@ -17259,6 +17345,7 @@ async function runSinglePath(data, deps) {
         return await taskToolResultWithOutput(response, ctx.getAgentTaskHost());
       r = settledChild;
     } else {
+      const launchCwd = ctx.cwd;
       r = await runOwnerlessChild({
         agent: params.agent,
         agentSource: agentConfig.source,
@@ -17267,7 +17354,7 @@ async function runSinglePath(data, deps) {
         options: runOptions,
         recordChild: createSubagentChildRecordSink(deps.pi, ctx),
         ...params[BURST_EXECUTION_SCHEDULE] ? { schedule: params[BURST_EXECUTION_SCHEDULE] } : {},
-        runSync: (childTask, options) => deps.runtime.runSync(ctx.cwd, agents, params.agent, childTask, options)
+        runSync: (childTask, options) => deps.runtime.runSync(launchCwd, agents, params.agent, childTask, options)
       }).result;
     }
   } catch (error) {
@@ -17604,7 +17691,16 @@ async function resumeChild(deps, ctx, request) {
   if (outcome.kind === "unrestorable")
     return errorResult(action, `${label(record)} could not be resumed: ${outcome.reason}.`);
   const intercom = outcome.intercomLive === true ? " It is live on Intercom under the same name." : outcome.intercomLive === false ? " It has not reconnected to Intercom yet; its result still arrives as a task completion." : "";
-  const held = record.heldMessages?.taskId === record.taskId ? " The messages it had queued and not yet read when it stopped are delivered first, once." : "";
+  const heldMessages = record.heldMessages && record.heldMessages.taskId === record.taskId ? record.heldMessages.messages : [];
+  if (outcome.fresh) {
+    const sent = heldMessages[0] === record.launch?.task ? heldMessages.slice(1) : heldMessages;
+    return controlResult(`Started ${label(record)} fresh with its task as task ${outcome.taskId}, since it stopped before it began${message ? ", with your message added to its task" : ""}.${sent.length > 0 ? " The messages it was sent and had not yet read are delivered after its task, once." : ""}${intercom}`, {
+      action,
+      children: [childDetails(record, "running", outcome.taskId)],
+      ...message ? { message } : {}
+    });
+  }
+  const held = heldMessages.length > 0 ? " The messages it had queued and not yet read when it stopped are delivered first, once." : "";
   return controlResult(`Resumed ${label(record)} from its own session as task ${outcome.taskId}${message ? interrupted ? ", with your message delivered before it continues its interrupted turn" : ", with your message as its new prompt" : ""}.${held}${intercom}`, {
     action,
     children: [childDetails(record, "running", outcome.taskId)],

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.45-alpha.1",
+  "version": "0.9.46-alpha.1",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,51 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.46-alpha.1] - 2026-10-27
+
+### Added
+
+- `RunResult.failure` (type `RunFailureClassification`, exported from `@bastani/atomic/workflows`) describes how a failed or blocked run's failure was classified: `kind`, `code`, `retryable`, `resumable`, `recoverability`, `disposition` and `retryAfterMs`. It is absent for runs that did not fail and for results recorded by earlier releases ([#4031](https://github.com/bastani-inc/atomic/issues/4031))
+- Opening a running stage that runs on a local worker (`workflows.localWorkers`) from the workflow graph or `/workflow attach` now shows its live chat: the transcript so far, the reply as it streams, and tool calls, with `on local worker` in the chat header. It no longer shows "Post-mortem chat is available only after the stage completes". Only stages you have open stream to the root, so pools with many workers send nothing extra for stages nobody watches. ([#3996](https://github.com/bastani-inc/atomic/issues/3996))
+- Enter (steer) and Ctrl+F (follow-up) in the chat of a stage that runs on a local worker now reach that stage and report the same delivery as an in-process stage. Each message is admitted at most once, even when a reply is lost and the send is retried. The stage's graph node shows `✉ N queued` with no chat open. SDK runs with `localWorkers` now accept `stageControlRegistry`, whose handles for pooled stages steer, queue follow-ups and stream events the same way ([#3996](https://github.com/bastani-inc/atomic/issues/3996))
+- A single stage on a local worker can now be paused and resumed (`/workflow pause <run> <stage>`, stage chat, `session.workflows.pause/resume` with `stageId`) without pausing the pool; it keeps its worker's lease while paused. When the worker running an open stage dies or its attempt is fenced, the chat shows `RECONNECTING`, reattaches to the replacement attempt, and redelivers once each, in send order and in their original mode (a steer still steers), the messages the replacement does not have ([#3996](https://github.com/bastani-inc/atomic/issues/3996))
+- Children on local workers can now ask for input. Their `ctx.ui` prompts show on their stage and are answered from the stage chat or the workflow tool's `answer` action, and a stage's `ask_user_question` shows its form in the stage chat as for an in-process stage; each answer reaches only the prompt it names on the worker's current attempt. Previously `ctx.ui` in a pooled child failed the child. SDK runs with `localWorkers` now accept `ui`, which answers those prompts (a rejecting `ui` fails the child with its error), and `stageUiBroker`, which receives the stages' `ask_user_question` forms (a broker that rejects a form fails that question in the stage with its error). `ctx.ui.custom` in a pooled child fails it with an error naming the limitation. When a worker dies, the replacement asks again a `ctx.ui` prompt that was still pending, and does not ask again one already answered. A stage's `ask_user_question` still waiting when its worker dies (or when a durable run resumes a stage) shows its form again on the replacement, and the answer becomes that call's result; previously the call was reported to the model as interrupted and the stage could finish without the answer ([#3996](https://github.com/bastani-inc/atomic/issues/3996))
+- Added a GPT-6.1 Terra reference to the prompt-engineering skill, based on OpenAI's updated GPT-6 guide, covering when to choose Terra, effort selection, migration from GPT-5.6 Terra, computer-use and writing prompts, and selective use of the shared templates observed on Astra.
+
+### Fixed
+
+- Starting a large local worker pool (`workflows.localWorkers`) no longer freezes the root's input and rendering for hundreds of milliseconds while the workers start. When a workflow starts many pooled children at once, such as `Promise.all` over 150 `ctx.workflow` calls, their journal work used to run back to back in one turn of the event loop, and each child's dispatch listed and sorted every checkpoint of the root. While many journal operations are queued, journal work now gives the event loop a turn after 8 ms, checked before each operation, and a child's dispatch looks up only its own boundary. When those children finish at once, completing each one no longer reads every checkpoint of the root, and the sweep for undeliverable stage messages checks run ownership only for runs that have messages to settle, and children finishing together complete in turns of the event loop instead of all at once
+- An Intercom send to a workflow path pattern that matches a live or pending stage, such as `workflow:<run>/**/work-2` for a stage in a child on a local worker, no longer reports `notInKnownSet` ("not in the workflow's known stage set"). The message was delivered, but the known set came only from the launch-time scan of the workflow source, which cannot see stages of children loaded with `loadWorkerWorkflow`. Stages that already exist and can receive messages now count as known; a target that matches neither the scan nor any such stage still gets the warning.
+- Large pooled fan-outs no longer stall the root's main thread when the workflow graph or a stage chat is open: typing in a stage chat during dispatch, wave turnover and run end of 150+ local workers stayed responsive only with nothing attached. Each store change used to re-project, re-freeze, re-expand and re-serialize every run of the root for the graph snapshot, the graph view, the attach pane, the workflow activity bridge and the BACKGROUND widget. Unchanged runs and stages now keep their frozen graph projections and expansions, the graph view and attach pane catch up once before they render or handle input, an open stage chat projects only its own run, the activity bridge publishes each root's final activity once per turn of the event loop (reading published activity, a root run's own lifecycle event and `waitForSettled` always see it first), store-driven widget refreshes spend at most 8 ms per 50 ms after the first four, and the coordinator gets the root's boundaries once per turn instead of once per enqueue and published batch. A pooled child whose worker was replaced also keeps its last known stages, marked `reconnecting`, until the replacement republishes them, instead of briefly showing no stages ([#4009](https://github.com/bastani-inc/atomic/issues/4009))
+- Stages on local workers (`workflows.localWorkers`) now share provider rate limits. When one worker's stage gets an HTTP 429 or an exhausted quota (HTTP 402), the other workers and the root apply the same cooldown or unavailable mark, with the same provider or model scope and the same `Retry-After` end. They hold requests to that provider or model back, or move their fallback walk past it, instead of each sending requests until it gets its own 429. A worker that starts later gets the limits still running. Limits are sent only when a request is rate limited, at most once per provider or model every 250 ms ([#4023](https://github.com/bastani-inc/atomic/issues/4023))
+- Text typed into a stage chat reaches the stage the same way whether the stage is idle, streaming, or still preparing its turn. Only `/skill:` commands expand. Before, Enter or Ctrl+F while the stage was busy expanded prompt templates such as `/review` and ran registered extension commands, or refused them, while the same text sent to an idle stage arrived as typed
+- A message given when resuming a stage that was paused in the middle of its workflow prompt is now delivered as typed, as it is when resuming an idle stage chat. It used to go through the stage prompt's own options, which expand prompt templates and run registered extension commands
+- A failed child workflow (`ctx.workflow`), or a failed stage, no longer has its failure classified from workflow or stage names. Before, a name containing words such as `rate-limit`, `overloaded` or `quota` could turn an ordinary failure, such as a tool that throws `ENOENT`, into a resumable rate limit or provider outage. The root then stayed `running`, blocked for a resume that could not help, and `run()` returned status `running` with the error. A parent now classifies a failed child from the child's own classification (`RunResult.failure`), at any nesting depth, for in-process children and children on local workers, including a child result a resumed root reads back from the journal. A stage's model-resolution failure is classified from the routing error it wraps. A child that really fails on a rate limit still blocks the root resumably. Error messages are unchanged ([#4031](https://github.com/bastani-inc/atomic/issues/4031))
+- A stage whose model hits an exhausted quota (HTTP 402) or a rate limit that resets beyond the retry-delay cap now moves straight to the next fallback model, without spending retries or cooldown-wait rounds on it. A model-specific rate limit no longer delays a fallback on the same provider, and an HTTP 529 overload waits for its `Retry-After` like a 503 ([#3984](https://github.com/bastani-inc/atomic/issues/3984))
+- A stage whose whole model and fallback chain returns HTTP 429 now waits for the earliest recorded provider cooldown and retries, instead of failing after one attempt per model. The wait is bounded: at most `retry.maxRetries` extra rounds per prompt, and only when the earliest cooldown fits the retry-delay cap (`retry.provider.maxRetryDelayMs`, else `retry.maxAgentDelayMs`, else 60 s). A persistent 429 still fails the stage once those rounds are spent ([#3984](https://github.com/bastani-inc/atomic/issues/3984))
+- A workflow run whose stage replaced its session through model fallback no longer fails with `This extension ctx is stale after session replacement` and hides the stage's real error (such as a rate limit). An unhandled stale extension-context rejection no longer fails the run. It is logged to stderr with its stack and the run id, so the code that kept the retired session's context can be found ([#3981](https://github.com/bastani-inc/atomic/issues/3981))
+- Disposing an SDK session right after a workflow run reports `completed`, without awaiting `session.workflows.waitForSettled(runId)`, no longer prints one `atomic-workflows: released stage listener failed Error: SessionClosed` warning per stage ([#3966](https://github.com/bastani-inc/atomic/issues/3966))
+- A workflow stage that has sent its first prompt no longer reads `startup first-dispatch (0s total, 0s on current step; dispatched)` in the workflow tool's `stages` and `stage` output, which looked like a stalled stage for the whole run. The line now reads `startup complete (dispatched after 2s)` ([#3967](https://github.com/bastani-inc/atomic/issues/3967))
+- A local-worker pool no longer fails every in-flight child with `Local worker process cleanup unconfirmed; permits quarantined` when one worker exits while its tool process groups are still running. The coordinator now reaps that worker's orphaned process groups (SIGTERM, then SIGKILL, with a bounded wait), holds the child's work lease so no other worker can claim it meanwhile, releases the permits of groups that are gone or hold only zombies, and replays only that worker's child on a replacement. If a group is still alive when the bound expires, only that child fails, with a retryable `WorkflowInfrastructureError` (`worker_cleanup_unconfirmed`) that names the process groups; their permits stay quarantined and the child is not replayed alongside them, also not by recovery after a stalled worker is stopped or by a durable resume (both read the quarantine from the journal), and closing the pool reports those groups. A durable resume reaps such an attempt's groups with the same bounded sequence, then replays it in the resumed root or fails only that child ([#3986](https://github.com/bastani-inc/atomic/issues/3986))
+- A direct Intercom send to a live stage in a local worker pool no longer routinely fails with `The recipient did not confirm that it saved the message in time` while the pool is busy. Saving a message to a pooled stage's session no longer waits for the worker to re-read the root workflow's journal or for a usage-total transaction; it is confirmed once the coordinator has committed it ([#3983](https://github.com/bastani-inc/atomic/issues/3983))
+- Resuming a quit or crashed root whose children run in `workflows.localWorkers` no longer fails in-flight children with `Session not found`. Resume used to make the previous run's pooled children claimable before the resumed root had enqueued them again, so workers crashed on `Stale work lease`, the pool failed with `Local worker retry limit`, and later children ran in the root process, which cannot see pooled stage sessions. A pooled child is now claimed only after the resumed root enqueues it, a child started after the pool has failed gets the pool's error instead of running in the root process, the three-attempt retry limit counts only crashes within one run of the root (a child resumed many times keeps its full budget), and a worker whose attempt was handed to another worker ends that attempt and serves new work instead of crashing and using up a retry ([#3979](https://github.com/bastani-inc/atomic/issues/3979))
+- Large local worker pools no longer lose child workflows to `database is locked … gave up after waiting 30000 ms for the write lock` after a few hours. Resource admission reconciliation, which every pooled worker runs before it starts a command, read the whole resource permit history twice for every live worker while it held the journal's write lock. With 160 workers and tens of thousands of permits, each pass held the lock for nearly a second. Reconciliation now uses indexes, keeps only the most recent 256 released permits, and takes the write lock only when it has a permit to fence or prune ([#3978](https://github.com/bastani-inc/atomic/issues/3978))
+- Workflow runs and local worker definitions load again after something such as a `/tmp` cleanup deletes the `jiti` transpile cache directory, instead of failing with `ENOENT: no such file or directory, open '/tmp/jiti/workflows-<name>.<hash>.cjs'` until Atomic restarts ([#3985](https://github.com/bastani-inc/atomic/issues/3985))
+- A sticky Intercom send to a workflow pattern target (for example `workflow:<rootRunId>/**`) no longer fails newly starting pooled stages with `Extension startup failed: … pending-stage message <id> changed during delivery`. A stage drain whose transcript snapshot was taken before a slow session append finished used to deliver the already-receipted message again and then fail. The drain now treats an existing delivery receipt for that stage and session as success, so the message reaches each stage exactly once ([#3980](https://github.com/bastani-inc/atomic/issues/3980))
+- A workflow that starts many child workflows at once, such as `Promise.all` over 150 `ctx.workflow` calls, no longer stalls the root session's input and rendering while the children start. Each workflow store change used to re-read every run and stage to detect lifecycle transitions, so a fan-out's cost grew with the square of its width; only the run, stage or tool node that changed is now re-read. Lifecycle events are unchanged
+- A finished stage that ran on a local worker now reopens for post-mortem chat. It used to report `The retained session is missing, unreadable, or invalid` in the same session and SESSION UNAVAILABLE after a restart, because its session lives in the workflow journal rather than the host's session store ([#3996](https://github.com/bastani-inc/atomic/issues/3996))
+- A workflow heartbeat no longer goes missing when its wake-up timer fires a moment early. The early wake-up found nothing due and rescheduled, and if the boundary passed while that pass was running, the heartbeat moved to the following interval instead of being sent. The scheduler now reads the clock once per pass, so a boundary that comes due during it is still delivered
+- An idle local worker that meets its root's released lease (between the root's teardown and the pool's close) now ends cleanly instead of crashing, and the pool no longer spawns replacements that crash the same way ([#3979](https://github.com/bastani-inc/atomic/issues/3979))
+- A stage chat open on a `ctx.ui` prompt or `ask_user_question` form of a stage on a local worker (`workflows.localWorkers`) now takes the answer after that worker dies: it shows the prompt the replacement worker asks again and delivers your answer to it once. Before, the open chat kept a prompt that dropped typed text and ignored Enter until you closed and reopened the stage. An answer you submit after the worker died but before the replacement asks again is now kept and given to the replacement's identical prompt instead of being lost, so you are not asked twice. The re-asked `ask_user_question` form no longer shows "Tool execution was interrupted after it started…" above it. A replacement worker whose child asks a different `ctx.ui` question at the same point (its text depends on data) no longer fails the child with `Pool topology scope: direct child source orders are not unique`: the unanswered question of the dead worker is replaced, an open stage chat moves to the new question, and an answer held for the old question is discarded. A child that really takes different steps when it runs again now fails with an error that says so in plain words. The forms of `ask_user_question` and the readiness gate are now built by one helper for in-process and local-worker stages, so they cannot drift apart ([#4022](https://github.com/bastani-inc/atomic/issues/4022))
+- A child on a local worker that loses its worker three times now fails alone with a retryable `WorkflowInfrastructureError` (`worker_retry_limit`) that names its child run and definition export, as #3986 already did for a child whose processes survive cleanup. Before, it failed the whole pool within milliseconds: every other child, including one waiting on a prompt whose worker was never touched, was rejected with `Local worker retry limit`. The same applies to a child whose every attempt the root refused as stale. The failed child, its nested runs and their unfinished stages show failed with its error, so the graph counts none of them as active. Workers that keep crashing without work, worker startup failures and a coordinator that dies still fail the pool. When a pool closes without a quit, the root's unfinished work rows end `failed` instead of staying `ready` or `leased`; quarantined attempts keep their leases, and a resumed root replays failed work it enqueues again ([#3996](https://github.com/bastani-inc/atomic/issues/3996))
+- The post-mortem chat of a completed or failed stage that ran on a local worker no longer shows `on local worker` in its header. Post-mortem chat runs in the root, so the header now matches an in-process stage's ([#3996](https://github.com/bastani-inc/atomic/issues/3996))
+
+## [0.9.45] - 2026-10-25
+
+### Fixed
+
+- A large local worker pool no longer fails at startup with `Local worker startup timed out after 30000 ms` on a small or busy machine. When `localWorkers.startupTimeoutMs` is not set, the readiness deadline now scales with the number of workers and the 1-minute load average per CPU core, from 30000 ms up to 600000 ms; on an idle machine with spare cores it stays 30000 ms. If workers still miss the deadline, the error now says they were too slow to start and names `workflows.localWorkers.startupTimeoutMs` ([#3962](https://github.com/bastani-inc/atomic/issues/3962))
+
 ## [0.9.45-alpha.1] - 2026-10-25
 
 ### Added

package/dist/builtin/workflows/builtin/{chunk-6901nsd6.js → chunk-6jpwc09k.js}

@@ -39,7 +39,7 @@ import {
   reviewerFailureText,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-jvna28mq.js";
+} from "./chunk-zhyqnf5g.js";
 import {
   fold_usage
 } from "./chunk-tgt0s5e5.js";