@jerryan/pi-subagent-tools 0.1.0 → 0.3.0

package/sandbox-bash.ts

@@ -0,0 +1,148 @@
+/**
+ * Sandboxed read-only bash for review/explore child sessions.
+ *
+ * One tool replaces the former read/grep/find/ls allowlist plus the git
+ * tool's policy table: a just-bash interpreter over a composed filesystem
+ * (see createSandboxFs), with just-git providing git inside the sandbox.
+ * Read-only is enforced at the capability layer — see DESIGN.md.
+ *
+ * The `disabled` git list below is UX only (clean "not available" errors
+ * for pure mutators); enforcement is the read-only filesystem. Dual-purpose
+ * verbs (branch, tag, stash, config, remote, worktree) stay enabled so
+ * their read modes work; their write modes fail at the filesystem.
+ *
+ * Each call runs in a freshly constructed interpreter: per-call
+ * construction is the statelessness guarantee, and it avoids any
+ * shared-state questions between parallel children.
+ */
+
+import * as path from "node:path";
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Bash, InMemoryFs, MountableFs, OverlayFs, type ExecResult } from "just-bash";
+import { createGit, type GitCommandName } from "just-git";
+
+/** Pure-mutator git verbs, disabled for clean UX errors. FS enforces the rest. */
+const DISABLED_GIT: GitCommandName[] = [
+  "init",
+  "add",
+  "commit",
+  "checkout",
+  "switch",
+  "restore",
+  "reset",
+  "merge",
+  "cherry-pick",
+  "revert",
+  "rebase",
+  "mv",
+  "rm",
+  "clean",
+  "bisect",
+  "gc",
+  "repack",
+];
+
+/** Mount point of the project root inside the sandbox. */
+const MOUNT_POINT = "/repo";
+
+/**
+ * Compose the sandbox filesystem: the project root mounted read-only at
+ * /repo over a writable in-memory base. The base provides working /dev/null
+ * (stderr silencing is a core shell idiom; on a real read-only mount the
+ * device still works) and per-call in-memory scratch (/tmp, ...) that
+ * evaporates with the interpreter. Note MountableFs strips the mount
+ * prefix before delegating, so the inner OverlayFs mounts at "/".
+ */
+function createSandboxFs(projectRoot: string): MountableFs {
+  const fs = new MountableFs({ base: new InMemoryFs() });
+  fs.mount(
+    MOUNT_POINT,
+    new OverlayFs({ root: projectRoot, mountPoint: "/", readOnly: true }),
+  );
+  return fs;
+}
+
+const MAX_OUTPUT_CHARS = 50_000;
+const MAX_OUTPUT_LINES = 2_000;
+
+/**
+ * Filesystem-style error codes the sandbox can raise. just-bash reports
+ * command-level failures (touch, rm) as exit codes, but interpreter-level
+ * failures — output redirections write through the interpreter's own FS
+ * path — REJECT the exec promise with these. Both shapes mean the same
+ * thing to the caller: the command failed. Anything outside this taxonomy
+ * is a genuine interpreter bug and is rethrown, loudly.
+ */
+const FS_ERROR_PATTERN =
+  /^(EROFS|EACCES|EPERM|ENOENT|EFBIG|ENOSPC|EISDIR|ENOTDIR|ELOOP|ENOTEMPTY|EEXIST|EINVAL|EBUSY|EXDEV|EIO)\b/;
+
+function truncateOutput(output: string): string {
+  const lines = output.split("\n");
+  if (lines.length <= MAX_OUTPUT_LINES && output.length <= MAX_OUTPUT_CHARS) {
+    return output;
+  }
+  const kept = lines.slice(0, MAX_OUTPUT_LINES).join("\n").slice(0, MAX_OUTPUT_CHARS);
+  const keptLines = kept.split("\n").length;
+  return `${kept}\n\n[output truncated: showing ${keptLines} lines, ${kept.length} chars]`;
+}
+
+export const sandboxBashTool = defineTool({
+  name: "bash",
+  label: "bash (read-only)",
+  description:
+    "Run a command in a sandboxed, read-only bash environment. " +
+    "The working directory is the project root (mounted at /repo); use relative paths with forward slashes. " +
+    "Standard utilities are available (grep, find, sed, awk, head, tail, sort, uniq, wc, cat, ls, ...) " +
+    "plus git for repository inspection (log, diff, show, blame, grep, ls-files, branch/tag listing; " +
+    "note: git status is slow in large repos — prefer the targeted commands). " +
+    "The environment has no network access and the project directory is read-only by design: all writes to it fail. " +
+    "Paths outside /repo (like /tmp) are in-memory scratch, discarded after each call. " +
+    "Each call runs in a fresh shell — cd and environment variables do not persist between calls; " +
+    "use compound commands (cd dir && command) for multi-step work.",
+  promptSnippet: "Run a command in the read-only sandboxed shell",
+  promptGuidelines: [
+    "Use bash for searching, file inspection, and git history — never attempt to modify files; all writes fail by design.",
+  ],
+  parameters: Type.Object({
+    command: Type.String({
+      description:
+        "The command line to execute (e.g. 'grep -rn \"pattern\" src/', 'git log --oneline -10', 'find . -name \"*.ts\" | head').",
+    }),
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const bash = new Bash({
+      fs: createSandboxFs(path.resolve(ctx.cwd)),
+      cwd: MOUNT_POINT,
+      customCommands: [createGit({ network: false, disabled: DISABLED_GIT })],
+    });
+    const result = await execSafely(bash, params.command, signal);
+    const stdout = result.stdout;
+    const stderr = result.stderr;
+    const combined =
+      stdout && stderr ? `${stdout}\n${stderr}` : stdout || stderr || "(no output)";
+    const text =
+      result.exitCode === 0
+        ? truncateOutput(combined)
+        : `Exit code ${result.exitCode}\n${truncateOutput(combined)}`;
+    return {
+      content: [{ type: "text" as const, text }],
+      details: { exitCode: result.exitCode },
+    };
+  },
+});
+
+async function execSafely(
+  bash: Bash,
+  command: string,
+  signal?: AbortSignal,
+): Promise<ExecResult> {
+  try {
+    return await bash.exec(command, { signal });
+  } catch (err: any) {
+    if (FS_ERROR_PATTERN.test(err?.message ?? "")) {
+      return { stdout: "", stderr: err.message, exitCode: 1 };
+    }
+    throw err;
+  }
+}

package/tui.ts

@@ -39,28 +39,35 @@ export function formatTokens(n: number): string {
   return s.padStart(6);
 }
 
+/** Cap a string at max chars, replacing overflow with "...". */
+export function truncate(s: string, max: number): string {
+  return s.length > max ? s.slice(0, max - 3) + "..." : s;
+}
+
+/** Prefix marking tool-call summary lines in subagent progress text. */
+export const TOOL_LINE_PREFIX = "▸";
+
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
-export function createSpinner(): () => string {
-  let idx = 0;
-  return () => {
-    const frame = SPINNER[idx];
-    idx = (idx + 1) % SPINNER.length;
-    return frame;
-  };
+/**
+ * Time-derived spinner frame. Stateless — no per-caller state to create,
+ * leak, or clean up. All concurrent spinners share the global clock, which
+ * is visually indistinguishable from per-caller frames.
+ */
+export function spinnerFrame(): string {
+  return SPINNER[Math.floor(Date.now() / 100) % SPINNER.length];
 }
 
 export interface UsageStats {
   turns: number;
   input: number;
   output: number;
-  total: number;
   durationMs: number;
 }
 
 export function formatUsage(u: UsageStats, spin: () => string): string {
   const parts: string[] = [`${spin()} · Turn ${u.turns}`];
   parts.push(`Tokens: input ${formatTokens(u.input)} | output ${formatTokens(u.output)}`);
-  if (u.durationMs != null) parts.push(formatDuration(u.durationMs));
+  parts.push(formatDuration(u.durationMs));
   return parts.join(" · ");
 }

package/ui-bridge.ts

@@ -0,0 +1,198 @@
+/**
+ * UI bridge — presents an ExtensionUIContext to an in-process subagent
+ * session that forwards interactive prompts to the parent session's TUI.
+ *
+ * Usage:
+ *   const bridge = createUIBridge(ctx.ui, { label: "delegate" });
+ *   await childSession.bindExtensions({ uiContext: bridge, mode: "rpc" });
+ *
+ * Mode is "rpc" (not "tui") because the bridge deliberately mirrors the
+ * documented RPC degradation contract: dialogs work, terminal chrome does
+ * not. Extensions running in the child should not assume direct TUI access.
+ *
+ * Method mapping
+ * ──────────────
+ * Dialogs (serialized through a shared queue, title prefixed with label):
+ *   select, confirm, input, editor, custom
+ *   Dialog opts (signal, timeout) pass through unchanged, so the child can
+ *   abort-dismiss and auto-dismiss exactly as documented.
+ *
+ * Fire-and-forget (forwarded):
+ *   notify        — message prefixed with [label]
+ *   setStatus     — key namespaced as "<label>:<key>"
+ *   setWidget     — key namespaced; string arrays and component factories
+ *                   both forwarded (factories are valid in-process)
+ *
+ * Fire-and-forget (dropped — they would hijack the parent's chrome):
+ *   setTitle, setWorkingMessage, setWorkingVisible, setWorkingIndicator,
+ *   setHiddenThinkingLabel, onTerminalInput, pasteToEditor, setEditorText,
+ *   setEditorComponent, setFooter, setHeader, addAutocompleteProvider,
+ *   setToolsExpanded
+ *
+ * Reads:
+ *   theme, getAllThemes, getTheme — read-through to the parent
+ *   getToolsExpanded              — read-through
+ *   getEditorText, getEditorComponent — return "" / undefined
+ *
+ * Writes blocked:
+ *   setTheme — returns { success: false, error }
+ */
+
+import type {
+  ExtensionUIContext,
+  ExtensionWidgetOptions,
+  Theme,
+} from "@earendil-works/pi-coding-agent";
+
+export interface UIBridgeOptions {
+  /**
+   * Short name identifying the subagent (e.g. "delegate", "review").
+   * Used to prefix dialog titles and notifications, and to namespace
+   * status/widget keys so concurrent subagents don't clobber each other.
+   */
+  label: string;
+}
+
+// ---------------------------------------------------------------------------
+// Dialog serialization
+//
+// The parent TUI can only show one modal at a time. Multiple subagents may
+// request dialogs concurrently (parallel tool calls), so all dialog methods
+// across ALL bridge instances funnel through one process-wide queue.
+// ---------------------------------------------------------------------------
+
+let dialogQueue: Promise<unknown> = Promise.resolve();
+
+function enqueueDialog<T>(fn: () => Promise<T>): Promise<T> {
+  const result = dialogQueue.then(fn, fn);
+  // Keep the queue alive even if fn rejects.
+  dialogQueue = result.then(
+    () => undefined,
+    () => undefined,
+  );
+  return result;
+}
+
+/** Test hook: reset the dialog queue. Not part of the public API. */
+export function _resetDialogQueue(): void {
+  dialogQueue = Promise.resolve();
+}
+
+// ---------------------------------------------------------------------------
+// Bridge factory
+// ---------------------------------------------------------------------------
+
+export function createUIBridge(
+  parent: ExtensionUIContext,
+  options: UIBridgeOptions,
+): ExtensionUIContext {
+  const { label } = options;
+  const tag = `[${label}]`;
+  const titled = (title: string) => `${tag} ${title}`;
+  const keyed = (key: string) => `${label}:${key}`;
+
+  const noop = () => {};
+  const noopUnsubscribe = () => noop;
+
+  const bridge: ExtensionUIContext = {
+    // --- Dialogs (serialized, forwarded) ----------------------------------
+
+    select(title, options_, opts) {
+      return enqueueDialog(() => parent.select(titled(title), options_, opts));
+    },
+
+    confirm(title, message, opts) {
+      return enqueueDialog(() => parent.confirm(titled(title), message, opts));
+    },
+
+    input(title, placeholder, opts) {
+      return enqueueDialog(() => parent.input(titled(title), placeholder, opts));
+    },
+
+    editor(title, prefill) {
+      return enqueueDialog(() => parent.editor(titled(title), prefill));
+    },
+
+    // Contextually typed against the generic interface signature; the
+    // explicit <T> is inferred from the ExtensionUIContext annotation.
+    custom(factory, customOptions) {
+      // In-process the factory executes against the parent's real TUI, so
+      // custom components work — unlike RPC mode, which degrades to undefined.
+      return enqueueDialog(() => parent.custom(factory, customOptions));
+    },
+
+    // --- Fire-and-forget (forwarded) ---------------------------------------
+
+    notify(message, type) {
+      parent.notify(`${tag} ${message}`, type);
+    },
+
+    setStatus(key, text) {
+      parent.setStatus(keyed(key), text);
+    },
+
+    setWidget(
+      key: string,
+      content: string[] | ((...args: any[]) => any) | undefined,
+      widgetOptions?: ExtensionWidgetOptions,
+    ) {
+      parent.setWidget(keyed(key), content as any, widgetOptions);
+    },
+
+    // --- Fire-and-forget (dropped) ------------------------------------------
+    // These manipulate the parent session's chrome (terminal title, streaming
+    // indicator, editor, footer/header). A subagent has no business touching
+    // them. Mirrors the RPC-mode degradation contract.
+
+    setTitle: noop,
+    setWorkingMessage: noop,
+    setWorkingVisible: noop,
+    setWorkingIndicator: noop,
+    setHiddenThinkingLabel: noop,
+    pasteToEditor: noop,
+    setEditorText: noop,
+    setEditorComponent: noop,
+    setFooter: noop,
+    setHeader: noop,
+    addAutocompleteProvider: noop,
+    setToolsExpanded: noop,
+    onTerminalInput: noopUnsubscribe,
+
+    // --- Reads ---------------------------------------------------------------
+
+    get theme(): Theme {
+      return parent.theme;
+    },
+
+    getAllThemes() {
+      return parent.getAllThemes();
+    },
+
+    getTheme(name) {
+      return parent.getTheme(name);
+    },
+
+    getToolsExpanded() {
+      return parent.getToolsExpanded();
+    },
+
+    getEditorText() {
+      return "";
+    },
+
+    getEditorComponent() {
+      return undefined;
+    },
+
+    // --- Writes blocked -------------------------------------------------------
+
+    setTheme() {
+      return {
+        success: false,
+        error: "Subagents cannot change the parent session's theme.",
+      };
+    },
+  };
+
+  return bridge;
+}

package/spawn.ts

@@ -1,262 +0,0 @@
-/**
- * Shared subagent spawn logic.
- */
-
-import { spawn } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { Message } from "@earendil-works/pi-ai";
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { UsageStats } from "./tui.ts";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface SpawnOptions {
-  cwd: string;
-  task: string;
-  skills?: string[];
-  allowedTools?: string[];
-  extensionFile?: string;
-  systemPromptFile?: string;
-  childRole?: "review" | "explore" | "delegate";
-  signal?: AbortSignal;
-  onUpdate?: (result: AgentToolResult) => void;
-}
-
-export interface SpawnResult {
-  output: string;
-  isError: boolean;
-  exitCode: number;
-  tokens?: { input: number; output: number; total: number };
-  turns: number;
-  toolCalls: string[];
-  durationMs: number;
-  stderr?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-export const READONLY_TOOLS = ["read", "grep", "find", "ls", "git"];
-
-// ---------------------------------------------------------------------------
-// Pi process detection
-// ---------------------------------------------------------------------------
-
-export function getPiInvocation(args: string[]): {
-  command: string;
-  args: string[];
-} {
-  const currentScript = process.argv[1];
-  if (currentScript && fs.existsSync(currentScript)) {
-    return { command: process.execPath, args: [currentScript, ...args] };
-  }
-  const npmGlobalRoot = process.env.APPDATA
-    ? path.join(process.env.APPDATA, "npm", "node_modules")
-    : process.env.HOME
-      ? path.join(process.env.HOME, ".npm-global", "node_modules")
-      : null;
-  if (npmGlobalRoot) {
-    const cliPath = path.join(npmGlobalRoot, "@earendil-works", "pi-coding-agent", "dist", "cli.js");
-    if (fs.existsSync(cliPath)) {
-      return { command: process.execPath, args: [cliPath, ...args] };
-    }
-  }
-  const execName = path.basename(process.execPath).toLowerCase();
-  const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
-  if (!isGenericRuntime) return { command: process.execPath, args };
-  return { command: "pi", args };
-}
-
-// ---------------------------------------------------------------------------
-// Argument construction
-// ---------------------------------------------------------------------------
-
-export function buildSpawnArgs(opts: SpawnOptions): string[] {
-  const args: string[] = ["--mode", "json", "-p"];
-
-  args.push("--no-session");
-
-  if (opts.allowedTools && opts.allowedTools.length > 0) {
-    args.push("--tools", opts.allowedTools.join(","));
-  }
-
-  for (const skill of opts.skills ?? []) {
-    args.push("--skill", skill);
-  }
-
-  if (opts.extensionFile) {
-    args.push("--extension", opts.extensionFile);
-  }
-
-  if (opts.systemPromptFile) {
-    args.push("--append-system-prompt", opts.systemPromptFile);
-  }
-
-  args.push(opts.task);
-  return args;
-}
-
-// ---------------------------------------------------------------------------
-// JSONL parsing
-// ---------------------------------------------------------------------------
-
-function getFinalOutput(messages: Message[]): string {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === "assistant") {
-      for (const part of msg.content) {
-        if (part.type === "text") return part.text ?? "";
-      }
-    }
-  }
-  return "";
-}
-
-// ---------------------------------------------------------------------------
-// Main spawn function
-// ---------------------------------------------------------------------------
-
-export async function runSubagent(opts: SpawnOptions): Promise<SpawnResult> {
-  const args = buildSpawnArgs(opts);
-  const invocation = getPiInvocation(args);
-
-  let buffer = "";
-  let stderr = "";
-  let spawnError: string | null = null;
-  const messages: Message[] = [];
-  let turnCount = 0;
-  let tokens = { input: 0, output: 0, total: 0 };
-  const toolCallNames: string[] = [];
-  const env: Record<string, string | undefined> = { ...process.env };
-  if (opts.childRole) env.PI_SUBAGENT_TOOLS_ROLE = opts.childRole;
-
-  const startTime = Date.now();
-
-  let previousTurnsText = "";
-  let streamText = "";
-
-  const displayText = () => previousTurnsText + (previousTurnsText && streamText ? "\n" : "") + streamText;
-  const proc = spawn(invocation.command, invocation.args, {
-    cwd: opts.cwd,
-    shell: false,
-    stdio: ["ignore", "pipe", "pipe"],
-    env,
-  });
-
-  const MAX_MSG_COUNT = 5;
-  const MAX_PREV_LINES = 20;
-
-  const trimPrev = () => {
-    const lines = previousTurnsText.split("\n");
-    if (lines.length > MAX_PREV_LINES) previousTurnsText = lines.slice(-MAX_PREV_LINES).join("\n");
-  };
-
-  let lastUpdate = 0;
-  let pendingTimer: ReturnType<typeof setTimeout> | null = null;
-  const UPDATE_INTERVAL = 200;
-
-  const doUpdate = () => {
-    if (!opts.onUpdate) return;
-    const bottom = displayText();
-    opts.onUpdate({
-      content: [{ type: "text", text: bottom }],
-      details: { usage: { turns: turnCount, input: tokens.input, output: tokens.output, total: tokens.total, durationMs: Date.now() - startTime } satisfies UsageStats, toolCalls: [...toolCallNames] },
-    });
-  };
-
-  const fireUpdate = () => {
-    if (!opts.onUpdate) return;
-    const now = Date.now();
-    if (now - lastUpdate >= UPDATE_INTERVAL) {
-      lastUpdate = now;
-      doUpdate();
-    } else if (!pendingTimer) {
-      pendingTimer = setTimeout(() => {
-        pendingTimer = null;
-        lastUpdate = Date.now();
-        doUpdate();
-      }, UPDATE_INTERVAL - (now - lastUpdate));
-    }
-  };
-
-  const processLine = (line: string) => {
-    if (!line.trim()) return;
-    let event: any;
-    try { event = JSON.parse(line); } catch { return; }
-
-    // Per-token streaming: show text on every message_update
-    if (event.type === "message_update" && event.message) {
-      const text = (event.message.content ?? [])
-        .filter((c: any) => c.type === "text" || c.type === "thinking")
-        .map((c: any) => c[c.type]).join("");
-      streamText = text;
-      fireUpdate();
-    }
-
-    if (event.type === "message_end" && event.message) {
-      const msg = event.message as Message & { content: any[] };
-      messages.push(msg);
-      if (messages.length > MAX_MSG_COUNT) messages.splice(0, messages.length - MAX_MSG_COUNT);
-      if (msg.role === "assistant") {
-        turnCount++;
-        if (msg.usage) {
-          tokens.input += msg.usage.input || 0;
-          tokens.output += msg.usage.output || 0;
-          tokens.total += msg.usage.totalTokens || 0;
-        }
-        if (streamText) {
-          previousTurnsText = previousTurnsText ? previousTurnsText + "\n" + streamText : streamText;
-          streamText = "";
-          trimPrev();
-        } else {
-          const text = (msg.content ?? []).filter((c: any) => c.type === "text" || c.type === "thinking").map((c: any) => c[c.type]).join("");
-          if (text) {
-            previousTurnsText = previousTurnsText ? previousTurnsText + "\n" + text : text;
-            trimPrev();
-          }
-        }
-        for (const tc of (msg.content ?? []).filter((c: any) => c.type === "toolCall")) {
-          toolCallNames.push(tc.name);
-          const parts = [`▸ ${tc.name}`];
-          if (tc.arguments && typeof tc.arguments === "object" && !Array.isArray(tc.arguments)) {
-            const entries = Object.entries(tc.arguments);
-            const capPerParam = entries.length > 1;
-            for (const [k, v] of entries) {
-              const val = typeof v === "string" ? v : JSON.stringify(v);
-              const short = capPerParam && val.length > 40 ? val.slice(0, 37) + "..." : val;
-              parts.push(`${k}=${short}`);
-            }
-          }
-          let line = parts.join(" ");
-          if (line.length > 80) line = line.slice(0, 77) + "...";
-          previousTurnsText = previousTurnsText ? `${previousTurnsText}\n${line}` : line;
-          trimPrev();
-        }
-        fireUpdate();
-      }
-    }
-  };
-
-  const exitCode = await new Promise<number>((resolve) => {
-    const killProc = () => { proc.kill("SIGTERM"); setTimeout(() => { if (!proc.killed) try { proc.kill("SIGKILL"); } catch { /* not supported on all platforms */ } }, 5000); };
-    if (opts.signal) {
-      if (opts.signal.aborted) killProc();
-      else opts.signal.addEventListener("abort", killProc, { once: true });
-    }
-    proc.stdout.on("data", (data) => { buffer += data.toString(); const lines = buffer.split("\n"); buffer = lines.pop() || ""; for (const line of lines) processLine(line); });
-    proc.stderr.on("data", (data) => { stderr += data.toString(); });
-    proc.on("close", (code) => { if (opts.signal) opts.signal.removeEventListener("abort", killProc); if (buffer.trim()) processLine(buffer); resolve(code ?? 1); });
-    proc.on("error", (err) => { if (opts.signal) opts.signal.removeEventListener("abort", killProc); spawnError = err.message; resolve(1); });
-  });
-
-  if (opts.signal?.aborted) return { output: "Subagent was aborted", isError: true, exitCode: 1, tokens, turns: turnCount, toolCalls: toolCallNames, durationMs: Date.now() - startTime };
-  if (spawnError) return { output: `Failed to start subagent: ${spawnError}`, isError: true, exitCode: 1, tokens, turns: turnCount, toolCalls: toolCallNames, durationMs: Date.now() - startTime };
-  if (exitCode !== 0) return { output: stderr || `Subagent exited with code ${exitCode}`, isError: true, exitCode, tokens, turns: turnCount, toolCalls: toolCallNames, durationMs: Date.now() - startTime };
-
-  const output = getFinalOutput(messages);
-  return { output: output || "(no output)", isError: false, exitCode: 0, tokens, turns: turnCount, toolCalls: toolCallNames, durationMs: Date.now() - startTime, stderr: stderr.trim() || undefined };
-}