@trim21/personal-pi-extensions 0.0.229 → 0.0.231

package/README.md

@@ -6,17 +6,16 @@
 
 ## 扩展概览
 
-| 扩展                                          | 描述                                                    |
-| --------------------------------------------- | ------------------------------------------------------- |
-| [bwrap](#bwrap)                               | 基于 bubblewrap 的 OS 级沙箱，提供文件系统和网络隔离    |
-| [写保护（内置）](#写保护内置)                 | 写工具内置：限制文件写入在 workspace 内，外部写入需审批 |
-| [opencode-edit](#opencode-edit)               | 替换内置 edit 工具，使用 opencode 的 schema 和匹配引擎  |
-| [bash-default-timeout](#bash-default-timeout) | 为 bash 工具设置默认超时（180 秒）                      |
-| [vision-agent](#vision-agent)                 | 视觉代理：主模型不支持视觉时，spawn 子 agent 识别图片   |
-| [session-name](#session-name)                 | 首个 user prompt 自动生成会话名，模型命名 + 启发式兜底  |
-| [todowrite](#todowrite)                       | opencode 风格的任务列表工具，完整列表替换语义           |
-| [question](#question)                         | opencode 风格的提问工具，阻塞式询问用户选择             |
-| [talk](#talk)                                 | session 间消息传递，SQLite 邮箱 + 双向 ask 时间戳仲裁   |
+| 扩展                            | 描述                                                    |
+| ------------------------------- | ------------------------------------------------------- |
+| [bwrap](#bwrap)                 | 基于 bubblewrap 的 OS 级沙箱，提供文件系统和网络隔离    |
+| [写保护（内置）](#写保护内置)   | 写工具内置：限制文件写入在 workspace 内，外部写入需审批 |
+| [opencode-edit](#opencode-edit) | 替换内置 edit 工具，使用 opencode 的 schema 和匹配引擎  |
+| [vision-agent](#vision-agent)   | 视觉代理：主模型不支持视觉时，spawn 子 agent 识别图片   |
+| [session-name](#session-name)   | 首个 user prompt 自动生成会话名，模型命名 + 启发式兜底  |
+| [todowrite](#todowrite)         | opencode 风格的任务列表工具，完整列表替换语义           |
+| [question](#question)           | opencode 风格的提问工具，阻塞式询问用户选择             |
+| [talk](#talk)                   | session 间消息传递，SQLite 邮箱 + 双向 ask 时间戳仲裁   |
 
 ---
 
@@ -79,10 +78,7 @@ bash 工具（opencode 风格 `bash`、Claude Code 风格 `Bash`）注册了 `da
 
 ### 使用
 
-```bash
-pi -e ./src/bwrap/index.ts
-# 或通过配置文件注册后自动加载
-```
+bwrap 已集成进 bash 工具实现（opencode 风格 `bash` 位于 `src/opencode/bash.ts`，Claude Code 风格 `Bash` 位于 `src/claude-code/shell.ts`），随对应扩展一起加载，无需单独安装。bash 工具内置默认超时 120 秒。
 
 ---
 
@@ -123,18 +119,6 @@ pi -e ./src/opencode-edit.ts
 
 ---
 
-## bash-default-timeout
-
-为所有 bash 工具调用设置 180 秒默认超时。仅在模型未显式指定 `timeout` 时生效，避免长时间运行的命令无限挂起。
-
-### 使用
-
-```bash
-pi -e ./src/bash-default-timeout.ts
-```
-
----
-
 ## vision-agent
 
 视觉代理扩展。主模型不支持视觉（如 DeepSeek）时自动启用 `describe_image` 工具；主模型支持视觉时自动隐藏，图片由 pi 原生透传。
@@ -357,7 +341,7 @@ pi -e ./src/talk/index.ts
 ### 命令行加载单个扩展
 
 ```bash
-pi -e ./src/bwrap/index.ts
+pi -e ./src/opencode/index.ts
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.0.229",
+  "version": "0.0.231",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [

package/src/bwrap/runtime.ts

@@ -7,6 +7,7 @@ import { createBashTool } from "@earendil-works/pi-coding-agent";
 import { type TObject, Type } from "typebox";
 
 import { type CommandSpec, parseCommand } from "../lib/cli.js";
+import { selectWithOptionalInput } from "../lib/ui.js";
 import {
   type BwrapMode,
   createBwrapBashOperations,
@@ -163,26 +164,27 @@ export class BwrapRuntime {
     if (policy.kind === "deny") throw new Error(policy.reason);
     const description = `Allow this command to run without sandbox?\n---\n\nReason: ${escapeHtml(reason ?? "(No reason provided by model)")}\n---\n${fenceCodeBlock(command)}`;
     while (true) {
-      const choice = await ctx.ui.select(
+      const result = await selectWithOptionalInput(
         description,
-        ["Approve once", "Block", "Block with reason"],
-        {
-          signal: ctx.signal,
-        },
+        [
+          { label: "Approve once" },
+          { label: "Block" },
+          { label: "Block with reason", inputPrompt: "Why was this denied?" },
+        ],
+        ctx.ui,
+        { signal: ctx.signal },
       );
-      if (choice === undefined) {
+      if (result === undefined) {
         ctx.abort();
         throw new Error("User denied the command execution.");
       }
-      if (choice === "Approve once") return;
-      if (choice === "Block") throw new Error("User denied unsandboxed execution.");
-      const feedback = await ctx.ui.input("Why was this denied?", undefined, {
-        signal: ctx.signal,
-      });
-      if (feedback === undefined) continue;
+      if (result.label === "Approve once") return;
+      if (result.label === "Block") throw new Error("User denied unsandboxed execution.");
+      // "Block with reason"：取消输入则重新询问；空输入同样拒绝（不带反馈文本）
+      if (result.input === undefined) continue;
       throw new Error(
-        feedback
-          ? `User denied unsandboxed execution: ${feedback}`
+        result.input
+          ? `User denied unsandboxed execution: ${result.input}`
           : "User denied unsandboxed execution.",
       );
     }

package/src/claude-code/common.ts

@@ -1,4 +1,4 @@
-import { isAbsolute, normalize } from "node:path";
+import { isAbsolute, normalize, resolve } from "node:path";
 
 export interface FileSnapshot {
   digest: string;
@@ -20,6 +20,12 @@ export function requireAbsolutePath(filePath: string, parameter = "file_path"):
   return normalize(filePath);
 }
 
+/** Resolve a search root path against the working directory. */
+export function searchRoot(path: string | undefined, cwd: string): string {
+  if (!path) return cwd;
+  return isAbsolute(path) ? path : resolve(cwd, path);
+}
+
 export function throwIfAborted(signal: AbortSignal | undefined): void {
   if (signal?.aborted) throw new Error("Operation aborted");
 }

package/src/claude-code/glob.ts

@@ -0,0 +1,73 @@
+/**
+ * Claude Code style `Glob` tool — fast file pattern matching.
+ *
+ * Split out of the former search.ts so spawn-agent subagents can load it
+ * independently (declare `Glob` in the frontmatter to get only this tool).
+ */
+
+import { glob as fsGlob, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+import { searchRoot, throwIfAborted } from "./common.js";
+
+const GLOB_RESULT_LIMIT = 100;
+
+export async function globFiles(
+  pattern: string,
+  cwd: string,
+  signal?: AbortSignal,
+): Promise<string[]> {
+  throwIfAborted(signal);
+  const matches: { path: string; mtimeMs: number }[] = [];
+  for await (const match of fsGlob(pattern, { cwd, exclude: [".git/**"], withFileTypes: false })) {
+    throwIfAborted(signal);
+    const absolutePath = resolve(cwd, match);
+    try {
+      const value = await stat(absolutePath);
+      if (value.isFile()) matches.push({ path: absolutePath, mtimeMs: value.mtimeMs });
+    } catch {
+      // A concurrent filesystem change can remove a match before stat.
+    }
+  }
+  return matches
+    .toSorted((left, right) => right.mtimeMs - left.mtimeMs || left.path.localeCompare(right.path))
+    .slice(0, GLOB_RESULT_LIMIT)
+    .map((match) => match.path);
+}
+
+export function registerGlobTool(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "Glob",
+    label: "Glob",
+    description: [
+      "Fast file pattern matching tool that works with any codebase size.",
+      'Supports glob patterns such as "**/*.js" and "src/**/*.ts".',
+      "Returns matching file paths sorted by modification time.",
+    ].join("\n"),
+    parameters: Type.Object(
+      {
+        pattern: Type.String({ description: "The glob pattern to match files against" }),
+        path: Type.Optional(
+          Type.String({
+            description:
+              "The directory to search in. If omitted, the current working directory is used.",
+          }),
+        ),
+      },
+      { additionalProperties: false },
+    ),
+    async execute(_id, params, signal, _onUpdate, ctx) {
+      const root = searchRoot(params.path, ctx.cwd);
+      const matches = await globFiles(params.pattern, root, signal);
+      return {
+        content: [
+          { type: "text", text: matches.length > 0 ? matches.join("\n") : "No files found" },
+        ],
+        details: { count: matches.length },
+      };
+    },
+  });
+}

package/src/claude-code/grep.ts

@@ -0,0 +1,232 @@
+/**
+ * Claude Code style `Grep` tool — powerful ripgrep-based search.
+ *
+ * Split out of the former search.ts so spawn-agent subagents can load it
+ * independently (declare `Grep` in the frontmatter to get only this tool).
+ *
+ * Parameter semantics and default behavior are aligned with Claude Code's
+ * GrepTool (ripgrep-based): hidden files searched, VCS directories excluded,
+ * lines capped at 500 columns, and an implicit head_limit of 250 entries.
+ */
+
+import { stat } from "node:fs/promises";
+
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+import { searchRoot, throwIfAborted } from "./common.js";
+
+const GREP_OUTPUT_MODES = ["content", "files_with_matches", "count"] as const;
+
+type GrepOutputMode = (typeof GREP_OUTPUT_MODES)[number];
+
+/** Version control directories excluded from searches (noise in results). */
+const VCS_DIRECTORIES_TO_EXCLUDE = [".git", ".svn", ".hg", ".bzr", ".jj", ".sl"] as const;
+
+/**
+ * Default cap on results when head_limit is unspecified. Prevents broad
+ * patterns from flooding the context; pass head_limit=0 explicitly for
+ * unlimited results. Mirrors Claude Code's default of 250.
+ */
+const DEFAULT_HEAD_LIMIT = 250;
+
+function truncateOutput(output: string, maxCharacters = 30_000): string {
+  if (output.length <= maxCharacters) return output;
+  return `${output.slice(0, maxCharacters)}\n\n[Output truncated at ${maxCharacters} characters]`;
+}
+
+interface GrepParameters {
+  pattern: string;
+  path?: string;
+  glob?: string;
+  output_mode?: GrepOutputMode;
+  "-B"?: number;
+  "-A"?: number;
+  "-C"?: number;
+  context?: number;
+  "-n"?: boolean;
+  "-i"?: boolean;
+  type?: string;
+  head_limit?: number;
+  offset?: number;
+  multiline?: boolean;
+}
+
+export function buildGrepArguments(params: GrepParameters, cwd: string): string[] {
+  const mode = params.output_mode ?? "files_with_matches";
+  const args = ["--color=never", "--hidden", "--max-columns", "500"];
+  for (const dir of VCS_DIRECTORIES_TO_EXCLUDE) {
+    args.push("--glob", `!${dir}`);
+  }
+  switch (mode) {
+    case "files_with_matches": {
+      args.push("--files-with-matches");
+      break;
+    }
+    case "count": {
+      args.push("--count-matches");
+      break;
+    }
+    case "content": {
+      args.push("--no-heading", "--with-filename");
+      const showLineNumbers = params["-n"] === true || params["-n"] === undefined;
+      if (showLineNumbers) args.push("--line-number");
+      const before = params["-B"];
+      const after = params["-A"];
+      const around = params.context ?? params["-C"];
+      if (around === undefined) {
+        if (before !== undefined) args.push("--before-context", String(before));
+        if (after !== undefined) args.push("--after-context", String(after));
+      } else args.push("--context", String(around));
+
+      break;
+    }
+    // No default
+  }
+  if (params["-i"] === true) args.push("--ignore-case");
+  if (params.glob) args.push("--glob", params.glob);
+  if (params.type) args.push("--type", params.type);
+  if (params.multiline === true) args.push("--multiline", "--multiline-dotall");
+  args.push("--", params.pattern, searchRoot(params.path, cwd));
+  return args;
+}
+
+/**
+ * Sort a newline-separated list of file paths by modification time, most
+ * recent first, with file name as a tiebreaker. Files that can no longer be
+ * stat-ed sort last (mtime 0). Used for files_with_matches output, matching
+ * Claude Code's behaviour.
+ */
+export async function sortFilesByMtime(output: string): Promise<string> {
+  const paths = output.replace(/\n$/, "").split("\n").filter(Boolean);
+  if (paths.length <= 1) return output;
+  const stats = await Promise.allSettled(paths.map((path) => stat(path)));
+  const sorted = paths
+    .map((path, index) => ({
+      path,
+      mtimeMs: stats[index]?.status === "fulfilled" ? stats[index].value.mtimeMs : 0,
+    }))
+    .toSorted((left, right) => right.mtimeMs - left.mtimeMs || left.path.localeCompare(right.path))
+    .map((entry) => entry.path);
+  return sorted.join("\n");
+}
+
+/**
+ * Append an occurrence/file summary to `filename:count` output (count mode),
+ * mirroring Claude Code's "Found N occurrences across M files" result.
+ */
+export function summarizeCountOutput(output: string): string {
+  const lines = output.split("\n").filter((line) => line.includes(":"));
+  let occurrences = 0;
+  for (const line of lines) {
+    const colon = line.lastIndexOf(":");
+    occurrences += Number(line.slice(colon + 1)) || 0;
+  }
+  const files = lines.length;
+  const occurrenceLabel = occurrences === 1 ? "occurrence" : "occurrences";
+  const fileLabel = files === 1 ? "file" : "files";
+  return `${output.trimEnd()}\n\nFound ${occurrences} total ${occurrenceLabel} across ${files} ${fileLabel}.`;
+}
+
+export function pageGrepOutput(output: string, offset = 0, headLimit = 0): string {
+  const lines = output ? output.replace(/\n$/, "").split("\n") : [];
+  if (offset >= lines.length && lines.length > 0) return "No entries at this offset";
+  const selected = headLimit > 0 ? lines.slice(offset, offset + headLimit) : lines.slice(offset);
+  return truncateOutput(selected.join("\n"));
+}
+
+export function registerGrepTool(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "Grep",
+    label: "Grep",
+    description: [
+      "A powerful search tool built on ripgrep.",
+      "Supports regular expressions, file globs, file types, multiline matching, context lines, and paginated output.",
+      'output_mode defaults to "files_with_matches"; use "content" for matching lines or "count" for match counts.',
+    ].join("\n"),
+    parameters: Type.Object(
+      {
+        pattern: Type.String({ description: "The regular expression pattern to search for" }),
+        path: Type.Optional(
+          Type.String({
+            description: "File or directory to search. Defaults to the current directory.",
+          }),
+        ),
+        glob: Type.Optional(
+          Type.String({ description: 'Glob filter such as "*.js" or "*.{ts,tsx}"' }),
+        ),
+        output_mode: Type.Optional(
+          StringEnum(GREP_OUTPUT_MODES, {
+            description: "Output mode. Defaults to files_with_matches.",
+          }),
+        ),
+        "-B": Type.Optional(
+          Type.Number({ description: "Lines to show before each match in content mode" }),
+        ),
+        "-A": Type.Optional(
+          Type.Number({ description: "Lines to show after each match in content mode" }),
+        ),
+        "-C": Type.Optional(
+          Type.Number({ description: "Lines to show before and after each match" }),
+        ),
+        context: Type.Optional(
+          Type.Number({ description: "Lines to show before and after each match" }),
+        ),
+        "-n": Type.Optional(
+          Type.Boolean({ description: "Show line numbers in content mode; defaults true" }),
+        ),
+        "-i": Type.Optional(Type.Boolean({ description: "Case-insensitive search" })),
+        type: Type.Optional(
+          Type.String({ description: "ripgrep file type such as js, py, rust, or go" }),
+        ),
+        head_limit: Type.Optional(
+          Type.Number({ description: "Limit output to the first N entries after offset" }),
+        ),
+        offset: Type.Optional(Type.Number({ description: "Skip the first N output entries" })),
+        multiline: Type.Optional(
+          Type.Boolean({ description: "Allow patterns to span multiple lines" }),
+        ),
+      },
+      { additionalProperties: false },
+    ),
+    async execute(_id, params, signal, _onUpdate, ctx) {
+      if (
+        params.offset !== undefined &&
+        (!Number.isSafeInteger(params.offset) || params.offset < 0)
+      ) {
+        throw new Error("offset must be a non-negative integer");
+      }
+      if (
+        params.head_limit !== undefined &&
+        (!Number.isSafeInteger(params.head_limit) || params.head_limit < 0)
+      ) {
+        throw new Error("head_limit must be a non-negative integer");
+      }
+      const result = await pi.exec("rg", buildGrepArguments(params, ctx.cwd), { signal });
+      throwIfAborted(signal);
+      if (result.code !== 0 && result.code !== 1) {
+        throw new Error(result.stderr.trim() || `ripgrep exited with code ${result.code}`);
+      }
+      if (result.code === 1 || result.stdout === "") {
+        return { content: [{ type: "text", text: "No files found" }], details: { matches: 0 } };
+      }
+      const mode = params.output_mode ?? "files_with_matches";
+      // head_limit defaults to DEFAULT_HEAD_LIMIT; an explicit 0 means unlimited.
+      const stdout =
+        mode === "files_with_matches" ? await sortFilesByMtime(result.stdout) : result.stdout;
+      const text = pageGrepOutput(
+        stdout,
+        params.offset ?? 0,
+        params.head_limit ?? DEFAULT_HEAD_LIMIT,
+      );
+      if (mode === "count") {
+        return {
+          content: [{ type: "text", text: summarizeCountOutput(text) }],
+          details: undefined,
+        };
+      }
+      return { content: [{ type: "text", text }], details: undefined };
+    },
+  });
+}

package/src/claude-code/search.ts

@@ -1,218 +1,22 @@
-import { glob as fsGlob, stat } from "node:fs/promises";
-import { isAbsolute, resolve } from "node:path";
+/**
+ * Claude Code style search tools — `Glob` and `Grep`.
+ *
+ * Aggregation entry that registers both tools; each tool also lives in its own
+ * file (glob.ts / grep.ts) so spawn-agent subagents can load them
+ * independently via the `Glob` / `Grep` frontmatter tool names.
+ */
 
-import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
 
-import { throwIfAborted } from "./common.js";
-
-const GLOB_RESULT_LIMIT = 100;
-const GREP_OUTPUT_MODES = ["content", "files_with_matches", "count"] as const;
-
-type GrepOutputMode = (typeof GREP_OUTPUT_MODES)[number];
-
-function searchRoot(path: string | undefined, cwd: string): string {
-  if (!path) return cwd;
-  return isAbsolute(path) ? path : resolve(cwd, path);
-}
-
-function truncateOutput(output: string, maxCharacters = 30_000): string {
-  if (output.length <= maxCharacters) return output;
-  return `${output.slice(0, maxCharacters)}\n\n[Output truncated at ${maxCharacters} characters]`;
-}
-
-export async function globFiles(
-  pattern: string,
-  cwd: string,
-  signal?: AbortSignal,
-): Promise<string[]> {
-  throwIfAborted(signal);
-  const matches: { path: string; mtimeMs: number }[] = [];
-  for await (const match of fsGlob(pattern, { cwd, exclude: [".git/**"], withFileTypes: false })) {
-    throwIfAborted(signal);
-    const absolutePath = resolve(cwd, match);
-    try {
-      const value = await stat(absolutePath);
-      if (value.isFile()) matches.push({ path: absolutePath, mtimeMs: value.mtimeMs });
-    } catch {
-      // A concurrent filesystem change can remove a match before stat.
-    }
-  }
-  return matches
-    .toSorted((left, right) => right.mtimeMs - left.mtimeMs || left.path.localeCompare(right.path))
-    .slice(0, GLOB_RESULT_LIMIT)
-    .map((match) => match.path);
-}
-
-interface GrepParameters {
-  pattern: string;
-  path?: string;
-  glob?: string;
-  output_mode?: GrepOutputMode;
-  "-B"?: number;
-  "-A"?: number;
-  "-C"?: number;
-  context?: number;
-  "-n"?: boolean;
-  "-i"?: boolean;
-  type?: string;
-  head_limit?: number;
-  offset?: number;
-  multiline?: boolean;
-}
-
-export function buildGrepArguments(params: GrepParameters, cwd: string): string[] {
-  const mode = params.output_mode ?? "files_with_matches";
-  const args = ["--color=never"];
-  switch (mode) {
-    case "files_with_matches": {
-      args.push("--files-with-matches");
-      break;
-    }
-    case "count": {
-      args.push("--count-matches");
-      break;
-    }
-    case "content": {
-      args.push("--no-heading", "--with-filename");
-      if (params["-n"] !== false) args.push("--line-number");
-      const before = params["-B"];
-      const after = params["-A"];
-      const around = params.context ?? params["-C"];
-      if (around === undefined) {
-        if (before !== undefined) args.push("--before-context", String(before));
-        if (after !== undefined) args.push("--after-context", String(after));
-      } else args.push("--context", String(around));
-
-      break;
-    }
-    // No default
-  }
-  if (params["-i"] === true) args.push("--ignore-case");
-  if (params.glob) args.push("--glob", params.glob);
-  if (params.type) args.push("--type", params.type);
-  if (params.multiline === true) args.push("--multiline", "--multiline-dotall");
-  args.push("--", params.pattern, searchRoot(params.path, cwd));
-  return args;
-}
-
-export function pageGrepOutput(output: string, offset = 0, headLimit = 0): string {
-  const lines = output ? output.replace(/\n$/, "").split("\n") : [];
-  if (offset >= lines.length && lines.length > 0) return "No entries at this offset";
-  const selected = headLimit > 0 ? lines.slice(offset, offset + headLimit) : lines.slice(offset);
-  return truncateOutput(selected.join("\n"));
-}
+import { registerGlobTool } from "./glob.js";
+import { registerGrepTool } from "./grep.js";
 
 export function registerSearchTools(pi: ExtensionAPI): void {
-  pi.registerTool({
-    name: "Glob",
-    label: "Glob",
-    description: [
-      "Fast file pattern matching tool that works with any codebase size.",
-      'Supports glob patterns such as "**/*.js" and "src/**/*.ts".',
-      "Returns matching file paths sorted by modification time.",
-    ].join("\n"),
-    parameters: Type.Object(
-      {
-        pattern: Type.String({ description: "The glob pattern to match files against" }),
-        path: Type.Optional(
-          Type.String({
-            description:
-              "The directory to search in. If omitted, the current working directory is used.",
-          }),
-        ),
-      },
-      { additionalProperties: false },
-    ),
-    async execute(_id, params, signal, _onUpdate, ctx) {
-      const root = searchRoot(params.path, ctx.cwd);
-      const matches = await globFiles(params.pattern, root, signal);
-      return {
-        content: [
-          { type: "text", text: matches.length > 0 ? matches.join("\n") : "No files found" },
-        ],
-        details: { count: matches.length },
-      };
-    },
-  });
-
-  pi.registerTool({
-    name: "Grep",
-    label: "Grep",
-    description: [
-      "A powerful search tool built on ripgrep.",
-      "Supports regular expressions, file globs, file types, multiline matching, context lines, and paginated output.",
-      'output_mode defaults to "files_with_matches"; use "content" for matching lines or "count" for match counts.',
-    ].join("\n"),
-    parameters: Type.Object(
-      {
-        pattern: Type.String({ description: "The regular expression pattern to search for" }),
-        path: Type.Optional(
-          Type.String({
-            description: "File or directory to search. Defaults to the current directory.",
-          }),
-        ),
-        glob: Type.Optional(
-          Type.String({ description: 'Glob filter such as "*.js" or "*.{ts,tsx}"' }),
-        ),
-        output_mode: Type.Optional(
-          StringEnum(GREP_OUTPUT_MODES, {
-            description: "Output mode. Defaults to files_with_matches.",
-          }),
-        ),
-        "-B": Type.Optional(
-          Type.Number({ description: "Lines to show before each match in content mode" }),
-        ),
-        "-A": Type.Optional(
-          Type.Number({ description: "Lines to show after each match in content mode" }),
-        ),
-        "-C": Type.Optional(
-          Type.Number({ description: "Lines to show before and after each match" }),
-        ),
-        context: Type.Optional(
-          Type.Number({ description: "Lines to show before and after each match" }),
-        ),
-        "-n": Type.Optional(
-          Type.Boolean({ description: "Show line numbers in content mode; defaults true" }),
-        ),
-        "-i": Type.Optional(Type.Boolean({ description: "Case-insensitive search" })),
-        type: Type.Optional(
-          Type.String({ description: "ripgrep file type such as js, py, rust, or go" }),
-        ),
-        head_limit: Type.Optional(
-          Type.Number({ description: "Limit output to the first N entries after offset" }),
-        ),
-        offset: Type.Optional(Type.Number({ description: "Skip the first N output entries" })),
-        multiline: Type.Optional(
-          Type.Boolean({ description: "Allow patterns to span multiple lines" }),
-        ),
-      },
-      { additionalProperties: false },
-    ),
-    async execute(_id, params, signal, _onUpdate, ctx) {
-      if (
-        params.offset !== undefined &&
-        (!Number.isSafeInteger(params.offset) || params.offset < 0)
-      ) {
-        throw new Error("offset must be a non-negative integer");
-      }
-      if (
-        params.head_limit !== undefined &&
-        (!Number.isSafeInteger(params.head_limit) || params.head_limit < 0)
-      ) {
-        throw new Error("head_limit must be a non-negative integer");
-      }
-      const result = await pi.exec("rg", buildGrepArguments(params, ctx.cwd), { signal });
-      throwIfAborted(signal);
-      if (result.code !== 0 && result.code !== 1) {
-        throw new Error(result.stderr.trim() || `ripgrep exited with code ${result.code}`);
-      }
-      if (result.code === 1 || result.stdout === "") {
-        return { content: [{ type: "text", text: "No files found" }], details: { matches: 0 } };
-      }
-      const text = pageGrepOutput(result.stdout, params.offset ?? 0, params.head_limit ?? 0);
-      return { content: [{ type: "text", text }], details: undefined };
-    },
-  });
+  registerGlobTool(pi);
+  registerGrepTool(pi);
 }
+
+// Re-exported for tests and other modules that import pure functions from
+// "./search.js"; the implementations live in the split files above.
+export { globFiles } from "./glob.js";
+export { buildGrepArguments, pageGrepOutput } from "./grep.js";

package/src/claude-code/session-tools.ts

@@ -2,6 +2,8 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
+import { selectWithOptionalInput } from "../lib/ui.js";
+
 const TODO_STATUSES = ["pending", "in_progress", "completed"] as const;
 const OTHER_OPTION = "Other";
 const DONE_OPTION = "Done";
@@ -45,15 +47,17 @@ async function askSingle(
   signal: AbortSignal | undefined,
 ): Promise<string> {
   const title = `${question.header}: ${question.question}`;
-  const selected = await ctx.ui.select(
+  const result = await selectWithOptionalInput(
     title,
-    [...question.options.map((option) => option.label), OTHER_OPTION],
+    [
+      ...question.options.map((option) => ({ label: option.label })),
+      { label: OTHER_OPTION, inputPrompt: "Type your answer" },
+    ],
+    ctx.ui,
     { signal },
   );
-  if (selected === undefined) return "Unanswered";
-  if (selected !== OTHER_OPTION) return selected;
-  const answer = await ctx.ui.input(title, "Type your answer", { signal });
-  return answer?.trim() || "Unanswered";
+  if (result === undefined) return "Unanswered";
+  return result.prompted ? result.input || "Unanswered" : result.label;
 }
 
 async function askMultiple(
@@ -65,16 +69,22 @@ async function askMultiple(
   const remaining = new Set(question.options.map((option) => option.label));
   const selected: string[] = [];
   while (remaining.size > 0) {
-    const choice = await ctx.ui.select(title, [...remaining, OTHER_OPTION, DONE_OPTION], {
-      signal,
-    });
-    if (choice === undefined || choice === DONE_OPTION) break;
-    if (choice === OTHER_OPTION) {
-      const answer = await ctx.ui.input(title, "Type your answer", { signal });
-      if (answer?.trim()) selected.push(answer.trim());
+    const result = await selectWithOptionalInput(
+      title,
+      [
+        ...[...remaining].map((label) => ({ label })),
+        { label: OTHER_OPTION, inputPrompt: "Type your answer" },
+        { label: DONE_OPTION },
+      ],
+      ctx.ui,
+      { signal },
+    );
+    if (result === undefined || result.label === DONE_OPTION) break;
+    if (result.prompted) {
+      if (result.input) selected.push(result.input);
       break;
     }
-    if (remaining.delete(choice)) selected.push(choice);
+    if (remaining.delete(result.label)) selected.push(result.label);
   }
   return selected.length > 0 ? selected.join(", ") : "Unanswered";
 }

package/src/lib/ui.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared interactive UI helpers used by multiple extensions.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export interface SelectAction {
+  label: string;
+  /**
+   * Set to turn this entry into a free-text input: picking it opens an input
+   * dialog instead of returning immediately. The typed text (trimmed) is
+   * reported via `SelectActionResult.input`; `undefined` means the input
+   * dialog was cancelled, `""` that an empty value was submitted.
+   */
+  inputPrompt?: string;
+}
+
+export interface SelectActionResult {
+  label: string;
+  /** Whether the picked action carries an inputPrompt (false for plain actions) */
+  prompted: boolean;
+  /** Meaningful when prompted: undefined=cancelled input, ""=blank submission, otherwise the trimmed text */
+  input?: string;
+}
+
+/**
+ * Combined select + optional input dialog.
+ *
+ * Shows a selection list built from `actions`. If the user picks an action
+ * with `inputPrompt`, an input dialog opens for free-text entry. Returns
+ * `undefined` when the selection list is dismissed.
+ */
+export async function selectWithOptionalInput(
+  title: string,
+  actions: readonly SelectAction[],
+  ui: ExtensionContext["ui"],
+  opts: { signal?: AbortSignal } = {},
+): Promise<SelectActionResult | undefined> {
+  const { signal } = opts;
+  const choice = await ui.select(
+    title,
+    actions.map((action) => action.label),
+    { signal },
+  );
+  if (choice === undefined) return undefined;
+  const action = actions.find((candidate) => candidate.label === choice);
+  if (action?.inputPrompt === undefined) return { label: choice, prompted: false };
+  const answer = await ui.input(title, action.inputPrompt, { signal });
+  return {
+    label: choice,
+    prompted: true,
+    input: answer === undefined ? undefined : answer.trim(),
+  };
+}

package/src/opencode/question.ts

@@ -23,6 +23,8 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
+import { selectWithOptionalInput } from "../lib/ui.js";
+
 // ── constants ────────────────────────────────────────────────────────────────
 
 export const TOOL_NAME = "question";
@@ -117,14 +119,16 @@ function dialogTitle(q: Question): string {
 
 async function askSingle(q: Question, ctx: ExtensionContext): Promise<Answer> {
   const title = dialogTitle(q);
-  const options = [...q.options.map((o) => o.label), CUSTOM_LABEL];
-  const choice = await ctx.ui.select(title, options);
-  if (choice === undefined) return [];
-  if (choice === CUSTOM_LABEL) {
-    const typed = await ctx.ui.input(title, "Type your answer…");
-    return typed?.trim() ? [typed.trim()] : [];
-  }
-  return [choice];
+  const result = await selectWithOptionalInput(
+    title,
+    [
+      ...q.options.map((o) => ({ label: o.label })),
+      { label: CUSTOM_LABEL, inputPrompt: "Type your answer…" },
+    ],
+    ctx.ui,
+  );
+  if (result === undefined) return [];
+  return result.prompted ? (result.input ? [result.input] : []) : [result.label];
 }
 
 async function askMultiple(q: Question, ctx: ExtensionContext): Promise<Answer> {

package/src/spawn-agent.ts

@@ -49,22 +49,28 @@ const DEFAULT_TOOLS = ["read", "grep", "find", "ls"];
 /** Progress log keeps only the most recent lines (rolling window). */
 const MAX_PROGRESS_LINES = 5;
 
-/**
- * Extensions loaded unconditionally into every subagent: the bwrap sandbox is a
- * protection layer and must not depend on the agent's declared toolset.
- * (Workspace write protection is embedded in the opencode write/edit tools.)
- */
-const UNCONDITIONAL_EXTENSIONS = ["bwrap/index.ts"] as const;
-
 /**
  * Tool → extension override map: when a subagent's frontmatter enables a
  * built-in tool, the matching opencode extension is loaded via `-e` so the
  * subagent uses the enhanced implementation instead of the built-in one.
+ *
+ * The bash override also carries the bwrap sandbox: opencode/bash.ts calls
+ * bwrapRuntime.setup() and runs commands through bwrapRuntime.execute(), so
+ * agents that declare the bash tool get sandboxing automatically. Agents
+ * without bash need no bwrap setup (there are no commands to sandbox).
+ * (Workspace write protection is embedded in the opencode write/edit tools.)
+ *
+ * Claude Code style tools (capitalized names, e.g. `Grep`/`Glob`) map to
+ * their split claude-code files, so a subagent can enable exactly the search
+ * tools it declares — e.g. `Grep` without `Glob`.
  */
 const TOOL_EXTENSION_OVERRIDES: Record<string, string> = {
   read: "opencode/read.ts",
   edit: "opencode/edit.ts",
   write: "opencode/write.ts",
+  bash: "opencode/bash.ts",
+  Grep: "claude-code/grep.ts",
+  Glob: "claude-code/glob.ts",
 };
 
 // ── schema ───────────────────────────────────────────────────────────────────
@@ -185,15 +191,9 @@ export function buildSubagentArgs(
   // dialog responses over stdin. --no-session keeps the child ephemeral.
   // --no-extensions disables
   // extension discovery; only the extensions explicitly loaded below (the
-  // unconditional guards plus per-tool overrides) run inside the subagent.
+  // per-tool overrides) run inside the subagent.
   const args: string[] = ["--mode", "rpc", "--no-session", "--no-extensions"];
 
-  // Protection layers that must be present in every subagent regardless of
-  // its declared toolset: the workspace write guard and the bwrap sandbox.
-  for (const ext of UNCONDITIONAL_EXTENSIONS) {
-    args.push("-e", extensionPath(ext));
-  }
-
   // Thinking level rides on the model shorthand ("model:level"); it cannot be
   // set without a model, so a level without a model is ignored.
   const model =