@bike4mind/cli 0.2.10-feat-cli-multi-directory-workspace.17245 → 0.2.10-feat-explore-subagent-implementation.17246

package/dist/index.js

@@ -91,13 +91,8 @@ import { Box as Box10, Text as Text10, Static } from "ink";
 // src/components/StatusBar.tsx
 import React from "react";
 import { Box, Text } from "ink";
-var StatusBar = React.memo(function StatusBar2({
-  sessionName,
-  model,
-  tokenUsage,
-  workspaceCount
-}) {
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, sessionName), /* @__PURE__ */ React.createElement(Box, { gap: 2 }, workspaceCount && workspaceCount > 1 && /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "\u{1F4C1} ", workspaceCount, " dirs"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, tokenUsage.toLocaleString(), " tokens"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, model)));
+var StatusBar = React.memo(function StatusBar2({ sessionName, model, tokenUsage }) {
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, sessionName), /* @__PURE__ */ React.createElement(Box, { gap: 2 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, tokenUsage.toLocaleString(), " tokens"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, model)));
 });
 
 // src/components/InputPrompt.tsx
@@ -1430,7 +1425,6 @@ function App({
   const sessionName = useCliStore((state) => state.session?.name || "New Session");
   const currentModel = useCliStore((state) => state.session?.model || "claude-sonnet-4-5-20250929");
   const totalTokens = useCliStore((state) => state.session?.metadata.totalTokens || 0);
-  const workspaceCount = useCliStore((state) => state.session?.workingDirectories?.length || 1);
   const isThinking = useCliStore((state) => state.isThinking);
   const permissionPrompt = useCliStore((state) => state.permissionPrompt);
   const showConfigEditor = useCliStore((state) => state.showConfigEditor);
@@ -1496,15 +1490,7 @@ ${errorBlock}`;
       onPrefillConsumed,
       onBashModeChange: setIsBashMode
     }
-  )), /* @__PURE__ */ React11.createElement(
-    StatusBar,
-    {
-      sessionName,
-      model: currentModel,
-      tokenUsage: totalTokens,
-      workspaceCount
-    }
-  )));
+  )), /* @__PURE__ */ React11.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens })));
 }
 
 // src/components/MessageList.tsx
@@ -5165,8 +5151,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 path15 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path15;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -6378,8 +6364,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 path15 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path15;
 }
 async function updateQuestAndReturnMarkdown2(storedImagePath, context) {
   await context.onFinish?.("edit_image", storedImagePath);
@@ -8283,7 +8269,8 @@ var fileReadTool = {
         return content;
       } catch (error) {
         context.logger.error("\u274C FileRead: Failed", error);
-        throw error;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return `Error reading file: ${errorMessage}`;
       }
     },
     toolSchema: {
@@ -9470,7 +9457,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((fs12) => fs12.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -9815,330 +9802,26 @@ async function executeTool(toolName, input, apiClient, localToolFn) {
   }
 }
 
-// src/tools/workspaceAwareFileTools.ts
-import path13 from "path";
-import fs11 from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-function validatePathInWorkspace(filePath, workspaceManager) {
-  try {
-    return workspaceManager.resolvePath(filePath);
-  } catch (error) {
-    throw error;
-  }
-}
-function createWorkspaceAwareFileRead(workspaceManager) {
-  return {
-    toolSchema: {
-      name: "file_read",
-      description: "Read contents of a file from the workspace. Returns file contents as a string.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "Path to the file to read (relative to workspace or absolute)"
-          }
-        },
-        required: ["path"]
-      }
-    },
-    toolFn: async (parameters) => {
-      const args = parameters;
-      const { path: filePath } = args;
-      const resolvedPath = validatePathInWorkspace(filePath, workspaceManager);
-      if (!existsSync8(resolvedPath)) {
-        throw new Error(`File not found: ${filePath}`);
-      }
-      const content = await fs11.readFile(resolvedPath, "utf-8");
-      return content;
-    }
-  };
-}
-function createWorkspaceAwareCreateFile(workspaceManager) {
-  return {
-    toolSchema: {
-      name: "create_file",
-      description: "Create a new file with the given content in the workspace.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "Path where the file should be created (relative to workspace or absolute)"
-          },
-          content: {
-            type: "string",
-            description: "Content to write to the file"
-          }
-        },
-        required: ["path", "content"]
-      }
-    },
-    toolFn: async (parameters) => {
-      const args = parameters;
-      const { path: filePath, content } = args;
-      const resolvedPath = validatePathInWorkspace(filePath, workspaceManager);
-      if (existsSync8(resolvedPath)) {
-        throw new Error(`File already exists: ${filePath}. Use edit_file to modify existing files.`);
-      }
-      const parentDir = path13.dirname(resolvedPath);
-      await fs11.mkdir(parentDir, { recursive: true });
-      await fs11.writeFile(resolvedPath, content, "utf-8");
-      return `File created successfully: ${filePath}`;
-    }
-  };
-}
-function createWorkspaceAwareEditFile(workspaceManager) {
-  return {
-    toolSchema: {
-      name: "edit_file",
-      description: "Edit an existing file by replacing its entire content.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "Path to the file to edit (relative to workspace or absolute)"
-          },
-          content: {
-            type: "string",
-            description: "New content for the file"
-          }
-        },
-        required: ["path", "content"]
-      }
-    },
-    toolFn: async (parameters) => {
-      const args = parameters;
-      const { path: filePath, content } = args;
-      const resolvedPath = validatePathInWorkspace(filePath, workspaceManager);
-      if (!existsSync8(resolvedPath)) {
-        throw new Error(`File not found: ${filePath}. Use create_file to create new files.`);
-      }
-      await fs11.writeFile(resolvedPath, content, "utf-8");
-      return `File edited successfully: ${filePath}`;
-    }
-  };
-}
-function createWorkspaceAwareDeleteFile(workspaceManager) {
-  return {
-    toolSchema: {
-      name: "delete_file",
-      description: "Delete a file from the workspace.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "Path to the file to delete (relative to workspace or absolute)"
-          }
-        },
-        required: ["path"]
-      }
-    },
-    toolFn: async (parameters) => {
-      const args = parameters;
-      const { path: filePath } = args;
-      const resolvedPath = validatePathInWorkspace(filePath, workspaceManager);
-      if (!existsSync8(resolvedPath)) {
-        throw new Error(`File not found: ${filePath}`);
-      }
-      await fs11.unlink(resolvedPath);
-      return `File deleted successfully: ${filePath}`;
-    }
-  };
-}
-function createWorkspaceAwareGlobFiles(workspaceManager) {
-  return {
-    toolSchema: {
-      name: "glob_files",
-      description: "Search for files matching a glob pattern in the workspace.",
-      parameters: {
-        type: "object",
-        properties: {
-          pattern: {
-            type: "string",
-            description: 'Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js")'
-          },
-          cwd: {
-            type: "string",
-            description: "Directory to search from (relative to primary workspace or absolute)"
-          }
-        },
-        required: ["pattern"]
-      }
-    },
-    toolFn: async (parameters) => {
-      const args = parameters;
-      const { pattern, cwd: relativeCwd } = args;
-      const primaryWorkspace = workspaceManager.getPrimaryWorkspace();
-      let searchDir = primaryWorkspace;
-      if (relativeCwd) {
-        searchDir = validatePathInWorkspace(relativeCwd, workspaceManager);
-      }
-      const glob = (await import("fast-glob")).default;
-      const files = await glob(pattern, {
-        cwd: searchDir,
-        absolute: false,
-        onlyFiles: true
-      });
-      const result = {
-        pattern,
-        cwd: searchDir,
-        files: files.map((f) => path13.join(searchDir, f)),
-        count: files.length
-      };
-      return JSON.stringify(result);
-    }
-  };
-}
-function createWorkspaceAwareGrepSearch(workspaceManager) {
-  return {
-    toolSchema: {
-      name: "grep_search",
-      description: "Search for text patterns in files within the workspace using grep.",
-      parameters: {
-        type: "object",
-        properties: {
-          pattern: {
-            type: "string",
-            description: "Regular expression pattern to search for"
-          },
-          path: {
-            type: "string",
-            description: "Directory or file to search (relative to primary workspace or absolute)"
-          },
-          filePattern: {
-            type: "string",
-            description: 'File pattern to filter files (e.g., "*.ts", "*.js")'
-          }
-        },
-        required: ["pattern"]
-      }
-    },
-    toolFn: async (parameters) => {
-      const args = parameters;
-      const { pattern, path: searchPath, filePattern } = args;
-      const primaryWorkspace = workspaceManager.getPrimaryWorkspace();
-      let searchDir = primaryWorkspace;
-      if (searchPath) {
-        searchDir = validatePathInWorkspace(searchPath, workspaceManager);
-      }
-      const glob = (await import("fast-glob")).default;
-      const globPattern = filePattern || "**/*";
-      const files = await glob(globPattern, {
-        cwd: searchDir,
-        absolute: true,
-        onlyFiles: true
-      });
-      const matches = [];
-      const regex = new RegExp(pattern, "gi");
-      for (const file of files) {
-        try {
-          const content = await fs11.readFile(file, "utf-8");
-          const lines = content.split("\n");
-          lines.forEach((line, index) => {
-            if (regex.test(line)) {
-              matches.push({
-                file: path13.relative(primaryWorkspace, file),
-                line: index + 1,
-                content: line.trim()
-              });
-            }
-          });
-        } catch (error) {
-        }
-      }
-      const result = {
-        pattern,
-        searchDir,
-        matches,
-        totalMatches: matches.length
-      };
-      return JSON.stringify(result);
-    }
-  };
-}
-function createWorkspaceAwareBashExecute(workspaceManager) {
-  return {
-    toolSchema: {
-      name: "bash_execute",
-      description: "Execute a bash command in the workspace. Use with caution.",
-      parameters: {
-        type: "object",
-        properties: {
-          command: {
-            type: "string",
-            description: "Bash command to execute"
-          },
-          cwd: {
-            type: "string",
-            description: "Working directory for command execution (relative to primary workspace or absolute)"
-          },
-          timeout: {
-            type: "number",
-            description: "Timeout in milliseconds (default: 30000)"
-          }
-        },
-        required: ["command"]
-      }
-    },
-    toolFn: async (parameters) => {
-      const args = parameters;
-      const { command, cwd: relativeCwd, timeout = 3e4 } = args;
-      const primaryWorkspace = workspaceManager.getPrimaryWorkspace();
-      let execDir = primaryWorkspace;
-      if (relativeCwd) {
-        execDir = path13.resolve(primaryWorkspace, relativeCwd);
-      }
-      const { execSync: execSync2 } = await import("child_process");
-      try {
-        const output = execSync2(command, {
-          cwd: execDir,
-          encoding: "utf-8",
-          timeout,
-          maxBuffer: 10 * 1024 * 1024
-          // 10MB
-        });
-        const result = {
-          success: true,
-          output: output.toString(),
-          exitCode: 0
-        };
-        return JSON.stringify(result);
-      } catch (error) {
-        const result = {
-          success: false,
-          output: error.stdout?.toString() || "",
-          error: error.stderr?.toString() || error.message,
-          exitCode: error.status || 1
-        };
-        return JSON.stringify(result);
-      }
-    }
-  };
-}
-
 // src/utils/toolsAdapter.ts
 var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path17) {
+  async download(path15) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path17) {
+  async delete(path15) {
   }
-  async getSignedUrl(path17) {
-    return `/tmp/${path17}`;
+  async getSignedUrl(path15) {
+    return `/tmp/${path15}`;
   }
-  getPublicUrl(path17) {
-    return `/tmp/${path17}`;
+  getPublicUrl(path15) {
+    return `/tmp/${path15}`;
   }
-  async getPreview(path17) {
-    return `/tmp/${path17}`;
+  async getPreview(path15) {
+    return `/tmp/${path15}`;
   }
-  async getMetadata(path17) {
+  async getMetadata(path15) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -10232,7 +9915,31 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
     }
   };
 }
-function generateCliTools(userId, llm, model, permissionManager, workspaceManager, showPermissionPrompt, agentContext, configStore, apiClient) {
+var TOOL_NAME_MAPPING = {
+  // Claude Code -> B4M
+  read: "file_read",
+  write: "create_file",
+  edit: "edit_file",
+  delete: "delete_file",
+  glob: "glob_files",
+  grep: "grep_search",
+  bash: "bash_execute",
+  // B4M -> Claude Code (reverse mapping)
+  file_read: "read",
+  create_file: "write",
+  edit_file: "edit",
+  delete_file: "delete",
+  glob_files: "glob",
+  grep_search: "grep",
+  bash_execute: "bash"
+};
+function normalizeToolName(toolName) {
+  if (toolName.includes("_")) {
+    return toolName;
+  }
+  return TOOL_NAME_MAPPING[toolName] || toolName;
+}
+function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient, toolFilter) {
   const logger2 = new CliLogger();
   const storage = new NoOpStorage();
   const user = {
@@ -10302,32 +10009,25 @@ function generateCliTools(userId, llm, model, permissionManager, workspaceManage
     toolConfig,
     model
   );
-  const tools2 = Object.entries(toolsMap).filter(([key]) => toolConfig[key] !== void 0).map(
+  let tools2 = Object.entries(toolsMap).filter(([key]) => toolConfig[key] !== void 0).map(
     ([_, tool]) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient)
   );
-  const fileToolNames = [
-    "file_read",
-    "create_file",
-    "edit_file",
-    "delete_file",
-    "glob_files",
-    "grep_search",
-    "bash_execute"
-  ];
-  const workspaceAwareTools = [
-    createWorkspaceAwareFileRead(workspaceManager),
-    createWorkspaceAwareCreateFile(workspaceManager),
-    createWorkspaceAwareEditFile(workspaceManager),
-    createWorkspaceAwareDeleteFile(workspaceManager),
-    createWorkspaceAwareGlobFiles(workspaceManager),
-    createWorkspaceAwareGrepSearch(workspaceManager),
-    createWorkspaceAwareBashExecute(workspaceManager)
-  ];
-  const filteredTools = tools2.filter((tool) => !fileToolNames.includes(tool.toolSchema.name));
-  const wrappedWorkspaceTools = workspaceAwareTools.map(
-    (tool) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient)
-  );
-  return { tools: [...filteredTools, ...wrappedWorkspaceTools], agentContext };
+  if (toolFilter) {
+    const { allowedTools, deniedTools } = toolFilter;
+    const normalizedAllowed = allowedTools?.map(normalizeToolName);
+    const normalizedDenied = deniedTools?.map(normalizeToolName);
+    tools2 = tools2.filter((tool) => {
+      const toolName = tool.toolSchema.name;
+      if (normalizedDenied && normalizedDenied.includes(toolName)) {
+        return false;
+      }
+      if (normalizedAllowed && normalizedAllowed.length > 0) {
+        return normalizedAllowed.includes(toolName);
+      }
+      return true;
+    });
+  }
+  return { tools: tools2, agentContext };
 }
 
 // src/config/toolSafety.ts
@@ -10506,174 +10206,6 @@ var PermissionManager = class {
   }
 };
 
-// src/utils/WorkspaceManager.ts
-import path14 from "path";
-import fs12 from "fs";
-var WorkspaceManager = class _WorkspaceManager {
-  constructor(initialWorkspaces = [process.cwd()]) {
-    this.workspaces = [];
-    this.workspaces = initialWorkspaces.length > 0 ? initialWorkspaces.map((dir) => path14.resolve(dir)) : [path14.resolve(process.cwd())];
-  }
-  static {
-    /**
-     * System directories that should never be added as workspaces
-     */
-    this.FORBIDDEN_PATHS = [
-      "/",
-      "/bin",
-      "/boot",
-      "/dev",
-      "/etc",
-      "/lib",
-      "/lib64",
-      "/proc",
-      "/root",
-      "/sbin",
-      "/sys",
-      "/usr",
-      "/var",
-      "/tmp",
-      "/System",
-      "/Library",
-      "/Applications",
-      "/Windows",
-      "/Program Files",
-      "/Program Files (x86)"
-    ];
-  }
-  /**
-   * Get all workspace directories
-   */
-  getWorkspaces() {
-    return [...this.workspaces];
-  }
-  /**
-   * Get the primary workspace (first in list, used as default)
-   */
-  getPrimaryWorkspace() {
-    return this.workspaces[0] || process.cwd();
-  }
-  /**
-   * Add a new workspace directory
-   * @throws Error if directory is invalid, doesn't exist, or is forbidden
-   */
-  addWorkspace(directory) {
-    const resolvedPath = path14.resolve(directory);
-    if (!fs12.existsSync(resolvedPath)) {
-      throw new Error(`Directory does not exist: ${resolvedPath}`);
-    }
-    const stat = fs12.statSync(resolvedPath);
-    if (!stat.isDirectory()) {
-      throw new Error(`Path is not a directory: ${resolvedPath}`);
-    }
-    if (_WorkspaceManager.isForbiddenPath(resolvedPath)) {
-      throw new Error(
-        `Cannot add system directory as workspace: ${resolvedPath}
-Adding system directories like /, /usr, /etc is not allowed for security reasons.`
-      );
-    }
-    if (this.workspaces.includes(resolvedPath)) {
-      throw new Error(`Directory already in workspace: ${resolvedPath}`);
-    }
-    this.workspaces.push(resolvedPath);
-  }
-  /**
-   * Remove a workspace directory
-   * @throws Error if trying to remove the last/primary workspace
-   */
-  removeWorkspace(directory) {
-    const resolvedPath = path14.resolve(directory);
-    const index = this.workspaces.indexOf(resolvedPath);
-    if (index === -1) {
-      throw new Error(`Directory not in workspace: ${resolvedPath}`);
-    }
-    if (this.workspaces.length === 1) {
-      throw new Error("Cannot remove the last workspace directory");
-    }
-    if (index === 0) {
-      throw new Error(
-        "Cannot remove the primary workspace. Remove other directories first, or use /clear to start a new session."
-      );
-    }
-    this.workspaces.splice(index, 1);
-  }
-  /**
-   * Check if a path is within any workspace
-   * @param filePath Absolute or relative path to check
-   * @returns true if path is within an allowed workspace
-   */
-  isPathInWorkspace(filePath) {
-    const absolutePath = path14.isAbsolute(filePath) ? filePath : path14.resolve(this.getPrimaryWorkspace(), filePath);
-    return this.workspaces.some(
-      (workspace) => absolutePath.startsWith(workspace + path14.sep) || absolutePath === workspace
-    );
-  }
-  /**
-   * Resolve a file path across all workspaces
-   * For relative paths: searches all workspaces and returns first match
-   * For absolute paths: validates it's within a workspace
-   * @throws Error if path is outside all workspaces
-   */
-  resolvePath(filePath) {
-    if (path14.isAbsolute(filePath)) {
-      if (!this.isPathInWorkspace(filePath)) {
-        throw new Error(
-          `Access denied: Path is outside all workspace directories.
-Path: ${filePath}
-Workspaces: ${this.workspaces.join(", ")}
-Use '/directory add <path>' to add the directory to your workspace.`
-        );
-      }
-      return filePath;
-    }
-    const primaryResolved = path14.resolve(this.getPrimaryWorkspace(), filePath);
-    if (fs12.existsSync(primaryResolved)) {
-      return primaryResolved;
-    }
-    for (let i = 1; i < this.workspaces.length; i++) {
-      const candidatePath = path14.resolve(this.workspaces[i], filePath);
-      if (fs12.existsSync(candidatePath)) {
-        return candidatePath;
-      }
-    }
-    return primaryResolved;
-  }
-  /**
-   * Get the workspace that contains a given path
-   * @returns The workspace directory, or null if not in any workspace
-   */
-  getWorkspaceForPath(filePath) {
-    const absolutePath = path14.isAbsolute(filePath) ? filePath : path14.resolve(this.getPrimaryWorkspace(), filePath);
-    for (const workspace of this.workspaces) {
-      if (absolutePath.startsWith(workspace + path14.sep) || absolutePath === workspace) {
-        return workspace;
-      }
-    }
-    return null;
-  }
-  /**
-   * Check if a path is a forbidden system directory
-   */
-  static isForbiddenPath(resolvedPath) {
-    if (_WorkspaceManager.FORBIDDEN_PATHS.includes(resolvedPath)) {
-      return true;
-    }
-    return _WorkspaceManager.FORBIDDEN_PATHS.some((forbidden) => resolvedPath.startsWith(forbidden + path14.sep));
-  }
-  /**
-   * Serialize workspace state for storage in session
-   */
-  toJSON() {
-    return this.getWorkspaces();
-  }
-  /**
-   * Create WorkspaceManager from serialized state
-   */
-  static fromJSON(workspaces) {
-    return new _WorkspaceManager(workspaces);
-  }
-};
-
 // src/utils/apiUrl.ts
 var BIKE4MIND_URL = "https://app.bike4mind.com";
 function getApiUrl(configApiConfig) {
@@ -10690,8 +10222,8 @@ function getEnvironmentName(configApiConfig) {
 }
 
 // src/utils/contextLoader.ts
-import * as fs13 from "fs";
-import * as path15 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 import { homedir as homedir4 } from "os";
 var CONTEXT_FILE_SIZE_LIMIT = 100 * 1024;
 var PROJECT_CONTEXT_FILES = [
@@ -10712,9 +10244,9 @@ function formatFileSize2(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 function tryReadContextFile(dir, filename, source) {
-  const filePath = path15.join(dir, filename);
+  const filePath = path13.join(dir, filename);
   try {
-    const stats = fs13.lstatSync(filePath);
+    const stats = fs11.lstatSync(filePath);
     if (stats.isDirectory()) {
       return null;
     }
@@ -10728,7 +10260,7 @@ function tryReadContextFile(dir, filename, source) {
         error: `${source === "global" ? "Global" : "Project"} ${filename} exceeds 100KB limit (${formatFileSize2(stats.size)})`
       };
     }
-    const content = fs13.readFileSync(filePath, "utf-8");
+    const content = fs11.readFileSync(filePath, "utf-8");
     return {
       filename,
       content,
@@ -10780,7 +10312,7 @@ ${project.content}`;
 }
 async function loadContextFiles(projectDir) {
   const errors = [];
-  const globalDir = path15.join(homedir4(), ".bike4mind");
+  const globalDir = path13.join(homedir4(), ".bike4mind");
   const projectDirectory = projectDir || process.cwd();
   const [globalResult, projectResult] = await Promise.all([
     Promise.resolve(findContextFile(globalDir, GLOBAL_CONTEXT_FILES, "global")),
@@ -10804,8 +10336,8 @@ async function loadContextFiles(projectDir) {
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path16 from "path";
-import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
+import path14 from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
@@ -10845,18 +10377,18 @@ var MCPClient = class {
         const root = process.env.INIT_CWD || process.cwd();
         const candidatePaths = [
           // When running from SST Lambda with node_modules structure (copyFiles)
-          path16.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+          path14.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda deployed environment (/var/task)
-          path16.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path14.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda (.sst/artifacts/mcpHandler-dev), navigate to monorepo root (3 levels up)
-          path16.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path14.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from packages/client (Next.js app), navigate to monorepo root (2 levels up)
-          path16.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path14.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // Original paths (backward compatibility)
-          path16.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-          path16.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+          path14.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path14.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
         ];
-        const serverScriptPath = candidatePaths.find((p) => existsSync9(p));
+        const serverScriptPath = candidatePaths.find((p) => existsSync8(p));
         if (!serverScriptPath) {
           const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
           console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
@@ -11658,7 +11190,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.10-feat-cli-multi-directory-workspace.17245+b0d0fbabe",
+  version: "0.2.10-feat-explore-subagent-implementation.17246+5c3defa5d",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -11726,7 +11258,6 @@ var package_default = {
     diff: "^8.0.2",
     dotenv: "^16.3.1",
     "eventsource-parser": "^3.0.6",
-    "fast-glob": "^3.3.3",
     "file-type": "^18.7.0",
     "fuse.js": "^7.1.0",
     ink: "^6.5.1",
@@ -11762,10 +11293,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.39.1-feat-cli-multi-directory-workspace.17245+b0d0fbabe",
-    "@bike4mind/mcp": "1.20.4-feat-cli-multi-directory-workspace.17245+b0d0fbabe",
-    "@bike4mind/services": "2.34.2-feat-cli-multi-directory-workspace.17245+b0d0fbabe",
-    "@bike4mind/utils": "2.1.4-feat-cli-multi-directory-workspace.17245+b0d0fbabe",
+    "@bike4mind/common": "2.39.1-feat-explore-subagent-implementation.17246+5c3defa5d",
+    "@bike4mind/mcp": "1.20.4-feat-explore-subagent-implementation.17246+5c3defa5d",
+    "@bike4mind/services": "2.34.2-feat-explore-subagent-implementation.17246+5c3defa5d",
+    "@bike4mind/utils": "2.1.4-feat-explore-subagent-implementation.17246+5c3defa5d",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -11778,7 +11309,7 @@ var package_default = {
     typescript: "^5.9.3",
     vitest: "^3.2.4"
   },
-  gitHead: "b0d0fbabeacd5799168626cb093b2573301f0e84"
+  gitHead: "5c3defa5da2bec9450d7b030dafc850c05863d68"
 };
 
 // src/config/constants.ts
@@ -11786,6 +11317,331 @@ var USAGE_DAYS = 30;
 var MODEL_NAME_COLUMN_WIDTH = 18;
 var USAGE_CACHE_TTL = 5 * 60 * 1e3;
 
+// src/agents/SubagentOrchestrator.ts
+var SubagentOrchestrator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Delegate a task to a specialized subagent
+   *
+   * @param options - Configuration for subagent execution
+   * @returns Subagent 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
+    };
+    const model = config.model || "claude-3-5-haiku-20241022";
+    const maxIterations = this.getMaxIterations(config, thoroughness);
+    const toolFilter = {
+      allowedTools: config.allowedTools,
+      deniedTools: config.deniedTools
+    };
+    const agentContext = {
+      currentAgent: null,
+      observationQueue: []
+    };
+    const { tools: tools2, agentContext: updatedContext } = generateCliTools(
+      this.deps.userId,
+      this.deps.llm,
+      model,
+      this.deps.permissionManager,
+      this.deps.showPermissionPrompt,
+      agentContext,
+      this.deps.configStore,
+      this.deps.apiClient,
+      toolFilter
+    );
+    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,
+      tools: tools2,
+      maxIterations,
+      systemPrompt: config.systemPrompt || this.getDefaultSystemPrompt(type)
+    });
+    updatedContext.currentAgent = subagent;
+    const startTime = Date.now();
+    const result = await subagent.run(task, {
+      maxIterations
+    });
+    const duration = Date.now() - startTime;
+    this.deps.logger.debug(
+      `Subagent completed in ${duration}ms, ${result.completionInfo.iterations} iterations, ${result.completionInfo.totalTokens} tokens`
+    );
+    const summary = this.summarizeResult(result, type);
+    const subagentResult = {
+      ...result,
+      subagentType: type,
+      thoroughness,
+      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
+   */
+  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.";
+    }
+  }
+  /**
+   * Summarize subagent result for parent agent
+   */
+  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;
+    let summary = `**${type.charAt(0).toUpperCase() + type.slice(1)} Subagent Results**
+
+`;
+    summary += `*Execution: ${completionInfo.iterations} iterations, ${completionInfo.toolCalls} tool calls*
+
+`;
+    if (type === "explore") {
+      summary += `*Exploration: ${filesRead} files read, ${searches} searches, ${globs} glob patterns*
+
+`;
+    }
+    const maxLength = 1e3;
+    if (finalAnswer.length > maxLength) {
+      summary += finalAnswer.slice(0, maxLength) + "\n\n...(truncated)";
+    } else {
+      summary += finalAnswer;
+    }
+    return summary;
+  }
+};
+
+// 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.
+
+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 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-3-5-sonnet-20241022",
+  // Use 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 createSubagentDelegateTool(orchestrator, parentSessionId) {
+  return {
+    toolFn: async (args) => {
+      const params = args;
+      if (!params.task) {
+        throw new Error("subagent_delegate: task parameter is required");
+      }
+      if (!params.type) {
+        throw new Error("subagent_delegate: type parameter is required");
+      }
+      const thoroughness = params.thoroughness || "medium";
+      const type = params.type;
+      const result = await orchestrator.delegateToSubagent({
+        task: params.task,
+        type,
+        thoroughness,
+        parentSessionId
+      });
+      return result.summary;
+    },
+    toolSchema: {
+      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
+
+**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)
+
+**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`,
+      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."
+          },
+          type: {
+            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)`
+          },
+          thoroughness: {
+            type: "string",
+            enum: ["quick", "medium", "very_thorough"],
+            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`
+          }
+        },
+        required: ["task", "type"]
+      }
+    }
+  };
+}
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -11800,19 +11656,6 @@ var usageCache = null;
 function CliApp() {
   const { exit } = useApp();
   const imageRenderer = new ImageRenderer();
-  const getInitialWorkspaces = () => {
-    const workspaces = [process.cwd()];
-    const addDirsEnv = process.env.B4M_ADD_DIRS;
-    if (addDirsEnv) {
-      try {
-        const additionalDirs = JSON.parse(addDirsEnv);
-        workspaces.push(...additionalDirs);
-      } catch (error) {
-        logger.warn(`Failed to parse B4M_ADD_DIRS environment variable: ${error}`);
-      }
-    }
-    return workspaces;
-  };
   const [state, setState] = useState8({
     session: null,
     sessionStore: new SessionStore(),
@@ -11825,7 +11668,6 @@ function CliApp() {
     agent: null,
     mcpManager: null,
     permissionManager: null,
-    workspaceManager: new WorkspaceManager(getInitialWorkspaces()),
     permissionPrompt: null,
     trustLocationSelector: null,
     rewindSelector: null,
@@ -11930,8 +11772,7 @@ function CliApp() {
             totalTokens: 0,
             totalCost: 0,
             toolCallCount: 0
-          },
-          workingDirectories: state.workspaceManager.getWorkspaces()
+          }
         };
         setState((prev) => ({
           ...prev,
@@ -11976,8 +11817,7 @@ function CliApp() {
           totalTokens: 0,
           totalCost: 0,
           toolCallCount: 0
-        },
-        workingDirectories: state.workspaceManager.getWorkspaces()
+        }
       };
       await logger.initialize(newSession.id);
       logger.setVerbose(process.env.B4M_VERBOSE === "1");
@@ -12024,7 +11864,6 @@ function CliApp() {
         llm,
         modelInfo.id,
         permissionManager,
-        state.workspaceManager,
         promptFn,
         agentContext,
         state.configStore,
@@ -12040,7 +11879,34 @@ function CliApp() {
           console.log(`  \u{1F4E1} ${serverName}: ${count} tool(s)`);
         });
       }
-      const allTools = [...b4mTools, ...mcpTools];
+      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,
+        logger: silentLogger,
+        permissionManager,
+        showPermissionPrompt: promptFn,
+        configStore: state.configStore,
+        apiClient,
+        subagentConfigs
+      });
+      const subagentDelegateTool = createSubagentDelegateTool(orchestrator, newSession.id);
+      const allTools = [...b4mTools, ...mcpTools, subagentDelegateTool];
+      console.log(`\u{1F916} Subagent delegation enabled (explore, plan, review)`);
       const projectDir = state.configStore.getProjectConfigDir();
       const contextResult = await loadContextFiles(projectDir);
       if (contextResult.globalContext) {
@@ -12077,6 +11943,15 @@ FOR CODING TASKS:
 - When searching for code: Use grep_search or glob_files to find relevant files
 - Permission system will ask for approval before any file writes
 
+SUBAGENT DELEGATION:
+- You have access to specialized subagents via the subagent_delegate tool
+- Use subagents for focused exploration, planning, or review tasks:
+  * explore: Fast read-only codebase search (e.g., "find all auth files", "locate API endpoints")
+  * plan: Break down complex tasks into actionable steps
+  * review: Analyze code quality and identify issues
+- Subagents keep the main conversation clean and run faster with optimized models
+- Delegate when you need to search extensively or analyze code structure
+
 FOR GENERAL TASKS:
 - Use available tools to get information (weather, web search, calculations, etc.)
 - When user asks follow-up questions, use conversation context to understand what they're referring to
@@ -12087,6 +11962,7 @@ EXAMPLES:
 - "how about Japan?" \u2192 use weather tool for Japan (applying same question from context)
 - "enhance README" \u2192 file_read \u2192 generate \u2192 create_file
 - "what packages installed?" \u2192 glob_files "**/package.json" \u2192 file_read
+- "find all components using React hooks" \u2192 subagent_delegate(task="find all components using React hooks", type="explore")
 
 Remember: Use context from previous messages to understand follow-up questions.${contextSection}`;
       const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
@@ -12365,11 +12241,6 @@ Tool Permissions:
   /untrust <tool-name> - Remove tool from trusted list
   /trusted - List all trusted tools
 
-Workspace Management:
-  /directory show - Show all workspace directories
-  /directory add <path> - Add directory to workspace
-  /directory remove <path> - Remove directory from workspace
-
 Project Configuration:
   /project-config - Show merged project configuration
         `);
@@ -12411,24 +12282,7 @@ Project Configuration:
           }
           await logger.initialize(loadedSession.id);
           logger.debug("=== Session Resumed ===");
-          if (loadedSession.workingDirectories && loadedSession.workingDirectories.length > 0) {
-            try {
-              const restoredWorkspaceManager = WorkspaceManager.fromJSON(loadedSession.workingDirectories);
-              setState((prev) => ({
-                ...prev,
-                session: loadedSession,
-                workspaceManager: restoredWorkspaceManager
-              }));
-              console.log(
-                `\u{1F4C1} Restored ${loadedSession.workingDirectories.length} workspace director${loadedSession.workingDirectories.length !== 1 ? "ies" : "y"}`
-              );
-            } catch (error) {
-              logger.warn(`Failed to restore workspace directories from session: ${error}`);
-              setState((prev) => ({ ...prev, session: loadedSession }));
-            }
-          } else {
-            setState((prev) => ({ ...prev, session: loadedSession }));
-          }
+          setState((prev) => ({ ...prev, session: loadedSession }));
           setStoreSession(loadedSession);
           useCliStore.getState().clearAgentSteps();
           useCliStore.getState().clearPendingMessages();
@@ -12624,74 +12478,6 @@ Project Configuration:
         }
         console.log("");
         break;
-      case "directory": {
-        const subcommand = args[0];
-        if (!subcommand || subcommand === "show") {
-          const workspaces = state.workspaceManager.getWorkspaces();
-          console.log("\n\u{1F4C1} Workspace Directories:\n");
-          workspaces.forEach((dir, index) => {
-            const label = index === 0 ? " (primary)" : "";
-            console.log(`  ${index + 1}. ${dir}${label}`);
-          });
-          console.log("");
-          break;
-        }
-        if (subcommand === "add") {
-          const dirPath = args[1];
-          if (!dirPath) {
-            console.log("Usage: /directory add <path>");
-            console.log("Example: /directory add ../other-project");
-            break;
-          }
-          try {
-            state.workspaceManager.addWorkspace(dirPath);
-            if (state.session) {
-              const updatedSession = {
-                ...state.session,
-                workingDirectories: state.workspaceManager.getWorkspaces()
-              };
-              setState((prev) => ({ ...prev, session: updatedSession }));
-              await state.sessionStore.save(updatedSession);
-            }
-            console.log(`\u2705 Added directory to workspace: ${dirPath}`);
-            console.log(`\u{1F4C1} Workspace now has ${state.workspaceManager.getWorkspaces().length} directories`);
-          } catch (error) {
-            console.log(`\u274C Failed to add directory: ${error.message}`);
-          }
-          break;
-        }
-        if (subcommand === "remove") {
-          const dirPath = args[1];
-          if (!dirPath) {
-            console.log("Usage: /directory remove <path>");
-            console.log("Example: /directory remove ../other-project");
-            break;
-          }
-          try {
-            state.workspaceManager.removeWorkspace(dirPath);
-            if (state.session) {
-              const updatedSession = {
-                ...state.session,
-                workingDirectories: state.workspaceManager.getWorkspaces()
-              };
-              setState((prev) => ({ ...prev, session: updatedSession }));
-              await state.sessionStore.save(updatedSession);
-            }
-            console.log(`\u2705 Removed directory from workspace: ${dirPath}`);
-            console.log(
-              `\u{1F4C1} Workspace now has ${state.workspaceManager.getWorkspaces().length} director${state.workspaceManager.getWorkspaces().length !== 1 ? "ies" : "y"}`
-            );
-          } catch (error) {
-            console.log(`\u274C Failed to remove directory: ${error.message}`);
-          }
-          break;
-        }
-        console.log("Unknown subcommand. Usage:");
-        console.log("  /directory show - Show all workspace directories");
-        console.log("  /directory add <path> - Add directory to workspace");
-        console.log("  /directory remove <path> - Remove directory from workspace");
-        break;
-      }
       case "login":
         setState((prev) => ({ ...prev, showLoginFlow: true }));
         break;
@@ -12728,8 +12514,7 @@ Project Configuration:
             totalTokens: 0,
             totalCost: 0,
             toolCallCount: 0
-          },
-          workingDirectories: state.workspaceManager.getWorkspaces()
+          }
         };
         await logger.initialize(newSession.id);
         logger.debug("=== New Session Started via /clear ===");