@bastani/atomic 0.9.45 → 0.9.46

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;
@@ -14823,7 +14866,7 @@ async function maybeBuildForegroundIntercomReceipt(input) {
 }
 
 // dist/builtin/subagents/src/runs/foreground/subagent-child-restore.ts
-var SUBAGENT_RESUME_CONTINUATION_PROMPT = "Atomic restarted while you were working, and your session has been restored. Continue where you left off. If you believe you are finished with your original task, stop.";
+var SUBAGENT_RESUME_CONTINUATION_PROMPT = "Atomic restarted while you were working, and your session has been restored. Continue where you left off. If the restart interrupted a command or step you were running, redo or continue that step as needed. If you believe you are finished with your original task, stop.";
 var SUBAGENT_AWAIT_INTERCOM_PEER_EVENT = "subagent:await-intercom-peer";
 var SUBAGENT_INTERCOM_PEER_TIMEOUT_MS = 15000;
 var SUBAGENT_AWAIT_CHILD_RESTORATION_EVENT = "subagent:await-child-restoration";
@@ -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) {
@@ -17397,7 +17484,7 @@ async function runSinglePath(data, deps) {
 }
 
 // dist/builtin/subagents/src/runs/foreground/subagent-run-control.ts
-var SUBAGENT_RUN_CONTROL_CONTINUATION_PROMPT = "Continue where you left off. If you believe you are finished with your original task (or a redefined task if the user told you), stop.";
+var SUBAGENT_RUN_CONTROL_CONTINUATION_PROMPT = "Continue where you left off. If a pause interrupted a command or step you were running, redo or continue that step as needed. If you believe you are finished with your original task (or a redefined task if the user told you), stop.";
 var NON_RESUMABLE_STATUSES = new Map([
   ["killed", "it was cancelled for good (an owner or batch cancellation, or the removed kill action)"],
   [
@@ -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",
+  "version": "0.9.46",
   "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": [