minovative-mind-cli 2.11.5 → 2.13.0

package/dist/services/orchestration/messageBus.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Two-Layer Message Bus for Sub-Agent Orchestration.
+ * @file Two-Layer Message Bus for Sub-Agent Orchestration.
  *
  * Provides the core inter-agent communication primitive for the orchestration system.
  * Two layers of communication:
@@ -19,6 +19,38 @@ import { promises as fs, readFileSync, existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { atomicWriteFile } from '../../utils/atomicWrite.js';
 import { debugLog } from '../../utils/logger.js';
+export const MUTATING_TOOLS = new Set([
+    'write_file',
+    'modify_file',
+    'delete_file',
+    'rename_file',
+    'run_command',
+]);
+export function coalesceActivityEntries(entries) {
+    const result = [];
+    for (const entry of entries) {
+        const last = result[result.length - 1];
+        if (last && last.agentId === entry.agentId && last.tool === entry.tool && last.target === entry.target) {
+            last.count++;
+            last.status = entry.status; // most recent status
+            if (entry.resultSummary) {
+                last.resultSummary = entry.resultSummary;
+            }
+        }
+        else {
+            result.push({
+                agentId: entry.agentId,
+                tool: entry.tool,
+                target: entry.target,
+                action: entry.action,
+                count: 1,
+                status: entry.status,
+                resultSummary: entry.resultSummary,
+            });
+        }
+    }
+    return result;
+}
 // ─── Message Bus Implementation ──────────────────────────────────────
 /**
  * Two-layer, disk-backed message bus for sub-agent coordination.
@@ -31,15 +63,15 @@ import { debugLog } from '../../utils/logger.js';
  * a CLI crash and resume from the last known state.
  */
 export class MessageBus {
-    activityLog = [];
-    signals = [];
+    /** Maximum semantic signals any single agent can post */
+    static MAX_SIGNALS_PER_AGENT = 50;
     activityCursors = new Map();
-    signalCursors = new Map();
-    persistQueue = Promise.resolve();
+    activityLog = [];
     persistPath;
+    persistQueue = Promise.resolve();
+    signalCursors = new Map();
+    signals = [];
     workspaceRoot;
-    /** Maximum semantic signals any single agent can post */
-    static MAX_SIGNALS_PER_AGENT = 50;
     constructor(workspaceRoot, conversationId) {
         this.workspaceRoot = workspaceRoot;
         const orchestrationDir = path.join(workspaceRoot, '.minovativemind', 'orchestration');
@@ -48,50 +80,70 @@ export class MessageBus {
     }
     // ─── Layer 1: Automatic Activity Log ─────────────────────────────
     /**
-     * Records a tool execution into the activity log. Called by the scoped tool
-     * wrapper in `scopedTools.ts` — zero cost to the agent.
+     * Formats a batch of activity entries into a compact, human-readable string
+     * without token-wasteful column whitespace padding. Coalesces repeated actions.
      */
-    logActivity(entry) {
-        this.activityLog.push(entry);
-        this.persistToDiskAsync();
+    static formatActivityEntries(entries) {
+        if (entries.length === 0)
+            return '';
+        const coalesced = coalesceActivityEntries(entries);
+        return coalesced
+            .map((e) => {
+            const countSuffix = e.count > 1 ? ` (${e.count} ops)` : '';
+            const statusPrefix = e.status === 'error' ? '[FAILED] ' : '';
+            const summary = e.resultSummary ? ` | ${e.resultSummary}` : '';
+            return `  [${e.agentId}] ${statusPrefix}${e.tool} ${e.target}: ${e.action}${countSuffix}${summary}`;
+        })
+            .join('\n');
     }
     // ─── Layer 2: Semantic Signals ───────────────────────────────────
     /**
-     * Posts a semantic signal from an agent. These cost tokens (the agent calls
-     * `post_message`) but carry intent that raw tool logs cannot express.
-     *
-     * Enforces per-agent signal cap to prevent runaway agents from flooding the bus.
-     *
-     * @returns `true` if the signal was accepted, `false` if the agent hit the cap.
+     * Formats semantic signals into a readable string for agent context injection.
      */
-    postSignal(signal) {
-        const agentSignalCount = this.signals.filter((s) => s.fromAgent === signal.fromAgent).length;
-        if (agentSignalCount >= MessageBus.MAX_SIGNALS_PER_AGENT) {
-            debugLog(`MessageBus: Agent ${signal.fromAgent} hit signal cap (${MessageBus.MAX_SIGNALS_PER_AGENT}). ` +
-                `Dropping signal of type "${signal.type}".`);
-            return false;
-        }
-        this.signals.push(signal);
-        this.persistToDiskAsync();
-        return true;
+    static formatSignals(signals) {
+        if (signals.length === 0)
+            return '';
+        return signals
+            .map((s) => {
+            const tag = s.type.toUpperCase();
+            switch (s.type) {
+                case 'discovery':
+                    return `  [${tag} from ${s.fromAgent}]: "${s.content}" (affects: ${s.affectedFiles.join(', ')})`;
+                case 'warning':
+                    return `  [${tag} from ${s.fromAgent}]: "${s.content}"${s.changedSignature ? ` (signature: ${s.changedSignature})` : ''}`;
+                case 'request':
+                    return `  [${tag} from ${s.fromAgent} → ${s.toAgent}]: "${s.content}"`;
+                case 'completion':
+                    return `  [${tag} from ${s.fromAgent}]: "${s.summary}"`;
+                default:
+                    return `  [SIGNAL from ${s.fromAgent}]: ${JSON.stringify(s)}`;
+            }
+        })
+            .join('\n');
     }
     // ─── Reading ─────────────────────────────────────────────────────
     /**
-     * Retrieves all unread activity entries and semantic signals for a specific agent.
-     * Advances the agent's cursors so subsequent calls return only new entries.
-     *
-     * Filters out the requesting agent's own entries (an agent doesn't need to
-     * re-read its own tool logs or signals).
+     * Clears all bus state and removes the persistence file.
+     * Called when orchestration completes successfully (no crash recovery needed).
      */
-    getUnread(agentId) {
-        const actCursor = this.activityCursors.get(agentId) ?? 0;
-        const sigCursor = this.signalCursors.get(agentId) ?? 0;
-        const activities = this.activityLog.slice(actCursor).filter((e) => e.agentId !== agentId);
-        const signals = this.signals.slice(sigCursor).filter((s) => s.fromAgent !== agentId);
-        // Advance cursors to current end
-        this.activityCursors.set(agentId, this.activityLog.length);
-        this.signalCursors.set(agentId, this.signals.length);
-        return { activities, signals };
+    async cleanup() {
+        this.activityLog = [];
+        this.signals = [];
+        this.activityCursors = new Map();
+        this.signalCursors = new Map();
+        try {
+            await fs.unlink(this.persistPath);
+        }
+        catch {
+            // File may not exist — non-fatal
+        }
+    }
+    /**
+     * Returns all activity entries for a specific agent (used for dead agent
+     * recovery — collecting partial progress before re-dispatch).
+     */
+    getAgentActivity(agentId) {
+        return this.activityLog.filter((e) => e.agentId === agentId);
     }
     /**
      * Returns the complete, unfiltered bus state for PM reconciliation.
@@ -103,13 +155,6 @@ export class MessageBus {
             signals: [...this.signals],
         };
     }
-    /**
-     * Returns all activity entries for a specific agent (used for dead agent
-     * recovery — collecting partial progress before re-dispatch).
-     */
-    getAgentActivity(agentId) {
-        return this.activityLog.filter((e) => e.agentId === agentId);
-    }
     /**
      * Returns the total number of activity entries and signals in the bus.
      * Used for terminal display and diagnostics.
@@ -120,47 +165,162 @@ export class MessageBus {
             signalCount: this.signals.length,
         };
     }
-    // ─── Formatting Helpers ──────────────────────────────────────────
     /**
-     * Formats a batch of activity entries into a compact, human-readable string
-     * suitable for injection into an agent's context window.
+     * Retrieves all unread activity entries and semantic signals for a specific agent.
+     * Defaults to state-mutating events and unicast signal routing to eliminate token noise.
      */
-    static formatActivityEntries(entries) {
-        if (entries.length === 0)
-            return '';
-        return entries
-            .map((e) => {
-            const statusIcon = e.status === 'success' ? '✓' : '✗';
-            const summary = e.resultSummary ? ` | ${e.resultSummary}` : '';
-            return `  ${e.agentId} | ${e.tool.padEnd(14)} → ${e.target.padEnd(40)} | ${statusIcon} ${e.action}${summary}`;
-        })
-            .join('\n');
+    getUnread(agentId, options) {
+        return this.queryBus({
+            agentId,
+            onlyMutations: options?.onlyMutations ?? true,
+            advanceCursor: options?.advanceCursor ?? true,
+        });
     }
     /**
-     * Formats semantic signals into a readable string for agent context injection.
+     * Records a tool execution into the activity log. Called by the scoped tool
+     * wrapper in `scopedTools.ts` — zero cost to the agent.
      */
-    static formatSignals(signals) {
-        if (signals.length === 0)
-            return '';
-        return signals
-            .map((s) => {
-            const tag = s.type.toUpperCase();
-            switch (s.type) {
-                case 'discovery':
-                    return `  [${tag} from ${s.fromAgent}]: "${s.content}" (affects: ${s.affectedFiles.join(', ')})`;
-                case 'warning':
-                    return `  [${tag} from ${s.fromAgent}]: "${s.content}"${s.changedSignature ? ` (signature: ${s.changedSignature})` : ''}`;
-                case 'request':
-                    return `  [${tag} from ${s.fromAgent} → ${s.toAgent}]: "${s.content}"`;
-                case 'completion':
-                    return `  [${tag} from ${s.fromAgent}]: "${s.summary}"`;
-                default:
-                    return `  [SIGNAL from ${s.fromAgent}]: ${JSON.stringify(s)}`;
+    logActivity(entry) {
+        this.activityLog.push(entry);
+        this.persistToDiskAsync();
+    }
+    // ─── Formatting Helpers ──────────────────────────────────────────
+    /**
+     * Peeks urgent signals (breaking warnings or direct requests) that are relevant
+     * to a sub-agent's task scope without advancing its cursor. Used for in-band notice
+     * delivery in scopedTools.
+     */
+    peekUrgentSignals(agentId, scope) {
+        const sigCursor = this.signalCursors.get(agentId) ?? 0;
+        const unreadSignals = this.signals.slice(sigCursor).filter((s) => s.fromAgent !== agentId);
+        const urgent = [];
+        for (const signal of unreadSignals) {
+            // 1. Direct targeted request to this agent
+            if (signal.type === 'request' && (signal.toAgent === agentId || signal.toAgent === 'all')) {
+                urgent.push(signal);
+                continue;
             }
-        })
-            .join('\n');
+            // 2. Warnings from upstream dependencies or affecting target files
+            if (signal.type === 'warning') {
+                if (!scope || !scope.dependsOn || scope.dependsOn.includes(signal.fromAgent)) {
+                    urgent.push(signal);
+                    continue;
+                }
+            }
+            // 3. Upstream completion signals from direct dependencies
+            if (signal.type === 'completion' && scope?.dependsOn && scope.dependsOn.includes(signal.fromAgent)) {
+                urgent.push(signal);
+                continue;
+            }
+        }
+        return urgent;
+    }
+    /**
+     * Posts a semantic signal from an agent. These cost tokens (the agent calls
+     * `post_message`) but carry intent that raw tool logs cannot express.
+     *
+     * Enforces per-agent signal cap to prevent runaway agents from flooding the bus.
+     *
+     * @returns `true` if the signal was accepted, `false` if the agent hit the cap.
+     */
+    postSignal(signal) {
+        const agentSignalCount = this.signals.filter((s) => s.fromAgent === signal.fromAgent).length;
+        if (agentSignalCount >= MessageBus.MAX_SIGNALS_PER_AGENT) {
+            debugLog(`MessageBus: Agent ${signal.fromAgent} hit signal cap (${MessageBus.MAX_SIGNALS_PER_AGENT}). ` +
+                `Dropping signal of type "${signal.type}".`);
+            return false;
+        }
+        this.signals.push(signal);
+        this.persistToDiskAsync();
+        return true;
     }
     // ─── Persistence ─────────────────────────────────────────────────
+    /**
+     * Performs an intelligent, scoped query against unread bus activity and signals.
+     * Filters out read-only noise for peer sub-agents, enforces unicast delivery for targeted
+     * requests, and supports selective querying by file, agent, or signal type.
+     */
+    queryBus(options) {
+        const actCursor = this.activityCursors.get(options.agentId) ?? 0;
+        const sigCursor = this.signalCursors.get(options.agentId) ?? 0;
+        const onlyMutations = options.onlyMutations ?? true;
+        const normalizedFile = options.file ? options.file.replace(/\\/g, '/').toLowerCase() : undefined;
+        const activities = this.activityLog.slice(actCursor).filter((e) => {
+            // Exclude own actions
+            if (e.agentId === options.agentId)
+                return false;
+            // Filter read-only tools if onlyMutations is enabled
+            if (onlyMutations && !MUTATING_TOOLS.has(e.tool))
+                return false;
+            // Optional file filter
+            if (normalizedFile) {
+                const entryTarget = e.target.replace(/\\/g, '/').toLowerCase();
+                if (!entryTarget.includes(normalizedFile) && !normalizedFile.includes(entryTarget)) {
+                    return false;
+                }
+            }
+            // Optional fromAgent filter
+            if (options.fromAgent && e.agentId !== options.fromAgent)
+                return false;
+            return true;
+        });
+        const signals = this.signals.slice(sigCursor).filter((s) => {
+            // Exclude own signals
+            if (s.fromAgent === options.agentId)
+                return false;
+            // Unicast request routing: only deliver if targeted to this agent or broadcast to 'all'
+            if (s.type === 'request') {
+                const req = s;
+                if (req.toAgent && req.toAgent !== 'all' && req.toAgent !== options.agentId) {
+                    return false;
+                }
+            }
+            // Optional type filter
+            if (options.type && s.type !== options.type)
+                return false;
+            // Optional fromAgent filter
+            if (options.fromAgent && s.fromAgent !== options.fromAgent)
+                return false;
+            // Optional file filter for signals
+            if (normalizedFile) {
+                if (s.type === 'discovery') {
+                    const disc = s;
+                    const touches = (disc.affectedFiles || []).some((f) => {
+                        const norm = f.replace(/\\/g, '/').toLowerCase();
+                        return norm.includes(normalizedFile) || normalizedFile.includes(norm);
+                    });
+                    if (!touches && !disc.content.toLowerCase().includes(normalizedFile))
+                        return false;
+                }
+                else if (s.type === 'warning') {
+                    const warn = s;
+                    const touches = warn.content.toLowerCase().includes(normalizedFile) ||
+                        Boolean(warn.changedSignature && warn.changedSignature.toLowerCase().includes(normalizedFile));
+                    if (!touches)
+                        return false;
+                }
+                else if (s.type === 'request') {
+                    const req = s;
+                    if (!req.content.toLowerCase().includes(normalizedFile))
+                        return false;
+                }
+                else if (s.type === 'completion') {
+                    const comp = s;
+                    const touches = comp.summary.toLowerCase().includes(normalizedFile) ||
+                        Object.keys(comp.exports || {}).some((k) => k.toLowerCase().includes(normalizedFile));
+                    if (!touches)
+                        return false;
+                }
+            }
+            return true;
+        });
+        // Advance cursors if requested (default: true)
+        if (options.advanceCursor !== false) {
+            this.activityCursors.set(options.agentId, this.activityLog.length);
+            this.signalCursors.set(options.agentId, this.signals.length);
+        }
+        return { activities, signals };
+    }
     /**
      * Writes the full bus state to disk atomically. Called after every mutation
      * to ensure crash resilience. Uses fire-and-forget to avoid blocking the
@@ -209,20 +369,4 @@ export class MessageBus {
             this.signalCursors = new Map();
         }
     }
-    /**
-     * Clears all bus state and removes the persistence file.
-     * Called when orchestration completes successfully (no crash recovery needed).
-     */
-    async cleanup() {
-        this.activityLog = [];
-        this.signals = [];
-        this.activityCursors = new Map();
-        this.signalCursors = new Map();
-        try {
-            await fs.unlink(this.persistPath);
-        }
-        catch {
-            // File may not exist — non-fatal
-        }
-    }
 }

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

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Main Orchestrator for Sub-Agent Dispatch and Coordination.
+ * @file Main Orchestrator for Sub-Agent Dispatch and Coordination.
  *
  * The orchestrator acts as the "PM Kernel", responsible for:
  * 1. Task Decomposition (using gemini-3.7-flash)
@@ -13,10 +13,10 @@ export declare class Orchestrator {
     private readonly workspaceRoot;
     private readonly conversationId;
     private readonly inputHandler;
+    private agentResults;
     private bus;
     private locks;
     private pmChat;
-    private agentResults;
     constructor(workspaceRoot: string, conversationId: string, inputHandler: AsyncInputHandler);
     /**
      * Main entry point for orchestration. Decomposes the task, validates the graph,
@@ -30,10 +30,6 @@ export declare class Orchestrator {
      * Calls the PM Agent to decompose the task into a TaskGraph.
      */
     private decomposeTask;
-    /**
-     * Computes execution waves and resolves file lock conflicts via pre-allocation.
-     */
-    private scheduleWaves;
     /**
      * Dispatches a single sub-agent and records its result.
      */
@@ -42,4 +38,8 @@ export declare class Orchestrator {
      * Final reconciliation phase after all waves complete.
      */
     private reconcile;
+    /**
+     * Computes execution waves and resolves file lock conflicts via pre-allocation.
+     */
+    private scheduleWaves;
 }

package/dist/services/orchestration/orchestrator.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Main Orchestrator for Sub-Agent Dispatch and Coordination.
+ * @file Main Orchestrator for Sub-Agent Dispatch and Coordination.
  *
  * The orchestrator acts as the "PM Kernel", responsible for:
  * 1. Task Decomposition (using gemini-3.7-flash)
@@ -57,10 +57,10 @@ export class Orchestrator {
     workspaceRoot;
     conversationId;
     inputHandler;
+    agentResults = new Map();
     bus;
     locks;
     pmChat;
-    agentResults = new Map();
     constructor(workspaceRoot, conversationId, inputHandler) {
         this.workspaceRoot = workspaceRoot;
         this.conversationId = conversationId;
@@ -103,7 +103,9 @@ export class Orchestrator {
             if (signal.aborted)
                 break;
             // Cooling-off pause before dispatching each execution wave
-            await new Promise((resolve) => setTimeout(resolve, TPM_COOLING_DELAYS.ORCHESTRATION_WAVE_MS));
+            await new Promise((resolve) => {
+                setTimeout(resolve, TPM_COOLING_DELAYS.ORCHESTRATION_WAVE_MS);
+            });
             if (signal.aborted)
                 break;
             const taskDescriptions = wave.taskIds
@@ -131,7 +133,9 @@ export class Orchestrator {
                 if (signal.aborted)
                     break;
                 if (i > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, TPM_COOLING_DELAYS.PARALLEL_CHUNK_MS));
+                    await new Promise((resolve) => {
+                        setTimeout(resolve, TPM_COOLING_DELAYS.PARALLEL_CHUNK_MS);
+                    });
                     if (signal.aborted)
                         break;
                 }
@@ -163,7 +167,8 @@ export class Orchestrator {
             const successful = results.filter((r) => r.success).length;
             s.stop(`Wave ${wave.depth + 1} completed: ${successful}/${wave.taskIds.length} tasks succeeded`);
             if (toolLogs.length > 0) {
-                toolLogs.forEach((log) => p.log.step(log));
+                for (const log of toolLogs)
+                    p.log.step(log);
             }
             // Post-wave evaluation
             const failedCount = results.filter((r) => !r.success).length;
@@ -179,7 +184,9 @@ export class Orchestrator {
         }
         // 4. Reconciliation
         if (!signal.aborted) {
-            await new Promise((resolve) => setTimeout(resolve, TPM_COOLING_DELAYS.ORCHESTRATION_RECONCILE_MS));
+            await new Promise((resolve) => {
+                setTimeout(resolve, TPM_COOLING_DELAYS.ORCHESTRATION_RECONCILE_MS);
+            });
         }
         const finalSummary = await this.reconcile(graph, signal);
         return finalSummary;
@@ -228,26 +235,16 @@ export class Orchestrator {
             return null;
         });
     }
-    /**
-     * Computes execution waves and resolves file lock conflicts via pre-allocation.
-     */
-    scheduleWaves(graph) {
-        try {
-            const rawWaves = computeExecutionWaves(graph);
-            const conflicts = detectFileConflicts(graph, rawWaves);
-            return resolveFileConflicts(rawWaves, conflicts);
-        }
-        catch (err) {
-            debugLog(`Orchestrator: Failed to schedule waves: ${err.message}`);
-            return null;
-        }
-    }
     /**
      * Dispatches a single sub-agent and records its result.
      */
     async dispatchAgent(taskDef, globalContext, signal, onProgress, onTool) {
         return trackTask(`Sub-Agent: ${taskDef.id}`, async () => {
-            const runner = new SubAgentRunner(taskDef.id, taskDef.intent, this.workspaceRoot, this.bus, this.locks, globalContext, onProgress, onTool);
+            const runner = new SubAgentRunner(taskDef.id, taskDef.intent, this.workspaceRoot, this.bus, this.locks, globalContext, onProgress, onTool, {
+                targetFiles: taskDef.targetFiles,
+                readOnlyFiles: taskDef.readOnlyFiles,
+                dependsOn: taskDef.dependsOn,
+            });
             const result = await runner.execute(signal);
             // Clean up any stray locks if the agent crashed or stalled
             if (result.crashed) {
@@ -310,4 +307,18 @@ export class Orchestrator {
         this.locks.shutdown();
         return finalSummary.trim();
     }
+    /**
+     * Computes execution waves and resolves file lock conflicts via pre-allocation.
+     */
+    scheduleWaves(graph) {
+        try {
+            const rawWaves = computeExecutionWaves(graph);
+            const conflicts = detectFileConflicts(graph, rawWaves);
+            return resolveFileConflicts(rawWaves, conflicts);
+        }
+        catch (err) {
+            debugLog(`Orchestrator: Failed to schedule waves: ${err.message}`);
+            return null;
+        }
+    }
 }

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

@@ -11,6 +11,11 @@ import { type PathResolutionOptions } from '../../utils/pathSecurity.js';
  * @returns Absolute canonical file path
  */
 export declare function resolveCanonicalLockPath(workspaceRoot: string, filePath: string, options?: PathResolutionOptions): string;
+export interface TaskScope {
+    targetFiles?: string[];
+    readOnlyFiles?: string[];
+    dependsOn?: string[];
+}
 /**
  * Returns Gemini tool declarations available to sub-agents during orchestration.
  * In addition to standard agent tools (read/write/search/command/etc.), includes
@@ -30,5 +35,6 @@ export declare function getScopedToolDeclarations(): any[];
  * @param locks - Shared file lock registry instance
  * @param onProgress - Callback to notify parent of sub-agent progress
  * @param options - Optional sub-path auto-focus and override configuration
+ * @param taskScope - Optional task scope metadata (targetFiles, dependsOn)
  */
-export declare function executeScopedTool(name: string, args: Record<string, any>, workspaceRoot: string, agentId: string, bus: MessageBus, locks: FileLockRegistry, onProgress: (msg?: string) => void, options?: PathResolutionOptions): Promise<any>;
+export declare function executeScopedTool(name: string, args: Record<string, any>, workspaceRoot: string, agentId: string, bus: MessageBus, locks: FileLockRegistry, onProgress: (msg?: string) => void, options?: PathResolutionOptions, taskScope?: TaskScope): Promise<any>;