@bastani/atomic 0.9.18-alpha.5 → 0.9.18-alpha.7

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

@@ -7768,14 +7768,12 @@ function splitKnownThinkingSuffix(model) {
 function formatTokens(n) {
   return n < 1000 ? String(n) : n < 1e4 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
 }
-function formatModelThinking(model, thinking, fastMode) {
+function formatModelThinking(model, thinking) {
   const parsed = model ? splitKnownThinkingSuffix(model) : undefined;
   const displayModel = parsed?.baseModel ?? model;
   const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
   const displayThinking = parsed?.thinkingSuffix ? parsed.thinkingSuffix.slice(1) : explicitThinking;
   const parts = [displayModel, displayThinking ? `thinking ${displayThinking}` : undefined].filter(Boolean);
-  if (fastMode && parts.length > 0)
-    parts.push("fast");
   return parts.join(" · ");
 }
 function formatUsage(u) {
@@ -10021,9 +10019,8 @@ import {
   DefaultResourceLoader,
   getAgentDir as getAgentDir2,
   getBuiltinPackagePaths as getBuiltinPackagePaths2,
-  readStoredCredential,
   SessionManager,
-  SettingsManager as SettingsManager2
+  SettingsManager
 } from "@bastani/atomic";
 import {
   SubagentControl
@@ -10253,59 +10250,6 @@ function cleanupAllArtifactDirs(maxAgeDays, sessionsRoots) {
   }
 }
 
-// dist/builtin/subagents/src/shared/fast-mode.ts
-import {
-  SettingsManager,
-  shouldApplyCodexFastModeForScope
-} from "@bastani/atomic";
-function getSubagentCodexFastModeSettings(cwd) {
-  try {
-    return SettingsManager.create(cwd).getCodexFastModeSettings();
-  } catch {
-    return { chat: false, workflow: false };
-  }
-}
-function modelIdentityFromModelId(model) {
-  if (!model)
-    return;
-  const { baseModel } = splitKnownThinkingSuffix(model);
-  const slash = baseModel.indexOf("/");
-  if (slash <= 0 || slash === baseModel.length - 1)
-    return;
-  return { provider: baseModel.slice(0, slash), id: baseModel.slice(slash + 1) };
-}
-function resolvedIdentityMatches(resolved, model) {
-  if (!model)
-    return true;
-  const parsed = modelIdentityFromModelId(model);
-  if (!parsed)
-    return false;
-  if (parsed.provider !== resolved.provider)
-    return false;
-  return resolved.id === undefined || parsed.id === resolved.id;
-}
-function identityForFastMode(input) {
-  if (input.resolvedModel && resolvedIdentityMatches(input.resolvedModel, input.model)) {
-    return input.resolvedModel;
-  }
-  if (input.model) {
-    const resolved = input.resolveModel?.(input.model);
-    if (resolved)
-      return resolved;
-  }
-  return modelIdentityFromModelId(input.model);
-}
-function resolveSubagentCodexFastModeScope(orchestrationContext) {
-  return orchestrationContext?.kind === "workflow-stage" ? "workflow" : "chat";
-}
-function resolveSubagentModelFastMode(input) {
-  const model = identityForFastMode(input);
-  if (!model)
-    return false;
-  const settings = input.settings ?? getSubagentCodexFastModeSettings(input.cwd);
-  return shouldApplyCodexFastModeForScope(model, settings, input.scope ?? "chat", input.copilotCredential);
-}
-
 // dist/builtin/subagents/src/shared/jsonl-writer.ts
 var DEFAULT_MAX_JSONL_BYTES = 50 * 1024 * 1024;
 
@@ -10483,12 +10427,6 @@ function thinkingLevelForSession(session) {
 function initialThinkingForAttempt(model, configuredThinking) {
   return resolveEffectiveThinking(model, configuredThinking) ?? configuredThinking;
 }
-function defaultFastModeForChild(cwd, context, resolvedModel) {
-  const settings = getSubagentCodexFastModeSettings(cwd);
-  const scope = resolveSubagentCodexFastModeScope(context);
-  const copilotCredential = readStoredCredential("github-copilot");
-  return (model) => resolveSubagentModelFastMode({ model, resolvedModel, cwd, settings, scope, copilotCredential });
-}
 var EMPTY_STATS = {
   sessionFile: undefined,
   sessionId: "",
@@ -10919,7 +10857,7 @@ class SubagentControlRuntime {
       })
     };
   }
-  async runChildAttempt(admitted, candidate, signals, onModelChange, fastModeForModel) {
+  async runChildAttempt(admitted, candidate, signals, onModelChange) {
     const candidateModelId = modelIdForCandidate(candidate, admitted.policy.model);
     const configuredThinking = candidate.thinkingLevel ?? admitted.policy.thinkingLevel;
     let effectiveModelId = candidateModelId;
@@ -11016,7 +10954,7 @@ class SubagentControlRuntime {
       if (admitted.spec.testSession) {
         created = { session: createTestSession(sessionManager, admitted.spec) };
       } else {
-        const settingsManager = SettingsManager2.create(admitted.policy.cwd, getAgentDir2());
+        const settingsManager = SettingsManager.create(admitted.policy.cwd, getAgentDir2());
         const resourceLoader = new DefaultResourceLoader(inProcessChildResourceLoaderOptions({
           cwd: admitted.policy.cwd,
           agentDir: getAgentDir2(),
@@ -11061,14 +10999,13 @@ class SubagentControlRuntime {
       effectiveModelId = initialModelId;
       effectiveThinking = thinkingLevelForSession(session) ?? initialThinkingForAttempt(candidateModelId, configuredThinking);
       attemptedModels = initialModelId ? [initialModelId] : [];
-      onModelChange?.(effectiveModelId, effectiveThinking, fastModeForModel(effectiveModelId));
+      onModelChange?.(effectiveModelId, effectiveThinking);
       const progressState = {
         index: 0,
         agent: admitted.spec.agent.name,
         status: "running",
         ...initialModelId === undefined ? {} : { model: initialModelId },
         ...effectiveThinking === undefined ? {} : { thinking: effectiveThinking },
-        fastMode: fastModeForModel(initialModelId),
         task: admitted.spec.task,
         recentTools: [],
         recentOutput: [],
@@ -11130,13 +11067,11 @@ class SubagentControlRuntime {
             attemptedModels.push(event.to);
           effectiveModelId = event.to;
           progressState.model = event.to;
-          progressState.fastMode = fastModeForModel(event.to);
-          onModelChange?.(effectiveModelId, effectiveThinking, progressState.fastMode);
+          onModelChange?.(effectiveModelId, effectiveThinking);
         } else if (event.type === "thinking_level_changed") {
           effectiveThinking = event.level;
           progressState.thinking = effectiveThinking;
-          const fastMode = fastModeForModel(effectiveModelId);
-          onModelChange?.(effectiveModelId, effectiveThinking, fastMode);
+          onModelChange?.(effectiveModelId, effectiveThinking);
           emitProgress(true);
         }
       });
@@ -11242,10 +11177,9 @@ class SubagentControlRuntime {
         this.attemptTerminators.delete(admitted.identity.path);
     }
   }
-  startAttempt(admitted, candidate, signals, options = {}) {
+  startAttempt(admitted, candidate, signals) {
     const initialModel = modelIdForCandidate(candidate, admitted.policy.model);
     const initialThinking = initialThinkingForAttempt(initialModel, candidate.thinkingLevel ?? admitted.policy.thinkingLevel);
-    const fastModeForModel = options.fastModeForModel ?? defaultFastModeForChild(admitted.policy.cwd, admitted.spec.parent?.orchestrationContext, candidate.model);
     const running = {
       id: this.nextAttemptId++,
       child: admitted,
@@ -11254,7 +11188,6 @@ class SubagentControlRuntime {
       startedAt: Date.now(),
       ...initialModel === undefined ? {} : { currentModel: initialModel },
       currentThinking: initialThinking,
-      currentFastMode: fastModeForModel(initialModel),
       promise: Promise.resolve({
         status: "error",
         cause: "uninitialized",
@@ -11263,11 +11196,10 @@ class SubagentControlRuntime {
         envelope: "uninitialized"
       })
     };
-    running.promise = this.runChildAttempt(admitted, candidate, signals, (model, thinking, fastMode) => {
+    running.promise = this.runChildAttempt(admitted, candidate, signals, (model, thinking) => {
       running.currentModel = model;
       running.currentThinking = thinking;
-      running.currentFastMode = fastMode;
-    }, fastModeForModel).then((result2) => {
+    }).then((result2) => {
       running.status = result2.status;
       this.runningAttempts.delete(running.id);
       return result2;
@@ -11295,12 +11227,11 @@ class SubagentControlRuntime {
       return;
     const model = running.currentModel;
     const thinking = running.currentThinking;
-    if (model === undefined && thinking === undefined && running.currentFastMode === undefined)
+    if (model === undefined && thinking === undefined)
       return;
     return {
       ...model === undefined ? {} : { model },
-      ...thinking === undefined ? {} : { thinking },
-      ...running.currentFastMode === undefined ? {} : { fastMode: running.currentFastMode }
+      ...thinking === undefined ? {} : { thinking }
     };
   }
   async terminateChildAttempt(running, cause) {
@@ -12182,6 +12113,8 @@ function refuseSubagentChildDelegation(ctx, mode) {
 }
 function prepareExecutionContext(input) {
   const { params, ctx, signal, onUpdate, deps } = input;
+  const stageCloseSignal = ctx.orchestrationContext?.messageAdmission?.boundary.closeSignal;
+  const executionSignal = stageCloseSignal === undefined ? signal : AbortSignal.any([signal, stageCloseSignal]);
   const depth = getCurrentSubagentDepth(ctx);
   const normalized = normalizeRepeatedParallelCounts(params);
   if (normalized.error)
@@ -12283,7 +12216,7 @@ ${effectiveParams.task ?? ""}` };
     params: effectiveParams,
     effectiveCwd,
     ctx,
-    signal,
+    signal: executionSignal,
     onUpdate: onUpdateWithContext,
     agents,
     ...parallelAgentConfigs ? { parallelAgentConfigs } : {},
@@ -12298,6 +12231,7 @@ ${effectiveParams.task ?? ""}` };
     controlConfig,
     intercomBridge
   };
+  ctx.orchestrationContext?.messageAdmission?.boundary.registerOwnedSubagentRun(runId);
   const foregroundMode = hasTasks ? "parallel" : "single";
   const foregroundControl = {
     runId,
@@ -13776,6 +13710,9 @@ function createForegroundControlNotifier(data, deps) {
     event
   });
 }
+function workflowStageAcceptsDetachedNotification(ctx) {
+  return ctx.orchestrationContext?.messageAdmission?.isOpen() !== false;
+}
 function resultSummaryForIntercom(result2) {
   const output = getSingleResultOutput(result2);
   if (result2.status === "error" && result2.error) {
@@ -13962,14 +13899,16 @@ async function runParallelPath(data, deps) {
     const results = await runForegroundParallelTasks({
       onDetachedExit: (index, result2) => {
         try {
-          notifyDetachedForegroundChildExit({
-            pi: deps.pi,
-            runId,
-            mode: "parallel",
-            index,
-            totalTasks: tasks.length,
-            result: result2
-          });
+          if (workflowStageAcceptsDetachedNotification(ctx)) {
+            notifyDetachedForegroundChildExit({
+              pi: deps.pi,
+              runId,
+              mode: "parallel",
+              index,
+              totalTasks: tasks.length,
+              result: result2
+            });
+          }
         } finally {
           detachedCleanup.recover(index);
         }
@@ -14108,7 +14047,6 @@ ${worktreeSuffix}` : childContent;
 // dist/builtin/subagents/src/runs/foreground/inprocess-run-sync.ts
 import { existsSync as existsSync15, statSync as statSync8 } from "node:fs";
 import { join as join19 } from "node:path";
-import { readStoredCredential as readStoredCredential2 } from "@bastani/atomic";
 
 // dist/builtin/subagents/src/runs/shared/model-candidate-filter.ts
 function providerFromModel(model) {
@@ -14309,7 +14247,7 @@ function workflowOrchestrationContext(options) {
     ...options.intercomGroup ? { intercomGroup: options.intercomGroup } : {}
   };
 }
-function progressFor(agent, task, outcome, startedAt, fastMode) {
+function progressFor(agent, task, outcome, startedAt) {
   const status = outcome.status === "ok" ? "completed" : outcome.status === "interrupted" && isParentCancellation(outcome.cause) ? "interrupted" : "failed";
   return {
     index: 0,
@@ -14318,7 +14256,6 @@ function progressFor(agent, task, outcome, startedAt, fastMode) {
     task,
     ...outcome.model === undefined ? {} : { model: outcome.model },
     ...outcome.thinking === undefined ? {} : { thinking: outcome.thinking },
-    ...fastMode ? { fastMode: true } : {},
     recentTools: [],
     recentOutput: outcome.envelope ? outcome.envelope.split(`
 `).slice(-10) : [],
@@ -14331,12 +14268,11 @@ function progressFor(agent, task, outcome, startedAt, fastMode) {
     ...outcome.status === "interrupted" && isParentCancellation(outcome.cause) ? { cause: outcome.cause } : {}
   };
 }
-function resultFromOutcome(agent, task, outcome, startedAt, artifactPaths, fastModeForModel) {
+function resultFromOutcome(agent, task, outcome, startedAt, artifactPaths) {
   const status = outcome.status;
   const output = outcome.status === "ok" ? outcome.output : outcome.envelope;
   const model = outcome.model;
   const thinking = outcome.thinking;
-  const fastModeEnabled = fastModeForModel(model);
   const result2 = {
     agent: agent.name,
     task,
@@ -14350,13 +14286,12 @@ function resultFromOutcome(agent, task, outcome, startedAt, artifactPaths, fastM
     usage: usageFromStats(outcome.stats),
     ...model === undefined ? {} : { model },
     ...thinking === undefined ? {} : { thinking },
-    ...fastModeEnabled ? { fastMode: true } : {},
     ..."attemptedModels" in outcome && outcome.attemptedModels?.length ? { attemptedModels: [...outcome.attemptedModels] } : {},
     ...outcome.skills?.length ? { skills: [...outcome.skills] } : {},
     ...outcome.skillsWarning ? { skillsWarning: outcome.skillsWarning } : {},
     finalOutput: output,
     sessionFile: outcome.sessionFile,
-    progress: progressFor(agent, task, outcome, startedAt, fastModeEnabled),
+    progress: progressFor(agent, task, outcome, startedAt),
     progressSummary: {
       toolCount: outcome.stats.toolCalls,
       tokens: outcome.stats.tokens.total,
@@ -14413,20 +14348,7 @@ async function runSingleInProcess(runtimeCwd, agent, task, options) {
   const fallbackCandidates = filteredCandidates.candidates.slice(1);
   const inheritsDispatchConfig = agent.model === undefined && (agent.fallbackModels === undefined || agent.fallbackModels.length === 0) && options.modelOverride === undefined;
   const resolvedCandidate = candidate ? options.resolveCandidateModel?.(candidate) : undefined;
-  const fastModeSettings = getSubagentCodexFastModeSettings(cwd);
-  const copilotCredential = readStoredCredential2("github-copilot");
   const orchestrationContext = workflowOrchestrationContext(options);
-  const fastModeScope = resolveSubagentCodexFastModeScope(orchestrationContext);
-  const resolveModel = (modelId) => options.resolveCandidateModel?.(modelId)?.model;
-  const fastModeForModel = (model) => resolveSubagentModelFastMode({
-    model,
-    resolvedModel: resolvedCandidate?.model,
-    resolveModel,
-    cwd,
-    settings: fastModeSettings,
-    scope: fastModeScope,
-    copilotCredential
-  });
   const parent = {
     path: options.runId,
     depth: options.parentDepth ?? 0,
@@ -14482,7 +14404,6 @@ ${task}`);
       const liveProgress = { ...progress, index: options.index ?? 0 };
       const liveModel = liveProgress.model ?? candidate;
       const liveThinking = liveProgress.thinking;
-      const liveFastMode = fastModeForModel(liveModel);
       const liveResult = {
         agent: agent.name,
         task,
@@ -14491,7 +14412,6 @@ ${task}`);
         usage: emptyUsage(),
         ...liveModel === undefined ? {} : { model: liveModel },
         ...liveThinking === undefined ? {} : { thinking: liveThinking },
-        ...liveFastMode ? { fastMode: true } : {},
         progress: liveProgress
       };
       options.onUpdate?.({
@@ -14513,7 +14433,7 @@ ${task}`);
   const running = control.startAttempt(admission.admitted, { model: resolvedCandidate?.model, modelId: candidate, thinkingLevel: spec.thinkingLevel }, {
     abort: options.signal ?? neverAbort,
     interrupt: options.interruptSignal ?? neverAbort
-  }, { fastModeForModel });
+  });
   if (options.onUpdate) {
     const launchModel = running.currentModel ?? candidate;
     spec.onProgress?.({
@@ -14523,7 +14443,6 @@ ${task}`);
       task,
       ...launchModel === undefined ? {} : { model: launchModel },
       ...running.currentThinking === undefined ? {} : { thinking: running.currentThinking },
-      fastMode: running.currentFastMode ?? fastModeForModel(launchModel),
       recentTools: [],
       recentOutput: [],
       toolCount: 0,
@@ -14558,7 +14477,7 @@ ${task}`);
     detachCleanup();
     parentAskCleanup();
     running.promise.then(async (continuedOutcome) => {
-      const recovered = resultFromOutcome(agent, task, continuedOutcome, startedAt, artifactPaths, fastModeForModel);
+      const recovered = resultFromOutcome(agent, task, continuedOutcome, startedAt, artifactPaths);
       await control.deliverChildResult({
         path: continuedOutcome.path,
         status: continuedOutcome.status,
@@ -14567,7 +14486,6 @@ ${task}`);
         envelope: continuedOutcome.envelope,
         ...recovered.model === undefined ? {} : { model: recovered.model },
         ...recovered.thinking === undefined ? {} : { thinking: recovered.thinking },
-        ...recovered.fastMode ? { fastMode: true } : {},
         sessionFile: continuedOutcome.sessionFile,
         timestamp: Date.now(),
         artifactsDir: options.artifactsDir
@@ -14580,7 +14498,6 @@ ${task}`);
       options.onDetachedExit?.(recovered);
     });
     const continuedModel = running.currentModel ?? candidate;
-    const continuedFastMode = fastModeForModel(continuedModel);
     const continuedThinking = running.currentThinking;
     const continuedResult = {
       agent: agent.name,
@@ -14594,7 +14511,6 @@ ${task}`);
       usage: emptyUsage(),
       ...continuedModel === undefined ? {} : { model: continuedModel },
       ...continuedThinking === undefined ? {} : { thinking: continuedThinking },
-      ...continuedFastMode ? { fastMode: true } : {},
       progress: {
         index: options.index ?? 0,
         agent: agent.name,
@@ -14602,7 +14518,6 @@ ${task}`);
         task,
         ...continuedModel === undefined ? {} : { model: continuedModel },
         ...continuedThinking === undefined ? {} : { thinking: continuedThinking },
-        fastMode: continuedFastMode,
         recentTools: [],
         recentOutput: [],
         toolCount: 0,
@@ -14620,7 +14535,7 @@ ${task}`);
   detachCleanup();
   parentAskCleanup();
   const outcome = winner.value;
-  const result2 = resultFromOutcome(agent, task, outcome, startedAt, artifactPaths, fastModeForModel);
+  const result2 = resultFromOutcome(agent, task, outcome, startedAt, artifactPaths);
   if (filteredCandidates.skippedAttempts.length)
     result2.modelAttempts = [...filteredCandidates.skippedAttempts, ...result2.modelAttempts ?? []];
   await control.deliverChildResult({
@@ -14631,7 +14546,6 @@ ${task}`);
     envelope: outcome.envelope,
     ...result2.model === undefined ? {} : { model: result2.model },
     ...result2.thinking === undefined ? {} : { thinking: result2.thinking },
-    ...result2.fastMode ? { fastMode: true } : {},
     sessionFile: outcome.sessionFile,
     timestamp: Date.now(),
     artifactsDir: options.artifactsDir
@@ -14841,8 +14755,9 @@ async function runSinglePath(data, deps) {
       },
       onDetachedExit: (result2) => {
         cleanupTransientProgress(progressDir, artifactConfig.enabled);
-        if (result2)
+        if (result2 && workflowStageAcceptsDetachedNotification(ctx)) {
           notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "single", index: 0, result: result2 });
+        }
       },
       index: 0,
       modelOverride,
@@ -15746,8 +15661,8 @@ import { getMarkdownTheme, keyHintIfBound as keyHintIfBound2 } from "@bastani/at
 import { Container as Container2, Markdown, Spacer, Text as Text2 } from "@earendil-works/pi-tui";
 
 // dist/builtin/subagents/src/tui/render-event-formatting.ts
-function modelThinkingBadge(theme, model, thinking, fastMode) {
-  const label = formatModelThinking(model, thinking, fastMode);
+function modelThinkingBadge(theme, model, thinking) {
+  const label = formatModelThinking(model, thinking);
   return label ? theme.fg("dim", ` (${label})`) : "";
 }
 
@@ -15989,7 +15904,7 @@ function renderSingleCompact(d, r, theme, now, pulseFrame) {
   ]);
   const c = new Container;
   const width = getTermWidth() - 4;
-  const modelDisplay = modelThinkingBadge(theme, r.model, r.thinking, r.fastMode);
+  const modelDisplay = modelThinkingBadge(theme, r.model, r.thinking);
   c.addChild(new Text(truncLine(`${resultGlyph(r, output, theme, isRunning, pulseFrame)} ${theme.fg("toolTitle", theme.bold(r.agent))}${modelDisplay}${contextBadge}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`, width), 0, 0));
   if (isRunning && r.progress) {
     const progressSnapshotNow = snapshotNowForProgress(r.progress, now);
@@ -16073,7 +15988,7 @@ function renderMultiCompact(d, theme, now, pulseFrame) {
       const runningProg = d.progress?.find((p) => p.index === i && p.status === "running");
       if (runningProg) {
         const runningStats = formatProgressStats(theme, runningProg, true, now);
-        const runningBadge = modelThinkingBadge(theme, runningProg.model, runningProg.thinking, runningProg.fastMode);
+        const runningBadge = modelThinkingBadge(theme, runningProg.model, runningProg.thinking);
         const runningLine = `${theme.fg("accent", pulseGlyph(pulseFrame))} ${rowLabel}: ${themeBold(theme, agentName)}${runningBadge}${runningStats ? ` ${theme.fg("dim", "·")} ${runningStats}` : ""}`;
         c.addChild(new Text(truncLine(`  ${runningLine}`, width), 0, 0));
         const activity = compactCurrentActivity(runningProg, now);
@@ -16095,7 +16010,7 @@ function renderMultiCompact(d, theme, now, pulseFrame) {
     const rPending = rProg && "status" in rProg && rProg.status === "pending";
     const stepNumber = r.progress?.index !== undefined ? r.progress.index + 1 : progressFromArray?.index !== undefined ? progressFromArray.index + 1 : i + 1;
     const stepStats = formatProgressStats(theme, rProg, true, now);
-    const modelDisplay = modelThinkingBadge(theme, r.model ?? rProg?.model, r.thinking ?? rProg?.thinking, r.fastMode ?? rProg?.fastMode);
+    const modelDisplay = modelThinkingBadge(theme, r.model ?? rProg?.model, r.thinking ?? rProg?.thinking);
     const glyph2 = rPending ? theme.fg("dim", "◦") : resultGlyph(r, output, theme, rRunning, pulseFrame);
     const pendingLabel = rPending ? ` ${theme.fg("dim", "· pending")}` : "";
     const stepLabel = resultRowLabel(d, multiLabel, i, stepNumber);
@@ -16226,7 +16141,7 @@ function renderSubagentResult(result2, options, theme) {
     const progressInfo = isRunning && r.progress ? ` | ${r.progress.toolCount} tools, ${formatTokens(r.progress.tokens)} tok, ${formatDuration(displayProgressDurationMs(r.progress, options.now))}` : r.progressSummary ? ` | ${r.progressSummary.toolCount} tools, ${formatTokens(r.progressSummary.tokens)} tok, ${formatDuration(r.progressSummary.durationMs)}` : "";
     const w2 = getTermWidth() - 4;
     const fit2 = (text) => expanded ? text : truncLine(text, w2);
-    const modelDisplay = modelThinkingBadge(theme, r.model, r.thinking, r.fastMode);
+    const modelDisplay = modelThinkingBadge(theme, r.model, r.thinking);
     const toolCallLines = getToolCallLines(r, expanded);
     const c2 = new Container2;
     c2.addChild(new Text2(fit2(`${icon2} ${theme.fg("toolTitle", theme.bold(r.agent))}${modelDisplay}${contextBadge2}${progressInfo}`), 0, 0));
@@ -16344,7 +16259,7 @@ function renderSubagentResult(result2, options, theme) {
       const runningProg = d.progress?.find((p) => p.index === i && p.status === "running");
       if (runningProg) {
         const runningStats = ` | ${runningProg.toolCount} tools, ${formatDuration(displayProgressDurationMs(runningProg, options.now))}`;
-        const runningBadge = modelThinkingBadge(theme, runningProg.model, runningProg.thinking, runningProg.fastMode);
+        const runningBadge = modelThinkingBadge(theme, runningProg.model, runningProg.thinking);
         c.addChild(new Text2(fit(`${theme.fg("warning", "running")} ${rowLabel}: ${theme.bold(theme.fg("warning", agentName))}${runningBadge}${runningStats}`), 0, 0));
         const progressSnapshotNow = snapshotNowForProgress(runningProg, options.now);
         const liveStatusLine = buildLiveStatusLine(runningProg, progressSnapshotNow);
@@ -16369,7 +16284,7 @@ function renderSubagentResult(result2, options, theme) {
     const resultOutput = getSingleResultOutput(r);
     const statusIcon = rRunning ? theme.fg("warning", "running") : r.status === "error" ? theme.fg("error", "failed") : isParentCancellation(r.cause) && (r.interrupted || r.status === "interrupted") ? theme.fg("warning", "cancelled") : r.status === "skipped" || r.status === "interrupted" || r.status === "continued" ? theme.fg("warning", r.status) : hasEmptyTextOutputWithoutOutputTarget(r.task, resultOutput) ? theme.fg("warning", "warning") : theme.fg("success", "done");
     const stats = rProg ? ` | ${rProg.toolCount} tools, ${formatDuration(displayProgressDurationMs(rProg, options.now))}` : "";
-    const modelDisplay = modelThinkingBadge(theme, r.model ?? rProg?.model, r.thinking ?? rProg?.thinking, r.fastMode ?? rProg?.fastMode);
+    const modelDisplay = modelThinkingBadge(theme, r.model ?? rProg?.model, r.thinking ?? rProg?.thinking);
     const stepLabel = resultRowLabel(d, multiLabel, i, stepNumber);
     const stepHeader = rRunning ? `${statusIcon} ${stepLabel}: ${theme.bold(theme.fg("warning", r.agent))}${modelDisplay}${stats}` : `${statusIcon} ${stepLabel}: ${theme.bold(r.agent)}${modelDisplay}${stats}`;
     const toolCallLines = getToolCallLines(r, expanded);
@@ -16547,13 +16462,15 @@ function parseSubagentNotifyContent(content) {
 // dist/builtin/subagents/src/extension/prompt-guidance.ts
 var DEFAULT_PROMPT_GUIDANCE = [
   `**Subagent orchestration**: Use subagents for focused specialist work inside workflows or as bounded delegation when a workflow would be unnecessary overhead.
-  - Because workflows are the default for non-trivial structured work with verifiable objectives, do not stretch parent-controlled subagent calls into an ad hoc implementation, review, or retry pipeline; use a workflow and let its stages delegate specialists.
+  - Unless the user explicitly chooses inline execution for the specified task, workflows are the default for non-trivial structured work with verifiable objectives; use a workflow for implementation, review, or retry pipelines and let its stages delegate specialists.
+  - Explicit requests such as "inline", "do this directly", or "don't use a workflow", and equivalent wording, override that default even for complex tasks. Do not create or launch a hidden/nested workflow or pressure the user to reapprove the choice. Preserve appropriate testing, review and evidence inline, and unrelated safety and authorization constraints. Apply the preference only to the specified task. Quoted examples and questions about inline code are not execution-mode instructions.
+  - On a switch from an active workflow to inline, notify the controlling session to safely hold/stop the affected run, reconcile completed work and in-flight side effects, then continue inline without duplicate execution. Do not claim completed work was undone.
   - Use a single subagent for a focused specialty or parallel tasks for independent work. Keep substantial-overlap tasks together rather than duplicating investigation across agents.
   - Delegate noisy or context-heavy command investigation when isolation helps, but run concise commands inline when that is simpler.
   - Foreground execution is the only subagent execution mode; do not duplicate a delegated job while waiting. Workflow stages may still run their own durable work in the background.
   - Use the debugger subagent for actual failures that need reproduction, root-cause diagnosis, and a validated fix; additional debugger or research delegates are optional when they add a distinct useful angle.
   - Let each named agent use its declared model and fallback policy: omit the explicit model argument unless the user requests an exact model or a documented task requirement needs one, and record the reason for any override before launch. Do not choose an ad hoc model merely for diversity.
-  - If an agent has no declared model or fallback policy, consult packages/coding-agent/docs/models/model-selection.md for the role's Pareto-efficient recommendations, then use workflow({ action: "models" }) when available to inspect the configured catalog. Pin only a returned fullId and only append a thinking level listed for that entry. If the catalog tool is unavailable, the catalog is empty, or no recommended model is present, leave the child unpinned and state the limitation rather than inventing a model. Do not inspect credentials or infer why a model is absent.
+  - If an agent has no declared model or fallback policy, consult packages/coding-agent/docs/models/model-selection.md for the role's Pareto-efficient recommendations and packages/coding-agent/docs/models/evals.md for the measured per-evaluation scores by task type, then use workflow({ action: "models" }) when available to inspect the configured catalog. Pin only a returned fullId and only append a thinking level listed for that entry. If the catalog tool is unavailable, the catalog is empty, or no recommended model is present, leave the child unpinned and state the limitation rather than inventing a model. Do not inspect credentials or infer why a model is absent.
   - Workflow stages automatically receive their invocation-scoped Intercom group, and delegated children inherit the launching session's group across single, parallel, and follow-up work. Do not create or propagate group identifiers for ordinary workflow-stage delegation; use an explicit group only for an intentional topology override. Keep contact_supervisor available for cross-group escalation.`
 ];
 

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.18-alpha.5",
+  "version": "0.9.18-alpha.7",
   "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": [
@@ -31,7 +31,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.84.4"
+    "@earendil-works/pi-tui": "^0.85.1"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,52 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.18-alpha.7] - 2026-09-05
+
+### Fixed
+
+- Pending-stage Intercom settlement now skips unrelated runs with no messages to settle. Genuine sweep failures produce one display-only warning per distinct message in interactive sessions instead of repeated console stack traces; headless sessions retain console diagnostics, and pending messages remain available for recovery.
+
+### Changed
+
+- Updated the bundled prompt-engineering skill with GPT-6 Astra prompting and API migration guidance, plus an attributed instruction audit covering concise skill descriptions, selective reference loading, proportionate testing, permission boundaries, and completion criteria.
+- Split prompt-engineering model advice into individually sourced guides for GPT-5.6, GPT-5.5, Claude Fable 5.1, Fable 5, Opus 5, Opus 4.8, and Sonnet 5, alongside Astra. Shared guidance now routes to each model's distinct effort, verification, delegation, and API migration rules.
+
+## [0.9.18-alpha.6] - 2026-09-04
+
+### Breaking Changes
+
+- Workflow-stage Intercom targets now accept only root-anchored `workflow:<rootRunId>/<segment>[/<segment>...]` paths. The legacy `<runId>:<stageKey>` form is refused with a canonical-path migration hint.
+- Removed the `fastMode` field from `WorkflowTaskResult`, stage snapshots, fallback metadata, and durable checkpoint/envelope records. Workflow stages now select fast inference explicitly by pinning a canonical `-fast` model ID in `model` or `fallbackModels`; normal and fast IDs remain separate ordered candidates.
+
+### Added
+
+- Durable workflows now resolve checksum-pinned embedded PostgreSQL runtimes on Linux musl x64/ARM64 and Windows ARM64 while preserving explicit database URL precedence, Docker fallback, root privilege dropping, and retained-process shutdown ownership. Windows ARM64 uses the PostgreSQL x64 runtime through Windows 11 x64 emulation.
+- Workflow launch now scans and persists possible literal, patterned, and nested-child stage paths. Sticky name and glob sends deliver to every future matching stage, while `workflow:<rootRunId>/**` broadcasts to live stages and remains queued for future descendants until root termination.
+- Possible future targets and their queued counts now appear in `intercom list`. Valid paths outside the scanned set are accepted with a `notInKnownSet` warning and settle as undeliverable at terminal only when they never matched.
+
+### Changed
+
+- Heartbeat, workflow-tool, and builtin stage guidance now directs shared scope and acceptance-criteria amendments through one authoritative path broadcast rather than enumerating known stages, and teaches path discovery, globs, sticky delivery, and live-only asks.
+- The stage-chat jump indicator now uses the same `↓ Jump to latest message · <shortcut>` copy as the fullscreen transcript overlay.
+- Updated Goal/Ralph orchestration, Ralph prompt engineering and research, and Open Claude Design to GPT-6 Astra at `high`; Goal reviewers and Ralph reviewer B use Astra at `xhigh`, while Ralph reviewer A uses Claude Fable 5.1 at `high`. Added Astra and Fable 5.1 fallbacks while retaining role-specific provider order and reasoning levels. Ralph research now places Fable 5 before Sol, and reviewer B places Sol after Fable 5 and Fugu before GPT-5.5 in its OpenRouter group.
+
+- Workflow guidance honors explicit task-scoped inline/no-workflow requests, including safe handoff from active runs without duplicate execution. Default authoring and Goal/Ralph prompts select browser, terminal or desktop/simulator verification by environment, support offline/manual qlty setup, and describe authorized native GitHub media attachments with verified hosted links.
+- Model-pinning guidance now points authored workflows at the measured per-evaluation scores in `packages/coding-agent/docs/models/evals.md` (formerly `artificial-analysis-index.md`), whose task-type picker maps each stage type to the eval that measures it, alongside the role guidance in `model-selection.md`.
+
+### Fixed
+
+- Tool-only workflows no longer emit a `ZERO_STAGES` discovery warning. The static scan now recognizes `ctx.tool()` as tracked graph work without advertising tool nodes as future chat-stage targets.
+- A schema-backed stage that exhausts its structured-output correction budget now advances the model fallback chain instead of failing the whole stage on its first candidate. Each candidate gets the stage prompt plus three corrective follow-ups; a candidate that never produces a valid `structured_output` call fails over exactly like a rate-limited one, recording its attempts as failures with an error naming what the turn looked like (no assistant message, empty assistant text, or the validation error), emitting a `[fallback]` warning, and re-sending the original stage prompt to the next candidate with a fresh budget. With no candidate left the stage still fails with the existing contract error. A model attempt that succeeds is now recorded in the running stage's durable metadata at the moment it succeeds rather than only when the stage ends, so mid-run status and a run resumed after an interruption both report the model that actually produced the result instead of showing only the attempts that failed. ([#2812](https://github.com/bastani-inc/atomic/issues/2812))
+- A stage whose queued Intercom messages can no longer be delivered now fails instead of running forever. `stage-runner-controller` awaits `pendingStageDelivery.ready()` with no timeout, and only a successful drain ever settled it — so when Intercom exhausted its bounded warm-up retries the stage stayed `running` with nothing owning recovery. `createWorkflowPendingStageDelivery` now implements the delivery contract's `fail(reason)`: the first reason wins, `ready()` settles exactly once with a `WorkflowPendingStageDeliveryFailedError` (`code: "pending_stage_delivery_failed"`) carrying the run id, stage id, and stage name, and the stage reaches a deterministic non-retryable `failed` outcome whose error names it. That outcome is now non-retryable by construction rather than by wording: the stage lifecycle refuses a terminal delivery failure as a model failure at both decision sites, so no same-model retry is spent, no fallback candidate is walked, and no `[fallback]` warning blames a model for a stage that would have been refused the same instructions by every candidate. The delivery owner's reason is kept on the error's `reason` property instead of as `cause`, because the shared classifier walks `cause` and Intercom's reason nests the transport error that lost the broker — which made a dead delivery read as a retryable `network_timeout`. A terminal failure latched before the controller's first `ready()` is honored, an unobserved rejection does not surface as an unhandled rejection, a stage with nothing queued still short-circuits and runs, and a drain requested after the latch is a no-op so queued steering stays queued rather than being marked delivered. The session attached just before the gate is disposed and detached on that failure, so a later `ensureSession()` cannot hand back a stage session that skipped its queued instructions.
+- Workflow durability degradation now appears as a display-only warning notification for interactive and RPC actions instead of being written to the console; print and headless actions still receive an actionable console diagnostic when no usable UI exists.
+- In-flight durable resume, catalog preparation, and completed-workflow opening now keep using the backend selected by initialization instead of re-reading mutable factory state after an asynchronous boundary, preventing a concurrent backend reset from stranding the operation with a not-ready error while preserving distinct malformed, stale, and missing-target diagnostics.
+
+- Uncaught targeted `ctx.tool` aborts now retain the failed tool identity and an inspection-only cancellation frontier. Public resume, including fresh DBOS hydration and session lifecycle restoration, replays completed work and retries the unfinished tool without fabricating a model stage.
+- Tool-frontier resume rejects missing, ambiguous, cyclic, or identity-inconsistent state before replaying unfinished callbacks. Older records recover only when typed persisted checkpoints prove a unique safe frontier, including for multiline tool names; transcript text is not converted into checkpoints.
+- Incremental graph parent replacement now rejects self-edges and back-edges before mutating the workflow DAG.
+- Tool-frontier continuations reject normal returns and explicit completed exits that skip the exact unfinished tool, and reject replacement model/task and child-workflow execution before side effects. Stage/task worktree setup follows replay selection and live admission. The failure names the pending frontier, preserves source recovery evidence, and does not repeat completed callbacks.
+
 ## [0.9.18-alpha.3] - 2026-09-01
 
 ### Added