@cryer/star-cli 0.3.9 → 0.3.11

package/dist/{chunk-OIJYNQFZ.js → chunk-Q5FJN4LN.js}

@@ -18,10 +18,11 @@ import {
   nextSnapshotId,
   probeImageDimensions,
   pushSnapshot,
+  sharedTodoStore,
   starHome,
   walkFiles,
   webFetchTool
-} from "./chunk-A5PXPWHB.js";
+} from "./chunk-LSYGHLRU.js";
 
 // src/tools/fs/edit.ts
 import { readFile, stat, writeFile } from "fs/promises";
@@ -334,10 +335,250 @@ var grepTool = {
   }
 };
 
-// src/tools/fs/read.ts
-import { open, realpath as realpath2, stat as stat3 } from "fs/promises";
+// src/tools/fs/outline.ts
+import { readFile as readFile3, realpath as realpath2, stat as stat3 } from "fs/promises";
 import path4 from "path";
 import { z as z4 } from "zod";
+var MAX_DIR_FILES = 60;
+var MAX_FILE_BYTES2 = 2 * 1024 * 1024;
+var MAX_SYMBOLS_PER_FILE = 150;
+var MAX_LINE_CHARS2 = 200;
+var MAX_OUT_CHARS = 30 * 1024;
+var MAX_INDENT_CHARS = 8;
+var KEYWORD_EXCLUSION = "(?!if\\b|for\\b|while\\b|switch\\b|catch\\b|return\\b|else\\b|do\\b|new\\b|throw\\b)";
+var TS_MEMBER_MODIFIERS = "(?:public|private|protected|static|async|readonly|get|set|override|abstract)";
+var TS_LIKE = [
+  /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\*?\s+[\w$]+/,
+  /^(?:export\s+)?(?:abstract\s+)?class\s+[\w$]+/,
+  /^(?:export\s+)?interface\s+[\w$]+/,
+  /^(?:export\s+)?type\s+[\w$]+\s*=/,
+  /^(?:export\s+)?(?:const\s+)?enum\s+[\w$]+/,
+  // const handler = (a, b) => / const handler = async (a) => — top level
+  // only; locals inside functions are navigation noise.
+  /^(?:export\s+)?(?:const|let|var)\s+[\w$]+\s*=\s*(?:async\s*)?(?:\([^)]*\)|[\w$]+)\s*=>/,
+  // Indented class/object members with a body: name<T>(args): ReturnType {
+  // — control flow excluded by the keyword lookahead, dotted calls
+  // (this.x()) fail the anchored name-then-paren shape.
+  new RegExp(
+    `^\\s+(?:${TS_MEMBER_MODIFIERS}\\s+)*${KEYWORD_EXCLUSION}[\\w$]+(?:<[^>]*>)?\\s*\\([^)]*\\)\\s*(?::\\s*[^{}=;]+?)?\\s*(?:\\{\\s*)?\\}?\\s*$`
+  ),
+  // Bodyless signatures (interface members, overloads): only when the
+  // parens carry type annotations or an explicit return type follows —
+  // otherwise indented calls like clearTimeout(timer); or finalize();
+  // would leak into the outline.
+  new RegExp(
+    `^\\s+(?:${TS_MEMBER_MODIFIERS}\\s+)*${KEYWORD_EXCLUSION}[\\w$]+(?:<[^>]*>)?\\s*(?:\\([^)]*:[^)]*\\)\\s*(?::\\s*[^{}=;]+?)?|\\([^)]*\\)\\s*:\\s*[^{}=;]+?)\\s*;\\s*$`
+  )
+];
+var LANGUAGE_PATTERNS = {
+  ts: TS_LIKE,
+  python: [/^\s*(?:async\s+)?def\s+\w+\s*\(/, /^\s*class\s+\w+/],
+  go: [/^func\s+(?:\([^)]*\)\s*)?\w+\s*\(/, /^type\s+\w+\s+(?:struct|interface)\b/],
+  rust: [
+    /^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+\w+/,
+    /^\s*(?:pub\s+)?(?:struct|enum|trait|union)\s+\w+/
+  ],
+  jvm: [
+    /^\s*(?:(?:public|private|protected|internal|static|final|abstract|sealed|open|suspend|inline|override|async|partial|virtual|extern)\s+)*(?:class|interface|enum|struct|record|object)\s+\w+/,
+    /^\s*(?:(?:public|private|protected|internal|open|suspend|inline|override)\s+)*fun\s+\w+\s*\(/,
+    new RegExp(
+      `^\\s+(?:(?:public|private|protected|internal|static|final|abstract|sealed|open|suspend|inline|override|async|partial|virtual)\\s+)*[\\w<>[\\],.?]+\\s+${KEYWORD_EXCLUSION}\\w+\\s*\\([^;{}]*\\)\\s*(?:\\{|;|=>|$)`
+    )
+  ],
+  cpp: [
+    /^\s*(?:class|struct|enum|union|namespace)\s+\w+/,
+    new RegExp(
+      `^\\s*(?:(?:static|inline|virtual|constexpr|extern|friend|explicit)\\s+)*[\\w:<>,~*&\\s]+?\\s+${KEYWORD_EXCLUSION}[\\w:~]+\\s*\\([^;]*\\)\\s*(?:const\\s*)?(?:noexcept\\s*)?(?:\\{|;|$)`
+    )
+  ],
+  ruby: [/^\s*def\s+[\w.=!?]+/, /^\s*(?:class|module)\s+[\w:]+/],
+  php: [
+    /^\s*(?:(?:public|private|protected|static|abstract|final)\s+)*function\s+\w+\s*\(/,
+    /^\s*(?:(?:abstract|final)\s+)?(?:class|interface|trait|enum)\s+\w+/
+  ],
+  shell: [/^\s*(?:function\s+)?[\w.-]+\s*\(\s*\)\s*(?:\{|$)/],
+  swift: [
+    /^\s*(?:(?:public|private|internal|open|fileprivate|static|class|override|mutating|final)\s+)*func\s+\w+\s*\(/,
+    /^\s*(?:(?:public|private|internal|open|final)\s+)*(?:class|struct|enum|protocol|extension)\s+\w+/
+  ],
+  scala: [
+    /^\s*(?:(?:private|protected|override|final|abstract|implicit)\s+)*def\s+\w+\s*[(\[]/,
+    /^\s*(?:(?:abstract|final|sealed)\s+)*(?:class|trait|object)\s+\w+/
+  ]
+};
+var EXT_TO_LANGUAGE = {
+  ts: "ts",
+  tsx: "ts",
+  mts: "ts",
+  cts: "ts",
+  js: "ts",
+  jsx: "ts",
+  mjs: "ts",
+  cjs: "ts",
+  py: "python",
+  pyi: "python",
+  go: "go",
+  rs: "rust",
+  java: "jvm",
+  kt: "jvm",
+  kts: "jvm",
+  cs: "jvm",
+  c: "cpp",
+  h: "cpp",
+  cc: "cpp",
+  cpp: "cpp",
+  cxx: "cpp",
+  hpp: "cpp",
+  hh: "cpp",
+  rb: "ruby",
+  php: "php",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell",
+  swift: "swift",
+  scala: "scala",
+  sc: "scala"
+};
+function languageOf(filePath) {
+  const name = path4.basename(filePath);
+  if (/\.(min|bundle|generated)\.[^.]+$/.test(name)) return void 0;
+  const ext = name.split(".").pop()?.toLowerCase() ?? "";
+  const lang = EXT_TO_LANGUAGE[ext];
+  return lang === void 0 ? void 0 : LANGUAGE_PATTERNS[lang];
+}
+function extractSymbols(text, patterns) {
+  const out = [];
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = (lines[i] ?? "").replace(/\r$/, "");
+    const trimmed = raw.trim();
+    if (trimmed === "") continue;
+    if (!patterns.some((re) => re.test(raw))) continue;
+    const indent = raw.slice(0, raw.length - raw.trimStart().length).slice(0, MAX_INDENT_CHARS);
+    const shown = trimmed.length > MAX_LINE_CHARS2 ? `${trimmed.slice(0, MAX_LINE_CHARS2)}\u2026` : trimmed;
+    out.push({ line: i + 1, indent, text: shown });
+  }
+  return out;
+}
+async function outlineFile(abs) {
+  const st = await stat3(abs).catch(() => null);
+  if (!st || st.size > MAX_FILE_BYTES2) return { unreadable: true };
+  const buf = await readFile3(abs).catch(() => null);
+  if (!buf) return { unreadable: true };
+  if (buf.includes(0)) return { binary: true };
+  const patterns = languageOf(abs);
+  if (!patterns) return { unreadable: true };
+  const all = extractSymbols(buf.toString("utf8"), patterns);
+  return { symbols: all.slice(0, MAX_SYMBOLS_PER_FILE), total: all.length };
+}
+function formatSymbols(symbols, total) {
+  const out = symbols.map((s) => `${s.line}	${s.indent}${s.text}`);
+  if (total > symbols.length) {
+    out.push(`... (${total - symbols.length} more declarations)`);
+  }
+  return out;
+}
+var schema4 = z4.object({
+  path: z4.string().optional().describe("Source file or directory to outline (default: the working directory)"),
+  maxFiles: z4.number().int().positive().optional().describe(`Directory mode: maximum files to include (default ${MAX_DIR_FILES})`)
+});
+var codeOutlineTool = {
+  name: "code_outline",
+  description: "List the declaration skeleton of a source file or directory (functions, classes, methods, types) with line numbers, without reading the bodies. Cheaper than read_file for navigating unfamiliar code: outline first, then read_file the exact line ranges you need. Supports TS/JS, Python, Go, Rust, Java/Kotlin/C#, C/C++, Ruby, PHP, Shell, Swift, Scala.",
+  permission: "read",
+  parameters: schema4,
+  async execute(args, ctx) {
+    const root = path4.resolve(ctx.cwd, args.path ?? ".");
+    const st = await stat3(root).catch(() => null);
+    if (!st) {
+      return { content: `Path not found: ${args.path ?? "."}`, isError: true };
+    }
+    if (st.isFile()) {
+      const resolved = await realpath2(root).catch(() => null);
+      if (isSensitivePath(root) || resolved !== null && isSensitivePath(resolved)) {
+        return { content: `Refused to outline sensitive file: ${args.path ?? "."}`, isError: true };
+      }
+      if (languageOf(root) === void 0) {
+        return {
+          content: `No supported source language for: ${args.path ?? "."} (supported: TS/JS, Python, Go, Rust, Java/Kotlin/C#, C/C++, Ruby, PHP, Shell, Swift, Scala)`
+        };
+      }
+      const result = await outlineFile(root);
+      if ("binary" in result) {
+        return { content: `Cannot outline binary file: ${args.path ?? "."}`, isError: true };
+      }
+      if ("unreadable" in result) {
+        return {
+          content: `Cannot outline ${args.path ?? "."}: unreadable or larger than 2MB`,
+          isError: true
+        };
+      }
+      if (result.symbols.length === 0) {
+        return { content: `(no recognizable declarations in ${args.path ?? "."})` };
+      }
+      return { content: formatSymbols(result.symbols, result.total).join("\n") };
+    }
+    const walked = await walkFiles(root, void 0, {
+      ignore: createIgnorePredicate(ctx.cwd),
+      withMtime: false,
+      signal: ctx.abortSignal,
+      symlinkBoundary: ctx.cwd,
+      nestedIgnore: true
+    });
+    const candidates = walked.files.filter(
+      (f) => languageOf(f.abs) !== void 0 && !isSensitivePath(f.abs) && (f.resolved === void 0 || !isSensitivePath(f.resolved))
+    );
+    const maxFiles = args.maxFiles ?? MAX_DIR_FILES;
+    const scan = async (file) => {
+      const result = await outlineFile(file.abs);
+      if ("symbols" in result && result.symbols.length > 0) {
+        const lines = formatSymbols(result.symbols, result.total);
+        const chars = lines.reduce((n, l) => n + l.length + 1, file.rel.length + 2);
+        return { rel: file.rel, lines, chars };
+      }
+      return null;
+    };
+    const out = [];
+    let size = 0;
+    let included = 0;
+    let hitLimit = false;
+    for (let i = 0; i < candidates.length && included < maxFiles; i += WALK_CONCURRENCY) {
+      if (ctx.abortSignal?.aborted) break;
+      const chunk = await Promise.all(
+        candidates.slice(i, i + WALK_CONCURRENCY).map((file) => scan(file))
+      );
+      for (const block of chunk) {
+        if (!block) continue;
+        if (size + block.chars > MAX_OUT_CHARS || included >= maxFiles) {
+          hitLimit = true;
+          break;
+        }
+        if (out.length > 0) out.push("");
+        out.push(`${block.rel}:`);
+        out.push(...block.lines);
+        size += block.chars;
+        included += 1;
+      }
+      if (hitLimit) break;
+    }
+    if (included === 0) {
+      return {
+        content: `No recognizable declarations under ${args.path ?? "."} (${candidates.length} source file(s) scanned)`
+      };
+    }
+    if (hitLimit) {
+      out.push("... (truncated: output limit reached, more files not outlined)");
+    } else if (walked.aborted || ctx.abortSignal?.aborted) {
+      out.push("... (interrupted: partial results)");
+    }
+    return { content: out.join("\n") };
+  }
+};
+
+// src/tools/fs/read.ts
+import { open, realpath as realpath3, stat as stat4 } from "fs/promises";
+import path5 from "path";
+import { z as z5 } from "zod";
 var DEFAULT_LIMIT = 2e3;
 var MAX_CHARS = 100 * 1024;
 var MAX_READ_BYTES = 1024 * 1024;
@@ -363,10 +604,10 @@ function decodeTextBuffer(buf) {
   }
   return { text: buf.toString("utf8") };
 }
-var schema4 = z4.object({
-  path: z4.string().describe("File path, absolute or relative to the working directory"),
-  offset: z4.number().int().positive().optional().describe("1-based line number to start reading from"),
-  limit: z4.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
+var schema5 = z5.object({
+  path: z5.string().describe("File path, absolute or relative to the working directory"),
+  offset: z5.number().int().positive().optional().describe("1-based line number to start reading from"),
+  limit: z5.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
 });
 var READ_CACHE_MAX_ENTRIES = 200;
 function createReadFileTool() {
@@ -375,15 +616,15 @@ function createReadFileTool() {
     name: "read_file",
     description: "Read a text file and return its contents with line numbers. Output is truncated to 2000 lines or 100KB by default. Re-reading an unchanged file range returns a short note instead of the content.",
     permission: "read",
-    parameters: schema4,
+    parameters: schema5,
     reset: () => cache.clear(),
     async execute(args, ctx) {
-      const filePath = path4.resolve(ctx.cwd, args.path);
-      const resolvedPath = await realpath2(filePath).catch(() => null);
+      const filePath = path5.resolve(ctx.cwd, args.path);
+      const resolvedPath = await realpath3(filePath).catch(() => null);
       if (isSensitivePath(filePath) || resolvedPath !== null && isSensitivePath(resolvedPath)) {
         return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
       }
-      const st = await stat3(filePath).catch(() => null);
+      const st = await stat4(filePath).catch(() => null);
       if (!st) {
         return { content: `File not found: ${args.path}`, isError: true };
       }
@@ -472,9 +713,9 @@ function createReadFileTool() {
 var readFileTool = createReadFileTool();
 
 // src/tools/fs/read-image.ts
-import { readFile as readFile3, realpath as realpath3, stat as stat4 } from "fs/promises";
-import path5 from "path";
-import { z as z5 } from "zod";
+import { readFile as readFile4, realpath as realpath4, stat as stat5 } from "fs/promises";
+import path6 from "path";
+import { z as z6 } from "zod";
 var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
 var IMAGE_MIME_TYPES = {
   ".png": "image/png",
@@ -483,8 +724,8 @@ var IMAGE_MIME_TYPES = {
   ".gif": "image/gif",
   ".webp": "image/webp"
 };
-var schema5 = z5.object({
-  path: z5.string().describe(
+var schema6 = z6.object({
+  path: z6.string().describe(
     "Image file path (png/jpg/jpeg/gif/webp), absolute or relative to the working directory"
   )
 });
@@ -492,7 +733,7 @@ var readImageTool = {
   name: "read_image",
   description: "Read an image file (png, jpg, gif, webp) and show it to the model. Use this whenever the user references a screenshot, diagram, or picture file you need to see. Images larger than 2000px are downsampled automatically.",
   permission: "read",
-  parameters: schema5,
+  parameters: schema6,
   async execute(args, ctx) {
     if (ctx.visionEnabled === false) {
       return {
@@ -500,19 +741,19 @@ var readImageTool = {
         isError: true
       };
     }
-    const filePath = path5.resolve(ctx.cwd, args.path);
-    const resolvedPath = await realpath3(filePath).catch(() => null);
+    const filePath = path6.resolve(ctx.cwd, args.path);
+    const resolvedPath = await realpath4(filePath).catch(() => null);
     if (isSensitivePath(filePath) || resolvedPath !== null && isSensitivePath(resolvedPath)) {
       return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
     }
-    const mimeType = IMAGE_MIME_TYPES[path5.extname(filePath).toLowerCase()];
+    const mimeType = IMAGE_MIME_TYPES[path6.extname(filePath).toLowerCase()];
     if (!mimeType) {
       return {
         content: `Not a supported image (png/jpg/jpeg/gif/webp): ${args.path}`,
         isError: true
       };
     }
-    const st = await stat4(filePath).catch(() => null);
+    const st = await stat5(filePath).catch(() => null);
     if (!st || !st.isFile()) {
       return { content: `File not found: ${args.path}`, isError: true };
     }
@@ -522,7 +763,7 @@ var readImageTool = {
         isError: true
       };
     }
-    const buf = await readFile3(filePath).catch(() => null);
+    const buf = await readFile4(filePath).catch(() => null);
     if (!buf || buf.length === 0) {
       return { content: `Failed to read ${args.path}`, isError: true };
     }
@@ -557,19 +798,19 @@ var readImageTool = {
 
 // src/tools/fs/write.ts
 import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import path6 from "path";
-import { z as z6 } from "zod";
-var schema6 = z6.object({
-  path: z6.string().describe("File path, absolute or relative to the working directory"),
-  content: z6.string().describe("Full content to write to the file")
+import path7 from "path";
+import { z as z7 } from "zod";
+var schema7 = z7.object({
+  path: z7.string().describe("File path, absolute or relative to the working directory"),
+  content: z7.string().describe("Full content to write to the file")
 });
 var writeFileTool = {
   name: "write_file",
   description: "Write content to a file, creating parent directories as needed. Overwrites existing files. Refuses content with NUL bytes (binary) or over 5MB.",
   permission: "write",
-  parameters: schema6,
+  parameters: schema7,
   async execute(args, ctx) {
-    const filePath = path6.resolve(ctx.cwd, args.path);
+    const filePath = path7.resolve(ctx.cwd, args.path);
     if (args.content.includes("\0")) {
       return {
         content: `Refused to write ${args.path}: content contains NUL bytes (write_file is text-only)`,
@@ -585,7 +826,7 @@ var writeFileTool = {
     }
     const snapshot = await captureSnapshot(filePath, "write_file", ctx.snapshotContext);
     try {
-      await mkdir(path6.dirname(filePath), { recursive: true });
+      await mkdir(path7.dirname(filePath), { recursive: true });
       await writeFile2(filePath, args.content, "utf8");
     } catch (err) {
       return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
@@ -596,14 +837,14 @@ var writeFileTool = {
 };
 
 // src/tools/screenshot.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/core/screenshot.ts
 import { execFile } from "child_process";
 import { randomUUID } from "crypto";
-import { readFile as readFile4, unlink } from "fs/promises";
+import { readFile as readFile5, unlink } from "fs/promises";
 import os from "os";
-import path7 from "path";
+import path8 from "path";
 import { promisify } from "util";
 var SCREENSHOT_TIMEOUT_MS = 2e4;
 var execFileAsync = promisify(execFile);
@@ -676,7 +917,7 @@ async function commandExists(command) {
 }
 var LINUX_TOOL_NAMES = ["grim", "gnome-screenshot", "spectacle", "import", "scrot"];
 async function captureScreenshot() {
-  const outputFile = path7.join(os.tmpdir(), `star-screenshot-${randomUUID()}.png`);
+  const outputFile = path8.join(os.tmpdir(), `star-screenshot-${randomUUID()}.png`);
   try {
     const tools = {};
     if (process.platform === "linux") {
@@ -695,7 +936,7 @@ async function captureScreenshot() {
       const detail = err instanceof Error && err.message ? ` (${err.message})` : "";
       return { ok: false, error: `${plan.command} failed to capture the screen${detail}` };
     }
-    const buf = await readFile4(outputFile).catch(() => null);
+    const buf = await readFile5(outputFile).catch(() => null);
     if (!buf || buf.length === 0) {
       return { ok: false, error: `${plan.command} produced no image file` };
     }
@@ -721,13 +962,13 @@ async function captureScreenshot() {
 }
 
 // src/tools/screenshot.ts
-var schema7 = z7.object({});
+var schema8 = z8.object({});
 function createScreenshotTool(capture = captureScreenshot) {
   return {
     name: "screenshot",
     description: "Capture a screenshot of the primary display and see it. Use this to check the actual visual result of a running program (web page, GUI) \u2014 e.g. after starting a dev server \u2014 instead of inferring from code. The capture shows exactly what is visible on screen, including overlapping windows: content hidden behind other windows cannot be seen, so if a specific window matters ask the user to bring it to the front first. Note the capture may include anything else currently on screen.",
     permission: "read",
-    parameters: schema7,
+    parameters: schema8,
     async execute(_args, ctx) {
       if (ctx.visionEnabled === false) {
         return {
@@ -753,7 +994,7 @@ function createScreenshotTool(capture = captureScreenshot) {
 var screenshotTool = createScreenshotTool();
 
 // src/tools/tasks.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/tasks/format.ts
 function formatDuration(startedAt, endedAt) {
@@ -799,8 +1040,8 @@ function formatTaskFinished(task) {
 }
 
 // src/tools/tasks.ts
-var idSchema = z8.object({
-  id: z8.string().describe("Task id, e.g. task-1 or agent-1")
+var idSchema = z9.object({
+  id: z9.string().describe("Task id, e.g. task-1 or agent-1")
 });
 function truncateOutput(s) {
   if (s.length <= MAX_OUTPUT) return s;
@@ -826,7 +1067,7 @@ var taskListTool = {
   name: "task_list",
   description: "List background tasks (shell commands and subagents) with status and runtime.",
   permission: "read",
-  parameters: z8.object({}),
+  parameters: z9.object({}),
   execute(_args, ctx) {
     const caller = callerId(ctx);
     const shell = formatTaskList(
@@ -888,17 +1129,17 @@ var taskKillTool = {
 };
 
 // src/tools/web/search.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/llm/debug.ts
 import { appendFileSync } from "fs";
-import path8 from "path";
+import path9 from "path";
 function debugStreamLog(event, data) {
   if (!process.env.STAR_DEBUG) return;
   try {
     const line = `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), event, ...data })}
 `;
-    appendFileSync(path8.join(starHome(), "debug.log"), line);
+    appendFileSync(path9.join(starHome(), "debug.log"), line);
   } catch {
   }
 }
@@ -908,9 +1149,9 @@ var TIMEOUT_MS = 15e3;
 var DEFAULT_MAX_RESULTS = 5;
 var MAX_RESULTS_LIMIT = 10;
 var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
-var schema8 = z9.object({
-  query: z9.string().min(1).describe("The search query"),
-  maxResults: z9.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
+var schema9 = z10.object({
+  query: z10.string().min(1).describe("The search query"),
+  maxResults: z10.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
     `Maximum number of results to return (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS_LIMIT})`
   )
 });
@@ -1031,7 +1272,7 @@ var webSearchTool = {
   name: "web_search",
   description: "Search the web and return a numbered list of results with title, URL and snippet. Uses DuckDuckGo with automatic fallback to DuckDuckGo Lite and Bing when a source fails or returns nothing. No API key required. Use web_fetch to read a result's full page.",
   permission: "read",
-  parameters: schema8,
+  parameters: schema9,
   async execute(args, ctx) {
     const maxResults = Math.min(args.maxResults ?? DEFAULT_MAX_RESULTS, MAX_RESULTS_LIMIT);
     const failures = [];
@@ -1105,7 +1346,10 @@ var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   // todoStore defaults to the module-level shared store; subagent loops pass
   // their own instance so a child's todo_write cannot clobber the parent list.
+  // Exposed so the agent loop can watch open items for staleness.
+  todos;
   constructor(todoStore) {
+    this.todos = todoStore ?? sharedTodoStore();
     for (const tool of [
       // Fresh per registry (i.e. per agent loop): the unchanged-since-last-
       // read cache must not leak across loops, whose contexts differ.
@@ -1116,13 +1360,14 @@ var ToolRegistry = class {
       editFileTool,
       globTool,
       grepTool,
+      codeOutlineTool,
       bashTool,
       webFetchTool,
       webSearchTool,
       taskListTool,
       taskOutputTool,
       taskKillTool,
-      ...createTodoTools(todoStore)
+      ...createTodoTools(this.todos)
     ]) {
       this.register(tool);
     }
@@ -1130,6 +1375,16 @@ var ToolRegistry = class {
   register(tool) {
     this.tools.set(tool.name, tool);
   }
+  // Drops every tool the predicate rejects. Used to restrict a read-only
+  // subagent loop's tool set; the agent loop reads list() lazily per
+  // request, so a retain right after loop construction still shapes the
+  // first request. The permission gate stays as backstop for anything
+  // attempted outside the model's tool map.
+  retain(predicate) {
+    for (const [name, tool] of this.tools) {
+      if (!predicate(tool)) this.tools.delete(name);
+    }
+  }
   // Drops per-session volatile tool state after a wholesale history rewrite
   // (compaction, /undo, resume): anything a tool remembers as "already sent
   // to the model" may no longer be in the context.
@@ -1160,4 +1415,4 @@ export {
   ToolRegistry,
   createDefaultRegistry
 };
-//# sourceMappingURL=chunk-OIJYNQFZ.js.map
+//# sourceMappingURL=chunk-Q5FJN4LN.js.map