autohand-cli 0.7.14 → 0.8.2

package/dist/chunk-LENHP55G.cjs

@@ -0,0 +1,1838 @@
+"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 _chunkBVKXEQVGcjs = require('./chunk-BVKXEQVG.cjs');
+
+
+var _chunkCNBKZEX5cjs = require('./chunk-CNBKZEX5.cjs');
+
+
+var _chunkULQ6MDSJcjs = require('./chunk-ULQ6MDSJ.cjs');
+
+// src/core/agents/SubAgent.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+
+// src/core/toolFilter.ts
+var TOOL_CATEGORIES = {
+  // Meta tools
+  tools_registry: "meta",
+  plan: "meta",
+  todo_write: "meta",
+  smart_context_cropper: "meta",
+  save_memory: "meta",
+  recall_memory: "meta",
+  create_meta_tool: "meta",
+  delegate_task: "meta",
+  delegate_parallel: "meta",
+  create_team: "meta",
+  add_teammate: "meta",
+  create_task: "meta",
+  team_status: "meta",
+  send_team_message: "meta",
+  ask_followup_question: "meta",
+  // Read operations
+  read_file: "read",
+  search: "read",
+  search_with_context: "read",
+  semantic_search: "read",
+  list_tree: "read",
+  file_stats: "read",
+  checksum: "read",
+  // Write operations
+  write_file: "write",
+  append_file: "write",
+  apply_patch: "write",
+  search_replace: "write",
+  format_file: "write",
+  multi_file_edit: "write",
+  // Create operations
+  create_directory: "create",
+  copy_path: "create",
+  rename_path: "create",
+  add_dependency: "create",
+  // Delete operations
+  delete_path: "delete",
+  remove_dependency: "delete",
+  // Git read operations
+  git_diff: "git_read",
+  git_status: "git_read",
+  git_list_untracked: "git_read",
+  git_diff_range: "git_read",
+  git_stash_list: "git_read",
+  git_branch: "git_read",
+  git_log: "git_read",
+  git_worktree_list: "git_read",
+  git_worktree_status_all: "git_read",
+  // Git write operations
+  git_checkout: "git_write",
+  git_apply_patch: "git_write",
+  git_worktree_add: "git_write",
+  git_worktree_remove: "git_write",
+  git_worktree_cleanup: "git_write",
+  git_worktree_run_parallel: "git_write",
+  git_worktree_sync: "git_write",
+  git_worktree_create_for_pr: "git_write",
+  git_worktree_create_from_template: "git_write",
+  git_stash: "git_write",
+  git_stash_pop: "git_write",
+  git_stash_apply: "git_write",
+  git_stash_drop: "git_write",
+  git_switch: "git_write",
+  git_cherry_pick: "git_write",
+  git_cherry_pick_abort: "git_write",
+  git_cherry_pick_continue: "git_write",
+  git_rebase: "git_write",
+  git_rebase_abort: "git_write",
+  git_rebase_continue: "git_write",
+  git_rebase_skip: "git_write",
+  git_merge: "git_write",
+  git_merge_abort: "git_write",
+  git_commit: "git_write",
+  git_add: "git_write",
+  git_reset: "git_write",
+  git_fetch: "git_write",
+  git_pull: "git_write",
+  git_push: "git_write",
+  // Shell operations
+  run_command: "shell",
+  custom_command: "shell"
+};
+var CONTEXT_POLICIES = {
+  // CLI: Full access to everything
+  cli: {
+    allowedCategories: ["read", "write", "create", "delete", "git_read", "git_write", "shell", "meta"]
+  },
+  // Slack: Chat-based, no file exploration or shell access
+  // Focuses on answering questions and simple operations
+  slack: {
+    allowedCategories: ["meta", "git_read"],
+    blockedTools: [
+      "list_tree",
+      // Don't expose directory structure
+      "search",
+      // Don't allow broad searches
+      "search_with_context",
+      // Don't allow broad searches
+      "semantic_search",
+      // Don't allow broad searches
+      "run_command",
+      // No shell access
+      "custom_command",
+      // No shell access
+      "file_stats",
+      // Don't expose file metadata
+      "checksum",
+      // Don't expose file checksums
+      "ask_followup_question"
+      // Requires interactive terminal
+    ]
+  },
+  // API: Programmatic access with sensible defaults
+  // Allows most operations except dangerous ones
+  api: {
+    allowedCategories: ["read", "write", "create", "git_read", "git_write", "meta"],
+    blockedTools: [
+      "delete_path",
+      // No deletions via API
+      "run_command",
+      // No shell access
+      "custom_command",
+      // No shell access
+      "git_push",
+      // No pushing via API
+      "git_reset",
+      // No resets via API
+      "ask_followup_question"
+      // Requires interactive terminal
+    ],
+    requireApprovalFor: [
+      "git_commit",
+      "git_merge",
+      "git_rebase"
+    ]
+  },
+  // 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)
+    ]
+  }
+};
+function getToolCategory(toolName) {
+  return _nullishCoalesce(TOOL_CATEGORIES[toolName], () => ( "meta"));
+}
+var ToolFilter = class {
+  constructor(context = "cli", customPolicy) {
+    this.context = context;
+    const basePolicy = CONTEXT_POLICIES[context];
+    this.policy = {
+      ...basePolicy,
+      ...customPolicy,
+      allowedCategories: _nullishCoalesce(_optionalChain([customPolicy, 'optionalAccess', _ => _.allowedCategories]), () => ( basePolicy.allowedCategories)),
+      blockedTools: [
+        ..._nullishCoalesce(basePolicy.blockedTools, () => ( [])),
+        ..._nullishCoalesce(_optionalChain([customPolicy, 'optionalAccess', _2 => _2.blockedTools]), () => ( []))
+      ],
+      allowedTools: _optionalChain([customPolicy, 'optionalAccess', _3 => _3.allowedTools]),
+      requireApprovalFor: [
+        ..._nullishCoalesce(basePolicy.requireApprovalFor, () => ( [])),
+        ..._nullishCoalesce(_optionalChain([customPolicy, 'optionalAccess', _4 => _4.requireApprovalFor]), () => ( []))
+      ]
+    };
+  }
+  /**
+   * Check if a tool is allowed in the current context
+   */
+  isAllowed(toolName) {
+    if (this.policy.allowedTools && this.policy.allowedTools.length > 0) {
+      return this.policy.allowedTools.includes(toolName);
+    }
+    if (_optionalChain([this, 'access', _5 => _5.policy, 'access', _6 => _6.blockedTools, 'optionalAccess', _7 => _7.includes, 'call', _8 => _8(toolName)])) {
+      return false;
+    }
+    const category = getToolCategory(toolName);
+    return this.policy.allowedCategories.includes(category);
+  }
+  /**
+   * Check if a tool requires approval (beyond its default setting)
+   */
+  requiresApproval(toolName, defaultRequiresApproval) {
+    if (_optionalChain([this, 'access', _9 => _9.policy, 'access', _10 => _10.requireApprovalFor, 'optionalAccess', _11 => _11.includes, 'call', _12 => _12(toolName)])) {
+      return true;
+    }
+    return _nullishCoalesce(defaultRequiresApproval, () => ( false));
+  }
+  /**
+   * Filter a list of tool definitions
+   */
+  filterDefinitions(definitions) {
+    return definitions.filter((def) => this.isAllowed(def.name)).map((def) => ({
+      ...def,
+      requiresApproval: this.requiresApproval(def.name, def.requiresApproval)
+    }));
+  }
+  /**
+   * Get the current context
+   */
+  getContext() {
+    return this.context;
+  }
+  /**
+   * Get a summary of what's allowed/blocked for logging
+   */
+  getSummary() {
+    const allTools = Object.keys(TOOL_CATEGORIES);
+    const allowed = allTools.filter((t) => this.isAllowed(t));
+    const blocked = allTools.filter((t) => !this.isAllowed(t));
+    return {
+      allowed,
+      blocked,
+      categories: this.policy.allowedCategories
+    };
+  }
+};
+var RELEVANCE_CATEGORIES = {
+  // Always include
+  read_file: "always",
+  write_file: "always",
+  search: "always",
+  list_tree: "always",
+  plan: "always",
+  run_command: "always",
+  todo_write: "always",
+  // Filesystem
+  append_file: "filesystem",
+  apply_patch: "filesystem",
+  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_with_context: "search",
+  semantic_search: "search",
+  // Basic git
+  git_diff: "git_basic",
+  git_status: "git_basic",
+  git_list_untracked: "git_basic",
+  git_add: "git_basic",
+  git_commit: "git_basic",
+  git_log: "git_basic",
+  git_branch: "git_basic",
+  git_switch: "git_basic",
+  git_checkout: "git_basic",
+  git_diff_range: "git_basic",
+  git_apply_patch: "git_basic",
+  git_fetch: "git_basic",
+  git_pull: "git_basic",
+  git_push: "git_basic",
+  git_stash: "git_basic",
+  git_stash_list: "git_basic",
+  git_stash_pop: "git_basic",
+  git_stash_apply: "git_basic",
+  git_stash_drop: "git_basic",
+  // Advanced git
+  git_merge: "git_advanced",
+  git_merge_abort: "git_advanced",
+  git_rebase: "git_advanced",
+  git_rebase_abort: "git_advanced",
+  git_rebase_continue: "git_advanced",
+  git_rebase_skip: "git_advanced",
+  git_cherry_pick: "git_advanced",
+  git_cherry_pick_abort: "git_advanced",
+  git_cherry_pick_continue: "git_advanced",
+  git_reset: "git_advanced",
+  git_worktree_list: "git_advanced",
+  git_worktree_add: "git_advanced",
+  git_worktree_remove: "git_advanced",
+  git_worktree_status_all: "git_advanced",
+  git_worktree_cleanup: "git_advanced",
+  git_worktree_run_parallel: "git_advanced",
+  git_worktree_sync: "git_advanced",
+  git_worktree_create_for_pr: "git_advanced",
+  git_worktree_create_from_template: "git_advanced",
+  // Dependencies
+  add_dependency: "dependencies",
+  remove_dependency: "dependencies",
+  // Meta
+  tools_registry: "meta",
+  save_memory: "meta",
+  recall_memory: "meta",
+  smart_context_cropper: "meta",
+  create_meta_tool: "meta",
+  custom_command: "meta",
+  delegate_task: "meta",
+  delegate_parallel: "meta",
+  create_team: "meta",
+  add_teammate: "meta",
+  create_task: "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
+};
+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"],
+  meta: [
+    "tool",
+    "delegate",
+    "agent",
+    "remember",
+    "memory",
+    "recall",
+    "team",
+    "teammate",
+    "together",
+    "engineers",
+    "crew",
+    "collaborate"
+  ]
+};
+function detectRelevantCategories(messages) {
+  const categories = /* @__PURE__ */ new Set(["always"]);
+  const recentMessages = messages.slice(-8);
+  const recentText = recentMessages.map((m) => _nullishCoalesce(m.content, () => ( ""))).join(" ").toLowerCase();
+  for (const [category, triggers] of Object.entries(CATEGORY_TRIGGERS)) {
+    if (triggers.some((trigger) => recentText.includes(trigger))) {
+      categories.add(category);
+    }
+  }
+  for (const msg of recentMessages) {
+    if (msg.tool_calls) {
+      for (const call of msg.tool_calls) {
+        const category = RELEVANCE_CATEGORIES[call.function.name];
+        if (category) {
+          categories.add(category);
+        }
+      }
+    }
+    if (msg.role === "tool" && msg.name) {
+      const category = RELEVANCE_CATEGORIES[msg.name];
+      if (category) {
+        categories.add(category);
+      }
+    }
+  }
+  return categories;
+}
+function filterToolsByRelevance(tools, messages) {
+  const relevantCategories = detectRelevantCategories(messages);
+  return tools.filter((tool) => {
+    const category = RELEVANCE_CATEGORIES[tool.name];
+    return !category || relevantCategories.has(category);
+  });
+}
+
+// src/core/toolManager.ts
+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.',
+    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.'
+        }
+      }
+    }
+  },
+  {
+    name: "ask_followup_question",
+    description: "Ask the user a follow-up question to gather clarification or preferences. Use when you need specific information to proceed. Include suggested answers when possible to guide the response. Only available in interactive and plan mode.",
+    parameters: {
+      type: "object",
+      properties: {
+        question: { type: "string", description: "The specific question to ask the user" },
+        suggested_answers: {
+          type: "array",
+          description: "Optional list of 2-4 suggested answers to guide the user response",
+          items: { type: "string", description: "A suggested answer option" }
+        }
+      },
+      required: ["question"]
+    },
+    requiresApproval: false
+    // User interaction, not a mutation
+  },
+  {
+    name: "read_file",
+    description: "Read file contents. For large files (>2500 lines), use offset and limit to read in chunks.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the file to read" },
+        offset: { type: "number", description: "Line number to start reading from (0-indexed). Use for large files." },
+        limit: { type: "number", description: "Maximum number of lines to read. Use for large files." }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "write_file",
+    description: "Write full contents to a file",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the file" },
+        contents: { type: "string", description: "Full file contents to write" }
+      },
+      required: ["path", "contents"]
+    }
+  },
+  {
+    name: "append_file",
+    description: "Append text to a file",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the file" },
+        contents: { type: "string", description: "Text to append" }
+      },
+      required: ["path", "contents"]
+    }
+  },
+  {
+    name: "apply_patch",
+    description: "Apply a unified diff to a file",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the file" },
+        patch: { type: "string", description: "Unified diff patch content" }
+      },
+      required: ["path", "patch"]
+    }
+  },
+  {
+    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",
+    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)" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "semantic_search",
+    description: "Search workspace text semantically with gitignore awareness",
+    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)" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "create_directory",
+    description: "Create a directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path for new directory" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "delete_path",
+    description: "Remove files or directories from the workspace",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to delete" }
+      },
+      required: ["path"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "rename_path",
+    description: "Rename a file or directory",
+    parameters: {
+      type: "object",
+      properties: {
+        from: { type: "string", description: "Current relative path" },
+        to: { type: "string", description: "New relative path" }
+      },
+      required: ["from", "to"]
+    }
+  },
+  {
+    name: "copy_path",
+    description: "Copy a file or directory",
+    parameters: {
+      type: "object",
+      properties: {
+        from: { type: "string", description: "Source relative path" },
+        to: { type: "string", description: "Destination relative path" }
+      },
+      required: ["from", "to"]
+    }
+  },
+  {
+    name: "search_replace",
+    description: "Apply precise text replacements using SEARCH/REPLACE blocks. SEARCH must match exactly. Multiple blocks applied in sequence.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path" },
+        blocks: { type: "string", description: "SEARCH/REPLACE block content" }
+      },
+      required: ["path", "blocks"]
+    }
+  },
+  {
+    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.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "Command to execute" },
+        args: { type: "array", description: "Command arguments", 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)" }
+      },
+      required: ["command"]
+    },
+    requiresApproval: true,
+    approvalMessage: "Allow the agent to run a shell command?"
+  },
+  {
+    name: "add_dependency",
+    description: "Add a package dependency (supports dev flag)",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Package name" },
+        version: { type: "string", description: "Version specifier" },
+        dev: { type: "boolean", description: "Install as dev dependency" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "remove_dependency",
+    description: "Remove a package dependency (supports dev flag)",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Package name" },
+        dev: { type: "boolean", description: "Remove from dev dependencies" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "format_file",
+    description: "Format a file with a named formatter",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the file" },
+        formatter: { type: "string", description: "Formatter name (prettier, eslint, etc.)" }
+      },
+      required: ["path", "formatter"]
+    }
+  },
+  {
+    name: "list_tree",
+    description: "List a directory tree for the workspace",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path (default: workspace root)" },
+        depth: { type: "number", description: "Maximum depth (default: 2)" }
+      }
+    }
+  },
+  {
+    name: "file_stats",
+    description: "Return file statistics and metadata",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the file" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "checksum",
+    description: "Compute a checksum for a file",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the file" },
+        algorithm: { type: "string", description: "Hash algorithm (default: sha256)" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "git_diff",
+    description: "Show git diff for a file",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the file" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "git_checkout",
+    description: "Restore a file from git",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path to the file" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "git_status",
+    description: "Show git status for the workspace"
+  },
+  {
+    name: "git_list_untracked",
+    description: "List untracked git files"
+  },
+  {
+    name: "git_diff_range",
+    description: "Show git diff for a range or staged files",
+    parameters: {
+      type: "object",
+      properties: {
+        range: { type: "string", description: "Commit range (e.g., HEAD~3..HEAD)" },
+        staged: { type: "boolean", description: "Show staged changes only" },
+        paths: { type: "array", description: "Specific paths to diff", items: { type: "string", description: "Path to diff" } }
+      }
+    }
+  },
+  {
+    name: "git_apply_patch",
+    description: "Apply a git patch to the working tree",
+    parameters: {
+      type: "object",
+      properties: {
+        patch: { type: "string", description: "Git patch content" }
+      },
+      required: ["patch"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_worktree_list",
+    description: "List git worktrees"
+  },
+  {
+    name: "git_worktree_add",
+    description: "Add a git worktree (may modify git state)",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path for the new worktree" },
+        ref: { type: "string", description: "Branch or commit to checkout" }
+      },
+      required: ["path"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_worktree_remove",
+    description: "Remove a git worktree",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path of the worktree to remove" },
+        force: { type: "boolean", description: "Force removal" }
+      },
+      required: ["path"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_worktree_status_all",
+    description: "Get comprehensive status of all worktrees (changes, commits, sync state)"
+  },
+  {
+    name: "git_worktree_cleanup",
+    description: "Find and clean up stale/merged worktrees",
+    parameters: {
+      type: "object",
+      properties: {
+        dry_run: { type: "boolean", description: "Preview without removing" },
+        remove_merged: { type: "boolean", description: "Remove merged branches" },
+        remove_stale: { type: "boolean", description: "Remove stale worktrees" }
+      }
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_worktree_run_parallel",
+    description: "Run a command in parallel across all worktrees",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "Command to run" },
+        timeout: { type: "number", description: "Timeout in ms" },
+        max_concurrent: { type: "number", description: "Max parallel executions" }
+      },
+      required: ["command"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_worktree_sync",
+    description: "Sync changes from main branch to all worktrees (rebase or merge)",
+    parameters: {
+      type: "object",
+      properties: {
+        strategy: { type: "string", description: "Sync strategy: rebase or merge" },
+        main_branch: { type: "string", description: "Main branch name" },
+        dry_run: { type: "boolean", description: "Preview without syncing" }
+      }
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_worktree_create_for_pr",
+    description: "Create a worktree for reviewing a specific PR",
+    parameters: {
+      type: "object",
+      properties: {
+        pr_number: { type: "number", description: "PR number" },
+        remote: { type: "string", description: "Remote name (default: origin)" }
+      },
+      required: ["pr_number"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_worktree_create_from_template",
+    description: "Create a worktree using a template (feature, hotfix, release, review, experiment)",
+    parameters: {
+      type: "object",
+      properties: {
+        template: { type: "string", description: "Template name" },
+        branch: { type: "string", description: "Branch name for the worktree" },
+        base_branch: { type: "string", description: "Base branch to branch from" },
+        run_setup: { type: "boolean", description: "Run setup commands" }
+      },
+      required: ["template", "branch"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_stash",
+    description: "Stash current changes (supports message, include-untracked, keep-index)",
+    parameters: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "Stash message" },
+        include_untracked: { type: "boolean", description: "Include untracked files" },
+        keep_index: { type: "boolean", description: "Keep staged changes" }
+      }
+    }
+  },
+  {
+    name: "git_stash_list",
+    description: "List all stashed changes"
+  },
+  {
+    name: "git_stash_pop",
+    description: "Apply and remove the most recent stash (or specified stash)",
+    parameters: {
+      type: "object",
+      properties: {
+        stash_ref: { type: "string", description: "Stash reference (e.g., stash@{0})" }
+      }
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_stash_apply",
+    description: "Apply a stash without removing it",
+    parameters: {
+      type: "object",
+      properties: {
+        stash_ref: { type: "string", description: "Stash reference (e.g., stash@{0})" }
+      }
+    }
+  },
+  {
+    name: "git_stash_drop",
+    description: "Drop a stash entry",
+    parameters: {
+      type: "object",
+      properties: {
+        stash_ref: { type: "string", description: "Stash reference (e.g., stash@{0})" }
+      }
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_branch",
+    description: "List or create/delete branches",
+    parameters: {
+      type: "object",
+      properties: {
+        branch_name: { type: "string", description: "Branch name (omit to list)" },
+        delete: { type: "boolean", description: "Delete the branch" },
+        force: { type: "boolean", description: "Force delete" }
+      }
+    }
+  },
+  {
+    name: "git_switch",
+    description: "Switch to a branch (can create with -c flag)",
+    parameters: {
+      type: "object",
+      properties: {
+        branch_name: { type: "string", description: "Branch to switch to" },
+        create: { type: "boolean", description: "Create new branch" }
+      },
+      required: ["branch_name"]
+    }
+  },
+  {
+    name: "git_cherry_pick",
+    description: "Cherry-pick commits onto current branch",
+    parameters: {
+      type: "object",
+      properties: {
+        commits: { type: "array", description: "Commit SHAs to cherry-pick", items: { type: "string", description: "Commit SHA" } },
+        no_commit: { type: "boolean", description: "Apply without committing" },
+        mainline: { type: "number", description: "Parent number for merge commits" }
+      },
+      required: ["commits"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_cherry_pick_abort",
+    description: "Abort an in-progress cherry-pick"
+  },
+  {
+    name: "git_cherry_pick_continue",
+    description: "Continue an in-progress cherry-pick after resolving conflicts"
+  },
+  {
+    name: "git_rebase",
+    description: "Rebase current branch onto another (non-interactive)",
+    parameters: {
+      type: "object",
+      properties: {
+        upstream: { type: "string", description: "Upstream branch to rebase onto" },
+        onto: { type: "string", description: "New base commit" },
+        autosquash: { type: "boolean", description: "Auto-squash fixup commits" }
+      },
+      required: ["upstream"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_rebase_abort",
+    description: "Abort an in-progress rebase"
+  },
+  {
+    name: "git_rebase_continue",
+    description: "Continue an in-progress rebase after resolving conflicts"
+  },
+  {
+    name: "git_rebase_skip",
+    description: "Skip the current commit during a rebase"
+  },
+  {
+    name: "git_merge",
+    description: "Merge a branch into current branch",
+    parameters: {
+      type: "object",
+      properties: {
+        branch: { type: "string", description: "Branch to merge" },
+        no_commit: { type: "boolean", description: "Merge without committing" },
+        no_ff: { type: "boolean", description: "No fast-forward" },
+        squash: { type: "boolean", description: "Squash commits" },
+        message: { type: "string", description: "Merge commit message" }
+      },
+      required: ["branch"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_merge_abort",
+    description: "Abort an in-progress merge"
+  },
+  {
+    name: "git_commit",
+    description: "Create a commit with the staged changes",
+    parameters: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "Commit message" },
+        amend: { type: "boolean", description: "Amend previous commit" },
+        allow_empty: { type: "boolean", description: "Allow empty commit" }
+      },
+      required: ["message"]
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_add",
+    description: "Stage files for commit",
+    parameters: {
+      type: "object",
+      properties: {
+        paths: { type: "array", description: "Paths to stage (default: all)", items: { type: "string", description: "Path to stage" } }
+      }
+    }
+  },
+  {
+    name: "git_reset",
+    description: "Reset HEAD and/or working tree (soft/mixed/hard)",
+    parameters: {
+      type: "object",
+      properties: {
+        mode: { type: "string", description: "Reset mode: soft, mixed, or hard", enum: ["soft", "mixed", "hard"] },
+        ref: { type: "string", description: "Commit reference to reset to" }
+      }
+    },
+    requiresApproval: true
+  },
+  {
+    name: "auto_commit",
+    description: "Automatically stage all changes and create a commit. In interactive mode, user can accept/edit/reject the message. In yes/non-interactive mode, commits immediately with the suggested or provided message.",
+    parameters: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "Optional commit message (auto-generated if not provided)" },
+        stage_all: { type: "boolean", description: "Stage all changes before committing (default: true)" }
+      }
+    },
+    requiresApproval: false
+    // Interactive flow prompts inside the tool; yes/non-interactive auto-approves
+  },
+  {
+    name: "git_log",
+    description: "Show commit history",
+    parameters: {
+      type: "object",
+      properties: {
+        max_count: { type: "number", description: "Maximum commits to show" },
+        oneline: { type: "boolean", description: "One line per commit" },
+        graph: { type: "boolean", description: "Show branch graph" },
+        all: { type: "boolean", description: "Show all branches" }
+      }
+    }
+  },
+  {
+    name: "git_fetch",
+    description: "Fetch from remote repository",
+    parameters: {
+      type: "object",
+      properties: {
+        remote: { type: "string", description: "Remote name (default: origin)" },
+        branch: { type: "string", description: "Branch to fetch" }
+      }
+    }
+  },
+  {
+    name: "git_pull",
+    description: "Pull changes from remote",
+    parameters: {
+      type: "object",
+      properties: {
+        remote: { type: "string", description: "Remote name (default: origin)" },
+        branch: { type: "string", description: "Branch to pull" }
+      }
+    },
+    requiresApproval: true
+  },
+  {
+    name: "git_push",
+    description: "Push changes to remote",
+    parameters: {
+      type: "object",
+      properties: {
+        remote: { type: "string", description: "Remote name (default: origin)" },
+        branch: { type: "string", description: "Branch to push" },
+        force: { type: "boolean", description: "Force push" },
+        set_upstream: { type: "boolean", description: "Set upstream tracking" }
+      }
+    },
+    requiresApproval: true
+  },
+  {
+    name: "custom_command",
+    description: "Define and execute a one-off command (saved for reuse)",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Command name for reuse" },
+        command: { type: "string", description: "Shell command" },
+        args: { type: "array", description: "Command arguments", items: { type: "string", description: "Single argument" } },
+        description: { type: "string", description: "Command description" },
+        dangerous: { type: "boolean", description: "Mark as dangerous" }
+      },
+      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).",
+    parameters: {
+      type: "object",
+      properties: {
+        tasks: {
+          type: "array",
+          description: "The complete updated todo list with all tasks and their current statuses",
+          items: {
+            type: "object",
+            properties: {
+              content: { type: "string", description: "Task description (what needs to be done)" },
+              status: { type: "string", enum: ["pending", "in_progress", "completed"], description: "Current task status" },
+              activeForm: { type: "string", description: 'Present continuous form shown during execution (e.g., "Running tests")' }
+            },
+            required: ["content", "status", "activeForm"]
+          }
+        }
+      },
+      required: ["tasks"]
+    }
+  },
+  {
+    name: "smart_context_cropper",
+    description: "Trim conversation history when context is full",
+    parameters: {
+      type: "object",
+      properties: {
+        crop_direction: { type: "string", description: "Direction: top or bottom", enum: ["top", "bottom"] },
+        crop_amount: { type: "number", description: "Number of messages to crop" },
+        need_user_approve: { type: "boolean", description: "Ask user for approval" },
+        deleted_messages_summary: { type: "string", description: "Summary of cropped content" }
+      },
+      required: ["crop_direction", "crop_amount"]
+    }
+  },
+  {
+    name: "save_memory",
+    description: "Save a fact or preference to memory for recall in future sessions. Use for important user preferences, project conventions, or key information worth remembering.",
+    parameters: {
+      type: "object",
+      properties: {
+        fact: { type: "string", description: "The fact or preference to remember. Should be a clear, self-contained statement." },
+        level: { type: "string", description: 'Storage level: "user" (global across projects) or "project" (specific to current workspace)', enum: ["user", "project"] }
+      },
+      required: ["fact"]
+    }
+  },
+  {
+    name: "recall_memory",
+    description: "Recall stored memories and preferences. Use to check what preferences are already saved or to find specific information.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Optional search query to filter memories. If omitted, returns all memories." },
+        level: { type: "string", description: 'Filter by level: "user" (global) or "project" (workspace-specific). If omitted, returns both.', enum: ["user", "project"] }
+      },
+      required: []
+    }
+  },
+  {
+    name: "create_meta_tool",
+    description: "Create a new reusable tool that persists across sessions. Use for automating repetitive shell commands or extending capabilities.",
+    parameters: {
+      type: "object",
+      properties: {
+        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}}")' }
+      },
+      required: ["name", "description", "parameters", "handler"]
+    }
+  },
+  // Web Search Operations
+  {
+    name: "web_search",
+    description: "Search the web for up-to-date information about packages, libraries, frameworks, documentation, changelogs, and more. Use this when you need current information that may have changed after your training data.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: 'Search query (e.g., "react 19 new features", "zod changelog latest")' },
+        max_results: { type: "number", description: "Maximum results to return (default: 5)" },
+        search_type: { type: "string", description: "Type of search: general, packages, docs, changelog", enum: ["general", "packages", "docs", "changelog"] }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "fetch_url",
+    description: "Fetch and extract text content from a URL. Useful for reading documentation, changelogs, release notes, or any web page.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL to fetch" },
+        max_length: { type: "number", description: "Maximum characters to return (default: 30000)" }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "package_info",
+    description: "Get detailed information about a package from npm, PyPI (Python), crates.io (Rust), Go modules, or RubyGems. Auto-detects registry or specify explicitly.",
+    parameters: {
+      type: "object",
+      properties: {
+        package_name: { type: "string", description: 'Package name (e.g., "react", "requests", "serde", "github.com/gin-gonic/gin")' },
+        registry: { type: "string", description: "Package registry: npm, pypi, crates, go, rubygems (auto-detected if not specified)", enum: ["npm", "pypi", "crates", "go", "rubygems"] },
+        version: { type: "string", description: "Specific version to get info for (default: latest)" }
+      },
+      required: ["package_name"]
+    }
+  },
+  {
+    name: "web_repo",
+    description: `Browse GitHub and GitLab repositories. Supports three operations:
+
+- 'info': Get repo metadata (description, stars, language, license, default branch)
+- 'list': List directory contents (files and folders at a path)
+- 'fetch': Get raw file content (defaults to README.md)
+
+Repo formats: Full URL (https://github.com/owner/repo), or shorthand (github:owner/repo, gitlab:group/project).
+
+Examples:
+  { repo: "github:openai/codex", operation: "info" }
+  { repo: "gitlab:inkscape/inkscape", operation: "list", path: "src" }
+  { repo: "github:openai/codex", operation: "fetch", path: "codex-cli/src/utils.ts" }`,
+    parameters: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository URL or shorthand (github:owner/repo, gitlab:group/project)" },
+        operation: { type: "string", description: "Operation to perform", enum: ["info", "list", "fetch"] },
+        path: { type: "string", description: "File/directory path (default: root for list, README.md for fetch)" },
+        branch: { type: "string", description: "Branch name (default: repo default branch)" }
+      },
+      required: ["repo", "operation"]
+    }
+  },
+  // Skills Discovery
+  {
+    name: "find_agent_skills",
+    description: "Search the community skills registry for agent skills that match a query. Returns skills with name, description, category, languages, and frameworks. Use this to discover skills that could help with the current task or project.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: 'Search terms \u2014 skill name, language, framework, or use-case (e.g. "react testing", "python api", "docker deployment")' },
+        category: { type: "string", description: 'Optional category filter (e.g. "languages", "frameworks", "workflows", "testing")' },
+        limit: { type: "number", description: "Maximum results to return (default: 10, max: 20)" }
+      },
+      required: ["query"]
+    }
+  }
+];
+var ToolManager = class _ToolManager {
+  constructor(options) {
+    this.definitions = /* @__PURE__ */ new Map();
+    this.executor = options.executor;
+    this.confirmApproval = options.confirmApproval;
+    this.toolFilter = new ToolFilter(_nullishCoalesce(options.clientContext, () => ( "cli")), options.customPolicy);
+    const defs = _nullishCoalesce(options.definitions, () => ( DEFAULT_TOOL_DEFINITIONS));
+    for (const def of defs) {
+      this.register(def);
+    }
+  }
+  register(definition) {
+    this.definitions.set(definition.name, definition);
+  }
+  /**
+   * 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)) {
+        continue;
+      }
+      this.definitions.set(def.name, def);
+    }
+  }
+  /**
+   * Replace all MCP tools (mcp__*) with a fresh set.
+   * Keeps built-ins and non-MCP meta-tools intact.
+   */
+  replaceMcpTools(toolDefinitions) {
+    for (const name of Array.from(this.definitions.keys())) {
+      if (name.startsWith("mcp__")) {
+        this.definitions.delete(name);
+      }
+    }
+    this.registerMetaTools(toolDefinitions);
+  }
+  /**
+   * Check if a tool name conflicts with built-in definitions
+   */
+  isBuiltInTool(name) {
+    return DEFAULT_TOOL_DEFINITIONS.some((d) => d.name === name);
+  }
+  listToolNames() {
+    return Array.from(this.definitions.keys()).filter((name) => this.toolFilter.isAllowed(name));
+  }
+  /**
+   * List all tool definitions (unfiltered)
+   */
+  listAllDefinitions() {
+    return Array.from(this.definitions.values());
+  }
+  /**
+   * List tool definitions filtered by client context
+   */
+  listDefinitions() {
+    return this.toolFilter.filterDefinitions(Array.from(this.definitions.values()));
+  }
+  /**
+   * Get the current tool filter
+   */
+  getFilter() {
+    return this.toolFilter;
+  }
+  /**
+   * Check if a specific tool is allowed in the current context
+   */
+  isToolAllowed(toolName) {
+    return this.toolFilter.isAllowed(toolName);
+  }
+  /**
+   * Convert tool definitions to FunctionDefinition format for LLM function calling
+   * This is used when passing tools to the LLM API
+   */
+  toFunctionDefinitions() {
+    return this.listDefinitions().map((def) => _ToolManager.toFunctionDefinition(def));
+  }
+  /**
+   * Convert a single tool definition to FunctionDefinition format
+   */
+  static toFunctionDefinition(def) {
+    return {
+      name: def.name,
+      description: def.description,
+      parameters: def.parameters ? {
+        type: "object",
+        properties: Object.fromEntries(
+          Object.entries(def.parameters.properties).map(([key, param]) => [
+            key,
+            {
+              type: param.type,
+              description: param.description,
+              enum: param.enum,
+              items: param.type === "array" ? _ToolManager.normalizeItemsStatic(param.items) : void 0,
+              properties: param.type === "object" ? _ToolManager.normalizeObjectPropertiesStatic(
+                param.properties
+              ) : void 0,
+              required: param.type === "object" && Array.isArray(param.required) ? param.required : void 0,
+              additionalProperties: param.type === "object" ? true : void 0
+            }
+          ])
+        ),
+        required: def.parameters.required
+      } : void 0
+    };
+  }
+  static normalizeItemsStatic(items) {
+    if (!items) return { type: "string" };
+    if (items.type !== "object") {
+      return { type: items.type, description: items.description, enum: items.enum };
+    }
+    const objItems = items;
+    return {
+      type: "object",
+      description: items.description,
+      properties: _ToolManager.normalizeObjectPropertiesStatic(objItems.properties),
+      required: objItems.required,
+      additionalProperties: true
+    };
+  }
+  static normalizeObjectPropertiesStatic(props) {
+    const safeProps = _nullishCoalesce(props, () => ( {}));
+    return Object.fromEntries(
+      Object.entries(safeProps).map(([k, v]) => [
+        k,
+        {
+          type: v.type,
+          description: v.description,
+          enum: v.enum,
+          items: v.type === "array" ? _ToolManager.normalizeItemsStatic(v.items) : void 0,
+          properties: v.type === "object" ? _ToolManager.normalizeObjectPropertiesStatic(v.properties) : void 0,
+          required: v.type === "object" && Array.isArray(v.required) ? v.required : void 0,
+          additionalProperties: v.type === "object" ? true : void 0
+        }
+      ])
+    );
+  }
+  async execute(toolCalls) {
+    const results = [];
+    const planModeManager = _chunkULQ6MDSJcjs.getPlanModeManager.call(void 0, );
+    const isInPlanningPhase = planModeManager.isEnabled() && planModeManager.getPhase() === "planning";
+    const readOnlyTools = isInPlanningPhase ? new Set(planModeManager.getReadOnlyTools()) : null;
+    for (const call of toolCalls) {
+      if (!this.toolFilter.isAllowed(call.tool)) {
+        results.push({
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' is not available in the current context (${this.toolFilter.getContext()})`
+        });
+        continue;
+      }
+      if (readOnlyTools && !readOnlyTools.has(call.tool)) {
+        results.push({
+          tool: call.tool,
+          success: false,
+          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.`
+        });
+        continue;
+      }
+      const definition = this.definitions.get(call.tool);
+      const requiresApproval = this.toolFilter.requiresApproval(call.tool, _optionalChain([definition, 'optionalAccess', _13 => _13.requiresApproval]));
+      if (requiresApproval) {
+        let message = _nullishCoalesce(_optionalChain([definition, 'optionalAccess', _14 => _14.approvalMessage]), () => ( `Allow tool ${call.tool}?`));
+        const permContext = { tool: call.tool };
+        if (call.tool === "run_command" && 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 command${dir}?
+  $ ${fullCommand}`;
+          permContext.command = fullCommand;
+        } else if (call.tool === "delete_path" && _optionalChain([call, 'access', _15 => _15.args, 'optionalAccess', _16 => _16.path])) {
+          message = `Delete this path?
+  ${call.args.path}`;
+          permContext.path = String(call.args.path);
+        } else if (call.tool === "write_file" && _optionalChain([call, 'access', _17 => _17.args, 'optionalAccess', _18 => _18.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', _19 => _19.args, 'optionalAccess', _20 => _20.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) {
+          results.push({
+            tool: call.tool,
+            success: false,
+            output: "Tool execution skipped by user."
+          });
+          continue;
+        }
+      }
+      try {
+        const action = this.toAction(call);
+        const output = await this.executor(action, { toolCallId: call.id, tool: call.tool });
+        results.push({
+          tool: call.tool,
+          success: true,
+          output
+        });
+      } catch (error) {
+        results.push({
+          tool: call.tool,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return results;
+  }
+  toAction(call) {
+    return {
+      type: call.tool,
+      ..._nullishCoalesce(call.args, () => ( {}))
+    };
+  }
+};
+
+// src/core/agents/AgentDelegator.ts
+
+var DEFAULT_MAX_DEPTH = 3;
+var AgentDelegator = class {
+  constructor(llm, actionExecutor, options = {}) {
+    this.llm = llm;
+    this.actionExecutor = actionExecutor;
+    this.subagentCounter = 0;
+    this.registry = _chunkBVKXEQVGcjs.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;
+  }
+  generateSubagentId() {
+    return `subagent-${Date.now()}-${++this.subagentCounter}`;
+  }
+  async delegateTask(agentName, task) {
+    if (this.currentDepth >= this.maxDepth) {
+      return `Error: Maximum delegation depth (${this.maxDepth}) reached. Cannot delegate to '${agentName}'.`;
+    }
+    await this.registry.loadAgents();
+    const agentConfig = this.registry.getAgent(agentName);
+    if (!agentConfig) {
+      return `Error: Agent '${agentName}' not found. Use /agents to list available agents.`;
+    }
+    const subAgentOptions = {
+      clientContext: this.clientContext,
+      depth: this.currentDepth + 1,
+      maxDepth: this.maxDepth
+    };
+    const subagentId = this.generateSubagentId();
+    const startTime = Date.now();
+    const agent = new SubAgent(agentConfig, this.llm, this.actionExecutor, subAgentOptions);
+    try {
+      const result = await agent.run(task);
+      if (this.onSubagentStop) {
+        await this.onSubagentStop({
+          subagentId,
+          subagentName: agentName,
+          subagentType: _nullishCoalesce(agentConfig.source, () => ( "user")),
+          success: true,
+          duration: Date.now() - startTime
+        });
+      }
+      return result;
+    } catch (error) {
+      const errorMessage = error.message;
+      if (this.onSubagentStop) {
+        await this.onSubagentStop({
+          subagentId,
+          subagentName: agentName,
+          subagentType: _nullishCoalesce(agentConfig.source, () => ( "user")),
+          success: false,
+          error: errorMessage,
+          duration: Date.now() - startTime
+        });
+      }
+      return `Error running agent '${agentName}': ${errorMessage}`;
+    }
+  }
+  async delegateParallel(tasks) {
+    if (this.currentDepth >= this.maxDepth) {
+      return `Error: Maximum delegation depth (${this.maxDepth}) reached. Cannot delegate parallel tasks.`;
+    }
+    if (tasks.length > 5) {
+      return `Error: Maximum 5 parallel agents allowed. You requested ${tasks.length}.`;
+    }
+    await this.registry.loadAgents();
+    const subAgentOptions = {
+      clientContext: this.clientContext,
+      depth: this.currentDepth + 1,
+      maxDepth: this.maxDepth
+    };
+    const promises = tasks.map(async ({ agent_name, task }) => {
+      const agentConfig = this.registry.getAgent(agent_name);
+      if (!agentConfig) {
+        return `[${agent_name}] Error: Agent not found.`;
+      }
+      const subagentId = this.generateSubagentId();
+      const startTime = Date.now();
+      const agent = new SubAgent(agentConfig, this.llm, this.actionExecutor, subAgentOptions);
+      try {
+        const result = await agent.run(task);
+        if (this.onSubagentStop) {
+          await this.onSubagentStop({
+            subagentId,
+            subagentName: agent_name,
+            subagentType: _nullishCoalesce(agentConfig.source, () => ( "user")),
+            success: true,
+            duration: Date.now() - startTime
+          });
+        }
+        return `[${agent_name}] Result:
+${result}`;
+      } catch (error) {
+        const errorMessage = error.message;
+        if (this.onSubagentStop) {
+          await this.onSubagentStop({
+            subagentId,
+            subagentName: agent_name,
+            subagentType: _nullishCoalesce(agentConfig.source, () => ( "user")),
+            success: false,
+            error: errorMessage,
+            duration: Date.now() - startTime
+          });
+        }
+        return `[${agent_name}] Failed: ${errorMessage}`;
+      }
+    });
+    const results = await Promise.all(promises);
+    return results.join("\n\n" + _chalk2.default.gray("\u2500".repeat(40)) + "\n\n");
+  }
+  /**
+   * Get the current delegation depth
+   */
+  getDepth() {
+    return this.currentDepth;
+  }
+  /**
+   * Check if further delegation is allowed
+   */
+  canDelegate() {
+    return this.currentDepth < this.maxDepth;
+  }
+};
+
+// src/core/agents/SubAgent.ts
+var DELEGATION_TOOL_DEFINITIONS = [
+  {
+    name: "delegate_task",
+    description: "Delegate a task to another specialized sub-agent",
+    parameters: {
+      type: "object",
+      properties: {
+        agent_name: { type: "string", description: "Name of the agent to delegate to" },
+        task: { type: "string", description: "Task description for the sub-agent" }
+      },
+      required: ["agent_name", "task"]
+    }
+  },
+  {
+    name: "delegate_parallel",
+    description: "Run multiple sub-agents in parallel (max 5)",
+    parameters: {
+      type: "object",
+      properties: {
+        tasks: { type: "array", description: "Array of {agent_name, task} objects" }
+      },
+      required: ["tasks"]
+    }
+  }
+];
+var SubAgent = class {
+  constructor(config, llm, actionExecutor, options) {
+    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));
+    if (canDelegate) {
+      definitions = [...definitions, ...DELEGATION_TOOL_DEFINITIONS];
+    }
+    const toolFilter = new ToolFilter(options.clientContext);
+    definitions = toolFilter.filterDefinitions(definitions);
+    if (canDelegate) {
+      this.delegator = new AgentDelegator(llm, actionExecutor, {
+        clientContext: options.clientContext,
+        currentDepth: options.depth,
+        maxDepth: options.maxDepth
+      });
+    }
+    this.toolManager = new ToolManager({
+      executor: async (action, context) => {
+        if (action.type === "delegate_task" && this.delegator) {
+          return this.delegator.delegateTask(
+            action.agent_name,
+            action.task
+          );
+        }
+        if (action.type === "delegate_parallel" && this.delegator) {
+          return this.delegator.delegateParallel(action.tasks);
+        }
+        return this.actionExecutor.execute(action, context);
+      },
+      confirmApproval: async () => true,
+      // Sub-agents auto-approve (inherit from main agent in future)
+      definitions,
+      clientContext: options.clientContext
+    });
+    const enhancedSystemPrompt = this.buildSystemPrompt(config.systemPrompt, definitions);
+    this.conversation = new (0, _chunkCNBKZEX5cjs.ConversationManager)();
+    this.conversation.reset(enhancedSystemPrompt);
+  }
+  /**
+   * Build system prompt with tool signatures for the LLM
+   */
+  buildSystemPrompt(basePrompt, tools) {
+    const toolSignatures = tools.map((def) => this.formatToolSignature(def)).join("\n");
+    return [
+      basePrompt,
+      "",
+      "## Available Tools",
+      "You have access to the following tools. Use them when needed:",
+      "",
+      toolSignatures,
+      "",
+      "## Response Format",
+      "Always respond with structured JSON:",
+      "```json",
+      "{",
+      '  "thought": "Your reasoning about what to do next",',
+      '  "toolCalls": [{"tool": "tool_name", "args": {...}}],',
+      '  "finalResponse": "Your final answer when done (omit toolCalls if providing this)"',
+      "}",
+      "```",
+      "",
+      `Depth: ${this.options.depth}/${this.options.maxDepth} ${this.delegator ? "(can delegate further)" : "(max depth reached)"}`
+    ].join("\n");
+  }
+  /**
+   * Format a tool definition as a signature string
+   */
+  formatToolSignature(def) {
+    const params = _optionalChain([def, 'access', _21 => _21.parameters, 'optionalAccess', _22 => _22.properties]) ? Object.entries(def.parameters.properties).map(([name, prop]) => {
+      const required = _optionalChain([def, 'access', _23 => _23.parameters, 'optionalAccess', _24 => _24.required, 'optionalAccess', _25 => _25.includes, 'call', _26 => _26(name)]) ? "" : "?";
+      return `${name}${required}: ${prop.type}`;
+    }).join(", ") : "";
+    return `- ${def.name}(${params}): ${def.description}`;
+  }
+  async run(task) {
+    console.log(_chalk2.default.cyan(`
+\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 maxIterations = 10;
+    for (let i = 0; i < maxIterations; i++) {
+      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
+      });
+      const payload = this.parseResponse(completion);
+      if (_optionalChain([completion, 'access', _27 => _27.toolCalls, 'optionalAccess', _28 => _28.length])) {
+        this.conversation.addMessage({
+          role: "assistant",
+          content: completion.content || ""
+        });
+      } else {
+        this.conversation.addMessage({ role: "assistant", content: completion.content });
+      }
+      if (payload.thought) {
+        console.log(_chalk2.default.gray(`[${this.name}] ${payload.thought}`));
+      }
+      if (payload.toolCalls && payload.toolCalls.length > 0) {
+        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', _29 => _29.toolCalls, 'optionalAccess', _30 => _30[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', _31 => _31.id])
+          });
+          if (!result.success) {
+            console.log(_chalk2.default.red(`[${this.name}] Tool ${result.tool} failed: ${content}`));
+          }
+        }
+        continue;
+      }
+      const response = _nullishCoalesce(_nullishCoalesce(payload.finalResponse, () => ( payload.response)), () => ( completion.content));
+      console.log(_chalk2.default.cyan(`[${this.name}] Finished.`));
+      return response;
+    }
+    return `[${this.name}] Failed to complete task within ${maxIterations} iterations.`;
+  }
+  /**
+   * Parse LLM response, preferring native tool calls over JSON parsing
+   */
+  parseResponse(completion) {
+    if (completion.toolCalls && completion.toolCalls.length > 0) {
+      return {
+        thought: completion.content || void 0,
+        toolCalls: completion.toolCalls.map((tc) => ({
+          tool: tc.function.name,
+          args: this.safeParseJson(tc.function.arguments)
+        }))
+      };
+    }
+    return this.parsePayload(completion.content);
+  }
+  /**
+   * Safely parse JSON, returning empty object on failure
+   */
+  safeParseJson(json) {
+    try {
+      return JSON.parse(json);
+    } catch (e) {
+      return {};
+    }
+  }
+  parsePayload(raw) {
+    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      return { finalResponse: raw.trim() };
+    }
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      const hasExpectedFields = "thought" in parsed || "toolCalls" in parsed || "finalResponse" in parsed || "response" in parsed;
+      if (hasExpectedFields) {
+        return {
+          thought: typeof parsed.thought === "string" ? parsed.thought : void 0,
+          toolCalls: Array.isArray(parsed.toolCalls) ? parsed.toolCalls : void 0,
+          finalResponse: _nullishCoalesce((typeof parsed.finalResponse === "string" ? parsed.finalResponse : void 0), () => ( (typeof parsed.response === "string" ? parsed.response : void 0))),
+          response: typeof parsed.response === "string" ? parsed.response : void 0
+        };
+      }
+      const contentValue = this.extractContentFromJson(parsed);
+      if (contentValue) {
+        return { finalResponse: contentValue };
+      }
+      return { finalResponse: raw.trim() };
+    } catch (e2) {
+      return { finalResponse: raw.trim() };
+    }
+  }
+  /**
+   * Extracts content from non-standard JSON response formats.
+   */
+  extractContentFromJson(parsed) {
+    const contentFields = ["content", "text", "message", "answer", "output", "result", "reply"];
+    for (const field of contentFields) {
+      const value = parsed[field];
+      if (typeof value === "string" && value.trim()) {
+        return value.trim();
+      }
+    }
+    if (parsed.message && typeof parsed.message === "object") {
+      const msg = parsed.message;
+      if (typeof msg.content === "string" && msg.content.trim()) {
+        return msg.content.trim();
+      }
+    }
+    return void 0;
+  }
+};
+
+
+
+
+
+
+
+exports.filterToolsByRelevance = filterToolsByRelevance; exports.DEFAULT_TOOL_DEFINITIONS = DEFAULT_TOOL_DEFINITIONS; exports.ToolManager = ToolManager; exports.SubAgent = SubAgent; exports.AgentDelegator = AgentDelegator;
+/**
+ * @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
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */