autohand-cli 0.8.3 → 0.9.1

package/dist/{chunk-3O3MOK5C.cjs → chunk-TE4SYTWR.cjs}

@@ -1,20 +1,38 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
 
-var _chunkBVKXEQVGcjs = require('./chunk-BVKXEQVG.cjs');
+var _chunkDA7NBAJKcjs = require('./chunk-DA7NBAJK.cjs');
 
 
-var _chunkCNBKZEX5cjs = require('./chunk-CNBKZEX5.cjs');
+var _chunkLFDPTJYFcjs = require('./chunk-LFDPTJYF.cjs');
 
 
-var _chunkULQ6MDSJcjs = require('./chunk-ULQ6MDSJ.cjs');
+var _chunkJV5HVCHUcjs = require('./chunk-JV5HVCHU.cjs');
+
+
+var _chunkWJYFLQ7Gcjs = require('./chunk-WJYFLQ7G.cjs');
 
 // src/core/agents/SubAgent.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 
+// src/permissions/types.ts
+function normalizePermissionPromptResponse(response) {
+  if (typeof response === "boolean") {
+    return { decision: response ? "allow_once" : "deny_once" };
+  }
+  if (!response) {
+    return { decision: "deny_once" };
+  }
+  return response;
+}
+function isAllowedPermissionPrompt(result) {
+  return result.decision === "allow_once" || result.decision === "allow_session" || result.decision === "allow_always_project" || result.decision === "allow_always_user" || result.decision === "alternative";
+}
+
 // src/core/toolFilter.ts
 var TOOL_CATEGORIES = {
   // Meta tools
   tools_registry: "meta",
+  tool_search: "meta",
   plan: "meta",
   todo_write: "meta",
   smart_context_cropper: "meta",
@@ -26,13 +44,32 @@ var TOOL_CATEGORIES = {
   create_team: "meta",
   add_teammate: "meta",
   create_task: "meta",
+  task_get: "meta",
+  task_list: "meta",
+  task_update: "meta",
+  task_stop: "meta",
+  task_output: "meta",
+  skill: "meta",
+  install_agent_skill: "create",
+  sleep: "meta",
+  enter_worktree: "meta",
+  exit_worktree: "meta",
   team_status: "meta",
   send_team_message: "meta",
   ask_followup_question: "meta",
+  find_agent_skills: "meta",
+  request_directory_access: "meta",
+  exit_plan_mode: "meta",
+  cron_create: "meta",
+  cron_delete: "meta",
   list_schedules: "meta",
   cancel_schedule: "meta",
   // Read operations
   read_file: "read",
+  fff_find: "read",
+  fff_grep: "read",
+  find: "read",
+  glob: "read",
   search: "read",
   search_with_context: "read",
   semantic_search: "read",
@@ -43,6 +80,7 @@ var TOOL_CATEGORIES = {
   write_file: "write",
   append_file: "write",
   apply_patch: "write",
+  notebook_edit: "write",
   search_replace: "write",
   format_file: "write",
   multi_file_edit: "write",
@@ -54,6 +92,11 @@ var TOOL_CATEGORIES = {
   // Delete operations
   delete_path: "delete",
   remove_dependency: "delete",
+  package_info: "read",
+  // Web read operations
+  web_search: "read",
+  fetch_url: "read",
+  web_repo: "read",
   // Git read operations
   git_diff: "git_read",
   git_status: "git_read",
@@ -97,7 +140,24 @@ var TOOL_CATEGORIES = {
   git_push: "git_write",
   // Shell operations
   run_command: "shell",
-  custom_command: "shell"
+  shell: "shell",
+  custom_command: "shell",
+  // Browser operations (Chrome extension bridge only)
+  browser_screenshot: "browser",
+  browser_click: "browser",
+  browser_type: "browser",
+  browser_navigate: "browser",
+  browser_scroll: "browser",
+  browser_find_element: "browser",
+  browser_press_key: "browser",
+  browser_get_page_context: "browser",
+  browser_get_element: "browser",
+  browser_wait_for_element: "browser",
+  browser_read_console: "browser",
+  browser_read_network: "browser",
+  browser_get_tabs: "browser",
+  browser_get_tab_groups: "browser",
+  browser_execute_js: "browser"
 };
 var CONTEXT_POLICIES = {
   // CLI: Full access to everything
@@ -111,6 +171,8 @@ var CONTEXT_POLICIES = {
     blockedTools: [
       "list_tree",
       // Don't expose directory structure
+      "find",
+      // Don't allow broad searches
       "search",
       // Don't allow broad searches
       "search_with_context",
@@ -155,14 +217,70 @@ var CONTEXT_POLICIES = {
       "git_rebase"
     ]
   },
+  // Chrome: Browser-first, limited file access
+  // Only browser_* tools + basic read/write for Downloads
+  chrome: {
+    allowedCategories: ["read", "write", "browser", "meta"],
+    allowedTools: [
+      // Browser tools — ALWAYS available, highest priority
+      "browser_screenshot",
+      "browser_click",
+      "browser_type",
+      "browser_navigate",
+      "browser_scroll",
+      "browser_find_element",
+      "browser_press_key",
+      "browser_get_page_context",
+      "browser_get_element",
+      "browser_wait_for_element",
+      "browser_read_console",
+      "browser_read_network",
+      "browser_get_tabs",
+      "browser_get_tab_groups",
+      "browser_execute_js",
+      // Basic file ops — restricted scope
+      "read_file",
+      "write_file",
+      "fff_grep",
+      "fff_find",
+      "search",
+      "list_tree",
+      // Web
+      "web_search",
+      "fetch_url",
+      // Communication
+      "plan",
+      "ask_followup_question",
+      "todo_write",
+      "save_memory",
+      "recall_memory",
+      "tools_registry"
+    ],
+    blockedTools: [
+      "run_command",
+      "custom_command",
+      "git_push",
+      "git_reset",
+      "git_rebase",
+      "git_merge",
+      "git_cherry_pick",
+      "auto_commit",
+      "delete_path",
+      "create_directory",
+      "rename_path",
+      "copy_path",
+      "git_worktree_add",
+      "git_worktree_remove",
+      "delegate_task",
+      "delegate_parallel"
+    ]
+  },
   // Restricted: Read-only mode
   restricted: {
     allowedCategories: ["read", "git_read", "meta"],
     blockedTools: [
       "list_tree",
-      // Even in read mode, don't expose full structure
       "ask_followup_question"
-      // Requires interactive terminal (may be running in restricted non-interactive mode)
     ]
   }
 };
@@ -170,6 +288,8 @@ function getToolCategory(toolName) {
   return _nullishCoalesce(TOOL_CATEGORIES[toolName], () => ( "meta"));
 }
 var ToolFilter = class {
+  
+  
   constructor(context = "cli", customPolicy) {
     this.context = context;
     const basePolicy = CONTEXT_POLICIES[context];
@@ -245,24 +365,35 @@ function createToolFilter(context = "cli", customPolicy) {
 var RELEVANCE_CATEGORIES = {
   // Always include
   read_file: "always",
-  write_file: "always",
-  search: "always",
-  list_tree: "always",
+  fff_find: "always",
+  fff_grep: "always",
+  tool_search: "always",
+  ask_followup_question: "always",
+  find_agent_skills: "always",
+  tools_registry: "always",
+  request_directory_access: "always",
   plan: "always",
-  run_command: "always",
+  exit_plan_mode: "always",
   todo_write: "always",
   // Filesystem
+  find: "filesystem",
+  glob: "filesystem",
+  search: "filesystem",
+  list_tree: "filesystem",
+  file_stats: "filesystem",
+  checksum: "filesystem",
+  // Editing
+  write_file: "editing",
   append_file: "filesystem",
-  apply_patch: "filesystem",
+  apply_patch: "editing",
   create_directory: "filesystem",
   delete_path: "filesystem",
   rename_path: "filesystem",
   copy_path: "filesystem",
-  search_replace: "filesystem",
-  format_file: "filesystem",
-  file_stats: "filesystem",
-  checksum: "filesystem",
-  multi_file_edit: "filesystem",
+  search_replace: "editing",
+  format_file: "editing",
+  multi_file_edit: "editing",
+  notebook_edit: "editing",
   search_with_context: "search",
   semantic_search: "search",
   // Basic git
@@ -279,7 +410,7 @@ var RELEVANCE_CATEGORIES = {
   git_apply_patch: "git_basic",
   git_fetch: "git_basic",
   git_pull: "git_basic",
-  git_push: "git_basic",
+  git_push: "git_advanced",
   git_stash: "git_basic",
   git_stash_list: "git_basic",
   git_stash_pop: "git_basic",
@@ -308,24 +439,52 @@ var RELEVANCE_CATEGORIES = {
   // Dependencies
   add_dependency: "dependencies",
   remove_dependency: "dependencies",
+  package_info: "dependencies",
+  // Verification and shell
+  run_command: "verification",
+  shell: "verification",
+  // Web
+  web_search: "web",
+  fetch_url: "web",
+  web_repo: "web",
+  // Browser
+  browser_screenshot: "browser",
+  browser_click: "browser",
+  browser_type: "browser",
+  browser_navigate: "browser",
+  browser_scroll: "browser",
+  browser_find_element: "browser",
+  browser_press_key: "browser",
+  browser_get_page_context: "browser",
+  browser_get_element: "browser",
+  browser_wait_for_element: "browser",
+  browser_read_console: "browser",
+  browser_read_network: "browser",
+  browser_get_tabs: "browser",
+  browser_get_tab_groups: "browser",
+  browser_execute_js: "browser",
   // Meta
-  tools_registry: "meta",
   save_memory: "meta",
   recall_memory: "meta",
   smart_context_cropper: "meta",
   create_meta_tool: "meta",
-  custom_command: "meta",
+  custom_command: "verification",
   delegate_task: "meta",
   delegate_parallel: "meta",
   create_team: "meta",
   add_teammate: "meta",
   create_task: "meta",
+  task_get: "meta",
+  task_list: "meta",
+  task_update: "meta",
+  task_stop: "meta",
+  task_output: "meta",
+  enter_worktree: "meta",
+  exit_worktree: "meta",
   team_status: "meta",
   send_team_message: "meta",
-  ask_followup_question: "always",
-  // User interaction should always be available when in interactive mode
-  find_agent_skills: "always",
-  // Skill search should always be available so the LLM can explore community skills
+  cron_create: "meta",
+  cron_delete: "meta",
   list_schedules: "meta",
   cancel_schedule: "meta",
   // Project tracking
@@ -333,11 +492,35 @@ var RELEVANCE_CATEGORIES = {
 };
 var CATEGORY_TRIGGERS = {
   always: [],
-  filesystem: ["file", "directory", "folder", "create", "delete", "rename", "copy", "move", "format", "edit"],
-  git_basic: ["git", "commit", "branch", "diff", "status", "stash", "pull", "push"],
-  git_advanced: ["merge", "rebase", "cherry-pick", "worktree", "reset"],
-  search: ["search", "find", "grep", "look for", "locate", "where is"],
-  dependencies: ["dependency", "dependencies", "package", "npm", "install", "yarn", "bun add"],
+  filesystem: ["file", "directory", "folder", "create", "delete", "rename", "copy", "move", "format", "path", "open"],
+  editing: ["fix", "edit", "change", "modify", "patch", "write", "implement", "refactor", "update", "replace", "create", "delete", "remove", "format", "add", "build", "document", "docs", "config", "configure"],
+  git_basic: [
+    "git",
+    "commit",
+    "branch",
+    "diff",
+    "status",
+    "stash",
+    "pull",
+    "push",
+    "recent changes",
+    "recent change",
+    "what changed",
+    "changes introduced",
+    "changes were introduced",
+    "changed recently",
+    "repo recently",
+    "repository recently",
+    "uncommitted",
+    "working tree",
+    "staged"
+  ],
+  git_advanced: ["merge", "rebase", "cherry-pick", "worktree", "reset", "push", "force-push"],
+  search: ["search", "find", "grep", "look for", "locate", "where is", "symbol", "definition"],
+  verification: ["test", "tests", "build", "lint", "typecheck", "verify", "run", "command", "script", "proof", "install"],
+  web: ["web", "url", "http", "https", "fetch", "search internet", "latest", "docs", "documentation", "changelog"],
+  browser: ["browser", "chrome", "page", "tab", "click", "screenshot", "console", "network"],
+  dependencies: ["dependency", "dependencies", "package", "npm", "install", "yarn", "bun add", "cargo add", "pip install"],
   meta: [
     "tool",
     "delegate",
@@ -354,12 +537,78 @@ var CATEGORY_TRIGGERS = {
   ],
   project_tracking: ["issue", "issues", "pr", "pull request", "assigned", "tracker", "bug", "feature request", "milestone", "review"]
 };
+var TOOL_SELECTION_CACHE_LIMIT = 100;
+var toolSelectionCache = /* @__PURE__ */ new Map();
+var CATALOG_LABELS = {
+  always: "core",
+  filesystem: "filesystem",
+  editing: "editing",
+  git_basic: "git",
+  git_advanced: "advanced git",
+  search: "search",
+  verification: "verification",
+  web: "web",
+  browser: "browser",
+  dependencies: "dependencies",
+  meta: "coordination",
+  project_tracking: "project tracking"
+};
+function extractRecentToolArguments(message) {
+  if (!_optionalChain([message, 'access', _14 => _14.tool_calls, 'optionalAccess', _15 => _15.length])) {
+    return "";
+  }
+  return message.tool_calls.map((call) => call.function.arguments).join(" ");
+}
+function getRecentSelectionText(messages) {
+  return messages.slice(-8).map((message) => `${_nullishCoalesce(message.content, () => ( ""))} ${extractRecentToolArguments(message)}`).join(" ").toLowerCase();
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchesCategoryTrigger(recentText, trigger) {
+  if (!recentText || !trigger) {
+    return false;
+  }
+  if (trigger.includes(" ")) {
+    return recentText.includes(trigger);
+  }
+  return new RegExp(`\\b${escapeRegExp(trigger)}\\b`).test(recentText);
+}
+function stableToolCacheKey(tools, messages) {
+  const toolNames = tools.map((tool) => tool.name).sort().join(",");
+  return `${toolNames}
+${getRecentSelectionText(messages)}`;
+}
+function rememberToolSelection(key, names) {
+  if (toolSelectionCache.size >= TOOL_SELECTION_CACHE_LIMIT) {
+    const oldestKey = toolSelectionCache.keys().next().value;
+    if (oldestKey) {
+      toolSelectionCache.delete(oldestKey);
+    }
+  }
+  toolSelectionCache.set(key, names);
+}
+function restoreCachedSelection(tools, names) {
+  const byName = new Map(tools.map((tool) => [tool.name, tool]));
+  return names.map((name) => byName.get(name)).filter((tool) => Boolean(tool));
+}
+function matchesToolByText(tool, recentText) {
+  if (!recentText) {
+    return false;
+  }
+  const normalizedName = tool.name.toLowerCase();
+  const spacedName = normalizedName.replace(/_/g, " ");
+  if (recentText.includes(normalizedName) || recentText.includes(spacedName)) {
+    return true;
+  }
+  return tool.description.toLowerCase().split(/[^a-z0-9_/-]+/).filter((token) => token.length >= 5).some((token) => recentText.includes(token));
+}
 function detectRelevantCategories(messages) {
   const categories = /* @__PURE__ */ new Set(["always"]);
   const recentMessages = messages.slice(-8);
-  const recentText = recentMessages.map((m) => _nullishCoalesce(m.content, () => ( ""))).join(" ").toLowerCase();
+  const recentText = getRecentSelectionText(messages);
   for (const [category, triggers] of Object.entries(CATEGORY_TRIGGERS)) {
-    if (triggers.some((trigger) => recentText.includes(trigger))) {
+    if (triggers.some((trigger) => matchesCategoryTrigger(recentText, trigger))) {
       categories.add(category);
     }
   }
@@ -381,31 +630,169 @@ function detectRelevantCategories(messages) {
   }
   return categories;
 }
-function filterToolsByRelevance(tools, messages) {
+function filterToolsByRelevance(tools, messages, options = {}) {
+  const cacheEnabled = options.cache !== false;
+  const cacheKey = cacheEnabled ? stableToolCacheKey(tools, messages) : "";
+  const cachedNames = cacheEnabled ? toolSelectionCache.get(cacheKey) : void 0;
+  if (cachedNames) {
+    return restoreCachedSelection(tools, cachedNames);
+  }
   const relevantCategories = detectRelevantCategories(messages);
-  return tools.filter((tool) => {
+  const recentText = getRecentSelectionText(messages);
+  const selected = tools.filter((tool) => {
     const category = RELEVANCE_CATEGORIES[tool.name];
-    return !category || relevantCategories.has(category);
+    if (category && relevantCategories.has(category)) {
+      return true;
+    }
+    return matchesToolByText(tool, recentText);
   });
+  if (cacheEnabled) {
+    rememberToolSelection(cacheKey, selected.map((tool) => tool.name));
+  }
+  return selected;
+}
+function formatToolCapabilityCatalog(tools) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const relevance = _nullishCoalesce(RELEVANCE_CATEGORIES[tool.name], () => ( "meta"));
+    const label = CATALOG_LABELS[relevance];
+    const existing = _nullishCoalesce(grouped.get(label), () => ( []));
+    existing.push(tool.name);
+    grouped.set(label, existing);
+  }
+  return [...grouped.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([label, names]) => `- ${label}: ${[...new Set(names)].sort().join(", ")}`).join("\n");
 }
 
 // src/core/toolManager.ts
+var SEQUENTIAL_TOOL_CATEGORIES = /* @__PURE__ */ new Set([
+  "write",
+  "create",
+  "delete",
+  "git_write",
+  "shell"
+]);
+var GOAL_TOOL_DEFINITIONS = [
+  {
+    name: "get_goal",
+    description: "Inspect the current persistent goal, queue, status, time and token budgets, and progress metadata. Use only for explicit goal-management requests."
+  },
+  {
+    name: "create_goal",
+    description: "Create a persistent goal only when the user explicitly asks for durable goal tracking or long-running goal pursuit. Do not infer goals from ordinary tasks.",
+    parameters: {
+      type: "object",
+      properties: {
+        objective: { type: "string", description: "Explicit user-requested goal objective" },
+        token_budget: { type: "number", description: "Optional positive token budget" },
+        time_budget_seconds: { type: "number", description: "Optional positive time budget in seconds" },
+        min_tokens_before_wrap_up: { type: "number", description: "Optional minimum tokens before normal completion is allowed" },
+        min_time_seconds_before_wrap_up: { type: "number", description: "Optional minimum time in seconds before normal completion is allowed" }
+      },
+      required: ["objective"]
+    }
+  },
+  {
+    name: "create_goal_from_template",
+    description: "Resolve a reusable .pi-goals template and create the resulting persistent goal when the user explicitly requests a template/workflow goal.",
+    parameters: {
+      type: "object",
+      properties: {
+        template: { type: "string", description: "Template name or alias" },
+        flags: { type: "object", description: "Template flag values" },
+        args: { type: "string", description: "Trailing template arguments" },
+        token_budget: { type: "number", description: "Optional positive token budget" },
+        time_budget_seconds: { type: "number", description: "Optional positive time budget in seconds" },
+        min_tokens_before_wrap_up: { type: "number", description: "Optional minimum tokens before normal completion is allowed" },
+        min_time_seconds_before_wrap_up: { type: "number", description: "Optional minimum time in seconds before normal completion is allowed" }
+      },
+      required: ["template"]
+    }
+  },
+  {
+    name: "update_goal",
+    description: "Update the current goal when the user explicitly asks to edit, pause, resume, complete, or adjust budgets.",
+    parameters: {
+      type: "object",
+      properties: {
+        objective: { type: "string", description: "Optional replacement objective" },
+        status: { type: "string", description: "Optional status", enum: ["active", "paused", "complete", "budgetLimited"] },
+        token_budget: { type: "number", description: "Optional positive token budget; use clear_goal for removal requests" },
+        time_budget_seconds: { type: "number", description: "Optional positive time budget in seconds" },
+        min_tokens_before_wrap_up: { type: "number", description: "Optional token floor" },
+        min_time_seconds_before_wrap_up: { type: "number", description: "Optional time floor in seconds" }
+      }
+    }
+  },
+  {
+    name: "clear_goal",
+    description: "Clear the current persistent goal only when the user explicitly asks to clear, remove, delete, or dismiss it."
+  },
+  {
+    name: "list_goal_templates",
+    description: "List reusable .pi-goals templates from bounded project template directories."
+  },
+  {
+    name: "enqueue_goal",
+    description: "Add a persistent goal to the FIFO queue only when the user explicitly asks to queue later goal work.",
+    parameters: {
+      type: "object",
+      properties: {
+        objective: { type: "string", description: "Goal objective to queue" },
+        token_budget: { type: "number", description: "Optional positive token budget" },
+        time_budget_seconds: { type: "number", description: "Optional positive time budget in seconds" },
+        min_tokens_before_wrap_up: { type: "number", description: "Optional token floor" },
+        min_time_seconds_before_wrap_up: { type: "number", description: "Optional time floor in seconds" }
+      },
+      required: ["objective"]
+    }
+  },
+  {
+    name: "list_goal_queue",
+    description: "List queued goal objectives waiting to run after the active goal completes or clears."
+  },
+  {
+    name: "start_queued_goal",
+    description: "Start the next queued direct goal after verifying no non-terminal goal is active. The queue item is removed only after goal creation succeeds."
+  },
+  {
+    name: "dequeue_goal",
+    description: "Remove the first queued goal after it is truly satisfied or the user explicitly authorized removing it. Requires audit rationale and authority.",
+    parameters: {
+      type: "object",
+      properties: {
+        rationale: { type: "string", description: "Why this queue head is being dequeued now" },
+        authority: { type: "string", description: "User authorization or completion evidence for dequeuing" }
+      },
+      required: ["rationale", "authority"]
+    }
+  },
+  {
+    name: "remove_queued_goal",
+    description: "Remove a specific queued goal by queue ID only when the user explicitly asks.",
+    parameters: {
+      type: "object",
+      properties: {
+        queueId: { type: "string", description: "Queue ID to remove" }
+      },
+      required: ["queueId"]
+    }
+  }
+];
 var DEFAULT_TOOL_DEFINITIONS = [
   {
     name: "tools_registry",
     description: "List all available tools (built-in and meta)"
   },
   {
-    name: "plan",
-    description: 'Create a structured implementation plan with detailed numbered steps before executing a task. Always break the task into concrete, actionable steps (e.g. "1. Read existing auth code\\n2. Create JWT utility module\\n3. Add login endpoint"). Each step should be a single clear action. Aim for 3-10 steps depending on complexity.',
+    name: "tool_search",
+    description: "Search available tools by capability, name, or description. Use this when you need to discover the best built-in or meta tool for a task instead of guessing.",
     parameters: {
       type: "object",
       properties: {
-        notes: {
-          type: "string",
-          description: 'A numbered step-by-step plan. Each step on its own line starting with "N. " (e.g. "1. Read existing code\\n2. Create new module\\n3. Write tests"). Be specific and actionable - avoid single vague descriptions.'
-        }
-      }
+        query: { type: "string", description: 'Search terms for the capability or tool you need (e.g. "delegate agent", "git worktree", "browser screenshot")' },
+        limit: { type: "number", description: "Maximum matching tools to return (default: 10)" }
+      },
+      required: ["query"]
     }
   },
   {
@@ -451,6 +838,22 @@ var DEFAULT_TOOL_DEFINITIONS = [
       required: ["path", "contents"]
     }
   },
+  {
+    name: "notebook_edit",
+    description: "Edit a Jupyter notebook cell without treating the .ipynb file as plain text. Supports replace, insert, and delete by cell index or cell ID.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the .ipynb notebook file" },
+        cell_index: { type: "number", description: "0-based cell index to target. For insert, inserts after this index; omit to append." },
+        cell_id: { type: "string", description: "Optional cell ID to target instead of cell_index" },
+        new_source: { type: "string", description: "New source for replace or insert operations" },
+        cell_type: { type: "string", description: "Cell type for insert operations", enum: ["code", "markdown"] },
+        edit_mode: { type: "string", description: "Notebook edit mode", enum: ["replace", "insert", "delete"] }
+      },
+      required: ["path"]
+    }
+  },
   {
     name: "append_file",
     description: "Append text to a file",
@@ -476,41 +879,31 @@ var DEFAULT_TOOL_DEFINITIONS = [
     }
   },
   {
-    name: "search",
-    description: "Search workspace text",
-    parameters: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Text to search for" },
-        path: { type: "string", description: "Optional relative path to search in" }
-      },
-      required: ["query"]
-    }
-  },
-  {
-    name: "search_with_context",
-    description: "Search workspace text with surrounding context",
+    name: "fff_grep",
+    description: "Content search with frecency ranking and definition detection when native FFF is available, plus a ripgrep-backed fallback. Use this for content search.",
     parameters: {
       type: "object",
       properties: {
-        query: { type: "string", description: "Text to search for" },
-        path: { type: "string", description: "Optional relative path to search in" },
-        context: { type: "number", description: "Number of context lines (default 2)" },
-        limit: { type: "number", description: "Maximum results (default 10)" }
+        query: { type: "string", description: "Search pattern (regex auto-detected)" },
+        path: { type: "string", description: "Optional subdirectory to search in" },
+        exclude: { type: "string", description: "Exclude patterns (comma/space separated)" },
+        caseSensitive: { type: "boolean", description: "Force case-sensitive matching" },
+        beforeContext: { type: "number", description: "Lines of context before match (default: 2)" },
+        afterContext: { type: "number", description: "Lines of context after match (default: 2)" },
+        classifyDefinitions: { type: "boolean", description: "Prioritize code definitions (default: true)" },
+        limit: { type: "number", description: "Maximum results (default: 50)" }
       },
       required: ["query"]
     }
   },
   {
-    name: "semantic_search",
-    description: "Search workspace text semantically with gitignore awareness",
+    name: "fff_find",
+    description: "Path and filename search with frecency ranking when native FFF is available, plus a ripgrep-backed fallback. Use this for file path discovery.",
     parameters: {
       type: "object",
       properties: {
-        query: { type: "string", description: "Text to search for" },
-        path: { type: "string", description: "Optional relative path to search in" },
-        limit: { type: "number", description: "Maximum results (default 5)" },
-        window: { type: "number", description: "Context window size (default 400)" }
+        query: { type: "string", description: "Filename or path pattern to search" },
+        limit: { type: "number", description: "Maximum results (default: 50)" }
       },
       required: ["query"]
     }
@@ -576,12 +969,12 @@ var DEFAULT_TOOL_DEFINITIONS = [
   },
   {
     name: "run_command",
-    description: "Execute shell commands with optional directory, background mode, and description. Prefer dedicated tools: read_file over cat, search over grep, search_replace over sed.",
+    description: "Execute a shell command in the user's shell with full pipe, redirect, and environment variable support. Cross-platform (bash/zsh on macOS/Linux, cmd/PowerShell on Windows). Prefer dedicated tools for file operations (read_file, write_file, fff_grep, fff_find). For most commands, prefer the `shell` tool instead - it shows real-time output. Use this only for quick commands where you don't need progress monitoring.",
     parameters: {
       type: "object",
       properties: {
-        command: { type: "string", description: "Command to execute" },
-        args: { type: "array", description: "Command arguments", items: { type: "string", description: "Single argument" } },
+        command: { type: "string", description: "Command to execute. Supports pipes (|), redirects (>), env vars ($HOME), globs (*), and chaining (&&)." },
+        args: { type: "array", description: "Command arguments. Joined with the command into a single shell string. For complex commands with pipes/redirects, put everything in the command field instead.", items: { type: "string", description: "Single argument" } },
         directory: { type: "string", description: "Directory relative to workspace root to execute in" },
         description: { type: "string", description: "Brief description of what this command does (shown to user)" },
         background: { type: "boolean", description: "Run process in background (returns PID, useful for dev servers)" }
@@ -591,6 +984,23 @@ var DEFAULT_TOOL_DEFINITIONS = [
     requiresApproval: true,
     approvalMessage: "Allow the agent to run a shell command?"
   },
+  {
+    name: "shell",
+    description: "Execute a shell command with real-time output displayed in a live, isolated box in the TUI. Use this as the DEFAULT for running shell commands - it shows stdout/stderr in real-time while keeping the CLI input responsive. Ideal for tests, builds, installs, dev servers, and any command where you want to see progress. For quick one-liners where output monitoring isn't needed, you can use run_command instead.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "Command to execute. Supports pipes (|), redirects (>), env vars ($HOME), globs (*), and chaining (&&)." },
+        args: { type: "array", description: "Command arguments. Joined with the command into a single shell string.", items: { type: "string", description: "Single argument" } },
+        directory: { type: "string", description: "Directory relative to workspace root to execute in" },
+        description: { type: "string", description: "Brief description of what this command does (shown to user)" },
+        background: { type: "boolean", description: "Run process in background (detached). Returns immediately with PID. Use for dev servers, long-running processes, or when you don't need to wait for completion." }
+      },
+      required: ["command"]
+    },
+    requiresApproval: true,
+    approvalMessage: "Allow the agent to run a shell command with live output?"
+  },
   {
     name: "add_dependency",
     description: "Add a package dependency (supports dev flag)",
@@ -664,13 +1074,12 @@ var DEFAULT_TOOL_DEFINITIONS = [
   },
   {
     name: "git_diff",
-    description: "Show git diff for a file",
+    description: "Show git diff. When path is provided, shows diff for that file only. When omitted, shows all uncommitted changes in the workspace.",
     parameters: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Relative path to the file" }
-      },
-      required: ["path"]
+        path: { type: "string", description: "Relative path to a specific file (optional). Omit to diff the entire workspace." }
+      }
     }
   },
   {
@@ -1072,31 +1481,6 @@ var DEFAULT_TOOL_DEFINITIONS = [
       required: ["name", "command"]
     }
   },
-  {
-    name: "multi_file_edit",
-    description: "Apply multiple edits to a file",
-    parameters: {
-      type: "object",
-      properties: {
-        file_path: { type: "string", description: "Relative path to the file" },
-        edits: {
-          type: "array",
-          description: "Array of {old_string, new_string, replace_all?}",
-          items: {
-            type: "object",
-            properties: {
-              old_string: { type: "string", description: "Text to replace" },
-              new_string: { type: "string", description: "Replacement text" },
-              replace_all: { type: "boolean", description: "Replace all occurrences (default: false)" }
-            },
-            required: ["old_string", "new_string"]
-          }
-        }
-      },
-      required: ["file_path", "edits"]
-    },
-    requiresApproval: true
-  },
   {
     name: "todo_write",
     description: "Persist and update the todo list. Send the COMPLETE updated todo list each time (not incremental changes).",
@@ -1167,11 +1551,211 @@ var DEFAULT_TOOL_DEFINITIONS = [
         name: { type: "string", description: "Tool name in snake_case (e.g., analyze_imports, count_lines)" },
         description: { type: "string", description: "Clear description of what the tool does" },
         parameters: { type: "object", description: "JSON Schema defining tool parameters" },
-        handler: { type: "string", description: 'Shell command template with {{param}} placeholders (e.g., "grep -E {{pattern}} {{path}}")' }
+        handler: { type: "string", description: 'Shell command template with {{param}} placeholders (e.g., "grep -E {{pattern}} {{path}}")' },
+        scope: { type: "string", description: 'Where to persist the tool: "user" for all workspaces or "project" for this repository only', enum: ["user", "project"] }
       },
       required: ["name", "description", "parameters", "handler"]
     }
   },
+  {
+    name: "delegate_task",
+    description: "Delegate a focused task to a specialized sub-agent. Use for broader exploration, verification, or work you want to keep out of the main context.",
+    parameters: {
+      type: "object",
+      properties: {
+        agent_name: { type: "string", description: "Registered agent name to delegate to" },
+        task: { type: "string", description: "Concrete task for the delegated agent" }
+      },
+      required: ["agent_name", "task"]
+    }
+  },
+  {
+    name: "delegate_parallel",
+    description: "Delegate multiple independent tasks to specialized sub-agents in parallel.",
+    parameters: {
+      type: "object",
+      properties: {
+        tasks: {
+          type: "array",
+          description: "Independent agent tasks to run in parallel",
+          items: {
+            type: "object",
+            properties: {
+              agent_name: { type: "string", description: "Registered agent name to delegate to" },
+              task: { type: "string", description: "Concrete task for that agent" }
+            },
+            required: ["agent_name", "task"]
+          }
+        }
+      },
+      required: ["tasks"]
+    }
+  },
+  {
+    name: "create_team",
+    description: "Create or reuse a teammate coordination group for multi-agent work.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Team name" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "add_teammate",
+    description: "Add a teammate process to the active team using a registered agent.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Human-readable teammate name" },
+        agent_name: { type: "string", description: "Registered agent name to run" },
+        model: { type: "string", description: "Optional model override for that teammate" }
+      },
+      required: ["name", "agent_name"]
+    }
+  },
+  {
+    name: "create_task",
+    description: "Create a team task that can be assigned to an idle teammate.",
+    parameters: {
+      type: "object",
+      properties: {
+        subject: { type: "string", description: "Short task title" },
+        description: { type: "string", description: "Detailed task description" },
+        blocked_by: {
+          type: "array",
+          description: "Optional prerequisite task IDs that must complete first",
+          items: { type: "string", description: "Task ID" }
+        }
+      },
+      required: ["subject", "description"]
+    }
+  },
+  {
+    name: "task_get",
+    description: "Get a single team task by ID from the active team task list.",
+    parameters: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "Task ID to retrieve" }
+      },
+      required: ["task_id"]
+    }
+  },
+  {
+    name: "task_list",
+    description: "List tasks from the active team task list, optionally filtered by status or owner.",
+    parameters: {
+      type: "object",
+      properties: {
+        status: { type: "string", description: "Optional status filter", enum: ["pending", "in_progress", "completed"] },
+        owner: { type: "string", description: "Optional owner filter" }
+      }
+    }
+  },
+  {
+    name: "task_update",
+    description: "Update a task in the active team task list.",
+    parameters: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "Task ID to update" },
+        subject: { type: "string", description: "Updated short task title" },
+        description: { type: "string", description: "Updated task description" },
+        blocked_by: {
+          type: "array",
+          description: "Updated prerequisite task IDs",
+          items: { type: "string", description: "Task ID" }
+        },
+        status: { type: "string", description: "Updated task status", enum: ["pending", "in_progress", "completed"] }
+      },
+      required: ["task_id"]
+    }
+  },
+  {
+    name: "task_stop",
+    description: "Stop an active or queued team task and return it to pending state.",
+    parameters: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "Task ID to stop" }
+      },
+      required: ["task_id"]
+    }
+  },
+  {
+    name: "task_output",
+    description: "Store or update the latest output/progress note for a task in the active team task list.",
+    parameters: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "Task ID to update" },
+        output: { type: "string", description: "Latest progress note, result, or output summary for the task" }
+      },
+      required: ["task_id", "output"]
+    }
+  },
+  {
+    name: "skill",
+    description: "List, inspect, activate, or deactivate a loaded skill. Activating a skill adds its instructions to the active session prompt.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "Skill operation to perform", enum: ["list", "info", "activate", "deactivate"] },
+        name: { type: "string", description: "Skill name for info, activate, or deactivate" }
+      },
+      required: ["command"]
+    }
+  },
+  {
+    name: "sleep",
+    description: "Pause execution for a short time when waiting for another system or process to settle. Use sparingly and prefer explicit polling when possible.",
+    parameters: {
+      type: "object",
+      properties: {
+        seconds: { type: "number", description: "Number of seconds to wait (maximum 300)" },
+        reason: { type: "string", description: "Optional short reason for the wait" }
+      },
+      required: ["seconds"]
+    }
+  },
+  {
+    name: "enter_worktree",
+    description: "Create and enter an isolated git worktree for the current session. Subsequent file, git, and command tools operate in that worktree until exit_worktree is called.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Optional branch/worktree name to use for the new session worktree" }
+      }
+    }
+  },
+  {
+    name: "exit_worktree",
+    description: "Exit the current session worktree and return to the original workspace. Optionally keep the worktree on disk for inspection.",
+    parameters: {
+      type: "object",
+      properties: {
+        keep: { type: "boolean", description: "When true, keep the worktree and branch instead of removing them" }
+      }
+    }
+  },
+  {
+    name: "team_status",
+    description: "Show the active team, teammate statuses, and current task queue."
+  },
+  {
+    name: "send_team_message",
+    description: "Send a direct message from the lead agent to a teammate.",
+    parameters: {
+      type: "object",
+      properties: {
+        to: { type: "string", description: "Teammate name" },
+        content: { type: "string", description: "Message content" }
+      },
+      required: ["to", "content"]
+    }
+  },
   // Web Search Operations
   {
     name: "web_search",
@@ -1283,7 +1867,45 @@ Actions:
       required: ["query"]
     }
   },
+  {
+    name: "install_agent_skill",
+    description: "Install a community skill by exact skill id or name, then optionally activate it for the current session. Prefer asking the user before using this unless they explicitly requested installation or started with --auto-skill.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Exact community skill id or name to install" },
+        scope: { type: "string", description: "Install scope (default: project)", enum: ["project", "user"] },
+        activate: { type: "boolean", description: "Activate the installed skill for the current session (default: true)" }
+      },
+      required: ["name"]
+    }
+  },
   // Schedule Management
+  {
+    name: "cron_create",
+    description: "Create a recurring scheduled job using an explicit interval and prompt. Use this for structured schedule creation instead of natural-language slash command parsing.",
+    parameters: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "The prompt/instruction to run on each schedule trigger" },
+        interval: { type: "string", description: "Repeat interval shorthand like 5m, 2h, 1d, or 30s" },
+        max_runs: { type: "number", description: "Optional maximum number of times to trigger before auto-cancel" },
+        expires_in: { type: "string", description: "Optional expiry duration shorthand like 7d, 2h, or 30m" }
+      },
+      required: ["prompt", "interval"]
+    }
+  },
+  {
+    name: "cron_delete",
+    description: "Cancel an active recurring scheduled job by its ID.",
+    parameters: {
+      type: "object",
+      properties: {
+        schedule_id: { type: "string", description: "The job ID to cancel" }
+      },
+      required: ["schedule_id"]
+    }
+  },
   {
     name: "list_schedules",
     description: "List all active recurring scheduled jobs. Returns job IDs, prompts, intervals, run counts, and expiry times."
@@ -1298,11 +1920,235 @@ Actions:
       },
       required: ["schedule_id"]
     }
+  },
+  // ── Directory Access ──
+  {
+    name: "request_directory_access",
+    description: "Request access to a directory outside the current workspace. Use this when the user mentions a folder or path that is not within the allowed directories. In yolo/auto-mode, access is granted automatically. In interactive mode, the user will be asked to approve. Returns the resolved path if access was granted, or an error message if denied.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "The directory path to request access to (absolute or relative to cwd)" },
+        reason: { type: "string", description: "Optional reason why access is needed (shown to user in interactive mode)" }
+      },
+      required: ["path"]
+    },
+    requiresApproval: false
+    // This tool handles its own approval flow
+  },
+  // ── Code review ──
+  {
+    name: "code_review",
+    description: "Perform a staff-engineer-level code review. Analyzes code quality, architecture, security, performance, and maintainability. Returns 10 prioritized actionable findings with specific file paths, line numbers, and suggested fixes. Use when the user asks to review code, audit quality, or find improvements.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File or directory to review. Defaults to workspace root." },
+        scope: {
+          type: "string",
+          description: 'Review scope: "full" analyzes the entire path, "diff" reviews only uncommitted changes, "file" reviews a single file.',
+          enum: ["full", "diff", "file"]
+        },
+        instructions: { type: "string", description: 'Additional review focus areas from the user (e.g., "focus on error handling", "check for memory leaks").' }
+      }
+    }
+  },
+  // ── Browser tools (available when Chrome extension is connected via /chrome) ──
+  {
+    name: "browser_screenshot",
+    description: "Capture a screenshot of the page currently visible in the Chrome browser tab. Returns a base64 PNG image. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        format: { type: "string", description: "Image format", enum: ["png", "jpeg"] },
+        quality: { type: "number", description: "JPEG quality 0-100 (default: 80)" }
+      }
+    }
+  },
+  {
+    name: "browser_click",
+    description: "Click an element on the current browser page by CSS selector. Scrolls the element into view first. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector of the element to click" }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "browser_type",
+    description: "Type text into an input, textarea, or contenteditable element on the current browser page. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector of the input element" },
+        text: { type: "string", description: "Text to type" },
+        clear: { type: "boolean", description: "Clear the field before typing (default: false)" }
+      },
+      required: ["selector", "text"]
+    }
+  },
+  {
+    name: "browser_navigate",
+    description: "Navigate the active Chrome browser tab to a URL. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL to navigate to" }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "browser_scroll",
+    description: "Scroll the browser page in a direction, or scroll a specific element into view. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        direction: { type: "string", description: "Scroll direction", enum: ["up", "down", "left", "right"] },
+        amount: { type: "number", description: "Pixels to scroll (default: 500)" },
+        selector: { type: "string", description: "CSS selector to scroll into view (overrides direction)" }
+      }
+    }
+  },
+  {
+    name: "browser_find_element",
+    description: "Find elements on the current browser page by CSS selector, visible text content, or ARIA role. Returns up to 20 matches with their selectors. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector to match" },
+        text: { type: "string", description: "Text content to search for" },
+        role: { type: "string", description: "ARIA role to match" }
+      }
+    }
+  },
+  {
+    name: "browser_press_key",
+    description: "Press a keyboard key on the current browser page. For modifier combos use ctrl/shift/alt/meta params. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Key name (e.g. Enter, Escape, Tab, a, 1)" },
+        ctrl: { type: "string", description: "Hold Ctrl (true/false)", enum: ["true", "false"] },
+        shift: { type: "string", description: "Hold Shift (true/false)", enum: ["true", "false"] },
+        alt: { type: "string", description: "Hold Alt (true/false)", enum: ["true", "false"] },
+        meta: { type: "string", description: "Hold Cmd/Meta (true/false)", enum: ["true", "false"] }
+      },
+      required: ["key"]
+    }
+  },
+  {
+    name: "browser_get_page_context",
+    description: "Extract the current browser page title, URL, headings, metadata, and body text content. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        max_chars: { type: "number", description: "Max body text characters (default: 7000, max: 12000)" }
+      }
+    }
+  },
+  {
+    name: "browser_get_element",
+    description: "Get detailed properties of a DOM element on the current browser page: bounding rect, computed styles, attributes, value, disabled state. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector of the element" }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "browser_wait_for_element",
+    description: "Wait for an element matching a CSS selector to appear on the current browser page. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector to wait for" },
+        timeout: { type: "number", description: "Max wait time in ms (default: 5000)" }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "browser_read_network",
+    description: "Read captured network requests from the current browser page. Shows URLs, methods, status codes, sizes. Requires debugger to be attached first. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        urlPattern: { type: "string", description: "Filter requests by URL substring" },
+        method: { type: "string", description: "Filter by HTTP method (GET, POST, etc.)" },
+        status: { type: "string", description: 'Filter by status code prefix (e.g. "4" for 4xx errors)' },
+        limit: { type: "number", description: "Max requests to return (default: 50)" }
+      }
+    }
+  },
+  {
+    name: "browser_get_tabs",
+    description: "List all open browser tabs with their titles, URLs, and tab group IDs. Only available when the Chrome extension is connected."
+  },
+  {
+    name: "browser_get_tab_groups",
+    description: "List all tab groups with their titles, colors, and member tabs. Only available when the Chrome extension is connected."
+  },
+  {
+    name: "browser_execute_js",
+    description: "Execute JavaScript code in the current browser page context. Use for DOM queries, data extraction, or page manipulation that other tools cannot achieve. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        code: { type: "string", description: "JavaScript code to execute in the page context. Use return statements for values." }
+      },
+      required: ["code"]
+    }
+  },
+  {
+    name: "browser_read_console",
+    description: "Read captured console log messages from the current browser page. Includes errors, warnings, and info messages. Useful for debugging. Only available when the Chrome extension is connected.",
+    parameters: {
+      type: "object",
+      properties: {
+        level: { type: "string", description: "Filter by level", enum: ["error", "warn", "log", "info", "debug"] },
+        limit: { type: "number", description: "Max messages to return (default: 50)" }
+      }
+    }
   }
 ];
-var ToolManager = class _ToolManager {
-  constructor(options) {
-    this.definitions = /* @__PURE__ */ new Map();
+var PLAN_TOOL_DEFINITION = {
+  name: "plan",
+  description: 'Create a structured implementation plan with detailed numbered steps before executing a task. Always break the task into concrete, actionable steps (e.g. "1. Read existing auth code\n2. Create JWT utility module\n3. Add login endpoint"). Each step should be a single clear action. Aim for 3-10 steps depending on complexity. You may call this tool multiple times to refine the plan. When you are satisfied with the plan, call `exit_plan_mode` to present it to the user for approval.',
+  parameters: {
+    type: "object",
+    properties: {
+      notes: {
+        type: "string",
+        description: 'A numbered step-by-step plan. Each step on its own line starting with "N. " (e.g. "1. Read existing code\n2. Create new module\n3. Write tests"). Be specific and actionable - avoid single vague descriptions.'
+      }
+    }
+  }
+};
+var EXIT_PLAN_MODE_TOOL_DEFINITION = {
+  name: "exit_plan_mode",
+  description: "Present the current plan to the user for approval and exit the planning phase. Call this ONLY after you have created a plan using the `plan` tool and are ready for the user to review it. Do NOT call this tool before creating a plan.",
+  parameters: {
+    type: "object",
+    properties: {
+      summary: {
+        type: "string",
+        description: "A brief summary of the plan you created, highlighting the key changes and approach."
+      }
+    }
+  }
+};
+var ToolManager = (_class = class _ToolManager {
+  __init() {this.definitions = /* @__PURE__ */ new Map()}
+  
+  
+  
+  
+  constructor(options) {;_class.prototype.__init.call(this);
     this.executor = options.executor;
     this.confirmApproval = options.confirmApproval;
     this.toolFilter = new ToolFilter(_nullishCoalesce(options.clientContext, () => ( "cli")), options.customPolicy);
@@ -1315,13 +2161,20 @@ var ToolManager = class _ToolManager {
   register(definition) {
     this.definitions.set(definition.name, definition);
   }
+  /**
+   * Unregister a tool definition by name.
+   * Used to dynamically remove tools (e.g. plan tool when plan mode is disabled).
+   */
+  unregister(name) {
+    return this.definitions.delete(name);
+  }
   /**
    * Register meta-tools from ToolsRegistry dynamically
    * Called during session initialization to load persisted tools
    */
   registerMetaTools(toolDefinitions) {
     for (const def of toolDefinitions) {
-      if (DEFAULT_TOOL_DEFINITIONS.some((d) => d.name === def.name)) {
+      if (DEFAULT_TOOL_DEFINITIONS.some((d) => d.name === def.name) || GOAL_TOOL_DEFINITIONS.some((d) => d.name === def.name)) {
         continue;
       }
       this.definitions.set(def.name, def);
@@ -1343,7 +2196,7 @@ var ToolManager = class _ToolManager {
    * Check if a tool name conflicts with built-in definitions
    */
   isBuiltInTool(name) {
-    return DEFAULT_TOOL_DEFINITIONS.some((d) => d.name === name);
+    return DEFAULT_TOOL_DEFINITIONS.some((d) => d.name === name) || GOAL_TOOL_DEFINITIONS.some((d) => d.name === name);
   }
   listToolNames() {
     return Array.from(this.definitions.keys()).filter((name) => this.toolFilter.isAllowed(name));
@@ -1441,7 +2294,7 @@ var ToolManager = class _ToolManager {
   }
   async execute(toolCalls, onToolComplete) {
     const results = /* @__PURE__ */ new Map();
-    const planModeManager = _chunkULQ6MDSJcjs.getPlanModeManager.call(void 0, );
+    const planModeManager = _chunkLFDPTJYFcjs.getPlanModeManager.call(void 0, );
     const isInPlanningPhase = planModeManager.isEnabled() && planModeManager.getPhase() === "planning";
     const readOnlyTools = isInPlanningPhase ? new Set(planModeManager.getReadOnlyTools()) : null;
     const readyToExecute = [];
@@ -1454,7 +2307,7 @@ var ToolManager = class _ToolManager {
           error: `Tool '${call.tool}' is not available in the current context (${this.toolFilter.getContext()})`
         };
         results.set(i, result);
-        _optionalChain([onToolComplete, 'optionalCall', _14 => _14(i, result)]);
+        _optionalChain([onToolComplete, 'optionalCall', _16 => _16(i, result)]);
         continue;
       }
       if (readOnlyTools && !readOnlyTools.has(call.tool)) {
@@ -1464,13 +2317,23 @@ var ToolManager = class _ToolManager {
           error: `Tool '${call.tool}' is not available in plan mode. Only read-only tools are allowed during planning. Use 'plan' tool to create a plan, then accept it to execute write operations.`
         };
         results.set(i, result);
-        _optionalChain([onToolComplete, 'optionalCall', _15 => _15(i, result)]);
+        _optionalChain([onToolComplete, 'optionalCall', _17 => _17(i, result)]);
         continue;
       }
       const definition = this.definitions.get(call.tool);
-      const requiresApproval = this.toolFilter.requiresApproval(call.tool, _optionalChain([definition, 'optionalAccess', _16 => _16.requiresApproval]));
+      if (!definition) {
+        const result = {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' is not available. Use tool_search or tools_registry to find an available tool.`
+        };
+        results.set(i, result);
+        _optionalChain([onToolComplete, 'optionalCall', _18 => _18(i, result)]);
+        continue;
+      }
+      const requiresApproval = this.toolFilter.requiresApproval(call.tool, _optionalChain([definition, 'optionalAccess', _19 => _19.requiresApproval]));
       if (requiresApproval) {
-        let message = _nullishCoalesce(_optionalChain([definition, 'optionalAccess', _17 => _17.approvalMessage]), () => ( `Allow tool ${call.tool}?`));
+        let message = _nullishCoalesce(_optionalChain([definition, 'optionalAccess', _20 => _20.approvalMessage]), () => ( `Allow tool ${call.tool}?`));
         const permContext = { tool: call.tool };
         if (call.tool === "run_command" && call.args) {
           const cmd = String(call.args.command || "");
@@ -1480,38 +2343,67 @@ var ToolManager = class _ToolManager {
           message = `Run this command${dir}?
   $ ${fullCommand}`;
           permContext.command = fullCommand;
-        } else if (call.tool === "delete_path" && _optionalChain([call, 'access', _18 => _18.args, 'optionalAccess', _19 => _19.path])) {
+        } else if (call.tool === "shell" && call.args) {
+          const cmd = String(call.args.command || "");
+          const args = Array.isArray(call.args.args) ? call.args.args.join(" ") : "";
+          const fullCommand = args ? `${cmd} ${args}` : cmd;
+          const dir = call.args.directory ? ` (in ${call.args.directory})` : "";
+          message = `Run this shell command with live output${dir}?
+  $ ${fullCommand}`;
+          permContext.command = fullCommand;
+        } else if (call.tool === "delete_path" && _optionalChain([call, 'access', _21 => _21.args, 'optionalAccess', _22 => _22.path])) {
           message = `Delete this path?
   ${call.args.path}`;
           permContext.path = String(call.args.path);
-        } else if (call.tool === "write_file" && _optionalChain([call, 'access', _20 => _20.args, 'optionalAccess', _21 => _21.path])) {
+        } else if (call.tool === "write_file" && _optionalChain([call, 'access', _23 => _23.args, 'optionalAccess', _24 => _24.path])) {
           message = `Write to this file?
   ${call.args.path}`;
           permContext.path = String(call.args.path);
-        } else if (call.tool === "multi_file_edit" && _optionalChain([call, 'access', _22 => _22.args, 'optionalAccess', _23 => _23.file_path])) {
+        } else if (call.tool === "multi_file_edit" && _optionalChain([call, 'access', _25 => _25.args, 'optionalAccess', _26 => _26.file_path])) {
           const editCount = Array.isArray(call.args.edits) ? call.args.edits.length : 0;
           message = `Edit this file (${editCount} change${editCount === 1 ? "" : "s"})?
   ${call.args.file_path}`;
           permContext.path = String(call.args.file_path);
         }
-        const confirmed = await this.confirmApproval(message, permContext);
-        if (!confirmed) {
+        const decision = normalizePermissionPromptResponse(await this.confirmApproval(message, permContext));
+        if (decision.decision === "alternative" && typeof decision.alternative === "string") {
+          if (call.tool === "run_command" && call.args) {
+            call.args.command = decision.alternative;
+            call.args.args = [];
+          } else if (call.tool === "shell" && call.args) {
+            call.args.command = decision.alternative;
+            call.args.args = [];
+          } else if (_optionalChain([call, 'access', _27 => _27.args, 'optionalAccess', _28 => _28.path]) && typeof call.args.path === "string") {
+            call.args.path = decision.alternative;
+          } else if (_optionalChain([call, 'access', _29 => _29.args, 'optionalAccess', _30 => _30.file_path]) && typeof call.args.file_path === "string") {
+            call.args.file_path = decision.alternative;
+          } else {
+            const result = {
+              tool: call.tool,
+              success: false,
+              output: "Tool execution skipped because the alternative input could not be applied."
+            };
+            results.set(i, result);
+            _optionalChain([onToolComplete, 'optionalCall', _31 => _31(i, result)]);
+            continue;
+          }
+        }
+        if (!isAllowedPermissionPrompt(decision)) {
           const result = {
             tool: call.tool,
             success: false,
             output: "Tool execution skipped by user."
           };
           results.set(i, result);
-          _optionalChain([onToolComplete, 'optionalCall', _24 => _24(i, result)]);
+          _optionalChain([onToolComplete, 'optionalCall', _32 => _32(i, result)]);
           continue;
         }
       }
       readyToExecute.push({ call, index: i });
     }
     if (readyToExecute.length > 0) {
-      const execResults = await this.executeWithConcurrency(
+      const execResults = await this.executeScheduled(
         readyToExecute,
-        this.maxConcurrency,
         onToolComplete
       );
       for (const [index, result] of execResults) {
@@ -1520,6 +2412,51 @@ var ToolManager = class _ToolManager {
     }
     return toolCalls.map((_, i) => results.get(i));
   }
+  /**
+   * Execute approved calls in model order while preserving safe parallelism.
+   *
+   * Read-only batches can run concurrently. Mutating tools are ordering
+   * barriers because they may affect following reads or other writes.
+   */
+  async executeScheduled(tasks, onToolComplete) {
+    const results = /* @__PURE__ */ new Map();
+    let parallelBatch = [];
+    const mergeResults = (batchResults) => {
+      for (const [index, result] of batchResults) {
+        results.set(index, result);
+      }
+    };
+    const flushParallelBatch = async () => {
+      if (parallelBatch.length === 0) {
+        return;
+      }
+      const batchResults = await this.executeWithConcurrency(
+        parallelBatch,
+        this.maxConcurrency,
+        onToolComplete
+      );
+      mergeResults(batchResults);
+      parallelBatch = [];
+    };
+    for (const task of tasks) {
+      if (!this.shouldExecuteSequentially(task.call)) {
+        parallelBatch.push(task);
+        continue;
+      }
+      await flushParallelBatch();
+      const sequentialResult = await this.executeWithConcurrency(
+        [task],
+        1,
+        onToolComplete
+      );
+      mergeResults(sequentialResult);
+    }
+    await flushParallelBatch();
+    return results;
+  }
+  shouldExecuteSequentially(call) {
+    return SEQUENTIAL_TOOL_CATEGORIES.has(getToolCategory(call.tool));
+  }
   /**
    * Execute tool calls with a concurrency limit using a worker-pool pattern.
    */
@@ -1533,7 +2470,11 @@ var ToolManager = class _ToolManager {
         let result;
         try {
           const action = this.toAction(call);
-          const output = await this.executor(action, { toolCallId: call.id, tool: call.tool });
+          const output = await this.executor(action, {
+            toolCallId: call.id,
+            tool: call.tool,
+            approvalHandled: true
+          });
           result = { tool: call.tool, success: true, output };
         } catch (error) {
           result = {
@@ -1543,7 +2484,7 @@ var ToolManager = class _ToolManager {
           };
         }
         results.set(index, result);
-        _optionalChain([onToolComplete, 'optionalCall', _25 => _25(index, result)]);
+        _optionalChain([onToolComplete, 'optionalCall', _33 => _33(index, result)]);
       }
     };
     const workers = Array.from(
@@ -1559,22 +2500,31 @@ var ToolManager = class _ToolManager {
       ..._nullishCoalesce(call.args, () => ( {}))
     };
   }
-};
+}, _class);
 
 // src/core/agents/AgentDelegator.ts
 
 var DEFAULT_MAX_DEPTH = 3;
-var AgentDelegator = class {
-  constructor(llm, actionExecutor, options = {}) {
+var AgentDelegator = (_class2 = class {
+  constructor(llm, actionExecutor, options = {}) {;_class2.prototype.__init2.call(this);
     this.llm = llm;
     this.actionExecutor = actionExecutor;
-    this.subagentCounter = 0;
-    this.registry = _chunkBVKXEQVGcjs.AgentRegistry.getInstance();
+    this.registry = _chunkJV5HVCHUcjs.AgentRegistry.getInstance();
     this.clientContext = _nullishCoalesce(options.clientContext, () => ( "cli"));
     this.currentDepth = _nullishCoalesce(options.currentDepth, () => ( 0));
     this.maxDepth = _nullishCoalesce(options.maxDepth, () => ( DEFAULT_MAX_DEPTH));
     this.onSubagentStop = options.onSubagentStop;
+    this.featureConfig = options.featureConfig;
   }
+  
+  
+  
+  
+  
+  
+  
+  
+  __init2() {this.subagentCounter = 0}
   generateSubagentId() {
     return `subagent-${Date.now()}-${++this.subagentCounter}`;
   }
@@ -1590,7 +2540,8 @@ var AgentDelegator = class {
     const subAgentOptions = {
       clientContext: this.clientContext,
       depth: this.currentDepth + 1,
-      maxDepth: this.maxDepth
+      maxDepth: this.maxDepth,
+      featureConfig: this.featureConfig
     };
     const subagentId = this.generateSubagentId();
     const startTime = Date.now();
@@ -1633,7 +2584,8 @@ var AgentDelegator = class {
     const subAgentOptions = {
       clientContext: this.clientContext,
       depth: this.currentDepth + 1,
-      maxDepth: this.maxDepth
+      maxDepth: this.maxDepth,
+      featureConfig: this.featureConfig
     };
     const promises = tasks.map(async ({ agent_name, task }) => {
       const agentConfig = this.registry.getAgent(agent_name);
@@ -1686,7 +2638,7 @@ ${result}`;
   canDelegate() {
     return this.currentDepth < this.maxDepth;
   }
-};
+}, _class2);
 
 // src/core/agents/SubAgent.ts
 var DELEGATION_TOOL_DEFINITIONS = [
@@ -1714,17 +2666,17 @@ var DELEGATION_TOOL_DEFINITIONS = [
     }
   }
 ];
-var SubAgent = class {
-  constructor(config, llm, actionExecutor, options) {
+var SubAgent = (_class3 = class {
+  constructor(config, llm, actionExecutor, options) {;_class3.prototype.__init3.call(this);
     this.config = config;
     this.llm = llm;
     this.actionExecutor = actionExecutor;
-    this.delegator = null;
     this.name = config.name;
     this.options = options;
     const canDelegate = options.depth < options.maxDepth;
     const allowedTools = new Set(config.tools);
-    let definitions = DEFAULT_TOOL_DEFINITIONS.filter((def) => allowedTools.has(def.name));
+    const baseDefinitions = _chunkWJYFLQ7Gcjs.isGoalFeatureEnabled.call(void 0, options.featureConfig) ? [...DEFAULT_TOOL_DEFINITIONS, ...GOAL_TOOL_DEFINITIONS] : DEFAULT_TOOL_DEFINITIONS;
+    let definitions = allowedTools.has("*") ? [...baseDefinitions] : baseDefinitions.filter((def) => allowedTools.has(def.name));
     if (canDelegate) {
       definitions = [...definitions, ...DELEGATION_TOOL_DEFINITIONS];
     }
@@ -1734,7 +2686,8 @@ var SubAgent = class {
       this.delegator = new AgentDelegator(llm, actionExecutor, {
         clientContext: options.clientContext,
         currentDepth: options.depth,
-        maxDepth: options.maxDepth
+        maxDepth: options.maxDepth,
+        featureConfig: options.featureConfig
       });
     }
     const scaledConcurrency = options.depth === 0 ? _nullishCoalesce(options.maxConcurrency, () => ( 5)) : options.depth === 1 ? Math.min(3, _nullishCoalesce(options.maxConcurrency, () => ( 5))) : 1;
@@ -1758,9 +2711,17 @@ var SubAgent = class {
       maxConcurrency: scaledConcurrency
     });
     const enhancedSystemPrompt = this.buildSystemPrompt(config.systemPrompt, definitions);
-    this.conversation = new (0, _chunkCNBKZEX5cjs.ConversationManager)();
+    this.conversation = new (0, _chunkDA7NBAJKcjs.ConversationManager)();
     this.conversation.reset(enhancedSystemPrompt);
   }
+  
+  
+  
+  
+  
+  __init3() {this.delegator = null}
+  
+  
   /**
    * Build system prompt with tool signatures for the LLM
    */
@@ -1795,8 +2756,8 @@ var SubAgent = class {
    * Format a tool definition as a signature string
    */
   formatToolSignature(def) {
-    const params = _optionalChain([def, 'access', _26 => _26.parameters, 'optionalAccess', _27 => _27.properties]) ? Object.entries(def.parameters.properties).map(([name, prop]) => {
-      const required = _optionalChain([def, 'access', _28 => _28.parameters, 'optionalAccess', _29 => _29.required, 'optionalAccess', _30 => _30.includes, 'call', _31 => _31(name)]) ? "" : "?";
+    const params = _optionalChain([def, 'access', _34 => _34.parameters, 'optionalAccess', _35 => _35.properties]) ? Object.entries(def.parameters.properties).map(([name, prop]) => {
+      const required = _optionalChain([def, 'access', _36 => _36.parameters, 'optionalAccess', _37 => _37.required, 'optionalAccess', _38 => _38.includes, 'call', _39 => _39(name)]) ? "" : "?";
       return `${name}${required}: ${prop.type}`;
     }).join(", ") : "";
     return `- ${def.name}(${params}): ${def.description}`;
@@ -1806,17 +2767,19 @@ var SubAgent = class {
 \u{1F916} Sub-agent '${this.name}' starting task... (depth ${this.options.depth}/${this.options.maxDepth})`));
     this.conversation.addMessage({ role: "user", content: task });
     const tools = this.toolManager.toFunctionDefinitions();
+    const supportsNativeToolCalling = _optionalChain([this, 'access', _40 => _40.llm, 'access', _41 => _41.getCapabilities, 'optionalCall', _42 => _42(), 'access', _43 => _43.nativeToolCalling]) === true;
     const maxIterations = 10;
     for (let i = 0; i < maxIterations; i++) {
+      const requestTools = supportsNativeToolCalling && tools.length > 0 ? tools : void 0;
       const completion = await this.llm.complete({
         messages: this.conversation.history(),
         model: this.config.model,
         temperature: 0.2,
-        tools: tools.length > 0 ? tools : void 0,
-        toolChoice: tools.length > 0 ? "auto" : void 0
+        tools: requestTools,
+        toolChoice: requestTools ? "auto" : void 0
       });
       const payload = this.parseResponse(completion);
-      if (_optionalChain([completion, 'access', _32 => _32.toolCalls, 'optionalAccess', _33 => _33.length])) {
+      if (_optionalChain([completion, 'access', _44 => _44.toolCalls, 'optionalAccess', _45 => _45.length])) {
         this.conversation.addMessage({
           role: "assistant",
           content: completion.content || ""
@@ -1831,13 +2794,13 @@ var SubAgent = class {
         const results = await this.toolManager.execute(payload.toolCalls);
         for (let j = 0; j < results.length; j++) {
           const result = results[j];
-          const toolCall = _optionalChain([completion, 'access', _34 => _34.toolCalls, 'optionalAccess', _35 => _35[j]]);
+          const toolCall = _optionalChain([completion, 'access', _46 => _46.toolCalls, 'optionalAccess', _47 => _47[j]]);
           const content = result.success ? _nullishCoalesce(result.output, () => ( "(no output)")) : _nullishCoalesce(result.error, () => ( "Tool failed"));
           this.conversation.addMessage({
             role: "tool",
             name: result.tool,
             content,
-            tool_call_id: _optionalChain([toolCall, 'optionalAccess', _36 => _36.id])
+            tool_call_id: _optionalChain([toolCall, 'optionalAccess', _48 => _48.id])
           });
           if (!result.success) {
             console.log(_chalk2.default.red(`[${this.name}] Tool ${result.tool} failed: ${content}`));
@@ -1920,7 +2883,8 @@ var SubAgent = class {
     }
     return void 0;
   }
-};
+}, _class3);
+
 
 
 
@@ -1929,14 +2893,22 @@ var SubAgent = class {
 
 
 
-exports.createToolFilter = createToolFilter; exports.filterToolsByRelevance = filterToolsByRelevance; exports.DEFAULT_TOOL_DEFINITIONS = DEFAULT_TOOL_DEFINITIONS; exports.ToolManager = ToolManager; exports.SubAgent = SubAgent; exports.AgentDelegator = AgentDelegator;
+
+
+
+
+
+exports.normalizePermissionPromptResponse = normalizePermissionPromptResponse; exports.isAllowedPermissionPrompt = isAllowedPermissionPrompt; exports.createToolFilter = createToolFilter; exports.filterToolsByRelevance = filterToolsByRelevance; exports.formatToolCapabilityCatalog = formatToolCapabilityCatalog; exports.GOAL_TOOL_DEFINITIONS = GOAL_TOOL_DEFINITIONS; exports.DEFAULT_TOOL_DEFINITIONS = DEFAULT_TOOL_DEFINITIONS; exports.PLAN_TOOL_DEFINITION = PLAN_TOOL_DEFINITION; exports.EXIT_PLAN_MODE_TOOL_DEFINITION = EXIT_PLAN_MODE_TOOL_DEFINITION; exports.ToolManager = ToolManager; exports.SubAgent = SubAgent; exports.AgentDelegator = AgentDelegator;
+/**
+ * Permission System Types
+ * @license Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Autohand AI LLC
  * SPDX-License-Identifier: Apache-2.0
  *
  * Tool filtering based on client context and risk categories
- * Inspired by Claude Code's permission model
  */
 /**
  * @license