autohand-cli 0.8.3 → 0.9.1

package/dist/{chunk-NAGQ2PDC.js → chunk-YC5OBZQU.js}

@@ -1,34 +1,53 @@
 import {
-  PermissionManager
-} from "./chunk-DNUOXBHL.js";
+  GitIgnoreParser
+} from "./chunk-H4D2Q2AL.js";
+import {
+  GoalManager
+} from "./chunk-SZD45IDG.js";
 import {
   applyFormatter
 } from "./chunk-W3X6PAC7.js";
+import {
+  PermissionManager
+} from "./chunk-I2ZK3AOD.js";
+import {
+  isToolAllowedByYolo,
+  normalizeYoloInput,
+  parseYoloPattern
+} from "./chunk-4LMUDS2K.js";
+import {
+  runCommand
+} from "./chunk-TH26BQJG.js";
+import {
+  executeStreamingShellCommand
+} from "./chunk-VUGOOGHB.js";
+import {
+  getPlanModeManager
+} from "./chunk-LUMV3DB2.js";
+import {
+  GOAL_FEATURE_DISABLED_MESSAGE,
+  isGoalFeatureEnabled
+} from "./chunk-7MY4JHER.js";
 import {
   fetchUrl,
   formatPackageInfo,
   formatSearchResults,
   getPackageInfo,
   webSearch
-} from "./chunk-SAHBLB3E.js";
+} from "./chunk-FP46B4X3.js";
 import {
   showInput,
   showModal
-} from "./chunk-YZXUDM5X.js";
+} from "./chunk-NZ3ZWLUW.js";
 import {
   getTheme,
   hexToRgb,
   isThemeInitialized
-} from "./chunk-LIEXWM2M.js";
-import {
-  AUTOHAND_PATHS
-} from "./chunk-EGFT4PGW.js";
-import {
-  getPlanModeManager
-} from "./chunk-NCC6ETZS.js";
+} from "./chunk-JAQO6XDB.js";
 import {
-  GitIgnoreParser
-} from "./chunk-EZMINVLU.js";
+  AUTOHAND_PATHS,
+  PROJECT_DIR_NAME
+} from "./chunk-SHRLFX6F.js";
 
 // src/core/actionExecutor.ts
 import chalk2 from "chalk";
@@ -596,88 +615,6 @@ async function removeDependency(cwd, name, options = {}) {
   }
 }
 
-// src/actions/command.ts
-import { spawn } from "child_process";
-import { join } from "path";
-function runCommand(cmd, args, cwd, options = {}) {
-  if (!cmd || typeof cmd !== "string") {
-    return Promise.reject(new Error("Command is required and must be a string"));
-  }
-  return new Promise((resolve, reject) => {
-    const workDir = options.directory ? join(cwd, options.directory) : cwd;
-    const spawnOptions = {
-      cwd: workDir,
-      shell: options.shell ?? false,
-      env: {
-        ...process.env,
-        AUTOHAND_CLI: "1",
-        ...options.env
-      }
-    };
-    if (options.background) {
-      spawnOptions.detached = true;
-      spawnOptions.stdio = ["ignore", "pipe", "pipe"];
-    }
-    let child;
-    try {
-      child = spawn(cmd, args, spawnOptions);
-    } catch (error) {
-      const err = error;
-      if (err.code === "ENOENT") {
-        reject(new Error(`Command not found: ${cmd}`));
-      } else {
-        reject(error);
-      }
-      return;
-    }
-    if (options.background) {
-      child.unref();
-      resolve({
-        stdout: "",
-        stderr: "",
-        code: null,
-        backgroundPid: child.pid,
-        signal: null
-      });
-      return;
-    }
-    let stdout = "";
-    let stderr = "";
-    let timeoutId;
-    if (options.timeout && options.timeout > 0) {
-      timeoutId = setTimeout(() => {
-        child.kill("SIGTERM");
-      }, options.timeout);
-    }
-    child.stdout?.on("data", (chunk) => {
-      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
-      stdout += text;
-      options.onStdout?.(text);
-    });
-    child.stderr?.on("data", (chunk) => {
-      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
-      stderr += text;
-      options.onStderr?.(text);
-    });
-    child.once("error", (error) => {
-      if (timeoutId) clearTimeout(timeoutId);
-      if (error.code === "ENOENT") {
-        reject(new Error(`Command not found: ${cmd}`));
-      } else {
-        reject(error);
-      }
-    });
-    child.once("close", (code, signal) => {
-      if (timeoutId) clearTimeout(timeoutId);
-      resolve({ stdout, stderr, code, signal });
-    });
-  });
-}
-var SHELL_PATTERN = /[|><;&`]|\$[({A-Za-z_]|&&|\|\||[*?](?![\w./-]*$)/;
-function needsShell(cmd) {
-  return SHELL_PATTERN.test(cmd);
-}
-
 // src/actions/metadata.ts
 import crypto from "crypto";
 import fs2 from "fs-extra";
@@ -688,11 +625,6 @@ async function listDirectoryTree(root, options = {}) {
   const maxEntries = options.maxEntries ?? 200;
   const workspaceRoot = options.workspaceRoot ?? root;
   const result = [];
-  const resolvedRoot = path3.resolve(root);
-  const resolvedWorkspace = path3.resolve(workspaceRoot);
-  if (!resolvedRoot.startsWith(resolvedWorkspace)) {
-    throw new Error(`Path ${root} is outside the workspace root.`);
-  }
   const ignoreFilter = new GitIgnoreParser(workspaceRoot);
   async function walk(current, prefix, currentDepth) {
     if (result.length >= maxEntries) {
@@ -797,6 +729,13 @@ function diffFile(cwd, file) {
   }
   return result.stdout || "No diff";
 }
+function diffWorkspace(cwd) {
+  const result = spawnSync("git", ["diff"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git diff failed");
+  }
+  return result.stdout || "No diff";
+}
 function checkoutFile(cwd, file) {
   const result = spawnSync("git", ["checkout", "--", file], { cwd, encoding: "utf8" });
   if (result.status !== 0) {
@@ -1326,7 +1265,7 @@ function gitPush(cwd, remote, branch, options = {}) {
 }
 
 // src/actions/worktree.ts
-import { spawnSync as spawnSync2, spawn as spawn2 } from "child_process";
+import { spawnSync as spawnSync2, spawn } from "child_process";
 import path4 from "path";
 import fs3 from "fs-extra";
 import os from "os";
@@ -1363,6 +1302,9 @@ var DEFAULT_TEMPLATES = [
   }
 ];
 var WorktreeManager = class {
+  repoRoot;
+  repoName;
+  templates;
   constructor(cwd) {
     this.repoRoot = this.findGitRoot(cwd);
     this.repoName = path4.basename(this.repoRoot);
@@ -1767,7 +1709,7 @@ var WorktreeManager = class {
   }
   async runInWorktree(worktreePath, command) {
     return new Promise((resolve, reject) => {
-      const child = spawn2("sh", ["-c", command], {
+      const child = spawn("sh", ["-c", command], {
         cwd: worktreePath,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -1792,7 +1734,7 @@ var WorktreeManager = class {
   }
   async runInWorktreeWithTimeout(worktreePath, command, timeout) {
     return new Promise((resolve, reject) => {
-      const child = spawn2("sh", ["-c", command], {
+      const child = spawn("sh", ["-c", command], {
         cwd: worktreePath,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -1825,6 +1767,92 @@ var WorktreeManager = class {
   }
 };
 
+// src/actions/notebook.ts
+function createNotebookCell(cellType, source) {
+  if (cellType === "code") {
+    return {
+      cell_type: "code",
+      source,
+      metadata: {},
+      outputs: [],
+      execution_count: null
+    };
+  }
+  return {
+    cell_type: "markdown",
+    source,
+    metadata: {}
+  };
+}
+function resolveCellIndex(notebook, input) {
+  if (typeof input.cell_index === "number") {
+    return input.cell_index;
+  }
+  if (input.cell_id) {
+    const index = notebook.cells.findIndex((cell) => cell.id === input.cell_id);
+    if (index === -1) {
+      throw new Error(`Notebook cell "${input.cell_id}" not found.`);
+    }
+    return index;
+  }
+  return -1;
+}
+function applyNotebookEdit(rawContent, input) {
+  if (!input.path.endsWith(".ipynb")) {
+    throw new Error("notebook_edit only supports .ipynb files.");
+  }
+  let notebook;
+  try {
+    notebook = JSON.parse(rawContent);
+  } catch {
+    throw new Error(`Notebook ${input.path} is not valid JSON.`);
+  }
+  if (!Array.isArray(notebook.cells)) {
+    throw new Error(`Notebook ${input.path} does not contain a valid cells array.`);
+  }
+  const editMode = input.edit_mode ?? "replace";
+  const index = resolveCellIndex(notebook, input);
+  if (editMode === "insert") {
+    if (!input.cell_type) {
+      throw new Error('notebook_edit insert requires "cell_type".');
+    }
+    if (typeof input.new_source !== "string") {
+      throw new Error('notebook_edit insert requires "new_source".');
+    }
+    const insertAt = index >= 0 ? index + 1 : notebook.cells.length;
+    notebook.cells.splice(insertAt, 0, createNotebookCell(input.cell_type, input.new_source));
+    return {
+      updated: `${JSON.stringify(notebook, null, 2)}
+`,
+      summary: `Inserted notebook cell at index ${insertAt} in ${input.path}.`
+    };
+  }
+  if (index < 0 || index >= notebook.cells.length) {
+    throw new Error('notebook_edit requires a valid "cell_index" or "cell_id".');
+  }
+  if (editMode === "delete") {
+    notebook.cells.splice(index, 1);
+    return {
+      updated: `${JSON.stringify(notebook, null, 2)}
+`,
+      summary: `Deleted notebook cell ${index} in ${input.path}.`
+    };
+  }
+  if (typeof input.new_source !== "string") {
+    throw new Error('notebook_edit replace requires "new_source".');
+  }
+  const target = notebook.cells[index];
+  target.source = input.new_source;
+  if (input.cell_type) {
+    target.cell_type = input.cell_type;
+  }
+  return {
+    updated: `${JSON.stringify(notebook, null, 2)}
+`,
+    summary: `Updated notebook cell ${index} in ${input.path}.`
+  };
+}
+
 // src/core/customCommands.ts
 import fs4 from "fs-extra";
 import path5 from "path";
@@ -2308,14 +2336,139 @@ async function getUser() {
 
 // src/core/toolsRegistry.ts
 import fs5 from "fs-extra";
+import nodeFs from "fs/promises";
 import path6 from "path";
+
+// src/core/metaTools/schema.ts
+import { createHash } from "crypto";
+import { z } from "zod";
+var META_TOOL_SCHEMA_VERSION = 1;
+var META_TOOL_NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
+var META_TOOL_SCOPES = ["user", "project"];
+var JsonSchemaObject = z.record(z.string(), z.unknown()).refine((value) => value.type === "object", 'parameters must be a JSON Schema object with type "object"');
+var MetaToolCreateInputSchema = z.object({
+  name: z.string().trim().regex(META_TOOL_NAME_PATTERN, "name must be snake_case and start with a lowercase letter"),
+  description: z.string().trim().min(1).max(300),
+  parameters: JsonSchemaObject,
+  handler: z.string().trim().min(1).max(2e3),
+  source: z.enum(["agent", "user"]).default("agent"),
+  scope: z.enum(META_TOOL_SCOPES).default("user")
+});
+var MetaToolDefinitionSchema = MetaToolCreateInputSchema.extend({
+  schemaVersion: z.literal(META_TOOL_SCHEMA_VERSION),
+  createdAt: z.string().min(1),
+  updatedAt: z.string().min(1).optional(),
+  fingerprint: z.string().min(16),
+  disabled: z.boolean().optional()
+});
+function canonicalize(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalize).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalize(record[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function fingerprintMetaTool(input) {
+  return createHash("sha256").update(canonicalize({
+    name: input.name,
+    description: input.description,
+    parameters: input.parameters,
+    handler: input.handler
+  })).digest("hex");
+}
+function normalizeMetaToolDefinition(candidate) {
+  if (!candidate || typeof candidate !== "object") {
+    return null;
+  }
+  const value = candidate;
+  const source = value.source === "user" ? "user" : "agent";
+  const scope = value.scope === "project" ? "project" : "user";
+  const definition = {
+    ...value,
+    schemaVersion: value.schemaVersion ?? META_TOOL_SCHEMA_VERSION,
+    source,
+    scope,
+    createdAt: typeof value.createdAt === "string" ? value.createdAt : (/* @__PURE__ */ new Date(0)).toISOString()
+  };
+  const parsedCreateInput = MetaToolCreateInputSchema.safeParse(definition);
+  if (!parsedCreateInput.success) {
+    return null;
+  }
+  const parsed = MetaToolDefinitionSchema.safeParse({
+    ...definition,
+    fingerprint: typeof value.fingerprint === "string" ? value.fingerprint : fingerprintMetaTool(parsedCreateInput.data)
+  });
+  return parsed.success ? parsed.data : null;
+}
+
+// src/core/metaTools/safety.ts
+var DANGEROUS_PATTERNS = [
+  { pattern: /rm\s+(-[rf]+\s+)*\/(?!\w)/i, description: "rm with root path" },
+  { pattern: /rm\s+.*--no-preserve-root/i, description: "rm --no-preserve-root" },
+  { pattern: /dd\s+.*(?:of|if)=\/dev\/[sh]d/i, description: "dd to disk device" },
+  { pattern: /mkfs\./i, description: "filesystem format" },
+  { pattern: /wipefs/i, description: "disk wipe" },
+  { pattern: /\bsudo\s/i, description: "sudo command" },
+  { pattern: /\bsu\s+-?\s*\w/i, description: "su command" },
+  { pattern: /chmod\s+[0-7]*7[0-7]*/i, description: "world-writable chmod" },
+  { pattern: /chown\s+root/i, description: "chown to root" },
+  { pattern: /curl\s+.*\|\s*(ba)?sh/i, description: "curl | bash" },
+  { pattern: /wget\s+.*\|\s*(ba)?sh/i, description: "wget | sh" },
+  { pattern: /\beval\s+[`$]/i, description: "eval with expansion" },
+  { pattern: /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;/i, description: "fork bomb" },
+  { pattern: /while\s+true.*do.*done/i, description: "infinite loop" },
+  { pattern: /nc\s+.*-e\s*\/bin/i, description: "netcat reverse shell" },
+  { pattern: /ncat\s+.*-e\s*\/bin/i, description: "ncat reverse shell" },
+  { pattern: /bash\s+-i\s+>&?\s*\/dev\/tcp/i, description: "bash reverse shell" },
+  { pattern: /iptables\s+-F/i, description: "flush firewall rules" },
+  { pattern: /gpg\s+.*--encrypt.*-r\s+\S+\s+\//i, description: "gpg encrypt root" }
+];
+function assertSafeMetaToolHandler(handler) {
+  for (const { pattern, description } of DANGEROUS_PATTERNS) {
+    if (pattern.test(handler)) {
+      throw new Error(`Handler contains dangerous pattern: ${description}`);
+    }
+  }
+}
+
+// src/core/toolsRegistry.ts
+function locationKey(scope, name) {
+  return `${scope}:${name}`;
+}
+function normalizeLocations(input) {
+  if (Array.isArray(input)) {
+    return input;
+  }
+  return [{ scope: "user", dir: input ?? AUTOHAND_PATHS.tools }];
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createToolsRegistry(workspaceRoot, userToolsDir = AUTOHAND_PATHS.tools) {
+  const locations = workspaceRoot ? [
+    { scope: "project", dir: path6.join(workspaceRoot, PROJECT_DIR_NAME, "tools") },
+    { scope: "user", dir: userToolsDir }
+  ] : [{ scope: "user", dir: userToolsDir }];
+  return new ToolsRegistry(locations);
+}
 var ToolsRegistry = class {
-  constructor(toolsDir = AUTOHAND_PATHS.tools) {
-    this.toolsDir = toolsDir;
-    this.metaToolCache = /* @__PURE__ */ new Map();
+  metaToolCache = /* @__PURE__ */ new Map();
+  metaToolRecords = /* @__PURE__ */ new Map();
+  diagnostics = [];
+  constructor(locations) {
+    this.locations = normalizeLocations(locations);
   }
+  locations;
   async initialize() {
-    await fs5.ensureDir(this.toolsDir);
+    this.metaToolCache.clear();
+    this.metaToolRecords.clear();
+    this.diagnostics = [];
+    for (const location of this.locations) {
+      await fs5.ensureDir(location.dir);
+    }
     await this.loadMetaToolDefinitions();
   }
   async listTools(builtIns) {
@@ -2341,20 +2494,41 @@ var ToolsRegistry = class {
       entries.push({
         name: tool.name,
         description: tool.description,
-        source: "meta"
+        source: "meta",
+        scope: tool.scope,
+        disabled: tool.disabled,
+        createdAt: tool.createdAt,
+        schemaVersion: tool.schemaVersion,
+        handlerPreview: tool.handler.length > 140 ? `${tool.handler.slice(0, 137)}...` : tool.handler,
+        reuseHint: `Use ${tool.name} instead of creating another tool for: ${tool.description}`
       });
       seen.add(name);
     }
     return entries;
   }
   async saveMetaTool(definition) {
-    const fullDef = {
-      ...definition,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const filePath = path6.join(this.toolsDir, `${definition.name}.json`);
-    await fs5.writeJson(filePath, fullDef, { spaces: 2 });
-    this.metaToolCache.set(definition.name, fullDef);
+    const fullDef = normalizeMetaToolDefinition(definition);
+    if (!fullDef) {
+      throw new Error(`Invalid meta-tool definition for "${definition.name}"`);
+    }
+    assertSafeMetaToolHandler(fullDef.handler);
+    const location = this.getLocationForScope(fullDef.scope);
+    const filePath = path6.join(location.dir, `${fullDef.name}.json`);
+    const release = await this.acquireLock(location.dir, fullDef.name);
+    try {
+      const existing = await this.readDefinition(filePath);
+      if (existing) {
+        if (existing.fingerprint === fullDef.fingerprint) {
+          this.upsertRecord(existing, filePath);
+          return existing;
+        }
+        throw new Error(`Meta-tool "${fullDef.name}" already exists in ${fullDef.scope} scope`);
+      }
+      await this.writeDefinition(filePath, fullDef);
+    } finally {
+      await release();
+    }
+    this.upsertRecord(fullDef, filePath);
     return fullDef;
   }
   getMetaTool(name) {
@@ -2366,6 +2540,71 @@ var ToolsRegistry = class {
   getAllMetaTools() {
     return Array.from(this.metaToolCache.values());
   }
+  listMetaTools(options = {}) {
+    if (!options.includeDisabled) {
+      return this.getAllMetaTools();
+    }
+    return Array.from(this.metaToolRecords.values()).map((record) => record.definition);
+  }
+  getDiagnostics() {
+    return [...this.diagnostics];
+  }
+  async deleteMetaTool(name, scope) {
+    const record = this.findRecord(name, scope);
+    if (!record) {
+      throw new Error(`Meta-tool "${name}" not found`);
+    }
+    await fs5.remove(record.filePath);
+    this.deleteRecord(record.definition);
+    return record.definition;
+  }
+  async setMetaToolDisabled(name, disabled, scope) {
+    const record = this.findRecord(name, scope);
+    if (!record) {
+      throw new Error(`Meta-tool "${name}" not found`);
+    }
+    const updated = {
+      ...record.definition,
+      disabled,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.writeDefinition(record.filePath, updated);
+    this.upsertRecord(updated, record.filePath);
+    this.rebuildActiveCache();
+    return updated;
+  }
+  async renameMetaTool(name, newName, scope) {
+    if (!META_TOOL_NAME_PATTERN.test(newName)) {
+      throw new Error("new name must be snake_case and start with a lowercase letter");
+    }
+    const record = this.findRecord(name, scope);
+    if (!record) {
+      throw new Error(`Meta-tool "${name}" not found`);
+    }
+    if (this.findRecord(newName)) {
+      throw new Error(`Meta-tool "${newName}" already exists`);
+    }
+    const renamed = {
+      ...record.definition,
+      name: newName,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const normalized = normalizeMetaToolDefinition({
+      ...renamed,
+      fingerprint: fingerprintMetaTool(renamed)
+    });
+    if (!normalized) {
+      throw new Error(`Invalid meta-tool definition for "${newName}"`);
+    }
+    const location = this.getLocationForScope(normalized.scope);
+    const nextFilePath = path6.join(location.dir, `${newName}.json`);
+    await this.writeDefinition(nextFilePath, normalized);
+    await fs5.remove(record.filePath);
+    this.deleteRecord(record.definition);
+    this.upsertRecord(normalized, nextFilePath);
+    this.rebuildActiveCache();
+    return normalized;
+  }
   toToolDefinitions() {
     return this.getAllMetaTools().map((tool) => {
       const params = tool.parameters;
@@ -2381,163 +2620,375 @@ var ToolsRegistry = class {
     });
   }
   async loadMetaToolDefinitions() {
-    try {
-      const exists = await fs5.pathExists(this.toolsDir);
-      if (!exists) {
-        return;
-      }
-      const files = await fs5.readdir(this.toolsDir);
-      for (const file of files) {
-        if (!file.endsWith(".json")) {
+    for (const location of this.locations) {
+      try {
+        const exists = await fs5.pathExists(location.dir);
+        if (!exists) {
           continue;
         }
-        const fullPath = path6.join(this.toolsDir, file);
-        try {
-          const data = await fs5.readJson(fullPath);
-          if (this.isValidMetaTool(data)) {
-            this.metaToolCache.set(data.name, data);
+        const files = await fs5.readdir(location.dir);
+        for (const file of files) {
+          if (!file.endsWith(".json")) {
+            continue;
+          }
+          const fullPath = path6.join(location.dir, file);
+          try {
+            const data = normalizeMetaToolDefinition({
+              ...await fs5.readJson(fullPath),
+              scope: location.scope
+            });
+            if (data) {
+              assertSafeMetaToolHandler(data.handler);
+              this.metaToolRecords.set(locationKey(data.scope, data.name), { definition: data, filePath: fullPath });
+            } else {
+              this.diagnostics.push({ file: fullPath, reason: "invalid meta-tool definition" });
+            }
+          } catch (error) {
+            const reason = error instanceof Error ? error.message : "invalid meta-tool file";
+            this.diagnostics.push({ file: fullPath, reason });
           }
-        } catch {
         }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : "tools directory could not be read";
+        this.diagnostics.push({ file: location.dir, reason });
       }
-    } catch {
     }
+    this.rebuildActiveCache();
   }
-  isValidMetaTool(candidate) {
-    if (!candidate || typeof candidate !== "object") {
-      return false;
+  getLocationForScope(scope) {
+    const location = this.locations.find((candidate) => candidate.scope === scope);
+    if (!location) {
+      throw new Error(`No tools directory configured for ${scope} scope`);
+    }
+    return location;
+  }
+  async readDefinition(filePath) {
+    if (!await fs5.pathExists(filePath)) {
+      return null;
+    }
+    return normalizeMetaToolDefinition(await fs5.readJson(filePath));
+  }
+  async writeDefinition(filePath, definition) {
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await fs5.ensureDir(path6.dirname(filePath));
+      await fs5.outputFile(tempPath, `${JSON.stringify(definition, null, 2)}
+`, { mode: 384 });
+      const handle = await nodeFs.open(tempPath, "r");
+      try {
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await nodeFs.rename(tempPath, filePath);
+    } catch (error) {
+      await fs5.remove(tempPath).catch(() => {
+      });
+      throw error;
+    }
+  }
+  async acquireLock(dir, name) {
+    await fs5.ensureDir(dir);
+    const lockPath = path6.join(dir, `${name}.lock`);
+    for (let attempt = 0; attempt < 40; attempt++) {
+      try {
+        const handle = await nodeFs.open(lockPath, "wx", 384);
+        await handle.close();
+        return async () => {
+          await fs5.remove(lockPath).catch(() => {
+          });
+        };
+      } catch (error) {
+        const code = typeof error === "object" && error && "code" in error ? error.code : void 0;
+        if (code === "EEXIST") {
+          await delay(25);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error(`Timed out waiting for meta-tool lock "${name}"`);
+  }
+  upsertRecord(definition, filePath) {
+    this.metaToolRecords.set(locationKey(definition.scope, definition.name), { definition, filePath });
+    this.rebuildActiveCache();
+  }
+  deleteRecord(definition) {
+    this.metaToolRecords.delete(locationKey(definition.scope, definition.name));
+    this.rebuildActiveCache();
+  }
+  findRecord(name, scope) {
+    if (scope) {
+      return this.metaToolRecords.get(locationKey(scope, name));
+    }
+    for (const location of this.locations) {
+      const record = this.metaToolRecords.get(locationKey(location.scope, name));
+      if (record) {
+        return record;
+      }
+    }
+    return void 0;
+  }
+  rebuildActiveCache() {
+    this.metaToolCache.clear();
+    for (const location of this.locations) {
+      for (const record of this.metaToolRecords.values()) {
+        if (record.definition.scope !== location.scope || record.definition.disabled) {
+          continue;
+        }
+        if (!this.metaToolCache.has(record.definition.name)) {
+          this.metaToolCache.set(record.definition.name, record.definition);
+        }
+      }
     }
-    const value = candidate;
-    return typeof value.name === "string" && typeof value.description === "string" && typeof value.handler === "string" && typeof value.parameters === "object";
   }
 };
 
-// src/core/SecurityScanner.ts
-var SecurityScanner = class {
-  constructor() {
-    /**
-     * Built-in secret detection patterns
-     */
-    this.patterns = [
-      // AWS
-      {
-        name: "AWS Access Key",
-        regex: /AKIA[0-9A-Z]{16}/,
-        severity: "high",
-        description: "AWS Access Key ID"
-      },
-      // GitHub
-      {
-        name: "GitHub Token",
-        regex: /ghp_[a-zA-Z0-9]{36}/,
-        severity: "high",
-        description: "GitHub Personal Access Token"
-      },
-      {
-        name: "GitHub OAuth",
-        regex: /gho_[a-zA-Z0-9]{36}/,
-        severity: "high",
-        description: "GitHub OAuth Token"
-      },
-      {
-        name: "GitHub App Token",
-        regex: /ghu_[a-zA-Z0-9]{36}/,
-        severity: "high",
-        description: "GitHub App User Token"
-      },
-      // OpenAI / Anthropic
-      {
-        name: "OpenAI Key",
-        regex: /sk-proj-[a-zA-Z0-9]{32,}/,
-        severity: "high",
-        description: "OpenAI Project API Key"
-      },
-      {
-        name: "Anthropic Key",
-        regex: /sk-ant-api[a-zA-Z0-9-]{32,}/,
-        severity: "high",
-        description: "Anthropic API Key"
-      },
-      // Google
-      {
-        name: "Google API Key",
-        regex: /AIzaSy[0-9A-Za-z-_]{33}/,
-        severity: "high",
-        description: "Google API Key"
-      },
-      // Stripe
-      {
-        name: "Stripe Live Key",
-        regex: /sk_live_[0-9a-zA-Z]{24,}/,
-        severity: "high",
-        description: "Stripe Live Secret Key"
-      },
-      {
-        name: "Stripe Test Key",
-        regex: /sk_test_[0-9a-zA-Z]{24,}/,
-        severity: "low",
-        description: "Stripe Test Secret Key"
-      },
-      // Private Keys
-      {
-        name: "Private Key",
-        regex: /-----BEGIN (RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
-        severity: "high",
-        description: "Private Key File"
-      },
-      // Database URLs with credentials
-      {
-        name: "Database URL",
-        regex: /(postgres|postgresql|mysql|mongodb|redis):\/\/[^:]+:[^@]+@/,
-        severity: "high",
-        description: "Database URL with credentials"
-      },
-      // JWT Tokens
-      {
-        name: "JWT Token",
-        regex: /eyJ[a-zA-Z0-9]{10,}\.eyJ[a-zA-Z0-9]{10,}\.[a-zA-Z0-9_-]{10,}/,
-        severity: "medium",
-        description: "JSON Web Token"
-      },
-      // Generic patterns (lower priority)
-      {
-        name: "Generic API Key",
-        regex: /[aA][pP][iI][-_]?[kK][eE][yY]\s*[:=]\s*['"][a-zA-Z0-9]{16,}['"]/,
-        severity: "medium",
-        description: "Generic API Key Assignment"
-      },
-      {
-        name: "Generic Secret",
-        regex: /[sS][eE][cC][rR][eE][tT]\s*[:=]\s*['"][^'"]{8,}['"]/,
-        severity: "medium",
-        description: "Generic Secret Assignment"
-      },
-      {
-        name: "Password Assignment",
-        regex: /[pP][aA][sS][sS][wW][oO][rR][dD]\s*[:=]\s*['"][^'"]{4,}['"]/,
-        severity: "medium",
-        description: "Password Assignment"
+// src/core/metaTools/MetaToolService.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "by",
+  "for",
+  "from",
+  "in",
+  "of",
+  "on",
+  "the",
+  "to",
+  "with",
+  "find",
+  "search",
+  "list",
+  "get",
+  "show",
+  "analyze",
+  "count",
+  "run",
+  "quick",
+  "tool",
+  "tools",
+  "file",
+  "files",
+  "codebase",
+  "workspace",
+  "source",
+  "across"
+]);
+function normalizeHandler(handler) {
+  return handler.trim().replace(/\s+/g, " ");
+}
+function tokenize2(value) {
+  const tokens = value.toLowerCase().split(/[^a-z0-9]+/).map((token) => token.endsWith("s") ? token.slice(0, -1) : token).filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+  return new Set(tokens);
+}
+function overlapRatio(left, right) {
+  if (left.size === 0 || right.size === 0) {
+    return 0;
+  }
+  let intersection = 0;
+  for (const token of left) {
+    if (right.has(token)) {
+      intersection++;
+    }
+  }
+  return intersection / Math.min(left.size, right.size);
+}
+function isSimilarTool(candidate, existing) {
+  const candidateNameTokens = tokenize2(candidate.name);
+  const existingNameTokens = tokenize2(existing.name);
+  if (overlapRatio(candidateNameTokens, existingNameTokens) >= 0.75) {
+    return true;
+  }
+  const candidateDescriptionTokens = tokenize2(candidate.description);
+  const existingDescriptionTokens = tokenize2(existing.description ?? "");
+  return overlapRatio(candidateDescriptionTokens, existingDescriptionTokens) >= 0.75;
+}
+var MetaToolService = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  registry;
+  async createMetaTool(input, registeredTools) {
+    const parsed = MetaToolCreateInputSchema.safeParse(input);
+    if (!parsed.success) {
+      throw new Error(`Invalid meta-tool definition: ${parsed.error.issues[0]?.message ?? "unknown validation error"}`);
+    }
+    const definitionInput = parsed.data;
+    assertSafeMetaToolHandler(definitionInput.handler);
+    const fingerprint = fingerprintMetaTool(definitionInput);
+    const existingByName = this.registry.getMetaTool(definitionInput.name);
+    if (existingByName) {
+      if (existingByName.fingerprint === fingerprint) {
+        return {
+          status: "existing",
+          definition: existingByName,
+          message: `Meta-tool "${definitionInput.name}" already exists with the same definition.`
+        };
       }
+      throw new Error(`Cannot create meta-tool "${definitionInput.name}": already exists with a different definition`);
+    }
+    const registeredNameConflict = registeredTools.find((tool) => tool.name === definitionInput.name);
+    if (registeredNameConflict) {
+      throw new Error(`Cannot create meta-tool "${definitionInput.name}": conflicts with existing tool`);
+    }
+    for (const existing of this.registry.getAllMetaTools()) {
+      if (normalizeHandler(existing.handler) === normalizeHandler(definitionInput.handler)) {
+        throw new Error(`Cannot create meta-tool "${definitionInput.name}": same handler already exists as "${existing.name}"`);
+      }
+    }
+    const existingTools = [
+      ...registeredTools,
+      ...this.registry.getAllMetaTools().map((tool) => ({
+        name: tool.name,
+        description: tool.description
+      }))
     ];
-    /**
-     * Placeholder patterns to ignore (false positives)
-     * These must be exact matches or specific patterns, not substrings
-     */
-    this.placeholderPatterns = [
-      /your[-_]?api[-_]?key/i,
-      /your[-_]?secret/i,
-      /\*\*\*/,
-      /\.\.\.$/,
-      /-example/i,
-      /placeholder/i,
-      /sk-xxx$/i,
-      /sk-your/i,
-      /<your[-_]?key[-_]?here>/i,
-      /\$\{[A-Z_]+\}/,
-      // Environment variable placeholders
-      /process\.env\./
-    ];
+    const similar = existingTools.find((tool) => tool.name !== definitionInput.name && isSimilarTool(definitionInput, tool));
+    if (similar) {
+      throw new Error(`Cannot create meta-tool "${definitionInput.name}": similar existing tool "${similar.name}" should be reused`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const saved = await this.registry.saveMetaTool({
+      ...definitionInput,
+      schemaVersion: 1,
+      createdAt: now,
+      updatedAt: now,
+      fingerprint
+    });
+    return {
+      status: "created",
+      definition: saved,
+      message: `Created meta-tool "${saved.name}" - available in this and future sessions`
+    };
   }
+};
+
+// src/core/SecurityScanner.ts
+var SecurityScanner = class {
+  /**
+   * Built-in secret detection patterns
+   */
+  patterns = [
+    // AWS
+    {
+      name: "AWS Access Key",
+      regex: /AKIA[0-9A-Z]{16}/,
+      severity: "high",
+      description: "AWS Access Key ID"
+    },
+    // GitHub
+    {
+      name: "GitHub Token",
+      regex: /ghp_[a-zA-Z0-9]{36}/,
+      severity: "high",
+      description: "GitHub Personal Access Token"
+    },
+    {
+      name: "GitHub OAuth",
+      regex: /gho_[a-zA-Z0-9]{36}/,
+      severity: "high",
+      description: "GitHub OAuth Token"
+    },
+    {
+      name: "GitHub App Token",
+      regex: /ghu_[a-zA-Z0-9]{36}/,
+      severity: "high",
+      description: "GitHub App User Token"
+    },
+    // OpenAI / Anthropic
+    {
+      name: "OpenAI Key",
+      regex: /sk-proj-[a-zA-Z0-9]{32,}/,
+      severity: "high",
+      description: "OpenAI Project API Key"
+    },
+    {
+      name: "Anthropic Key",
+      regex: /sk-ant-api[a-zA-Z0-9-]{32,}/,
+      severity: "high",
+      description: "Anthropic API Key"
+    },
+    // Google
+    {
+      name: "Google API Key",
+      regex: /AIzaSy[0-9A-Za-z-_]{33}/,
+      severity: "high",
+      description: "Google API Key"
+    },
+    // Stripe
+    {
+      name: "Stripe Live Key",
+      regex: /sk_live_[0-9a-zA-Z]{24,}/,
+      severity: "high",
+      description: "Stripe Live Secret Key"
+    },
+    {
+      name: "Stripe Test Key",
+      regex: /sk_test_[0-9a-zA-Z]{24,}/,
+      severity: "low",
+      description: "Stripe Test Secret Key"
+    },
+    // Private Keys
+    {
+      name: "Private Key",
+      regex: /-----BEGIN (RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
+      severity: "high",
+      description: "Private Key File"
+    },
+    // Database URLs with credentials
+    {
+      name: "Database URL",
+      regex: /(postgres|postgresql|mysql|mongodb|redis):\/\/[^:]+:[^@]+@/,
+      severity: "high",
+      description: "Database URL with credentials"
+    },
+    // JWT Tokens
+    {
+      name: "JWT Token",
+      regex: /eyJ[a-zA-Z0-9]{10,}\.eyJ[a-zA-Z0-9]{10,}\.[a-zA-Z0-9_-]{10,}/,
+      severity: "medium",
+      description: "JSON Web Token"
+    },
+    // Generic patterns (lower priority)
+    {
+      name: "Generic API Key",
+      regex: /[aA][pP][iI][-_]?[kK][eE][yY]\s*[:=]\s*['"][a-zA-Z0-9]{16,}['"]/,
+      severity: "medium",
+      description: "Generic API Key Assignment"
+    },
+    {
+      name: "Generic Secret",
+      regex: /[sS][eE][cC][rR][eE][tT]\s*[:=]\s*['"][^'"]{8,}['"]/,
+      severity: "medium",
+      description: "Generic Secret Assignment"
+    },
+    {
+      name: "Password Assignment",
+      regex: /[pP][aA][sS][sS][wW][oO][rR][dD]\s*[:=]\s*['"][^'"]{4,}['"]/,
+      severity: "medium",
+      description: "Password Assignment"
+    }
+  ];
+  /**
+   * Placeholder patterns to ignore (false positives)
+   * These must be exact matches or specific patterns, not substrings
+   */
+  placeholderPatterns = [
+    /your[-_]?api[-_]?key/i,
+    /your[-_]?secret/i,
+    /\*\*\*/,
+    /\.\.\.$/,
+    /-example/i,
+    /placeholder/i,
+    /sk-xxx$/i,
+    /sk-your/i,
+    /<your[-_]?key[-_]?here>/i,
+    /\$\{[A-Z_]+\}/,
+    // Environment variable placeholders
+    /process\.env\./
+  ];
   /**
    * Scan git diff for secrets
    * @param diff - Git diff output
@@ -2697,7 +3148,9 @@ var SecurityScanner = class {
       lines.push("");
     }
     if (result.blockedCount > 0) {
-      lines.push(`[BLOCKED] ${result.blockedCount} high-severity secrets found`);
+      lines.push(
+        `[BLOCKED] ${result.blockedCount} high-severity secrets found`
+      );
       lines.push("          Remove secrets before committing.");
       lines.push("          Consider using environment variables instead.");
     } else if (result.warningCount > 0) {
@@ -2725,6 +3178,7 @@ import { execSync } from "child_process";
 import fs6 from "fs-extra";
 import path7 from "path";
 var PlanFileStorage = class {
+  plansDir;
   constructor() {
     this.plansDir = AUTOHAND_PATHS.plans;
   }
@@ -2859,10 +3313,22 @@ var PlanFileStorage = class {
 
 // src/core/actionExecutor.ts
 import { randomUUID } from "crypto";
+var GOAL_TOOL_TYPES = /* @__PURE__ */ new Set([
+  "get_goal",
+  "create_goal",
+  "create_goal_from_template",
+  "update_goal",
+  "clear_goal",
+  "list_goal_templates",
+  "enqueue_goal",
+  "list_goal_queue",
+  "start_queued_goal",
+  "dequeue_goal",
+  "remove_queued_goal"
+]);
 var ActionExecutor = class _ActionExecutor {
   constructor(deps) {
     this.deps = deps;
-    this.searchCache = /* @__PURE__ */ new Map();
     this.runtime = deps.runtime;
     this.files = deps.files;
     this.resolveWorkspacePath = deps.resolveWorkspacePath;
@@ -2870,7 +3336,8 @@ var ActionExecutor = class _ActionExecutor {
     this.projectManager = deps.projectManager;
     this.sessionId = deps.sessionId;
     this.logExploration = deps.onExploration;
-    this.toolsRegistry = deps.toolsRegistry ?? new ToolsRegistry();
+    this.toolsRegistry = deps.toolsRegistry ?? createToolsRegistry(deps.runtime.workspaceRoot);
+    this.metaToolService = deps.metaToolService ?? new MetaToolService(this.toolsRegistry);
     this.getRegisteredTools = deps.getRegisteredTools ?? (() => []);
     this.permissionManager = deps.permissionManager ?? new PermissionManager(deps.runtime.config.permissions);
     this.memoryManager = deps.memoryManager;
@@ -2879,8 +3346,84 @@ var ActionExecutor = class _ActionExecutor {
     this.onAskFollowup = deps.onAskFollowup;
     this.onPlanCreated = deps.onPlanCreated;
     this.onPermissionRequest = deps.onPermissionRequest;
+    this.onReviewHook = deps.onReviewHook;
+    this.onModalPause = deps.onModalPause;
+    this.onRequestDirectoryAccess = deps.onRequestDirectoryAccess;
+    this.onLiveCommandStart = deps.onLiveCommandStart;
+    this.onLiveCommandOutput = deps.onLiveCommandOutput;
+    this.onLiveCommandRemove = deps.onLiveCommandRemove;
+    this.onMetaToolCreated = deps.onMetaToolCreated;
     this.securityScanner = new SecurityScanner();
   }
+  deps;
+  runtime;
+  files;
+  resolveWorkspacePath;
+  confirmDangerousAction;
+  projectManager;
+  sessionId;
+  logExploration;
+  toolsRegistry;
+  metaToolService;
+  getRegisteredTools;
+  permissionManager;
+  memoryManager;
+  onToolOutput;
+  onFileModified;
+  onAskFollowup;
+  onPlanCreated;
+  onPermissionRequest;
+  onReviewHook;
+  onModalPause;
+  onRequestDirectoryAccess;
+  onLiveCommandStart;
+  onLiveCommandOutput;
+  onLiveCommandRemove;
+  onMetaToolCreated;
+  securityScanner;
+  searchCache = /* @__PURE__ */ new Map();
+  fffSearchProviderPromise = null;
+  fffSearchWorkspaceRoot = null;
+  fffSearchIdleTimer = null;
+  static FFF_SEARCH_IDLE_TTL_MS = 6e4;
+  shouldDisplayToolOutput() {
+    return this.runtime.config.ui?.silentToolOutput !== true;
+  }
+  async getFFFSearchProvider() {
+    if (this.fffSearchIdleTimer) {
+      clearTimeout(this.fffSearchIdleTimer);
+      this.fffSearchIdleTimer = null;
+    }
+    const workspaceRoot = this.runtime.workspaceRoot;
+    if (this.fffSearchProviderPromise && this.fffSearchWorkspaceRoot === workspaceRoot) {
+      return this.fffSearchProviderPromise;
+    }
+    if (this.fffSearchProviderPromise) {
+      this.fffSearchProviderPromise.then((provider) => provider.destroy()).catch(() => {
+      });
+    }
+    const { FFFSearchProvider } = await import("./fffSearchProvider-2YCNKOYD.js");
+    this.fffSearchWorkspaceRoot = workspaceRoot;
+    this.fffSearchProviderPromise = FFFSearchProvider.create(workspaceRoot);
+    return this.fffSearchProviderPromise;
+  }
+  scheduleFFFSearchProviderCleanup() {
+    if (!this.fffSearchProviderPromise) {
+      return;
+    }
+    if (this.fffSearchIdleTimer) {
+      clearTimeout(this.fffSearchIdleTimer);
+    }
+    this.fffSearchIdleTimer = setTimeout(() => {
+      const providerPromise = this.fffSearchProviderPromise;
+      this.fffSearchProviderPromise = null;
+      this.fffSearchWorkspaceRoot = null;
+      this.fffSearchIdleTimer = null;
+      providerPromise?.then((provider) => provider.destroy()).catch(() => {
+      });
+    }, _ActionExecutor.FFF_SEARCH_IDLE_TTL_MS);
+    this.fffSearchIdleTimer.unref?.();
+  }
   /**
    * Check permission hooks before prompting user.
    * Returns true if allowed, false if denied/blocked, undefined if should ask user.
@@ -2906,7 +3449,10 @@ var ActionExecutor = class _ActionExecutor {
     }
   }
   async execute(action, context) {
-    if (this.runtime.options.dryRun && action.type !== "search" && action.type !== "plan") {
+    if (GOAL_TOOL_TYPES.has(action.type) && !isGoalFeatureEnabled(this.runtime.config)) {
+      return GOAL_FEATURE_DISABLED_MESSAGE;
+    }
+    if (this.runtime.options.dryRun && !["fff_grep", "fff_find", "find", "search", "search_with_context", "semantic_search", "glob", "plan"].includes(action.type)) {
       return "Dry-run mode: skipped mutation";
     }
     switch (action.type) {
@@ -3101,11 +3647,15 @@ ${steps.map((s) => `${s.number}. ${s.description}`).join("\n")}`;
           const receivedKeys = Object.keys(action).filter((k) => k !== "type").join(", ") || "none";
           throw new Error(`write_file requires a "path" argument. Received arguments: [${receivedKeys}]`);
         }
+        if (action.contents === void 0 && action.content === void 0) {
+          return 'Error: write_file requires "contents" argument.';
+        }
         const filePath = this.resolveWorkspacePath(action.path);
         const fs7 = await import("fs-extra");
         const exists = this.files.root && await fs7.pathExists(filePath);
         const oldContent = exists ? await this.files.readFile(action.path) : "";
         const newContent = this.pickText(action.contents, action.content) ?? "";
+        let resultOutput = null;
         if (!exists) {
           const permContext = {
             tool: "write_file",
@@ -3151,16 +3701,18 @@ ${steps.map((s) => `${s.number}. ${s.description}`).join("\n")}`;
               }
             }
           }
+          resultOutput = this.formatDiffPreview("", newContent, action.path);
         } else if (oldContent === newContent) {
           return `No changes needed for ${action.path} (content identical)`;
         } else {
           console.log(chalk2.cyan(`
 \u{1F4DD} ${action.path}:`));
           this.showDiff(oldContent, newContent, action.path);
+          resultOutput = this.formatDiffPreview(oldContent, newContent, action.path);
         }
         await this.files.writeFile(action.path, newContent);
-        this.onFileModified?.(action.path);
-        return exists ? `Updated ${action.path}` : `Created ${action.path}`;
+        this.onFileModified?.(action.path, exists ? "modify" : "create");
+        return resultOutput ?? (exists ? `Updated ${action.path}` : `Created ${action.path}`);
       }
       case "append_file": {
         if (!action.path) {
@@ -3173,17 +3725,17 @@ ${steps.map((s) => `${s.number}. ${s.description}`).join("\n")}`;
 \u{1F4DD} ${action.path}:`));
         this.showDiff(oldContent, newContent, action.path);
         await this.files.appendFile(action.path, addition);
-        this.onFileModified?.(action.path);
-        return `Appended to ${action.path}`;
+        this.onFileModified?.(action.path, "modify");
+        return this.formatDiffPreview(oldContent, newContent, action.path);
       }
       case "apply_patch": {
         if (!action.path) {
-          throw new Error('apply_patch requires a "path" argument.');
+          return 'Error: apply_patch requires a "path" argument.';
         }
         const oldContent = await this.files.readFile(action.path).catch(() => "");
         const patch = this.pickText(action.patch, action.diff);
         if (!patch) {
-          throw new Error("apply_patch requires patch or diff content.");
+          return 'Error: apply_patch requires a "patch" argument.';
         }
         console.log(chalk2.cyan(`
 \u{1F527} ${action.path}:`));
@@ -3191,58 +3743,148 @@ ${steps.map((s) => `${s.number}. ${s.description}`).join("\n")}`;
         await this.files.applyPatch(action.path, patch);
         const newContent = await this.files.readFile(action.path);
         this.showDiff(oldContent, newContent, action.path);
-        this.onFileModified?.(action.path);
-        return `Patched ${action.path}`;
+        this.onFileModified?.(action.path, "modify");
+        return this.formatDiffPreview(oldContent, newContent, action.path);
+      }
+      case "notebook_edit": {
+        if (!action.path) {
+          throw new Error('notebook_edit requires a "path" argument.');
+        }
+        const current = await this.files.readFile(action.path);
+        const { updated, summary } = applyNotebookEdit(current, action);
+        await this.files.writeFile(action.path, updated);
+        this.onFileModified?.(action.path, "modify");
+        return summary;
       }
       case "tools_registry": {
         const tools = await this.toolsRegistry.listTools(this.getRegisteredTools());
         return JSON.stringify(tools, null, 2);
       }
-      case "search": {
-        const cacheKey = `search:${action.query}:${action.path || ""}`;
-        if (this.searchCache.has(cacheKey)) {
-          return `[Cached] ${this.searchCache.get(cacheKey)}`;
-        }
-        const hits = this.files.search(action.query, action.path);
-        this.recordExploration("search", action.query);
-        const result = hits.slice(0, 10).map((hit) => `${hit.file}:${hit.line}: ${hit.text}`).join("\n");
-        this.searchCache.set(cacheKey, result);
-        return result;
+      case "get_goal": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        return JSON.stringify(await manager.getSnapshot(), null, 2);
       }
-      case "search_with_context": {
-        const cacheKey = `search_ctx:${action.query}:${action.path || ""}:${action.limit || ""}:${action.context || ""}`;
-        if (this.searchCache.has(cacheKey)) {
-          return `[Cached] ${this.searchCache.get(cacheKey)}`;
-        }
-        this.recordExploration("search", action.query);
-        const result = this.files.searchWithContext(action.query, {
-          limit: action.limit,
-          context: action.context,
-          relativePath: action.path
+      case "list_goal_templates": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        return JSON.stringify(await manager.listTemplates(), null, 2);
+      }
+      case "create_goal": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        const created = await manager.createGoal({
+          objective: action.objective,
+          tokenBudget: action.token_budget,
+          timeBudgetSeconds: action.time_budget_seconds,
+          minTokensBeforeWrapUp: action.min_tokens_before_wrap_up,
+          minTimeSecondsBeforeWrapUp: action.min_time_seconds_before_wrap_up
         });
-        this.searchCache.set(cacheKey, result);
-        return result;
+        return formatGoalToolResult(created);
       }
-      case "semantic_search": {
-        const cacheKey = `semantic:${action.query}:${action.path || ""}:${action.limit || ""}:${action.window || ""}`;
-        if (this.searchCache.has(cacheKey)) {
-          return `[Cached] ${this.searchCache.get(cacheKey)}`;
+      case "create_goal_from_template": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        const resolution = await import("./templates-UGVZV3KJ.js").then((mod) => mod.resolveGoalTemplateByName(
+          this.runtime.workspaceRoot,
+          action.template,
+          action.flags ?? {},
+          action.args ?? ""
+        ));
+        if (!resolution.ok) {
+          return `Error: ${"notTemplate" in resolution ? `Unknown goal template '${action.template}'.` : resolution.error}`;
         }
-        const results = this.files.semanticSearch(action.query, {
-          limit: action.limit,
-          window: action.window,
-          relativePath: action.path
+        const created = await manager.createGoal({
+          objective: resolution.template.objective,
+          tokenBudget: action.token_budget,
+          timeBudgetSeconds: action.time_budget_seconds,
+          minTokensBeforeWrapUp: action.min_tokens_before_wrap_up,
+          minTimeSecondsBeforeWrapUp: action.min_time_seconds_before_wrap_up
+        }, { replace: true });
+        return formatGoalToolResult(created);
+      }
+      case "update_goal": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        const updated = await manager.updateGoal({
+          objective: action.objective,
+          status: parseGoalStatus(action.status),
+          tokenBudget: action.token_budget,
+          timeBudgetSeconds: action.time_budget_seconds,
+          minTokensBeforeWrapUp: action.min_tokens_before_wrap_up,
+          minTimeSecondsBeforeWrapUp: action.min_time_seconds_before_wrap_up
         });
-        if (!results.length) {
-          this.searchCache.set(cacheKey, "No matches found.");
-          return "No matches found.";
+        return formatGoalToolResult(updated);
+      }
+      case "clear_goal": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        return formatGoalToolResult(await manager.clearGoal());
+      }
+      case "enqueue_goal": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        return formatGoalToolResult(await manager.enqueueGoal({
+          objective: action.objective,
+          source: "tool",
+          tokenBudget: action.token_budget,
+          timeBudgetSeconds: action.time_budget_seconds,
+          minTokensBeforeWrapUp: action.min_tokens_before_wrap_up,
+          minTimeSecondsBeforeWrapUp: action.min_time_seconds_before_wrap_up
+        }));
+      }
+      case "list_goal_queue": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        const snapshot = await manager.getSnapshot();
+        return JSON.stringify({ goal: snapshot.goal, queue: snapshot.queue }, null, 2);
+      }
+      case "start_queued_goal": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        return formatGoalToolResult(await manager.startQueuedGoal());
+      }
+      case "dequeue_goal": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        return formatGoalToolResult(await manager.dequeueGoal({
+          rationale: action.rationale,
+          authority: action.authority
+        }));
+      }
+      case "remove_queued_goal": {
+        const manager = new GoalManager(this.runtime.workspaceRoot);
+        const queueId = action.queueId ?? action.queue_id;
+        if (!queueId) return "Error: remove_queued_goal requires queueId.";
+        return formatGoalToolResult(await manager.removeQueuedGoal(queueId));
+      }
+      case "tool_search": {
+        const query = action.query?.trim();
+        if (!query) {
+          throw new Error('tool_search requires a non-empty "query" argument.');
         }
-        const result = results.map((hit) => `${chalk2.cyan(hit.file)}
-${hit.snippet}`).join("\n\n");
-        this.searchCache.set(cacheKey, result);
-        return result;
+        const limit = Math.max(1, action.limit ?? 10);
+        const tools = await this.toolsRegistry.listTools(this.getRegisteredTools());
+        const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+        const scored = tools.map((tool) => {
+          const haystack = `${tool.name} ${tool.description}`.toLowerCase();
+          let score = 0;
+          for (const term of terms) {
+            if (tool.name.toLowerCase() === term) {
+              score += 10;
+            } else if (tool.name.toLowerCase().includes(term)) {
+              score += 6;
+            }
+            if (haystack.includes(term)) {
+              score += 2;
+            }
+          }
+          return { tool, score };
+        }).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name)).slice(0, limit).map((entry) => entry.tool);
+        return JSON.stringify(scored, null, 2);
       }
+      case "find":
+        return this.executeFind(action);
+      case "glob":
+        return this.executeGlob(action);
+      case "fff_grep":
+        return this.executeFFFGrep(action);
+      case "fff_find":
+        return this.executeFFFFind(action);
       case "create_directory": {
+        if (!action.path) {
+          return 'Error: create_directory requires a "path" argument.';
+        }
         await this.files.createDirectory(action.path);
         return `Created directory ${action.path}`;
       }
@@ -3257,14 +3899,24 @@ ${hit.snippet}`).join("\n\n");
         if (!confirmed) {
           return `Skipped deleting ${action.path}`;
         }
+        const oldDeleteContent = await this.files.readFile(action.path).catch(() => null);
         await this.files.deletePath(action.path);
-        return `Deleted ${action.path}`;
+        if (oldDeleteContent !== null) {
+          console.log(chalk2.cyan(`
+\u{1F5D1}\uFE0F ${action.path}:`));
+          this.showDiff(oldDeleteContent, "", action.path);
+          this.onFileModified?.(action.path, "delete");
+          return this.formatDiffPreview(oldDeleteContent, "", action.path);
+        }
+        this.onFileModified?.(action.path, "delete");
+        return `Deleted directory ${action.path}`;
       }
       case "rename_path": {
         if (!action.from || !action.to) {
           throw new Error('rename_path requires "from" and "to" arguments.');
         }
         await this.files.renamePath(action.from, action.to);
+        this.onFileModified?.(action.to, "create");
         return `Renamed ${action.from} -> ${action.to}`;
       }
       case "copy_path": {
@@ -3272,9 +3924,16 @@ ${hit.snippet}`).join("\n\n");
           throw new Error('copy_path requires "from" and "to" arguments.');
         }
         await this.files.copyPath(action.from, action.to);
+        this.onFileModified?.(action.to, "create");
         return `Copied ${action.from} -> ${action.to}`;
       }
       case "search_replace": {
+        if (!action.path) {
+          return 'Error: search_replace requires a "path" argument.';
+        }
+        if (!action.blocks) {
+          return 'Error: search_replace requires a "blocks" argument.';
+        }
         const content = await this.files.readFile(action.path);
         const result = this.applySearchReplaceBlocks(content, action.blocks);
         if (content !== result) {
@@ -3282,16 +3941,26 @@ ${hit.snippet}`).join("\n\n");
 \u{1F504} ${action.path}:`));
           this.showDiff(content, result, action.path);
           await this.files.writeFile(action.path, result);
-          this.onFileModified?.(action.path);
+          this.onFileModified?.(action.path, "modify");
+          return this.formatDiffPreview(content, result, action.path);
         }
-        return `Updated ${action.path}`;
+        return `No changes needed for ${action.path} (content identical)`;
       }
       case "format_file": {
         if (!action.path) {
           throw new Error('format_file requires a "path" argument.');
         }
+        const oldFormatContent = await this.files.readFile(action.path).catch(() => "");
         await this.files.formatFile(action.path, (contents, file) => applyFormatter(action.formatter, contents, file));
-        return `Formatted ${action.path} (${action.formatter})`;
+        const newFormatContent = await this.files.readFile(action.path).catch(() => "");
+        if (oldFormatContent !== newFormatContent) {
+          console.log(chalk2.cyan(`
+\u{1F3A8} ${action.path}:`));
+          this.showDiff(oldFormatContent, newFormatContent, action.path);
+          this.onFileModified?.(action.path, "modify");
+          return this.formatDiffPreview(oldFormatContent, newFormatContent, action.path);
+        }
+        return `No changes needed (already formatted): ${action.path}`;
       }
       case "run_command": {
         if (!action.command || typeof action.command !== "string") {
@@ -3312,24 +3981,76 @@ ${hit.snippet}`).join("\n\n");
           });
         };
         const cmdStr = `${action.command} ${(action.args ?? []).join(" ")}`.trim();
+        if (action.interactive) {
+          const onModalPause = this.onModalPause;
+          if (onModalPause) {
+            return await onModalPause(async () => {
+              let result2;
+              try {
+                result2 = await runCommand(
+                  cmdStr,
+                  [],
+                  this.runtime.workspaceRoot,
+                  {
+                    directory: action.directory,
+                    shell: true,
+                    interactive: true
+                  }
+                );
+              } catch (err) {
+                const error = err;
+                if (error.code === "ENOENT" || error.message.includes("Command not found")) {
+                  return `Error: Command not found: "${action.command}". Make sure it is installed and available on your PATH.`;
+                }
+                return `Error running "${cmdStr}": ${error.message}`;
+              }
+              const header2 = action.description ? `$ ${action.description}
+> ${cmdStr}` : `$ ${cmdStr}`;
+              const dirInfo2 = action.directory ? `[dir: ${action.directory}]` : "";
+              const parts2 = [dirInfo2 ? `${header2} ${dirInfo2}` : header2];
+              if (result2.code !== 0) {
+                parts2.push(`(exit code: ${result2.code})`);
+              }
+              return parts2.join("\n");
+            });
+          }
+        }
         let result;
-        const useShell = needsShell(action.command);
-        const shellCmd = useShell ? `${action.command} ${(action.args ?? []).join(" ")}`.trim() : action.command;
-        const shellArgs = useShell ? [] : action.args ?? [];
+        const shellCmd = cmdStr;
+        const liveCommandId = !action.background && this.shouldDisplayToolOutput() ? this.onLiveCommandStart?.(cmdStr) : void 0;
+        const hasLiveDisplay = Boolean(liveCommandId);
+        const emitLiveOutput = (stream, data) => {
+          if (!hasLiveDisplay || !liveCommandId) {
+            return;
+          }
+          this.onLiveCommandOutput?.(liveCommandId, stream, data);
+        };
         try {
           result = await runCommand(
             shellCmd,
-            shellArgs,
+            [],
             this.runtime.workspaceRoot,
             {
               directory: action.directory,
               background: action.background,
-              shell: useShell,
-              onStdout: (chunk) => emitOutput("stdout", chunk),
-              onStderr: (chunk) => emitOutput("stderr", chunk)
+              shell: true,
+              onStdout: (chunk) => {
+                emitOutput("stdout", chunk);
+                emitLiveOutput("stdout", chunk);
+              },
+              onStderr: (chunk) => {
+                emitOutput("stderr", chunk);
+                emitLiveOutput("stderr", chunk);
+              }
             }
           );
+          if (liveCommandId) {
+            this.onLiveCommandRemove?.(liveCommandId);
+          }
         } catch (err) {
+          if (liveCommandId) {
+            this.onLiveCommandRemove?.(liveCommandId);
+          }
           const error = err;
           if (error.code === "ENOENT" || error.message.includes("Command not found")) {
             return `Error: Command not found: "${action.command}". Make sure it is installed and available on your PATH.`;
@@ -3349,12 +4070,100 @@ ${hit.snippet}`).join("\n\n");
         }
         return parts.join("\n");
       }
+      case "shell": {
+        if (!action.command || typeof action.command !== "string") {
+          return 'Error: shell requires a "command" argument (string)';
+        }
+        const cmdStr = `${action.command} ${(action.args ?? []).join(" ")}`.trim();
+        const commandId = this.shouldDisplayToolOutput() ? this.onLiveCommandStart?.(cmdStr) : void 0;
+        const hasLiveDisplay = Boolean(commandId);
+        if (hasLiveDisplay) {
+          const liveId = commandId;
+          try {
+            const result2 = await executeStreamingShellCommand(
+              cmdStr,
+              this.runtime.workspaceRoot,
+              {
+                onStdout: (chunk) => this.onLiveCommandOutput(liveId, "stdout", chunk),
+                onStderr: (chunk) => this.onLiveCommandOutput(liveId, "stderr", chunk),
+                preferPty: process.stdin.isTTY && process.stdout.isTTY,
+                columns: process.stdout.columns,
+                rows: process.stdout.rows,
+                background: action.background
+              }
+            );
+            this.onLiveCommandRemove(liveId);
+            const header2 = action.description ? `$ ${action.description}
+> ${cmdStr}` : `$ ${cmdStr}`;
+            const dirInfo2 = action.directory ? `[dir: ${action.directory}]` : "";
+            const parts2 = [dirInfo2 ? `${header2} ${dirInfo2}` : header2];
+            if (result2.output) parts2.push(result2.output);
+            if (result2.error) parts2.push(result2.error);
+            if (result2.backgroundPid) parts2.push(`[Background PID: ${result2.backgroundPid}]`);
+            return parts2.join("\n");
+          } catch (err) {
+            this.onLiveCommandRemove(liveId);
+            const error = err;
+            return `Error running "${cmdStr}": ${error.message}`;
+          }
+        }
+        let result;
+        try {
+          result = await runCommand(
+            cmdStr,
+            [],
+            this.runtime.workspaceRoot,
+            {
+              directory: action.directory,
+              shell: true,
+              background: action.background
+            }
+          );
+        } catch (err) {
+          const error = err;
+          if (error.code === "ENOENT" || error.message.includes("Command not found")) {
+            return `Error: Command not found: "${action.command}". Make sure it is installed and available on your PATH.`;
+          }
+          return `Error running "${cmdStr}": ${error.message}`;
+        }
+        const header = action.description ? `$ ${action.description}
+> ${cmdStr}` : `$ ${cmdStr}`;
+        const dirInfo = action.directory ? `[dir: ${action.directory}]` : "";
+        const parts = [
+          dirInfo ? `${header} ${dirInfo}` : header,
+          result.stdout,
+          result.stderr
+        ].filter(Boolean);
+        return parts.join("\n");
+      }
       case "add_dependency": {
+        const fseAdd = (await import("fs-extra")).default;
+        const pkgPathAdd = `${this.runtime.workspaceRoot}/package.json`;
+        const oldPkgAdd = await fseAdd.readFile(pkgPathAdd, "utf-8").catch(() => "");
         await addDependency(this.runtime.workspaceRoot, action.name, action.version, { dev: action.dev });
+        const newPkgAdd = await fseAdd.readFile(pkgPathAdd, "utf-8").catch(() => "");
+        if (oldPkgAdd !== newPkgAdd) {
+          console.log(chalk2.cyan(`
+\u{1F4E6} package.json:`));
+          this.showDiff(oldPkgAdd, newPkgAdd, "package.json");
+          this.onFileModified?.("package.json", "modify");
+          return this.formatDiffPreview(oldPkgAdd, newPkgAdd, "package.json");
+        }
         return `Added dependency ${action.name}@${action.version}${action.dev ? " (dev)" : ""}`;
       }
       case "remove_dependency": {
+        const fseRm = (await import("fs-extra")).default;
+        const pkgPathRm = `${this.runtime.workspaceRoot}/package.json`;
+        const oldPkgRm = await fseRm.readFile(pkgPathRm, "utf-8").catch(() => "");
         await removeDependency(this.runtime.workspaceRoot, action.name, { dev: action.dev });
+        const newPkgRm = await fseRm.readFile(pkgPathRm, "utf-8").catch(() => "");
+        if (oldPkgRm !== newPkgRm) {
+          console.log(chalk2.cyan(`
+\u{1F4E6} package.json:`));
+          this.showDiff(oldPkgRm, newPkgRm, "package.json");
+          this.onFileModified?.("package.json", "modify");
+          return this.formatDiffPreview(oldPkgRm, newPkgRm, "package.json");
+        }
         return `Removed dependency ${action.name}${action.dev ? " (dev)" : ""}`;
       }
       case "list_tree": {
@@ -3383,11 +4192,7 @@ ${hit.snippet}`).join("\n\n");
         return `${action.algorithm ?? "sha256"} ${action.path}: ${sum}`;
       }
       case "git_diff": {
-        if (!action.path) {
-          throw new Error('git_diff requires a "path" argument.');
-        }
-        this.resolveWorkspacePath(action.path);
-        const rawDiff = diffFile(this.runtime.workspaceRoot, action.path);
+        const rawDiff = action.path ? (this.resolveWorkspacePath(action.path), diffFile(this.runtime.workspaceRoot, action.path)) : diffWorkspace(this.runtime.workspaceRoot);
         return this.colorizeGitDiff(rawDiff);
       }
       case "git_checkout": {
@@ -3395,8 +4200,17 @@ ${hit.snippet}`).join("\n\n");
           throw new Error('git_checkout requires a "path" argument.');
         }
         this.resolveWorkspacePath(action.path);
+        const oldCheckoutContent = await this.files.readFile(action.path).catch(() => "");
         checkoutFile(this.runtime.workspaceRoot, action.path);
-        return `Restored ${action.path} from git.`;
+        const newCheckoutContent = await this.files.readFile(action.path).catch(() => "");
+        if (oldCheckoutContent !== newCheckoutContent) {
+          console.log(chalk2.cyan(`
+\u21A9\uFE0F ${action.path}:`));
+          this.showDiff(oldCheckoutContent, newCheckoutContent, action.path);
+          this.onFileModified?.(action.path, "modify");
+          return this.formatDiffPreview(oldCheckoutContent, newCheckoutContent, action.path);
+        }
+        return `Restored ${action.path} from git (no changes).`;
       }
       case "git_status":
         return gitStatus(this.runtime.workspaceRoot);
@@ -3666,8 +4480,10 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
         console.log(chalk2.cyan("Suggested commit message:"));
         console.log(chalk2.white(`   ${commitMessage}`));
         console.log();
+        const normalizedYolo = normalizeYoloInput(this.runtime.options.yolo);
+        const yoloAllowsCommit = normalizedYolo && isToolAllowedByYolo("auto_commit", parseYoloPattern(normalizedYolo));
         const autoApproveCommit = Boolean(
-          this.runtime.options.yes || process.env.CI === "1" || process.env.AUTOHAND_NON_INTERACTIVE === "1"
+          this.runtime.options.unrestricted || this.runtime.options.yes || yoloAllowsCommit || process.env.CI === "1" || process.env.AUTOHAND_NON_INTERACTIVE === "1"
         );
         if (autoApproveCommit) {
           console.log(chalk2.gray("Auto-commit approval enabled; committing without prompt."));
@@ -3682,26 +4498,36 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
           return result2.message;
         }
         const options = [
-          { label: "Yes - commit with this message", value: "y" },
+          { label: `Yes - commit with this message`, value: "y" },
           { label: "Edit - modify the message", value: "e" },
           { label: "No - cancel commit", value: "n" }
         ];
-        const modalResult = await showModal({
-          title: "Commit with this message?",
-          options
-        });
-        if (!modalResult || modalResult.value === "n") {
+        const runModal = async () => {
+          const modalResult = await showModal({
+            title: `Commit with this message?
+
+"${commitMessage}"`,
+            options
+          });
+          if (!modalResult || modalResult.value === "n") {
+            return { cancelled: true, editedMessage: null };
+          }
+          if (modalResult.value === "e") {
+            const editedMessage = await showInput({
+              title: "Enter commit message:",
+              defaultValue: commitMessage
+            });
+            return { cancelled: false, editedMessage };
+          }
+          return { cancelled: false, editedMessage: null };
+        };
+        const modalOutcome = this.onModalPause ? await this.onModalPause(runModal) : await runModal();
+        if (modalOutcome.cancelled) {
           console.log(chalk2.yellow("Commit cancelled."));
           return "Commit cancelled by user";
         }
-        if (modalResult.value === "e") {
-          const editedMessage = await showInput({
-            title: "Enter commit message:",
-            defaultValue: commitMessage
-          });
-          if (editedMessage) {
-            commitMessage = editedMessage;
-          }
+        if (modalOutcome.editedMessage) {
+          commitMessage = modalOutcome.editedMessage;
         }
         const result = executeAutoCommit(this.runtime.workspaceRoot, commitMessage, action.stage_all !== false);
         if (result.success) {
@@ -3735,6 +4561,12 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
       case "custom_command":
         return this.executeCustomCommand(action);
       case "multi_file_edit": {
+        if (!action.file_path) {
+          return 'Error: multi_file_edit requires a "file_path" argument.';
+        }
+        if (!action.edits || !Array.isArray(action.edits)) {
+          return 'Error: multi_file_edit requires an "edits" argument (array).';
+        }
         const oldContent = await this.files.readFile(action.file_path);
         let newContent = oldContent;
         console.log(chalk2.cyan(`
@@ -3775,14 +4607,20 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
               }
             }
             if (firstIndex === -1) {
-              console.log(chalk2.red(`  \u2717 Edit ${i + 1}: Could not find text to replace`));
-              console.log(chalk2.gray(`    Looking for (${edit.old_string.length} chars):`));
-              console.log(chalk2.gray(`    "${edit.old_string.substring(0, 80)}${edit.old_string.length > 80 ? "..." : ""}"`));
               const similar = this.findSimilarText(newContent, edit.old_string);
               if (similar) {
-                console.log(chalk2.yellow(`    Did you mean:`));
-                console.log(chalk2.yellow(`    "${similar.substring(0, 80)}${similar.length > 80 ? "..." : ""}"`));
+                const similarIndex = newContent.indexOf(similar);
+                if (similarIndex !== -1) {
+                  newContent = newContent.substring(0, similarIndex) + edit.new_string + newContent.substring(similarIndex + similar.length);
+                  console.log(chalk2.yellow(`  \u26A0 Edit ${i + 1}: Applied with fuzzy match (whitespace/indentation differed)`));
+                  console.log(chalk2.gray(`    Original search: "${edit.old_string.substring(0, 60)}${edit.old_string.length > 60 ? "..." : ""}"`));
+                  console.log(chalk2.gray(`    Matched: "${similar.substring(0, 60)}${similar.length > 60 ? "..." : ""}"`));
+                  continue;
+                }
               }
+              console.log(chalk2.red(`  \u2717 Edit ${i + 1}: Could not find text to replace`));
+              console.log(chalk2.gray(`    Looking for (${edit.old_string.length} chars):`));
+              console.log(chalk2.gray(`    "${edit.old_string.substring(0, 80)}${edit.old_string.length > 80 ? "..." : ""}"`));
               if (edit.old_string.length < 100) {
                 const nonAscii = edit.old_string.match(/[^\x20-\x7E\n\r\t]/g);
                 if (nonAscii && nonAscii.length > 0) {
@@ -3798,9 +4636,10 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
         if (oldContent !== newContent) {
           this.showDiff(oldContent, newContent, action.file_path);
           await this.files.writeFile(action.file_path, newContent);
-          this.onFileModified?.(action.file_path);
+          this.onFileModified?.(action.file_path, "modify");
+          return this.formatDiffPreview(oldContent, newContent, action.file_path);
         }
-        return `Applied ${action.edits.length} edit(s) to ${action.file_path}`;
+        return `No changes needed for ${action.file_path} (content identical)`;
       }
       case "todo_write": {
         const todoPath = ".autohand/agents/tasks/todos.json";
@@ -3810,17 +4649,17 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
         }
         const validTasks = action.tasks.filter((task) => {
           if (!task) return false;
-          const hasId = !!task.id;
           const hasContent = !!(task.content || task.title);
-          return hasId && hasContent;
+          return hasContent;
         });
-        const normalizedTasks = validTasks.map((task) => {
+        const normalizedTasks = validTasks.map((task, index) => {
           const content = task.content || task.title || "";
           const title = content;
           return {
             ...task,
             // Preserve extra properties like priority, tags, etc.
-            id: task.id,
+            id: task.id || `task-${Date.now()}-${index}`,
+            // Auto-generate id if missing
             title,
             content,
             // Keep original content field
@@ -3831,24 +4670,51 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
         });
         const allTodos = normalizedTasks;
         await this.files.writeFile(todoPath, JSON.stringify(allTodos, null, 2));
-        console.log(chalk2.cyan("\n\u{1F4CB} Task Progress:"));
+        this.onFileModified?.(todoPath, "modify");
         const total = allTodos.length;
-        const completed = allTodos.filter((t) => t.status === "completed").length;
+        if (total === 0) {
+          console.log(chalk2.dim("\n\u{1F4CB} Task list cleared"));
+          console.log();
+          return "Task list cleared (0 tasks)";
+        }
+        const completedTasks = allTodos.filter((t) => t.status === "completed");
         const inProgress = allTodos.filter((t) => t.status === "in_progress");
-        const pending = allTodos.filter((t) => t.status === "pending").length;
-        const percent = total > 0 ? Math.round(completed / total * 100) : 0;
+        const pendingTasks = allTodos.filter((t) => t.status === "pending");
+        const completed = completedTasks.length;
+        const pending = pendingTasks.length;
+        const percent = Math.round(completed / total * 100);
         const barWidth = 20;
         const filled = Math.round(barWidth * percent / 100);
         const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
-        console.log(`  ${chalk2.green(bar)} ${percent}%`);
-        console.log(chalk2.gray(`  ${completed} done \xB7 ${inProgress.length} in progress \xB7 ${pending} pending`));
+        const titleOf = (task) => {
+          const title = task.title ?? task.content;
+          return typeof title === "string" && title.trim().length > 0 ? title : "Untitled task";
+        };
+        const outputLines = [
+          chalk2.cyan("\n\u{1F4CB} Task Progress:"),
+          `  ${chalk2.green(bar)} ${percent}%`,
+          chalk2.gray(`  ${completed} done \xB7 ${inProgress.length} in progress \xB7 ${pending} pending`)
+        ];
+        if (completedTasks.length > 0) {
+          outputLines.push("", chalk2.green("  \u2705 Completed Tasks:"));
+          for (const task of completedTasks) {
+            outputLines.push(chalk2.green(`    \u2713 ${titleOf(task)}`));
+          }
+        }
         if (inProgress.length > 0) {
-          console.log(chalk2.yellow("\n  \u{1F504} Active Tasks:"));
+          outputLines.push("", chalk2.yellow("  \u{1F504} Active Tasks:"));
           for (const task of inProgress) {
-            console.log(`    \u2022 ${task.title || task.content}`);
+            outputLines.push(chalk2.yellow(`    \u2022 ${titleOf(task)}`));
           }
         }
-        console.log();
+        if (pendingTasks.length > 0) {
+          outputLines.push("", chalk2.cyan("  \u23F3 Pending Tasks:"));
+          for (const task of pendingTasks) {
+            outputLines.push(chalk2.dim(`    \u25CB ${titleOf(task)}`));
+          }
+        }
+        console.log(`${outputLines.join("\n")}
+`);
         return `Updated task list: ${percent}% complete (${completed}/${total})`;
       }
       case "save_memory": {
@@ -3876,58 +4742,21 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
         return formatted;
       }
       case "create_meta_tool": {
-        if (!action.name || !action.description || !action.handler) {
-          throw new Error("create_meta_tool requires name, description, and handler");
-        }
-        const builtInNames = this.getRegisteredTools().map((t) => t.name);
-        if (builtInNames.includes(action.name)) {
-          throw new Error(`Cannot create meta-tool "${action.name}": conflicts with built-in tool`);
-        }
-        const dangerousPatterns = [
-          // Destructive file operations
-          { pattern: /rm\s+(-[rf]+\s+)*\/(?!\w)/i, description: "rm with root path" },
-          { pattern: /rm\s+.*--no-preserve-root/i, description: "rm --no-preserve-root" },
-          { pattern: /dd\s+.*(?:of|if)=\/dev\/[sh]d/i, description: "dd to disk device" },
-          { pattern: /mkfs\./i, description: "filesystem format" },
-          { pattern: /wipefs/i, description: "disk wipe" },
-          // Privilege escalation
-          { pattern: /\bsudo\s/i, description: "sudo command" },
-          { pattern: /\bsu\s+-?\s*\w/i, description: "su command" },
-          { pattern: /chmod\s+[0-7]*7[0-7]*/i, description: "world-writable chmod" },
-          { pattern: /chown\s+root/i, description: "chown to root" },
-          // Remote code execution
-          { pattern: /curl\s+.*\|\s*(ba)?sh/i, description: "curl | bash" },
-          { pattern: /wget\s+.*\|\s*(ba)?sh/i, description: "wget | sh" },
-          { pattern: /\beval\s+[`$]/i, description: "eval with expansion" },
-          // Fork bomb and resource exhaustion
-          { pattern: /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;/i, description: "fork bomb" },
-          { pattern: /while\s+true.*do.*done/i, description: "infinite loop" },
-          // Reverse shell indicators
-          { pattern: /nc\s+.*-e\s*\/bin/i, description: "netcat reverse shell" },
-          { pattern: /ncat\s+.*-e\s*\/bin/i, description: "ncat reverse shell" },
-          { pattern: /bash\s+-i\s+>&?\s*\/dev\/tcp/i, description: "bash reverse shell" },
-          // Dangerous network operations
-          { pattern: /iptables\s+-F/i, description: "flush firewall rules" },
-          // Crypto operations that could lock out user
-          { pattern: /gpg\s+.*--encrypt.*-r\s+\S+\s+\//i, description: "gpg encrypt root" }
-        ];
-        for (const { pattern, description } of dangerousPatterns) {
-          if (pattern.test(action.handler)) {
-            throw new Error(`Handler contains dangerous pattern: ${description}`);
-          }
-        }
-        await this.toolsRegistry.saveMetaTool({
+        const result = await this.metaToolService.createMetaTool({
           name: action.name,
           description: action.description,
           parameters: action.parameters ?? { type: "object", properties: {} },
           handler: action.handler,
-          source: "agent"
-        });
+          source: "agent",
+          scope: action.scope ?? "user"
+        }, this.getRegisteredTools());
+        const metaTool = result.definition;
+        this.onMetaToolCreated?.(metaTool);
         console.log(chalk2.green(`
-\u{1F527} Created meta-tool: ${action.name}`));
+\u{1F527} ${result.status === "created" ? "Created" : "Reused"} meta-tool: ${metaTool.name}`));
         console.log(chalk2.gray(`   ${action.description}`));
         console.log(chalk2.gray(`   Handler: ${action.handler}`));
-        return `Created meta-tool "${action.name}" - available in this and future sessions`;
+        return result.message;
       }
       // Web Search Operations
       case "web_search": {
@@ -4023,7 +4852,7 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
         const query = action.query ?? "";
         console.log(chalk2.cyan(`
 Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...`));
-        const { searchCommunitySkills } = await import("./skills-ZZCIAS7C.js");
+        const { searchCommunitySkills } = await import("./skills-OB6RDW7D.js");
         const result = await searchCommunitySkills(query, {
           category: action.category,
           limit: action.limit
@@ -4086,6 +4915,32 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
           return `<answer>${finalAnswer}</answer>`;
         }
       }
+      // Code review tool
+      // Directory access tool
+      case "request_directory_access": {
+        return this.executeRequestDirectoryAccess(action);
+      }
+      case "code_review": {
+        return this.executeCodeReview(action);
+      }
+      // Browser tools — forwarded to Chrome extension via RPC
+      case "browser_screenshot":
+      case "browser_click":
+      case "browser_type":
+      case "browser_navigate":
+      case "browser_scroll":
+      case "browser_find_element":
+      case "browser_press_key":
+      case "browser_get_page_context":
+      case "browser_get_element":
+      case "browser_wait_for_element":
+      case "browser_read_network":
+      case "browser_read_console":
+      case "browser_get_tabs":
+      case "browser_get_tab_groups":
+      case "browser_execute_js": {
+        return this.executeBrowserTool(action);
+      }
       default: {
         const actionType = action.type;
         const metaTool = this.toolsRegistry.getMetaTool(actionType);
@@ -4096,6 +4951,145 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
       }
     }
   }
+  async executeBrowserTool(action) {
+    const { type, ...params } = action;
+    const toolName = type;
+    const { invokeBrowserTool } = await import("./browserToolBridge-F5N66PE7.js");
+    return invokeBrowserTool(toolName, params);
+  }
+  async executeRequestDirectoryAccess(action) {
+    const path8 = await import("path");
+    const fs7 = (await import("fs-extra")).default;
+    const { checkWorkspaceSafety } = await import("./workspaceSafety-XOUMUBVB.js");
+    const resolvedPath = path8.resolve(action.path);
+    if (!await fs7.pathExists(resolvedPath)) {
+      return `Error: Directory does not exist: ${resolvedPath}`;
+    }
+    const stats = await fs7.stat(resolvedPath);
+    if (!stats.isDirectory()) {
+      return `Error: Path is not a directory: ${resolvedPath}`;
+    }
+    const safetyResult = checkWorkspaceSafety(resolvedPath);
+    if (!safetyResult.safe) {
+      return `Error: Unsafe directory: ${resolvedPath}. ${safetyResult.reason}`;
+    }
+    const workspaceRoot = this.runtime.workspaceRoot;
+    const additionalDirs = this.files.getAllowedDirectories();
+    if (resolvedPath === workspaceRoot || additionalDirs.includes(resolvedPath)) {
+      return `Directory is already accessible: ${resolvedPath}`;
+    }
+    const normalizedResolved = resolvedPath.endsWith(path8.sep) ? resolvedPath.slice(0, -1) : resolvedPath;
+    const normalizedWorkspace = workspaceRoot.endsWith(path8.sep) ? workspaceRoot.slice(0, -1) : workspaceRoot;
+    if (normalizedResolved.startsWith(normalizedWorkspace + path8.sep)) {
+      return `Directory is already within workspace: ${resolvedPath}`;
+    }
+    for (const dir of additionalDirs) {
+      const normalizedDir = dir.endsWith(path8.sep) ? dir.slice(0, -1) : dir;
+      if (normalizedResolved.startsWith(normalizedDir + path8.sep) || normalizedResolved === normalizedDir) {
+        return `Directory is already accessible: ${resolvedPath}`;
+      }
+    }
+    if (this.onRequestDirectoryAccess) {
+      const result = await this.onRequestDirectoryAccess(resolvedPath, action.reason);
+      if (result) {
+        this.files.addAdditionalDirectory(resolvedPath);
+        return `Access granted to directory: ${resolvedPath}
+
+You can now use file tools (read_file, write_file, glob, find, etc.) to work with files in this directory.`;
+      } else {
+        return `Access denied to directory: ${resolvedPath}`;
+      }
+    }
+    const normalizedYolo = normalizeYoloInput(this.runtime.options.yolo);
+    if (normalizedYolo) {
+      this.files.addAdditionalDirectory(resolvedPath);
+      return `Access auto-granted (yolo mode) to directory: ${resolvedPath}
+
+You can now use file tools (read_file, write_file, glob, find, etc.) to work with files in this directory.`;
+    }
+    if (this.runtime.options.unrestricted || this.runtime.options.yes) {
+      this.files.addAdditionalDirectory(resolvedPath);
+      return `Access auto-granted to directory: ${resolvedPath}
+
+You can now use file tools (read_file, write_file, glob, find, etc.) to work with files in this directory.`;
+    }
+    return `Directory access required: ${resolvedPath}
+
+To grant access, use:
+  /add-dir ${resolvedPath}
+
+Or restart with:
+  --add-dir ${resolvedPath}`;
+  }
+  async executeCodeReview(action) {
+    const targetPath = action.path ? this.resolveWorkspacePath(action.path) : this.runtime.workspaceRoot;
+    const scope = action.scope || "full";
+    await this.onReviewHook?.("review:start", {
+      reviewPath: targetPath,
+      reviewScope: scope,
+      reviewInstructions: action.instructions
+    });
+    try {
+      let context = "";
+      if (scope === "diff") {
+        const { execFile: execFile2 } = await import("child_process");
+        const { promisify } = await import("util");
+        const execFileAsync = promisify(execFile2);
+        const result2 = await execFileAsync("git", ["diff", "--stat"], {
+          cwd: this.runtime.workspaceRoot,
+          encoding: "utf8"
+        }).catch(() => null);
+        context = result2?.stdout || "No uncommitted changes found.";
+      } else if (scope === "file" && action.path) {
+        const fse = (await import("fs-extra")).default;
+        context = await fse.readFile(targetPath, "utf-8").catch(() => `Could not read ${targetPath}`);
+      } else {
+        const { execFile: execFile2 } = await import("child_process");
+        const { promisify } = await import("util");
+        const execFileAsync = promisify(execFile2);
+        const tree = await execFileAsync("find", [
+          targetPath,
+          "-maxdepth",
+          "3",
+          "-type",
+          "f",
+          "-not",
+          "-path",
+          "*/node_modules/*",
+          "-not",
+          "-path",
+          "*/.git/*"
+        ], {
+          cwd: this.runtime.workspaceRoot,
+          encoding: "utf8"
+        }).catch(() => null);
+        context = tree?.stdout || "";
+      }
+      const result = [
+        `Code review initiated for: ${targetPath}`,
+        `Scope: ${scope}`,
+        action.instructions ? `Focus: ${action.instructions}` : "",
+        "",
+        "Project structure:",
+        context.slice(0, 5e3)
+      ].filter(Boolean).join("\n");
+      await this.onReviewHook?.("review:completed", {
+        reviewPath: targetPath,
+        reviewScope: scope,
+        reviewInstructions: action.instructions
+      });
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await this.onReviewHook?.("review:failed", {
+        reviewPath: targetPath,
+        reviewScope: scope,
+        reviewInstructions: action.instructions,
+        reviewError: message
+      });
+      return `Review failed: ${message}`;
+    }
+  }
   pickText(...values) {
     for (const value of values) {
       if (typeof value === "string") {
@@ -4192,6 +5186,122 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
     }
     return result.length > 0 ? result.join("\n") : "No structure detected";
   }
+  executeFind(action) {
+    console.warn(chalk2.yellow("[DEPRECATED] The `find` tool is deprecated. Use `fff_grep` instead. Will be removed in v0.9.0."));
+    const mode = action.mode ?? (action.context && action.context > 0 ? "context" : "exact");
+    const cacheKey = `find:${mode}:${action.query}:${action.path || ""}:${action.limit || ""}:${action.context || ""}:${action.window || ""}`;
+    if (this.searchCache.has(cacheKey)) {
+      return `[Cached] ${this.searchCache.get(cacheKey)}`;
+    }
+    this.recordExploration("search", action.query);
+    if (mode === "semantic") {
+      const results = this.files.semanticSearch(action.query, {
+        limit: action.limit,
+        window: action.window,
+        relativePath: action.path
+      });
+      if (!results.length) {
+        this.searchCache.set(cacheKey, "No matches found.");
+        return "No matches found.";
+      }
+      const result2 = results.map((hit) => `${chalk2.cyan(hit.file)}
+${hit.snippet}`).join("\n\n");
+      this.searchCache.set(cacheKey, result2);
+      return result2;
+    }
+    if (mode === "context") {
+      const result2 = this.files.searchWithContext(action.query, {
+        limit: action.limit,
+        context: action.context,
+        relativePath: action.path
+      });
+      this.searchCache.set(cacheKey, result2);
+      return result2;
+    }
+    const hits = this.files.search(action.query, action.path);
+    const result = hits.slice(0, action.limit ?? 10).map((hit) => `${hit.file}:${hit.line}: ${hit.text}`).join("\n");
+    this.searchCache.set(cacheKey, result);
+    return result;
+  }
+  async executeGlob(action) {
+    console.warn(chalk2.yellow("[DEPRECATED] The `glob` tool is deprecated. Use `fff_find` instead. Will be removed in v0.9.0."));
+    const { resolveRipgrepCommand } = await import("./ripgrep-VHJQQ55W.js");
+    const rgPath = resolveRipgrepCommand();
+    const searchPath = action.path ? this.resolveWorkspacePath(action.path) : this.runtime.workspaceRoot;
+    const limit = action.limit ?? 100;
+    const args = ["--files"];
+    const patterns = action.patterns ?? (action.pattern ? [action.pattern] : ["**/*"]);
+    for (const p of patterns) {
+      args.push("--glob", p);
+    }
+    args.push(searchPath);
+    const { execFile: execFile2 } = await import("child_process");
+    const { promisify } = await import("util");
+    const execFileAsync = promisify(execFile2);
+    try {
+      const result = await execFileAsync(rgPath, args, {
+        cwd: this.runtime.workspaceRoot,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const files = result.stdout.trim().split("\n").filter(Boolean);
+      if (files.length === 0) {
+        return "No files found matching the pattern.";
+      }
+      const fse = (await import("fs-extra")).default;
+      const withStats = await Promise.all(
+        files.map(async (f) => {
+          try {
+            const stat = await fse.stat(f);
+            return { file: f, mtime: stat.mtimeMs };
+          } catch {
+            return { file: f, mtime: 0 };
+          }
+        })
+      );
+      withStats.sort((a, b) => b.mtime - a.mtime);
+      const sorted = withStats.map((s) => s.file);
+      const limited = sorted.slice(0, limit);
+      const header = `Found ${files.length} file${files.length === 1 ? "" : "s"}${files.length > limit ? ` (showing first ${limit})` : ""}`;
+      this.recordExploration("list", action.pattern ?? action.patterns?.join(", ") ?? "*");
+      return `${header}
+${limited.join("\n")}`;
+    } catch (error) {
+      const exitCode = error?.code;
+      if (exitCode === 1 || exitCode === "1") {
+        return "No files found matching the pattern.";
+      }
+      throw error;
+    }
+  }
+  async executeFFFGrep(action) {
+    const provider = await this.getFFFSearchProvider();
+    try {
+      return await provider.grep({
+        query: action.query,
+        path: action.path,
+        exclude: action.exclude,
+        caseSensitive: action.caseSensitive,
+        beforeContext: action.beforeContext,
+        afterContext: action.afterContext,
+        classifyDefinitions: action.classifyDefinitions,
+        limit: action.limit
+      });
+    } finally {
+      this.scheduleFFFSearchProviderCleanup();
+    }
+  }
+  async executeFFFFind(action) {
+    const provider = await this.getFFFSearchProvider();
+    try {
+      return await provider.fileSearch({
+        query: action.query,
+        limit: action.limit
+      });
+    } finally {
+      this.scheduleFFFSearchProviderCleanup();
+    }
+  }
   recordExploration(kind, target) {
     if (!target) {
       return;
@@ -4233,12 +5343,6 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
     const lowered = command.toLowerCase();
     return lowered.includes("rm ") || lowered.includes("sudo ") || lowered.includes("dd ");
   }
-  static {
-    /**
-     * Shell metacharacters that could enable command injection
-     */
-    this.SHELL_METACHARACTERS = /[|;&$`><(){}[\]!#*?~'"\\]/;
-  }
   /**
    * Safely escape a value for shell interpolation
    * Uses single quotes which prevent all shell expansion except for single quotes themselves
@@ -4259,21 +5363,62 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
       if (value === void 0 || value === null) {
         throw new Error(`Missing required parameter "${paramName}" for meta-tool "${metaTool.name}"`);
       }
-      const stringValue = String(value);
-      let safeValue;
-      if (_ActionExecutor.SHELL_METACHARACTERS.test(stringValue)) {
-        safeValue = this.shellEscape(stringValue);
-        console.log(chalk2.yellow(`   \u26A0 Parameter "${paramName}" contains shell metacharacters, escaped for safety`));
-      } else {
-        safeValue = stringValue;
-      }
+      const safeValue = this.shellEscape(String(value));
+      command = command.replace(new RegExp(`(["'])\\{\\{${paramName}\\}\\}\\1`, "g"), safeValue);
       command = command.replace(new RegExp(`\\{\\{${paramName}\\}\\}`, "g"), safeValue);
     }
     console.log(chalk2.cyan(`
 \u{1F527} Running meta-tool: ${metaTool.name}`));
     console.log(chalk2.gray(`   $ ${command}`));
-    const result = await runCommand(command, [], this.runtime.workspaceRoot, { shell: true });
-    return [`$ ${command}`, result.stdout, result.stderr].filter(Boolean).join("\n");
+    const permissionContext = {
+      tool: "run_command",
+      command,
+      description: `Meta-tool ${metaTool.name}: ${metaTool.description}`
+    };
+    const decision = this.permissionManager.checkPermission(permissionContext);
+    if (decision.reason === "blacklisted" || decision.reason === "mode_restricted" || decision.reason === "pattern_denied" || decision.reason === "not_in_available" || decision.reason === "excluded" || decision.reason === "deny_list" || decision.reason === "session_deny_list" || decision.reason === "project_deny_list" || decision.reason === "user_deny_list") {
+      return `Blocked: Cannot run meta-tool ${metaTool.name} (${decision.reason})`;
+    }
+    if (!decision.allowed) {
+      const hookResult = await this.checkPermissionHook({
+        tool: "run_command",
+        command,
+        args
+      });
+      if (hookResult.blocked) {
+        return `Blocked: ${hookResult.reason}`;
+      }
+      if (hookResult.allowed !== void 0) {
+        await this.permissionManager.recordDecision(permissionContext, hookResult.allowed);
+        if (!hookResult.allowed) {
+          return `Denied: ${hookResult.reason ?? `meta-tool ${metaTool.name}`}`;
+        }
+      } else {
+        const confirmed = await this.confirmDangerousAction(
+          `Run meta-tool ${metaTool.name}?`,
+          { tool: "run_command", command }
+        );
+        await this.permissionManager.recordDecision(permissionContext, confirmed);
+        if (!confirmed) {
+          return `Skipped running meta-tool ${metaTool.name}`;
+        }
+      }
+    }
+    const result = await runCommand(command, [], this.runtime.workspaceRoot, {
+      shell: true,
+      timeout: 12e4
+    });
+    const stdout = this.truncateMetaToolOutput(result.stdout);
+    const stderr = this.truncateMetaToolOutput(result.stderr);
+    return [`$ ${command}`, stdout, stderr].filter(Boolean).join("\n");
+  }
+  truncateMetaToolOutput(output) {
+    const limit = 2e5;
+    if (output.length <= limit) {
+      return output;
+    }
+    return `${output.slice(0, limit)}
+[meta-tool output truncated at ${limit} characters]`;
   }
   applySearchReplaceBlocks(content, blocks) {
     let result = content;
@@ -4368,10 +5513,10 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
         score += 2;
       }
       if (score > 0 && (!bestMatch || score > bestMatch.score)) {
-        bestMatch = { line: line.trim(), score };
+        bestMatch = { line: line.trim(), originalLine: line, score };
       }
     }
-    return bestMatch && bestMatch.score >= 2 ? bestMatch.line : null;
+    return bestMatch && bestMatch.score >= 2 ? bestMatch.originalLine : null;
   }
   /**
    * Colorize raw git diff output with green for additions and red for removals
@@ -4457,6 +5602,10 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
     }
   }
   showDiff(oldContent, newContent, filePath) {
+    console.log(this.formatDiffPreview(oldContent, newContent, filePath));
+    console.log();
+  }
+  formatDiffPreview(oldContent, newContent, filePath) {
     const diff = diffLines(oldContent, newContent);
     const contextLines = 3;
     const lang = filePath ? detectLanguage(filePath) : "text";
@@ -4473,10 +5622,11 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
     const termWidth = process.stdout.columns || 100;
     const addText = additions === 1 ? "1 line" : `${additions} lines`;
     const delText = deletions === 1 ? "1 line" : `${deletions} lines`;
+    const outputLines = [];
     if (theme) {
-      console.log(theme.fg("muted", `  Added ${theme.fg("diffAdded", addText)}, removed ${theme.fg("diffRemoved", delText)}`));
+      outputLines.push(theme.fg("muted", `  Added ${theme.fg("diffAdded", addText)}, removed ${theme.fg("diffRemoved", delText)}`));
     } else {
-      console.log(chalk2.gray(`  Added ${chalk2.green(addText)}, removed ${chalk2.red(delText)}`));
+      outputLines.push(chalk2.gray(`  Added ${chalk2.green(addText)}, removed ${chalk2.red(delText)}`));
     }
     const hunks = [];
     let currentHunk = null;
@@ -4565,7 +5715,7 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
             const bgB = addedRgb ? Math.floor(addedRgb.b * 0.15) : 30;
             const prefix = chalk2.bgHex(addedColor).black(` ${lineNumStr} + `);
             const content = chalk2.bgRgb(bgR, bgG, bgB)(` ${highlighted} `.padEnd(Math.max(termWidth - 10, change.line.length + 2)));
-            console.log(prefix + content);
+            outputLines.push(prefix + content);
           } else if (change.type === "remove") {
             const removedRgb = hexToRgb(removedColor);
             const bgR = removedRgb ? Math.floor(removedRgb.r * 0.25) : 60;
@@ -4573,32 +5723,53 @@ Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...
             const bgB = removedRgb ? Math.floor(removedRgb.b * 0.15) : 30;
             const prefix = chalk2.bgHex(removedColor).white(` ${lineNumStr} - `);
             const content = chalk2.bgRgb(bgR, bgG, bgB)(` ${highlighted} `.padEnd(Math.max(termWidth - 10, change.line.length + 2)));
-            console.log(prefix + content);
+            outputLines.push(prefix + content);
           } else {
-            console.log(chalk2.hex(contextColor)(` ${lineNumStr}   `) + ` ${highlighted}`);
+            outputLines.push(chalk2.hex(contextColor)(` ${lineNumStr}   `) + ` ${highlighted}`);
           }
         } else {
           if (change.type === "add") {
             const prefix = chalk2.bgGreen.black(` ${lineNumStr} + `);
             const content = chalk2.bgRgb(30, 50, 30)(` ${highlighted} `.padEnd(Math.max(termWidth - 10, change.line.length + 2)));
-            console.log(prefix + content);
+            outputLines.push(prefix + content);
           } else if (change.type === "remove") {
             const prefix = chalk2.bgRed.white(` ${lineNumStr} - `);
             const content = chalk2.bgRgb(60, 30, 30)(` ${highlighted} `.padEnd(Math.max(termWidth - 10, change.line.length + 2)));
-            console.log(prefix + content);
+            outputLines.push(prefix + content);
           } else {
-            console.log(chalk2.gray(` ${lineNumStr}   `) + ` ${highlighted}`);
+            outputLines.push(chalk2.gray(` ${lineNumStr}   `) + ` ${highlighted}`);
           }
         }
       }
     }
-    console.log();
+    return outputLines.join("\n");
   }
 };
+function parseGoalStatus(value) {
+  if (!value) return void 0;
+  if (value === "active" || value === "paused" || value === "complete" || value === "budgetLimited") {
+    return value;
+  }
+  return void 0;
+}
+function formatGoalToolResult(result) {
+  return JSON.stringify({
+    ok: result.ok,
+    message: result.message,
+    goal: result.goal,
+    queue: result.queue,
+    queued: result.queued,
+    started: result.started,
+    dequeued: result.dequeued,
+    removed: result.removed,
+    telemetry: result.telemetry
+  }, null, 2);
+}
 
 export {
   getAutoCommitInfo,
-  ToolsRegistry,
+  WorktreeManager,
+  createToolsRegistry,
   ActionExecutor
 };
 /**