@bike4mind/cli 0.2.26-refactor-dry-credit-deduction.18613 → 0.2.26

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-OHEBSPEW.js";
+} from "./chunk-HVF6LOKH.js";
 import {
   ConfigStore
 } from "./chunk-23T2XGSZ.js";
@@ -13,8 +13,8 @@ import {
   selectActiveBackgroundAgents,
   useCliStore
 } from "./chunk-TVW4ZESU.js";
-import "./chunk-Z7PQXS5G.js";
-import "./chunk-3EQCYEKW.js";
+import "./chunk-UA7GLVP3.js";
+import "./chunk-QD65IUNH.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -26,7 +26,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-I7ZMNVAN.js";
+} from "./chunk-MMAOFFE3.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -82,7 +82,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-L42V7DCM.js";
+} from "./chunk-F3HPUK2I.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -3783,6 +3783,7 @@ var DEFAULT_TOOL_CATEGORIES = {
   current_datetime: "auto_approve",
   dice_roll: "auto_approve",
   prompt_enhancement: "auto_approve",
+  find_definition: "auto_approve",
   weather_info: "prompt_default",
   // ===== PROMPT ALWAYS (Dangerous tools) =====
   // These tools can modify files, execute code, or have other dangerous side effects
@@ -6057,8 +6058,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path17 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path17;
+    const path18 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path18;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -7373,8 +7374,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path17 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path17;
+  const path18 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path18;
 }
 async function updateQuestAndReturnMarkdown2(storedImagePath, context) {
   await context.onFinish?.("edit_image", storedImagePath);
@@ -10512,9 +10513,9 @@ async function getFileStats(files, since, filterPath) {
         }
       });
       const result = files.map((file) => {
-        const stat3 = stats.get(file.path);
-        if (stat3) {
-          return { ...file, ...stat3 };
+        const stat4 = stats.get(file.path);
+        if (stat4) {
+          return { ...file, ...stat4 };
         }
         return file;
       });
@@ -10867,6 +10868,486 @@ var QuestStartBodySchema = z139.object({
 // ../../b4m-core/packages/services/dist/src/llm/StatusManager.js
 import throttle from "lodash/throttle.js";
 
+// ../../b4m-core/packages/services/dist/src/conversationContextService/types.js
+var CONVERSATION_CONTEXT_DEFAULTS = {
+  maxEntitiesPerType: 20,
+  entityTTLMs: 60 * 60 * 1e3
+  // 1 hour
+};
+
+// ../../b4m-core/packages/services/dist/src/conversationContextService/extractors/github.js
+var GITHUB_PATTERNS = {
+  // GitHub URL patterns
+  // https://github.com/owner/repo
+  repoUrl: /https?:\/\/github\.com\/([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)(?:\/|$|\s|[)\]>])/gi,
+  // https://github.com/owner/repo/pull/123
+  prUrl: /https?:\/\/github\.com\/([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)\/pull\/(\d+)/gi,
+  // https://github.com/owner/repo/issues/123
+  issueUrl: /https?:\/\/github\.com\/([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)\/issues\/(\d+)/gi,
+  // owner/repo format (e.g., "milliononmars/lumina5")
+  // Must not be preceded by @ (to avoid email-like patterns)
+  // Must not be followed by common file extensions
+  repoSlash: /(?<![/@])([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)(?!\.(?:js|ts|tsx|jsx|json|md|css|html|py|go|rs|java|rb|php|c|cpp|h|hpp))/g
+};
+var GitHubExtractor = class {
+  /**
+   * Extract GitHub entities from text
+   */
+  extract(text, source) {
+    const entities = [];
+    const seenRepos = /* @__PURE__ */ new Set();
+    const seenPRs = /* @__PURE__ */ new Set();
+    const seenIssues = /* @__PURE__ */ new Set();
+    let match;
+    GITHUB_PATTERNS.prUrl.lastIndex = 0;
+    while ((match = GITHUB_PATTERNS.prUrl.exec(text)) !== null) {
+      const [, owner, repo, number] = match;
+      const key = `${owner}/${repo}#${number}`;
+      if (!seenPRs.has(key)) {
+        seenPRs.add(key);
+        entities.push({
+          entity: {
+            type: "github_pr",
+            entity: { owner, repo, number: parseInt(number, 10) }
+          },
+          source
+        });
+        const repoKey = `${owner}/${repo}`;
+        if (!seenRepos.has(repoKey)) {
+          seenRepos.add(repoKey);
+          entities.push({
+            entity: {
+              type: "github_repo",
+              entity: { owner, repo }
+            },
+            source
+          });
+        }
+      }
+    }
+    GITHUB_PATTERNS.issueUrl.lastIndex = 0;
+    while ((match = GITHUB_PATTERNS.issueUrl.exec(text)) !== null) {
+      const [, owner, repo, number] = match;
+      const key = `${owner}/${repo}#${number}`;
+      if (!seenIssues.has(key)) {
+        seenIssues.add(key);
+        entities.push({
+          entity: {
+            type: "github_issue",
+            entity: { owner, repo, number: parseInt(number, 10) }
+          },
+          source
+        });
+        const repoKey = `${owner}/${repo}`;
+        if (!seenRepos.has(repoKey)) {
+          seenRepos.add(repoKey);
+          entities.push({
+            entity: {
+              type: "github_repo",
+              entity: { owner, repo }
+            },
+            source
+          });
+        }
+      }
+    }
+    GITHUB_PATTERNS.repoUrl.lastIndex = 0;
+    while ((match = GITHUB_PATTERNS.repoUrl.exec(text)) !== null) {
+      const [, owner, repo] = match;
+      const key = `${owner}/${repo}`;
+      if (!seenRepos.has(key)) {
+        seenRepos.add(key);
+        entities.push({
+          entity: {
+            type: "github_repo",
+            entity: { owner, repo: repo.replace(/\.git$/, "") }
+          },
+          source
+        });
+      }
+    }
+    GITHUB_PATTERNS.repoSlash.lastIndex = 0;
+    while ((match = GITHUB_PATTERNS.repoSlash.exec(text)) !== null) {
+      const [, owner, repo] = match;
+      if (["http", "https", "git", "ssh", "ftp"].includes(owner.toLowerCase())) {
+        continue;
+      }
+      const skipOwners = [
+        "node_modules",
+        "src",
+        "dist",
+        "build",
+        "lib",
+        "bin",
+        // URL components that shouldn't be treated as owners
+        "github",
+        "com",
+        "www",
+        "api",
+        "raw",
+        "gist"
+      ];
+      const skipRepos = [
+        // GitHub URL path segments that aren't repos
+        "pull",
+        "pulls",
+        "issue",
+        "issues",
+        "blob",
+        "tree",
+        "commit",
+        "commits",
+        "compare",
+        "releases",
+        "tags",
+        "branches",
+        "actions",
+        "settings",
+        "wiki",
+        "projects",
+        "security",
+        "pulse",
+        "graphs",
+        "network"
+      ];
+      if (skipOwners.includes(owner.toLowerCase())) {
+        continue;
+      }
+      if (skipRepos.includes(repo.toLowerCase())) {
+        continue;
+      }
+      const key = `${owner}/${repo}`;
+      if (!seenRepos.has(key)) {
+        seenRepos.add(key);
+        entities.push({
+          entity: {
+            type: "github_repo",
+            entity: { owner, repo: repo.replace(/\.git$/, "") }
+          },
+          source
+        });
+      }
+    }
+    return { entities };
+  }
+};
+var githubExtractor = new GitHubExtractor();
+
+// ../../b4m-core/packages/services/dist/src/conversationContextService/extractors/jira.js
+var SKIP_PROJECT_KEYS = /* @__PURE__ */ new Set([
+  "AT",
+  "IN",
+  "ON",
+  "TO",
+  "OF",
+  "BY",
+  "IS",
+  "IT",
+  "OR",
+  "AS",
+  "AN",
+  "A",
+  "BE",
+  "DO",
+  "GO",
+  "IF",
+  "NO",
+  "SO",
+  "UP",
+  "WE",
+  "MY",
+  "HE",
+  "ME",
+  "THE",
+  "AND",
+  "FOR",
+  "ARE",
+  "BUT",
+  "NOT",
+  "YOU",
+  "ALL",
+  "CAN",
+  "HAD",
+  "HER",
+  "WAS",
+  "ONE",
+  "OUR",
+  "OUT",
+  "HAS",
+  "HIS",
+  "HOW",
+  "ITS",
+  "MAY",
+  "NEW",
+  "NOW",
+  "OLD",
+  "SEE",
+  "WAY",
+  "WHO",
+  "BOY",
+  "DID",
+  "GET",
+  "LET"
+]);
+var JIRA_PATTERNS = {
+  // Jira issue key format: PROJECT-123 (2-10 uppercase letters followed by hyphen and number)
+  // Common Jira project key pattern
+  issueKey: /\b([A-Z][A-Z0-9]{1,9})-(\d+)\b/g,
+  // Jira URL patterns
+  // https://company.atlassian.net/browse/PROJECT-123
+  issueUrl: /https?:\/\/[a-zA-Z0-9_-]+\.atlassian\.net\/browse\/([A-Z][A-Z0-9]{1,9})-(\d+)/gi,
+  // https://company.atlassian.net/jira/software/projects/PROJECT/...
+  projectUrl: /https?:\/\/[a-zA-Z0-9_-]+\.atlassian\.net\/jira\/(?:software|core|servicedesk)\/projects\/([A-Z][A-Z0-9]{1,9})/gi,
+  // Project key mentioned in context (e.g., "in the PROJ project")
+  projectMention: /(?:project|board)\s+([A-Z][A-Z0-9]{1,9})\b/gi
+};
+var JiraExtractor = class {
+  /**
+   * Extract Jira entities from text
+   */
+  extract(text, source) {
+    const entities = [];
+    const seenProjects = /* @__PURE__ */ new Set();
+    const seenIssues = /* @__PURE__ */ new Set();
+    let match;
+    JIRA_PATTERNS.issueUrl.lastIndex = 0;
+    while ((match = JIRA_PATTERNS.issueUrl.exec(text)) !== null) {
+      const [, projectKey, number] = match;
+      const issueKey = `${projectKey.toUpperCase()}-${number}`;
+      if (!seenIssues.has(issueKey)) {
+        seenIssues.add(issueKey);
+        entities.push({
+          entity: {
+            type: "jira_issue",
+            entity: { key: issueKey }
+          },
+          source
+        });
+        const projectKeyUpper = projectKey.toUpperCase();
+        if (!seenProjects.has(projectKeyUpper)) {
+          seenProjects.add(projectKeyUpper);
+          entities.push({
+            entity: {
+              type: "jira_project",
+              entity: { key: projectKeyUpper }
+            },
+            source
+          });
+        }
+      }
+    }
+    JIRA_PATTERNS.projectUrl.lastIndex = 0;
+    while ((match = JIRA_PATTERNS.projectUrl.exec(text)) !== null) {
+      const [, projectKey] = match;
+      const projectKeyUpper = projectKey.toUpperCase();
+      if (!seenProjects.has(projectKeyUpper)) {
+        seenProjects.add(projectKeyUpper);
+        entities.push({
+          entity: {
+            type: "jira_project",
+            entity: { key: projectKeyUpper }
+          },
+          source
+        });
+      }
+    }
+    JIRA_PATTERNS.issueKey.lastIndex = 0;
+    while ((match = JIRA_PATTERNS.issueKey.exec(text)) !== null) {
+      const [, projectKey, number] = match;
+      const issueKey = `${projectKey.toUpperCase()}-${number}`;
+      if (!seenIssues.has(issueKey)) {
+        seenIssues.add(issueKey);
+        entities.push({
+          entity: {
+            type: "jira_issue",
+            entity: { key: issueKey }
+          },
+          source
+        });
+        const projectKeyUpper = projectKey.toUpperCase();
+        if (!seenProjects.has(projectKeyUpper)) {
+          seenProjects.add(projectKeyUpper);
+          entities.push({
+            entity: {
+              type: "jira_project",
+              entity: { key: projectKeyUpper }
+            },
+            source
+          });
+        }
+      }
+    }
+    JIRA_PATTERNS.projectMention.lastIndex = 0;
+    while ((match = JIRA_PATTERNS.projectMention.exec(text)) !== null) {
+      const [, projectKey] = match;
+      const projectKeyUpper = projectKey.toUpperCase();
+      if (SKIP_PROJECT_KEYS.has(projectKeyUpper)) {
+        continue;
+      }
+      if (!seenProjects.has(projectKeyUpper)) {
+        seenProjects.add(projectKeyUpper);
+        entities.push({
+          entity: {
+            type: "jira_project",
+            entity: { key: projectKeyUpper }
+          },
+          source
+        });
+      }
+    }
+    return { entities };
+  }
+};
+var jiraExtractor = new JiraExtractor();
+
+// ../../b4m-core/packages/services/dist/src/conversationContextService/extractors/confluence.js
+var CONFLUENCE_PATTERNS = {
+  // Confluence page URL patterns
+  // https://company.atlassian.net/wiki/spaces/SPACE/pages/123456/Page+Title
+  pageUrl: /https?:\/\/[a-zA-Z0-9_-]+\.atlassian\.net\/wiki\/spaces\/([A-Z0-9_-]+)\/pages\/(\d+)(?:\/([^?\s]+))?/gi,
+  // https://company.atlassian.net/wiki/spaces/SPACE
+  spaceUrl: /https?:\/\/[a-zA-Z0-9_-]+\.atlassian\.net\/wiki\/spaces\/([A-Z0-9_-]+)(?:\/|$|\s|[)\]>])/gi,
+  // Space key mentioned in context (e.g., "in the DOCS space")
+  spaceMention: /(?:space|confluence space)\s+([A-Z][A-Z0-9_-]{0,9})\b/gi,
+  // Page ID pattern (often appears in tool results)
+  pageId: /(?:pageId|page_id|page id)[:\s]+["']?(\d+)["']?/gi
+};
+var ConfluenceExtractor = class {
+  /**
+   * Extract Confluence entities from text
+   */
+  extract(text, source) {
+    const entities = [];
+    const seenSpaces = /* @__PURE__ */ new Set();
+    const seenPages = /* @__PURE__ */ new Set();
+    let match;
+    CONFLUENCE_PATTERNS.pageUrl.lastIndex = 0;
+    while ((match = CONFLUENCE_PATTERNS.pageUrl.exec(text)) !== null) {
+      const [, spaceKey, pageId, encodedTitle] = match;
+      if (!seenPages.has(pageId)) {
+        seenPages.add(pageId);
+        let title = `Page ${pageId}`;
+        if (encodedTitle) {
+          try {
+            title = decodeURIComponent(encodedTitle.replace(/\+/g, " "));
+          } catch {
+            title = encodedTitle.replace(/\+/g, " ");
+          }
+        }
+        entities.push({
+          entity: {
+            type: "confluence_page",
+            entity: {
+              id: pageId,
+              title,
+              spaceKey: spaceKey.toUpperCase()
+            }
+          },
+          source
+        });
+        const spaceKeyUpper = spaceKey.toUpperCase();
+        if (!seenSpaces.has(spaceKeyUpper)) {
+          seenSpaces.add(spaceKeyUpper);
+          entities.push({
+            entity: {
+              type: "confluence_space",
+              entity: { key: spaceKeyUpper }
+            },
+            source
+          });
+        }
+      }
+    }
+    CONFLUENCE_PATTERNS.spaceUrl.lastIndex = 0;
+    while ((match = CONFLUENCE_PATTERNS.spaceUrl.exec(text)) !== null) {
+      const [, spaceKey] = match;
+      const spaceKeyUpper = spaceKey.toUpperCase();
+      if (!seenSpaces.has(spaceKeyUpper)) {
+        seenSpaces.add(spaceKeyUpper);
+        entities.push({
+          entity: {
+            type: "confluence_space",
+            entity: { key: spaceKeyUpper }
+          },
+          source
+        });
+      }
+    }
+    CONFLUENCE_PATTERNS.spaceMention.lastIndex = 0;
+    while ((match = CONFLUENCE_PATTERNS.spaceMention.exec(text)) !== null) {
+      const [, spaceKey] = match;
+      const spaceKeyUpper = spaceKey.toUpperCase();
+      if (!seenSpaces.has(spaceKeyUpper)) {
+        seenSpaces.add(spaceKeyUpper);
+        entities.push({
+          entity: {
+            type: "confluence_space",
+            entity: { key: spaceKeyUpper }
+          },
+          source
+        });
+      }
+    }
+    CONFLUENCE_PATTERNS.pageId.lastIndex = 0;
+    while ((match = CONFLUENCE_PATTERNS.pageId.exec(text)) !== null) {
+      const [, pageId] = match;
+      if (!seenPages.has(pageId)) {
+        seenPages.add(pageId);
+        entities.push({
+          entity: {
+            type: "confluence_page",
+            entity: {
+              id: pageId,
+              title: `Page ${pageId}`
+              // Title unknown from just ID
+            }
+          },
+          source
+        });
+      }
+    }
+    return { entities };
+  }
+};
+var confluenceExtractor = new ConfluenceExtractor();
+
+// ../../b4m-core/packages/services/dist/src/conversationContextService/extractors/index.js
+var CombinedExtractor = class {
+  constructor() {
+    this.extractors = [githubExtractor, jiraExtractor, confluenceExtractor];
+  }
+  /**
+   * Extract all entities from text using all available extractors
+   *
+   * @param text - The text to extract entities from
+   * @param source - The source of the text
+   * @returns Combined extraction results from all extractors
+   */
+  extract(text, source) {
+    const allEntities = [];
+    for (const extractor of this.extractors) {
+      const result = extractor.extract(text, source);
+      allEntities.push(...result.entities);
+    }
+    return { entities: allEntities };
+  }
+  /**
+   * Extract entities from multiple text blocks (e.g., messages in a conversation)
+   *
+   * @param texts - Array of text content with their sources
+   * @returns Combined extraction results
+   */
+  extractFromMultiple(texts) {
+    const allEntities = [];
+    for (const { text, source } of texts) {
+      const result = this.extract(text, source);
+      allEntities.push(...result.entities);
+    }
+    return { entities: allEntities };
+  }
+};
+var combinedExtractor = new CombinedExtractor();
+
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionProcess.js
 var DISABLE_SERVER_THROTTLING = process.env.DISABLE_SERVER_THROTTLING === "true";
 var questSaveMutex = new Mutex();
@@ -11294,6 +11775,7 @@ var AgentFrontmatterSchema = z146.object({
   model: z146.string().optional(),
   "allowed-tools": z146.array(z146.string()).optional(),
   "denied-tools": z146.array(z146.string()).optional(),
+  skills: z146.array(z146.string()).optional(),
   "max-iterations": z146.object({
     quick: z146.number().int().positive().optional(),
     medium: z146.number().int().positive().optional(),
@@ -11316,21 +11798,21 @@ var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path17) {
+  async download(path18) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path17) {
+  async delete(path18) {
   }
-  async getSignedUrl(path17) {
-    return `/tmp/${path17}`;
+  async getSignedUrl(path18) {
+    return `/tmp/${path18}`;
   }
-  getPublicUrl(path17) {
-    return `/tmp/${path17}`;
+  getPublicUrl(path18) {
+    return `/tmp/${path18}`;
   }
-  async getPreview(path17) {
-    return `/tmp/${path17}`;
+  async getPreview(path18) {
+    return `/tmp/${path18}`;
   }
-  async getMetadata(path17) {
+  async getMetadata(path18) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -13207,7 +13689,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.26-refactor-dry-credit-deduction.18613+04ea81997",
+  version: "0.2.26",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -13315,10 +13797,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.48.1-refactor-dry-credit-deduction.18613+04ea81997",
-    "@bike4mind/mcp": "1.28.2-refactor-dry-credit-deduction.18613+04ea81997",
-    "@bike4mind/services": "2.46.1-refactor-dry-credit-deduction.18613+04ea81997",
-    "@bike4mind/utils": "2.3.5-refactor-dry-credit-deduction.18613+04ea81997",
+    "@bike4mind/common": "2.49.0",
+    "@bike4mind/mcp": "1.28.2",
+    "@bike4mind/services": "2.47.0",
+    "@bike4mind/utils": "2.4.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -13335,7 +13817,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "04ea81997073bcb80acec65dc9f714cac430d530"
+  gitHead: "38aa7cfdcf121f8fea9cc0bfb390a27e1434c76c"
 };
 
 // src/config/constants.ts
@@ -13366,104 +13848,368 @@ function filterToolsByPatterns(allTools, allowedPatterns, deniedPatterns) {
   });
 }
 
-// src/agents/SubagentOrchestrator.ts
-var SubagentOrchestrator = class {
-  constructor(deps) {
-    this.beforeRunCallback = null;
-    this.afterRunCallback = null;
-    this.deps = deps;
+// src/tools/skillTool.ts
+async function executeHook(script, context) {
+  const result = await runShellCommand({
+    command: script,
+    cwd: process.cwd(),
+    timeoutMs: 3e4,
+    env: {
+      ...process.env,
+      SKILL_NAME: context.skillName,
+      SKILL_ARGS: context.args,
+      SKILL_RESULT: context.result || "",
+      SKILL_ERROR: context.error || ""
+    }
+  });
+  if (result.timedOut) {
+    return { success: false, output: "Hook failed: timed out after 30s" };
   }
-  /**
-   * Set a callback to be invoked before each agent.run()
-   * Use this to subscribe to agent events (e.g., agent.on('action', handler))
-   */
-  setBeforeRunCallback(callback) {
-    this.beforeRunCallback = callback;
+  if (result.exitCode !== 0) {
+    return { success: false, output: `Hook failed: ${result.stderr || `exit code ${result.exitCode}`}` };
   }
-  /**
-   * Set a callback to be invoked after each agent.run()
-   * Use this to unsubscribe from agent events (e.g., agent.off('action', handler))
-   */
-  setAfterRunCallback(callback) {
-    this.afterRunCallback = callback;
+  return { success: true, output: result.stdout || result.stderr };
+}
+function parseAgentConfig(agent) {
+  if (!agent) {
+    return { name: "general-purpose", thoroughness: void 0 };
   }
-  /**
-   * Delegate a task to an agent loaded from markdown definition
-   *
-   * @param options - Configuration for agent execution
-   * @returns Agent result with summary
-   */
-  async delegateToAgent(options) {
-    const { task, agentName, thoroughness, variables, parentSessionId, model, allowedTools } = options;
-    const agentDef = this.deps.agentStore.getAgent(agentName);
-    if (!agentDef) {
-      const available = this.deps.agentStore.getAgentNames().join(", ");
-      throw new Error(`Unknown agent: "${agentName}". Available agents: ${available}`);
-    }
-    const effectiveModel = model || agentDef.model;
-    const effectiveThoroughness = thoroughness || agentDef.defaultThoroughness;
-    const maxIterations = agentDef.maxIterations[effectiveThoroughness];
-    const effectiveVariables = {
-      ...agentDef.defaultVariables,
-      ...variables
-    };
-    const systemPrompt = this.substituteVariables(agentDef.systemPrompt, task, effectiveVariables);
-    const effectiveAllowedTools = allowedTools || agentDef.allowedTools;
-    const toolFilter = {
-      allowedTools: effectiveAllowedTools,
-      deniedTools: [...agentDef.deniedTools || [], ...ALWAYS_DENIED_FOR_AGENTS]
-    };
-    const agentContext = {
-      currentAgent: null,
-      observationQueue: []
-    };
-    const { tools: allTools, agentContext: updatedContext } = generateCliTools(
-      this.deps.userId,
-      this.deps.llm,
-      effectiveModel,
-      this.deps.permissionManager,
-      this.deps.showPermissionPrompt,
-      agentContext,
-      this.deps.configStore,
-      this.deps.apiClient
-    );
-    const filteredTools = filterToolsByPatterns(allTools, toolFilter.allowedTools, toolFilter.deniedTools);
-    const hookWrapperContext = {
-      sessionId: parentSessionId,
-      agentName,
-      cwd: process.cwd()
-    };
-    const hookedTools = filteredTools.map((tool) => wrapToolWithHooks(tool, agentDef.hooks, hookWrapperContext));
-    this.deps.logger.debug(
-      `Spawning "${agentName}" agent with ${hookedTools.length} tools, thoroughness: ${effectiveThoroughness}, max iterations: ${maxIterations}`
-    );
-    const agent = new ReActAgent({
-      userId: this.deps.userId,
-      logger: this.deps.logger,
-      llm: this.deps.llm,
-      model: effectiveModel,
-      tools: hookedTools,
-      maxIterations,
-      systemPrompt
-    });
-    updatedContext.currentAgent = agent;
-    if (this.beforeRunCallback) {
-      this.beforeRunCallback(agent, agentName);
+  if (typeof agent === "string") {
+    return { name: agent, thoroughness: void 0 };
+  }
+  return { name: agent.type, thoroughness: agent.thoroughness };
+}
+function parseArguments(argsString) {
+  const args = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = 0; i < argsString.length; i++) {
+    const char = argsString[i];
+    if (!inQuotes && (char === '"' || char === "'")) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (inQuotes && char === quoteChar) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (!inQuotes && char === " ") {
+      if (current.length > 0) {
+        args.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
     }
-    const startTime = Date.now();
-    let result;
-    try {
-      result = await agent.run(task, {
-        maxIterations,
-        parallelExecution: this.deps.enableParallelToolExecution === true,
-        isReadOnlyTool
-      });
-    } catch (error) {
-      if (error instanceof HookBlockedError) {
-        if (this.afterRunCallback) {
-          this.afterRunCallback(agent, agentName);
-        }
-        return {
+  }
+  if (current.length > 0) {
+    args.push(current);
+  }
+  return args;
+}
+function createSkillTool(deps) {
+  const { customCommandStore } = deps;
+  return {
+    toolFn: async (args) => {
+      const params = args;
+      if (!params.skill || typeof params.skill !== "string") {
+        throw new Error("skill: skill parameter is required");
+      }
+      const skillName = params.skill.replace(/^\//, "");
+      const argsString = params.args || "";
+      const { allowedSkills } = deps;
+      if (allowedSkills && allowedSkills.length > 0) {
+        if (!allowedSkills.includes(skillName)) {
+          throw new Error(
+            `skill: "${skillName}" is not available to this agent. Allowed skills: ${allowedSkills.join(", ")}`
+          );
+        }
+      }
+      const command = customCommandStore.getCommand(skillName);
+      if (!command) {
+        const available = customCommandStore.getAllCommands().map((c) => c.name).join(", ");
+        throw new Error(`skill: "${skillName}" not found. Available skills: ${available || "none"}`);
+      }
+      if (command.hooks?.["pre-invoke"]) {
+        const hookResult = await executeHook(command.hooks["pre-invoke"], {
+          skillName,
+          args: argsString
+        });
+        if (!hookResult.success) {
+          throw new Error(`Pre-invoke hook failed: ${hookResult.output}`);
+        }
+      }
+      try {
+        const argsArray = params.args ? parseArguments(params.args) : [];
+        let expandedBody = substituteArguments(command.body, argsArray);
+        const processed = await processFileReferences(expandedBody);
+        expandedBody = processed.content;
+        if (processed.errors.length > 0) {
+          expandedBody += `
+
+**File reference errors:**
+${processed.errors.map((e) => `- ${e}`).join("\n")}`;
+        }
+        let result;
+        const hasToolRestrictions = Boolean(command.allowedTools?.length);
+        const hasModelOverride = Boolean(command.model);
+        const needsFork = command.context === "fork" || hasToolRestrictions || hasModelOverride;
+        if (needsFork) {
+          const { subagentOrchestrator, sessionId } = deps;
+          if (!subagentOrchestrator || !sessionId) {
+            const missing = !subagentOrchestrator ? "subagentOrchestrator" : "sessionId";
+            throw new Error(`Skill "${skillName}" requires forked context but ${missing} is not available`);
+          }
+          if (command.context !== "fork") {
+            const reasons = [hasToolRestrictions && "allowed-tools", hasModelOverride && "model"].filter(Boolean);
+            logger.info(`Auto-upgraded "/${skillName}" to fork context (uses: ${reasons.join(", ")})`);
+          }
+          const agentConfig = parseAgentConfig(command.agent);
+          const agentResult = await subagentOrchestrator.delegateToAgent({
+            task: expandedBody,
+            agentName: agentConfig.name,
+            thoroughness: agentConfig.thoroughness || command.thoroughness,
+            variables: command.variables,
+            parentSessionId: sessionId,
+            // Pass skill-level overrides
+            model: command.model,
+            allowedTools: command.allowedTools
+          });
+          const agentName = agentConfig.name;
+          result = `## Skill Executed: /${skillName} (via ${agentName} agent)
+
+${agentResult.summary}`;
+        } else {
+          result = `## Skill Loaded: /${skillName}
+
+${expandedBody}
+
+---
+*Follow the instructions above. This skill was invoked programmatically.*`;
+        }
+        if (command.hooks?.["post-invoke"]) {
+          const hookResult = await executeHook(command.hooks["post-invoke"], {
+            skillName,
+            args: argsString,
+            result
+          });
+          if (!hookResult.success) {
+            logger.warn(`Post-invoke hook warning: ${hookResult.output}`);
+          }
+        }
+        return result;
+      } catch (error) {
+        if (command.hooks?.["on-error"]) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const hookResult = await executeHook(command.hooks["on-error"], {
+            skillName,
+            args: argsString,
+            error: errorMessage
+          });
+          if (hookResult.output) {
+            logger.warn(`On-error hook output: ${hookResult.output}`);
+          }
+        }
+        throw error;
+      }
+    },
+    toolSchema: {
+      name: "skill",
+      description: `Execute a skill (custom slash command) within the conversation.
+
+**When to use this tool:**
+- When a user asks you to use a skill by name (e.g., "use the review-pr skill")
+- When a skill would help accomplish the user's request
+- When you see /<skill-name> syntax in user messages
+
+**How it works:**
+1. Skills are loaded from markdown files in .bike4mind/commands/
+2. The skill template is expanded with argument substitution ($1, $2, $ARGUMENTS)
+3. File references (@filename) are resolved and content is injected
+4. The expanded template is returned for you to follow
+
+**Example invocations:**
+- skill({ skill: "commit" }) - invoke commit skill
+- skill({ skill: "review-pr", args: "123" }) - review PR #123
+- skill({ skill: "feature-code-map", args: "authentication" }) - generate code map
+
+**Important:**
+- Skill names can be with or without leading slash: "commit" or "/commit"
+- Arguments are space-separated; use quotes for arguments with spaces
+- The tool returns instructions to follow, not a final answer`,
+      parameters: {
+        type: "object",
+        properties: {
+          skill: {
+            type: "string",
+            description: 'Name of the skill to invoke (e.g., "commit", "review-pr")'
+          },
+          args: {
+            type: "string",
+            description: `Optional arguments as space-separated string. Use quotes for arguments containing spaces (e.g., '123 "bug fix"').`
+          }
+        },
+        required: ["skill"]
+      }
+    }
+  };
+}
+
+// src/core/skillsPrompt.ts
+function getSkillDisplayName(cmd) {
+  return cmd.displayName || cmd.name;
+}
+function formatSkillEntry(cmd) {
+  const displayName = getSkillDisplayName(cmd);
+  const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
+  const nameDisplay = cmd.displayName && cmd.displayName !== cmd.name ? `**${displayName}** (\`${cmd.name}\`)` : `**${cmd.name}**`;
+  return `- ${nameDisplay}${argHint}: ${cmd.description}
+`;
+}
+function formatSkillGroup(heading, commands) {
+  if (commands.length === 0) {
+    return "";
+  }
+  return `
+### ${heading}
+${commands.map(formatSkillEntry).join("")}`;
+}
+function filterAIVisibleSkills(commands) {
+  return commands.filter((cmd) => !cmd.disableModelInvocation);
+}
+function filterSkillsByAllowedList(commands, allowedSkills) {
+  if (!allowedSkills || allowedSkills.length === 0) {
+    return commands;
+  }
+  return commands.filter((cmd) => allowedSkills.includes(cmd.name));
+}
+function buildSkillsPromptSection(commands, allowedSkills) {
+  const filteredByAllowed = filterSkillsByAllowedList(commands, allowedSkills);
+  const visibleCommands = filterAIVisibleSkills(filteredByAllowed);
+  if (visibleCommands.length === 0) {
+    return "";
+  }
+  const projectSkills = visibleCommands.filter((c) => c.source === "project");
+  const globalSkills = visibleCommands.filter((c) => c.source === "global");
+  return `
+
+## Available Skills
+
+Use the \`skill\` tool to invoke these. Example: skill({ skill: "commit" })
+` + formatSkillGroup("Project Skills", projectSkills) + formatSkillGroup("Global Skills", globalSkills);
+}
+
+// src/agents/SubagentOrchestrator.ts
+var SubagentOrchestrator = class {
+  constructor(deps) {
+    this.beforeRunCallback = null;
+    this.afterRunCallback = null;
+    this.deps = deps;
+  }
+  /**
+   * Set a callback to be invoked before each agent.run()
+   * Use this to subscribe to agent events (e.g., agent.on('action', handler))
+   */
+  setBeforeRunCallback(callback) {
+    this.beforeRunCallback = callback;
+  }
+  /**
+   * Set a callback to be invoked after each agent.run()
+   * Use this to unsubscribe from agent events (e.g., agent.off('action', handler))
+   */
+  setAfterRunCallback(callback) {
+    this.afterRunCallback = callback;
+  }
+  /**
+   * Delegate a task to an agent loaded from markdown definition
+   *
+   * @param options - Configuration for agent execution
+   * @returns Agent result with summary
+   */
+  async delegateToAgent(options) {
+    const { task, agentName, thoroughness, variables, parentSessionId, model, allowedTools } = options;
+    const agentDef = this.deps.agentStore.getAgent(agentName);
+    if (!agentDef) {
+      const available = this.deps.agentStore.getAgentNames().join(", ");
+      throw new Error(`Unknown agent: "${agentName}". Available agents: ${available}`);
+    }
+    const effectiveModel = model || agentDef.model;
+    const effectiveThoroughness = thoroughness || agentDef.defaultThoroughness;
+    const maxIterations = agentDef.maxIterations[effectiveThoroughness];
+    const effectiveVariables = {
+      ...agentDef.defaultVariables,
+      ...variables
+    };
+    let systemPrompt = this.substituteVariables(agentDef.systemPrompt, task, effectiveVariables);
+    const effectiveAllowedTools = allowedTools || agentDef.allowedTools;
+    const toolFilter = {
+      allowedTools: effectiveAllowedTools,
+      deniedTools: [...agentDef.deniedTools || [], ...ALWAYS_DENIED_FOR_AGENTS]
+    };
+    const agentContext = {
+      currentAgent: null,
+      observationQueue: []
+    };
+    const { tools: allTools, agentContext: updatedContext } = generateCliTools(
+      this.deps.userId,
+      this.deps.llm,
+      effectiveModel,
+      this.deps.permissionManager,
+      this.deps.showPermissionPrompt,
+      agentContext,
+      this.deps.configStore,
+      this.deps.apiClient
+    );
+    const filteredTools = filterToolsByPatterns(allTools, toolFilter.allowedTools, toolFilter.deniedTools);
+    if (this.deps.customCommandStore) {
+      const skillTool = createSkillTool({
+        customCommandStore: this.deps.customCommandStore,
+        subagentOrchestrator: this,
+        sessionId: parentSessionId,
+        allowedSkills: agentDef.skills
+      });
+      filteredTools.push(skillTool);
+      const commands = this.deps.customCommandStore.getAllCommands();
+      const skillsSection = buildSkillsPromptSection(commands, agentDef.skills);
+      if (skillsSection) {
+        systemPrompt += skillsSection;
+      }
+    }
+    const hookWrapperContext = {
+      sessionId: parentSessionId,
+      agentName,
+      cwd: process.cwd()
+    };
+    const hookedTools = filteredTools.map((tool) => wrapToolWithHooks(tool, agentDef.hooks, hookWrapperContext));
+    this.deps.logger.debug(
+      `Spawning "${agentName}" agent with ${hookedTools.length} tools, thoroughness: ${effectiveThoroughness}, max iterations: ${maxIterations}`
+    );
+    const agent = new ReActAgent({
+      userId: this.deps.userId,
+      logger: this.deps.logger,
+      llm: this.deps.llm,
+      model: effectiveModel,
+      tools: hookedTools,
+      maxIterations,
+      systemPrompt
+    });
+    updatedContext.currentAgent = agent;
+    if (this.beforeRunCallback) {
+      this.beforeRunCallback(agent, agentName);
+    }
+    const startTime = Date.now();
+    let result;
+    try {
+      result = await agent.run(task, {
+        maxIterations,
+        parallelExecution: this.deps.enableParallelToolExecution === true,
+        isReadOnlyTool
+      });
+    } catch (error) {
+      if (error instanceof HookBlockedError) {
+        if (this.afterRunCallback) {
+          this.afterRunCallback(agent, agentName);
+        }
+        return {
           agentName,
           thoroughness: effectiveThoroughness,
           summary: `Agent blocked: ${error.message}`,
@@ -13589,14 +14335,15 @@ var MODEL_ALIASES = {
   // Anthropic/Claude Models
   // ===================
   // Short aliases (most common)
-  opus: "claude-opus-4-5-20251101",
+  opus: "claude-opus-4-6",
   sonnet: "claude-sonnet-4-5-20250929",
   haiku: "claude-3-5-haiku-20241022",
   // Claude-prefixed aliases
-  "claude-opus": "claude-opus-4-5-20251101",
+  "claude-opus": "claude-opus-4-6",
   "claude-sonnet": "claude-sonnet-4-5-20250929",
   "claude-haiku": "claude-3-5-haiku-20241022",
   // Version-specific Claude aliases
+  "claude-4.6-opus": "claude-opus-4-6",
   "claude-4.5-opus": "claude-opus-4-5-20251101",
   "claude-4.5-sonnet": "claude-sonnet-4-5-20250929",
   "claude-4.5-haiku": "claude-haiku-4-5-20251001",
@@ -13805,6 +14552,7 @@ var AgentStore = class {
       systemPrompt: body.trim(),
       allowedTools: parsed["allowed-tools"],
       deniedTools: parsed["denied-tools"],
+      skills: parsed.skills,
       maxIterations: {
         quick: parsed["max-iterations"]?.quick ?? DEFAULT_MAX_ITERATIONS.quick,
         medium: parsed["max-iterations"]?.medium ?? DEFAULT_MAX_ITERATIONS.medium,
@@ -14303,323 +15051,125 @@ ${details}`;
       for (const [id] of toRemove) {
         this.jobs.delete(id);
         cleanedCount++;
-      }
-    }
-    return cleanedCount;
-  }
-  /**
-   * Get the current number of jobs (for monitoring)
-   */
-  getJobCount() {
-    let running = 0;
-    let queued = 0;
-    let completed = 0;
-    for (const internal of this.jobs.values()) {
-      switch (internal.job.status) {
-        case "running":
-          running++;
-          break;
-        case "queued":
-          queued++;
-          break;
-        default:
-          completed++;
-      }
-    }
-    return { total: this.jobs.size, running, queued, completed };
-  }
-};
-
-// src/agents/backgroundTools.ts
-function createBackgroundAgentTools(manager) {
-  const checkAgentStatus = {
-    toolFn: async (args) => {
-      const { job_id } = args;
-      if (!job_id) throw new Error("check_agent_status: job_id is required");
-      const job = manager.getJob(job_id);
-      if (!job) return `No background agent found with ID: ${job_id}`;
-      switch (job.status) {
-        case "queued":
-          return `Agent "${job.agentName}" is queued (waiting for a concurrency slot). Task: ${job.task}`;
-        case "running": {
-          const elapsed = Math.round((Date.now() - job.startTime) / 1e3);
-          return `Agent "${job.agentName}" is still running (${elapsed}s elapsed). Task: ${job.task}`;
-        }
-        case "completed": {
-          const result = manager.getResult(job_id);
-          return result?.summary || `Agent "${job.agentName}" completed but no summary available.`;
-        }
-        case "failed":
-          return `Agent "${job.agentName}" failed: ${job.error || "Unknown error"}`;
-        case "cancelled":
-          return `Agent "${job.agentName}" was cancelled.`;
-      }
-    },
-    toolSchema: {
-      name: "check_agent_status",
-      description: "Check the status and retrieve results of a background agent job. Use after spawning an agent with run_in_background: true.",
-      parameters: {
-        type: "object",
-        properties: {
-          job_id: {
-            type: "string",
-            description: "The job ID returned by agent_delegate when run_in_background was true"
-          }
-        },
-        required: ["job_id"]
-      }
-    }
-  };
-  const listBackgroundAgents = {
-    toolFn: async () => {
-      const jobs = manager.listJobs();
-      if (jobs.length === 0) return "No background agents.";
-      return jobs.map((job) => {
-        const elapsed = Math.round(((job.endTime || Date.now()) - job.startTime) / 1e3);
-        const statusIcons = {
-          queued: "\u{1F550}",
-          running: "\u23F3",
-          completed: "\u2705",
-          failed: "\u274C",
-          cancelled: "\u{1F6AB}"
-        };
-        const statusIcon = statusIcons[job.status] || "\u2753";
-        return `${statusIcon} [${job.id}] ${job.agentName} (${job.status}, ${elapsed}s) - ${job.task.slice(0, 80)}`;
-      }).join("\n");
-    },
-    toolSchema: {
-      name: "list_background_agents",
-      description: "List all background agent jobs with their current status.",
-      parameters: {
-        type: "object",
-        properties: {}
-      }
-    }
-  };
-  const cancelBackgroundAgent = {
-    toolFn: async (args) => {
-      const { job_id } = args;
-      if (!job_id) throw new Error("cancel_background_agent: job_id is required");
-      const cancelled = manager.cancelJob(job_id);
-      if (cancelled) return `Background agent ${job_id} has been cancelled.`;
-      const job = manager.getJob(job_id);
-      if (!job) return `No background agent found with ID: ${job_id}`;
-      return `Cannot cancel agent ${job_id} - status is already "${job.status}".`;
-    },
-    toolSchema: {
-      name: "cancel_background_agent",
-      description: "Cancel a running background agent job.",
-      parameters: {
-        type: "object",
-        properties: {
-          job_id: {
-            type: "string",
-            description: "The job ID of the background agent to cancel"
-          }
-        },
-        required: ["job_id"]
-      }
-    }
-  };
-  return [checkAgentStatus, listBackgroundAgents, cancelBackgroundAgent];
-}
-
-// src/tools/skillTool.ts
-async function executeHook(script, context) {
-  const result = await runShellCommand({
-    command: script,
-    cwd: process.cwd(),
-    timeoutMs: 3e4,
-    env: {
-      ...process.env,
-      SKILL_NAME: context.skillName,
-      SKILL_ARGS: context.args,
-      SKILL_RESULT: context.result || "",
-      SKILL_ERROR: context.error || ""
-    }
-  });
-  if (result.timedOut) {
-    return { success: false, output: "Hook failed: timed out after 30s" };
-  }
-  if (result.exitCode !== 0) {
-    return { success: false, output: `Hook failed: ${result.stderr || `exit code ${result.exitCode}`}` };
-  }
-  return { success: true, output: result.stdout || result.stderr };
-}
-function parseAgentConfig(agent) {
-  if (!agent) {
-    return { name: "general-purpose", thoroughness: void 0 };
-  }
-  if (typeof agent === "string") {
-    return { name: agent, thoroughness: void 0 };
-  }
-  return { name: agent.type, thoroughness: agent.thoroughness };
-}
-function parseArguments(argsString) {
-  const args = [];
-  let current = "";
-  let inQuotes = false;
-  let quoteChar = "";
-  for (let i = 0; i < argsString.length; i++) {
-    const char = argsString[i];
-    if (!inQuotes && (char === '"' || char === "'")) {
-      inQuotes = true;
-      quoteChar = char;
-    } else if (inQuotes && char === quoteChar) {
-      inQuotes = false;
-      quoteChar = "";
-    } else if (!inQuotes && char === " ") {
-      if (current.length > 0) {
-        args.push(current);
-        current = "";
-      }
-    } else {
-      current += char;
-    }
-  }
-  if (current.length > 0) {
-    args.push(current);
-  }
-  return args;
-}
-function createSkillTool(deps) {
-  const { customCommandStore } = deps;
-  return {
-    toolFn: async (args) => {
-      const params = args;
-      if (!params.skill || typeof params.skill !== "string") {
-        throw new Error("skill: skill parameter is required");
-      }
-      const skillName = params.skill.replace(/^\//, "");
-      const argsString = params.args || "";
-      const command = customCommandStore.getCommand(skillName);
-      if (!command) {
-        const available = customCommandStore.getAllCommands().map((c) => c.name).join(", ");
-        throw new Error(`skill: "${skillName}" not found. Available skills: ${available || "none"}`);
-      }
-      if (command.hooks?.["pre-invoke"]) {
-        const hookResult = await executeHook(command.hooks["pre-invoke"], {
-          skillName,
-          args: argsString
-        });
-        if (!hookResult.success) {
-          throw new Error(`Pre-invoke hook failed: ${hookResult.output}`);
-        }
-      }
-      try {
-        const argsArray = params.args ? parseArguments(params.args) : [];
-        let expandedBody = substituteArguments(command.body, argsArray);
-        const processed = await processFileReferences(expandedBody);
-        expandedBody = processed.content;
-        if (processed.errors.length > 0) {
-          expandedBody += `
-
-**File reference errors:**
-${processed.errors.map((e) => `- ${e}`).join("\n")}`;
-        }
-        let result;
-        const hasToolRestrictions = Boolean(command.allowedTools?.length);
-        const hasModelOverride = Boolean(command.model);
-        const needsFork = command.context === "fork" || hasToolRestrictions || hasModelOverride;
-        if (needsFork) {
-          const { subagentOrchestrator, sessionId } = deps;
-          if (!subagentOrchestrator || !sessionId) {
-            const missing = !subagentOrchestrator ? "subagentOrchestrator" : "sessionId";
-            throw new Error(`Skill "${skillName}" requires forked context but ${missing} is not available`);
-          }
-          if (command.context !== "fork") {
-            const reasons = [hasToolRestrictions && "allowed-tools", hasModelOverride && "model"].filter(Boolean);
-            logger.info(`Auto-upgraded "/${skillName}" to fork context (uses: ${reasons.join(", ")})`);
-          }
-          const agentConfig = parseAgentConfig(command.agent);
-          const agentResult = await subagentOrchestrator.delegateToAgent({
-            task: expandedBody,
-            agentName: agentConfig.name,
-            thoroughness: agentConfig.thoroughness || command.thoroughness,
-            variables: command.variables,
-            parentSessionId: sessionId,
-            // Pass skill-level overrides
-            model: command.model,
-            allowedTools: command.allowedTools
-          });
-          const agentName = agentConfig.name;
-          result = `## Skill Executed: /${skillName} (via ${agentName} agent)
-
-${agentResult.summary}`;
-        } else {
-          result = `## Skill Loaded: /${skillName}
-
-${expandedBody}
+      }
+    }
+    return cleanedCount;
+  }
+  /**
+   * Get the current number of jobs (for monitoring)
+   */
+  getJobCount() {
+    let running = 0;
+    let queued = 0;
+    let completed = 0;
+    for (const internal of this.jobs.values()) {
+      switch (internal.job.status) {
+        case "running":
+          running++;
+          break;
+        case "queued":
+          queued++;
+          break;
+        default:
+          completed++;
+      }
+    }
+    return { total: this.jobs.size, running, queued, completed };
+  }
+};
 
----
-*Follow the instructions above. This skill was invoked programmatically.*`;
-        }
-        if (command.hooks?.["post-invoke"]) {
-          const hookResult = await executeHook(command.hooks["post-invoke"], {
-            skillName,
-            args: argsString,
-            result
-          });
-          if (!hookResult.success) {
-            logger.warn(`Post-invoke hook warning: ${hookResult.output}`);
-          }
+// src/agents/backgroundTools.ts
+function createBackgroundAgentTools(manager) {
+  const checkAgentStatus = {
+    toolFn: async (args) => {
+      const { job_id } = args;
+      if (!job_id) throw new Error("check_agent_status: job_id is required");
+      const job = manager.getJob(job_id);
+      if (!job) return `No background agent found with ID: ${job_id}`;
+      switch (job.status) {
+        case "queued":
+          return `Agent "${job.agentName}" is queued (waiting for a concurrency slot). Task: ${job.task}`;
+        case "running": {
+          const elapsed = Math.round((Date.now() - job.startTime) / 1e3);
+          return `Agent "${job.agentName}" is still running (${elapsed}s elapsed). Task: ${job.task}`;
         }
-        return result;
-      } catch (error) {
-        if (command.hooks?.["on-error"]) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          const hookResult = await executeHook(command.hooks["on-error"], {
-            skillName,
-            args: argsString,
-            error: errorMessage
-          });
-          if (hookResult.output) {
-            logger.warn(`On-error hook output: ${hookResult.output}`);
-          }
+        case "completed": {
+          const result = manager.getResult(job_id);
+          return result?.summary || `Agent "${job.agentName}" completed but no summary available.`;
         }
-        throw error;
+        case "failed":
+          return `Agent "${job.agentName}" failed: ${job.error || "Unknown error"}`;
+        case "cancelled":
+          return `Agent "${job.agentName}" was cancelled.`;
       }
     },
     toolSchema: {
-      name: "skill",
-      description: `Execute a skill (custom slash command) within the conversation.
-
-**When to use this tool:**
-- When a user asks you to use a skill by name (e.g., "use the review-pr skill")
-- When a skill would help accomplish the user's request
-- When you see /<skill-name> syntax in user messages
-
-**How it works:**
-1. Skills are loaded from markdown files in .bike4mind/commands/
-2. The skill template is expanded with argument substitution ($1, $2, $ARGUMENTS)
-3. File references (@filename) are resolved and content is injected
-4. The expanded template is returned for you to follow
-
-**Example invocations:**
-- skill({ skill: "commit" }) - invoke commit skill
-- skill({ skill: "review-pr", args: "123" }) - review PR #123
-- skill({ skill: "feature-code-map", args: "authentication" }) - generate code map
-
-**Important:**
-- Skill names can be with or without leading slash: "commit" or "/commit"
-- Arguments are space-separated; use quotes for arguments with spaces
-- The tool returns instructions to follow, not a final answer`,
+      name: "check_agent_status",
+      description: "Check the status and retrieve results of a background agent job. Use after spawning an agent with run_in_background: true.",
       parameters: {
         type: "object",
         properties: {
-          skill: {
+          job_id: {
             type: "string",
-            description: 'Name of the skill to invoke (e.g., "commit", "review-pr")'
-          },
-          args: {
+            description: "The job ID returned by agent_delegate when run_in_background was true"
+          }
+        },
+        required: ["job_id"]
+      }
+    }
+  };
+  const listBackgroundAgents = {
+    toolFn: async () => {
+      const jobs = manager.listJobs();
+      if (jobs.length === 0) return "No background agents.";
+      return jobs.map((job) => {
+        const elapsed = Math.round(((job.endTime || Date.now()) - job.startTime) / 1e3);
+        const statusIcons = {
+          queued: "\u{1F550}",
+          running: "\u23F3",
+          completed: "\u2705",
+          failed: "\u274C",
+          cancelled: "\u{1F6AB}"
+        };
+        const statusIcon = statusIcons[job.status] || "\u2753";
+        return `${statusIcon} [${job.id}] ${job.agentName} (${job.status}, ${elapsed}s) - ${job.task.slice(0, 80)}`;
+      }).join("\n");
+    },
+    toolSchema: {
+      name: "list_background_agents",
+      description: "List all background agent jobs with their current status.",
+      parameters: {
+        type: "object",
+        properties: {}
+      }
+    }
+  };
+  const cancelBackgroundAgent = {
+    toolFn: async (args) => {
+      const { job_id } = args;
+      if (!job_id) throw new Error("cancel_background_agent: job_id is required");
+      const cancelled = manager.cancelJob(job_id);
+      if (cancelled) return `Background agent ${job_id} has been cancelled.`;
+      const job = manager.getJob(job_id);
+      if (!job) return `No background agent found with ID: ${job_id}`;
+      return `Cannot cancel agent ${job_id} - status is already "${job.status}".`;
+    },
+    toolSchema: {
+      name: "cancel_background_agent",
+      description: "Cancel a running background agent job.",
+      parameters: {
+        type: "object",
+        properties: {
+          job_id: {
             type: "string",
-            description: `Optional arguments as space-separated string. Use quotes for arguments containing spaces (e.g., '123 "bug fix"').`
+            description: "The job ID of the background agent to cancel"
           }
         },
-        required: ["skill"]
+        required: ["job_id"]
       }
     }
   };
+  return [checkAgentStatus, listBackgroundAgents, cancelBackgroundAgent];
 }
 
 // src/tools/writeTodosTool.ts
@@ -14747,41 +15297,204 @@ function createTodoStore(onUpdate) {
   };
 }
 
-// src/core/skillsPrompt.ts
-function getSkillDisplayName(cmd) {
-  return cmd.displayName || cmd.name;
+// src/tools/findDefinitionTool.ts
+import { stat as stat3 } from "fs/promises";
+import path17 from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { createRequire as createRequire2 } from "module";
+var execFileAsync2 = promisify2(execFile2);
+var require3 = createRequire2(import.meta.url);
+var VALID_KINDS = ["class", "function", "type", "interface", "variable", "enum", "struct", "module"];
+var KIND_KEYWORDS = {
+  class: ["class"],
+  function: ["function", "def", "func", "fn"],
+  type: ["type"],
+  interface: ["interface", "trait", "protocol"],
+  variable: ["const", "let", "var"],
+  enum: ["enum"],
+  struct: ["struct"],
+  module: ["module", "namespace", "package"]
+};
+var ALL_KEYWORDS = Object.values(KIND_KEYWORDS).flat();
+function getRipgrepPath2() {
+  try {
+    const ripgrepPath = require3.resolve("@vscode/ripgrep");
+    const ripgrepDir = path17.dirname(ripgrepPath);
+    return path17.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+  } catch {
+    throw new Error(
+      "ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services"
+    );
+  }
 }
-function formatSkillEntry(cmd) {
-  const displayName = getSkillDisplayName(cmd);
-  const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
-  const nameDisplay = cmd.displayName && cmd.displayName !== cmd.name ? `**${displayName}** (\`${cmd.name}\`)` : `**${cmd.name}**`;
-  return `- ${nameDisplay}${argHint}: ${cmd.description}
-`;
+function isPathWithinWorkspace2(targetPath, baseCwd) {
+  const resolvedTarget = path17.resolve(targetPath);
+  const resolvedBase = path17.resolve(baseCwd);
+  const relativePath = path17.relative(resolvedBase, resolvedTarget);
+  return !relativePath.startsWith("..") && !path17.isAbsolute(relativePath);
 }
-function formatSkillGroup(heading, commands) {
-  if (commands.length === 0) {
-    return "";
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildDefinitionPattern(symbolName, kind) {
+  const escaped = escapeRegex(symbolName);
+  let keywords;
+  if (kind) {
+    if (!VALID_KINDS.includes(kind)) {
+      throw new Error(`Invalid kind "${kind}". Valid kinds: ${VALID_KINDS.join(", ")}`);
+    }
+    keywords = KIND_KEYWORDS[kind];
+  } else {
+    keywords = ALL_KEYWORDS;
   }
-  return `
-### ${heading}
-${commands.map(formatSkillEntry).join("")}`;
+  const keywordGroup = keywords.join("|");
+  return `(export\\s+(default\\s+)?)?(abstract\\s+)?(${keywordGroup})\\s+${escaped}\\w*`;
 }
-function filterAIVisibleSkills(commands) {
-  return commands.filter((cmd) => !cmd.disableModelInvocation);
+function isLikelyDefinition(line) {
+  const trimmed = line.trim();
+  if (/^\s*(\/\/|\/\*|\*|#|"""|''')/.test(trimmed)) return false;
+  if (/\bimport\s/.test(trimmed) && !/\bexport\b/.test(trimmed)) return false;
+  if (/\brequire\s*\(/.test(trimmed) && !/\b(const|let|var)\b/.test(trimmed)) return false;
+  if (/\b(jest|vi|sinon)\.(mock|stub|spy)\b/.test(trimmed)) return false;
+  return true;
 }
-function buildSkillsPromptSection(commands) {
-  const visibleCommands = filterAIVisibleSkills(commands);
-  if (visibleCommands.length === 0) {
-    return "";
+async function findDefinitions(params) {
+  const { symbol_name, kind, search_path } = params;
+  if (!symbol_name || !symbol_name.trim()) {
+    throw new Error("symbol_name is required");
   }
-  const projectSkills = visibleCommands.filter((c) => c.source === "project");
-  const globalSkills = visibleCommands.filter((c) => c.source === "global");
-  return `
+  const baseCwd = process.cwd();
+  const targetDir = search_path ? path17.resolve(baseCwd, search_path) : baseCwd;
+  if (!isPathWithinWorkspace2(targetDir, baseCwd)) {
+    throw new Error(`Path validation failed: "${search_path}" resolves outside the allowed workspace directory`);
+  }
+  try {
+    const stats = await stat3(targetDir);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${search_path}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Path does not exist: ${search_path}`);
+    }
+    throw error;
+  }
+  const rgPath = getRipgrepPath2();
+  const pattern = buildDefinitionPattern(symbol_name.trim(), kind);
+  const rgArgs = [
+    "--json",
+    "--max-count",
+    "50",
+    // Definitions are rare per file
+    "--max-filesize",
+    "5M",
+    // Case-sensitive — definition names are exact (unlike grep_search)
+    pattern,
+    targetDir
+  ];
+  let stdout;
+  try {
+    const result2 = await execFileAsync2(rgPath, rgArgs, {
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB — definitions produce far less output than grep
+    });
+    stdout = result2.stdout;
+  } catch (error) {
+    const execError = error;
+    if (execError.code === 1) {
+      stdout = execError.stdout || "";
+    } else if (execError.code === 2) {
+      throw new Error(`Ripgrep error: ${execError.stderr || "Unknown error"}`);
+    } else {
+      throw error;
+    }
+  }
+  const lines = stdout.split("\n").filter(Boolean);
+  const allMatches = [];
+  for (const line of lines) {
+    try {
+      const item = JSON.parse(line);
+      if (item.type === "match") {
+        const match = item;
+        const lineText = match.data.lines.text.trimEnd();
+        if (isLikelyDefinition(lineText)) {
+          allMatches.push({
+            filePath: path17.relative(targetDir, match.data.path.text) || path17.basename(match.data.path.text),
+            lineNumber: match.data.line_number,
+            line: lineText
+          });
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (allMatches.length === 0) {
+    const kindInfo = kind ? ` (kind: "${kind}")` : "";
+    const pathInfo = search_path ? ` in "${search_path}"` : "";
+    return `No definitions found for "${symbol_name}"${kindInfo}${pathInfo}.
+
+Suggestions:
+- The symbol may be from an external package (node_modules)
+` + (kind ? "- Try without the kind filter\n" : "") + "- Check for alternate naming (e.g., camelCase vs PascalCase)";
+  }
+  const sorted = allMatches.sort((a, b) => {
+    const aIsExport = /\bexport\b/.test(a.line) ? 0 : 1;
+    const bIsExport = /\bexport\b/.test(b.line) ? 0 : 1;
+    if (aIsExport !== bIsExport) return aIsExport - bIsExport;
+    const aIsTest = /(\btest\b|\bspec\b|__tests__|\.test\.|\.spec\.)/.test(a.filePath) ? 1 : 0;
+    const bIsTest = /(\btest\b|\bspec\b|__tests__|\.test\.|\.spec\.)/.test(b.filePath) ? 1 : 0;
+    if (aIsTest !== bIsTest) return aIsTest - bIsTest;
+    return a.filePath.localeCompare(b.filePath);
+  });
+  const maxResults = 20;
+  const displayed = sorted.slice(0, maxResults);
+  const truncated = sorted.length > maxResults;
+  const count = sorted.length;
+  let result = `Found ${count} definition${count === 1 ? "" : "s"} for "${symbol_name}"${truncated ? ` (showing top ${maxResults})` : ""}:
 
-## Available Skills
+`;
+  for (const match of displayed) {
+    const trimmed = match.line.trim();
+    const displayLine = trimmed.length > 200 ? trimmed.slice(0, 200) + "..." : trimmed;
+    result += `${match.filePath}:${match.lineNumber}
+  ${displayLine}
 
-Use the \`skill\` tool to invoke these. Example: skill({ skill: "commit" })
-` + formatSkillGroup("Project Skills", projectSkills) + formatSkillGroup("Global Skills", globalSkills);
+`;
+  }
+  return result.trim();
+}
+function createFindDefinitionTool() {
+  return {
+    toolFn: async (args) => {
+      const params = args;
+      return findDefinitions(params);
+    },
+    toolSchema: {
+      name: "find_definition",
+      description: "Find where a class, function, type, or interface is defined in the codebase. Much faster and more precise than grep_search for definition lookups. Works across all languages (TypeScript, JavaScript, Python, Go, Rust, etc.) automatically.",
+      parameters: {
+        type: "object",
+        properties: {
+          symbol_name: {
+            type: "string",
+            description: 'The name (or prefix) of the symbol to find. Supports prefix matching \u2014 "Bedrock" finds "BedrockBackend", "BedrockClient", etc.'
+          },
+          kind: {
+            type: "string",
+            description: "Optional: narrow search to a specific kind of definition",
+            enum: ["class", "function", "type", "interface", "variable", "enum", "struct", "module"]
+          },
+          search_path: {
+            type: "string",
+            description: 'Optional: directory to search within, relative to current working directory (e.g., "src/auth", "packages/core")'
+          }
+        },
+        required: ["symbol_name"]
+      }
+    }
+  };
 }
 
 // src/index.tsx
@@ -15069,6 +15782,7 @@ function CliApp() {
         configStore: state.configStore,
         apiClient,
         agentStore,
+        customCommandStore: state.customCommandStore,
         enableParallelToolExecution: config.preferences.enableParallelToolExecution === true
       });
       const backgroundManager = new BackgroundAgentManager(orchestrator);
@@ -15090,7 +15804,8 @@ function CliApp() {
         subagentOrchestrator: orchestrator,
         sessionId: newSession.id
       }) : null;
-      const cliTools = [agentDelegateTool, ...backgroundTools, writeTodosTool];
+      const findDefinitionTool = createFindDefinitionTool();
+      const cliTools = [agentDelegateTool, ...backgroundTools, writeTodosTool, findDefinitionTool];
       if (skillTool) {
         cliTools.push(skillTool);
       }