minovative-mind-cli 2.0.0 → 2.1.0

package/README.md

@@ -116,6 +116,14 @@ Hot-swap during a session using `/models`:
 
 ---
 
+## 🌐 Multi-Workspace & Cross-Repo Support
+
+Minovative Mind CLI doesn't restrict you to a single repository. You can link multiple external workspaces to your current session and the AI will seamlessly operate across all of them simultaneously. 
+
+By prefixing file paths with `@alias/` (e.g. `@backend/src/api.ts` and `@frontend/src/App.tsx`), the Context Agent, Thread Agents, and Semantic Search tools can investigate, refactor, and coordinate changes across your entire tech stack in a single prompt. The terminal highlights cross-workspace actions with a blue `[alias]` visual tag. Use the "Edit Workspace" menu option to configure your linked projects.
+
+---
+
 ## 🌐 Supported Languages
 
 Minovative Mind CLI fundamentally supports **ALL programming languages** for chat, code generation, planning, and execution, as it relies on Gemini's vast training data.

package/dist/commands/chat.js

@@ -30,6 +30,7 @@ Inside the chat session, you can use the following commands in the slash menu:
   /auto-approve  - Toggle automatic approval of tool/command runs
   /sub-agents    - Toggle the MMAAK Engine for parallel investigation and execution
   /semantic-search - Toggle local vector index capabilities
+  /workspaces    - Manage external workspaces for cross-project development
   /stats         - View current session statistics and configuration
   /commit        - Commit current workspace changes to Git
   /revert        - Revert the last file modification made by the agent
@@ -76,6 +77,8 @@ Chat Controls:
         if (idToken) {
             updateWorkspaceStatus(idToken, workspaceRoot).catch(() => { });
         }
+        const { workspaceRegistry } = await import('../services/workspaceRegistry.js');
+        workspaceRegistry.init();
         await startAgentLoop(workspaceRoot, this.config.version);
     }
 }

package/dist/services/agent/slashCommands.js

@@ -233,14 +233,33 @@ export async function handleSlashCommand(command, context) {
         }
         let targetTimestamp = lastChangeSet ? lastChangeSet.timestamp : null;
         if (revertMenu === 'view_history') {
+            const { workspaceRegistry } = await import('../workspaceRegistry.js');
             const historyOptions = history
                 .slice()
                 .reverse()
-                .map((cs, i) => ({
-                value: cs.timestamp,
-                label: `[${i === 0 ? 'Latest' : `-${i}`}] ${truncate(cs.description, 50)} (${new Date(cs.timestamp).toLocaleTimeString()})${cs.status === 'partial' ? ' [Partial]' : ''}`,
-                hint: `Reverts this and all ${i} changes after it`,
-            }));
+                .map((cs, i) => {
+                const externalWorkspaces = new Set();
+                for (const change of cs.changes) {
+                    if (change.filePath.startsWith('@')) {
+                        const slashIndex = change.filePath.indexOf('/');
+                        const aliasStr = slashIndex === -1 ? change.filePath.substring(1) : change.filePath.substring(1, slashIndex);
+                        const ws = workspaceRegistry.get(aliasStr);
+                        if (ws) {
+                            const rootName = path.basename(ws.absolutePath);
+                            externalWorkspaces.add(rootName);
+                        }
+                        else {
+                            externalWorkspaces.add(`@${aliasStr}`);
+                        }
+                    }
+                }
+                const tags = externalWorkspaces.size > 0 ? pc.blue(` [${Array.from(externalWorkspaces).join(', ')}]`) : '';
+                return {
+                    value: cs.timestamp,
+                    label: `[${i === 0 ? 'Latest' : `-${i}`}] ${truncate(cs.description, 50)}${tags} (${new Date(cs.timestamp).toLocaleTimeString()})${cs.status === 'partial' ? ' [Partial]' : ''}`,
+                    hint: `Reverts this and all ${i} changes after it`,
+                };
+            });
             const selectedHistory = await p['select']({
                 message: 'Select the point in history to revert back to:',
                 options: [...historyOptions, { value: -1, label: 'Cancel' }],
@@ -255,13 +274,14 @@ export async function handleSlashCommand(command, context) {
         try {
             const changesToRevert = changeLogger.popUntil(targetTimestamp);
             const flatChanges = changesToRevert.flatMap((cs) => cs.changes);
+            const { resolveAndValidateMultiWorkspacePath } = await import('../../utils/pathSecurity.js');
             for (const change of flatChanges) {
-                const absPath = path.resolve(workspaceRoot, change.filePath);
+                const { absolutePath } = resolveAndValidateMultiWorkspacePath(workspaceRoot, change.filePath);
                 if (change.action === 'create') {
-                    await fs.rm(absPath, { force: true });
+                    await fs.rm(absolutePath, { force: true });
                 }
                 else if (change.originalContent !== null) {
-                    await fs.writeFile(absPath, change.originalContent, 'utf-8');
+                    await fs.writeFile(absolutePath, change.originalContent, 'utf-8');
                 }
             }
             spinner.stop('Reverted successfully.');
@@ -308,13 +328,41 @@ export async function handleSlashCommand(command, context) {
             console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
             return { shouldContinue: true };
         }
+        const { workspaceRegistry } = await import('../workspaceRegistry.js');
         const sessionOptions = sessions
             .slice()
             .reverse()
-            .map((s) => ({
-            value: s.id,
-            label: `${truncate(s.title, 50)} (${new Date(s.timestamp).toLocaleString()})`,
-        }));
+            .map((s) => {
+            const externalWorkspaces = new Set();
+            if (s.history) {
+                for (const item of s.history) {
+                    if (item.role === 'user' || !item.parts)
+                        continue;
+                    for (const part of item.parts) {
+                        if (part.functionCall && part.functionCall.args && part.functionCall.args.filePath) {
+                            const p = part.functionCall.args.filePath;
+                            if (typeof p === 'string' && p.startsWith('@')) {
+                                const slashIndex = p.indexOf('/');
+                                const aliasStr = slashIndex === -1 ? p.substring(1) : p.substring(1, slashIndex);
+                                const ws = workspaceRegistry.get(aliasStr);
+                                if (ws) {
+                                    const rootName = path.basename(ws.absolutePath);
+                                    externalWorkspaces.add(rootName);
+                                }
+                                else {
+                                    externalWorkspaces.add(`@${aliasStr}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const tags = externalWorkspaces.size > 0 ? pc.blue(` [${Array.from(externalWorkspaces).join(', ')}]`) : '';
+            return {
+                value: s.id,
+                label: `${truncate(s.title, 50)}${tags} (${new Date(s.timestamp).toLocaleString()})`,
+            };
+        });
         if (chatsMenu === 'resume') {
             const selectedSessionId = await p['select']({
                 message: 'Select a session to resume:',
@@ -386,6 +434,159 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    if (lowerCommand === '/workspaces') {
+        const { workspaceRegistry } = await import('../workspaceRegistry.js');
+        while (true) {
+            const allRoots = workspaceRegistry.getAllRoots(workspaceRoot);
+            const options = [];
+            options.push({ value: 'add', label: 'Add Workspace' });
+            const externalRoots = allRoots.filter(r => r.alias);
+            if (externalRoots.length > 0) {
+                options.push({ value: 'edit', label: 'Edit Workspace' });
+                options.push({ value: 'remove', label: 'Remove Workspace' });
+                options.push({ value: 'list', label: 'List Workspaces' });
+            }
+            options.push({ value: 'cancel', label: 'Exit Menu' });
+            const action = await p['select']({
+                message: 'Manage External Workspaces',
+                options,
+            });
+            if (p.isCancel(action) || action === 'cancel') {
+                break;
+            }
+            if (action === 'add') {
+                const aliasStr = await p['text']({
+                    message: 'Enter a short alias (e.g. backend, ui):',
+                    validate: (val) => {
+                        if (!val)
+                            return 'Alias is required';
+                        if (!/^[a-zA-Z0-9_-]+$/.test(val))
+                            return 'Only letters, numbers, hyphens, and underscores';
+                        if (workspaceRegistry.getAllRoots(workspaceRoot).some(r => r.alias === val))
+                            return 'Alias already in use';
+                    }
+                });
+                if (p.isCancel(aliasStr))
+                    continue;
+                const rootPathStr = await p['text']({
+                    message: 'Enter the absolute path to the workspace root (e.g. /Users/name/Projects/app):',
+                    validate: (val) => {
+                        if (!val)
+                            return 'Path is required';
+                    }
+                });
+                if (p.isCancel(rootPathStr))
+                    continue;
+                let cleanRootPathStr = rootPathStr.trim();
+                if ((cleanRootPathStr.startsWith("'") && cleanRootPathStr.endsWith("'")) ||
+                    (cleanRootPathStr.startsWith('"') && cleanRootPathStr.endsWith('"'))) {
+                    cleanRootPathStr = cleanRootPathStr.slice(1, -1);
+                }
+                try {
+                    const stats = await fs.stat(cleanRootPathStr);
+                    if (!stats.isDirectory()) {
+                        p.log.error('Path is not a directory.');
+                        continue;
+                    }
+                    workspaceRegistry.register(aliasStr, cleanRootPathStr);
+                    p.log.success(`Added @${aliasStr} -> ${cleanRootPathStr}`);
+                }
+                catch (e) {
+                    p.log.error(`Invalid path or directory does not exist: ${cleanRootPathStr}`);
+                }
+            }
+            else if (action === 'edit') {
+                const editOptions = externalRoots.map(r => ({
+                    value: r.alias,
+                    label: `@${r.alias} -> ${r.root}`
+                }));
+                editOptions.push({ value: 'cancel', label: 'Cancel' });
+                const aliasToEdit = await p['select']({
+                    message: 'Select workspace to edit:',
+                    options: editOptions
+                });
+                if (p.isCancel(aliasToEdit) || aliasToEdit === 'cancel')
+                    continue;
+                const ws = workspaceRegistry.get(aliasToEdit);
+                if (!ws)
+                    continue;
+                const newAliasStr = await p['text']({
+                    message: `Enter new alias (current: ${ws.alias}):`,
+                    initialValue: ws.alias,
+                    validate: (val) => {
+                        if (!val)
+                            return 'Alias is required';
+                        if (!/^[a-zA-Z0-9_-]+$/.test(val))
+                            return 'Only letters, numbers, hyphens, and underscores';
+                        if (val !== ws.alias && workspaceRegistry.getAllRoots(workspaceRoot).some(r => r.alias === val))
+                            return 'Alias already in use';
+                    }
+                });
+                if (p.isCancel(newAliasStr))
+                    continue;
+                const newRootPathStr = await p['text']({
+                    message: `Enter absolute path to workspace root (e.g. /Users/name/Projects/app):`,
+                    initialValue: ws.absolutePath,
+                    validate: (val) => {
+                        if (!val)
+                            return 'Path is required';
+                    }
+                });
+                if (p.isCancel(newRootPathStr))
+                    continue;
+                let cleanNewRootPathStr = newRootPathStr.trim();
+                if ((cleanNewRootPathStr.startsWith("'") && cleanNewRootPathStr.endsWith("'")) ||
+                    (cleanNewRootPathStr.startsWith('"') && cleanNewRootPathStr.endsWith('"'))) {
+                    cleanNewRootPathStr = cleanNewRootPathStr.slice(1, -1);
+                }
+                try {
+                    const stats = await fs.stat(cleanNewRootPathStr);
+                    if (!stats.isDirectory()) {
+                        p.log.error('Path is not a directory.');
+                        continue;
+                    }
+                    // Remove old alias first to avoid duplicate alias error, or to clean up
+                    workspaceRegistry.unregister(ws.alias);
+                    workspaceRegistry.register(newAliasStr, cleanNewRootPathStr);
+                    p.log.success(`Updated @${newAliasStr} -> ${cleanNewRootPathStr}`);
+                }
+                catch (e) {
+                    // If register failed, try to rollback
+                    p.log.error(`Failed to update workspace: ${e instanceof Error ? e.message : String(e)}`);
+                    try {
+                        workspaceRegistry.register(ws.alias, ws.absolutePath);
+                    }
+                    catch { }
+                }
+            }
+            else if (action === 'remove') {
+                const removeOptions = externalRoots.map(r => ({
+                    value: r.alias,
+                    label: `@${r.alias} -> ${r.root}`
+                }));
+                removeOptions.push({ value: 'cancel', label: 'Cancel' });
+                const aliasToRemove = await p['select']({
+                    message: 'Select workspace to remove:',
+                    options: removeOptions
+                });
+                if (p.isCancel(aliasToRemove) || aliasToRemove === 'cancel')
+                    continue;
+                workspaceRegistry.unregister(aliasToRemove);
+                p.log.success(`Removed @${aliasToRemove}`);
+            }
+            else if (action === 'list') {
+                for (const { alias, root } of allRoots) {
+                    if (alias) {
+                        p.log.step(`${pc.blue(`@${alias}`)} -> ${pc.dim(root)}`);
+                    }
+                    else {
+                        p.log.step(`${pc.cyan('(primary)')} -> ${pc.dim(root)}`);
+                    }
+                }
+            }
+        }
+        return { shouldContinue: true };
+    }
     if (lowerCommand === '/commit') {
         const commitSpinner = p.spinner();
         commitSpinner.start('Staging changes and analyzing diff...');

package/dist/services/agent-tools.js

@@ -4,7 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { SchemaType } from '@google/generative-ai';
-import { resolveAndValidatePath } from '../utils/pathSecurity.js';
+import { resolveAndValidatePath, resolveAndValidateMultiWorkspacePath } from '../utils/pathSecurity.js';
+import { workspaceRegistry } from './workspaceRegistry.js';
 import { changeLogger } from './changeLogger.js';
 import { findBestMatch, applyMatch } from '../utils/fuzzyMatch.js';
 import { validateSyntax } from '../utils/syntaxValidator.js';
@@ -36,13 +37,13 @@ export function getToolDeclarations() {
 export const toolDeclarations = [
     {
         name: 'read_file',
-        description: 'Read the contents of a file at the given path relative to the workspace root. Supports text files and native parsing of .pdf files (including math and diagrams). Use startLine and endLine to read specific chunks of massive files to avoid context limits.',
+        description: 'Read the contents of a file at the given path relative to the workspace root. Supports text files and native parsing of .pdf files (including math and diagrams). Use startLine and endLine to read specific chunks of massive files to avoid context limits. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 filePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file from the workspace root.',
+                    description: 'Relative path to the file from the workspace root, or @alias/path for external workspaces.',
                 },
                 startLine: {
                     type: SchemaType.NUMBER,
@@ -63,13 +64,13 @@ export const toolDeclarations = [
     },
     {
         name: 'write_file',
-        description: 'Create a new file or completely overwrite an existing file with the provided content. Use modify_file for targeted edits instead.',
+        description: 'Create a new file or completely overwrite an existing file with the provided content. Use modify_file for targeted edits instead. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 filePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file from the workspace root.',
+                    description: 'Relative path to the file from the workspace root, or @alias/path for external workspaces.',
                 },
                 content: {
                     type: SchemaType.STRING,
@@ -81,13 +82,13 @@ export const toolDeclarations = [
     },
     {
         name: 'delete_file',
-        description: 'Deletes a file from the filesystem. Use this instead of running an rm command.',
+        description: 'Deletes a file from the filesystem. Use this instead of running an rm command. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 filePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file to delete.',
+                    description: 'Relative path to the file to delete, or @alias/path for external workspaces.',
                 },
             },
             required: ['filePath'],
@@ -95,17 +96,17 @@ export const toolDeclarations = [
     },
     {
         name: 'rename_file',
-        description: 'Moves or renames a file. Use this instead of running an mv command.',
+        description: 'Moves or renames a file. Use this instead of running an mv command. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 sourcePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file to move/rename.',
+                    description: 'Relative path to the file to move/rename, or @alias/path for external workspaces.',
                 },
                 targetPath: {
                     type: SchemaType.STRING,
-                    description: 'New relative path for the file.',
+                    description: 'New relative path for the file, or @alias/path for external workspaces.',
                 },
             },
             required: ['sourcePath', 'targetPath'],
@@ -113,13 +114,13 @@ export const toolDeclarations = [
     },
     {
         name: 'modify_file',
-        description: 'Perform one or multiple targeted search-and-replace edits in a single file. CRITICAL REQUIREMENT: You MUST use read_file or grep_search to fetch the exact current file content BEFORE using this tool. Do NOT guess or hallucinate the searchContent without reading the exact lines first, or the edit will fail. The search strings must match the current file exactly (including whitespace). This is preferred over write_file for editing existing files.',
+        description: 'Perform one or multiple targeted search-and-replace edits in a single file. CRITICAL REQUIREMENT: You MUST use read_file or grep_search to fetch the exact current file content BEFORE using this tool. Do NOT guess or hallucinate the searchContent without reading the exact lines first, or the edit will fail. The search strings must match the current file exactly (including whitespace). This is preferred over write_file for editing existing files. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 filePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file from the workspace root.',
+                    description: 'Relative path to the file from the workspace root, or @alias/path for external workspaces.',
                 },
                 edits: {
                     type: SchemaType.ARRAY,
@@ -145,13 +146,13 @@ export const toolDeclarations = [
     },
     {
         name: 'list_directory',
-        description: 'List files and subdirectories in a directory relative to the workspace root. Returns a recursive tree structure.',
+        description: 'List files and subdirectories in a directory relative to the workspace root. Returns a recursive tree structure. For directories in external workspaces, prefix the path with @alias/ (e.g., @backend/src). Use "@all" to see a summary of all registered workspaces.',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 dirPath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the directory from the workspace root. Use "." for the root.',
+                    description: 'Relative path to the directory from the workspace root, @alias/path for external workspaces, or "@all" for all workspaces.',
                 },
                 maxDepth: {
                     type: SchemaType.NUMBER,
@@ -177,7 +178,7 @@ export const toolDeclarations = [
     },
     {
         name: 'grep_search',
-        description: 'Search for a text pattern across files in the workspace. Returns matching file paths with line numbers and content snippets. Uses Extended Regular Expressions (grep -E). IMPORTANT: grep searches line-by-line. Do NOT search for long lists of Tailwind classes or multi-line strings, as they will fail if line-wrapped. Search for short, unique substrings.',
+        description: 'Search for a text pattern across files in the workspace. Returns matching file paths with line numbers and content snippets. Uses Extended Regular Expressions (grep -E). IMPORTANT: grep searches line-by-line. Do NOT search for long lists of Tailwind classes or multi-line strings, as they will fail if line-wrapped. Search for short, unique substrings. Use the workspace parameter to search external workspaces.',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
@@ -189,6 +190,10 @@ export const toolDeclarations = [
                     type: SchemaType.STRING,
                     description: 'Optional glob to restrict file types, e.g. "*.ts" or "*.py". Defaults to all files.',
                 },
+                workspace: {
+                    type: SchemaType.STRING,
+                    description: 'Optional. Workspace alias to search in (e.g., "backend"), or "all" to search all registered workspaces. Defaults to the primary workspace.',
+                },
             },
             required: ['pattern'],
         },
@@ -889,36 +894,145 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
         }
     }
 }
+/**
+ * Resolves `@alias/` prefixed paths in tool arguments to the correct workspace root
+ * and relative path. Returns the effective workspaceRoot and the cleaned arguments.
+ */
+function resolveWorkspaceArgs(primaryRoot, toolName, args) {
+    // Only resolve if workspaces are registered
+    if (!workspaceRegistry.hasWorkspaces()) {
+        return { effectiveRoot: primaryRoot, resolvedArgs: args };
+    }
+    const resolvedArgs = { ...args };
+    // Map of tool-name -> argument keys that hold file/dir paths
+    const pathArgKeys = {
+        read_file: ['filePath'],
+        write_file: ['filePath'],
+        delete_file: ['filePath'],
+        modify_file: ['filePath'],
+        list_directory: ['dirPath'],
+        find_dependencies: ['filePath'],
+        find_recent_changes: ['dirPath'],
+        rename_file: ['sourcePath', 'targetPath'],
+    };
+    const keys = pathArgKeys[toolName];
+    if (!keys) {
+        return { effectiveRoot: primaryRoot, resolvedArgs };
+    }
+    let effectiveRoot = primaryRoot;
+    for (const key of keys) {
+        const val = resolvedArgs[key];
+        if (typeof val !== 'string' || !val.startsWith('@'))
+            continue;
+        // Special case: "@all" for list_directory — handled separately in executeTool
+        if (val === '@all')
+            continue;
+        const resolved = resolveAndValidateMultiWorkspacePath(primaryRoot, val);
+        effectiveRoot = resolved.workspaceRoot;
+        resolvedArgs[key] = resolved.relativePath;
+    }
+    return { effectiveRoot, resolvedArgs };
+}
+/**
+ * Runs grep across all registered workspaces (primary + external) and merges results.
+ * Results from external workspaces are prefixed with @alias/ for disambiguation.
+ */
+async function crossWorkspaceGrep(primaryRoot, pattern, fileGlob, abortSignal) {
+    const allRoots = workspaceRegistry.getAllRoots(primaryRoot);
+    const allResults = [];
+    for (const { alias, root } of allRoots) {
+        const result = await grepSearch(root, pattern, fileGlob, abortSignal);
+        if (result.error)
+            continue;
+        // Extract the raw text from the XML wrapper
+        const cdataMatch = result.output.match(/<!\[CDATA\[\n([\s\S]*?)\n\]\]>/);
+        const rawText = cdataMatch ? cdataMatch[1] : result.output;
+        if (rawText.startsWith('No matches found'))
+            continue;
+        // Prefix each result line with the workspace alias for disambiguation
+        const prefix = alias ? `@${alias}/` : '';
+        const lines = rawText.split('\n').filter((l) => l.trim());
+        for (const line of lines) {
+            if (line.startsWith('...')) {
+                allResults.push(line);
+            }
+            else {
+                // Lines are in format "./path:lineNum:content" — prepend alias prefix
+                allResults.push(prefix ? line.replace(/^\.?\//, `@${alias}/`) : line);
+            }
+        }
+    }
+    if (allResults.length === 0) {
+        return { output: `No matches found for "${pattern}" across all workspaces.` };
+    }
+    const limited = allResults.slice(0, 80);
+    const resultText = limited.join('\n') +
+        (allResults.length > 80 ? `\n\n... (${allResults.length - 80} more results truncated)` : '');
+    const wrappedResult = `<workspace_file path="grep_search_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(resultText)}\n]]></content_data>\n</workspace_file>`;
+    return { output: wrappedResult };
+}
 export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
+    // ─── Multi-Workspace Path Resolution ─────────────────────────────
+    // Intercept @alias/ prefixed paths and swap workspaceRoot + relative path
+    // before dispatching to the underlying tool functions (which remain unchanged).
+    const { effectiveRoot, resolvedArgs } = resolveWorkspaceArgs(workspaceRoot, toolName, args);
     let result;
     switch (toolName) {
         case 'read_file':
-            result = await readFile(workspaceRoot, args.filePath, args.startLine, args.endLine, args.targetElements);
+            result = await readFile(effectiveRoot, resolvedArgs.filePath, resolvedArgs.startLine, resolvedArgs.endLine, resolvedArgs.targetElements);
             break;
         case 'write_file':
-            result = await writeFile(workspaceRoot, args.filePath, args.content);
+            result = await writeFile(effectiveRoot, resolvedArgs.filePath, resolvedArgs.content);
             break;
         case 'delete_file':
-            result = await deleteFile(workspaceRoot, args.filePath);
+            result = await deleteFile(effectiveRoot, resolvedArgs.filePath);
             break;
         case 'rename_file':
-            result = await renameFile(workspaceRoot, args.sourcePath, args.targetPath);
+            result = await renameFile(effectiveRoot, resolvedArgs.sourcePath, resolvedArgs.targetPath);
             break;
         case 'modify_file':
-            result = await modifyFile(workspaceRoot, args.filePath, args.edits);
+            result = await modifyFile(effectiveRoot, resolvedArgs.filePath, resolvedArgs.edits);
             break;
-        case 'list_directory':
-            result = await listDirectory(workspaceRoot, args.dirPath, args.maxDepth ?? 3);
+        case 'list_directory': {
+            const dirPath = resolvedArgs.dirPath;
+            // Handle @all — list all registered workspace roots
+            if (dirPath === '@all') {
+                const allRoots = workspaceRegistry.getAllRoots(workspaceRoot);
+                const sections = [];
+                for (const { alias, root } of allRoots) {
+                    const label = alias ? `@${alias}` : '(primary)';
+                    const subResult = await listDirectory(root, '.', 2);
+                    sections.push(`=== Workspace: ${label} [${root}] ===\n${subResult.output}`);
+                }
+                result = { output: sections.join('\n\n') };
+            }
+            else {
+                result = await listDirectory(effectiveRoot, dirPath, resolvedArgs.maxDepth ?? 3);
+            }
             break;
+        }
         case 'run_command':
-            result = await runCommand(workspaceRoot, args.command, abortSignal);
+            result = await runCommand(effectiveRoot, resolvedArgs.command, abortSignal);
             break;
         case 'run_debug_script':
-            result = await runDebugScript(workspaceRoot, args.language, args.code, abortSignal);
+            result = await runDebugScript(effectiveRoot, resolvedArgs.language, resolvedArgs.code, abortSignal);
             break;
-        case 'grep_search':
-            result = await grepSearch(workspaceRoot, args.pattern, args.fileGlob, abortSignal);
+        case 'grep_search': {
+            const wsParam = resolvedArgs.workspace;
+            if (wsParam === 'all') {
+                // Cross-workspace search across all registered workspaces
+                result = await crossWorkspaceGrep(workspaceRoot, resolvedArgs.pattern, resolvedArgs.fileGlob, abortSignal);
+            }
+            else if (wsParam && workspaceRegistry.get(wsParam)) {
+                // Search in a specific external workspace
+                const ws = workspaceRegistry.get(wsParam);
+                result = await grepSearch(ws.absolutePath, resolvedArgs.pattern, resolvedArgs.fileGlob, abortSignal);
+            }
+            else {
+                result = await grepSearch(effectiveRoot, resolvedArgs.pattern, resolvedArgs.fileGlob, abortSignal);
+            }
             break;
+        }
         case 'semantic_search': {
             const query = args.query;
             const topK = args.topK || 5;
@@ -950,10 +1064,10 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
             break;
         }
         case 'find_dependencies':
-            result = await traceDependencies(workspaceRoot, args.filePath, args.direction, args.maxDepth);
+            result = await traceDependencies(effectiveRoot, resolvedArgs.filePath, resolvedArgs.direction, resolvedArgs.maxDepth);
             break;
         case 'find_recent_changes':
-            result = await findRecentChanges(workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
+            result = await findRecentChanges(effectiveRoot, resolvedArgs.dirPath, resolvedArgs.minutes, resolvedArgs.maxDepth);
             break;
         default:
             result = { output: '', error: `Unknown tool: "${toolName}"` };

package/dist/services/agent.js

@@ -140,6 +140,7 @@ export async function startAgentLoop(workspaceRoot, version) {
                         label: '/semantic-search',
                         hint: 'Toggle local vector index capabilities for better search',
                     },
+                    { value: '/workspaces', label: '/workspaces', hint: 'Manage external workspaces for cross-project development' },
                     { value: '/stats', label: '/stats', hint: 'View current session statistics and configuration' },
                     { value: '/commit', label: '/commit', hint: 'Auto-commit changes with AI message' },
                     { value: '/revert', label: '/revert', hint: 'Undo last change' },
@@ -306,6 +307,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     selectedModel = GEMINI_MODELS.FLASH_LITE_3_1;
                 }
                 else {
+                    spinner.stop(); // MUST clear the investigation spinner first to prevent leaking the setInterval
                     spinner.start(pc.blue('🧠 Evaluating execution complexity...'));
                     const complexity = await evaluateExecutionComplexity(finalInput, gatherRes.contextResult?.summary, gatherRes.contextResult?.relevantFiles?.size || 0);
                     spinner.stop();
@@ -331,6 +333,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 else {
                     // Parallel investigation already printed its own detailed summary log
                     if (!inputHandler.isCurrentlyPrompting()) {
+                        spinner.stop(); // MUST clear the investigation spinner first to prevent leaking the setInterval
                         spinner.start('Thinking...');
                     }
                 }