@botconnector/bccli 0.4.0-beta.37 → 0.4.0-beta.39

package/dist/{chunk-HXSREA7S.js → chunk-ZMU7MXCH.js}

@@ -1,262 +1,65 @@
 #!/usr/bin/env node
 import {
-  ConfigError
-} from "./chunk-H5N4ST6B.js";
+  defineTool
+} from "./chunk-PSO7R5AD.js";
 import {
   t
-} from "./chunk-4RMP4CNT.js";
+} from "./chunk-M23QBX3V.js";
 
-// src/hooks.ts
+// src/tools/bash.ts
 import { spawn } from "child_process";
-var DEFAULT_TIMEOUT_MS = 1e4;
-var MAX_CAPTURE = 8192;
-function globToRegExp(pattern) {
-  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
-}
-function runOne(command, event, payload, opts) {
-  const env = {
-    ...process.env,
-    ...opts.env,
-    BCCLI_HOOK_EVENT: event,
-    ...payload.tool !== void 0 ? { BCCLI_HOOK_TOOL: payload.tool } : {},
-    ...payload.input !== void 0 ? { BCCLI_HOOK_INPUT: JSON.stringify(payload.input) } : {},
-    ...payload.output !== void 0 ? { BCCLI_HOOK_OUTPUT: payload.output } : {}
-  };
-  return new Promise((resolve) => {
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    let settled = false;
-    const finish = (result) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(result);
-    };
-    let child;
-    try {
-      child = spawn(command, { shell: true, env, cwd: opts.cwd ?? process.cwd(), stdio: ["ignore", "pipe", "pipe"] });
-    } catch (error) {
-      resolve({ failure: error.message });
-      return;
-    }
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill();
-    }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    child.stdout?.on("data", (chunk) => {
-      if (stdout.length < MAX_CAPTURE) stdout += String(chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      if (stderr.length < MAX_CAPTURE) stderr += String(chunk);
-    });
-    child.on("error", (error) => finish({ failure: error.message }));
-    child.on("close", (code) => {
-      if (timedOut) {
-        finish({ failure: "timed out" });
-        return;
-      }
-      if (event === "PreToolUse" && code === 2) {
-        finish({ blocked: stderr.trim() || stdout.trim() || "Blocked by a PreToolUse hook." });
-        return;
-      }
-      if (code !== 0) {
-        const detail = stderr.trim().split("\n")[0];
-        finish({ failure: detail ? `exit ${code}: ${detail}` : `exit ${code}` });
-        return;
-      }
-      finish({});
-    });
-  });
-}
-async function runHooks(hooks, event, payload = {}, opts = {}) {
-  const rules = hooks?.[event];
-  if (!Array.isArray(rules) || rules.length === 0) return { warnings: [] };
-  const warnings = [];
-  let blocked;
-  for (const rule of rules) {
-    if (!rule || typeof rule.command !== "string" || rule.command.length === 0) continue;
-    if (payload.tool !== void 0 && rule.match && !globToRegExp(rule.match).test(payload.tool)) continue;
-    const result = await runOne(rule.command, event, payload, opts);
-    if (result.blocked) {
-      blocked = result.blocked;
-      break;
-    }
-    if (result.failure) warnings.push(t("Hook {event} failed: {reason}", { event, reason: result.failure }));
-  }
-  return { blocked, warnings };
-}
-
-// src/print.ts
-function toolLabel(tool) {
-  if (tool === "web_search") return "Search";
-  return tool.charAt(0).toUpperCase() + tool.slice(1);
-}
-async function runPrint(rt, prompt, io = { out: process.stdout, err: process.stderr }, opts = {}) {
-  const format = opts.outputFormat ?? "text";
-  const emit = (line) => io.out.write(`${JSON.stringify(line)}
-`);
-  let result = "";
-  const toolNames = /* @__PURE__ */ new Map();
-  rt.interaction.approvePlan = async () => {
-    if (opts.allowAll) return "allowAll";
-    io.err.write(`${t("Plan needs approval; run with --allow-all.")}
-`);
-    return "no";
-  };
-  let failed = false;
-  let wroteText = false;
-  rt.agent.onEvent = (event) => {
-    switch (event.type) {
-      case "text":
-        if (format === "text") {
-          io.out.write(event.delta);
-          wroteText = true;
-        } else {
-          result += event.delta;
-        }
-        break;
-      case "toolStart":
-        toolNames.set(event.id, event.tool);
-        io.err.write(`\u23BF ${toolLabel(event.tool)}  ${event.target}
-`);
-        if (format === "stream-json") emit({ type: "tool_use", tool: event.tool, target: event.target });
-        break;
-      case "toolEnd":
-        if (event.isError) io.err.write(`  \u2717 ${event.output.split("\n")[0]}
-`);
-        if (format === "stream-json") emit({ type: "tool_result", tool: toolNames.get(event.id), isError: !!event.isError, output: event.output });
-        break;
-      case "stepLimit":
-        io.err.write(`${t("Step limit reached.")}
-`);
-        failed = true;
-        break;
-      case "aborted":
-        io.err.write(`${t("Cancelled.")}
-`);
-        failed = true;
-        break;
-      case "error":
-        io.err.write(`Error: ${event.message}
-`);
-        if (format === "stream-json") emit({ type: "error", message: event.message });
-        failed = true;
-        break;
-    }
-  };
-  rt.agent.askPermission = async (req) => {
-    io.err.write(`  ${t("Needs permission for {tool}. Run with --allow-all or --allowed-tools {kind}.", { tool: req.tool, kind: req.kind })}
-`);
-    return "no";
-  };
-  const controller = new AbortController();
-  const onSigint = () => controller.abort();
-  process.once("SIGINT", onSigint);
-  const start = await runHooks(rt.config.hooks, "SessionStart", {}, { env: rt.env, cwd: rt.cwd });
-  for (const warning of start.warnings) io.err.write(`${warning}
-`);
-  await rt.emitPlugins("SessionStart");
-  try {
-    await rt.agent.run(prompt, controller.signal);
-  } finally {
-    process.off("SIGINT", onSigint);
-  }
-  const stop = await runHooks(rt.config.hooks, "Stop", {}, { env: rt.env, cwd: rt.cwd });
-  for (const warning of stop.warnings) io.err.write(`${warning}
-`);
-  await rt.emitPlugins("Stop");
-  if (format === "json") {
-    io.out.write(`${JSON.stringify({ status: failed ? "failed" : "ok", model: rt.modelRef, result })}
-`);
-  } else if (format === "stream-json") {
-    if (result) emit({ type: "message", text: result });
-    emit({ type: "result", status: failed ? "failed" : "ok", model: rt.modelRef });
-  } else if (wroteText) {
-    io.out.write("\n");
-  }
-  return failed ? 1 : 0;
-}
+import { z } from "zod";
 
-// src/worktree.ts
-import { execFile } from "child_process";
-import { existsSync } from "fs";
-import { basename, dirname, join } from "path";
-function git(cwd, args, bin = "git") {
-  return new Promise((resolve) => {
-    execFile(
-      bin,
-      args,
-      { cwd, maxBuffer: 20 * 1024 * 1024 },
-      (error, stdout, stderr) => resolve({ ok: !error, out: error ? stderr : stdout, missing: error?.code === "ENOENT" })
-    );
-  });
-}
-var NAME_RE = /^[A-Za-z0-9._-]+$/;
-function samePath(a, b) {
-  const norm = (p) => process.platform === "win32" ? p.replace(/\//g, "\\").toLowerCase() : p.replace(/\\/g, "/");
-  return norm(a) === norm(b);
-}
-function worktreeEntries(porcelain) {
-  return porcelain.split(/\r?\n\r?\n/).map((block) => {
-    const path = /^worktree (.+)$/m.exec(block)?.[1]?.trim();
-    if (!path) return void 0;
-    const branch = /^branch refs\/heads\/(.+)$/m.exec(block)?.[1];
-    return branch ? { path, branch } : { path };
-  }).filter((entry) => !!entry);
-}
-async function resolveWorktree(cwd, name, bin = "git") {
-  if (!NAME_RE.test(name)) {
-    throw new ConfigError(t('Invalid worktree name "{name}": use letters, digits, dot, dash, or underscore (no slashes).', { name }));
-  }
-  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
-  if (inside.missing) throw new ConfigError(t("git is not installed or not on PATH, so -w cannot be used."));
-  if (!inside.ok || inside.out.trim() !== "true") throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
-  const list2 = await git(cwd, ["worktree", "list", "--porcelain"], bin);
-  if (!list2.ok) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
-  const entries = worktreeEntries(list2.out);
-  const main = entries[0]?.path;
-  if (!main) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
-  const path = join(dirname(main), `${basename(main)}.worktrees`, name);
-  if (entries.some((entry) => samePath(entry.path, path))) return { path, created: false };
-  if (existsSync(path)) {
-    throw new ConfigError(t("Worktree path {path} already exists but is not a registered worktree; remove or rename it first.", { path }));
-  }
-  const branch = `bccli/${name}`;
-  const hasBranch = (await git(main, ["rev-parse", "--verify", "-q", `refs/heads/${branch}`], bin)).ok;
-  const add = hasBranch ? await git(main, ["worktree", "add", path, branch], bin) : await git(main, ["worktree", "add", "-b", branch, path], bin);
-  if (!add.ok) throw new ConfigError(add.out.trim() || t("This folder is not a git repository, so -w cannot create a worktree."));
-  return { path, created: true };
-}
-async function worktreeListText(cwd, bin = "git") {
-  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
-  if (inside.missing) return t("git is not installed or not on PATH, so /worktree cannot be used.");
-  if (!inside.ok || inside.out.trim() !== "true") return t("This folder is not a git repository, so there is no diff.");
-  const list2 = await git(cwd, ["worktree", "list", "--porcelain"], bin);
-  if (!list2.ok) return t("This folder is not a git repository, so there is no diff.");
-  const rows = worktreeEntries(list2.out).map((entry) => `  ${entry.path}${entry.branch ? ` (${entry.branch})` : ""}`);
+// src/tools/sandbox.ts
+function darwinProfile(cwd, network) {
+  const writable = [cwd, "/tmp", "/private/tmp", "/dev", "/var/folders"].map((p) => `(subpath "${p}")`).join(" ");
   return [
-    t("Git worktrees:"),
-    ...rows,
-    "",
-    t("Create one with: bccli -w <name>"),
-    t("Remove with: git worktree remove <path>")
+    "(version 1)",
+    "(deny default)",
+    "(allow process*)",
+    "(allow signal (target self))",
+    "(allow sysctl-read)",
+    "(allow file-read*)",
+    `(allow file-write* ${writable})`,
+    "(allow mach-lookup)",
+    "(allow ipc-posix*)",
+    network ? "(allow network*)" : "(deny network*)"
   ].join("\n");
 }
-
-// src/tools/bash.ts
-import { spawn as spawn2 } from "child_process";
-import { z } from "zod";
-
-// src/tools/types.ts
-function defineTool(tool) {
-  return tool;
+function sandboxArgv(command, opts) {
+  if (opts.platform === "darwin") {
+    return ["sandbox-exec", "-p", darwinProfile(opts.cwd, opts.network), "/bin/bash", "-c", command];
+  }
+  if (opts.platform === "linux") {
+    return [
+      "bwrap",
+      "--ro-bind",
+      "/",
+      "/",
+      "--dev-bind",
+      "/dev",
+      "/dev",
+      "--proc",
+      "/proc",
+      "--bind",
+      opts.cwd,
+      opts.cwd,
+      "--tmpfs",
+      "/tmp",
+      "--die-with-parent",
+      ...opts.network ? [] : ["--unshare-net"],
+      "--",
+      "/bin/bash",
+      "-c",
+      command
+    ];
+  }
+  return void 0;
 }
 
 // src/tools/bash.ts
 var HALF = 15e3;
-function killProcessTree(pid, platform = process.platform, spawnFn = spawn2) {
+function killProcessTree(pid, platform = process.platform, spawnFn = spawn) {
   if (platform === "win32") {
     const killer = spawnFn("taskkill", ["/pid", String(pid), "/T", "/F"]);
     killer.on("error", () => {
@@ -285,16 +88,10 @@ function killAllCommands() {
 var backgrounds = /* @__PURE__ */ new Map();
 var nextBackgroundId = 1;
 function startBackground(command, cwd, env) {
-  const child = spawn2(command, {
-    cwd,
-    shell: true,
-    detached: process.platform !== "win32",
-    stdio: ["ignore", "pipe", "pipe"],
-    env
-  });
+  const child = spawnChild(command, cwd, env);
   const task = {
     id: nextBackgroundId++,
-    command,
+    command: Array.isArray(command) ? command.join(" ") : command,
     startedAt: Date.now(),
     status: "running",
     killed: false,
@@ -362,6 +159,9 @@ function renderBackgroundTasks() {
   return `Background tasks:
 ${lines.join("\n")}`;
 }
+function spawnChild(command, cwd, env) {
+  return Array.isArray(command) ? spawn(command[0], command.slice(1), { cwd, detached: process.platform !== "win32", stdio: ["ignore", "pipe", "pipe"], env }) : spawn(command, { cwd, shell: true, detached: process.platform !== "win32", stdio: ["ignore", "pipe", "pipe"], env });
+}
 var NETWORK_PATTERNS = [
   /\b(curl|wget|ftp|scp|sftp|rsync|lynx|telnet)\b/i,
   /\bssh\b/i,
@@ -396,13 +196,7 @@ function offlineEnv(env = process.env) {
 }
 function runCommand(command, opts) {
   return new Promise((resolve) => {
-    const child = spawn2(command, {
-      cwd: opts.cwd,
-      shell: true,
-      detached: process.platform !== "win32",
-      stdio: ["ignore", "pipe", "pipe"],
-      env: opts.env
-    });
+    const child = spawnChild(command, opts.cwd, opts.env);
     if (!exitHookInstalled) {
       process.on("exit", killAllCommands);
       exitHookInstalled = true;
@@ -472,9 +266,11 @@ var BASH_SCHEMA = z.object({
 });
 function createBashTool(options = {}) {
   const offline = options.networkPolicy === "offline";
+  const sandbox = options.sandbox === true;
+  const platform = options.platform ?? process.platform;
   const childEnv = offline ? offlineEnv() : void 0;
-  const description = offline ? `${BASH_DESCRIPTION}
-Network access is off (networkPolicy "offline"): internet commands such as curl, wget, git fetch/push/clone, package installs (npm, pip, ...), gh, and docker pull are blocked.` : BASH_DESCRIPTION;
+  const description = `${offline ? `${BASH_DESCRIPTION}
+Network access is off (networkPolicy "offline"): internet commands such as curl, wget, git fetch/push/clone, package installs (npm, pip, ...), gh, and docker pull are blocked.` : BASH_DESCRIPTION}${sandbox ? "\nCommands run inside an OS sandbox: file writes are limited to the working directory and temp areas." : ""}`;
   return defineTool({
     name: "bash",
     description,
@@ -501,9 +297,20 @@ Network access is off (networkPolicy "offline"): internet commands such as curl,
           isError: true
         };
       }
+      let exec = input.command ?? "";
+      if (input.command && sandbox) {
+        const argv = sandboxArgv(input.command, { platform, cwd: ctx.cwd, network: !offline });
+        if (!argv) {
+          return {
+            output: `The bash sandbox is not supported on ${platform}; disable "sandbox" in ~/.bccli/config.json or run on macOS (sandbox-exec) / Linux (bwrap).`,
+            isError: true
+          };
+        }
+        exec = argv;
+      }
       if (input.background) {
         if (!input.command) return { output: 'The "command" argument is required to start a background task.', isError: true };
-        const task = startBackground(input.command, ctx.cwd, childEnv);
+        const task = startBackground(exec, ctx.cwd, childEnv);
         return {
           output: `Background task #${task.id} started: ${input.command}
 Poll it with {task_id: ${task.id}}; stop it with {task_id: ${task.id}, kill: true}.`
@@ -512,7 +319,7 @@ Poll it with {task_id: ${task.id}}; stop it with {task_id: ${task.id}, kill: tru
       if (!input.command) {
         return { output: 'The "command" argument is required (or set task_id to poll a background task).', isError: true };
       }
-      const r = await runCommand(input.command, {
+      const r = await runCommand(exec, {
         cwd: ctx.cwd,
         timeoutMs: input.timeout_ms ?? 12e4,
         signal: ctx.signal,
@@ -546,23 +353,23 @@ var BUILTIN_AGENTS = [
 ];
 
 // src/context.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
 var FILES = ["AGENTS.md", "BCCLI.md"];
 function readIf(path) {
   try {
-    return existsSync2(path) ? readFileSync(path, "utf8").trim() : void 0;
+    return existsSync(path) ? readFileSync(path, "utf8").trim() : void 0;
   } catch {
     return void 0;
   }
 }
 function instructionPaths(cwd, home) {
   const dirs2 = [];
-  for (let dir = cwd; ; dir = dirname2(dir)) {
+  for (let dir = cwd; ; dir = dirname(dir)) {
     dirs2.unshift(dir);
-    if (dirname2(dir) === dir) break;
+    if (dirname(dir) === dir) break;
   }
-  return [join2(home, "BCCLI.md"), ...dirs2.flatMap((dir) => FILES.map((name) => join2(dir, name)))];
+  return [join(home, "BCCLI.md"), ...dirs2.flatMap((dir) => FILES.map((name) => join(dir, name)))];
 }
 function loadInstructions(cwd, home) {
   const parts = [];
@@ -574,9 +381,9 @@ ${text}`);
   return parts.join("\n\n");
 }
 function isGitRepo(cwd) {
-  for (let dir = cwd; ; dir = dirname2(dir)) {
-    if (existsSync2(join2(dir, ".git"))) return true;
-    if (dirname2(dir) === dir) return false;
+  for (let dir = cwd; ; dir = dirname(dir)) {
+    if (existsSync(join(dir, ".git"))) return true;
+    if (dirname(dir) === dir) return false;
   }
 }
 function buildSystemPrompt(opts) {
@@ -586,6 +393,10 @@ function buildSystemPrompt(opts) {
 
 Skills (load one with the skill tool when it matches the task):
 ${skills.map((s) => `- ${s.name}: ${s.description.slice(0, 200)}`).join("\n")}` : "";
+  const mapText = opts.repoMap ? `
+
+Repository map (files and top-level symbols):
+${opts.repoMap}` : "";
   return `You are a coding agent running in the user's terminal, inside BCCLI (BotConnector's terminal app). You help with software engineering tasks by reading code, editing files, and running commands with the tools provided.
 
 How to work:
@@ -607,7 +418,7 @@ Environment:
 - Git repository: ${isGitRepo(opts.cwd) ? "yes" : "no"}
 - Platform: ${opts.platform ?? process.platform}
 - Date: ${opts.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
-- Model: ${opts.model}${skillText}${instructions ? `
+- Model: ${opts.model}${skillText}${mapText}${instructions ? `
 
 Project and user instructions (follow them):
 
@@ -615,8 +426,8 @@ ${instructions}` : ""}`;
 }
 
 // src/extensions.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { basename as basename2, join as join3 } from "path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { basename, join as join2 } from "path";
 function parseFrontmatter(text) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
   if (!match) return { data: {}, body: text };
@@ -636,7 +447,7 @@ function parseFrontmatter(text) {
 }
 var str = (v) => Array.isArray(v) ? v.join(", ") : v;
 function dirs(r, kind) {
-  return [join3(r.userHome, ".claude", kind), join3(r.home, kind), join3(r.cwd, ".claude", kind), join3(r.cwd, ".bccli", kind)];
+  return [join2(r.userHome, ".claude", kind), join2(r.home, kind), join2(r.cwd, ".claude", kind), join2(r.cwd, ".bccli", kind)];
 }
 function list(dir) {
   try {
@@ -649,11 +460,11 @@ function loadSkills(r) {
   const byName = /* @__PURE__ */ new Map();
   for (const dir of dirs(r, "skills")) {
     for (const entry of list(dir)) {
-      const file = join3(dir, entry, "SKILL.md");
-      if (!existsSync3(file)) continue;
+      const file = join2(dir, entry, "SKILL.md");
+      if (!existsSync2(file)) continue;
       const { data } = parseFrontmatter(readFileSync2(file, "utf8"));
       const name = str(data.name) || entry;
-      byName.set(name, { name, description: str(data.description) ?? "", dir: join3(dir, entry), file });
+      byName.set(name, { name, description: str(data.description) ?? "", dir: join2(dir, entry), file });
     }
   }
   return [...byName.values()];
@@ -662,10 +473,10 @@ function loadCommands(r) {
   const byName = /* @__PURE__ */ new Map();
   for (const dir of dirs(r, "commands")) {
     for (const entry of list(dir)) {
-      const file = join3(dir, entry);
+      const file = join2(dir, entry);
       if (!entry.endsWith(".md") || !statSync(file).isFile()) continue;
       const { data, body } = parseFrontmatter(readFileSync2(file, "utf8"));
-      const def = { name: basename2(entry, ".md"), body: body.trim() };
+      const def = { name: basename(entry, ".md"), body: body.trim() };
       if (data.description) def.description = str(data.description);
       if (data["argument-hint"]) def.argumentHint = str(data["argument-hint"]);
       byName.set(def.name, def);
@@ -678,8 +489,8 @@ function loadAgentDefs(r) {
   for (const dir of dirs(r, "agents")) {
     for (const entry of list(dir)) {
       if (!entry.endsWith(".md")) continue;
-      const { data, body } = parseFrontmatter(readFileSync2(join3(dir, entry), "utf8"));
-      const name = str(data.name) || basename2(entry, ".md");
+      const { data, body } = parseFrontmatter(readFileSync2(join2(dir, entry), "utf8"));
+      const name = str(data.name) || basename(entry, ".md");
       const def = { name, description: str(data.description) ?? "", prompt: body.trim() };
       if (data.tools)
         def.tools = Array.isArray(data.tools) ? data.tools : String(data.tools).split(",").map((s) => s.trim()).filter(Boolean);
@@ -696,13 +507,95 @@ function loadAgentDefs(r) {
   return [...byName.values()];
 }
 
+// src/hooks.ts
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MAX_CAPTURE = 8192;
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function runOne(command, event, payload, opts) {
+  const env = {
+    ...process.env,
+    ...opts.env,
+    BCCLI_HOOK_EVENT: event,
+    ...payload.tool !== void 0 ? { BCCLI_HOOK_TOOL: payload.tool } : {},
+    ...payload.input !== void 0 ? { BCCLI_HOOK_INPUT: JSON.stringify(payload.input) } : {},
+    ...payload.output !== void 0 ? { BCCLI_HOOK_OUTPUT: payload.output } : {}
+  };
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    let child;
+    try {
+      child = spawn2(command, { shell: true, env, cwd: opts.cwd ?? process.cwd(), stdio: ["ignore", "pipe", "pipe"] });
+    } catch (error) {
+      resolve({ failure: error.message });
+      return;
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < MAX_CAPTURE) stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < MAX_CAPTURE) stderr += String(chunk);
+    });
+    child.on("error", (error) => finish({ failure: error.message }));
+    child.on("close", (code) => {
+      if (timedOut) {
+        finish({ failure: "timed out" });
+        return;
+      }
+      if (event === "PreToolUse" && code === 2) {
+        finish({ blocked: stderr.trim() || stdout.trim() || "Blocked by a PreToolUse hook." });
+        return;
+      }
+      if (code !== 0) {
+        const detail = stderr.trim().split("\n")[0];
+        finish({ failure: detail ? `exit ${code}: ${detail}` : `exit ${code}` });
+        return;
+      }
+      finish({});
+    });
+  });
+}
+async function runHooks(hooks, event, payload = {}, opts = {}) {
+  const rules = hooks?.[event];
+  if (!Array.isArray(rules) || rules.length === 0) return { warnings: [] };
+  const warnings = [];
+  let blocked;
+  for (const rule of rules) {
+    if (!rule || typeof rule.command !== "string" || rule.command.length === 0) continue;
+    if (payload.tool !== void 0 && rule.match && !globToRegExp(rule.match).test(payload.tool)) continue;
+    const result = await runOne(rule.command, event, payload, opts);
+    if (result.blocked) {
+      blocked = result.blocked;
+      break;
+    }
+    if (result.failure) warnings.push(t("Hook {event} failed: {reason}", { event, reason: result.failure }));
+  }
+  return { blocked, warnings };
+}
+
 // src/slash/memory.ts
-import { appendFileSync, existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 function instructionFiles(cwd, home) {
-  return instructionPaths(cwd, home).filter((path) => existsSync4(path)).map((path) => ({ path, lines: readFileSync3(path, "utf8").split("\n").filter(Boolean).length }));
+  return instructionPaths(cwd, home).filter((path) => existsSync3(path)).map((path) => ({ path, lines: readFileSync3(path, "utf8").split("\n").filter(Boolean).length }));
 }
 function appendMemory(file, text) {
-  const prefix = existsSync4(file) && !readFileSync3(file, "utf8").endsWith("\n") ? "\n" : "";
+  const prefix = existsSync3(file) && !readFileSync3(file, "utf8").endsWith("\n") ? "\n" : "";
   appendFileSync(file, `${prefix}- ${text.trim()}
 `);
 }
@@ -713,12 +606,12 @@ function parseMemoryArgs(args) {
 
 // src/tools/ignore.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 function ignorePatterns(root) {
   const patterns = ["**/node_modules/**", "**/.git/**"];
   let lines = [];
   try {
-    lines = readFileSync4(join4(root, ".gitignore"), "utf8").split(/\r?\n/);
+    lines = readFileSync4(join3(root, ".gitignore"), "utf8").split(/\r?\n/);
   } catch {
     return patterns;
   }
@@ -762,10 +655,8 @@ function normalizeGlobPath(path) {
 
 export {
   runHooks,
-  toolLabel,
-  runPrint,
-  defineTool,
   renderBackgroundTasks,
+  runCommand,
   createBashTool,
   bashTool,
   ignorePatterns,
@@ -779,7 +670,5 @@ export {
   loadAgentDefs,
   instructionFiles,
   appendMemory,
-  parseMemoryArgs,
-  resolveWorktree,
-  worktreeListText
+  parseMemoryArgs
 };