minovative-mind-cli 2.1.1 → 2.1.3

package/README.md

@@ -15,6 +15,9 @@ the build/performance metrics are green.
 [![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
 [![Version](https://img.shields.io/npm/v/minovative-mind-cli.svg)](https://npmjs.org/package/minovative-mind-cli)
 [![Downloads/week](https://img.shields.io/npm/dw/minovative-mind-cli.svg)](https://npmjs.org/package/minovative-mind-cli)
+[![Node.js Version](https://img.shields.io/node/v/minovative-mind-cli.svg)](https://nodejs.org)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![License](https://img.shields.io/npm/l/minovative-mind-cli.svg)](https://github.com/quarantiine/minovative-mind-cli/blob/main/LICENSE.md)
 
 - Official Website: [Main Website](https://www.minovativemind.dev/)
 - Latest Updates: [Updates](https://www.minovativemind.dev/updates)
@@ -121,7 +124,7 @@ Hot-swap during a session using `/models`:
 
 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.
+By prefixing file paths with `@alias/` (e.g. `@backend/src/api.ts` and `@frontend/src/App.tsx`), the Context Agent and Thread Agents 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.
 
 ---
 

package/dist/commands/chat.js

@@ -29,7 +29,6 @@ Inside the chat session, you can use the following commands in the slash menu:
   /debug         - Debug tests or command execution in a sandbox loop
   /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
@@ -56,9 +55,13 @@ Chat Controls:
         console.clear();
         // Setup update notifier
         const pkg = JSON.parse(await fs.promises.readFile(new URL('../../package.json', import.meta.url), 'utf8'));
-        updateNotifier({ pkg }).notify();
+        const notifier = updateNotifier({ pkg, updateCheckInterval: 1000 * 60 * 60 }); // Check every hour in background
+        notifier.notify();
         printLogo();
         p.intro(`${brandBg(' Minovative Mind CLI ')} ${pc.dim('v' + this.config.version)}`);
+        if (notifier.update && notifier.update.latest !== this.config.version) {
+            p.log.warn(`Update available! ${pc.red(this.config.version)} → ${pc.green(notifier.update.latest)}\nRun ${pc.cyan(`npm i -g ${pkg.name}`)} to update.`);
+        }
         // Check authentication
         let idToken = await getAuthorizedIdToken();
         if (!idToken) {

package/dist/services/agent/slashCommands.js

@@ -10,7 +10,7 @@ import { changeLogger } from '../changeLogger.js';
 import { chatHistoryService } from '../chatHistoryService.js';
 import { printLogo, brandBg, brandFg } from '../../utils/logo.js';
 import { readPaste } from '../../utils/paste.js';
-import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled, isSemanticSearchEnabled, setSemanticSearchEnabled, } from '../agent-tools.js';
+import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled, } from '../agent-tools.js';
 import { ProxyChatSession, setGlobalActiveModel, getGlobalActiveModel, getGlobalLatestUsageMetadata } from '../ai.js';
 const execAsync = promisify(exec);
 /**
@@ -128,17 +128,6 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
-    if (lowerCommand === '/semantic-search') {
-        if (isSemanticSearchEnabled()) {
-            setSemanticSearchEnabled(false);
-            p.log.success('Semantic search disabled. The vector indexing layer is now turned off.');
-        }
-        else {
-            setSemanticSearchEnabled(true);
-            p.log.success('Semantic search enabled. The AST-aware vector index is active.');
-        }
-        return { shouldContinue: true };
-    }
     if (lowerCommand === '/stats') {
         const latestUsage = getGlobalLatestUsageMetadata();
         const currentModel = chat.getModel();
@@ -146,14 +135,12 @@ export async function handleSlashCommand(command, context) {
         const displayModel = globalModel === 'auto' ? `Auto (Last turn: ${currentModel})` : currentModel;
         const autoApprove = getApprovalMode() === 'skip-all' ? 'Enabled' : 'Disabled';
         const subAgents = isSubAgentsEnabled() ? 'Enabled' : 'Disabled';
-        const semanticSearch = isSemanticSearchEnabled() ? 'Enabled' : 'Disabled';
         const planMode = context.isPlanMode ? 'Enabled' : 'Disabled';
         p.log.step(pc.magenta('📊 Session Statistics & Status'));
         console.log(pc.dim('----------------------------------------'));
         console.log(`${pc.bold('AI Model:')}         ${pc.cyan(displayModel)}`);
         console.log(`${pc.bold('Auto-Approve:')}     ${autoApprove === 'Enabled' ? pc.green(autoApprove) : pc.yellow(autoApprove)}`);
         console.log(`${pc.bold('Sub-Agents:')}       ${subAgents === 'Enabled' ? pc.green(subAgents) : pc.yellow(subAgents)}`);
-        console.log(`${pc.bold('Semantic Search:')}  ${semanticSearch === 'Enabled' ? pc.green(semanticSearch) : pc.yellow(semanticSearch)}`);
         console.log(`${pc.bold('Plan Mode:')}        ${planMode === 'Enabled' ? pc.green(planMode) : pc.yellow(planMode)}`);
         const debugMode = isDebugOn() ? 'Enabled' : 'Disabled';
         console.log(`${pc.bold('Debug Log:')}        ${debugMode === 'Enabled' ? pc.green(debugMode) : pc.yellow(debugMode)}`);

package/dist/services/agent-tools.d.ts

@@ -7,8 +7,6 @@ export interface ToolResult {
         data: string;
     };
 }
-export declare function isSemanticSearchEnabled(): boolean;
-export declare function setSemanticSearchEnabled(val: boolean): void;
 export declare function getToolDeclarations(): FunctionDeclaration[];
 /**
  * FunctionDeclaration-compatible schema objects that describe

package/dist/services/agent-tools.js

@@ -17,18 +17,8 @@ import { extractSymbols } from '../utils/symbolExtractor.js';
 import { getMetricCollector } from './metrics.js';
 const execAsync = promisify(exec);
 // ─── Tool Declarations for Gemini Function Calling ───────────────────
-let _semanticSearchEnabled = true;
-export function isSemanticSearchEnabled() {
-    return _semanticSearchEnabled;
-}
-export function setSemanticSearchEnabled(val) {
-    _semanticSearchEnabled = val;
-}
 export function getToolDeclarations() {
-    if (_semanticSearchEnabled) {
-        return toolDeclarations;
-    }
-    return toolDeclarations.filter((t) => t.name !== 'semantic_search');
+    return toolDeclarations;
 }
 /**
  * FunctionDeclaration-compatible schema objects that describe
@@ -259,24 +249,6 @@ export const toolDeclarations = [
             required: ['language', 'code'],
         },
     },
-    {
-        name: 'semantic_search',
-        description: 'Search the codebase by meaning and concept rather than exact text match. Use this when you need to find code related to a concept, pattern, or behavior but don\'t know the exact variable or function names to grep for. Examples: "error handling for API requests", "user authentication flow", "database connection pooling logic". Returns ranked results with file paths, line ranges, and similarity scores.',
-        parameters: {
-            type: SchemaType.OBJECT,
-            properties: {
-                query: {
-                    type: SchemaType.STRING,
-                    description: "Natural language description of what you're looking for in the codebase.",
-                },
-                topK: {
-                    type: SchemaType.NUMBER,
-                    description: 'Number of results to return. Defaults to 5, maximum 15.',
-                },
-            },
-            required: ['query'],
-        },
-    },
 ];
 let currentApprovalMode = 'ask';
 export function getApprovalMode() {
@@ -361,7 +333,147 @@ export async function readFile(workspaceRoot, filePath, startLine, endLine, targ
                 inlineData: { mimeType: 'application/pdf', data: base64Data },
             };
         }
+        // Prevent reading massive lockfiles
+        const isLockfile = ['package-lock.json', 'yarn.lock', 'poetry.lock', 'pnpm-lock.yaml'].some(file => filePath.toLowerCase().endsWith(file));
+        if (isLockfile) {
+            return {
+                output: '',
+                error: `Do not read lockfiles directly as they waste thousands of tokens. Please read the 'package.json', 'pyproject.toml', or equivalent source file to see dependencies.`,
+            };
+        }
+        // Handle SQLite databases natively by dumping the schema
+        if (filePath.toLowerCase().endsWith('.sqlite') || filePath.toLowerCase().endsWith('.db')) {
+            try {
+                const { stdout } = await execAsync(`sqlite3 "${absPath}" ".schema"`);
+                return {
+                    output: `## Database Schema for ${path.basename(absPath)}\n\`\`\`sql\n${stdout}\n\`\`\``,
+                };
+            }
+            catch (e) {
+                return {
+                    output: '',
+                    error: `Could not parse SQLite DB natively. Ensure 'sqlite3' CLI is installed. Error: ${e instanceof Error ? e.message : String(e)}`,
+                };
+            }
+        }
         let content = await fs.readFile(absPath, 'utf-8');
+        // Handle Jupyter Notebooks natively
+        if (filePath.toLowerCase().endsWith('.ipynb')) {
+            try {
+                const notebook = JSON.parse(content);
+                if (notebook && Array.isArray(notebook.cells)) {
+                    const cleanCells = [];
+                    for (const cell of notebook.cells) {
+                        const sourceArray = Array.isArray(cell.source) ? cell.source : [cell.source || ''];
+                        const source = sourceArray.join('');
+                        if (cell.cell_type === 'markdown') {
+                            cleanCells.push(source);
+                        }
+                        else if (cell.cell_type === 'code') {
+                            let cellStr = '```python\n' + source + '\n```';
+                            if (cell.outputs && Array.isArray(cell.outputs)) {
+                                const textOutputs = [];
+                                for (const out of cell.outputs) {
+                                    if (out.output_type === 'stream' && out.text) {
+                                        const text = Array.isArray(out.text) ? out.text.join('') : out.text;
+                                        textOutputs.push(text);
+                                    }
+                                    else if (out.data) {
+                                        if (out.data['text/plain']) {
+                                            const text = Array.isArray(out.data['text/plain']) ? out.data['text/plain'].join('') : out.data['text/plain'];
+                                            textOutputs.push(text);
+                                        }
+                                        else if (out.data['image/png'] || out.data['image/jpeg'] || out.data['image/svg+xml']) {
+                                            textOutputs.push('[Image Output]');
+                                        }
+                                        else if (out.data['text/html']) {
+                                            textOutputs.push('[HTML Output]');
+                                        }
+                                    }
+                                }
+                                if (textOutputs.length > 0) {
+                                    let joinedOutput = textOutputs.join('\n').trim();
+                                    const outLines = joinedOutput.split('\n');
+                                    if (outLines.length > 50) {
+                                        joinedOutput = outLines.slice(0, 50).join('\n') + '\n... (Output truncated)';
+                                    }
+                                    cellStr += '\n\n**Output:**\n```text\n' + joinedOutput + '\n```';
+                                }
+                            }
+                            cleanCells.push(cellStr);
+                        }
+                    }
+                    content = cleanCells.join('\n\n');
+                }
+            }
+            catch (err) {
+                content = `<!-- Failed to parse .ipynb cleanly, showing raw JSON -->\n${content}`;
+            }
+        }
+        // Handle CSV natively by formatting as a Markdown table
+        if (filePath.toLowerCase().endsWith('.csv')) {
+            try {
+                const rows = [];
+                let currentRow = [];
+                let currentCell = '';
+                let inQuotes = false;
+                for (let i = 0; i < content.length; i++) {
+                    const char = content[i];
+                    if (char === '"') {
+                        if (inQuotes && content[i + 1] === '"') {
+                            currentCell += '"';
+                            i++;
+                        }
+                        else {
+                            inQuotes = !inQuotes;
+                        }
+                    }
+                    else if (char === ',' && !inQuotes) {
+                        currentRow.push(currentCell.trim().replace(/\n/g, ' ').replace(/\|/g, '\\|'));
+                        currentCell = '';
+                    }
+                    else if ((char === '\n' || char === '\r') && !inQuotes) {
+                        if (char === '\r' && content[i + 1] === '\n')
+                            i++;
+                        currentRow.push(currentCell.trim().replace(/\n/g, ' ').replace(/\|/g, '\\|'));
+                        if (currentRow.some(cell => cell.length > 0)) {
+                            rows.push(currentRow);
+                        }
+                        currentRow = [];
+                        currentCell = '';
+                    }
+                    else {
+                        currentCell += char;
+                    }
+                }
+                if (currentCell !== '' || currentRow.length > 0) {
+                    currentRow.push(currentCell.trim().replace(/\n/g, ' ').replace(/\|/g, '\\|'));
+                    if (currentRow.some(cell => cell.length > 0))
+                        rows.push(currentRow);
+                }
+                if (rows.length > 0) {
+                    const header = rows[0];
+                    const MAX_CSV_ROWS = 250; // Generous truncation limit
+                    const isTruncated = rows.length > MAX_CSV_ROWS;
+                    const displayRows = isTruncated ? rows.slice(0, MAX_CSV_ROWS) : rows;
+                    let mdTable = `| ${header.join(' | ')} |\n`;
+                    mdTable += `| ${header.map(() => '---').join(' | ')} |\n`;
+                    for (let i = 1; i < displayRows.length; i++) {
+                        const row = displayRows[i];
+                        while (row.length < header.length)
+                            row.push('');
+                        mdTable += `| ${row.slice(0, header.length).join(' | ')} |\n`;
+                    }
+                    if (isTruncated) {
+                        mdTable += `\n*(Note: CSV truncated from ${rows.length} rows to ${MAX_CSV_ROWS} rows for safe viewing)*\n`;
+                    }
+                    content = mdTable;
+                }
+            }
+            catch (err) {
+                content = `<!-- Failed to parse .csv as table, showing raw text -->\n${content}`;
+            }
+        }
         if (targetElements && targetElements.length > 0) {
             content = extractSymbols(content, filePath, targetElements);
         }
@@ -1033,36 +1145,6 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
             }
             break;
         }
-        case 'semantic_search': {
-            const query = args.query;
-            const topK = args.topK || 5;
-            let output = '';
-            try {
-                const { getEmbeddingIndex } = await import('./embeddingIndex.js');
-                const index = getEmbeddingIndex();
-                if (!index.isReady()) {
-                    const loaded = await index.load(workspaceRoot);
-                    if (!loaded) {
-                        await index.buildIndex(workspaceRoot);
-                        await index.save(workspaceRoot);
-                    }
-                }
-                const results = await index.search(query, topK);
-                if (results.length === 0) {
-                    output = 'No semantically similar code found. (Index might be empty or embedding failed)';
-                }
-                else {
-                    output = results
-                        .map((r) => `[Score: ${r.score.toFixed(3)}] ${r.filePath}:${r.startLine}-${r.endLine}\n${r.preview}`)
-                        .join('\n---\n');
-                }
-            }
-            catch (e) {
-                output = `Semantic search failed: ${e.message}`;
-            }
-            result = { output };
-            break;
-        }
         case 'find_dependencies':
             result = await traceDependencies(effectiveRoot, resolvedArgs.filePath, resolvedArgs.direction, resolvedArgs.maxDepth);
             break;

package/dist/services/agent.js

@@ -135,11 +135,6 @@ export async function startAgentLoop(workspaceRoot, version) {
                     { value: '/debug', label: '/debug', hint: 'Toggle internal debug logs' },
                     { value: '/auto-approve', label: '/auto-approve', hint: 'Approve all future terminal commands' },
                     { value: '/sub-agents', label: '/sub-agents', hint: 'Toggle the MMAAK Engine for parallel investigation and execution' },
-                    {
-                        value: '/semantic-search',
-                        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' },
@@ -548,21 +543,6 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             // the user can still use /revert to undo the partial file mutations.
             const changedFiles = changeLogger.getChangedFiles();
             changeLogger.commitChangeSet();
-            // Delta-update the embedding index if there were changes
-            if (changedFiles.length > 0) {
-                try {
-                    const { getEmbeddingIndex } = await import('./embeddingIndex.js');
-                    const index = getEmbeddingIndex();
-                    // Only update if it's already loaded in memory
-                    if (index.isReady()) {
-                        await index.updateIndex(workspaceRoot, changedFiles);
-                        await index.save(workspaceRoot);
-                    }
-                }
-                catch (e) {
-                    debugLog(`Failed to delta-update embedding index: ${e.message}`);
-                }
-            }
         }
     });
 }
@@ -635,10 +615,10 @@ async function compressContextFiles(workspaceRoot, contextResult) {
         }
     }
     if (cacheUpdated) {
-        // Keep cache size manageable by restricting to recent 100 file entries
+        // Keep cache size manageable by restricting to recent 500 file entries
         const keys = Object.keys(cachedContext);
-        if (keys.length > 100) {
-            const toDelete = keys.length - 100;
+        if (keys.length > 500) {
+            const toDelete = keys.length - 500;
             for (let i = 0; i < toDelete; i++) {
                 delete cachedContext[keys[i]];
             }

package/dist/services/ai.js

@@ -487,29 +487,6 @@ export function getContextToolDeclarations() {
                         required: ['query'],
                     },
                 },
-                {
-                    name: 'semantic_search',
-                    description: 'Search the codebase by meaning and concept rather than exact text match. ' +
-                        'Use this when you need to find code related to a concept, pattern, or behavior ' +
-                        "but don't know the exact variable or function names to grep for. " +
-                        'Examples: "error handling for API requests", "user authentication flow", ' +
-                        '"database connection pooling logic". Returns ranked results with file paths, ' +
-                        'line ranges, and similarity scores.',
-                    parameters: {
-                        type: 'OBJECT',
-                        properties: {
-                            query: {
-                                type: 'STRING',
-                                description: "Natural language description of what you're looking for in the codebase.",
-                            },
-                            topK: {
-                                type: 'NUMBER',
-                                description: 'Number of results to return. Defaults to 5, maximum 15.',
-                            },
-                        },
-                        required: ['query'],
-                    },
-                },
             ],
         },
     ];

package/dist/services/chatHistoryService.js

@@ -1,7 +1,7 @@
 import { readCache, writeCache } from '../utils/projectStorage.js';
 class ChatHistoryService {
     workspaceRoot = '';
-    MAX_SESSIONS = 50;
+    MAX_SESSIONS = 250;
     init(workspaceRoot) {
         this.workspaceRoot = workspaceRoot;
     }

package/dist/services/contextAgent.js

@@ -434,15 +434,6 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                     },
                 });
             }
-            else if (call.name === 'semantic_search') {
-                const semRes = await executeTool(workspaceRoot, 'semantic_search', args);
-                functionResponses.push({
-                    functionResponse: {
-                        name: call.name,
-                        response: { output: semRes.output },
-                    },
-                });
-            }
             else if (call.name === 'read_file') {
                 const readRes = await executeTool(workspaceRoot, 'read_file', args);
                 if (!readRes.error) {

package/dist/services/orchestration/investigationAgent.js

@@ -240,36 +240,6 @@ export class InvestigationAgentRunner {
                             });
                         }
                     }
-                    else if (call.name === 'semantic_search') {
-                        const query = args.query;
-                        const topK = args.topK || 5;
-                        if (onProgress)
-                            onProgress(`${logPrefix} Semantic search: "${query}"`);
-                        let output = '';
-                        try {
-                            const { getEmbeddingIndex } = await import('../embeddingIndex.js');
-                            const index = getEmbeddingIndex();
-                            if (!index.isReady()) {
-                                const loaded = await index.load(this.workspaceRoot);
-                                if (!loaded) {
-                                    output = 'Semantic search index not available. Use search_codebase instead.';
-                                }
-                            }
-                            if (index.isReady()) {
-                                const results = await index.search(query, topK);
-                                output =
-                                    results.length === 0
-                                        ? 'No semantically similar code found.'
-                                        : results
-                                            .map((r) => `[Score: ${r.score.toFixed(3)}] ${r.filePath}:${r.startLine}-${r.endLine}\n${r.preview}`)
-                                            .join('\n---\n');
-                            }
-                        }
-                        catch (e) {
-                            output = `Semantic search failed: ${e.message}`;
-                        }
-                        functionResponses.push({ functionResponse: { name: call.name, response: { output } } });
-                    }
                     else if (call.name === 'perform_web_search') {
                         if (onProgress)
                             onProgress(`${logPrefix} Web search: "${args.query}"`);

package/dist/services/orchestration/orchestrator.js

@@ -96,14 +96,21 @@ export class Orchestrator {
         for (const wave of waves) {
             if (signal.aborted)
                 break;
-            p.log.step(pc.magenta(`Starting Wave ${wave.depth + 1}...`));
+            const taskDescriptions = wave.taskIds.map(taskId => {
+                const taskDef = graph.tasks.find(t => t.id === taskId);
+                return `  - ${pc.cyan(taskDef.id)}: ${pc.dim(taskDef.intent)}`;
+            }).join('\n');
+            p.log.step(pc.magenta(`Starting Wave ${wave.depth + 1} (${wave.taskIds.length} tasks):\n${taskDescriptions}`));
+            const s = p.spinner();
+            s.start(`Executing Wave ${wave.depth + 1}...`);
             const wavePromises = wave.taskIds.map(taskId => {
                 const taskDef = graph.tasks.find(t => t.id === taskId);
                 const globalContext = `Objective:\n${objective}\n\nContext:\n${contextInjection}`;
-                return this.dispatchAgent(taskDef, globalContext, signal);
+                return this.dispatchAgent(taskDef, globalContext, signal, (msg) => s.message(msg));
             });
             // Run all agents in this wave concurrently
             const results = await Promise.all(wavePromises);
+            s.stop(`Wave ${wave.depth + 1} execution finished.`);
             // Post-wave evaluation
             const failedCount = results.filter(r => !r.success).length;
             if (failedCount > 0) {
@@ -179,8 +186,8 @@ export class Orchestrator {
     /**
      * Dispatches a single sub-agent and records its result.
      */
-    async dispatchAgent(taskDef, globalContext, signal) {
-        const runner = new SubAgentRunner(taskDef.id, taskDef.intent, this.workspaceRoot, this.bus, this.locks, globalContext);
+    async dispatchAgent(taskDef, globalContext, signal, onProgress) {
+        const runner = new SubAgentRunner(taskDef.id, taskDef.intent, this.workspaceRoot, this.bus, this.locks, globalContext, onProgress);
         const result = await runner.execute(signal);
         // Clean up any stray locks if the agent crashed or stalled
         if (result.crashed) {
@@ -197,13 +204,13 @@ export class Orchestrator {
         const stats = this.bus.getStats();
         let totalTokens = 0;
         let failedTasks = 0;
-        let finalSummary = '[Sub-Agent Orchestration Completed]\\n\\n';
+        let finalSummary = '[Sub-Agent Orchestration Completed]\n\n';
         for (const [taskId, res] of this.agentResults.entries()) {
             totalTokens += res.creditsUsed;
             if (!res.success)
                 failedTasks++;
             debugLog(`Task ${taskId} summary: ${res.summary.substring(0, 100)}...`);
-            finalSummary += `**Task: ${taskId}**\\nStatus: ${res.success ? 'Success' : 'Failed'}\\n${res.summary}\\n\\n`;
+            finalSummary += `**Task: ${taskId}**\nStatus: ${res.success ? 'Success' : 'Failed'}\n${res.summary}\n\n`;
         }
         p.log.info(`${pc.green('✓')} Sub-agent execution complete.\n` +
             `  Total tasks: ${graph.tasks.length} (${failedTasks} failed)\n` +

package/dist/services/orchestration/subAgent.d.ts

@@ -30,12 +30,13 @@ export declare class SubAgentRunner {
     private readonly bus;
     private readonly locks;
     private readonly globalContext;
+    private readonly onProgress?;
     private chat;
     private lastHeartbeat;
     private creditsUsed;
     /** Max time without a tool call or response before the agent is considered stalled */
     static readonly STALL_TIMEOUT_MS = 60000;
-    constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string);
+    constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string, onProgress?: ((msg: string) => void) | undefined);
     /**
      * Constructs the base system instruction for this specific agent.
      */

package/dist/services/orchestration/subAgent.js

@@ -20,18 +20,20 @@ export class SubAgentRunner {
     bus;
     locks;
     globalContext;
+    onProgress;
     chat;
     lastHeartbeat = Date.now();
     creditsUsed = 0;
     /** Max time without a tool call or response before the agent is considered stalled */
     static STALL_TIMEOUT_MS = 60_000;
-    constructor(taskId, intent, workspaceRoot, bus, locks, globalContext) {
+    constructor(taskId, intent, workspaceRoot, bus, locks, globalContext, onProgress) {
         this.taskId = taskId;
         this.intent = intent;
         this.workspaceRoot = workspaceRoot;
         this.bus = bus;
         this.locks = locks;
         this.globalContext = globalContext;
+        this.onProgress = onProgress;
         let model = getGlobalActiveModel();
         if (model === GEMINI_MODELS.AUTO)
             model = GEMINI_MODELS.FLASH_3_5;
@@ -123,6 +125,9 @@ export class SubAgentRunner {
                             break;
                         }
                         this.pingHeartbeat();
+                        if (this.onProgress) {
+                            this.onProgress(`[${this.taskId}] executing ${call.name}...`);
+                        }
                         debugLog(`SubAgent [${this.taskId}]: Executing tool ${call.name}`);
                         let responseData;
                         try {

package/dist/services/proxyClient.d.ts

@@ -34,7 +34,6 @@ export interface ProxyUsageMetadata {
  */
 export declare class ProxyClient {
     private readonly PROXY_URL;
-    private readonly EMBED_URL;
     /**
      * Generates text, thoughts, or function calls via the secure Gemini proxy URL.
      * Utilizes Server-Sent Events (SSE) to stream partial token responses back to the client.
@@ -61,28 +60,4 @@ export declare class ProxyClient {
         usageMetadata?: ProxyUsageMetadata;
         groundingMetadata?: any;
     }>;
-    /**
-     * Embeds one or more text chunks via the secure embedding proxy endpoint.
-     * Uses the same Firebase auth pattern as generateFunctionCallViaProxy, but
-     * targets a separate Cloud Function optimized for embedding generation.
-     *
-     * Unlike the generative endpoint, embedding responses are small and atomic,
-     * so no SSE streaming is required — a single JSON response is returned.
-     *
-     * @param idToken - The Firebase ID token for authorization.
-     * @param texts - Array of text strings to embed. Batched by caller (max ~25 per call).
-     * @param taskType - Embedding task type hint for optimal retrieval quality.
-     *   - 'RETRIEVAL_DOCUMENT': Used when indexing source code chunks.
-     *   - 'RETRIEVAL_QUERY': Used when embedding a user's semantic search query.
-     * @returns The embedding vectors and usage metadata from the proxy.
-     * @throws {Error} If authentication fails (401), credits are insufficient (402), or network errors occur.
-     */
-    embedTextsViaProxy(idToken: string, texts: string[], taskType?: 'RETRIEVAL_DOCUMENT' | 'RETRIEVAL_QUERY'): Promise<{
-        embeddings: number[][];
-        usage?: {
-            promptTokens: number;
-            creditsUsed: number;
-            remainingBalance: number;
-        };
-    }>;
 }