@bike4mind/cli 0.2.19-feat-unified-agent-system.17813 → 0.2.19-feat-cli-skill-tool.17811

package/dist/index.js

@@ -7,7 +7,7 @@ import {
 } from "./chunk-AZ7I44K7.js";
 import {
   ConfigStore
-} from "./chunk-FFJX3FF3.js";
+} from "./chunk-VFQF2JIT.js";
 import "./chunk-KZNSOBD6.js";
 import "./chunk-E4K7LPQC.js";
 import {
@@ -529,20 +529,6 @@ var COMMANDS = [
     name: "mcp",
     description: "Show MCP server status and connected tools",
     aliases: ["mcp:list"]
-  },
-  {
-    name: "agents",
-    description: "List all available agents",
-    aliases: ["agents:list"]
-  },
-  {
-    name: "agents:new",
-    description: "Create a new agent definition",
-    args: "<name>"
-  },
-  {
-    name: "agents:reload",
-    description: "Reload agent definitions from disk"
   }
 ];
 function getAllCommandNames() {
@@ -2412,17 +2398,42 @@ import os from "os";
 // src/utils/commandParser.ts
 import matter from "gray-matter";
 import { z } from "zod";
+var flexibleString = z.union([z.string(), z.array(z.string())]).transform((val) => Array.isArray(val) ? val.join(" ") : val).optional();
+function needsQuoting(value) {
+  const firstChar = value.charAt(0);
+  const isAlreadyQuoted = firstChar === '"' || firstChar === "'";
+  const isStructured = firstChar === "[" || firstChar === "{";
+  const containsColon = value.includes(":");
+  return containsColon && !isAlreadyQuoted && !isStructured;
+}
+function preprocessFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatterMatch) return content;
+  const frontmatter = frontmatterMatch[1];
+  const processedLines = frontmatter.split("\n").map((line) => {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) return line;
+    const match = line.match(/^(\s*)([a-zA-Z-_]+):\s*(.+)$/);
+    if (!match) return line;
+    const [, indent, key, value] = match;
+    const trimmedValue = value.trim();
+    if (!needsQuoting(trimmedValue)) return line;
+    const escapedValue = trimmedValue.replace(/"/g, '\\"');
+    return `${indent}${key}: "${escapedValue}"`;
+  });
+  const processedFrontmatter = processedLines.join("\n");
+  return content.replace(/^---\r?\n[\s\S]*?\r?\n---/, `---
+${processedFrontmatter}
+---`);
+}
 var FrontmatterSchema = z.object({
-  description: z.string().optional(),
-  "argument-hint": z.string().optional(),
+  description: flexibleString,
+  "argument-hint": flexibleString,
   model: z.string().optional(),
-  // Agent integration fields
-  agent: z.string().optional(),
-  thoroughness: z.enum(["quick", "medium", "very_thorough"]).optional(),
-  variables: z.record(z.string()).optional(),
   // Future fields (ignored for now):
   "allowed-tools": z.any().optional(),
   context: z.any().optional(),
+  agent: z.any().optional(),
   "disable-model-invocation": z.any().optional(),
   hooks: z.any().optional()
 });
@@ -2438,7 +2449,8 @@ function extractDescriptionFromBody(body) {
 }
 function parseCommandFile(fileContent, filePath, commandName, source) {
   try {
-    const { data: frontmatter, content: body } = matter(fileContent);
+    const processedContent = preprocessFrontmatter(fileContent);
+    const { data: frontmatter, content: body } = matter(processedContent);
     const validationResult = FrontmatterSchema.safeParse(frontmatter);
     if (!validationResult.success) {
       console.warn(
@@ -2455,10 +2467,7 @@ function parseCommandFile(fileContent, filePath, commandName, source) {
       model: validFrontmatter.model,
       body: body.trim(),
       source,
-      filePath,
-      agent: validFrontmatter.agent,
-      thoroughness: validFrontmatter.thoroughness,
-      variables: validFrontmatter.variables
+      filePath
     };
   } catch (error) {
     throw new Error(
@@ -2488,17 +2497,32 @@ function extractCommandName(filename) {
 var CustomCommandStore = class {
   constructor(projectRoot) {
     this.commands = /* @__PURE__ */ new Map();
-    this.globalCommandsDir = path5.join(os.homedir(), ".bike4mind", "commands");
-    this.projectCommandsDir = path5.join(projectRoot || process.cwd(), ".bike4mind", "commands");
+    const home = os.homedir();
+    const root = projectRoot || process.cwd();
+    this.globalCommandsDirs = [
+      path5.join(home, ".bike4mind", "commands"),
+      path5.join(home, ".claude", "commands"),
+      path5.join(home, ".claude", "skills")
+    ];
+    this.projectCommandsDirs = [
+      path5.join(root, ".bike4mind", "commands"),
+      path5.join(root, ".claude", "commands"),
+      path5.join(root, ".claude", "skills")
+    ];
   }
   /**
    * Loads all custom commands from both global and project directories
    * Project commands override global commands with the same name
+   * Later directories in each category override earlier ones with same name
    */
   async loadCommands() {
     this.commands.clear();
-    await this.loadCommandsFromDirectory(this.globalCommandsDir, "global");
-    await this.loadCommandsFromDirectory(this.projectCommandsDir, "project");
+    for (const dir of this.globalCommandsDirs) {
+      await this.loadCommandsFromDirectory(dir, "global");
+    }
+    for (const dir of this.projectCommandsDirs) {
+      await this.loadCommandsFromDirectory(dir, "project");
+    }
   }
   /**
    * Recursively scans a directory for .md files and loads them as commands
@@ -2564,19 +2588,27 @@ var CustomCommandStore = class {
    */
   async loadCommandFile(filePath, source) {
     const filename = path5.basename(filePath);
-    const commandName = extractCommandName(filename);
+    const isSkillFile = filename.toLowerCase() === "skill.md";
+    const commandName = isSkillFile ? this.extractSkillName(filePath) : extractCommandName(filename);
     if (!commandName) {
       console.warn(`Invalid command filename: ${filename} (must end with .md and have valid name)`);
       return;
     }
     const fileContent = await fs5.readFile(filePath, "utf-8");
     const command = parseCommandFile(fileContent, filePath, commandName, source);
-    const existing = this.commands.get(commandName);
-    if (existing && existing.source === "project" && source === "global") {
-      return;
-    }
     this.commands.set(commandName, command);
   }
+  /**
+   * Extracts skill name from a SKILL.md file path
+   * Uses the parent directory name as the skill name
+   *
+   * @param filePath - Full path to the SKILL.md file
+   * @returns Skill name or null if invalid
+   */
+  extractSkillName(filePath) {
+    const parentDir = path5.basename(path5.dirname(filePath));
+    return parentDir && parentDir !== "skills" ? parentDir : null;
+  }
   /**
    * Gets a command by name
    *
@@ -2635,15 +2667,14 @@ var CustomCommandStore = class {
    * @returns Path to the created file
    */
   async createCommandFile(name, isGlobal = false) {
-    const targetDir = isGlobal ? this.globalCommandsDir : this.projectCommandsDir;
+    const targetDir = isGlobal ? this.globalCommandsDirs[0] : this.projectCommandsDirs[0];
     const filePath = path5.join(targetDir, `${name}.md`);
-    try {
-      await fs5.access(filePath);
+    const fileExists = await fs5.access(filePath).then(
+      () => true,
+      () => false
+    );
+    if (fileExists) {
       throw new Error(`Command file already exists: ${filePath}`);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
     }
     await fs5.mkdir(targetDir, { recursive: true });
     const template = `---
@@ -5235,8 +5266,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 path16 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path16;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -6448,8 +6479,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 path16 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path16;
 }
 async function updateQuestAndReturnMarkdown2(storedImagePath, context) {
   await context.onFinish?.("edit_image", storedImagePath);
@@ -7978,8 +8009,8 @@ var getHeliocentricCoords = (planet, T) => {
   const sinNode = Math.sin(longNode);
   const x = r * (cosNode * cosOmega - sinNode * sinOmega * cosI);
   const y = r * (sinNode * cosOmega + cosNode * sinOmega * cosI);
-  const z145 = r * sinOmega * sinI;
-  return { x, y, z: z145, r };
+  const z144 = r * sinOmega * sinI;
+  return { x, y, z: z144, r };
 };
 var getGeocentricEcliptic = (planet, earth) => {
   const dx = planet.x - earth.x;
@@ -9702,7 +9733,7 @@ async function generateFileDeletePreview(args) {
     if (!existsSync7(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs14) => fs14.stat(args.path));
+    const stats = await import("fs/promises").then((fs13) => fs13.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -10047,198 +10078,26 @@ async function executeTool(toolName, input, apiClient, localToolFn) {
   }
 }
 
-// src/agents/hookExecutor.ts
-import { spawn as spawn2 } from "child_process";
-var DEFAULT_HOOK_TIMEOUT_SECONDS = 60;
-async function executeCommandHook(hook, context) {
-  if (!hook.command) {
-    return { decision: "allow" };
-  }
-  const timeoutSeconds = hook.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS;
-  const timeoutMs = timeoutSeconds * 1e3;
-  return new Promise((resolve3) => {
-    const child = spawn2("bash", ["-c", hook.command], {
-      cwd: context.cwd,
-      env: {
-        ...process.env,
-        B4M_PROJECT_DIR: context.cwd,
-        B4M_AGENT_NAME: context.agent_name,
-        B4M_SESSION_ID: context.session_id
-      },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (data) => {
-      stdout += data;
-    });
-    child.stderr.on("data", (data) => {
-      stderr += data;
-    });
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      resolve3({
-        decision: "allow",
-        reason: `Hook timed out after ${timeoutSeconds}s`
-      });
-    }, timeoutMs);
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      if (code === 2) {
-        resolve3({
-          decision: "deny",
-          reason: stderr.trim() || "Hook blocked execution"
-        });
-        return;
-      }
-      if (code !== 0) {
-        console.warn(`Hook exited with code ${code}: ${stderr.trim()}`);
-        resolve3({ decision: "allow" });
-        return;
-      }
-      try {
-        const result = JSON.parse(stdout.trim());
-        resolve3({
-          decision: result.decision || "allow",
-          reason: result.reason,
-          updatedInput: result.updatedInput
-        });
-      } catch {
-        resolve3({ decision: "allow" });
-      }
-    });
-    child.on("error", (error) => {
-      clearTimeout(timer);
-      console.warn(`Hook execution error: ${error.message}`);
-      resolve3({ decision: "allow" });
-    });
-    child.stdin.write(JSON.stringify(context));
-    child.stdin.end();
-  });
-}
-function matchesToolPattern(toolName, pattern) {
-  try {
-    const regex = new RegExp(`^${pattern}$`);
-    return regex.test(toolName);
-  } catch {
-    return false;
-  }
-}
-async function executeHooks(hooks, context) {
-  if (!hooks || hooks.length === 0) {
-    return { decision: "allow" };
-  }
-  const matchingHooks = [];
-  for (const matcher of hooks) {
-    const shouldMatch = !matcher.matcher || !context.tool_name || matchesToolPattern(context.tool_name, matcher.matcher);
-    if (shouldMatch) {
-      matchingHooks.push(...matcher.hooks);
-    }
-  }
-  if (matchingHooks.length === 0) {
-    return { decision: "allow" };
-  }
-  const results = await Promise.all(
-    matchingHooks.filter((hook) => hook.type === "command").map((hook) => executeCommandHook(hook, context))
-  );
-  for (const result of results) {
-    if (result.decision === "deny" || result.decision === "block") {
-      return result;
-    }
-  }
-  let updatedInput;
-  for (const result of results) {
-    if (result.updatedInput) {
-      updatedInput = { ...updatedInput, ...result.updatedInput };
-    }
-  }
-  return { decision: "allow", updatedInput };
-}
-function buildHookContext(params) {
-  return {
-    session_id: params.sessionId,
-    agent_name: params.agentName,
-    cwd: params.cwd,
-    hook_event_name: params.hookEventName,
-    tool_name: params.toolName,
-    tool_input: params.toolInput,
-    tool_use_id: params.toolUseId,
-    tool_result: params.toolResult,
-    error: params.error
-  };
-}
-
-// src/agents/types.ts
-import { z as z143 } from "zod";
-var HookBlockedError = class extends Error {
-  constructor(toolName, reason) {
-    super(`Hook blocked execution of ${toolName}: ${reason || "No reason provided"}`);
-    this.name = "HookBlockedError";
-    this.toolName = toolName;
-  }
-};
-var ALWAYS_DENIED_FOR_AGENTS = [
-  "agent_delegate"
-  // No agent chaining
-];
-var HookDefinitionSchema = z143.object({
-  type: z143.enum(["command", "prompt"]),
-  command: z143.string().optional(),
-  prompt: z143.string().optional(),
-  timeout: z143.number().optional()
-});
-var HookMatcherSchema = z143.object({
-  matcher: z143.string().optional(),
-  hooks: z143.array(HookDefinitionSchema)
-});
-var AgentHooksSchema = z143.object({
-  PreToolUse: z143.array(HookMatcherSchema).optional(),
-  PostToolUse: z143.array(HookMatcherSchema).optional(),
-  PostToolUseFailure: z143.array(HookMatcherSchema).optional(),
-  Stop: z143.array(HookMatcherSchema).optional()
-}).optional();
-var AgentFrontmatterSchema = z143.object({
-  description: z143.string().min(1, "Agent description is required"),
-  model: z143.string().optional(),
-  "allowed-tools": z143.array(z143.string()).optional(),
-  "denied-tools": z143.array(z143.string()).optional(),
-  "max-iterations": z143.object({
-    quick: z143.number().int().positive().optional(),
-    medium: z143.number().int().positive().optional(),
-    very_thorough: z143.number().int().positive().optional()
-  }).optional(),
-  "default-thoroughness": z143.enum(["quick", "medium", "very_thorough"]).optional(),
-  variables: z143.record(z143.string()).optional(),
-  hooks: AgentHooksSchema
-});
-var DEFAULT_MAX_ITERATIONS = {
-  quick: 2,
-  medium: 5,
-  very_thorough: 10
-};
-var DEFAULT_AGENT_MODEL = "claude-3-5-haiku-20241022";
-var DEFAULT_THOROUGHNESS = "medium";
-
 // src/utils/toolsAdapter.ts
 var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path17) {
+  async download(path16) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path17) {
+  async delete(path16) {
   }
-  async getSignedUrl(path17) {
-    return `/tmp/${path17}`;
+  async getSignedUrl(path16) {
+    return `/tmp/${path16}`;
   }
-  getPublicUrl(path17) {
-    return `/tmp/${path17}`;
+  getPublicUrl(path16) {
+    return `/tmp/${path16}`;
   }
-  async getPreview(path17) {
-    return `/tmp/${path17}`;
+  async getPreview(path16) {
+    return `/tmp/${path16}`;
   }
-  async getMetadata(path17) {
+  async getMetadata(path16) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -10333,75 +10192,6 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
     }
   };
 }
-function wrapToolWithHooks(tool, hooks, hookContext) {
-  const hasToolHooks = hooks?.PreToolUse || hooks?.PostToolUse || hooks?.PostToolUseFailure;
-  if (!hasToolHooks) {
-    return tool;
-  }
-  const originalFn = tool.toolFn;
-  const toolName = tool.toolSchema.name;
-  return {
-    ...tool,
-    toolFn: async (args) => {
-      let finalArgs = args;
-      if (hooks.PreToolUse) {
-        const preResult = await executeHooks(
-          hooks.PreToolUse,
-          buildHookContext({
-            ...hookContext,
-            hookEventName: "PreToolUse",
-            toolName,
-            toolInput: args
-          })
-        );
-        if (preResult.decision === "deny") {
-          return `Tool execution denied by hook: ${preResult.reason || "No reason provided"}`;
-        }
-        if (preResult.decision === "block") {
-          throw new HookBlockedError(toolName, preResult.reason);
-        }
-        if (preResult.updatedInput) {
-          finalArgs = { ...args, ...preResult.updatedInput };
-        }
-      }
-      let observation;
-      try {
-        observation = await originalFn(finalArgs);
-      } catch (err) {
-        if (hooks.PostToolUseFailure) {
-          const error = err;
-          await executeHooks(
-            hooks.PostToolUseFailure,
-            buildHookContext({
-              ...hookContext,
-              hookEventName: "PostToolUseFailure",
-              toolName,
-              toolInput: finalArgs,
-              error: error.message
-            })
-          );
-        }
-        throw err;
-      }
-      if (hooks.PostToolUse) {
-        const postResult = await executeHooks(
-          hooks.PostToolUse,
-          buildHookContext({
-            ...hookContext,
-            hookEventName: "PostToolUse",
-            toolName,
-            toolInput: finalArgs,
-            toolResult: observation
-          })
-        );
-        if (postResult.decision === "block") {
-          throw new HookBlockedError(toolName, postResult.reason);
-        }
-      }
-      return observation;
-    }
-  };
-}
 var TOOL_NAME_MAPPING = {
   // Claude Code -> B4M
   read: "file_read",
@@ -10519,8 +10309,8 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
 }
 
 // src/config/toolSafety.ts
-import { z as z144 } from "zod";
-var ToolCategorySchema = z144.enum([
+import { z as z143 } from "zod";
+var ToolCategorySchema = z143.enum([
   "auto_approve",
   // Safe tools that run automatically without permission
   "prompt_always",
@@ -10528,9 +10318,9 @@ var ToolCategorySchema = z144.enum([
   "prompt_default"
   // Tools that prompt by default but can be trusted
 ]);
-var ToolSafetyConfigSchema = z144.object({
-  categories: z144.record(z144.string(), ToolCategorySchema),
-  trustedTools: z144.array(z144.string())
+var ToolSafetyConfigSchema = z143.object({
+  categories: z143.record(z143.string(), ToolCategorySchema),
+  trustedTools: z143.array(z143.string())
 });
 var DEFAULT_TOOL_CATEGORIES = {
   // ===== AUTO APPROVE (Safe tools) =====
@@ -11824,7 +11614,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.19-feat-unified-agent-system.17813+f0daae7c8",
+  version: "0.2.19-feat-cli-skill-tool.17811+8e53e9310",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -11931,10 +11721,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.43.1-feat-unified-agent-system.17813+f0daae7c8",
-    "@bike4mind/mcp": "1.23.1-feat-unified-agent-system.17813+f0daae7c8",
-    "@bike4mind/services": "2.41.2-feat-unified-agent-system.17813+f0daae7c8",
-    "@bike4mind/utils": "2.2.1-feat-unified-agent-system.17813+f0daae7c8",
+    "@bike4mind/common": "2.43.1-feat-cli-skill-tool.17811+8e53e9310",
+    "@bike4mind/mcp": "1.23.1-feat-cli-skill-tool.17811+8e53e9310",
+    "@bike4mind/services": "2.41.2-feat-cli-skill-tool.17811+8e53e9310",
+    "@bike4mind/utils": "2.2.1-feat-cli-skill-tool.17811+8e53e9310",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -11951,7 +11741,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "f0daae7c8a8ee4961bfdece2cc62628cdfe3cf01"
+  gitHead: "8e53e9310a7e9eaeb0ef443047a638dccb93382e"
 };
 
 // src/config/constants.ts
@@ -11959,29 +11749,6 @@ var USAGE_DAYS = 30;
 var MODEL_NAME_COLUMN_WIDTH = 18;
 var USAGE_CACHE_TTL = 5 * 60 * 1e3;
 
-// src/agents/toolFilter.ts
-function matchesToolPattern2(toolName, pattern) {
-  const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${regexPattern}$`).test(toolName);
-}
-function matchesAnyPattern(toolName, patterns) {
-  return patterns.some((pattern) => matchesToolPattern2(toolName, pattern));
-}
-function filterToolsByPatterns(allTools, allowedPatterns, deniedPatterns) {
-  return allTools.filter((tool) => {
-    const toolName = tool.toolSchema.name;
-    if (deniedPatterns && deniedPatterns.length > 0) {
-      if (matchesAnyPattern(toolName, deniedPatterns)) {
-        return false;
-      }
-    }
-    if (!allowedPatterns || allowedPatterns.length === 0) {
-      return true;
-    }
-    return matchesAnyPattern(toolName, allowedPatterns);
-  });
-}
-
 // src/agents/SubagentOrchestrator.ts
 var SubagentOrchestrator = class {
   constructor(deps) {
@@ -11990,176 +11757,168 @@ var SubagentOrchestrator = class {
     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))
+   * Set a callback to be invoked before each subagent.run()
+   * Use this to subscribe to agent events (e.g., subagent.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))
+   * Set a callback to be invoked after each subagent.run()
+   * Use this to unsubscribe from agent events (e.g., subagent.off('action', handler))
    */
   setAfterRunCallback(callback) {
     this.afterRunCallback = callback;
   }
   /**
-   * Delegate a task to an agent loaded from markdown definition
+   * Delegate a task to a specialized subagent
    *
-   * @param options - Configuration for agent execution
-   * @returns Agent result with summary
+   * @param options - Configuration for subagent execution
+   * @returns Subagent result with summary
    */
-  async delegateToAgent(options) {
-    const { task, agentName, thoroughness, variables, parentSessionId } = 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 effectiveThoroughness = thoroughness || agentDef.defaultThoroughness;
-    const maxIterations = agentDef.maxIterations[effectiveThoroughness];
-    const effectiveVariables = {
-      ...agentDef.defaultVariables,
-      ...variables
+  async delegateToSubagent(options) {
+    const { task, type, thoroughness, parentSessionId, config: configOverride } = options;
+    const baseConfig = this.deps.subagentConfigs.get(type);
+    if (!baseConfig) {
+      throw new Error(`No configuration found for subagent type: ${type}`);
+    }
+    const config = {
+      ...baseConfig,
+      ...configOverride,
+      type
     };
-    const systemPrompt = this.substituteVariables(agentDef.systemPrompt, task, effectiveVariables);
+    const model = config.model || "claude-3-5-haiku-20241022";
+    const maxIterations = this.getMaxIterations(config, thoroughness);
     const toolFilter = {
-      allowedTools: agentDef.allowedTools,
-      deniedTools: [...agentDef.deniedTools || [], ...ALWAYS_DENIED_FOR_AGENTS]
+      allowedTools: config.allowedTools,
+      deniedTools: config.deniedTools
     };
     const agentContext = {
       currentAgent: null,
       observationQueue: []
     };
-    const { tools: allTools, agentContext: updatedContext } = generateCliTools(
+    const { tools: tools2, agentContext: updatedContext } = generateCliTools(
       this.deps.userId,
       this.deps.llm,
-      agentDef.model,
+      model,
       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}`
+      this.deps.apiClient,
+      toolFilter
     );
-    const agent = new ReActAgent({
+    this.deps.logger.debug(`Spawning ${type} subagent with ${tools2.length} tools, thoroughness: ${thoroughness}`);
+    const subagent = new ReActAgent({
       userId: this.deps.userId,
       logger: this.deps.logger,
       llm: this.deps.llm,
-      model: agentDef.model,
-      tools: hookedTools,
+      model,
+      tools: tools2,
       maxIterations,
-      systemPrompt
+      systemPrompt: config.systemPrompt || this.getDefaultSystemPrompt(type)
     });
-    updatedContext.currentAgent = agent;
+    updatedContext.currentAgent = subagent;
     if (this.beforeRunCallback) {
-      this.beforeRunCallback(agent, agentName);
+      this.beforeRunCallback(subagent, type);
     }
     const startTime = Date.now();
-    let result;
-    try {
-      result = await agent.run(task, {
-        maxIterations
-      });
-    } catch (error) {
-      if (error instanceof HookBlockedError) {
-        if (this.afterRunCallback) {
-          this.afterRunCallback(agent, agentName);
-        }
-        return {
-          agentName,
-          thoroughness: effectiveThoroughness,
-          summary: `Agent blocked: ${error.message}`,
-          parentSessionId,
-          finalAnswer: error.message,
-          steps: [],
-          completionInfo: {
-            totalTokens: 0,
-            iterations: 0,
-            toolCalls: 0,
-            reachedMaxIterations: false
-          }
-        };
-      }
-      throw error;
-    }
+    const result = await subagent.run(task, {
+      maxIterations
+    });
     const duration = Date.now() - startTime;
-    if (agentDef.hooks?.Stop) {
-      const stopResult = await executeHooks(
-        agentDef.hooks.Stop,
-        buildHookContext({
-          ...hookWrapperContext,
-          hookEventName: "Stop"
-        })
-      );
-      if (stopResult.decision === "block") {
-        this.deps.logger.debug(`Stop hook blocked: ${stopResult.reason}`);
-      }
-    }
     if (this.afterRunCallback) {
-      this.afterRunCallback(agent, agentName);
+      this.afterRunCallback(subagent, type);
     }
     this.deps.logger.debug(
-      `Agent "${agentName}" completed in ${duration}ms, ${result.completionInfo.iterations} iterations, ${result.completionInfo.totalTokens} tokens`
+      `Subagent completed in ${duration}ms, ${result.completionInfo.iterations} iterations, ${result.completionInfo.totalTokens} tokens`
     );
-    const summary = this.summarizeResult(result, agentDef);
-    return {
+    const summary = this.summarizeResult(result, type);
+    const subagentResult = {
       ...result,
-      agentName,
-      thoroughness: effectiveThoroughness,
+      subagentType: type,
+      thoroughness,
       summary,
       parentSessionId
     };
+    return subagentResult;
   }
   /**
-   * Substitute variables in system prompt
-   * Reserved: $TASK, $ARGUMENTS, $1, $2, etc.
+   * Get max iterations based on thoroughness and config
    */
-  substituteVariables(systemPrompt, task, variables) {
-    let result = systemPrompt;
-    result = result.replace(/\$TASK/g, task);
-    if (variables) {
-      for (const [key, value] of Object.entries(variables)) {
-        const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        result = result.replace(new RegExp(`\\$${escapedKey}`, "g"), value);
-      }
+  getMaxIterations(config, thoroughness) {
+    const defaults = {
+      quick: 2,
+      medium: 5,
+      very_thorough: 10
+    };
+    const configIterations = config.maxIterations || defaults;
+    return configIterations[thoroughness];
+  }
+  /**
+   * Get default system prompt for subagent type
+   */
+  getDefaultSystemPrompt(type) {
+    switch (type) {
+      case "explore":
+        return `You are a code exploration specialist. Your job is to search and analyze codebases efficiently.
+
+Focus on:
+- Finding relevant files and functions
+- Understanding code structure and patterns
+- Providing clear, concise summaries
+
+You have read-only access. Use file_read, grep_search, and glob_files to explore.
+
+When you find what you're looking for, provide a clear summary including:
+1. What you found (files, functions, patterns)
+2. Key insights or observations
+3. Relevant code locations
+
+Be thorough but concise. Your summary will be used by the main agent.`;
+      case "plan":
+        return `You are a task planning specialist. Your job is to break down complex tasks into clear, actionable steps.
+
+Focus on:
+- Identifying dependencies and blockers
+- Creating logical sequence of steps
+- Estimating scope and priorities
+
+Provide a structured plan that the main agent can execute.`;
+      case "review":
+        return `You are a code review specialist. Your job is to analyze code quality and identify issues.
+
+Focus on:
+- Code quality and best practices
+- Potential bugs and edge cases
+- Performance and security considerations
+
+Provide actionable feedback with specific file and line references.`;
+      default:
+        return "You are a helpful AI assistant.";
     }
-    return result;
   }
   /**
-   * Summarize agent result for parent agent
+   * Summarize subagent result for parent agent
    */
-  summarizeResult(result, agentDef) {
+  summarizeResult(result, type) {
     const { finalAnswer, steps, completionInfo } = result;
     const toolCalls = steps.filter((s) => s.type === "action");
     const filesRead = toolCalls.filter((s) => s.metadata?.toolName === "file_read").length;
     const searches = toolCalls.filter((s) => s.metadata?.toolName === "grep_search").length;
     const globs = toolCalls.filter((s) => s.metadata?.toolName === "glob_files").length;
-    const capitalizedName = agentDef.name.charAt(0).toUpperCase() + agentDef.name.slice(1);
-    let summary = `**${capitalizedName} Agent Results**
+    let summary = `**${type.charAt(0).toUpperCase() + type.slice(1)} Subagent Results**
 
-`;
-    summary += `*${agentDef.description}*
 `;
     summary += `*Execution: ${completionInfo.iterations} iterations, ${completionInfo.toolCalls} tool calls*
 
 `;
-    const hasExplorationActivity = filesRead > 0 || searches > 0 || globs > 0;
-    if (hasExplorationActivity) {
+    if (type === "explore") {
       summary += `*Exploration: ${filesRead} files read, ${searches} searches, ${globs} glob patterns*
 
 `;
     }
-    const maxLength = 1500;
+    const maxLength = 1e3;
     if (finalAnswer.length > maxLength) {
       summary += finalAnswer.slice(0, maxLength) + "\n\n...(truncated)";
     } else {
@@ -12167,311 +11926,169 @@ var SubagentOrchestrator = class {
     }
     return summary;
   }
-  /**
-   * Get available agent names (for autocomplete/validation)
-   */
-  getAvailableAgents() {
-    return this.deps.agentStore.getAgentNames();
-  }
-  /**
-   * Check if an agent exists
-   */
-  hasAgent(name) {
-    return this.deps.agentStore.hasAgent(name);
-  }
 };
 
-// src/agents/AgentStore.ts
-import fs13 from "fs/promises";
-import path16 from "path";
-import os3 from "os";
-import matter2 from "gray-matter";
-var AgentStore = class {
-  /**
-   * Creates a new AgentStore
-   *
-   * @param builtinDir - Directory containing built-in agent definitions
-   * @param projectRoot - Root of the project (defaults to cwd)
-   */
-  constructor(builtinDir, projectRoot) {
-    this.agents = /* @__PURE__ */ new Map();
-    const root = projectRoot || process.cwd();
-    const home = os3.homedir();
-    this.builtinAgentsDir = builtinDir;
-    this.globalB4MAgentsDir = path16.join(home, ".bike4mind", "agents");
-    this.globalClaudeAgentsDir = path16.join(home, ".claude", "agents");
-    this.projectB4MAgentsDir = path16.join(root, ".bike4mind", "agents");
-    this.projectClaudeAgentsDir = path16.join(root, ".claude", "agents");
-  }
-  /**
-   * Load all agents from all directories
-   * Precedence (lowest to highest):
-   * 1. builtin
-   * 2. global ~/.bike4mind/agents/
-   * 3. global ~/.claude/agents/
-   * 4. project .bike4mind/agents/
-   * 5. project .claude/agents/
-   */
-  async loadAgents() {
-    this.agents.clear();
-    await this.loadAgentsFromDirectory(this.builtinAgentsDir, "builtin");
-    await this.loadAgentsFromDirectory(this.globalB4MAgentsDir, "global");
-    await this.loadAgentsFromDirectory(this.globalClaudeAgentsDir, "global");
-    await this.loadAgentsFromDirectory(this.projectB4MAgentsDir, "project");
-    await this.loadAgentsFromDirectory(this.projectClaudeAgentsDir, "project");
-  }
-  /**
-   * Recursively load agents from a directory
-   */
-  async loadAgentsFromDirectory(directory, source) {
-    try {
-      const stats = await fs13.stat(directory);
-      if (!stats.isDirectory()) {
-        return;
-      }
-      const files = await this.findAgentFiles(directory);
-      for (const filePath of files) {
-        try {
-          const agent = await this.parseAgentFile(filePath, source);
-          this.agents.set(agent.name, agent);
-        } catch (error) {
-          console.warn(
-            `Failed to load agent from ${filePath}:`,
-            error instanceof Error ? error.message : String(error)
-          );
-        }
-      }
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        console.warn(`Error accessing agents directory ${directory}`);
-      }
-    }
-  }
-  /**
-   * Recursively find all .md files in directory
-   */
-  async findAgentFiles(directory) {
-    const files = [];
-    try {
-      const entries = await fs13.readdir(directory, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path16.join(directory, entry.name);
-        if (entry.isDirectory()) {
-          const subFiles = await this.findAgentFiles(fullPath);
-          files.push(...subFiles);
-        } else if (entry.isFile() && entry.name.endsWith(".md")) {
-          files.push(fullPath);
-        }
-      }
-    } catch (error) {
-      console.warn(`Error reading directory ${directory}:`, error instanceof Error ? error.message : String(error));
-    }
-    return files;
-  }
-  /**
-   * Parse a single agent markdown file
-   */
-  async parseAgentFile(filePath, source) {
-    const content = await fs13.readFile(filePath, "utf-8");
-    const { data: frontmatter, content: body } = matter2(content);
-    const parsed = AgentFrontmatterSchema.parse(frontmatter);
-    const name = path16.basename(filePath, ".md");
-    return {
-      name,
-      description: parsed.description,
-      model: parsed.model || DEFAULT_AGENT_MODEL,
-      systemPrompt: body.trim(),
-      allowedTools: parsed["allowed-tools"],
-      deniedTools: parsed["denied-tools"],
-      maxIterations: {
-        quick: parsed["max-iterations"]?.quick ?? DEFAULT_MAX_ITERATIONS.quick,
-        medium: parsed["max-iterations"]?.medium ?? DEFAULT_MAX_ITERATIONS.medium,
-        very_thorough: parsed["max-iterations"]?.very_thorough ?? DEFAULT_MAX_ITERATIONS.very_thorough
-      },
-      defaultThoroughness: parsed["default-thoroughness"] || DEFAULT_THOROUGHNESS,
-      defaultVariables: parsed.variables,
-      hooks: parsed.hooks,
-      source,
-      filePath
-    };
-  }
-  /**
-   * Get an agent by name
-   */
-  getAgent(name) {
-    return this.agents.get(name);
-  }
-  /**
-   * Get all loaded agents
-   */
-  getAllAgents() {
-    return Array.from(this.agents.values());
-  }
-  /**
-   * Get available agent names (for autocomplete/validation)
-   */
-  getAgentNames() {
-    return Array.from(this.agents.keys());
-  }
-  /**
-   * Get agents by source
-   */
-  getAgentsBySource(source) {
-    return this.getAllAgents().filter((agent) => agent.source === source);
-  }
-  /**
-   * Check if an agent exists
-   */
-  hasAgent(name) {
-    return this.agents.has(name);
-  }
-  /**
-   * Get the number of loaded agents
-   */
-  getAgentCount() {
-    return this.agents.size;
-  }
-  /**
-   * Reload all agents
-   */
-  async reloadAgents() {
-    await this.loadAgents();
-  }
-  /**
-   * Creates a new agent file from a template
-   *
-   * @param name - Agent name
-   * @param isGlobal - If true, creates in global directory, otherwise project directory
-   * @param useClaude - If true, uses .claude/agents/ convention, otherwise .bike4mind/agents/
-   * @returns Path to the created file
-   */
-  async createAgentFile(name, isGlobal = false, useClaude = true) {
-    const targetDir = isGlobal ? useClaude ? this.globalClaudeAgentsDir : this.globalB4MAgentsDir : useClaude ? this.projectClaudeAgentsDir : this.projectB4MAgentsDir;
-    const filePath = path16.join(targetDir, `${name}.md`);
-    try {
-      await fs13.access(filePath);
-      throw new Error(`Agent file already exists: ${filePath}`);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    await fs13.mkdir(targetDir, { recursive: true });
-    const template = `---
-description: ${name} agent description
-model: claude-3-5-haiku-20241022
-allowed-tools:
-  - file_read
-  - grep_search
-  - glob_files
-  - bash_execute
-denied-tools:
-  - create_file
-  - edit_file
-  - delete_file
-max-iterations:
-  quick: 2
-  medium: 5
-  very_thorough: 10
-default-thoroughness: medium
----
-
-You are a ${name} specialist. Your job is to [describe primary task].
-
-## Focus Areas
-- [Area 1]
-- [Area 2]
-- [Area 3]
-
-## Instructions
-1. [Step 1]
-2. [Step 2]
-3. [Step 3]
-
-## Output Format
-Describe the expected output format here.
-`;
-    await fs13.writeFile(filePath, template, "utf-8");
-    return filePath;
-  }
-  /**
-   * Get summary of loaded agents by source (single-pass iteration)
-   */
-  getSummary() {
-    let builtin = 0;
-    let global = 0;
-    let project = 0;
-    for (const agent of this.agents.values()) {
-      if (agent.source === "builtin") builtin++;
-      else if (agent.source === "global") global++;
-      else project++;
-    }
-    return { builtin, global, project, total: this.agents.size };
-  }
+// src/agents/configs.ts
+var EXPLORE_CONFIG = {
+  type: "explore",
+  model: "claude-3-5-haiku-20241022",
+  systemPrompt: `You are a code exploration specialist. Your job is to search and analyze codebases efficiently.
+
+Focus on:
+- Finding relevant files and functions
+- Understanding code structure and patterns
+- Providing clear, concise summaries
+
+You have read-only access. Use file_read, grep_search, and glob_files to explore.
+
+CODE SEARCH EFFICIENCY:
+1. Start narrow with glob_files using specific patterns (e.g., "**/*Auth*.ts")
+2. Then use grep_search with precise regex on narrowed results
+3. Finally use file_read only on relevant files
+4. Leverage git log to find recent changes
+5. Check test files first to understand feature usage
+6. Batch glob operations instead of multiple separate calls
+
+When you find what you're looking for, provide a clear summary including:
+1. What you found (files, functions, patterns)
+2. Key insights or observations
+3. Relevant code locations
+
+Be thorough but concise. Your summary will be used by the main agent.`,
+  allowedTools: [
+    "file_read",
+    "grep_search",
+    "glob_files",
+    "bash_execute",
+    // Only for read-only commands like ls, cat, find
+    "current_datetime",
+    "math_evaluate"
+  ],
+  deniedTools: [
+    "create_file",
+    "edit_file",
+    "delete_file",
+    "web_search",
+    "weather_info",
+    "blog_publish",
+    "blog_edit",
+    "blog_draft"
+  ],
+  maxIterations: {
+    quick: 2,
+    medium: 5,
+    very_thorough: 10
+  },
+  defaultThoroughness: "medium"
+};
+var PLAN_CONFIG = {
+  type: "plan",
+  model: "claude-3-5-haiku-20241022",
+  systemPrompt: `You are a task planning specialist. Your job is to break down complex tasks into clear, actionable steps.
+
+Focus on:
+- Identifying dependencies and blockers
+- Creating logical sequence of steps
+- Estimating scope and priorities
+
+You have read-only access to analyze code.
+You can explore the codebase to understand the current architecture before planning.
+
+Provide a structured plan that the main agent can execute.`,
+  allowedTools: ["file_read", "grep_search", "glob_files", "bash_execute", "current_datetime", "math_evaluate"],
+  deniedTools: ["create_file", "edit_file", "delete_file", "web_search", "weather_info"],
+  maxIterations: {
+    quick: 3,
+    medium: 7,
+    very_thorough: 12
+  },
+  defaultThoroughness: "medium"
 };
+var REVIEW_CONFIG = {
+  type: "review",
+  model: "claude-sonnet-4-5-20250929",
+  // Use latest Sonnet for better reasoning
+  systemPrompt: `You are a code review specialist. Your job is to analyze code quality and identify issues.
+
+Focus on:
+- Code quality and best practices
+- Potential bugs and edge cases
+- Performance and security considerations
+
+You have read-only access to analyze code.
+
+Provide actionable feedback with specific file and line references.`,
+  allowedTools: ["file_read", "grep_search", "glob_files", "bash_execute", "current_datetime"],
+  deniedTools: ["create_file", "edit_file", "delete_file", "web_search", "weather_info"],
+  maxIterations: {
+    quick: 3,
+    medium: 8,
+    very_thorough: 15
+  },
+  defaultThoroughness: "medium"
+};
+function getDefaultSubagentConfigs() {
+  return /* @__PURE__ */ new Map([
+    ["explore", EXPLORE_CONFIG],
+    ["plan", PLAN_CONFIG],
+    ["review", REVIEW_CONFIG]
+  ]);
+}
 
 // src/agents/delegateTool.ts
-function createAgentDelegateTool(orchestrator, agentStore, parentSessionId) {
-  const agents = agentStore.getAllAgents();
-  const agentDescriptions = agents.map((a) => `- **${a.name}**: ${a.description}`).join("\n");
-  const agentNames = agentStore.getAgentNames();
+function createSubagentDelegateTool(orchestrator, parentSessionId) {
   return {
     toolFn: async (args) => {
       const params = args;
       if (!params.task) {
-        throw new Error("agent_delegate: task parameter is required");
-      }
-      if (!params.agent) {
-        throw new Error("agent_delegate: agent parameter is required");
+        throw new Error("subagent_delegate: task parameter is required");
       }
-      if (!agentStore.hasAgent(params.agent)) {
-        const available = agentNames.join(", ");
-        throw new Error(`agent_delegate: unknown agent "${params.agent}". Available agents: ${available}`);
+      if (!params.type) {
+        throw new Error("subagent_delegate: type parameter is required");
       }
-      const result = await orchestrator.delegateToAgent({
+      const thoroughness = params.thoroughness || "medium";
+      const type = params.type;
+      const result = await orchestrator.delegateToSubagent({
         task: params.task,
-        agentName: params.agent,
-        thoroughness: params.thoroughness,
-        variables: params.variables,
+        type,
+        thoroughness,
         parentSessionId
       });
       return result.summary;
     },
     toolSchema: {
-      name: "agent_delegate",
-      description: `Delegate a task to a specialized agent for focused work.
-
-**Available Agents:**
-${agentDescriptions}
+      name: "subagent_delegate",
+      description: `Delegate a task to a specialized subagent for focused work.
 
 **When to use this tool:**
-- **explore**: When you need to search through the codebase, find files, or understand code structure (read-only)
-- **plan**: When you need to break down a complex task into actionable steps
-- **review**: When you need to analyze code quality and identify potential issues
-- Custom agents: Use for domain-specific tasks defined in project or global agent files
+- **Explore**: When you need to search through the codebase, find files, or understand code structure (read-only)
+- **Plan**: When you need to break down a complex task into actionable steps
+- **Review**: When you need to analyze code quality and identify potential issues
 
 **Benefits:**
 - Keeps main conversation focused and clean
 - Uses specialized prompts optimized for each task type
 - Faster execution with appropriate models (Haiku for explore/plan, Sonnet for review)
-- Supports custom variables for parameterized behavior
 
 **Example uses:**
-- "Find all files that use the authentication system" \u2192 agent: explore
-- "Search for components that handle user input" \u2192 agent: explore
-- "Break down implementing a new feature into steps" \u2192 agent: plan
-- "Review this module for potential bugs" \u2192 agent: review`,
+- "Find all files that use the authentication system" \u2192 explore
+- "Search for components that handle user input" \u2192 explore
+- "Break down implementing a new feature into steps" \u2192 plan
+- "Review this module for potential bugs" \u2192 review`,
       parameters: {
         type: "object",
         properties: {
           task: {
             type: "string",
-            description: "Clear description of what you want the agent to do. Be specific about what you're looking for or what needs to be accomplished."
+            description: "Clear description of what you want the subagent to do. Be specific about what you're looking for or what needs to be accomplished."
           },
-          agent: {
+          type: {
             type: "string",
-            enum: agentNames,
-            description: `Name of the agent to use for this task. Available: ${agentNames.join(", ")}`
+            enum: ["explore", "plan", "review"],
+            description: `Type of subagent to use:
+- explore: Read-only codebase exploration and search (fast, uses Haiku)
+- plan: Task breakdown and planning (uses Haiku)
+- review: Code quality analysis and review (uses Sonnet for better reasoning)`
           },
           thoroughness: {
             type: "string",
@@ -12479,15 +12096,10 @@ ${agentDescriptions}
             description: `How thoroughly to execute:
 - quick: Fast lookup, 1-2 iterations
 - medium: Balanced exploration, 3-5 iterations (default)
-- very_thorough: Comprehensive analysis, 8-10+ iterations`
-          },
-          variables: {
-            type: "object",
-            additionalProperties: { type: "string" },
-            description: 'Custom variables to substitute in agent system prompt. For example: { "DOMAIN": "authentication", "STRICTNESS": "high" }'
+- very_thorough: Comprehensive analysis, 8-10 iterations`
           }
         },
-        required: ["task", "agent"]
+        required: ["task", "type"]
       }
     }
   };
@@ -12618,6 +12230,134 @@ function createTodoStore(onUpdate) {
   };
 }
 
+// src/tools/skillTool.ts
+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(customCommandStore) {
+  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 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"}`);
+      }
+      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")}`;
+      }
+      return `## Skill Loaded: /${skillName}
+
+${expandedBody}
+
+---
+*Follow the instructions above. This skill was invoked programmatically.*`;
+    },
+    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 formatSkillEntry(cmd) {
+  const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
+  return `- **${cmd.name}**${argHint}: ${cmd.description}
+`;
+}
+function formatSkillGroup(heading, commands) {
+  if (commands.length === 0) {
+    return "";
+  }
+  return `
+### ${heading}
+${commands.map(formatSkillEntry).join("")}`;
+}
+function buildSkillsPromptSection(commands) {
+  if (commands.length === 0) {
+    return "";
+  }
+  const projectSkills = commands.filter((c) => c.source === "project");
+  const globalSkills = commands.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/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -12650,7 +12390,6 @@ function CliApp() {
     rewindSelector: null,
     sessionSelector: null,
     orchestrator: null,
-    agentStore: null,
     abortController: null
   });
   const [isInitialized, setIsInitialized] = useState8(false);
@@ -12882,14 +12621,21 @@ function CliApp() {
       } else {
         console.log(`\u{1F4E1} No MCP tools loaded`);
       }
-      const builtinAgentsDir = new URL("./agents/defaults/", import.meta.url).pathname;
-      const agentProjectDir = state.configStore.getProjectConfigDir();
-      const agentStore = new AgentStore(builtinAgentsDir, agentProjectDir || process.cwd());
-      await agentStore.loadAgents();
-      const agentSummary = agentStore.getSummary();
-      console.log(
-        `\u{1F916} Loaded ${agentSummary.total} agent(s): ${agentSummary.builtin} built-in, ${agentSummary.global} global, ${agentSummary.project} project`
-      );
+      const subagentConfigs = getDefaultSubagentConfigs();
+      if (config.subagents) {
+        if (config.subagents.explore) {
+          const currentConfig = subagentConfigs.get("explore");
+          subagentConfigs.set("explore", { ...currentConfig, ...config.subagents.explore });
+        }
+        if (config.subagents.plan) {
+          const currentConfig = subagentConfigs.get("plan");
+          subagentConfigs.set("plan", { ...currentConfig, ...config.subagents.plan });
+        }
+        if (config.subagents.review) {
+          const currentConfig = subagentConfigs.get("review");
+          subagentConfigs.set("review", { ...currentConfig, ...config.subagents.review });
+        }
+      }
       const orchestrator = new SubagentOrchestrator({
         userId: config.userId,
         llm,
@@ -12898,14 +12644,28 @@ function CliApp() {
         showPermissionPrompt: promptFn,
         configStore: state.configStore,
         apiClient,
-        agentStore
+        subagentConfigs
       });
-      const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id);
+      const subagentDelegateTool = createSubagentDelegateTool(orchestrator, newSession.id);
       const todoStore = createTodoStore();
       const writeTodosTool = createWriteTodosTool(todoStore);
-      const allTools = [...b4mTools, ...mcpTools, agentDelegateTool, writeTodosTool];
+      const enableSkillTool = config.preferences.enableSkillTool !== false;
+      const skillTool = enableSkillTool ? createSkillTool(state.customCommandStore) : null;
+      const cliTools = [subagentDelegateTool, writeTodosTool];
+      if (skillTool) {
+        cliTools.push(skillTool);
+      }
+      const allTools = [...b4mTools, ...mcpTools, ...cliTools];
+      console.log(`\u{1F4C2} Working directory: ${process.cwd()}`);
+      console.log(`\u{1F916} Subagent delegation enabled (explore, plan, review)`);
+      if (skillTool) {
+        const skillCount = state.customCommandStore.getCommandCount();
+        if (skillCount > 0) {
+          console.log(`\u{1F6E0}\uFE0F  Skill tool enabled (${skillCount} skills available)`);
+        }
+      }
       logger.debug(
-        `Total tools available to agent: ${allTools.length} (${b4mTools.length} B4M + ${mcpTools.length} MCP + 2 CLI)`
+        `Total tools available to agent: ${allTools.length} (${b4mTools.length} B4M + ${mcpTools.length} MCP + ${cliTools.length} CLI)`
       );
       const projectDir = state.configStore.getProjectConfigDir();
       const contextResult = await loadContextFiles(projectDir);
@@ -12918,13 +12678,17 @@ function CliApp() {
       for (const error of contextResult.errors) {
         console.log(`\u26A0\uFE0F  Context file error: ${error}`);
       }
-      const contextSection = contextResult.mergedContent ? `
+      let contextSection = contextResult.mergedContent ? `
 
 ## Project Context
 
 Follow these project-specific instructions:
 
 ${contextResult.mergedContent}` : "";
+      if (enableSkillTool) {
+        const commands = state.customCommandStore.getAllCommands();
+        contextSection += buildSkillsPromptSection(commands);
+      }
       const cliSystemPrompt = buildCoreSystemPrompt(contextSection);
       const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
       const agent = new ReActAgent({
@@ -12978,10 +12742,8 @@ ${contextResult.mergedContent}` : "";
         // Store config for synchronous access
         availableModels: models,
         // Store models for ConfigEditor
-        orchestrator,
+        orchestrator
         // Store orchestrator for step handler updates
-        agentStore
-        // Store agent store for agent management commands
       }));
       setStoreSession(newSession);
       setIsInitialized(true);
@@ -13420,20 +13182,6 @@ ${output}` : output.trim() || "(no output)",
       toolCallCount
     };
   };
-  const displayAgentsBySource = (agents, label, emoji) => {
-    if (agents.length > 0) {
-      console.log(`${emoji} ${label}:`);
-      const terminalWidth = process.stdout.columns || 80;
-      const nameWidth = 25;
-      const prefixWidth = 2 + nameWidth + 3;
-      const maxDescLength = Math.max(20, terminalWidth - prefixWidth);
-      agents.forEach((agent) => {
-        const desc = agent.description.length > maxDescLength ? agent.description.slice(0, maxDescLength - 3) + "..." : agent.description;
-        console.log(`  ${agent.name.padEnd(nameWidth)} - ${desc}`);
-      });
-      console.log("");
-    }
-  };
   const handleCommand = async (command, args) => {
     const customCommand = state.customCommandStore.getCommand(command);
     if (customCommand) {
@@ -13450,25 +13198,6 @@ ${output}` : output.trim() || "(no output)",
           console.log("\u{1F4DD} Expanded command:\n", substitutedBody);
         }
         const displayMessage = `/${command}${args.length > 0 ? " " + args.join(" ") : ""}`;
-        if (customCommand.agent && state.orchestrator && state.agentStore) {
-          if (!state.agentStore.hasAgent(customCommand.agent)) {
-            const available = state.agentStore.getAgentNames().join(", ");
-            console.error(`\u274C Unknown agent "${customCommand.agent}" specified in command.`);
-            console.error(`   Available agents: ${available}`);
-            return;
-          }
-          console.log(`\u{1F916} Delegating to ${customCommand.agent} agent...
-`);
-          const result = await state.orchestrator.delegateToAgent({
-            task: substitutedBody,
-            agentName: customCommand.agent,
-            thoroughness: customCommand.thoroughness,
-            variables: customCommand.variables,
-            parentSessionId: state.session?.id || "unknown"
-          });
-          console.log("\n" + result.summary + "\n");
-          return;
-        }
         if (customCommand.model && state.agent) {
           console.log(`\u{1F504} Using model override: ${customCommand.model}`);
           const originalModel = state.session?.model;
@@ -14033,11 +13762,19 @@ No usage data available for the last ${USAGE_DAYS} days.`);
           console.log("  \u{1F3E0} Global: ~/.bike4mind/commands/ (available in all projects)");
           console.log("  \u{1F4C1} Project: .bike4mind/commands/ (team-shared, committed to git)");
         } else {
+          const termWidth = process.stdout.columns || 80;
+          const truncateDescription = (desc, prefixLen) => {
+            const maxDescLen = termWidth - prefixLen - 5;
+            if (maxDescLen < 20) return desc;
+            return desc.length > maxDescLen ? desc.slice(0, maxDescLen) + "..." : desc;
+          };
           if (globalCommands.length > 0) {
             console.log("\u{1F3E0} Global Commands (~/.bike4mind/commands/):");
             globalCommands.forEach((cmd) => {
               const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
-              console.log(`  /${cmd.name}${argHint} - ${cmd.description}`);
+              const prefix = `  /${cmd.name}${argHint}`;
+              const desc = truncateDescription(cmd.description, prefix.length);
+              console.log(`${prefix} - ${desc}`);
             });
             console.log("");
           }
@@ -14045,7 +13782,9 @@ No usage data available for the last ${USAGE_DAYS} days.`);
             console.log("\u{1F4C1} Project Commands (.bike4mind/commands/):");
             projectCommands.forEach((cmd) => {
               const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
-              console.log(`  /${cmd.name}${argHint} - ${cmd.description}`);
+              const prefix = `  /${cmd.name}${argHint}`;
+              const desc = truncateDescription(cmd.description, prefix.length);
+              console.log(`${prefix} - ${desc}`);
             });
             console.log("");
           }
@@ -14090,78 +13829,6 @@ No usage data available for the last ${USAGE_DAYS} days.`);
         setShowMcpViewer(true);
         break;
       }
-      case "agents":
-      case "agents:list": {
-        if (!state.agentStore) {
-          console.log("\u274C Agent store not initialized");
-          break;
-        }
-        const summary = state.agentStore.getSummary();
-        console.log("\n\u{1F916} Available Agents:\n");
-        if (summary.total === 0) {
-          console.log("No agents found.");
-          console.log("\nTo create a custom agent:");
-          console.log("  /agents:new <name> - Create a new agent");
-        } else {
-          displayAgentsBySource(state.agentStore.getAgentsBySource("builtin"), "Built-in Agents", "\u{1F4E6}");
-          displayAgentsBySource(
-            state.agentStore.getAgentsBySource("global"),
-            "Global Agents (~/.claude/agents/ or ~/.bike4mind/agents/)",
-            "\u{1F3E0}"
-          );
-          displayAgentsBySource(
-            state.agentStore.getAgentsBySource("project"),
-            "Project Agents (.claude/agents/ or .bike4mind/agents/)",
-            "\u{1F4C1}"
-          );
-          console.log(
-            `Total: ${summary.total} agent${summary.total !== 1 ? "s" : ""} (${summary.builtin} built-in, ${summary.global} global, ${summary.project} project)`
-          );
-        }
-        console.log("");
-        break;
-      }
-      case "agents:new": {
-        if (!state.agentStore) {
-          console.log("\u274C Agent store not initialized");
-          break;
-        }
-        const agentName = args[0];
-        if (!agentName) {
-          console.log("\u274C Please provide an agent name");
-          console.log("Usage: /agents:new <name>");
-          break;
-        }
-        console.log("\nWhere should this agent be stored?");
-        console.log("  1. \u{1F3E0} Global (~/.claude/agents/) - available in all projects");
-        console.log("  2. \u{1F4C1} Project (.claude/agents/) - team-shared");
-        console.log("\nDefaulting to global (~/.claude/agents/). Creating agent file...");
-        try {
-          const filePath = await state.agentStore.createAgentFile(agentName, true);
-          console.log(`\u2705 Created agent file: ${filePath}`);
-          console.log("\nEdit this file to customize your agent.");
-          console.log("Then run: /agents:reload to load it");
-        } catch (error) {
-          console.error("\u274C Failed to create agent file:", error instanceof Error ? error.message : String(error));
-        }
-        break;
-      }
-      case "agents:reload": {
-        if (!state.agentStore) {
-          console.log("\u274C Agent store not initialized");
-          break;
-        }
-        try {
-          await state.agentStore.reloadAgents();
-          const summary = state.agentStore.getSummary();
-          console.log(
-            `\u2705 Reloaded ${summary.total} agent${summary.total !== 1 ? "s" : ""} (${summary.builtin} built-in, ${summary.global} global, ${summary.project} project)`
-          );
-        } catch (error) {
-          console.error("\u274C Failed to reload agents:", error instanceof Error ? error.message : String(error));
-        }
-        break;
-      }
       default:
         console.log(`Unknown command: /${command}`);
         console.log("Type /help for available commands");