open-agents-ai 0.11.8 → 0.12.1

package/dist/index.js

@@ -2,6 +2,12 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -1164,7 +1170,7 @@ var init_shell = __esm({
         const timeout = args["timeout"] ?? this.defaultTimeout;
         const stdinInput = args["stdin"];
         const start = performance.now();
-        return new Promise((resolve14) => {
+        return new Promise((resolve15) => {
           const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
             env: {
@@ -1217,7 +1223,7 @@ var init_shell = __esm({
               const combined = stdout + stderr;
               const looksInteractive = /\? .+[›>]|y\/n|yes\/no|\(Y\/n\)|\[y\/N\]/i.test(combined);
               const hint = looksInteractive ? " The command appears to be waiting for interactive input. Use non-interactive flags (e.g., --yes, --no-input) or provide input via the stdin parameter." : "";
-              resolve14({
+              resolve15({
                 success: false,
                 output: stdout,
                 error: `Command timed out after ${timeout}ms.${hint}`,
@@ -1226,7 +1232,7 @@ var init_shell = __esm({
               return;
             }
             const success = code === 0;
-            resolve14({
+            resolve15({
               success,
               output: stdout + (stderr && success ? `
 STDERR:
@@ -1237,7 +1243,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve14({
+            resolve15({
               success: false,
               output: stdout,
               error: err.message,
@@ -1741,24 +1747,50 @@ var init_web_search = __esm({
 // packages/execution/dist/tools/file-edit.js
 import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
+function countOccurrences(haystack, needle) {
+  let count = 0;
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+function findMatchLines(haystack, needle) {
+  const lines = [];
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    const lineNumber = haystack.slice(0, pos).split("\n").length;
+    lines.push(lineNumber);
+    pos += needle.length;
+  }
+  return lines;
+}
+function replaceAllOccurrences(haystack, needle, replacement) {
+  return haystack.split(needle).join(replacement);
+}
 var FileEditTool;
 var init_file_edit = __esm({
   "packages/execution/dist/tools/file-edit.js"() {
     "use strict";
     FileEditTool = class {
       name = "file_edit";
-      description = "Make a precise edit to a file by replacing an exact string match. More efficient than rewriting the entire file.";
+      description = "Make a precise edit to a file by replacing an exact string match. The old_string must be unique in the file unless replace_all is true. Use replace_all to rename variables or change repeated patterns throughout the file.";
       parameters = {
         type: "object",
         properties: {
           path: { type: "string", description: "Absolute or relative file path" },
           old_string: {
             type: "string",
-            description: "The exact string to search for and replace"
+            description: "The exact string to search for and replace. Must be unique in the file (or use replace_all)."
           },
           new_string: {
             type: "string",
             description: "The replacement string"
+          },
+          replace_all: {
+            type: "boolean",
+            description: "Replace ALL occurrences instead of just the first. Use for variable renames, import path changes, etc. Default: false"
           }
         },
         required: ["path", "old_string", "new_string"]
@@ -1771,25 +1803,45 @@ var init_file_edit = __esm({
         const filePath = args["path"];
         const oldString = args["old_string"];
         const newString = args["new_string"];
+        const replaceAll = args["replace_all"] === true;
         const start = performance.now();
         try {
           const fullPath = resolve5(this.workingDir, filePath);
           const content = await readFile2(fullPath, "utf-8");
-          const index = content.indexOf(oldString);
-          if (index === -1) {
+          const occurrences = countOccurrences(content, oldString);
+          if (occurrences === 0) {
+            return {
+              success: false,
+              output: "",
+              error: `old_string not found in ${filePath}. Read the file first to verify the exact content.`,
+              durationMs: performance.now() - start
+            };
+          }
+          if (!replaceAll && occurrences > 1) {
+            const matchLines = findMatchLines(content, oldString);
             return {
               success: false,
               output: "",
-              error: `old_string not found in ${fullPath}`,
+              error: `old_string is not unique \u2014 found ${occurrences} occurrences at lines ${matchLines.join(", ")}. Either include more surrounding context to make old_string unique, or set replace_all=true to replace all ${occurrences} occurrences.`,
               durationMs: performance.now() - start
             };
           }
-          const lineNumber = content.slice(0, index).split("\n").length;
-          const updated = content.slice(0, index) + newString + content.slice(index + oldString.length);
+          let updated;
+          let editedLines;
+          if (replaceAll) {
+            editedLines = findMatchLines(content, oldString);
+            updated = replaceAllOccurrences(content, oldString, newString);
+          } else {
+            const index = content.indexOf(oldString);
+            const lineNumber = content.slice(0, index).split("\n").length;
+            editedLines = [lineNumber];
+            updated = content.slice(0, index) + newString + content.slice(index + oldString.length);
+          }
           await writeFile2(fullPath, updated, "utf-8");
+          const linesInfo = editedLines.length === 1 ? `line ${editedLines[0]}` : `${editedLines.length} locations (lines ${editedLines.join(", ")})`;
           return {
             success: true,
-            output: `Edited ${fullPath} at line ${lineNumber}`,
+            output: `Edited ${filePath} at ${linesInfo}`,
             durationMs: performance.now() - start
           };
         } catch (error) {
@@ -2431,15 +2483,24 @@ var init_aiwg_workflow = __esm({
 });
 
 // packages/execution/dist/tools/batch-edit.js
-import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3 } from "node:fs/promises";
-import { resolve as resolve9, dirname as dirname2 } from "node:path";
+import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { resolve as resolve9 } from "node:path";
+function countOccurrences2(haystack, needle) {
+  let count = 0;
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
 var BatchEditTool;
 var init_batch_edit = __esm({
   "packages/execution/dist/tools/batch-edit.js"() {
     "use strict";
     BatchEditTool = class {
       name = "batch_edit";
-      description = "Make multiple precise edits across one or more files in a single call. More efficient than calling file_edit repeatedly. Each edit replaces an exact string match. Edits are applied in order within each file.";
+      description = "Make multiple precise edits across one or more files in a single call. More efficient than calling file_edit repeatedly. Each edit replaces an exact string match with uniqueness validation. Edits are applied in order within each file. Set replace_all on individual edits for bulk renames.";
       parameters = {
         type: "object",
         properties: {
@@ -2449,9 +2510,22 @@ var init_batch_edit = __esm({
             items: {
               type: "object",
               properties: {
-                path: { type: "string", description: "File path relative to project root" },
-                old_string: { type: "string", description: "Exact string to find and replace" },
-                new_string: { type: "string", description: "Replacement string" }
+                path: {
+                  type: "string",
+                  description: "File path relative to project root"
+                },
+                old_string: {
+                  type: "string",
+                  description: "Exact string to find and replace (must be unique unless replace_all)"
+                },
+                new_string: {
+                  type: "string",
+                  description: "Replacement string"
+                },
+                replace_all: {
+                  type: "boolean",
+                  description: "Replace all occurrences (for renames). Default: false"
+                }
               },
               required: ["path", "old_string", "new_string"]
             }
@@ -2479,7 +2553,12 @@ var init_batch_edit = __esm({
           const fullPath = resolve9(this.workingDir, edit.path);
           if (!byFile.has(fullPath))
             byFile.set(fullPath, []);
-          byFile.get(fullPath).push({ old_string: edit.old_string, new_string: edit.new_string });
+          byFile.get(fullPath).push({
+            old_string: edit.old_string,
+            new_string: edit.new_string,
+            replace_all: edit.replace_all,
+            relPath: edit.path
+          });
         }
         const results = [];
         let successCount = 0;
@@ -2488,15 +2567,26 @@ var init_batch_edit = __esm({
           try {
             let content = await readFile5(fullPath, "utf-8");
             for (const edit of fileEdits) {
-              const index = content.indexOf(edit.old_string);
-              if (index === -1) {
-                results.push(`SKIP: old_string not found in ${fullPath}`);
+              const occurrences = countOccurrences2(content, edit.old_string);
+              if (occurrences === 0) {
+                results.push(`SKIP: old_string not found in ${edit.relPath}`);
+                failCount++;
+                continue;
+              }
+              if (!edit.replace_all && occurrences > 1) {
+                results.push(`AMBIGUOUS: old_string has ${occurrences} matches in ${edit.relPath} \u2014 add more context or use replace_all`);
                 failCount++;
                 continue;
               }
-              const lineNumber = content.slice(0, index).split("\n").length;
-              content = content.slice(0, index) + edit.new_string + content.slice(index + edit.old_string.length);
-              results.push(`EDIT: ${fullPath} line ${lineNumber}`);
+              if (edit.replace_all) {
+                content = content.split(edit.old_string).join(edit.new_string);
+                results.push(`EDIT: ${edit.relPath} (${occurrences} replacements)`);
+              } else {
+                const index = content.indexOf(edit.old_string);
+                const lineNumber = content.slice(0, index).split("\n").length;
+                content = content.slice(0, index) + edit.new_string + content.slice(index + edit.old_string.length);
+                results.push(`EDIT: ${edit.relPath} line ${lineNumber}`);
+              }
               successCount++;
             }
             await writeFile4(fullPath, content, "utf-8");
@@ -2518,6 +2608,178 @@ ${results.join("\n")}`,
   }
 });
 
+// packages/execution/dist/tools/file-patch.js
+import { readFile as readFile6, writeFile as writeFile5, copyFile } from "node:fs/promises";
+import { resolve as resolve10 } from "node:path";
+var FilePatchTool;
+var init_file_patch = __esm({
+  "packages/execution/dist/tools/file-patch.js"() {
+    "use strict";
+    FilePatchTool = class {
+      name = "file_patch";
+      description = "Edit specific line ranges in a file. More precise than string matching for large files. Modes: 'replace' replaces lines start_line..end_line with new_content, 'insert_before' inserts before start_line, 'insert_after' inserts after start_line, 'delete' removes lines start_line..end_line. Use dry_run to preview changes.";
+      parameters = {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "File path relative to project root"
+          },
+          start_line: {
+            type: "number",
+            description: "Starting line number (1-based, inclusive)"
+          },
+          end_line: {
+            type: "number",
+            description: "Ending line number (1-based, inclusive). Required for replace and delete modes. For single-line edits, set equal to start_line."
+          },
+          new_content: {
+            type: "string",
+            description: "Replacement content (for replace mode) or content to insert (for insert modes). Not needed for delete mode."
+          },
+          mode: {
+            type: "string",
+            enum: ["replace", "insert_before", "insert_after", "delete"],
+            description: "Edit mode. Default: replace"
+          },
+          dry_run: {
+            type: "boolean",
+            description: "Preview the diff without writing. Returns what would change. Default: false"
+          }
+        },
+        required: ["path", "start_line"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const filePath = args["path"];
+        const startLine = args["start_line"];
+        const endLine = args["end_line"] ?? startLine;
+        const newContent = args["new_content"] ?? "";
+        const mode = args["mode"] ?? "replace";
+        const dryRun = args["dry_run"] === true;
+        const start = performance.now();
+        try {
+          if (!Number.isInteger(startLine) || startLine < 1) {
+            return {
+              success: false,
+              output: "",
+              error: "start_line must be a positive integer (1-based)",
+              durationMs: performance.now() - start
+            };
+          }
+          if (!Number.isInteger(endLine) || endLine < startLine) {
+            return {
+              success: false,
+              output: "",
+              error: `end_line (${endLine}) must be >= start_line (${startLine})`,
+              durationMs: performance.now() - start
+            };
+          }
+          const fullPath = resolve10(this.workingDir, filePath);
+          const content = await readFile6(fullPath, "utf-8");
+          const lines = content.split("\n");
+          const totalLines = lines.length;
+          if (startLine > totalLines) {
+            return {
+              success: false,
+              output: "",
+              error: `start_line ${startLine} exceeds file length (${totalLines} lines)`,
+              durationMs: performance.now() - start
+            };
+          }
+          const effectiveEnd = Math.min(endLine, totalLines);
+          const startIdx = startLine - 1;
+          const endIdx = effectiveEnd;
+          const newLines = newContent.length > 0 ? newContent.split("\n") : [];
+          let resultLines;
+          let description;
+          switch (mode) {
+            case "replace": {
+              const removedLines = lines.slice(startIdx, endIdx);
+              resultLines = [
+                ...lines.slice(0, startIdx),
+                ...newLines,
+                ...lines.slice(endIdx)
+              ];
+              description = `Replaced lines ${startLine}-${effectiveEnd} (${removedLines.length} lines \u2192 ${newLines.length} lines)`;
+              break;
+            }
+            case "insert_before": {
+              resultLines = [
+                ...lines.slice(0, startIdx),
+                ...newLines,
+                ...lines.slice(startIdx)
+              ];
+              description = `Inserted ${newLines.length} lines before line ${startLine}`;
+              break;
+            }
+            case "insert_after": {
+              resultLines = [
+                ...lines.slice(0, startIdx + 1),
+                ...newLines,
+                ...lines.slice(startIdx + 1)
+              ];
+              description = `Inserted ${newLines.length} lines after line ${startLine}`;
+              break;
+            }
+            case "delete": {
+              const removedLines = lines.slice(startIdx, endIdx);
+              resultLines = [...lines.slice(0, startIdx), ...lines.slice(endIdx)];
+              description = `Deleted lines ${startLine}-${effectiveEnd} (${removedLines.length} lines removed)`;
+              break;
+            }
+            default:
+              return {
+                success: false,
+                output: "",
+                error: `Unknown mode: ${mode}. Use replace, insert_before, insert_after, or delete.`,
+                durationMs: performance.now() - start
+              };
+          }
+          const oldSection = lines.slice(Math.max(0, startIdx - 2), Math.min(totalLines, endIdx + 2)).map((l, i) => `- ${String(Math.max(1, startLine - 2) + i).padStart(4)} | ${l}`).join("\n");
+          const newSectionStart = Math.max(0, startIdx - 2);
+          const newSectionEnd = Math.min(resultLines.length, startIdx + newLines.length + 2);
+          const newSection = resultLines.slice(newSectionStart, newSectionEnd).map((l, i) => `+ ${String(newSectionStart + 1 + i).padStart(4)} | ${l}`).join("\n");
+          const diff = `${description}
+
+Before:
+${oldSection}
+
+After:
+${newSection}`;
+          if (dryRun) {
+            return {
+              success: true,
+              output: `[DRY RUN] ${diff}
+
+File NOT modified. Remove dry_run to apply.`,
+              durationMs: performance.now() - start
+            };
+          }
+          await writeFile5(fullPath, resultLines.join("\n"), "utf-8");
+          return {
+            success: true,
+            output: `${filePath}: ${description} (${totalLines} \u2192 ${resultLines.length} total lines)
+
+${diff}`,
+            durationMs: performance.now() - start
+          };
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: performance.now() - start
+          };
+        }
+      }
+    };
+  }
+});
+
 // packages/execution/dist/tools/codebase-map.js
 import { readdirSync as readdirSync3, statSync as statSync3, readFileSync as readFileSync4, existsSync as existsSync4 } from "node:fs";
 import { join as join7, relative, extname } from "node:path";
@@ -3372,7 +3634,7 @@ Exit code: ${task.exitCode ?? "N/A"}`,
 
 // packages/execution/dist/tools/image.js
 import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
-import { resolve as resolve10, extname as extname2, basename } from "node:path";
+import { resolve as resolve11, extname as extname2, basename } from "node:path";
 import { execSync as execSync7 } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join as join10 } from "node:path";
@@ -3481,7 +3743,7 @@ var init_image = __esm({
         if (!rawPath) {
           return { success: false, output: "", error: "path is required", durationMs: 0 };
         }
-        const fullPath = resolve10(this.workingDir, rawPath);
+        const fullPath = resolve11(this.workingDir, rawPath);
         if (!existsSync7(fullPath)) {
           return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
         }
@@ -3550,7 +3812,7 @@ ${ocrText}`);
       }
       async execute(args) {
         const start = Date.now();
-        const outputPath = args["output_path"] ? resolve10(this.workingDir, String(args["output_path"])) : join10(tmpdir(), `oa-screenshot-${Date.now()}.png`);
+        const outputPath = args["output_path"] ? resolve11(this.workingDir, String(args["output_path"])) : join10(tmpdir(), `oa-screenshot-${Date.now()}.png`);
         const delayMs = typeof args["delay_ms"] === "number" ? args["delay_ms"] : 0;
         const region = String(args["region"] ?? "full");
         if (delayMs > 0) {
@@ -3673,7 +3935,7 @@ ${ocrText}`);
         if (!rawPath) {
           return { success: false, output: "", error: "path is required", durationMs: 0 };
         }
-        const fullPath = resolve10(this.workingDir, rawPath);
+        const fullPath = resolve11(this.workingDir, rawPath);
         if (!existsSync7(fullPath)) {
           return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
         }
@@ -3723,6 +3985,510 @@ ${text}`,
   }
 });
 
+// packages/execution/dist/tools/custom-tool.js
+var custom_tool_exports = {};
+__export(custom_tool_exports, {
+  CustomTool: () => CustomTool,
+  buildCustomTools: () => buildCustomTools,
+  deleteCustomToolDefinition: () => deleteCustomToolDefinition,
+  listCustomToolFiles: () => listCustomToolFiles,
+  loadCustomTools: () => loadCustomTools,
+  saveCustomToolDefinition: () => saveCustomToolDefinition
+});
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join11 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { spawn as spawn3 } from "node:child_process";
+function projectToolsDir(repoRoot) {
+  return join11(repoRoot, ".oa", "tools");
+}
+function loadCustomTools(repoRoot) {
+  const definitions = /* @__PURE__ */ new Map();
+  for (const def of loadFromDirectory(GLOBAL_TOOLS_DIR)) {
+    definitions.set(def.name, def);
+  }
+  const projectDir = projectToolsDir(repoRoot);
+  for (const def of loadFromDirectory(projectDir)) {
+    definitions.set(def.name, def);
+  }
+  return Array.from(definitions.values());
+}
+function buildCustomTools(repoRoot) {
+  const definitions = loadCustomTools(repoRoot);
+  return definitions.map((def) => new CustomTool(def, repoRoot));
+}
+function saveCustomToolDefinition(definition, scope, repoRoot) {
+  const dir = scope === "project" && repoRoot ? projectToolsDir(repoRoot) : GLOBAL_TOOLS_DIR;
+  mkdirSync3(dir, { recursive: true });
+  const filePath = join11(dir, `${definition.name}.json`);
+  writeFileSync3(filePath, JSON.stringify(definition, null, 2), "utf-8");
+  return filePath;
+}
+function deleteCustomToolDefinition(name, scope, repoRoot) {
+  const dir = scope === "project" && repoRoot ? projectToolsDir(repoRoot) : GLOBAL_TOOLS_DIR;
+  const filePath = join11(dir, `${name}.json`);
+  if (existsSync8(filePath)) {
+    const { unlinkSync: unlinkSync2 } = __require("node:fs");
+    unlinkSync2(filePath);
+    return true;
+  }
+  return false;
+}
+function listCustomToolFiles(repoRoot) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const def of loadFromDirectory(projectToolsDir(repoRoot))) {
+    result.push({
+      name: def.name,
+      scope: "project",
+      description: def.description,
+      stepsCount: def.steps.length,
+      version: def.version
+    });
+    seen.add(def.name);
+  }
+  for (const def of loadFromDirectory(GLOBAL_TOOLS_DIR)) {
+    if (!seen.has(def.name)) {
+      result.push({
+        name: def.name,
+        scope: "global",
+        description: def.description,
+        stepsCount: def.steps.length,
+        version: def.version
+      });
+    }
+  }
+  return result;
+}
+function loadFromDirectory(dir) {
+  if (!existsSync8(dir))
+    return [];
+  const definitions = [];
+  try {
+    const files = readdirSync4(dir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const content = readFileSync7(join11(dir, file), "utf-8");
+        const def = JSON.parse(content);
+        if (def.name && def.description && Array.isArray(def.steps) && def.steps.length > 0) {
+          if (!def.parameters || typeof def.parameters !== "object") {
+            def.parameters = { type: "object", properties: {}, required: [] };
+          }
+          definitions.push(def);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return definitions;
+}
+var GLOBAL_TOOLS_DIR, CustomTool;
+var init_custom_tool = __esm({
+  "packages/execution/dist/tools/custom-tool.js"() {
+    "use strict";
+    GLOBAL_TOOLS_DIR = join11(homedir3(), ".open-agents", "tools");
+    CustomTool = class {
+      name;
+      description;
+      parameters;
+      steps;
+      workingDir;
+      constructor(definition, workingDir) {
+        this.name = definition.name;
+        this.description = definition.description;
+        this.parameters = definition.parameters;
+        this.steps = definition.steps;
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const start = performance.now();
+        const outputs = [];
+        let allSuccess = true;
+        for (let i = 0; i < this.steps.length; i++) {
+          const step = this.steps[i];
+          const command = this.interpolate(step.command, args);
+          outputs.push(`--- Step ${i + 1}: ${step.description} ---`);
+          outputs.push(`$ ${command}`);
+          try {
+            const result = await this.runCommand(command);
+            outputs.push(result.output);
+            if (!result.success) {
+              allSuccess = false;
+              if (result.error)
+                outputs.push(`Error: ${result.error}`);
+              if (!step.continueOnError) {
+                outputs.push(`Step ${i + 1} failed. Stopping.`);
+                break;
+              }
+              outputs.push(`Step ${i + 1} failed but continueOnError=true, proceeding.`);
+            }
+          } catch (err) {
+            allSuccess = false;
+            outputs.push(`Step ${i + 1} error: ${err instanceof Error ? err.message : String(err)}`);
+            if (!step.continueOnError)
+              break;
+          }
+        }
+        return {
+          success: allSuccess,
+          output: outputs.join("\n"),
+          error: allSuccess ? void 0 : "One or more steps failed",
+          durationMs: performance.now() - start
+        };
+      }
+      /** Replace {{param}} placeholders with actual argument values */
+      interpolate(template, args) {
+        return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+          const val = args[key];
+          if (val === void 0 || val === null)
+            return "";
+          return String(val).replace(/[`$\\!"]/g, "\\$&");
+        });
+      }
+      /** Execute a single shell command and return output */
+      runCommand(command) {
+        return new Promise((resolve15) => {
+          const child = spawn3("bash", ["-c", command], {
+            cwd: this.workingDir,
+            env: { ...process.env, CI: "true", NO_COLOR: "1" },
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          let stdout = "";
+          let stderr = "";
+          const maxBuf = 512 * 1024;
+          child.stdout.on("data", (data) => {
+            stdout += data.toString();
+            if (stdout.length > maxBuf)
+              stdout = stdout.slice(0, maxBuf);
+          });
+          child.stderr.on("data", (data) => {
+            stderr += data.toString();
+            if (stderr.length > maxBuf)
+              stderr = stderr.slice(0, maxBuf);
+          });
+          child.stdin.end();
+          const timer = setTimeout(() => {
+            try {
+              child.kill("SIGTERM");
+            } catch {
+            }
+            resolve15({ success: false, output: stdout, error: "Command timed out after 60s" });
+          }, 6e4);
+          child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve15({
+              success: code === 0,
+              output: stdout + (stderr && code === 0 ? `
+STDERR:
+${stderr}` : ""),
+              error: code !== 0 ? stderr || `Exit code ${code}` : void 0
+            });
+          });
+          child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve15({ success: false, output: stdout, error: err.message });
+          });
+        });
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/tool-creator.js
+var CreateToolTool, ManageToolsTool;
+var init_tool_creator = __esm({
+  "packages/execution/dist/tools/tool-creator.js"() {
+    "use strict";
+    init_custom_tool();
+    CreateToolTool = class {
+      name = "create_tool";
+      description = "Create a reusable custom tool from a multi-step workflow. Use this when you notice you're performing the same sequence of operations repeatedly (3+ times). The tool will be saved and available in future sessions. Parameters in step commands use {{param}} interpolation.";
+      parameters = {
+        type: "object",
+        properties: {
+          tool_name: {
+            type: "string",
+            description: "Unique tool name in snake_case (e.g., deploy_staging, run_full_test_suite)"
+          },
+          tool_description: {
+            type: "string",
+            description: "Clear description of what this tool does (shown to the agent)"
+          },
+          tool_parameters: {
+            type: "object",
+            description: `JSON Schema for the tool's parameters. Example: {"type":"object","properties":{"branch":{"type":"string","description":"Branch name"}},"required":["branch"]}`
+          },
+          steps: {
+            type: "array",
+            description: "Ordered list of steps. Each step has: command (shell command with {{param}} placeholders), description (what this step does), continueOnError (optional boolean).",
+            items: {
+              type: "object",
+              properties: {
+                command: { type: "string" },
+                description: { type: "string" },
+                continueOnError: { type: "boolean" }
+              },
+              required: ["command", "description"]
+            }
+          },
+          scope: {
+            type: "string",
+            enum: ["project", "global"],
+            description: "Where to save: 'project' saves to .oa/tools/ (this workspace only), 'global' saves to ~/.open-agents/tools/ (available in all projects). Use 'project' for project-specific workflows, 'global' for cross-project patterns."
+          },
+          source_pattern: {
+            type: "string",
+            description: "Description of the repeated pattern that motivated creating this tool"
+          }
+        },
+        required: ["tool_name", "tool_description", "steps", "scope"]
+      };
+      repoRoot;
+      constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+      }
+      async execute(args) {
+        const start = performance.now();
+        const toolName = String(args["tool_name"] ?? "").trim();
+        const toolDescription = String(args["tool_description"] ?? "").trim();
+        const rawSteps = args["steps"];
+        const scope = args["scope"] === "global" ? "global" : "project";
+        const toolParameters = args["tool_parameters"] ?? {
+          type: "object",
+          properties: {},
+          required: []
+        };
+        const sourcePattern = args["source_pattern"];
+        if (!toolName) {
+          return {
+            success: false,
+            output: "",
+            error: "tool_name is required",
+            durationMs: performance.now() - start
+          };
+        }
+        if (!/^[a-z][a-z0-9_]*$/.test(toolName)) {
+          return {
+            success: false,
+            output: "",
+            error: "tool_name must be snake_case (lowercase letters, numbers, underscores, starting with a letter)",
+            durationMs: performance.now() - start
+          };
+        }
+        const CORE_TOOLS = /* @__PURE__ */ new Set([
+          "file_read",
+          "file_write",
+          "file_edit",
+          "shell",
+          "grep_search",
+          "find_files",
+          "list_directory",
+          "web_fetch",
+          "web_search",
+          "memory_read",
+          "memory_write",
+          "task_complete",
+          "sub_agent",
+          "background_run",
+          "task_status",
+          "task_output",
+          "task_stop",
+          "batch_edit",
+          "codebase_map",
+          "diagnostic",
+          "git_info",
+          "image_read",
+          "screenshot",
+          "ocr",
+          "create_tool",
+          "manage_tools",
+          "aiwg_setup",
+          "aiwg_health",
+          "aiwg_workflow"
+        ]);
+        if (CORE_TOOLS.has(toolName)) {
+          return {
+            success: false,
+            output: "",
+            error: `Cannot override core tool: ${toolName}`,
+            durationMs: performance.now() - start
+          };
+        }
+        if (!toolDescription) {
+          return {
+            success: false,
+            output: "",
+            error: "tool_description is required",
+            durationMs: performance.now() - start
+          };
+        }
+        if (!rawSteps || !Array.isArray(rawSteps) || rawSteps.length === 0) {
+          return {
+            success: false,
+            output: "",
+            error: "steps must be a non-empty array of {command, description} objects",
+            durationMs: performance.now() - start
+          };
+        }
+        const steps = [];
+        for (let i = 0; i < rawSteps.length; i++) {
+          const raw = rawSteps[i];
+          const command = String(raw["command"] ?? "").trim();
+          const description = String(raw["description"] ?? "").trim();
+          if (!command) {
+            return {
+              success: false,
+              output: "",
+              error: `Step ${i + 1} is missing a command`,
+              durationMs: performance.now() - start
+            };
+          }
+          steps.push({
+            command,
+            description: description || `Step ${i + 1}`,
+            continueOnError: Boolean(raw["continueOnError"])
+          });
+        }
+        const existing = loadCustomTools(this.repoRoot);
+        const existingTool = existing.find((t) => t.name === toolName);
+        const isUpdate = !!existingTool;
+        const definition = {
+          name: toolName,
+          description: toolDescription,
+          version: isUpdate ? existingTool.version + 1 : 1,
+          parameters: toolParameters,
+          steps,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdBy: "agent",
+          sourcePattern,
+          triggerCount: void 0
+        };
+        try {
+          const filePath = saveCustomToolDefinition(definition, scope, this.repoRoot);
+          const output = [
+            `Custom tool ${isUpdate ? "updated" : "created"}: ${toolName}`,
+            `  Scope: ${scope}`,
+            `  Saved to: ${filePath}`,
+            `  Steps: ${steps.length}`,
+            `  Version: ${definition.version}`,
+            "",
+            "The tool will be available in future sessions.",
+            isUpdate ? "Note: This updates the existing tool definition." : "",
+            "",
+            "Definition:",
+            JSON.stringify(definition, null, 2)
+          ].join("\n");
+          return {
+            success: true,
+            output,
+            durationMs: performance.now() - start
+          };
+        } catch (err) {
+          return {
+            success: false,
+            output: "",
+            error: `Failed to save tool: ${err instanceof Error ? err.message : String(err)}`,
+            durationMs: performance.now() - start
+          };
+        }
+      }
+    };
+    ManageToolsTool = class {
+      name = "manage_tools";
+      description = "List, inspect, or delete custom tools. Actions: 'list' (show all custom tools), 'inspect <name>' (show definition), 'delete <name> <scope>' (remove a tool).";
+      parameters = {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["list", "inspect", "delete"],
+            description: "Action to perform"
+          },
+          tool_name: {
+            type: "string",
+            description: "Tool name (for inspect/delete)"
+          },
+          scope: {
+            type: "string",
+            enum: ["project", "global"],
+            description: "Scope for delete action"
+          }
+        },
+        required: ["action"]
+      };
+      repoRoot;
+      constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+      }
+      async execute(args) {
+        const start = performance.now();
+        const action = String(args["action"] ?? "list");
+        const toolName = args["tool_name"];
+        switch (action) {
+          case "list": {
+            const { listCustomToolFiles: listCustomToolFiles2 } = await Promise.resolve().then(() => (init_custom_tool(), custom_tool_exports));
+            const tools = listCustomToolFiles2(this.repoRoot);
+            if (tools.length === 0) {
+              return {
+                success: true,
+                output: "No custom tools installed.\n\nUse create_tool to create one from a repeated workflow.",
+                durationMs: performance.now() - start
+              };
+            }
+            const lines = ["Custom Tools:", ""];
+            for (const t of tools) {
+              lines.push(`  ${t.name} (${t.scope}, v${t.version}, ${t.stepsCount} steps)`);
+              lines.push(`    ${t.description}`);
+            }
+            return {
+              success: true,
+              output: lines.join("\n"),
+              durationMs: performance.now() - start
+            };
+          }
+          case "inspect": {
+            if (!toolName) {
+              return { success: false, output: "", error: "tool_name required for inspect", durationMs: performance.now() - start };
+            }
+            const tools = loadCustomTools(this.repoRoot);
+            const tool = tools.find((t) => t.name === toolName);
+            if (!tool) {
+              return { success: false, output: "", error: `Tool not found: ${toolName}`, durationMs: performance.now() - start };
+            }
+            return {
+              success: true,
+              output: JSON.stringify(tool, null, 2),
+              durationMs: performance.now() - start
+            };
+          }
+          case "delete": {
+            if (!toolName) {
+              return { success: false, output: "", error: "tool_name required for delete", durationMs: performance.now() - start };
+            }
+            const scope = args["scope"] === "global" ? "global" : "project";
+            const { deleteCustomToolDefinition: deleteCustomToolDefinition2 } = await Promise.resolve().then(() => (init_custom_tool(), custom_tool_exports));
+            const deleted = deleteCustomToolDefinition2(toolName, scope, this.repoRoot);
+            return {
+              success: deleted,
+              output: deleted ? `Deleted custom tool: ${toolName} (${scope})` : `Tool not found: ${toolName} (${scope})`,
+              error: deleted ? void 0 : "Tool not found",
+              durationMs: performance.now() - start
+            };
+          }
+          default:
+            return {
+              success: false,
+              output: "",
+              error: `Unknown action: ${action}. Use list, inspect, or delete.`,
+              durationMs: performance.now() - start
+            };
+        }
+      }
+    };
+  }
+});
+
 // packages/execution/dist/shellRunner.js
 var init_shellRunner = __esm({
   "packages/execution/dist/shellRunner.js"() {
@@ -3817,11 +4583,14 @@ var init_dist2 = __esm({
     init_aiwg_health();
     init_aiwg_workflow();
     init_batch_edit();
+    init_file_patch();
     init_codebase_map();
     init_diagnostic();
     init_git_info();
     init_background_task();
     init_image();
+    init_custom_tool();
+    init_tool_creator();
     init_shellRunner();
     init_gitWorktree();
     init_patchApplier();
@@ -4936,8 +5705,8 @@ var init_code_retriever = __esm({
         });
       }
       async getFileContent(filePath, startLine, endLine) {
-        const { readFile: readFile9 } = await import("node:fs/promises");
-        const content = await readFile9(filePath, "utf-8");
+        const { readFile: readFile10 } = await import("node:fs/promises");
+        const content = await readFile10(filePath, "utf-8");
         if (startLine === void 0)
           return content;
         const lines = content.split("\n");
@@ -4952,8 +5721,8 @@ var init_code_retriever = __esm({
 // packages/retrieval/dist/lexicalSearch.js
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { readFile as readFile6, readdir, stat } from "node:fs/promises";
-import { join as join11, extname as extname3 } from "node:path";
+import { readFile as readFile7, readdir, stat } from "node:fs/promises";
+import { join as join12, extname as extname3 } from "node:path";
 async function searchByPath(pathPattern, options) {
   const allFiles = await collectFiles(options.rootDir, options.includeGlobs ?? DEFAULT_INCLUDE_GLOBS, options.excludeGlobs ?? DEFAULT_EXCLUDE_GLOBS);
   const pattern = options.caseInsensitive ? pathPattern.toLowerCase() : pathPattern;
@@ -5058,7 +5827,7 @@ async function searchWithNodeFallback(pattern, kind, options) {
     if (results.length >= maxMatches)
       break;
     try {
-      const content = await readFile6(filePath, "utf-8");
+      const content = await readFile7(filePath, "utf-8");
       const contentLines = content.split("\n");
       for (let i = 0; i < contentLines.length; i++) {
         if (results.length >= maxMatches)
@@ -5095,7 +5864,7 @@ async function walkForFiles(rootDir, dir, excludeGlobs, results) {
       continue;
     if (excludeGlobs.some((g) => entry.name === g || matchesGlob(entry.name, g)))
       continue;
-    const absPath = join11(dir, entry.name);
+    const absPath = join12(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForFiles(rootDir, absPath, excludeGlobs, results);
     } else if (entry.isFile()) {
@@ -5269,8 +6038,8 @@ var init_graphExpand = __esm({
 });
 
 // packages/retrieval/dist/snippetPacker.js
-import { readFile as readFile7 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import { join as join13 } from "node:path";
 async function packSnippets(requests, opts = {}) {
   const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
   const contextLines = opts.contextLines ?? DEFAULT_CONTEXT_LINES;
@@ -5296,10 +6065,10 @@ async function packSnippets(requests, opts = {}) {
   return { packed, dropped, totalTokens };
 }
 async function extractSnippet(req, repoRoot, contextLines = DEFAULT_CONTEXT_LINES) {
-  const absPath = req.filePath.startsWith("/") ? req.filePath : join12(repoRoot, req.filePath);
+  const absPath = req.filePath.startsWith("/") ? req.filePath : join13(repoRoot, req.filePath);
   let content;
   try {
-    content = await readFile7(absPath, "utf-8");
+    content = await readFile8(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -6458,7 +7227,8 @@ var init_agenticRunner = __esm({
 
 - file_read: Read file contents (always read before editing). Supports path, offset, limit.
 - file_write: Create or overwrite a file with complete content
-- file_edit: Make a precise string replacement in a file (preferred over rewriting). Uses old_string/new_string.
+- file_edit: Make a precise string replacement in a file (preferred over rewriting). Uses old_string/new_string. old_string must be unique unless replace_all=true. Use replace_all for variable renames.
+- file_patch: Edit specific line ranges in large files. Modes: replace (swap lines), insert_before, insert_after, delete. Use dry_run to preview. Best for large files (500+ lines) where string matching is fragile.
 - find_files: Find files by name pattern (glob). Searches recursively, excludes node_modules/.git.
 - grep_search: Search file contents with regex. Returns matching lines with paths and line numbers.
 - shell: Execute any shell command (tests, builds, git, npm, etc.). Supports stdin parameter for input. Commands run with CI=true for non-interactive mode.
@@ -6564,11 +7334,39 @@ Commands run non-interactively (CI=true). When running scaffolding tools:
 - If a command needs specific answers, use the stdin parameter
 - If a command times out, it likely hit an interactive prompt \u2014 retry with --yes
 
+## Custom Tools
+
+- create_tool: Create a reusable custom tool from a repeated multi-step workflow. Saves to .oa/tools/ (project) or ~/.open-agents/tools/ (global).
+- manage_tools: List, inspect, or delete custom tools.
+
+Custom tools are agent-created shell command sequences that automate repeated workflows.
+They appear alongside core tools and can be invoked just like any built-in tool.
+
+### When to Create a Custom Tool
+
+If you notice you're performing the SAME multi-step sequence for the 3rd time or more:
+1. Recognize the repeated pattern (e.g., "bump version \u2192 build \u2192 publish \u2192 commit \u2192 push")
+2. Identify what varies between runs (these become parameters)
+3. Call create_tool with the steps and parameters
+4. Choose scope: 'project' for project-specific workflows, 'global' for cross-project patterns
+
+### Custom Tool Guidelines
+
+- Name tools descriptively in snake_case (e.g., run_full_validation, deploy_to_staging)
+- Use {{param}} syntax in step commands for interpolation
+- Set continueOnError=true on steps that may fail but shouldn't stop the pipeline
+- Test the tool mentally before creating \u2014 ensure the steps would work in order
+- Prefer 'project' scope unless the pattern genuinely applies to all projects
+
 ## Context Efficiency
 
 - Use grep_search to find specific code instead of reading many files
 - Use file_edit for targeted changes instead of full file rewrites
-- When files are long, use file_read with offset/limit to read specific sections
+- Use file_edit with replace_all=true for variable/function renames across a file
+- If file_edit fails with "not unique", include more surrounding context in old_string
+- For large files (500+ lines): use file_read with offset/limit, then file_patch with line numbers
+- file_patch with dry_run=true lets you preview changes before applying them
+- batch_edit to apply multiple edits across files in one call (reduces turns)
 - Focus on error messages in shell output \u2014 skip verbose build logs
 - Don't read files you don't need to modify`;
     AgenticRunner = class {
@@ -7708,6 +8506,7 @@ function renderSlashHelp() {
     ["/voice <model>", "Set voice: glados, overwatch"],
     ["/stream", "Toggle real-time token streaming (pastel syntax highlighting)"],
     ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
+    ["/tools", "List agent-created custom tools"],
     ["/verbose", "Toggle verbose mode"],
     ["/clear", "Clear the screen"],
     ["/help", "Show this help"],
@@ -7953,6 +8752,7 @@ var init_render = __esm({
       "file_read",
       "file_write",
       "file_edit",
+      "file_patch",
       "shell",
       "grep_search",
       "find_files",
@@ -7976,6 +8776,8 @@ var init_render = __esm({
       "aiwg_setup",
       "aiwg_health",
       "aiwg_workflow",
+      "create_tool",
+      "manage_tools",
       "task_complete"
     ];
     COMMAND_NAMES = [
@@ -7988,6 +8790,7 @@ var init_render = __esm({
       "/stream",
       "/verbose",
       "/bruteforce",
+      "/tools",
       "/clear",
       "/help",
       "/quit"
@@ -8080,6 +8883,27 @@ async function handleSlashCommand(input, ctx) {
       renderInfo(`Token streaming: ${isOn ? "on" : "off"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 thinking tokens in grey italics, responses with pastel syntax highlighting" : ""));
       return "handled";
     }
+    case "tools": {
+      const tools = listCustomToolFiles(ctx.repoRoot);
+      if (tools.length === 0) {
+        renderInfo("No custom tools installed.");
+        renderInfo("The agent will automatically create tools when it detects repeated workflows (3+ times).");
+        renderInfo('Or ask the agent: "create a tool for [workflow]"');
+      } else {
+        process.stdout.write(`
+  ${c2.bold("Custom Tools:")}
+
+`);
+        for (const t of tools) {
+          process.stdout.write(`  ${c2.cyan(t.name.padEnd(28))} ${c2.dim(`(${t.scope}, v${t.version}, ${t.stepsCount} steps)`)}
+`);
+          process.stdout.write(`  ${"".padEnd(28)} ${t.description}
+`);
+        }
+        process.stdout.write("\n");
+      }
+      return "handled";
+    }
     case "bruteforce":
     case "brute": {
       const isOn = ctx.bruteForceToggle();
@@ -8208,17 +9032,17 @@ async function handleUpdate() {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath3 } = await import("node:url");
-    const { dirname: dirname5, join: join22 } = await import("node:path");
-    const { existsSync: existsSync14 } = await import("node:fs");
+    const { dirname: dirname4, join: join23 } = await import("node:path");
+    const { existsSync: existsSync15 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
-    const thisDir = dirname5(fileURLToPath3(import.meta.url));
+    const thisDir = dirname4(fileURLToPath3(import.meta.url));
     const candidates = [
-      join22(thisDir, "..", "package.json"),
-      join22(thisDir, "..", "..", "package.json"),
-      join22(thisDir, "..", "..", "..", "package.json")
+      join23(thisDir, "..", "package.json"),
+      join23(thisDir, "..", "..", "package.json"),
+      join23(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync14(pkgPath)) {
+      if (existsSync15(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -8286,6 +9110,7 @@ var init_commands = __esm({
     "use strict";
     init_model_picker();
     init_render();
+    init_dist2();
     init_config();
     init_updater();
   }
@@ -8294,9 +9119,9 @@ var init_commands = __esm({
 // packages/cli/dist/tui/setup.js
 import * as readline from "node:readline";
 import { execSync as execSync8 } from "node:child_process";
-import { existsSync as existsSync8, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join13 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { existsSync as existsSync9, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join14 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 function detectSystemSpecs() {
   let totalRamGB = 0;
   let availableRamGB = 0;
@@ -8379,8 +9204,8 @@ function modelSupportsToolCalling(modelName) {
   return false;
 }
 function ask(rl, question) {
-  return new Promise((resolve14) => {
-    rl.question(question, (answer) => resolve14(answer.trim()));
+  return new Promise((resolve15) => {
+    rl.question(question, (answer) => resolve15(answer.trim()));
   });
 }
 function pullModelWithAutoUpdate(tag) {
@@ -8591,10 +9416,10 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict 16384`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir2 = join13(homedir3(), ".open-agents", "models");
-        mkdirSync3(modelDir2, { recursive: true });
-        const modelfilePath = join13(modelDir2, `Modelfile.${customName}`);
-        writeFileSync3(modelfilePath, modelfileContent + "\n", "utf8");
+        const modelDir2 = join14(homedir4(), ".open-agents", "models");
+        mkdirSync4(modelDir2, { recursive: true });
+        const modelfilePath = join14(modelDir2, `Modelfile.${customName}`);
+        writeFileSync4(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
         execSync8(`ollama create ${customName} -f ${modelfilePath}`, {
           stdio: "pipe",
@@ -8639,7 +9464,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync8(join13(homedir3(), ".open-agents", "config.json"));
+    return !existsSync9(join14(homedir4(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -8679,52 +9504,52 @@ var init_setup = __esm({
 });
 
 // packages/cli/dist/tui/oa-directory.js
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
-import { join as join14, relative as relative2, basename as basename2, extname as extname4 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
+import { join as join15, relative as relative2, basename as basename2, extname as extname4 } from "node:path";
+import { homedir as homedir5 } from "node:os";
 function initOaDirectory(repoRoot) {
-  const oaPath = join14(repoRoot, OA_DIR);
+  const oaPath = join15(repoRoot, OA_DIR);
   for (const sub of SUBDIRS) {
-    mkdirSync4(join14(oaPath, sub), { recursive: true });
+    mkdirSync5(join15(oaPath, sub), { recursive: true });
   }
   return oaPath;
 }
 function hasOaDirectory(repoRoot) {
-  return existsSync9(join14(repoRoot, OA_DIR, "index"));
+  return existsSync10(join15(repoRoot, OA_DIR, "index"));
 }
 function loadProjectSettings(repoRoot) {
-  const settingsPath = join14(repoRoot, OA_DIR, "settings.json");
+  const settingsPath = join15(repoRoot, OA_DIR, "settings.json");
   try {
-    if (existsSync9(settingsPath)) {
-      return JSON.parse(readFileSync7(settingsPath, "utf-8"));
+    if (existsSync10(settingsPath)) {
+      return JSON.parse(readFileSync8(settingsPath, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveProjectSettings(repoRoot, settings) {
-  const oaPath = join14(repoRoot, OA_DIR);
-  mkdirSync4(oaPath, { recursive: true });
+  const oaPath = join15(repoRoot, OA_DIR);
+  mkdirSync5(oaPath, { recursive: true });
   const existing = loadProjectSettings(repoRoot);
   const merged = { ...existing, ...settings };
-  writeFileSync4(join14(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  writeFileSync5(join15(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 function loadGlobalSettings() {
-  const settingsPath = join14(homedir4(), ".open-agents", "settings.json");
+  const settingsPath = join15(homedir5(), ".open-agents", "settings.json");
   try {
-    if (existsSync9(settingsPath)) {
-      return JSON.parse(readFileSync7(settingsPath, "utf-8"));
+    if (existsSync10(settingsPath)) {
+      return JSON.parse(readFileSync8(settingsPath, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveGlobalSettings(settings) {
-  const dir = join14(homedir4(), ".open-agents");
-  mkdirSync4(dir, { recursive: true });
+  const dir = join15(homedir5(), ".open-agents");
+  mkdirSync5(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
-  writeFileSync4(join14(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  writeFileSync5(join15(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 function resolveSettings(repoRoot) {
   const global = loadGlobalSettings();
@@ -8739,12 +9564,12 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   while (dir && !visited.has(dir)) {
     visited.add(dir);
     for (const name of CONTEXT_FILES) {
-      const filePath = join14(dir, name);
+      const filePath = join15(dir, name);
       const normalizedName = name.toLowerCase();
-      if (existsSync9(filePath) && !seen.has(filePath)) {
+      if (existsSync10(filePath) && !seen.has(filePath)) {
         seen.add(filePath);
         try {
-          let content = readFileSync7(filePath, "utf-8");
+          let content = readFileSync8(filePath, "utf-8");
           if (content.length > maxContentLen) {
             content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
           }
@@ -8758,11 +9583,11 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
         }
       }
     }
-    const projectMap = join14(dir, OA_DIR, "context", "project-map.md");
-    if (existsSync9(projectMap) && !seen.has(projectMap)) {
+    const projectMap = join15(dir, OA_DIR, "context", "project-map.md");
+    if (existsSync10(projectMap) && !seen.has(projectMap)) {
       seen.add(projectMap);
       try {
-        let content = readFileSync7(projectMap, "utf-8");
+        let content = readFileSync8(projectMap, "utf-8");
         if (content.length > maxContentLen) {
           content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
         }
@@ -8774,7 +9599,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
       } catch {
       }
     }
-    const parent = join14(dir, "..");
+    const parent = join15(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -8792,9 +9617,9 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   return found;
 }
 function readIndexMeta(repoRoot) {
-  const metaPath = join14(repoRoot, OA_DIR, "index", "meta.json");
+  const metaPath = join15(repoRoot, OA_DIR, "index", "meta.json");
   try {
-    return JSON.parse(readFileSync7(metaPath, "utf-8"));
+    return JSON.parse(readFileSync8(metaPath, "utf-8"));
   } catch {
     return null;
   }
@@ -8845,28 +9670,28 @@ ${tree}\`\`\`
     sections.push("");
   }
   const content = sections.join("\n");
-  const contextDir = join14(repoRoot, OA_DIR, "context");
-  mkdirSync4(contextDir, { recursive: true });
-  writeFileSync4(join14(contextDir, "project-map.md"), content, "utf-8");
+  const contextDir = join15(repoRoot, OA_DIR, "context");
+  mkdirSync5(contextDir, { recursive: true });
+  writeFileSync5(join15(contextDir, "project-map.md"), content, "utf-8");
   return content;
 }
 function saveSession(repoRoot, session) {
-  const historyDir = join14(repoRoot, OA_DIR, "history");
-  mkdirSync4(historyDir, { recursive: true });
-  writeFileSync4(join14(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+  const historyDir = join15(repoRoot, OA_DIR, "history");
+  mkdirSync5(historyDir, { recursive: true });
+  writeFileSync5(join15(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
 }
 function loadRecentSessions(repoRoot, limit = 5) {
-  const historyDir = join14(repoRoot, OA_DIR, "history");
-  if (!existsSync9(historyDir))
+  const historyDir = join15(repoRoot, OA_DIR, "history");
+  if (!existsSync10(historyDir))
     return [];
   try {
-    const files = readdirSync4(historyDir).filter((f) => f.endsWith(".json")).map((f) => {
-      const stat3 = statSync5(join14(historyDir, f));
+    const files = readdirSync5(historyDir).filter((f) => f.endsWith(".json")).map((f) => {
+      const stat3 = statSync5(join15(historyDir, f));
       return { file: f, mtime: stat3.mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
     return files.map((f) => {
       try {
-        return JSON.parse(readFileSync7(join14(historyDir, f.file), "utf-8"));
+        return JSON.parse(readFileSync8(join15(historyDir, f.file), "utf-8"));
       } catch {
         return null;
       }
@@ -8893,12 +9718,12 @@ function detectManifests(repoRoot) {
     { file: "docker-compose.yaml", type: "Docker Compose" }
   ];
   for (const check of checks) {
-    const filePath = join14(repoRoot, check.file);
-    if (existsSync9(filePath)) {
+    const filePath = join15(repoRoot, check.file);
+    if (existsSync10(filePath)) {
       let name;
       if (check.nameField) {
         try {
-          const data = JSON.parse(readFileSync7(filePath, "utf-8"));
+          const data = JSON.parse(readFileSync8(filePath, "utf-8"));
           name = data[check.nameField];
         } catch {
         }
@@ -8927,7 +9752,7 @@ function findKeyFiles(repoRoot) {
     { pattern: "CLAUDE.md", description: "Claude Code context" }
   ];
   for (const check of checks) {
-    if (existsSync9(join14(repoRoot, check.pattern))) {
+    if (existsSync10(join15(repoRoot, check.pattern))) {
       keyFiles.push({ path: check.pattern, description: check.description });
     }
   }
@@ -8938,7 +9763,7 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
     return "";
   let result = "";
   try {
-    const entries = readdirSync4(root, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") || e.name === ".github").filter((e) => !SKIP_DIRS.has(e.name)).sort((a, b) => {
+    const entries = readdirSync5(root, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") || e.name === ".github").filter((e) => !SKIP_DIRS.has(e.name)).sort((a, b) => {
       if (a.isDirectory() && !b.isDirectory())
         return -1;
       if (!a.isDirectory() && b.isDirectory())
@@ -8953,12 +9778,12 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
       if (entry.isDirectory()) {
         let fileCount = 0;
         try {
-          fileCount = readdirSync4(join14(root, entry.name)).filter((f) => !f.startsWith(".")).length;
+          fileCount = readdirSync5(join15(root, entry.name)).filter((f) => !f.startsWith(".")).length;
         } catch {
         }
         result += `${prefix}${connector}${entry.name}/ (${fileCount})
 `;
-        result += buildDirTree(join14(root, entry.name), maxDepth, childPrefix, depth + 1);
+        result += buildDirTree(join15(root, entry.name), maxDepth, childPrefix, depth + 1);
       } else if (depth < maxDepth) {
         result += `${prefix}${connector}${entry.name}
 `;
@@ -8973,7 +9798,7 @@ var init_oa_directory = __esm({
   "packages/cli/dist/tui/oa-directory.js"() {
     "use strict";
     OA_DIR = ".oa";
-    SUBDIRS = ["memory", "index", "context", "history", "notes", "embedded", "provenance"];
+    SUBDIRS = ["memory", "index", "context", "history", "notes", "embedded", "provenance", "tools"];
     CONTEXT_FILES = [
       "AGENTS.md",
       "OA.md",
@@ -9007,10 +9832,10 @@ var init_oa_directory = __esm({
 });
 
 // packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync10, readFileSync as readFileSync8, readdirSync as readdirSync5 } from "node:fs";
-import { join as join15, basename as basename3 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync9, readdirSync as readdirSync6 } from "node:fs";
+import { join as join16, basename as basename3 } from "node:path";
 import { execSync as execSync9 } from "node:child_process";
-import { homedir as homedir5, platform, release } from "node:os";
+import { homedir as homedir6, platform, release } from "node:os";
 function loadProjectFiles(repoRoot) {
   const discovered = discoverContextFiles(repoRoot);
   if (discovered.length === 0)
@@ -9028,10 +9853,10 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath = join15(repoRoot, OA_DIR, "context", "project-map.md");
-  if (existsSync10(mapPath)) {
+  const mapPath = join16(repoRoot, OA_DIR, "context", "project-map.md");
+  if (existsSync11(mapPath)) {
     try {
-      const content = readFileSync8(mapPath, "utf-8");
+      const content = readFileSync9(mapPath, "utf-8");
       return content;
     } catch {
     }
@@ -9072,31 +9897,31 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join15(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join16(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join15(repoRoot, ".open-agents", "memory");
-  if (legacyMemDir !== oaMemDir && existsSync10(legacyMemDir)) {
+  const legacyMemDir = join16(repoRoot, ".open-agents", "memory");
+  if (legacyMemDir !== oaMemDir && existsSync11(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join15(homedir5(), ".open-agents", "memory");
+  const globalMemDir = join16(homedir6(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync10(memDir))
+  if (!existsSync11(memDir))
     return "";
   const lines = [];
   try {
-    const files = readdirSync5(memDir).filter((f) => f.endsWith(".json"));
+    const files = readdirSync6(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync8(join15(memDir, file), "utf-8");
+        const raw = readFileSync9(join16(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
         const topic = basename3(file, ".json");
         const keys = Object.keys(entries);
@@ -9186,6 +10011,31 @@ function loadFailurePatterns(store) {
     return "";
   }
 }
+function loadPatternSuggestions(repoRoot, store) {
+  try {
+    const projectPatterns = store.detectPatterns({ repoRoot, minOccurrences: 3, minLen: 3 });
+    const globalPatterns = store.detectPatterns({ minOccurrences: 3, minLen: 3 });
+    const all = [...projectPatterns];
+    for (const gp of globalPatterns) {
+      const fp = gp.pattern.map((e) => e.tool).join("->");
+      const exists = all.some((p) => p.pattern.map((e) => e.tool).join("->") === fp);
+      if (!exists)
+        all.push(gp);
+    }
+    if (all.length === 0)
+      return "";
+    const lines = [
+      "Repeated workflow patterns detected (consider creating custom tools with create_tool):"
+    ];
+    for (const p of all.slice(0, 3)) {
+      const steps = p.pattern.map((e) => e.tool).join(" \u2192 ");
+      lines.push(`- [${p.occurrences}x, ${p.scope}] ${steps}`);
+    }
+    return lines.join("\n");
+  } catch {
+    return "";
+  }
+}
 function buildProjectContext(repoRoot, stores) {
   return {
     projectInstructions: loadProjectFiles(repoRoot),
@@ -9195,7 +10045,8 @@ function buildProjectContext(repoRoot, stores) {
     sessionHistory: loadSessionHistory(repoRoot),
     environment: getEnvironment(repoRoot),
     taskMemories: stores?.taskMemoryStore ? loadTaskMemories(repoRoot, stores.taskMemoryStore) : "",
-    failurePatterns: stores?.failureStore ? loadFailurePatterns(stores.failureStore) : ""
+    failurePatterns: stores?.failureStore ? loadFailurePatterns(stores.failureStore) : "",
+    patternSuggestions: stores?.toolPatternStore ? loadPatternSuggestions(repoRoot, stores.toolPatternStore) : ""
   };
 }
 function formatContextForPrompt(ctx) {
@@ -9243,6 +10094,13 @@ Use this history to avoid re-doing completed work and to learn from past approac
 ${ctx.failurePatterns}
 
 Avoid approaches that led to these failures. If you encounter these errors, try a different strategy.`);
+  }
+  if (ctx.patternSuggestions) {
+    sections.push(`## Tool Creation Suggestions
+
+${ctx.patternSuggestions}
+
+These patterns have been repeated 3+ times. Consider using create_tool to automate them.`);
   }
   return sections.join("\n\n");
 }
@@ -9587,6 +10445,189 @@ var init_validationStore = __esm({
   }
 });
 
+// packages/memory/dist/toolPatternStore.js
+import { randomUUID as randomUUID3 } from "node:crypto";
+var ToolPatternStore;
+var init_toolPatternStore = __esm({
+  "packages/memory/dist/toolPatternStore.js"() {
+    "use strict";
+    ToolPatternStore = class {
+      db;
+      constructor(db) {
+        this.db = db;
+        this.ensureTable();
+      }
+      ensureTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tool_sequences (
+        id          TEXT    PRIMARY KEY,
+        task_id     TEXT    NOT NULL,
+        session_id  TEXT    NOT NULL,
+        repo_root   TEXT    NOT NULL,
+        sequence    TEXT    NOT NULL DEFAULT '[]',
+        created_at  TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_tool_sequences_repo
+        ON tool_sequences (repo_root);
+
+      CREATE INDEX IF NOT EXISTS idx_tool_sequences_created
+        ON tool_sequences (created_at);
+
+      CREATE TABLE IF NOT EXISTS custom_tools (
+        name        TEXT    PRIMARY KEY,
+        definition  TEXT    NOT NULL,
+        scope       TEXT    NOT NULL DEFAULT 'project',
+        repo_root   TEXT,
+        created_at  TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+        updated_at  TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_custom_tools_scope
+        ON custom_tools (scope);
+    `);
+      }
+      /** Record a tool call sequence from a completed task */
+      insert(input) {
+        const id = randomUUID3();
+        this.db.prepare(`
+      INSERT INTO tool_sequences (id, task_id, session_id, repo_root, sequence)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(id, input.taskId, input.sessionId, input.repoRoot, JSON.stringify(input.sequence));
+        return id;
+      }
+      /** Get all sequences for a given repo */
+      listByRepo(repoRoot) {
+        const rows = this.db.prepare(`
+      SELECT * FROM tool_sequences WHERE repo_root = ? ORDER BY created_at DESC
+    `).all(repoRoot);
+        return rows.map(this.hydrate);
+      }
+      /** Get recent sequences globally */
+      recent(limit = 20) {
+        const rows = this.db.prepare(`
+      SELECT * FROM tool_sequences ORDER BY created_at DESC LIMIT ?
+    `).all(limit);
+        return rows.map(this.hydrate);
+      }
+      /**
+       * Detect repeated patterns across recorded sequences.
+       * Looks for subsequences of length >= minLen that appear in >= minOccurrences tasks.
+       *
+       * Algorithm:
+       *   1. Extract all contiguous subsequences of length minLen..maxLen
+       *   2. Fingerprint each subsequence (tool names + arg keys)
+       *   3. Count occurrences across tasks
+       *   4. Return patterns that meet the threshold
+       */
+      detectPatterns(opts = {}) {
+        const minOccurrences = opts.minOccurrences ?? 3;
+        const minLen = opts.minLen ?? 3;
+        const maxLen = opts.maxLen ?? 10;
+        const sequences = opts.repoRoot ? this.listByRepo(opts.repoRoot) : this.recent(50);
+        if (sequences.length < minOccurrences)
+          return [];
+        const fingerprints = /* @__PURE__ */ new Map();
+        for (const seq of sequences) {
+          const entries = seq.sequence;
+          for (let len = minLen; len <= Math.min(maxLen, entries.length); len++) {
+            for (let start = 0; start <= entries.length - len; start++) {
+              const sub = entries.slice(start, start + len);
+              const fp = this.fingerprint(sub);
+              if (!fingerprints.has(fp)) {
+                fingerprints.set(fp, { pattern: sub, taskIds: /* @__PURE__ */ new Set(), repos: /* @__PURE__ */ new Set() });
+              }
+              const entry = fingerprints.get(fp);
+              entry.taskIds.add(seq.taskId);
+              entry.repos.add(seq.repoRoot);
+            }
+          }
+        }
+        const suggestions = [];
+        for (const [, data] of fingerprints) {
+          if (data.taskIds.size >= minOccurrences) {
+            suggestions.push({
+              pattern: data.pattern,
+              occurrences: data.taskIds.size,
+              scope: data.repos.size === 1 ? "project" : "global",
+              taskIds: Array.from(data.taskIds)
+            });
+          }
+        }
+        suggestions.sort((a, b) => b.occurrences - a.occurrences || b.pattern.length - a.pattern.length);
+        return this.deduplicatePatterns(suggestions);
+      }
+      /** Create a fingerprint for a tool call subsequence */
+      fingerprint(entries) {
+        return entries.map((e) => `${e.tool}(${e.argKeys.sort().join(",")})`).join(" -> ");
+      }
+      /** Remove patterns that are strict subsets of longer detected patterns */
+      deduplicatePatterns(suggestions) {
+        const result = [];
+        const kept = /* @__PURE__ */ new Set();
+        for (let i = 0; i < suggestions.length; i++) {
+          const fpI = this.fingerprint(suggestions[i].pattern);
+          let isSubset = false;
+          for (let j = 0; j < suggestions.length; j++) {
+            if (i === j)
+              continue;
+            const fpJ = this.fingerprint(suggestions[j].pattern);
+            if (fpJ.includes(fpI) && fpJ.length > fpI.length) {
+              if (suggestions[j].occurrences >= suggestions[i].occurrences) {
+                isSubset = true;
+                break;
+              }
+            }
+          }
+          if (!isSubset) {
+            result.push(suggestions[i]);
+            kept.add(i);
+          }
+        }
+        return result.slice(0, 5);
+      }
+      // -- Custom tool tracking in DB -----------------------------------------
+      /** Record a custom tool in the database */
+      saveCustomTool(name, definition, scope, repoRoot) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO custom_tools (name, definition, scope, repo_root, updated_at)
+      VALUES (?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    `).run(name, definition, scope, repoRoot ?? null);
+      }
+      /** List all custom tools */
+      listCustomTools(scope, repoRoot) {
+        let query = "SELECT name, scope, created_at FROM custom_tools";
+        const params = [];
+        if (scope && repoRoot) {
+          query += " WHERE (scope = ? AND repo_root = ?) OR scope = 'global'";
+          params.push(scope, repoRoot);
+        } else if (scope) {
+          query += " WHERE scope = ?";
+          params.push(scope);
+        }
+        query += " ORDER BY created_at DESC";
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((r) => ({
+          name: r["name"],
+          scope: r["scope"],
+          createdAt: r["created_at"]
+        }));
+      }
+      // -- Helpers -------------------------------------------------------------
+      hydrate(row) {
+        return {
+          id: row["id"],
+          taskId: row["task_id"],
+          sessionId: row["session_id"],
+          repoRoot: row["repo_root"],
+          sequence: JSON.parse(row["sequence"] || "[]"),
+          createdAt: row["created_at"]
+        };
+      }
+    };
+  }
+});
+
 // packages/memory/dist/index.js
 var init_dist6 = __esm({
   "packages/memory/dist/index.js"() {
@@ -9598,6 +10639,7 @@ var init_dist6 = __esm({
     init_patchHistoryStore();
     init_failureStore();
     init_validationStore();
+    init_toolPatternStore();
   }
 });
 
@@ -9885,19 +10927,19 @@ var init_carousel = __esm({
 });
 
 // packages/cli/dist/tui/voice.js
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readFileSync as readFileSync9, unlinkSync } from "node:fs";
-import { join as join16 } from "node:path";
-import { homedir as homedir6, tmpdir as tmpdir2, platform as platform2 } from "node:os";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, readFileSync as readFileSync10, unlinkSync } from "node:fs";
+import { join as join17 } from "node:path";
+import { homedir as homedir7, tmpdir as tmpdir2, platform as platform2 } from "node:os";
 import { execSync as execSync10, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 function modelDir(id) {
-  return join16(MODELS_DIR, id);
+  return join17(MODELS_DIR, id);
 }
 function modelOnnxPath(id) {
-  return join16(modelDir(id), "model.onnx");
+  return join17(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join16(modelDir(id), "config.json");
+  return join17(modelDir(id), "config.json");
 }
 function describeToolCall(toolName, args) {
   const path = args["path"];
@@ -9909,6 +10951,8 @@ function describeToolCall(toolName, args) {
       return `Writing ${file}`;
     case "file_edit":
       return `Editing ${file}`;
+    case "file_patch":
+      return `Patching ${file}`;
     case "shell": {
       const cmd = String(args["command"] ?? "");
       if (/npm\s+test|vitest|jest|mocha/.test(cmd))
@@ -9971,6 +11015,10 @@ function describeToolCall(toolName, args) {
       return `Taking screenshot`;
     case "ocr":
       return `Extracting text from image`;
+    case "create_tool":
+      return `Creating custom tool`;
+    case "manage_tools":
+      return `Managing custom tools`;
     default:
       return `Using ${toolName}`;
   }
@@ -10006,8 +11054,8 @@ var init_voice = __esm({
         configUrl: "https://raw.githubusercontent.com/robit-man/combine_overwatch_onnx/main/overwatch.onnx.json"
       }
     };
-    VOICE_DIR = join16(homedir6(), ".open-agents", "voice");
-    MODELS_DIR = join16(VOICE_DIR, "models");
+    VOICE_DIR = join17(homedir7(), ".open-agents", "voice");
+    MODELS_DIR = join17(VOICE_DIR, "models");
     VoiceEngine = class {
       enabled = false;
       modelId = "glados";
@@ -10166,7 +11214,7 @@ var init_voice = __esm({
         const audioData = result["output"].data;
         if (audioData.length === 0)
           return;
-        const wavPath = join16(tmpdir2(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join17(tmpdir2(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, this.config.audio.sample_rate, wavPath);
         await this.playWav(wavPath);
         try {
@@ -10246,7 +11294,7 @@ var init_voice = __esm({
         buffer.write("data", 36);
         buffer.writeUInt32LE(dataSize, 40);
         Buffer.from(int16.buffer, int16.byteOffset, int16.byteLength).copy(buffer, 44);
-        writeFileSync5(path, buffer);
+        writeFileSync6(path, buffer);
       }
       // -------------------------------------------------------------------------
       // Audio playback (system default speakers)
@@ -10255,7 +11303,7 @@ var init_voice = __esm({
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
-        return new Promise((resolve14) => {
+        return new Promise((resolve15) => {
           const child = nodeSpawn(cmd[0], cmd.slice(1), {
             stdio: "ignore",
             detached: false
@@ -10264,12 +11312,12 @@ var init_voice = __esm({
           child.on("close", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve14();
+            resolve15();
           });
           child.on("error", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve14();
+            resolve15();
           });
           setTimeout(() => {
             if (this.currentPlayback === child) {
@@ -10279,7 +11327,7 @@ var init_voice = __esm({
               }
               this.currentPlayback = null;
             }
-            resolve14();
+            resolve15();
           }, 15e3);
         });
       }
@@ -10318,30 +11366,30 @@ var init_voice = __esm({
       async ensureRuntime() {
         if (this.ort)
           return;
-        mkdirSync5(VOICE_DIR, { recursive: true });
-        const pkgPath = join16(VOICE_DIR, "package.json");
+        mkdirSync6(VOICE_DIR, { recursive: true });
+        const pkgPath = join17(VOICE_DIR, "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
         };
-        if (existsSync11(pkgPath)) {
+        if (existsSync12(pkgPath)) {
           try {
-            const existing = JSON.parse(readFileSync9(pkgPath, "utf8"));
+            const existing = JSON.parse(readFileSync10(pkgPath, "utf8"));
             if (!existing.dependencies?.["phonemizer"]) {
               existing.dependencies = { ...existing.dependencies, ...expectedDeps };
-              writeFileSync5(pkgPath, JSON.stringify(existing, null, 2));
+              writeFileSync6(pkgPath, JSON.stringify(existing, null, 2));
             }
           } catch {
           }
         }
-        if (!existsSync11(pkgPath)) {
-          writeFileSync5(pkgPath, JSON.stringify({
+        if (!existsSync12(pkgPath)) {
+          writeFileSync6(pkgPath, JSON.stringify({
             name: "open-agents-voice",
             private: true,
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join16(VOICE_DIR, "index.js"));
+        const voiceRequire = createRequire(join17(VOICE_DIR, "index.js"));
         try {
           this.ort = voiceRequire("onnxruntime-node");
         } catch {
@@ -10387,18 +11435,18 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         const dir = modelDir(id);
         const onnxPath = modelOnnxPath(id);
         const configPath = modelConfigPath(id);
-        if (existsSync11(onnxPath) && existsSync11(configPath))
+        if (existsSync12(onnxPath) && existsSync12(configPath))
           return;
-        mkdirSync5(dir, { recursive: true });
-        if (!existsSync11(configPath)) {
+        mkdirSync6(dir, { recursive: true });
+        if (!existsSync12(configPath)) {
           renderInfo(`Downloading ${model.label} voice config...`);
           const configResp = await fetch(model.configUrl);
           if (!configResp.ok)
             throw new Error(`Failed to download config: HTTP ${configResp.status}`);
           const configText = await configResp.text();
-          writeFileSync5(configPath, configText);
+          writeFileSync6(configPath, configText);
         }
-        if (!existsSync11(onnxPath)) {
+        if (!existsSync12(onnxPath)) {
           renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
           const onnxResp = await fetch(model.onnxUrl);
           if (!onnxResp.ok)
@@ -10422,7 +11470,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           }
           process.stdout.write("\r" + " ".repeat(60) + "\r");
           const fullBuffer = Buffer.concat(chunks);
-          writeFileSync5(onnxPath, fullBuffer);
+          writeFileSync6(onnxPath, fullBuffer);
           renderInfo(`${model.label} model downloaded (${formatBytes2(fullBuffer.length)}).`);
         }
       }
@@ -10434,10 +11482,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           throw new Error("ONNX runtime not loaded");
         const onnxPath = modelOnnxPath(this.modelId);
         const configPath = modelConfigPath(this.modelId);
-        if (!existsSync11(onnxPath) || !existsSync11(configPath)) {
+        if (!existsSync12(onnxPath) || !existsSync12(configPath)) {
           throw new Error(`Model files not found for ${this.modelId}`);
         }
-        this.config = JSON.parse(readFileSync9(configPath, "utf8"));
+        this.config = JSON.parse(readFileSync10(configPath, "utf8"));
         renderInfo("Loading voice model...");
         this.session = await this.ort.InferenceSession.create(onnxPath, {
           executionProviders: ["cpu"],
@@ -10712,23 +11760,23 @@ var init_stream_renderer = __esm({
 // packages/cli/dist/tui/interactive.js
 import * as readline2 from "node:readline";
 import { cwd } from "node:process";
-import { resolve as resolve11, join as join17, dirname as dirname3 } from "node:path";
+import { resolve as resolve12, join as join18, dirname as dirname2 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath } from "node:url";
-import { readFileSync as readFileSync10 } from "node:fs";
-import { existsSync as existsSync12 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { extname as extname5 } from "node:path";
 function getVersion() {
   try {
     const require2 = createRequire2(import.meta.url);
-    const thisDir = dirname3(fileURLToPath(import.meta.url));
+    const thisDir = dirname2(fileURLToPath(import.meta.url));
     const candidates = [
-      join17(thisDir, "..", "package.json"),
-      join17(thisDir, "..", "..", "package.json"),
-      join17(thisDir, "..", "..", "..", "package.json")
+      join18(thisDir, "..", "package.json"),
+      join18(thisDir, "..", "..", "package.json"),
+      join18(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync12(pkgPath)) {
+      if (existsSync13(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -10785,6 +11833,7 @@ function buildTools(repoRoot, config) {
     new AiwgWorkflowTool(repoRoot),
     // Advanced tools (mirroring Claude Code capabilities)
     new BatchEditTool(repoRoot),
+    new FilePatchTool(repoRoot),
     new CodebaseMapTool(repoRoot),
     new DiagnosticTool(repoRoot),
     new GitInfoTool(repoRoot),
@@ -10796,7 +11845,12 @@ function buildTools(repoRoot, config) {
     // Image tools (multimodal context)
     new ImageReadTool(repoRoot),
     new ScreenshotTool(repoRoot),
-    new OCRTool(repoRoot)
+    new OCRTool(repoRoot),
+    // Custom tool system (agent-created tools)
+    new CreateToolTool(repoRoot),
+    new ManageToolsTool(repoRoot),
+    // Load agent-created custom tools from .oa/tools/ and ~/.open-agents/tools/
+    ...buildCustomTools(repoRoot)
   ];
   return [
     ...executionTools.map(adaptTool),
@@ -10893,9 +11947,14 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   });
   runner.registerTools(buildTools(repoRoot, config));
   const filesTouched = /* @__PURE__ */ new Set();
+  const toolSequence = [];
   runner.onEvent((event) => {
     switch (event.type) {
       case "tool_call":
+        toolSequence.push({
+          tool: event.toolName ?? "unknown",
+          argKeys: Object.keys(event.toolArgs ?? {})
+        });
         if (event.toolArgs?.path && typeof event.toolArgs.path === "string") {
           const name = event.toolName ?? "";
           if (name === "file_write" || name === "file_edit" || name === "batch_edit") {
@@ -10993,11 +12052,22 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
       } catch {
       }
     }
+    if (taskStores?.toolPatternStore && toolSequence.length > 0) {
+      try {
+        taskStores.toolPatternStore.insert({
+          taskId: sessionId,
+          sessionId,
+          repoRoot,
+          sequence: toolSequence
+        });
+      } catch {
+      }
+    }
   });
   return { runner, promise };
 }
 async function startInteractive(config, repoPath) {
-  const repoRoot = resolve11(repoPath ?? cwd());
+  const repoRoot = resolve12(repoPath ?? cwd());
   const isResumed = !!process.env.__OA_RESUMED;
   if (isResumed) {
     delete process.env.__OA_RESUMED;
@@ -11007,12 +12077,14 @@ async function startInteractive(config, repoPath) {
   let memoryDb = null;
   let taskMemoryStore = null;
   let failureStore = null;
+  let toolPatternStore = null;
   let contextStores;
   try {
     memoryDb = initDb(config.dbPath);
     taskMemoryStore = new TaskMemoryStore(memoryDb);
     failureStore = new FailureStore(memoryDb);
-    contextStores = { taskMemoryStore, failureStore };
+    toolPatternStore = new ToolPatternStore(memoryDb);
+    contextStores = { taskMemoryStore, failureStore, toolPatternStore };
   } catch {
   }
   if (savedSettings.model)
@@ -11124,6 +12196,7 @@ async function startInteractive(config, repoPath) {
     get config() {
       return currentConfig;
     },
+    repoRoot,
     setModel(model) {
       currentConfig = { ...currentConfig, model };
     },
@@ -11208,12 +12281,12 @@ ${c2.dim("Goodbye!")}
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync12(resolve11(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync13(resolve12(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
-          const imgPath = resolve11(repoRoot, cleanPath);
-          const imgBuffer = readFileSync10(imgPath);
+          const imgPath = resolve12(repoRoot, cleanPath);
+          const imgBuffer = readFileSync11(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname5(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
@@ -11250,7 +12323,8 @@ ${c2.dim("Goodbye!")}
       }, {
         contextStores,
         taskMemoryStore: taskMemoryStore ?? void 0,
-        failureStore: failureStore ?? void 0
+        failureStore: failureStore ?? void 0,
+        toolPatternStore: toolPatternStore ?? void 0
       }, bruteForceEnabled);
       activeTask = task;
       showPrompt();
@@ -11322,7 +12396,7 @@ ${c2.dim("(Use /quit to exit)")}
   });
 }
 async function runWithTUI(task, config, repoPath) {
-  const repoRoot = resolve11(repoPath ?? cwd());
+  const repoRoot = resolve12(repoPath ?? cwd());
   const needsSetup = isFirstRun() || !await isModelAvailable(config);
   if (needsSetup && config.backendType === "ollama") {
     const setupModel = await runSetupWizard(config);
@@ -11402,9 +12476,9 @@ var init_run = __esm({
 // packages/indexer/dist/codebase-indexer.js
 import { glob } from "glob";
 import ignore from "ignore";
-import { readFile as readFile8, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile9, stat as stat2 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join18, relative as relative3, extname as extname6, basename as basename4 } from "node:path";
+import { join as join19, relative as relative3, extname as extname6, basename as basename4 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -11448,7 +12522,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile8(join18(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile9(join19(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -11463,12 +12537,12 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join18(this.config.rootDir, relativePath);
+          const fullPath = join19(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat2(fullPath);
             if (fileStat.size > this.config.maxFileSize)
               continue;
-            const content = await readFile8(fullPath);
+            const content = await readFile9(fullPath);
             const hash = createHash("sha256").update(content).digest("hex");
             const ext = extname6(relativePath);
             indexed.push({
@@ -11509,7 +12583,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join18(current.path, part),
+                  path: join19(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -11583,14 +12657,14 @@ var index_repo_exports = {};
 __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
-import { resolve as resolve12 } from "node:path";
-import { existsSync as existsSync13, statSync as statSync6 } from "node:fs";
+import { resolve as resolve13 } from "node:path";
+import { existsSync as existsSync14, statSync as statSync6 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
-  const repoRoot = resolve12(opts.repoPath ?? cwd2());
+  const repoRoot = resolve13(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync13(repoRoot)) {
+  if (!existsSync14(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -11836,8 +12910,8 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join19, resolve as resolve13 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { join as join20, resolve as resolve14 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function coerceForSettings(key, value) {
   if (INT_KEYS.has(key))
@@ -11857,7 +12931,7 @@ async function configCommand(opts, config) {
   return handleShow(opts, config);
 }
 function handleShow(opts, config) {
-  const repoRoot = resolve13(opts.repoPath ?? cwd3());
+  const repoRoot = resolve14(opts.repoPath ?? cwd3());
   printHeader("Configuration");
   printSection("Active Settings (merged)");
   printKeyValue("backendUrl", config.backendUrl, 2);
@@ -11889,7 +12963,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join19(homedir7(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join20(homedir8(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -11922,13 +12996,13 @@ function handleSet(opts, _config) {
     process.exit(1);
   }
   if (opts.local) {
-    const repoRoot = resolve13(opts.repoPath ?? cwd3());
+    const repoRoot = resolve14(opts.repoPath ?? cwd3());
     try {
       initOaDirectory(repoRoot);
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${value}`);
-      printInfo(`Saved to ${join19(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join20(repoRoot, ".oa", "settings.json")}`);
       printInfo("This override applies only when running in this workspace.");
     } catch (err) {
       printError(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
@@ -11988,7 +13062,7 @@ var serve_exports = {};
 __export(serve_exports, {
   serveCommand: () => serveCommand
 });
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 async function serveCommand(opts, config) {
   const backendType = config.backendType;
   if (backendType === "ollama") {
@@ -12080,8 +13154,8 @@ async function serveVllm(opts, config) {
   await runVllmServer(args, opts.verbose ?? false);
 }
 async function runVllmServer(args, verbose) {
-  return new Promise((resolve14, reject) => {
-    const child = spawn3("python", args, {
+  return new Promise((resolve15, reject) => {
+    const child = spawn4("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
     });
@@ -12115,10 +13189,10 @@ async function runVllmServer(args, verbose) {
     child.once("exit", (code, signal) => {
       if (signal) {
         printInfo(`vLLM server stopped by signal ${signal}`);
-        resolve14();
+        resolve15();
       } else if (code === 0) {
         printSuccess("vLLM server exited cleanly");
-        resolve14();
+        resolve15();
       } else {
         printError(`vLLM server exited with code ${code}`);
         reject(new Error(`vLLM exited with code ${code}`));
@@ -12146,8 +13220,8 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir3 } from "node:os";
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join20 } from "node:path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join21 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -12268,9 +13342,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join20(tmpdir3(), `open-agents-eval-${Date.now()}`);
-  mkdirSync6(dir, { recursive: true });
-  writeFileSync6(join20(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  const dir = join21(tmpdir3(), `open-agents-eval-${Date.now()}`);
+  mkdirSync7(dir, { recursive: true });
+  writeFileSync7(join21(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -12330,7 +13404,7 @@ init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname4, join as join21 } from "node:path";
+import { dirname as dirname3, join as join22 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -12437,7 +13511,7 @@ init_output();
 function getVersion2() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join21(dirname4(fileURLToPath2(import.meta.url)), "..", "package.json");
+    const pkgPath = join22(dirname3(fileURLToPath2(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {