@bike4mind/cli 0.2.19-feat-github-webhook-endpoint.17809 → 0.2.19-feat-unified-agent-system.17810

package/dist/index.js

@@ -529,6 +529,20 @@ 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() {
@@ -2402,10 +2416,13 @@ var FrontmatterSchema = z.object({
   description: z.string().optional(),
   "argument-hint": z.string().optional(),
   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 +2455,10 @@ function parseCommandFile(fileContent, filePath, commandName, source) {
       model: validFrontmatter.model,
       body: body.trim(),
       source,
-      filePath
+      filePath,
+      agent: validFrontmatter.agent,
+      thoroughness: validFrontmatter.thoroughness,
+      variables: validFrontmatter.variables
     };
   } catch (error) {
     throw new Error(
@@ -5215,8 +5235,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path16 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path16;
+    const path17 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path17;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -6428,8 +6448,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path16 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path16;
+  const path17 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path17;
 }
 async function updateQuestAndReturnMarkdown2(storedImagePath, context) {
   await context.onFinish?.("edit_image", storedImagePath);
@@ -7958,8 +7978,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 z144 = r * sinOmega * sinI;
-  return { x, y, z: z144, r };
+  const z145 = r * sinOmega * sinI;
+  return { x, y, z: z145, r };
 };
 var getGeocentricEcliptic = (planet, earth) => {
   const dx = planet.x - earth.x;
@@ -9682,7 +9702,7 @@ async function generateFileDeletePreview(args) {
     if (!existsSync7(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs13) => fs13.stat(args.path));
+    const stats = await import("fs/promises").then((fs14) => fs14.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -10032,21 +10052,21 @@ var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path16) {
+  async download(path17) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path16) {
+  async delete(path17) {
   }
-  async getSignedUrl(path16) {
-    return `/tmp/${path16}`;
+  async getSignedUrl(path17) {
+    return `/tmp/${path17}`;
   }
-  getPublicUrl(path16) {
-    return `/tmp/${path16}`;
+  getPublicUrl(path17) {
+    return `/tmp/${path17}`;
   }
-  async getPreview(path16) {
-    return `/tmp/${path16}`;
+  async getPreview(path17) {
+    return `/tmp/${path17}`;
   }
-  async getMetadata(path16) {
+  async getMetadata(path17) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -11563,7 +11583,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.19-feat-github-webhook-endpoint.17809+f7b8becbd",
+  version: "0.2.19-feat-unified-agent-system.17810+1e592a9b4",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -11670,10 +11690,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.43.1-feat-github-webhook-endpoint.17809+f7b8becbd",
-    "@bike4mind/mcp": "1.23.1-feat-github-webhook-endpoint.17809+f7b8becbd",
-    "@bike4mind/services": "2.41.2-feat-github-webhook-endpoint.17809+f7b8becbd",
-    "@bike4mind/utils": "2.2.1-feat-github-webhook-endpoint.17809+f7b8becbd",
+    "@bike4mind/common": "2.43.1-feat-unified-agent-system.17810+1e592a9b4",
+    "@bike4mind/mcp": "1.23.1-feat-unified-agent-system.17810+1e592a9b4",
+    "@bike4mind/services": "2.41.2-feat-unified-agent-system.17810+1e592a9b4",
+    "@bike4mind/utils": "2.2.1-feat-unified-agent-system.17810+1e592a9b4",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -11690,7 +11710,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "f7b8becbd1ea101ceb0a0fe5463a370a6bb35ab5"
+  gitHead: "1e592a9b411d5d9436c7ee8f49608dfdaaab3228"
 };
 
 // src/config/constants.ts
@@ -11698,6 +11718,194 @@ var USAGE_DAYS = 30;
 var MODEL_NAME_COLUMN_WIDTH = 18;
 var USAGE_CACHE_TTL = 5 * 60 * 1e3;
 
+// src/agents/types.ts
+import { z as z144 } from "zod";
+var ALWAYS_DENIED_FOR_AGENTS = [
+  "agent_delegate"
+  // No agent chaining
+];
+var HookDefinitionSchema = z144.object({
+  type: z144.enum(["command", "prompt"]),
+  command: z144.string().optional(),
+  prompt: z144.string().optional(),
+  timeout: z144.number().optional()
+});
+var HookMatcherSchema = z144.object({
+  matcher: z144.string().optional(),
+  hooks: z144.array(HookDefinitionSchema)
+});
+var AgentHooksSchema = z144.object({
+  PreToolUse: z144.array(HookMatcherSchema).optional(),
+  PostToolUse: z144.array(HookMatcherSchema).optional(),
+  PostToolUseFailure: z144.array(HookMatcherSchema).optional(),
+  Stop: z144.array(HookMatcherSchema).optional()
+}).optional();
+var AgentFrontmatterSchema = z144.object({
+  description: z144.string().min(1, "Agent description is required"),
+  model: z144.string().optional(),
+  "allowed-tools": z144.array(z144.string()).optional(),
+  "denied-tools": z144.array(z144.string()).optional(),
+  "max-iterations": z144.object({
+    quick: z144.number().int().positive().optional(),
+    medium: z144.number().int().positive().optional(),
+    very_thorough: z144.number().int().positive().optional()
+  }).optional(),
+  "default-thoroughness": z144.enum(["quick", "medium", "very_thorough"]).optional(),
+  variables: z144.record(z144.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/agents/toolFilter.ts
+function matchesToolPattern(toolName, pattern) {
+  const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${regexPattern}$`).test(toolName);
+}
+function matchesAnyPattern(toolName, patterns) {
+  return patterns.some((pattern) => matchesToolPattern(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/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 matchesToolPattern2(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 || matchesToolPattern2(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/SubagentOrchestrator.ts
 var SubagentOrchestrator = class {
   constructor(deps) {
@@ -11706,168 +11914,151 @@ var SubagentOrchestrator = class {
     this.deps = deps;
   }
   /**
-   * Set a callback to be invoked before each subagent.run()
-   * Use this to subscribe to agent events (e.g., subagent.on('action', handler))
+   * 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 subagent.run()
-   * Use this to unsubscribe from agent events (e.g., subagent.off('action', handler))
+   * 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 a specialized subagent
+   * Delegate a task to an agent loaded from markdown definition
    *
-   * @param options - Configuration for subagent execution
-   * @returns Subagent result with summary
+   * @param options - Configuration for agent execution
+   * @returns Agent result with summary
    */
-  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
+  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
     };
-    const model = config.model || "claude-3-5-haiku-20241022";
-    const maxIterations = this.getMaxIterations(config, thoroughness);
+    const systemPrompt = this.substituteVariables(agentDef.systemPrompt, task, effectiveVariables);
     const toolFilter = {
-      allowedTools: config.allowedTools,
-      deniedTools: config.deniedTools
+      allowedTools: agentDef.allowedTools,
+      deniedTools: [...agentDef.deniedTools || [], ...ALWAYS_DENIED_FOR_AGENTS]
     };
     const agentContext = {
       currentAgent: null,
       observationQueue: []
     };
-    const { tools: tools2, agentContext: updatedContext } = generateCliTools(
+    const { tools: allTools, agentContext: updatedContext } = generateCliTools(
       this.deps.userId,
       this.deps.llm,
-      model,
+      agentDef.model,
       this.deps.permissionManager,
       this.deps.showPermissionPrompt,
       agentContext,
       this.deps.configStore,
-      this.deps.apiClient,
-      toolFilter
+      this.deps.apiClient
     );
-    this.deps.logger.debug(`Spawning ${type} subagent with ${tools2.length} tools, thoroughness: ${thoroughness}`);
-    const subagent = new ReActAgent({
+    const filteredTools = filterToolsByPatterns(allTools, toolFilter.allowedTools, toolFilter.deniedTools);
+    this.deps.logger.debug(
+      `Spawning "${agentName}" agent with ${filteredTools.length} tools, thoroughness: ${effectiveThoroughness}, max iterations: ${maxIterations}`
+    );
+    const agent = new ReActAgent({
       userId: this.deps.userId,
       logger: this.deps.logger,
       llm: this.deps.llm,
-      model,
-      tools: tools2,
+      model: agentDef.model,
+      tools: filteredTools,
       maxIterations,
-      systemPrompt: config.systemPrompt || this.getDefaultSystemPrompt(type)
+      systemPrompt
     });
-    updatedContext.currentAgent = subagent;
+    updatedContext.currentAgent = agent;
+    const hookContext = {
+      sessionId: parentSessionId,
+      agentName,
+      cwd: process.cwd()
+    };
     if (this.beforeRunCallback) {
-      this.beforeRunCallback(subagent, type);
+      this.beforeRunCallback(agent, agentName);
     }
     const startTime = Date.now();
-    const result = await subagent.run(task, {
+    const result = await agent.run(task, {
       maxIterations
     });
     const duration = Date.now() - startTime;
+    if (agentDef.hooks?.Stop) {
+      const stopResult = await executeHooks(
+        agentDef.hooks.Stop,
+        buildHookContext({
+          ...hookContext,
+          hookEventName: "Stop"
+        })
+      );
+      if (stopResult.decision === "block") {
+        this.deps.logger.debug(`Stop hook blocked: ${stopResult.reason}`);
+      }
+    }
     if (this.afterRunCallback) {
-      this.afterRunCallback(subagent, type);
+      this.afterRunCallback(agent, agentName);
     }
     this.deps.logger.debug(
-      `Subagent completed in ${duration}ms, ${result.completionInfo.iterations} iterations, ${result.completionInfo.totalTokens} tokens`
+      `Agent "${agentName}" completed in ${duration}ms, ${result.completionInfo.iterations} iterations, ${result.completionInfo.totalTokens} tokens`
     );
-    const summary = this.summarizeResult(result, type);
-    const subagentResult = {
+    const summary = this.summarizeResult(result, agentDef);
+    return {
       ...result,
-      subagentType: type,
-      thoroughness,
+      agentName,
+      thoroughness: effectiveThoroughness,
       summary,
       parentSessionId
     };
-    return subagentResult;
-  }
-  /**
-   * Get max iterations based on thoroughness and config
-   */
-  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
+   * Substitute variables in system prompt
+   * Reserved: $TASK, $ARGUMENTS, $1, $2, etc.
    */
-  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.";
+  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);
+      }
     }
+    return result;
   }
   /**
-   * Summarize subagent result for parent agent
+   * Summarize agent result for parent agent
    */
-  summarizeResult(result, type) {
+  summarizeResult(result, agentDef) {
     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;
-    let summary = `**${type.charAt(0).toUpperCase() + type.slice(1)} Subagent Results**
+    const capitalizedName = agentDef.name.charAt(0).toUpperCase() + agentDef.name.slice(1);
+    let summary = `**${capitalizedName} Agent Results**
 
+`;
+    summary += `*${agentDef.description}*
 `;
     summary += `*Execution: ${completionInfo.iterations} iterations, ${completionInfo.toolCalls} tool calls*
 
 `;
-    if (type === "explore") {
+    const hasExplorationActivity = filesRead > 0 || searches > 0 || globs > 0;
+    if (hasExplorationActivity) {
       summary += `*Exploration: ${filesRead} files read, ${searches} searches, ${globs} glob patterns*
 
 `;
     }
-    const maxLength = 1e3;
+    const maxLength = 1500;
     if (finalAnswer.length > maxLength) {
       summary += finalAnswer.slice(0, maxLength) + "\n\n...(truncated)";
     } else {
@@ -11875,169 +12066,299 @@ Provide actionable feedback with specific file and line references.`;
     }
     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/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"
+// 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();
+    this.builtinAgentsDir = builtinDir;
+    this.globalAgentsDir = path16.join(os3.homedir(), ".bike4mind", "agents");
+    this.projectAgentsDir = path16.join(projectRoot || process.cwd(), ".bike4mind", "agents");
+  }
+  /**
+   * Load all agents from all directories
+   * Precedence: project > global > builtin
+   */
+  async loadAgents() {
+    this.agents.clear();
+    await this.loadAgentsFromDirectory(this.builtinAgentsDir, "builtin");
+    await this.loadAgentsFromDirectory(this.globalAgentsDir, "global");
+    await this.loadAgentsFromDirectory(this.projectAgentsDir, "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
+   * @returns Path to the created file
+   */
+  async createAgentFile(name, isGlobal = false) {
+    const targetDir = isGlobal ? this.globalAgentsDir : this.projectAgentsDir;
+    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 };
+  }
 };
-function getDefaultSubagentConfigs() {
-  return /* @__PURE__ */ new Map([
-    ["explore", EXPLORE_CONFIG],
-    ["plan", PLAN_CONFIG],
-    ["review", REVIEW_CONFIG]
-  ]);
-}
 
 // src/agents/delegateTool.ts
-function createSubagentDelegateTool(orchestrator, parentSessionId) {
+function createAgentDelegateTool(orchestrator, agentStore, parentSessionId) {
+  const agents = agentStore.getAllAgents();
+  const agentDescriptions = agents.map((a) => `- **${a.name}**: ${a.description}`).join("\n");
+  const agentNames = agentStore.getAgentNames();
   return {
     toolFn: async (args) => {
       const params = args;
       if (!params.task) {
-        throw new Error("subagent_delegate: task parameter is required");
+        throw new Error("agent_delegate: task parameter is required");
+      }
+      if (!params.agent) {
+        throw new Error("agent_delegate: agent parameter is required");
       }
-      if (!params.type) {
-        throw new Error("subagent_delegate: type parameter is required");
+      if (!agentStore.hasAgent(params.agent)) {
+        const available = agentNames.join(", ");
+        throw new Error(`agent_delegate: unknown agent "${params.agent}". Available agents: ${available}`);
       }
-      const thoroughness = params.thoroughness || "medium";
-      const type = params.type;
-      const result = await orchestrator.delegateToSubagent({
+      const result = await orchestrator.delegateToAgent({
         task: params.task,
-        type,
-        thoroughness,
+        agentName: params.agent,
+        thoroughness: params.thoroughness,
+        variables: params.variables,
         parentSessionId
       });
       return result.summary;
     },
     toolSchema: {
-      name: "subagent_delegate",
-      description: `Delegate a task to a specialized subagent for focused work.
+      name: "agent_delegate",
+      description: `Delegate a task to a specialized agent for focused work.
+
+**Available Agents:**
+${agentDescriptions}
 
 **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
+- **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
 
 **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 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`,
+- "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`,
       parameters: {
         type: "object",
         properties: {
           task: {
             type: "string",
-            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."
+            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."
           },
-          type: {
+          agent: {
             type: "string",
-            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)`
+            enum: agentNames,
+            description: `Name of the agent to use for this task. Available: ${agentNames.join(", ")}`
           },
           thoroughness: {
             type: "string",
@@ -12045,10 +12366,15 @@ function createSubagentDelegateTool(orchestrator, parentSessionId) {
             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`
+- 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" }'
           }
         },
-        required: ["task", "type"]
+        required: ["task", "agent"]
       }
     }
   };
@@ -12211,6 +12537,7 @@ function CliApp() {
     rewindSelector: null,
     sessionSelector: null,
     orchestrator: null,
+    agentStore: null,
     abortController: null
   });
   const [isInitialized, setIsInitialized] = useState8(false);
@@ -12442,21 +12769,14 @@ function CliApp() {
       } else {
         console.log(`\u{1F4E1} No MCP tools loaded`);
       }
-      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 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 orchestrator = new SubagentOrchestrator({
         userId: config.userId,
         llm,
@@ -12465,13 +12785,12 @@ function CliApp() {
         showPermissionPrompt: promptFn,
         configStore: state.configStore,
         apiClient,
-        subagentConfigs
+        agentStore
       });
-      const subagentDelegateTool = createSubagentDelegateTool(orchestrator, newSession.id);
+      const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id);
       const todoStore = createTodoStore();
       const writeTodosTool = createWriteTodosTool(todoStore);
-      const allTools = [...b4mTools, ...mcpTools, subagentDelegateTool, writeTodosTool];
-      console.log(`\u{1F916} Subagent delegation enabled (explore, plan, review)`);
+      const allTools = [...b4mTools, ...mcpTools, agentDelegateTool, writeTodosTool];
       logger.debug(
         `Total tools available to agent: ${allTools.length} (${b4mTools.length} B4M + ${mcpTools.length} MCP + 2 CLI)`
       );
@@ -12546,8 +12865,10 @@ ${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);
@@ -12986,6 +13307,15 @@ ${output}` : output.trim() || "(no output)",
       toolCallCount
     };
   };
+  const displayAgentsBySource = (agents, label, emoji) => {
+    if (agents.length > 0) {
+      console.log(`${emoji} ${label}:`);
+      agents.forEach((agent) => {
+        console.log(`  ${agent.name.padEnd(15)} - ${agent.description}`);
+      });
+      console.log("");
+    }
+  };
   const handleCommand = async (command, args) => {
     const customCommand = state.customCommandStore.getCommand(command);
     if (customCommand) {
@@ -13002,6 +13332,25 @@ ${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;
@@ -13623,6 +13972,78 @@ 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 (~/.bike4mind/agents/)",
+            "\u{1F3E0}"
+          );
+          displayAgentsBySource(
+            state.agentStore.getAgentsBySource("project"),
+            "Project Agents (.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 (~/.bike4mind/agents/) - available in all projects");
+        console.log("  2. \u{1F4C1} Project (.bike4mind/agents/) - team-shared");
+        console.log("\nDefaulting to global. 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");