@bastani/atomic 0.9.21-alpha.1 → 0.9.21

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

@@ -6944,7 +6944,7 @@ var require_public_api = __commonJS(function(exports) {
 });
 
 // dist/builtin/subagents/src/extension/index.ts
-import * as fs21 from "node:fs";
+import * as fs22 from "node:fs";
 import * as os8 from "node:os";
 import * as path23 from "node:path";
 import {
@@ -6978,7 +6978,9 @@ import * as fs2 from "node:fs";
 import {
   eligiblePair,
   ModelConstraintsSchema,
-  parseModelConstraints
+  parseModelConstraints,
+  parseTaskNeeds,
+  TaskNeedsSchema
 } from "@bastani/atomic";
 
 // dist/builtin/subagents/src/agents/agent-paths.ts
@@ -11794,6 +11796,7 @@ function topLevelSingleTask(item) {
     ...item.params.progress !== undefined ? { progress: item.params.progress } : {},
     ...item.params.model !== undefined ? { model: item.params.model } : {},
     ...item.params.modelConstraints !== undefined ? { modelConstraints: item.params.modelConstraints } : {},
+    ...item.params.taskNeeds !== undefined ? { taskNeeds: item.params.taskNeeds } : {},
     ...item.params.skill !== undefined ? { skill: item.params.skill } : {},
     ...item.params.group !== undefined ? { group: item.params.group } : {}
   };
@@ -12577,11 +12580,14 @@ function currentModelFullId(model) {
 import {
   AutoRoutingInferenceError,
   parseModelConstraints as parseModelConstraints2,
-  routeExecutionModel
+  reportModelRoutingDebug,
+  routeExecutionModel,
+  setsProviders
 } from "@bastani/atomic";
 async function routeSubagentModel(input) {
   const { ctx, agent } = input;
   const constraints = structuredClone([parseModelConstraints2(agent.modelConstraints), parseModelConstraints2(input.modelConstraints)].filter((c) => c !== undefined));
+  const taskNeeds = parseTaskNeeds(input.taskNeeds);
   const effortOverride = agent.source === "builtin" && agent.thinking !== "" ? agent.thinking : undefined;
   let route;
   try {
@@ -12590,14 +12596,16 @@ async function routeSubagentModel(input) {
       task: input.task?.trim() ? input.task : agent.systemPrompt,
       agent: { name: agent.name, description: agent.description },
       constraints: effortOverride === undefined ? constraints : [...constraints, { allowedEfforts: [effortOverride] }],
-      signal: input.signal
+      signal: input.signal,
+      ...taskNeeds ? { taskNeeds } : {},
+      ...setsProviders(parseModelConstraints2(input.modelConstraints)) ? { overrideProviderSettings: true } : {}
     });
   } catch (error) {
     input.signal?.throwIfAborted();
     if (!(error instanceof AutoRoutingInferenceError) || error.currentModelRoute === undefined)
       throw error;
     route = error.currentModelRoute;
-    console.warn(`Subagent auto routing failed; running "${agent.name}" on the current chat model ${route.modelOverride}.`);
+    reportModelRoutingDebug(`Subagent auto routing failed; running "${agent.name}" on the current chat model ${route.modelOverride}.`);
   }
   const fallbackRoute = effortOverride === undefined ? route : await routeExecutionModel({
     ctx,
@@ -12642,6 +12650,7 @@ function recordRun(agent, task, status, durationMs) {
 }
 
 // dist/builtin/subagents/src/runs/shared/single-output.ts
+import * as fs15 from "node:fs";
 import * as path15 from "node:path";
 function normalizeSingleOutputOverride(output, defaultOutput) {
   if (output === false || output === "false")
@@ -12703,6 +12712,58 @@ function validateFileOnlyOutputMode(outputMode, outputPath, context) {
   }
   return;
 }
+function captureSingleOutputSnapshot(outputPath) {
+  if (!outputPath)
+    return;
+  try {
+    const stat = fs15.statSync(outputPath);
+    return { exists: true, mtimeMs: stat.mtimeMs, size: stat.size };
+  } catch {
+    return { exists: false };
+  }
+}
+function persistSingleOutput(outputPath, fullOutput) {
+  if (!outputPath)
+    return {};
+  try {
+    fs15.mkdirSync(path15.dirname(outputPath), { recursive: true });
+    fs15.writeFileSync(outputPath, fullOutput, "utf-8");
+    return { savedPath: outputPath };
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function resolveSingleOutput(outputPath, fallbackOutput, beforeRun) {
+  if (!outputPath)
+    return { fullOutput: fallbackOutput };
+  let changedSinceStart = false;
+  try {
+    const stat = fs15.statSync(outputPath);
+    changedSinceStart = !beforeRun?.exists || stat.mtimeMs !== beforeRun.mtimeMs || stat.size !== beforeRun.size;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+    if (code !== "ENOENT" && code !== "ENOTDIR") {
+      return {
+        fullOutput: fallbackOutput,
+        saveError: `Failed to inspect output file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  if (changedSinceStart) {
+    try {
+      return { fullOutput: fs15.readFileSync(outputPath, "utf-8"), savedPath: outputPath };
+    } catch (error) {
+      return {
+        fullOutput: fallbackOutput,
+        saveError: `Failed to read changed output file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  const save = persistSingleOutput(outputPath, fallbackOutput);
+  if (save.savedPath)
+    return { fullOutput: fallbackOutput, savedPath: save.savedPath };
+  return { fullOutput: fallbackOutput, saveError: save.error };
+}
 function finalizeSingleOutput(params) {
   let displayOutput = params.truncatedOutput || params.fullOutput;
   if (params.status === "ok" && params.savedPath) {
@@ -12727,13 +12788,13 @@ ${params.saveError}`;
 
 // dist/builtin/subagents/src/runs/shared/worktree.ts
 import { spawnSync } from "node:child_process";
-import * as fs17 from "node:fs";
+import * as fs18 from "node:fs";
 import * as os7 from "node:os";
 import * as path18 from "node:path";
 import { createChildProcessEnvironment as createChildProcessEnvironment3, createGitEnvironment } from "@bastani/atomic";
 
 // dist/builtin/subagents/src/runs/shared/worktree-post-create.ts
-import * as fs15 from "node:fs";
+import * as fs16 from "node:fs";
 import * as path16 from "node:path";
 function tracked(runGit, repo, relativePath) {
   return runGit(repo, ["ls-files", "--error-unmatch", "--", relativePath]).status === 0;
@@ -12752,10 +12813,10 @@ function hasTrackedPathComponent(runGit, repo, relativePath) {
 function copySettings(runGit, mainRoot, worktreeRoot, relativePath) {
   const source = path16.join(mainRoot, relativePath);
   const destination = path16.join(worktreeRoot, relativePath);
-  if (!fs15.existsSync(source) || fs15.existsSync(destination) || hasTrackedPathComponent(runGit, worktreeRoot, relativePath))
+  if (!fs16.existsSync(source) || fs16.existsSync(destination) || hasTrackedPathComponent(runGit, worktreeRoot, relativePath))
     return false;
-  fs15.mkdirSync(path16.dirname(destination), { recursive: true });
-  fs15.copyFileSync(source, destination);
+  fs16.mkdirSync(path16.dirname(destination), { recursive: true });
+  fs16.copyFileSync(source, destination);
   return true;
 }
 function configureHooks(runGit, mainRoot) {
@@ -12763,12 +12824,12 @@ function configureHooks(runGit, mainRoot) {
   const ordinary = path16.join(mainRoot, ".git", "hooks");
   let desired;
   try {
-    if (fs15.statSync(husky).isDirectory())
+    if (fs16.statSync(husky).isDirectory())
       desired = husky;
   } catch {}
   if (!desired) {
     try {
-      if (fs15.readdirSync(ordinary, { withFileTypes: true }).some((entry) => entry.isFile() && !entry.name.endsWith(".sample")))
+      if (fs16.readdirSync(ordinary, { withFileTypes: true }).some((entry) => entry.isFile() && !entry.name.endsWith(".sample")))
         desired = ordinary;
     } catch {}
   }
@@ -12782,7 +12843,7 @@ function configureHooks(runGit, mainRoot) {
     throw new Error(result.stderr.trim() || "failed to configure shared core.hooksPath");
 }
 function copyIncludes(runGit, mainRoot, worktreeRoot) {
-  if (!fs15.existsSync(path16.join(mainRoot, ".worktreeinclude")))
+  if (!fs16.existsSync(path16.join(mainRoot, ".worktreeinclude")))
     return;
   const ignored = runGit(mainRoot, ["ls-files", "--others", "--ignored", "--exclude-standard"]);
   const included = runGit(mainRoot, ["ls-files", "--others", "--ignored", "--exclude-from=.worktreeinclude"]);
@@ -12795,10 +12856,10 @@ function copyIncludes(runGit, mainRoot, worktreeRoot) {
     const source = path16.join(mainRoot, relativePath);
     const destination = path16.join(worktreeRoot, relativePath);
     try {
-      if (!fs15.statSync(source).isFile() || fs15.existsSync(destination))
+      if (!fs16.statSync(source).isFile() || fs16.existsSync(destination))
         continue;
-      fs15.mkdirSync(path16.dirname(destination), { recursive: true });
-      fs15.copyFileSync(source, destination);
+      fs16.mkdirSync(path16.dirname(destination), { recursive: true });
+      fs16.copyFileSync(source, destination);
     } catch {}
   }
 }
@@ -12812,9 +12873,9 @@ function performPostCreationSetup(runGit, mainRoot, worktreeRoot) {
   configureHooks(runGit, mainRoot);
   const source = path16.join(mainRoot, "node_modules");
   const destination = path16.join(worktreeRoot, "node_modules");
-  if (fs15.existsSync(source) && !fs15.existsSync(destination) && !tracked(runGit, worktreeRoot, "node_modules")) {
+  if (fs16.existsSync(source) && !fs16.existsSync(destination) && !tracked(runGit, worktreeRoot, "node_modules")) {
     try {
-      fs15.symlinkSync(source, destination, process.platform === "win32" ? "junction" : undefined);
+      fs16.symlinkSync(source, destination, process.platform === "win32" ? "junction" : undefined);
       synthetic.push("node_modules");
     } catch {}
   }
@@ -12823,19 +12884,19 @@ function performPostCreationSetup(runGit, mainRoot, worktreeRoot) {
 }
 
 // dist/builtin/subagents/src/runs/shared/worktree-root.ts
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as path17 from "node:path";
 function readText(file) {
   try {
-    return fs16.readFileSync(file, "utf8");
+    return fs17.readFileSync(file, "utf8");
   } catch {
     return;
   }
 }
 function samePath(left, right) {
   try {
-    const a = fs16.realpathSync.native(left);
-    const b = fs16.realpathSync.native(right);
+    const a = fs17.realpathSync.native(left);
+    const b = fs17.realpathSync.native(right);
     return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
   } catch {
     return false;
@@ -12844,14 +12905,14 @@ function samePath(left, right) {
 function findGitRoot(cwd) {
   let current = path17.resolve(cwd);
   try {
-    if (!fs16.statSync(current).isDirectory())
+    if (!fs17.statSync(current).isDirectory())
       current = path17.dirname(current);
   } catch {
     return;
   }
   while (true) {
     try {
-      const entry = fs16.statSync(path17.join(current, ".git"));
+      const entry = fs17.statSync(path17.join(current, ".git"));
       if (entry.isDirectory() || entry.isFile())
         return current;
     } catch {}
@@ -12865,7 +12926,7 @@ function resolveMainRepoRoot(repoRoot) {
   const gitEntry = path17.join(repoRoot, ".git");
   let stats;
   try {
-    stats = fs16.statSync(gitEntry);
+    stats = fs17.statSync(gitEntry);
   } catch {
     return;
   }
@@ -12952,7 +13013,7 @@ function resolveRepoState(cwd) {
 function normalizeComparableCwd(cwd) {
   const resolved = path18.resolve(cwd);
   try {
-    return fs17.realpathSync(resolved);
+    return fs18.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -12987,8 +13048,8 @@ function buildWorktreePath(mainRoot, runId, index) {
 }
 function ensureWorktreeIgnore(mainRoot) {
   const root = path18.join(mainRoot, ".atomic", "worktrees");
-  fs17.mkdirSync(root, { recursive: true });
-  fs17.writeFileSync(path18.join(root, ".gitignore"), `*
+  fs18.mkdirSync(root, { recursive: true });
+  fs18.writeFileSync(path18.join(root, ".gitignore"), `*
 `, "utf8");
 }
 function resolveRepoCwdRelative(cwd) {
@@ -13024,10 +13085,10 @@ function resolveWorktreeSetupHook(repoRoot, config) {
   } else {
     throw new Error("worktree setup hook must be an absolute path or a repo-relative path");
   }
-  if (!fs17.existsSync(resolvedPath)) {
+  if (!fs18.existsSync(resolvedPath)) {
     throw new Error(`worktree setup hook not found: ${resolvedPath}`);
   }
-  if (fs17.statSync(resolvedPath).isDirectory()) {
+  if (fs18.statSync(resolvedPath).isDirectory()) {
     throw new Error(`worktree setup hook must be a file, got directory: ${resolvedPath}`);
   }
   return {
@@ -13174,7 +13235,7 @@ function removeSyntheticPath(worktree, syntheticPath) {
   }
   let stat;
   try {
-    stat = fs17.lstatSync(resolved);
+    stat = fs18.lstatSync(resolved);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
     if (code === "ENOENT")
@@ -13182,14 +13243,14 @@ function removeSyntheticPath(worktree, syntheticPath) {
     throw error;
   }
   if (stat.isSymbolicLink()) {
-    fs17.unlinkSync(resolved);
+    fs18.unlinkSync(resolved);
     return;
   }
   if (stat.isDirectory()) {
-    fs17.rmSync(resolved, { recursive: true, force: true });
+    fs18.rmSync(resolved, { recursive: true, force: true });
     return;
   }
-  fs17.rmSync(resolved, { force: true });
+  fs18.rmSync(resolved, { force: true });
 }
 function removeSyntheticPathsBeforeDiff(worktree) {
   if (worktree.syntheticPaths.length === 0)
@@ -13238,7 +13299,7 @@ function captureWorktreeDiff(setup, worktree, agent, patchPath) {
   const diffStat = runGitChecked(worktree.path, ["diff", "--cached", "--stat", setup.baseCommit]).trim();
   const patch = runGitChecked(worktree.path, ["diff", "--cached", setup.baseCommit]);
   const numstat = runGitChecked(worktree.path, ["diff", "--cached", "--numstat", setup.baseCommit]);
-  fs17.writeFileSync(patchPath, patch, "utf-8");
+  fs18.writeFileSync(patchPath, patch, "utf-8");
   if (!patch.trim()) {
     return emptyDiff(worktree.index, agent, worktree.branch, patchPath);
   }
@@ -13256,7 +13317,7 @@ function captureWorktreeDiff(setup, worktree, agent, patchPath) {
 }
 function writeEmptyPatch(patchPath) {
   try {
-    fs17.writeFileSync(patchPath, "", "utf-8");
+    fs18.writeFileSync(patchPath, "", "utf-8");
   } catch {}
 }
 function hasWorktreeChanges(diff) {
@@ -13279,7 +13340,7 @@ function createWorktrees(cwd, runId, count, options) {
 }
 function diffWorktrees(setup, agents, diffsDir) {
   try {
-    fs17.mkdirSync(diffsDir, { recursive: true });
+    fs18.mkdirSync(diffsDir, { recursive: true });
   } catch {
     return [];
   }
@@ -13347,7 +13408,7 @@ function createDetachedCleanupBarrier(onReady) {
 }
 
 // dist/builtin/subagents/src/runs/foreground/subagent-executor-parallel-task.ts
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 
 // dist/builtin/subagents/src/runs/foreground/subagent-executor-worktree.ts
 import * as path19 from "node:path";
@@ -13411,6 +13472,75 @@ function findDuplicateParallelOutputPath(input) {
   return;
 }
 
+// dist/builtin/subagents/src/runs/foreground/task-output-retention.ts
+import { mkdtempSync, readFileSync as readFileSync11, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join18 } from "node:path";
+var INLINE_TASK_OUTPUT_MAX_BYTES = 16 * 1024;
+var MAX_RETAINED_TASK_OUTPUTS = 256;
+var retained = new Map;
+var copyRoot;
+function retentionKey(ownerId, taskId) {
+  return `${ownerId}\x00${taskId}`;
+}
+function fileSafe(value) {
+  return value.replace(/[^A-Za-z0-9._-]+/g, "_");
+}
+function privateCopyRoot() {
+  if (copyRoot)
+    return copyRoot;
+  const root = mkdtempSync(join18(tmpdir2(), "atomic-subagent-output-"));
+  copyRoot = root;
+  process.once("exit", () => rmSync3(root, { recursive: true, force: true }));
+  return root;
+}
+function removeCopy(entry) {
+  if (entry?.path)
+    rmSync3(entry.path, { force: true });
+}
+function fullOutputText(child, text) {
+  if (child.outputMode !== "file-only" || !child.outputReference)
+    return text;
+  try {
+    return readFileSync11(child.outputReference.path, "utf-8");
+  } catch {
+    return text;
+  }
+}
+function writePrivateCopy(ownerId, taskId, text) {
+  try {
+    const path = join18(privateCopyRoot(), `${fileSafe(ownerId)}-${fileSafe(taskId)}.md`);
+    writeFileSync8(path, text, { encoding: "utf-8", mode: 384 });
+    return path;
+  } catch {
+    return;
+  }
+}
+function retainTaskOutput(child, text, ref) {
+  const bytes = Buffer.from(text);
+  const path = writePrivateCopy(ref.ownerId, ref.taskId, fullOutputText(child, text));
+  const key = retentionKey(ref.ownerId, ref.taskId);
+  removeCopy(retained.get(key));
+  retained.delete(key);
+  retained.set(key, {
+    ...path ? { path } : {},
+    ...child.outputReference ? { requestedPath: child.outputReference.path } : {},
+    ...child.outputSaveError ? { saveError: child.outputSaveError } : {},
+    head: new TextDecoder().decode(bytes.subarray(0, INLINE_TASK_OUTPUT_MAX_BYTES)),
+    totalBytes: bytes.byteLength
+  });
+  while (retained.size > MAX_RETAINED_TASK_OUTPUTS) {
+    const oldest = retained.keys().next().value;
+    if (oldest === undefined)
+      break;
+    removeCopy(retained.get(oldest));
+    retained.delete(oldest);
+  }
+}
+function retainedTaskOutput(ownerId, taskId) {
+  return retained.get(retentionKey(ownerId, taskId));
+}
+
 // dist/builtin/subagents/src/runs/foreground/task-execution.ts
 function subagentTaskResultLabel(result) {
   return result.kind === "cancelled" && result.cause === "user" ? "killed (non-resumable)" : result.kind;
@@ -13421,6 +13551,69 @@ function subagentTaskResponseText(response) {
   return `${killed.length ? `${killed.length} killed. These children cannot be resumed. Underlying host response:
 ` : ""}${JSON.stringify(response)}`;
 }
+function settledOutputsFromResponse(response) {
+  const outcomes = response.kind === "parallel" ? response.slots.map((slot) => slot.outcome) : [response];
+  return outcomes.flatMap((outcome) => outcome.kind === "admitted" && outcome.observation.kind === "settled" ? [{ taskId: outcome.observation.taskId, result: outcome.observation.result }] : []);
+}
+function settledOutputsFromRecords(records) {
+  return records.flatMap((record) => record.execution.kind === "settled" ? [{ taskId: record.ref.taskId, result: record.execution.result }] : []);
+}
+function settledOutputSection(taskId, label, output) {
+  const truncated = output.shown < output.total ? `, first ${output.shown} shown${output.path ? "; read the full output file for the rest" : ""}` : "";
+  const lines = [`Output of ${taskId} (${label}, ${output.total} bytes${truncated}):`];
+  if (output.requestedPath)
+    lines.push(`Requested output: ${output.requestedPath}`);
+  if (output.saveError)
+    lines.push(`Output file error: ${output.saveError}`);
+  if (output.path)
+    lines.push(`Full output: ${output.path}`);
+  lines.push(output.head);
+  return lines.join(`
+`);
+}
+async function readSettledOutput(host, settled) {
+  const output = settled.result.output;
+  if (!output)
+    return;
+  const label = subagentTaskResultLabel(settled.result);
+  const kept = retainedTaskOutput(output.ownerId, output.taskId);
+  if (kept) {
+    return settledOutputSection(settled.taskId, label, {
+      ...kept,
+      shown: Math.min(kept.totalBytes, INLINE_TASK_OUTPUT_MAX_BYTES),
+      total: kept.totalBytes
+    });
+  }
+  const unavailable = (reason) => `Output of ${settled.taskId} (${label}) is unavailable: ${reason}`;
+  const lease = host.resolveTask(settled.taskId);
+  if (!lease.ok)
+    return unavailable(lease.error.message);
+  try {
+    const page = await host.ownerBinding.supervisor.readTaskOutput(lease.value, {
+      start: "0",
+      maximumBytes: INLINE_TASK_OUTPUT_MAX_BYTES
+    });
+    if (!page.ok)
+      return unavailable(page.error.message);
+    const decoder = new TextDecoder;
+    const head = page.value.chunks.map((chunk) => decoder.decode(chunk.bytes, { stream: true })).join("") + decoder.decode();
+    const shown = page.value.chunks.reduce((sum, chunk) => sum + chunk.bytes.byteLength, 0);
+    return settledOutputSection(settled.taskId, label, { head, shown, total: Number(output.byteCount) });
+  } catch (error) {
+    return unavailable(error instanceof Error ? error.message : String(error));
+  }
+}
+async function settledTaskOutputText(host, settled) {
+  if (!host || settled.length === 0)
+    return "";
+  const sections = await Promise.all(settled.map((entry) => readSettledOutput(host, entry)));
+  const present = sections.filter((section) => section !== undefined);
+  return present.length ? `
+
+${present.join(`
+
+`)}` : "";
+}
 function taskToolResult(response, host) {
   return {
     content: [{ type: "text", text: subagentTaskResponseText(response) }],
@@ -13433,6 +13626,16 @@ function taskToolResult(response, host) {
     ...response.kind === "unstarted" ? { isError: true } : {}
   };
 }
+async function taskToolResultWithOutput(response, host) {
+  const result = taskToolResult(response, host);
+  const outputText = await settledTaskOutputText(host, settledOutputsFromResponse(response));
+  if (!outputText)
+    return result;
+  return {
+    ...result,
+    content: [{ type: "text", text: `${subagentTaskResponseText(response)}${outputText}` }]
+  };
+}
 function taskResponseRecords(response, host) {
   const outcomes = response.kind === "parallel" ? response.slots.map((slot) => slot.outcome) : [response];
   const ids = new Set(outcomes.flatMap((outcome) => outcome.kind === "admitted" ? [outcome.observation.taskId] : []));
@@ -13505,6 +13708,7 @@ async function runAgentTask(input) {
           });
         input.onTerminal?.(child);
         const text = input.outputText?.(child) ?? getSingleResultOutput(child);
+        retainTaskOutput(child, text, context.ref);
         const bytes = Buffer.from(text);
         context.reportActivity({
           reportId: "terminal-output",
@@ -13664,7 +13868,7 @@ async function runForegroundParallelTasks(input) {
     }
     const agentConfig = input.agentConfigs?.[index] ?? input.agents.find((agent) => agent.name === task.agent);
     const taskAgents = input.agentConfigs && agentConfig ? [agentConfig] : input.agents;
-    const sharedProgress = index === input.behaviors.findIndex((candidate) => candidate.progress) ? join18(input.paramsCwd, "progress.md") : undefined;
+    const sharedProgress = index === input.behaviors.findIndex((candidate) => candidate.progress) ? join19(input.paramsCwd, "progress.md") : undefined;
     const runOptions = {
       getChildSessionOptions: input.ctx.getChildSessionOptions,
       resourceLoaderInheritanceSnapshot: input.resourceLoaderInheritanceSnapshot,
@@ -14319,6 +14523,7 @@ async function runParallelPath(data, deps) {
           agent: agentConfigs[index],
           task: task.task,
           modelConstraints: task.modelConstraints,
+          taskNeeds: task.taskNeeds,
           signal: routing.signal
         }) : undefined)),
         cancelled.promise
@@ -14442,7 +14647,12 @@ async function runParallelPath(data, deps) {
       };
       worktreeCleanupDeferred = detachedCleanup.defer(response.slots.flatMap(({ ordinal, outcome }) => outcome.kind === "admitted" && outcome.observation.kind === "yielded" ? [ordinal] : []));
       return {
-        content: [{ type: "text", text: subagentTaskResponseText(response) }],
+        content: [
+          {
+            type: "text",
+            text: `${subagentTaskResponseText(response)}${await settledTaskOutputText(ctx.getAgentTaskHost(), settledOutputsFromResponse(response))}`
+          }
+        ],
         details: {
           mode: "parallel",
           results: [],
@@ -14530,8 +14740,8 @@ ${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 { existsSync as existsSync15, statSync as statSync9 } from "node:fs";
+import { join as join20 } from "node:path";
 
 // dist/builtin/subagents/src/runs/shared/model-candidate-filter.ts
 function providerFromModel(model) {
@@ -14841,7 +15051,7 @@ async function runSingleInProcess(runtimeCwd, agent, task, options) {
   const cwd = options.cwd ?? runtimeCwd;
   if (!existsSync15(cwd))
     return refusedResult(agent, task, `cwd does not exist: ${cwd}`);
-  if (!statSync8(cwd).isDirectory())
+  if (!statSync9(cwd).isDirectory())
     return refusedResult(agent, task, `cwd is not a directory: ${cwd}`);
   options.modelRoute?.assertCurrent();
   const seenModels = new Set;
@@ -14871,6 +15081,7 @@ async function runSingleInProcess(runtimeCwd, agent, task, options) {
   if (options.modelRoute && !resolvedCandidate)
     throw new Error("Subagent auto-selected model could not be resolved before execution. Retry explicitly with the current catalog.");
   const orchestrationContext = workflowOrchestrationContext(options);
+  const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
   const parent = {
     path: options.runId,
     depth: options.parentDepth ?? 0,
@@ -14880,7 +15091,7 @@ async function runSingleInProcess(runtimeCwd, agent, task, options) {
     ...options.workflowStageSubagentGuard === undefined ? {} : { workflowStageSubagentGuard: options.workflowStageSubagentGuard },
     ...orchestrationContext ? { orchestrationContext } : {}
   };
-  const sessionRoot = options.sessionDir ?? join19(options.artifactsDir ?? cwd, ".atomic", "subagents");
+  const sessionRoot = options.sessionDir ?? join20(options.artifactsDir ?? cwd, ".atomic", "subagents");
   const control = getOrCreateSubagentControl(parent, sessionRoot);
   control.registerAgents([agent]);
   const artifactsDir = options.artifactsDir && options.artifactConfig?.enabled !== false ? options.artifactsDir : undefined;
@@ -15020,6 +15231,7 @@ ${task}`);
         recovered.envelope = delivered.envelope;
         recovered.finalOutput = delivered.envelope;
       }
+      persistRequestedOutput(recovered, options, outputSnapshot);
       options.onDetachedExit?.(recovered);
     });
     const continuedModel = running.currentModel ?? candidate;
@@ -15082,6 +15294,7 @@ ${task}`);
     result.envelope = delivered.envelope;
     result.finalOutput = delivered.envelope;
   }
+  persistRequestedOutput(result, options, outputSnapshot);
   const update = {
     content: [{ type: "text", text: result.finalOutput ?? "(no output)" }],
     details: {
@@ -15094,6 +15307,18 @@ ${task}`);
   options.onUpdate?.(update);
   return result;
 }
+function persistRequestedOutput(result, options, outputSnapshot) {
+  result.outputMode = options.outputMode ?? "inline";
+  if (!options.outputPath || result.status !== "ok")
+    return;
+  const resolved = resolveSingleOutput(options.outputPath, result.finalOutput ?? "", outputSnapshot);
+  result.savedOutputPath = resolved.savedPath;
+  result.outputSaveError = resolved.saveError;
+  if (!resolved.savedPath)
+    return;
+  result.outputReference = formatSavedOutputReference(resolved.savedPath, resolved.fullOutput);
+  result.finalOutput = result.outputMode === "file-only" ? result.outputReference.message : resolved.fullOutput;
+}
 async function runSync(runtimeCwd, agents, agentName, task, options) {
   const agent = agents.find((candidate) => candidate.name === agentName);
   if (!agent)
@@ -15130,7 +15355,7 @@ function resolveSubagentExecutorRuntimeDeps(overrides) {
 }
 
 // dist/builtin/subagents/src/runs/foreground/subagent-executor-single.ts
-import * as fs18 from "node:fs";
+import * as fs19 from "node:fs";
 import * as path20 from "node:path";
 function formatFailedSingleRunOutput(result, displayOutput) {
   const error = result.error || "Failed";
@@ -15149,7 +15374,7 @@ function cleanupTransientProgress(progressDir, artifactsEnabled) {
   if (!progressDir || artifactsEnabled)
     return;
   try {
-    fs18.rmSync(progressDir, { recursive: true, force: true });
+    fs19.rmSync(progressDir, { recursive: true, force: true });
   } catch {}
 }
 function createForwardSingleUpdate(onUpdate, foregroundControl, agent, index) {
@@ -15212,6 +15437,7 @@ async function runSinglePath(data, deps) {
     agent: agentConfig,
     task: params.task,
     modelConstraints: params.modelConstraints,
+    taskNeeds: params.taskNeeds,
     signal
   }) : undefined;
   const modelOverride = modelRoute?.modelOverride ?? resolveModelCandidate(effectiveModel, availableModels, currentProvider);
@@ -15344,7 +15570,7 @@ async function runSinglePath(data, deps) {
         }) : getSingleResultOutput(child)
       });
       if (!parentAsk || !settledChild?.interrupted)
-        return taskToolResult(response, ctx.getAgentTaskHost());
+        return await taskToolResultWithOutput(response, ctx.getAgentTaskHost());
       r = settledChild;
     } else
       r = await deps.runtime.runSync(ctx.cwd, agents, params.agent, task, runOptions);
@@ -15516,12 +15742,15 @@ async function handleManagementRequest(input) {
   }
   if (action === "wait") {
     const observed = ctx.getAgentTaskHost && params.id !== undefined ? await ctx.getAgentTaskHost().waitForTask(params.id, params.budgetMs) : { ok: false, error: { code: "UnknownTask", message: "Task not found in this owner" } };
+    const settledOutput = observed.ok && observed.value.kind === "settled" ? await settledTaskOutputText(ctx.getAgentTaskHost?.(), [
+      { taskId: observed.value.taskId, result: observed.value.result }
+    ]) : "";
     return {
       content: [
         {
           type: "text",
           text: `${observed.ok && observed.value.kind === "settled" && subagentTaskResultLabel(observed.value.result) === "killed (non-resumable)" ? `Killed. This child cannot be resumed. Underlying host observation:
-` : ""}${JSON.stringify(observed.ok ? observed.value : observed.error)}`
+` : ""}${JSON.stringify(observed.ok ? observed.value : observed.error)}${settledOutput}`
         }
       ],
       details: {
@@ -15553,13 +15782,14 @@ async function handleManagementRequest(input) {
       if (watched.ok) {
         const records = watched.value.snapshot.tasks.filter((task) => task.ref.taskId === taskId);
         watched.value.dispose();
+        const settledOutput = action === "status" ? await settledTaskOutputText(host, settledOutputsFromRecords(records)) : "";
         return {
           content: [
             {
               type: "text",
               text: `${records.some((task) => task.execution.kind === "settled" && subagentTaskResultLabel(task.execution.result) === "killed (non-resumable)") ? `Killed. This child cannot be resumed. Underlying host records:
 ` : action === "kill" ? `Kill requested. This child cannot be resumed. Underlying host records:
-` : ""}${JSON.stringify(records)}`
+` : ""}${JSON.stringify(records)}${settledOutput}`
             }
           ],
           details: { mode: "management", results: [], taskRecords: records }
@@ -17238,13 +17468,13 @@ function renderSubagentResult(result, options, theme) {
   return appendParentAskOutput(c, handoffOutput, theme);
 }
 // dist/builtin/subagents/src/extension/config.ts
-import * as fs19 from "node:fs";
+import * as fs20 from "node:fs";
 import { getAgentConfigPaths as getAgentConfigPaths5 } from "@bastani/atomic";
 function loadConfig() {
   for (const configPath of getAgentConfigPaths5("extensions", "subagent", "config.json")) {
     try {
-      if (fs19.existsSync(configPath)) {
-        return JSON.parse(fs19.readFileSync(configPath, "utf-8"));
+      if (fs20.existsSync(configPath)) {
+        return JSON.parse(fs20.readFileSync(configPath, "utf-8"));
       }
     } catch (error) {
       console.error(`Failed to load subagent config from '${configPath}':`, error);
@@ -17406,6 +17636,7 @@ var TaskItem = Type.Object({
     description: "Concrete model override, or 'auto' to select an available model and effort for this task."
   })),
   modelConstraints: Type.Optional(ModelConstraintsSchema),
+  taskNeeds: Type.Optional(TaskNeedsSchema),
   skill: Type.Optional(SkillOverride),
   group: Type.Optional(GroupSchema)
 });
@@ -17499,7 +17730,8 @@ var SubagentParams = Type.Object({
   model: Type.Optional(Type.String({
     description: "Concrete model override, or 'auto' to select an available model and effort for this task."
   })),
-  modelConstraints: Type.Optional(ModelConstraintsSchema)
+  modelConstraints: Type.Optional(ModelConstraintsSchema),
+  taskNeeds: Type.Optional(TaskNeedsSchema)
 }, { additionalProperties: false });
 
 // dist/builtin/subagents/src/extension/tool-description.ts
@@ -17674,11 +17906,11 @@ function getApiScopedSet(pi, key) {
 import * as path22 from "node:path";
 
 // dist/builtin/subagents/src/runs/inprocess/runtime-support/temp-cleanup.ts
-import * as fs20 from "node:fs";
+import * as fs21 from "node:fs";
 import * as path21 from "node:path";
 var SUBAGENT_RUNTIME_TEMP_DIR = path21.join(TEMP_ROOT_DIR, "nested-subagent-events");
 function hasEntryNewerThan(filePath, cutoff) {
-  const stat = fs20.statSync(filePath);
+  const stat = fs21.statSync(filePath);
   if (stat.mtimeMs >= cutoff)
     return true;
   if (!stat.isDirectory())
@@ -17688,14 +17920,14 @@ function hasEntryNewerThan(filePath, cutoff) {
 function directoryHasEntryNewerThan(dirPath, cutoff) {
   let entries;
   try {
-    entries = fs20.readdirSync(dirPath);
+    entries = fs21.readdirSync(dirPath);
   } catch {
     return false;
   }
   for (const entry of entries) {
     const childPath = path21.join(dirPath, entry);
     try {
-      const stat = fs20.statSync(childPath);
+      const stat = fs21.statSync(childPath);
       if (stat.mtimeMs >= cutoff)
         return true;
       if (stat.isDirectory() && directoryHasEntryNewerThan(childPath, cutoff))
@@ -17707,7 +17939,7 @@ function directoryHasEntryNewerThan(dirPath, cutoff) {
 function cleanupOldSubdirectories(root, maxAgeDays) {
   let entries;
   try {
-    entries = fs20.readdirSync(root);
+    entries = fs21.readdirSync(root);
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -17718,7 +17950,7 @@ function cleanupOldSubdirectories(root, maxAgeDays) {
     const entryPath = path21.join(root, entry);
     try {
       if (!hasEntryNewerThan(entryPath, cutoff))
-        fs20.rmSync(entryPath, { recursive: true, force: true });
+        fs21.rmSync(entryPath, { recursive: true, force: true });
     } catch {}
   }
 }
@@ -17823,7 +18055,7 @@ function getSubagentSessionRoot(parentSessionFile) {
     const sessionsDir = path23.dirname(parentSessionFile);
     return path23.join(sessionsDir, baseName);
   }
-  return fs21.mkdtempSync(path23.join(os8.tmpdir(), `${APP_NAME3}-subagent-session-`));
+  return fs22.mkdtempSync(path23.join(os8.tmpdir(), `${APP_NAME3}-subagent-session-`));
 }
 function expandTilde2(p) {
   return p.startsWith("~/") ? path23.join(os8.homedir(), p.slice(2)) : p;