min-agent 0.2.0 → 0.3.0

package/dist/tools/grep.js

@@ -1,8 +1,123 @@
 import { tool, jsonSchema } from "ai";
-import { execSync } from "child_process";
+import { readdir, readFile, stat } from "fs/promises";
+import { spawn } from "child_process";
+import path from "path";
 import { truncateToolOutput } from "../tool-output.js";
+const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", ".out", "coverage", ".min-agent"]);
+const MAX_RESULTS = 500;
+const MAX_FILE_BYTES = 5 * 1024 * 1024;
+const MAX_RG_OUTPUT_BYTES = 8 * 1024 * 1024;
+const WALK_CONCURRENCY = 8;
+/** Convert a simple glob like "*.ts" into an anchored regex for file names. */
+function globToRegex(glob) {
+    const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+}
+/** Fast path: shell out to ripgrep when available. Resolves null if rg is missing or fails. */
+function rgSearch(pattern, root, includeRegex, ignore) {
+    const args = [
+        "--no-heading",
+        "--line-number",
+        "-i",
+        "-e", pattern,
+        "--max-count", "1",
+        "-g", "!*.lock",
+        "--max-filesize", String(MAX_FILE_BYTES),
+    ];
+    for (const dir of ignore)
+        args.push("-g", `!${dir}/**`);
+    if (includeRegex) {
+        const glob = includeRegex.source
+            .replace(/^\^/, "")
+            .replace(/\$$/, "")
+            .replace(/\\\./g, ".")
+            .replace(/\.\*/g, "*");
+        args.push("-g", glob);
+    }
+    args.push(root);
+    return new Promise((resolve) => {
+        const child = spawn("rg", args, { stdio: ["ignore", "pipe", "pipe"] });
+        const chunks = [];
+        let total = 0;
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            finish(null);
+        }, 15000);
+        child.stdout.on("data", (chunk) => {
+            total += chunk.byteLength;
+            if (total > MAX_RG_OUTPUT_BYTES) {
+                child.kill("SIGKILL");
+                finish(null);
+                return;
+            }
+            chunks.push(chunk);
+        });
+        child.on("error", () => finish(null));
+        child.on("close", (code) => {
+            if (code === 1)
+                finish([]);
+            else if (code === 0)
+                finish(Buffer.concat(chunks).toString("utf-8").split("\n").filter(Boolean).slice(0, MAX_RESULTS));
+            else
+                finish(null);
+        });
+    });
+}
+async function walk(dir, regex, includeRegex, results) {
+    const dirQueue = [dir];
+    const worker = async () => {
+        while (dirQueue.length > 0 && results.length < MAX_RESULTS) {
+            const current = dirQueue.pop();
+            let entries;
+            try {
+                entries = await readdir(current, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            await Promise.all(entries.map(async (entry) => {
+                const full = path.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    if (!IGNORED_DIRS.has(entry.name) && results.length < MAX_RESULTS)
+                        dirQueue.push(full);
+                    return;
+                }
+                if (!entry.isFile())
+                    return;
+                if (includeRegex && !includeRegex.test(entry.name))
+                    return;
+                try {
+                    const info = await stat(full);
+                    if (info.size > MAX_FILE_BYTES)
+                        return;
+                    const content = await readFile(full, "utf-8");
+                    if (content.includes("\0"))
+                        return;
+                    const lines = content.split("\n");
+                    for (let i = 0; i < lines.length && results.length < MAX_RESULTS; i++) {
+                        if (regex.test(lines[i])) {
+                            results.push(`${path.relative(process.cwd(), full)}:${i + 1}:${lines[i]}`);
+                        }
+                    }
+                }
+                catch {
+                    // unreadable file — skip
+                }
+            }));
+        }
+    };
+    await Promise.all(Array.from({ length: WALK_CONCURRENCY }, worker));
+}
 export const grepTool = tool({
-    description: "Search for a pattern in files using grep. Returns matching lines with file paths and line numbers. Use this to find code references, usages, and definitions.",
+    description: "Search for a pattern in files using regex. Returns matching lines with file paths and line numbers. Use this to find code references, usages, and definitions.",
     inputSchema: jsonSchema({
         type: "object",
         properties: {
@@ -13,22 +128,39 @@ export const grepTool = tool({
         required: ["pattern"],
     }),
     execute: async ({ pattern, path: searchPath, include }) => {
-        const target = searchPath ?? ".";
-        const includeFlag = include ? `--include='${include}'` : "";
-        const cmd = `grep -rn ${includeFlag} --color=never -E '${pattern.replace(/'/g, "'\\''")}' '${target}' 2>/dev/null | head -50`;
         try {
-            const output = execSync(cmd, {
-                encoding: "utf-8",
-                cwd: process.cwd(),
-                timeout: 10000,
-                maxBuffer: 512 * 1024,
-            });
-            const text = output.trim() || "No matches found";
+            const regex = new RegExp(pattern);
+            const includeRegex = include ? globToRegex(include) : null;
+            const root = path.resolve(process.cwd(), searchPath ?? ".");
+            const results = [];
+            const info = await stat(root).catch(() => null);
+            if (!info)
+                return `Error: path not found: ${searchPath ?? "."}`;
+            if (info.isFile()) {
+                try {
+                    const content = await readFile(root, "utf-8");
+                    if (!content.includes("\0")) {
+                        content.split("\n").forEach((line, i) => {
+                            if (regex.test(line))
+                                results.push(`${root}:${i + 1}:${line}`);
+                        });
+                    }
+                }
+                catch { }
+            }
+            else {
+                const rgResults = await rgSearch(pattern, root, includeRegex, [...IGNORED_DIRS]);
+                if (rgResults !== null) {
+                    results.push(...rgResults);
+                }
+                else {
+                    await walk(root, regex, includeRegex, results);
+                }
+            }
+            const text = results.length > 0 ? results.join("\n") : "No matches found";
             return truncateToolOutput(text, { direction: "head" }).content;
         }
         catch (err) {
-            if (err.status === 1)
-                return "No matches found";
             return `Error: ${err.message}`;
         }
     },

package/dist/tools/index.js

@@ -2,6 +2,7 @@ import { bashTool } from "./bash.js";
 import { readTool } from "./read.js";
 import { writeTool } from "./write.js";
 import { editTool } from "./edit.js";
+import { applyPatchTool } from "./apply_patch.js";
 import { globTool } from "./glob.js";
 import { grepTool } from "./grep.js";
 import { webSearchTool } from "./web_search.js";
@@ -16,24 +17,27 @@ export function createChatTools() {
         read: readTool,
         write: writeTool,
         edit: editTool,
+        apply_patch: applyPatchTool,
         glob: globTool,
         grep: grepTool,
-        web_search: webSearchTool,
+        search_web: webSearchTool,
         web_fetch: webFetchTool,
+        todo: todoTool,
         question: questionTool,
     };
     return tools;
 }
-/** Code mode: full tool set including task tracking and code search */
+/** Code mode: full tool set including task tracking and code search. Todo replaced per-run by the caller. */
 export function createCodeTools() {
     const tools = {
         bash: bashTool,
         read: readTool,
         write: writeTool,
         edit: editTool,
+        apply_patch: applyPatchTool,
         glob: globTool,
         grep: grepTool,
-        web_search: webSearchTool,
+        search_web: webSearchTool,
         web_fetch: webFetchTool,
         todo: todoTool,
         question: questionTool,
@@ -43,7 +47,3 @@ export function createCodeTools() {
     }
     return tools;
 }
-/** @deprecated Use createChatTools or createCodeTools */
-export function createTools() {
-    return createChatTools();
-}

package/dist/tools/question.js

@@ -1,5 +1,5 @@
 import { tool, jsonSchema } from "ai";
-import readline from "readline";
+import { askQuestion } from "../confirm.js";
 export const questionTool = tool({
     description: `Ask the user a question to get clarification before proceeding. Use this when:
 - The task is ambiguous and you need more information
@@ -21,15 +21,9 @@ Provide clear, specific questions. Optionally include numbered options for the u
         required: ["question"],
     }),
     execute: async ({ question, options }) => {
-        console.log();
-        console.log(`\x1b[33m❓ ${question}\x1b[0m`);
-        if (options && options.length > 0) {
-            for (let i = 0; i < options.length; i++) {
-                console.log(`\x1b[90m   ${i + 1}. ${options[i]}\x1b[0m`);
-            }
-        }
-        const answer = await askUser();
-        // If user picked a number and options exist, resolve it
+        const answer = await askQuestion(question, options);
+        if (answer === null)
+            return "User cancelled the question";
         if (options && options.length > 0) {
             const idx = parseInt(answer) - 1;
             if (idx >= 0 && idx < options.length) {
@@ -39,15 +33,3 @@ Provide clear, specific questions. Optionally include numbered options for the u
         return `User answered: ${answer}`;
     },
 });
-function askUser() {
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.question("\x1b[36m   → \x1b[0m", (answer) => {
-            rl.close();
-            resolve(answer.trim() || "(no answer)");
-        });
-    });
-}

package/dist/tools/read.js

@@ -1,10 +1,58 @@
 import { tool, jsonSchema } from "ai";
-import { readFileSync, statSync } from "fs";
+import { createReadStream } from "fs";
+import { stat, readFile } from "fs/promises";
+import { createInterface } from "readline";
 import path from "path";
-import { truncateToolOutput } from "../tool-output.js";
+import { TOOL_OUTPUT_MAX_BYTES, truncateToolOutput } from "../tool-output.js";
 import { InstructionTracker } from "../instructions.js";
 // Shared tracker instance for context-aware instruction discovery
 const instructionTracker = new InstructionTracker();
+/** Files above this size are streamed instead of loaded into memory. */
+const STREAM_THRESHOLD_BYTES = 20 * 1024 * 1024;
+/** Stream lines [start, end] (1-indexed, inclusive) without loading the whole file. */
+function readLineRange(filePath, start, end) {
+    return new Promise((resolve, reject) => {
+        const lines = [];
+        const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+        let i = 0;
+        rl.on("line", (line) => {
+            i++;
+            if (i >= start && i <= end)
+                lines.push(line);
+            if (i > end)
+                rl.close();
+        });
+        rl.on("close", () => resolve(lines.join("\n")));
+        rl.on("error", reject);
+    });
+}
+/** Stream the first maxBytes of a file, cut on a UTF-8 safe boundary. */
+function readStreamHead(filePath, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        let truncated = false;
+        let totalLines = 0;
+        const stream = createReadStream(filePath);
+        stream.on("data", (chunk) => {
+            const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+            total += buf.byteLength;
+            if (total > maxBytes) {
+                const keep = buf.byteLength - (total - maxBytes);
+                chunks.push(buf.subarray(0, keep));
+                truncated = true;
+                stream.destroy();
+                return;
+            }
+            chunks.push(buf);
+        });
+        stream.on("close", () => {
+            totalLines = Buffer.concat(chunks).toString("utf-8").split("\n").length;
+            resolve({ text: Buffer.concat(chunks).toString("utf-8"), truncated, totalLines });
+        });
+        stream.on("error", reject);
+    });
+}
 export const readTool = tool({
     description: "Read the contents of a file. Returns the file content as text. Use this to understand code, check configurations, etc.",
     inputSchema: jsonSchema({
@@ -19,19 +67,31 @@ export const readTool = tool({
     execute: async ({ filePath, startLine, endLine }) => {
         const resolved = path.resolve(process.cwd(), filePath);
         try {
-            const stat = statSync(resolved);
-            if (stat.isDirectory())
+            const info = await stat(resolved);
+            if (info.isDirectory())
                 return `Error: ${filePath} is a directory, not a file`;
-            const content = readFileSync(resolved, "utf-8");
+            if (info.size > STREAM_THRESHOLD_BYTES && !startLine && !endLine) {
+                const { text, truncated, totalLines } = await readStreamHead(resolved, TOOL_OUTPUT_MAX_BYTES);
+                let result = text;
+                if (truncated) {
+                    result += `\n\n...(file too large: ${info.size} bytes, ${totalLines}+ lines — use startLine/endLine to read specific ranges)...`;
+                }
+                return result;
+            }
             let result;
-            if (startLine || endLine) {
-                const lines = content.split("\n");
-                const start = (startLine ?? 1) - 1;
-                const end = endLine ?? lines.length;
-                result = lines.slice(start, end).join("\n");
+            if (startLine != null || endLine != null) {
+                const start = startLine ?? 1;
+                const end = endLine ?? Number.MAX_SAFE_INTEGER;
+                if (start < 1)
+                    return `Error: startLine must be >= 1`;
+                if (endLine != null && end < start)
+                    return `Error: endLine (${end}) must be >= startLine (${start})`;
+                result = await readLineRange(resolved, start, end);
+                if (!result)
+                    return `Error: no lines found in range ${start}-${end}`;
             }
             else {
-                result = content;
+                result = await readFile(resolved, "utf-8");
             }
             // Context-aware: discover nearby instruction files
             const nearbyInstructions = instructionTracker.resolveForFile(resolved);

package/dist/tools/task.js

@@ -1,8 +1,8 @@
 import { tool, jsonSchema, streamText, stepCountIs } from "ai";
 import { resolveModel } from "../provider.js";
-import { createTools } from "./index.js";
+import { createCodeTools } from "./index.js";
 import { getMcpTools } from "../mcp.js";
-import { getSkillsTool, getSkills } from "../skills.js";
+import { attachSkills } from "../skills.js";
 import { loadPluginTools } from "../plugins.js";
 import { DoomLoopDetector } from "../doom-loop.js";
 import { stripThinkingFromAssistantText } from "../assistant-stream.js";
@@ -19,7 +19,7 @@ Rules:
 Working directory: ${process.cwd()}
 Platform: ${process.platform}
 Date: ${new Date().toDateString()}`;
-export function createTaskTool(modelId) {
+export function createTaskTool(modelId, abortSignal, onUsage) {
     return tool({
         description: `Launch a sub-agent to execute a task independently. The sub-agent has its own context and tools. Use this for:
 - Parallel execution: call multiple tasks at once for independent work
@@ -37,42 +37,48 @@ Call multiple tasks in parallel when the work is independent.`,
             required: ["description", "prompt"],
         }),
         execute: async ({ description, prompt }) => {
-            console.log(`\x1b[90m  ┌─ Sub-agent: ${description}\x1b[0m`);
+            console.error(`\x1b[90m  ┌─ Sub-agent: ${description}\x1b[0m`);
             try {
-                const result = await runSubAgent(prompt, modelId);
-                console.log(`\x1b[90m  └─ ✓ Done\x1b[0m`);
-                return truncateToolOutput(result, { direction: "head" }).content;
+                const result = await runSubAgent(prompt, modelId, abortSignal);
+                if (result.usage)
+                    onUsage?.(result.usage);
+                console.error(`\x1b[90m  └─ ✓ Done\x1b[0m`);
+                return truncateToolOutput(result.text, { direction: "head" }).content;
             }
             catch (err) {
-                console.log(`\x1b[90m  └─ ✗ Failed: ${err.message}\x1b[0m`);
+                if (abortSignal?.aborted)
+                    return "Sub-agent cancelled by user.";
+                console.error(`\x1b[90m  └─ ✗ Failed: ${err.message}\x1b[0m`);
                 return `Sub-agent error: ${err.message}`;
             }
         },
     });
 }
-async function runSubAgent(prompt, modelId) {
+async function runSubAgent(prompt, modelId, abortSignal) {
     const model = resolveModel(modelId);
-    // Build tools for sub-agent (no task tool to prevent recursion)
-    const builtinTools = createTools();
+    // Build tools for sub-agent (code-mode tool set, minus recursion-prone tools)
+    const builtinTools = createCodeTools();
     const mcpTools = getMcpTools();
     const pluginTools = await loadPluginTools();
-    const skills = getSkills();
     const allTools = { ...builtinTools, ...pluginTools };
     for (const [id, t] of Object.entries(mcpTools))
         allTools[id] = t;
-    if (skills.length > 0)
-        allTools["skill"] = getSkillsTool();
-    // Remove task tool from sub-agent to prevent infinite recursion
+    const skillsPrompt = attachSkills(allTools);
+    // Remove task/explore tools from sub-agent to prevent infinite recursion
     delete allTools["task"];
+    delete allTools["explore"];
     const messages = [{ role: "user", content: prompt }];
     const doomLoop = new DoomLoopDetector();
+    const controller = new AbortController();
+    const signal = abortSignal ? AbortSignal.any([abortSignal, controller.signal]) : controller.signal;
     const result = streamText({
         model,
-        system: SUB_AGENT_SYSTEM,
+        system: skillsPrompt ? `${SUB_AGENT_SYSTEM}\n\n${skillsPrompt}` : SUB_AGENT_SYSTEM,
         messages,
         tools: allTools,
         stopWhen: stepCountIs(SUB_AGENT_MAX_STEPS),
         maxRetries: 2,
+        abortSignal: signal,
         onError() { },
     });
     let assistantText = "";
@@ -83,16 +89,23 @@ async function runSubAgent(prompt, modelId) {
                 break;
             case "tool-call":
                 if (doomLoop.record(event.toolName, event.input)) {
-                    return assistantText + "\n\n[Sub-agent stopped: doom loop detected]";
+                    controller.abort();
+                    return { text: assistantText + "\n\n[Sub-agent stopped: doom loop detected]" };
                 }
-                console.log(`\x1b[90m  │ ⚡ ${event.toolName}\x1b[0m`);
+                console.error(`\x1b[90m  │ ⚡ ${event.toolName}\x1b[0m`);
                 break;
             case "tool-result":
                 break;
             case "error":
-                return assistantText + `\n\n[Sub-agent error: ${event.error}]`;
+                controller.abort();
+                return { text: assistantText + `\n\n[Sub-agent error: ${event.error}]` };
         }
     }
     const cleaned = stripThinkingFromAssistantText(assistantText);
-    return cleaned || "(sub-agent produced no output)";
+    let usage;
+    try {
+        usage = await result.usage;
+    }
+    catch { }
+    return { text: cleaned || "(sub-agent produced no output)", usage };
 }

package/dist/tools/todo.js

@@ -1,43 +1,40 @@
 import { tool, jsonSchema } from "ai";
-let todos = [];
-let nextId = 1;
-export function getTodos() {
-    return todos;
-}
-export function resetTodos() {
-    todos = [];
-    nextId = 1;
-}
-function formatTodos() {
-    if (todos.length === 0)
-        return "No tasks.";
-    const icons = {
-        pending: "○",
-        in_progress: "◐",
-        done: "●",
-        cancelled: "✕",
+export const TODO_STATUSES = ["pending", "in_progress", "done", "cancelled"];
+/** Create an isolated todo tool for one agent run. */
+export function createTodoTool(opts) {
+    const silent = opts?.silent ?? false;
+    let todos = [];
+    let nextId = 1;
+    const formatTodos = () => {
+        if (todos.length === 0)
+            return "No tasks.";
+        const icons = {
+            pending: "○",
+            in_progress: "◐",
+            done: "●",
+            cancelled: "✕",
+        };
+        return todos
+            .map((t) => `  ${icons[t.status]} #${t.id} ${t.text}`)
+            .join("\n");
     };
-    return todos
-        .map((t) => `  ${icons[t.status]} #${t.id} ${t.text}`)
-        .join("\n");
-}
-function printTodos() {
-    if (todos.length === 0)
-        return;
-    console.log(`\x1b[90m  ┌─ Tasks${"─".repeat(36)}\x1b[0m`);
-    for (const t of todos) {
-        const icon = t.status === "done" ? "\x1b[32m●\x1b[0m"
-            : t.status === "in_progress" ? "\x1b[33m◐\x1b[0m"
-                : t.status === "cancelled" ? "\x1b[90m✕\x1b[0m"
-                    : "\x1b[90m○\x1b[0m";
-        const dim = t.status === "done" || t.status === "cancelled" ? "\x1b[90m" : "";
-        const reset = dim ? "\x1b[0m" : "";
-        console.log(`\x1b[90m  │\x1b[0m ${icon} ${dim}#${t.id} ${t.text}${reset}`);
-    }
-    console.log(`\x1b[90m  └${"─".repeat(44)}\x1b[0m`);
-}
-export const todoTool = tool({
-    description: `Create or update tasks to track progress. Use this FREQUENTLY to:
+    const printTodos = () => {
+        if (silent || todos.length === 0)
+            return;
+        console.log(`\x1b[90m  ┌─ Tasks${"─".repeat(36)}\x1b[0m`);
+        for (const t of todos) {
+            const icon = t.status === "done" ? "\x1b[32m●\x1b[0m"
+                : t.status === "in_progress" ? "\x1b[33m◐\x1b[0m"
+                    : t.status === "cancelled" ? "\x1b[90m✕\x1b[0m"
+                        : "\x1b[90m○\x1b[0m";
+            const dim = t.status === "done" || t.status === "cancelled" ? "\x1b[90m" : "";
+            const reset = dim ? "\x1b[0m" : "";
+            console.log(`\x1b[90m  │\x1b[0m ${icon} ${dim}#${t.id} ${t.text}${reset}`);
+        }
+        console.log(`\x1b[90m  └${"─".repeat(44)}\x1b[0m`);
+    };
+    return tool({
+        description: `Create or update tasks to track progress. Use this FREQUENTLY to:
 - Plan multi-step work by creating tasks upfront
 - Mark tasks as in_progress when starting them
 - Mark tasks as done when completed
@@ -46,43 +43,56 @@ export const todoTool = tool({
 To create new tasks: provide items with "text" and optionally "status" (defaults to "pending").
 To update existing tasks: provide items with "id" and "status".
 You can mix creates and updates in one call.`,
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            todos: {
-                type: "array",
-                description: "List of tasks to create or update",
-                items: {
-                    type: "object",
-                    properties: {
-                        text: { type: "string", description: "Task description (for new tasks)" },
-                        status: { type: "string", description: "Status: pending, in_progress, done, cancelled" },
-                        id: { type: "number", description: "Task ID (for updating existing tasks)" },
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                todos: {
+                    type: "array",
+                    description: "List of tasks to create or update",
+                    items: {
+                        type: "object",
+                        properties: {
+                            text: { type: "string", description: "Task description (for new tasks)" },
+                            status: { type: "string", description: "Status: pending, in_progress, done, cancelled" },
+                            id: { type: "number", description: "Task ID (for updating existing tasks)" },
+                        },
                     },
                 },
             },
-        },
-        required: ["todos"],
-    }),
-    execute: async ({ todos: items }) => {
-        for (const item of items) {
-            if (item.id) {
-                // Update existing
-                const existing = todos.find((t) => t.id === item.id);
-                if (existing && item.status) {
-                    existing.status = item.status;
+            required: ["todos"],
+        }),
+        execute: async ({ todos: items }) => {
+            const errors = [];
+            for (const item of items) {
+                if (item.id != null) {
+                    const existing = todos.find((t) => t.id === item.id);
+                    if (!existing) {
+                        errors.push(`task #${item.id} not found`);
+                        continue;
+                    }
+                    if (item.status) {
+                        if (!TODO_STATUSES.includes(item.status)) {
+                            errors.push(`invalid status "${item.status}" for task #${item.id}`);
+                            continue;
+                        }
+                        existing.status = item.status;
+                    }
+                }
+                else if (item.text) {
+                    todos.push({
+                        id: nextId++,
+                        text: item.text,
+                        status: TODO_STATUSES.includes(item.status) ? item.status : "pending",
+                    });
+                }
+                else {
+                    errors.push("item needs either an id (update) or text (create)");
                 }
             }
-            else if (item.text) {
-                // Create new
-                todos.push({
-                    id: nextId++,
-                    text: item.text,
-                    status: item.status ?? "pending",
-                });
-            }
-        }
-        printTodos();
-        return formatTodos();
-    },
-});
+            printTodos();
+            return errors.length > 0 ? `${formatTodos()}\n\nWarnings: ${errors.join("; ")}` : formatTodos();
+        },
+    });
+}
+/** Shared placeholder — callers in code mode replace it with a per-run instance. */
+export const todoTool = createTodoTool();