xiaotime 0.6.0 → 0.7.0

package/dist/todos.js

@@ -0,0 +1,55 @@
+/**
+ * Task/todo tracking — SPRINT-CLI-CAPABILITY-PARITY-1 (#14608).
+ *
+ * A working-memory aid for multi-step work: the agent writes the whole
+ * task list each time (the Claude-Code TodoWrite shape — the list is
+ * state the model owns, not an append log), and the rendered checklist
+ * comes back as the tool result so it lands in the transcript for both
+ * the classic and Ink surfaces without either needing bespoke render
+ * wiring. Kept in a session-global store so a future status bar can read
+ * the current list.
+ */
+const VALID = new Set(["pending", "in_progress", "completed"]);
+let todos = [];
+/**
+ * Replace the whole list. Throws on a malformed entry so the tool
+ * surfaces a real error instead of silently storing junk.
+ */
+export function setTodos(list) {
+    if (!Array.isArray(list)) {
+        throw new Error("todos must be an array of { content, status }");
+    }
+    const next = list.map((raw, i) => {
+        const item = raw;
+        const content = typeof item?.content === "string" ? item.content.trim() : "";
+        const status = String(item?.status ?? "");
+        if (!content)
+            throw new Error(`todo #${i + 1} is missing content`);
+        if (!VALID.has(status)) {
+            throw new Error(`todo #${i + 1} has invalid status "${status}" (use pending / in_progress / completed)`);
+        }
+        return { content, status: status };
+    });
+    todos = next;
+    return todos;
+}
+export function getTodos() {
+    return todos;
+}
+export function clearTodos() {
+    todos = [];
+}
+const MARK = {
+    completed: "[x]",
+    in_progress: "[~]",
+    pending: "[ ]",
+};
+/** Render the list as a plain-text checklist (tool-result body). */
+export function renderTodos(list = todos) {
+    if (list.length === 0)
+        return "(no tasks)";
+    const done = list.filter((t) => t.status === "completed").length;
+    const lines = list.map((t) => `${MARK[t.status]} ${t.content}`);
+    return `Tasks (${done}/${list.length} done):\n${lines.join("\n")}`;
+}
+//# sourceMappingURL=todos.js.map

package/dist/todos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"todos.js","sourceRoot":"","sources":["../src/todos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AASH,MAAM,KAAK,GAAwB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC;AAEpF,IAAI,KAAK,GAAW,EAAE,CAAC;AAEvB;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAa;IACpC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,IAAI,GAAW,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE;QACvC,MAAM,IAAI,GAAG,GAA8C,CAAC;QAC5D,MAAM,OAAO,GAAG,OAAO,IAAI,EAAE,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7E,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC;QAC1C,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;QACnE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,wBAAwB,MAAM,2CAA2C,CAAC,CAAC;QAC3G,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAoB,EAAE,CAAC;IACnD,CAAC,CAAC,CAAC;IACH,KAAK,GAAG,IAAI,CAAC;IACb,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,QAAQ;IACtB,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,UAAU;IACxB,KAAK,GAAG,EAAE,CAAC;AACb,CAAC;AAED,MAAM,IAAI,GAA+B;IACvC,SAAS,EAAE,KAAK;IAChB,WAAW,EAAE,KAAK;IAClB,OAAO,EAAE,KAAK;CACf,CAAC;AAEF,oEAAoE;AACpE,MAAM,UAAU,WAAW,CAAC,OAAe,KAAK;IAC9C,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,YAAY,CAAC;IAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,WAAW,CAAC,CAAC,MAAM,CAAC;IACjE,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAChE,OAAO,UAAU,IAAI,IAAI,IAAI,CAAC,MAAM,YAAY,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;AACrE,CAAC"}

package/dist/tools.d.ts

@@ -47,4 +47,30 @@ export declare function executeTool(call: ToolCall, ui: SessionUI): Promise<Tool
 export declare function listRecursive(dir: string, pattern?: string, cap?: number): string[];
 export declare function _listDirectoryMax(): number;
 export declare function globToRegex(glob: string): RegExp;
+/** Count non-overlapping occurrences of `needle` in `hay`. */
+export declare function _countOccurrences(hay: string, needle: string): number;
+/**
+ * Replace the first literal occurrence of `needle` with `repl`.
+ * Uses index-splicing (not String.replace) so `$&`/`$1` sequences in
+ * `repl` are inserted verbatim rather than interpreted as regex
+ * back-references (#14608 — the surgical-edit correctness trap).
+ */
+export declare function _replaceFirst(hay: string, needle: string, repl: string): string;
+/**
+ * Recursively grep a directory tree. Skips dotfiles, node_modules,
+ * binary files (any NUL byte), and files larger than 2 MB. Returns
+ * `relpath:lineno:linetext` matches, capped at `cap`. Directory entries
+ * are visited in sorted order for deterministic output.
+ */
+export declare function grepTree(dir: string, regex: RegExp, glob?: string, cap?: number): {
+    matches: string[];
+    truncated: boolean;
+};
+/**
+ * Reduce an HTML document to readable text: drop script/style/comments
+ * and tags, decode the common named entities, and collapse whitespace.
+ * Intentionally minimal — enough to make a fetched page legible to the
+ * agent, not a full HTML parser.
+ */
+export declare function stripHtml(html: string): string;
 //# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAS/C,MAAM,WAAW,QAAQ;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAiBD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE;QACZ,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QACrF,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAED,eAAO,MAAM,aAAa,EAAE,iBAAiB,EAiF5C,CAAC;AAIF,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,QAExC;AACD,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAkED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,QAAQ,EACd,EAAE,EAAE,SAAS,GACZ,OAAO,CAAC,UAAU,CAAC,CAkMrB;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAyBnF;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAO1C;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOhD"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAa/C,MAAM,WAAW,QAAQ;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAiBD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE;QACZ,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QACrF,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAED,eAAO,MAAM,aAAa,EAAE,iBAAiB,EA+N5C,CAAC;AAIF,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,QAExC;AACD,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAkED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,QAAQ,EACd,EAAE,EAAE,SAAS,GACZ,OAAO,CAAC,UAAU,CAAC,CAoerB;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAyBnF;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAO1C;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOhD;AAED,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CASrE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAI/E;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,MAAM,EACb,GAAG,SAAM,GACR;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAsD3C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAe9C"}

package/dist/tools.js

@@ -20,7 +20,10 @@ import * as path from "path";
 import * as child_process from "child_process";
 import chalk from "chalk";
 import { printFileDiff, printApprovalPrompt } from "./display.js";
-import { loadAllowlist, matchAllowlist, appendAllowlist, derivePattern, } from "./settings.js";
+import { loadAllowlist, matchAllowlist, appendAllowlist, derivePattern, _urlHost, } from "./settings.js";
+import { backgroundRegistry } from "./background.js";
+import { setTodos, renderTodos } from "./todos.js";
+import { listSkills, loadSkill, renderSkillList } from "./skills.js";
 export const TOOL_MANIFEST = [
     {
         name: "read_file",
@@ -102,6 +105,137 @@ export const TOOL_MANIFEST = [
             required: ["message"],
         },
     },
+    {
+        name: "edit",
+        description: "Make a surgical edit to a file: replace an exact string with new text, leaving the rest untouched. Prefer this over write_file for changing part of a file. old_string must appear exactly once unless replace_all is set. Shows a diff + prompts for approval.",
+        input_schema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Absolute or session-cwd-relative path to the file to edit" },
+                old_string: { type: "string", description: "The exact text to replace (must match the file exactly, including whitespace)" },
+                new_string: { type: "string", description: "The text to replace it with (must differ from old_string)" },
+                replace_all: { type: "boolean", description: "Replace every occurrence instead of requiring old_string to be unique (default false)" },
+            },
+            required: ["path", "old_string", "new_string"],
+        },
+    },
+    {
+        name: "grep",
+        description: "Search file contents for a regular expression across a directory tree. Returns matching lines as path:line:text. Read-only, no approval needed.",
+        input_schema: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "Regular expression to search for (JavaScript regex syntax)" },
+                path: { type: "string", description: "Directory to search under (default: session cwd)" },
+                glob: { type: "string", description: "Optional file-name glob to limit which files are searched (e.g. *.ts, **/*.py)" },
+                ignore_case: { type: "boolean", description: "Case-insensitive match (default false)" },
+                max_results: { type: "integer", description: "Maximum matching lines to return (default 200)" },
+            },
+            required: ["pattern"],
+        },
+    },
+    {
+        name: "glob",
+        description: "Find files whose path matches a glob pattern across a directory tree, sorted by path. Returns paths relative to the search directory. Read-only, no approval needed.",
+        input_schema: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "Glob pattern (e.g. **/*.ts, src/**/index.*)" },
+                path: { type: "string", description: "Directory to search under (default: session cwd)" },
+            },
+            required: ["pattern"],
+        },
+    },
+    {
+        name: "web_fetch",
+        description: "Fetch a web page or API over http(s) and return its text content (HTML is reduced to readable text). Shows the URL + prompts for approval, since the request leaves the user's machine.",
+        input_schema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "Absolute http(s) URL to fetch" },
+                max_chars: { type: "integer", description: "Maximum characters of body text to return (default 20000)" },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "run_background",
+        description: "Start a long-running shell command in the background (a build, dev server, or test watcher) without blocking. Returns a shell_id — poll it with background_output and stop it with kill_background. Shows the command + prompts for approval.",
+        input_schema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "Shell command line to run in the background" },
+                cwd: { type: "string", description: "Optional working directory (default: session cwd)" },
+            },
+            required: ["command"],
+        },
+    },
+    {
+        name: "background_output",
+        description: "Read output produced by a background command since the last read, plus its running/exited status. Read-only, no approval needed.",
+        input_schema: {
+            type: "object",
+            properties: {
+                shell_id: { type: "string", description: "The shell_id returned by run_background" },
+            },
+            required: ["shell_id"],
+        },
+    },
+    {
+        name: "kill_background",
+        description: "Terminate a background command started with run_background. No approval needed (you are stopping your own process).",
+        input_schema: {
+            type: "object",
+            properties: {
+                shell_id: { type: "string", description: "The shell_id returned by run_background" },
+            },
+            required: ["shell_id"],
+        },
+    },
+    {
+        name: "todo_write",
+        description: "Record or update the task list for a multi-step job. Pass the ENTIRE list every time (it replaces the previous one), each item an object { content, status } where status is pending, in_progress, or completed. Keep exactly one task in_progress. Read-only to the filesystem; no approval needed.",
+        input_schema: {
+            type: "object",
+            properties: {
+                todos: {
+                    type: "array",
+                    description: "Full task list — array of { content: string, status: \"pending\"|\"in_progress\"|\"completed\" }",
+                },
+            },
+            required: ["todos"],
+        },
+    },
+    {
+        name: "present_plan",
+        description: "Present a plan for the user to approve BEFORE you make any changes. Use this once you've finished researching and are ready to act — lay out the steps, then wait. The user approves or rejects; only proceed on approval. Always prompts (never auto-approved).",
+        input_schema: {
+            type: "object",
+            properties: {
+                plan: { type: "string", description: "The plan to execute, in markdown — the concrete steps you intend to take" },
+            },
+            required: ["plan"],
+        },
+    },
+    {
+        name: "list_skills",
+        description: "List the skills available in this project (./.claude/skills) and the user's global skills (~/.xiaotime/skills) — name + one-line description. Load one with load_skill. Read-only, no approval needed.",
+        input_schema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "load_skill",
+        description: "Load a local skill's full instructions by name (discover names with list_skills), then follow them. Read-only, no approval needed.",
+        input_schema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "The skill name from list_skills" },
+            },
+            required: ["name"],
+        },
+    },
 ];
 // Session cwd — set on connect
 let sessionCwd = process.cwd();
@@ -300,6 +434,252 @@ export async function executeTool(call, ui) {
                 console.log(chalk.hex("#a6e3a1")("  ✓ Committed") + _approvedSuffix(gate));
                 return { tool_use_id, content: out, is_error: false };
             }
+            case "edit": {
+                const filePath = resolvePath(input.path);
+                const oldString = input.old_string;
+                const newString = input.new_string;
+                const replaceAll = input.replace_all;
+                if (!fs.existsSync(filePath)) {
+                    return { tool_use_id, content: `File not found: ${filePath}`, is_error: true };
+                }
+                if (oldString === newString) {
+                    return {
+                        tool_use_id,
+                        content: "old_string and new_string are identical — nothing to change.",
+                        is_error: true,
+                    };
+                }
+                const oldContent = fs.readFileSync(filePath, "utf-8");
+                const occurrences = _countOccurrences(oldContent, oldString);
+                if (occurrences === 0) {
+                    return {
+                        tool_use_id,
+                        content: "old_string not found in file. It must match exactly, including whitespace and indentation.",
+                        is_error: true,
+                    };
+                }
+                if (occurrences > 1 && !replaceAll) {
+                    return {
+                        tool_use_id,
+                        content: `old_string is not unique (${occurrences} matches). Add surrounding context to make it unique, or set replace_all: true.`,
+                        is_error: true,
+                    };
+                }
+                const newContent = replaceAll
+                    ? oldContent.split(oldString).join(newString)
+                    : _replaceFirst(oldContent, oldString, newString);
+                const replaced = replaceAll ? occurrences : 1;
+                // Show styled diff box before the approval gate (same as write_file)
+                printFileDiff(filePath, oldContent, newContent);
+                const gate = await _gateApproval(ui, "edit", input, `edit  ${filePath}`, `Replacing ${replaced} occurrence${replaced === 1 ? "" : "s"}`);
+                if (!gate.approved) {
+                    const tail = gate.rejectReason ? `: ${gate.rejectReason}` : ".";
+                    return { tool_use_id, content: `Rejected by user${tail}`, is_error: false };
+                }
+                fs.writeFileSync(filePath, newContent, "utf-8");
+                console.log(chalk.hex("#a6e3a1")("  ✓ Edited") + _approvedSuffix(gate));
+                return {
+                    tool_use_id,
+                    content: `File edited: ${filePath} (${replaced} replacement${replaced === 1 ? "" : "s"})`,
+                    is_error: false,
+                };
+            }
+            case "grep": {
+                const searchDir = input.path ? resolvePath(input.path) : sessionCwd;
+                const flags = input.ignore_case ? "i" : "";
+                let regex;
+                try {
+                    regex = new RegExp(input.pattern, flags);
+                }
+                catch (e) {
+                    return {
+                        tool_use_id,
+                        content: `Invalid regular expression: ${e.message}`,
+                        is_error: true,
+                    };
+                }
+                const globPat = input.glob;
+                const max = input.max_results || 200;
+                const { matches, truncated } = grepTree(searchDir, regex, globPat, max);
+                console.log(chalk.dim(`  [grep] ${input.pattern} in ${searchDir} (${matches.length} match${matches.length === 1 ? "" : "es"})`));
+                const marker = truncated
+                    ? `\n... (truncated to ${max} matches — narrow the pattern or glob)`
+                    : "";
+                return {
+                    tool_use_id,
+                    content: (matches.join("\n") || "(no matches)") + marker,
+                    is_error: false,
+                };
+            }
+            case "glob": {
+                const searchDir = input.path ? resolvePath(input.path) : sessionCwd;
+                const cap = _listDirectoryMax();
+                let entries = listRecursive(searchDir, input.pattern, cap + 1);
+                entries.sort();
+                let truncated = false;
+                if (entries.length > cap) {
+                    entries = entries.slice(0, cap);
+                    truncated = true;
+                }
+                console.log(chalk.dim(`  [glob] ${input.pattern} in ${searchDir} (${entries.length} file${entries.length === 1 ? "" : "s"})`));
+                const marker = truncated ? `\n... (truncated to ${cap})` : "";
+                return {
+                    tool_use_id,
+                    content: (entries.join("\n") || "(no matches)") + marker,
+                    is_error: false,
+                };
+            }
+            case "web_fetch": {
+                const url = String(input.url ?? "").trim();
+                const host = _urlHost(url);
+                if (host === null) {
+                    return {
+                        tool_use_id,
+                        content: "web_fetch requires an absolute http(s) URL.",
+                        is_error: true,
+                    };
+                }
+                const maxChars = input.max_chars || 20000;
+                const gate = await _gateApproval(ui, "web_fetch", input, `web_fetch  ${host}`, url);
+                if (!gate.approved) {
+                    const tail = gate.rejectReason ? `: ${gate.rejectReason}` : ".";
+                    return { tool_use_id, content: `Rejected by user${tail}`, is_error: false };
+                }
+                let body;
+                try {
+                    const controller = new AbortController();
+                    const timer = setTimeout(() => controller.abort(), 30000);
+                    const resp = await fetch(url, {
+                        signal: controller.signal,
+                        redirect: "follow",
+                        headers: { "User-Agent": "xiaotime-cli" },
+                    });
+                    clearTimeout(timer);
+                    if (!resp.ok) {
+                        return {
+                            tool_use_id,
+                            content: `HTTP ${resp.status} ${resp.statusText} for ${url}`,
+                            is_error: true,
+                        };
+                    }
+                    const ctype = resp.headers.get("content-type") || "";
+                    const raw = await resp.text();
+                    body = /html/i.test(ctype) ? stripHtml(raw) : raw;
+                }
+                catch (e) {
+                    return {
+                        tool_use_id,
+                        content: `Fetch failed: ${e.message}`,
+                        is_error: true,
+                    };
+                }
+                const truncated = body.length > maxChars;
+                console.log(chalk.hex("#a6e3a1")("  ✓ Fetched") +
+                    _approvedSuffix(gate) +
+                    chalk.dim(` (${body.length} chars)`));
+                return {
+                    tool_use_id,
+                    content: body.slice(0, maxChars) + (truncated ? `\n... (truncated to ${maxChars} chars)` : ""),
+                    is_error: false,
+                };
+            }
+            case "run_background": {
+                const command = input.command;
+                const cwd = input.cwd ? resolvePath(input.cwd) : sessionCwd;
+                const gate = await _gateApproval(ui, "run_background", input, `run_background`, `${command}\ncwd: ${cwd}`);
+                if (!gate.approved) {
+                    const tail = gate.rejectReason ? `: ${gate.rejectReason}` : ".";
+                    return { tool_use_id, content: `Rejected by user${tail}`, is_error: false };
+                }
+                const proc = backgroundRegistry.start(command, cwd);
+                console.log(chalk.hex("#a6e3a1")(`  ✓ Background started (${proc.id})`) + _approvedSuffix(gate));
+                return {
+                    tool_use_id,
+                    content: `Background command started: ${proc.id}. Poll output with background_output (shell_id "${proc.id}"); stop it with kill_background.`,
+                    is_error: false,
+                };
+            }
+            case "background_output": {
+                const shellId = input.shell_id;
+                const read = backgroundRegistry.readNew(shellId);
+                if (read === null) {
+                    return { tool_use_id, content: `No such background command: ${shellId}`, is_error: true };
+                }
+                console.log(chalk.dim(`  [background_output] ${shellId} (${read.status})`));
+                const exitNote = read.status === "running"
+                    ? ""
+                    : `\n[${read.status}${read.exitCode !== null ? `, exit ${read.exitCode}` : ""}]`;
+                return {
+                    tool_use_id,
+                    content: (read.text || "(no new output)") + exitNote,
+                    is_error: false,
+                };
+            }
+            case "kill_background": {
+                const shellId = input.shell_id;
+                const ok = backgroundRegistry.kill(shellId);
+                if (!ok) {
+                    return { tool_use_id, content: `No such background command: ${shellId}`, is_error: true };
+                }
+                console.log(chalk.dim(`  [kill_background] ${shellId}`));
+                return { tool_use_id, content: `Killed background command: ${shellId}`, is_error: false };
+            }
+            case "todo_write": {
+                let rendered;
+                try {
+                    const list = setTodos(input.todos);
+                    rendered = renderTodos(list);
+                }
+                catch (e) {
+                    return { tool_use_id, content: e.message, is_error: true };
+                }
+                console.log(chalk.dim(`  [todo_write]\n${rendered.split("\n").map((l) => "  " + l).join("\n")}`));
+                return { tool_use_id, content: rendered, is_error: false };
+            }
+            case "present_plan": {
+                const plan = String(input.plan ?? "").trim();
+                if (!plan) {
+                    return { tool_use_id, content: "present_plan requires a non-empty plan.", is_error: true };
+                }
+                // Always prompt — a plan is unique, so it is never allowlisted.
+                printApprovalPrompt("Plan — approve before I act?", plan);
+                const decision = await ui.promptApprovalMenu("");
+                if (!decision.approved) {
+                    const tail = decision.rejectReason ? `: ${decision.rejectReason}` : ".";
+                    return {
+                        tool_use_id,
+                        content: `Plan rejected by user${tail} Do not proceed — revise the plan and present again.`,
+                        is_error: false,
+                    };
+                }
+                console.log(chalk.hex("#a6e3a1")("  ✓ Plan approved"));
+                return {
+                    tool_use_id,
+                    content: "Plan approved by user. Proceed with the steps as presented.",
+                    is_error: false,
+                };
+            }
+            case "list_skills": {
+                const skills = listSkills(sessionCwd);
+                console.log(chalk.dim(`  [list_skills] ${skills.length} skill${skills.length === 1 ? "" : "s"}`));
+                return { tool_use_id, content: renderSkillList(skills), is_error: false };
+            }
+            case "load_skill": {
+                const skillName = String(input.name ?? "").trim();
+                if (!skillName) {
+                    return { tool_use_id, content: "load_skill requires a skill name.", is_error: true };
+                }
+                const content = loadSkill(skillName, sessionCwd);
+                if (content === null) {
+                    return {
+                        tool_use_id,
+                        content: `No local skill named "${skillName}". Use list_skills to see what's available.`,
+                        is_error: true,
+                    };
+                }
+                console.log(chalk.dim(`  [load_skill] ${skillName}`));
+                return { tool_use_id, content, is_error: false };
+            }
             default:
                 return {
                     tool_use_id,
@@ -358,4 +738,119 @@ export function globToRegex(glob) {
         .replace(/\?/g, "[^/]");
     return new RegExp(escaped);
 }
+/** Count non-overlapping occurrences of `needle` in `hay`. */
+export function _countOccurrences(hay, needle) {
+    if (needle === "")
+        return 0;
+    let count = 0;
+    let i = 0;
+    while ((i = hay.indexOf(needle, i)) !== -1) {
+        count++;
+        i += needle.length;
+    }
+    return count;
+}
+/**
+ * Replace the first literal occurrence of `needle` with `repl`.
+ * Uses index-splicing (not String.replace) so `$&`/`$1` sequences in
+ * `repl` are inserted verbatim rather than interpreted as regex
+ * back-references (#14608 — the surgical-edit correctness trap).
+ */
+export function _replaceFirst(hay, needle, repl) {
+    const i = hay.indexOf(needle);
+    if (i === -1)
+        return hay;
+    return hay.slice(0, i) + repl + hay.slice(i + needle.length);
+}
+/**
+ * Recursively grep a directory tree. Skips dotfiles, node_modules,
+ * binary files (any NUL byte), and files larger than 2 MB. Returns
+ * `relpath:lineno:linetext` matches, capped at `cap`. Directory entries
+ * are visited in sorted order for deterministic output.
+ */
+export function grepTree(dir, regex, glob, cap = 200) {
+    const matches = [];
+    const globRe = glob ? globToRegex(glob) : null;
+    const MAX_FILE = 2 * 1024 * 1024;
+    let truncated = false;
+    function walk(current, rel) {
+        let entries;
+        try {
+            entries = fs.readdirSync(current);
+        }
+        catch {
+            return false;
+        }
+        entries.sort();
+        for (const entry of entries) {
+            if (entry.startsWith("."))
+                continue;
+            if (entry === "node_modules")
+                continue;
+            const full = path.join(current, entry);
+            const relPath = rel ? `${rel}/${entry}` : entry;
+            let stat;
+            try {
+                stat = fs.statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                if (walk(full, relPath))
+                    return true;
+            }
+            else {
+                if (globRe && !globRe.test(relPath))
+                    continue;
+                if (stat.size > MAX_FILE)
+                    continue;
+                let content;
+                try {
+                    content = fs.readFileSync(full, "utf-8");
+                }
+                catch {
+                    continue;
+                }
+                if (/\u0000/.test(content))
+                    continue; // binary (any NUL byte)
+                const lines = content.split("\n");
+                for (let i = 0; i < lines.length; i++) {
+                    if (regex.test(lines[i])) {
+                        matches.push(`${relPath}:${i + 1}:${lines[i]}`);
+                        if (matches.length >= cap) {
+                            truncated = true;
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    walk(dir, "");
+    return { matches, truncated };
+}
+/**
+ * Reduce an HTML document to readable text: drop script/style/comments
+ * and tags, decode the common named entities, and collapse whitespace.
+ * Intentionally minimal — enough to make a fetched page legible to the
+ * agent, not a full HTML parser.
+ */
+export function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<!--[\s\S]*?-->/g, " ")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/[ \t]+/g, " ")
+        .replace(/\n\s*\n\s*\n+/g, "\n\n")
+        .trim();
+}
 //# sourceMappingURL=tools.js.map