minovative-mind-cli 2.11.5 → 2.13.0

package/dist/services/orchestration/scopedTools.js

@@ -41,7 +41,7 @@ export function getScopedToolDeclarations() {
                     },
                     content: {
                         type: 'STRING',
-                        description: 'The semantic intent or message content',
+                        description: 'The semantic intent or message content (concise summary, max 500 chars)',
                     },
                     affectedFiles: {
                         type: 'ARRAY',
@@ -58,10 +58,23 @@ export function getScopedToolDeclarations() {
         },
         {
             name: 'read_messages',
-            description: 'Fetch any new messages or activity from other agents on the bus.',
+            description: 'Fetch intelligent updates from other agents on the bus. Can filter by file, agent ID, or signal type.',
             parameters: {
                 type: 'OBJECT',
-                properties: {},
+                properties: {
+                    file: {
+                        type: 'STRING',
+                        description: 'Optional: Filter updates touching a specific file path (e.g., "src/services/auth.ts")',
+                    },
+                    fromAgent: {
+                        type: 'STRING',
+                        description: 'Optional: Filter updates from a specific collaborator agent ID',
+                    },
+                    type: {
+                        type: 'STRING',
+                        description: 'Optional: Filter by signal type ("completion", "warning", "discovery", "request")',
+                    },
+                },
             },
         },
     ];
@@ -80,8 +93,9 @@ export function getScopedToolDeclarations() {
  * @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 async function executeScopedTool(name, args, workspaceRoot, agentId, bus, locks, onProgress, options) {
+export async function executeScopedTool(name, args, workspaceRoot, agentId, bus, locks, onProgress, options, taskScope) {
     // Update heartbeat so the orchestrator knows we are making progress
     onProgress();
     const timestamp = Date.now();
@@ -89,23 +103,27 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
     let targetDesc = 'workspace';
     let status = 'success';
     let result = null;
-    let resultSummary = undefined;
+    let resultSummary;
     try {
         // ─── Orchestration-Specific Tools ────────────────────────────────
         if (name === 'post_message') {
             const type = args.type;
+            let content = String(args.content || '');
+            if (content.length > 500) {
+                content = content.substring(0, 500) + '... (truncated)';
+            }
             const signal = {
                 type,
                 timestamp,
                 fromAgent: agentId,
-                content: args.content,
+                content,
             };
             if (type === 'discovery')
                 signal.affectedFiles = args.affectedFiles || [];
             if (type === 'request')
                 signal.toAgent = args.toAgent || 'all';
             if (type === 'completion')
-                signal.summary = args.content; // map completion summary
+                signal.summary = content; // map completion summary
             const accepted = bus.postSignal(signal);
             if (!accepted) {
                 return { error: `Message bus rejected signal. You have hit the max signal cap (${MessageBus.MAX_SIGNALS_PER_AGENT}). Stop sending signals.` };
@@ -113,7 +131,18 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
             return { success: true, message: 'Message posted to bus.' };
         }
         if (name === 'read_messages') {
-            const unread = bus.getUnread(agentId);
+            const unread = bus.queryBus({
+                agentId,
+                file: args.file,
+                fromAgent: args.fromAgent,
+                type: args.type,
+                onlyMutations: true,
+                targetFiles: taskScope?.targetFiles,
+                dependsOn: taskScope?.dependsOn,
+            });
+            if (unread.activities.length === 0 && unread.signals.length === 0) {
+                return { status: 'No new peer messages or workspace mutations.' };
+            }
             return {
                 activityLogs: MessageBus.formatActivityEntries(unread.activities),
                 semanticSignals: MessageBus.formatSignals(unread.signals),
@@ -157,9 +186,16 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
             // If we got a file lock and had context from a previous writer, we should 
             // inject that diff info back into the agent's tool return payload so it 
             // knows someone else changed the file while it was queued.
-            if (diffContext && typeof result === 'object') {
+            if (diffContext && typeof result === 'object' && result !== null) {
                 result._orchestrationWarning = `NOTICE: Another agent modified this file while you were waiting. Diff context: ${diffContext}`;
             }
+            // In-band relevance-gated urgent signals (warnings, targeted requests, or upstream completions)
+            if (typeof result === 'object' && result !== null && typeof bus?.peekUrgentSignals === 'function') {
+                const urgentSignals = bus.peekUrgentSignals(agentId, taskScope);
+                if (urgentSignals && urgentSignals.length > 0) {
+                    result._orchestrationNotice = MessageBus.formatSignals(urgentSignals);
+                }
+            }
         }
         finally {
             // Release the lock if we grabbed one

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

@@ -1,11 +1,12 @@
 /**
- * @fileoverview Sub-Agent Runner for Orchestration.
+ * @file Sub-Agent Runner for Orchestration.
  *
  * Implements the lifecycle, health monitoring, and tool-loop execution for a single
  * parallelized sub-agent.
  */
 import { MessageBus } from './messageBus.js';
 import { FileLockRegistry } from './fileLockRegistry.js';
+import { TaskScope } from './scopedTools.js';
 /**
  * Scopes workspace file blocks within a context string by replacing full implementation
  * bodies with compact AST declaration outlines (types, classes, function signatures),
@@ -53,31 +54,20 @@ export declare class SubAgentRunner {
     private readonly globalContext;
     private readonly onProgress?;
     private readonly onTool?;
+    private readonly taskScope?;
+    /** Max time without a tool call or response before the agent is considered stalled */
+    static readonly STALL_TIMEOUT_MS = 300000;
     private chat;
-    private lastHeartbeat;
     private creditsUsed;
     private inputTokens;
+    private lastHeartbeat;
     private outputTokens;
-    /** Max time without a tool call or response before the agent is considered stalled */
-    static readonly STALL_TIMEOUT_MS = 300000;
-    constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string, onProgress?: ((msg: string) => void) | undefined, onTool?: ((msg: string) => void) | undefined);
-    /**
-     * Constructs the base system instruction for this specific agent,
-     * injecting scoped AST outlines for referenced workspace files to eliminate
-     * multi-megabyte context bloat during parallel sub-agent execution.
-     */
-    private buildSystemInstruction;
     /**
      * Updates the heartbeat. Passed to `executeScopedTool` to ensure the agent
      * isn't marked as stalled while performing long-running commands.
      */
     private pingHeartbeat;
-    /**
-     * Executes the sub-agent with a health monitor harness.
-     * Runs the tool loop until the model stops returning function calls,
-     * an error occurs, or the stall timeout is hit.
-     */
-    execute(signal: AbortSignal): Promise<SubAgentResult>;
+    constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string, onProgress?: ((msg: string) => void) | undefined, onTool?: ((msg: string) => void) | undefined, taskScope?: TaskScope | undefined);
     /**
      * Compacts older tool responses in the chat session history into concise references
      * (e.g. `[Read X lines from file.ts - tool execution completed]`), drastically reducing
@@ -87,6 +77,18 @@ export declare class SubAgentRunner {
      * @param turnsToKeep Number of recent turns to preserve in full (default: 1).
      */
     compactOlderToolResponses(turnsToKeep?: number): void;
+    /**
+     * Executes the sub-agent with a health monitor harness.
+     * Runs the tool loop until the model stops returning function calls,
+     * an error occurs, or the stall timeout is hit.
+     */
+    execute(signal: AbortSignal): Promise<SubAgentResult>;
+    /**
+     * Constructs the base system instruction for this specific agent,
+     * injecting scoped AST outlines for referenced workspace files to eliminate
+     * multi-megabyte context bloat during parallel sub-agent execution.
+     */
+    private buildSystemInstruction;
     /**
      * Accumulates token usage from the chat session.
      */

package/dist/services/orchestration/subAgent.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Sub-Agent Runner for Orchestration.
+ * @file Sub-Agent Runner for Orchestration.
  *
  * Implements the lifecycle, health monitoring, and tool-loop execution for a single
  * parallelized sub-agent.
@@ -64,6 +64,12 @@ function findMatchingFunctionCall(modelEntry, toolName, partIndex) {
  * @returns Compacted tool execution reference string.
  */
 export function createCompactToolReference(toolName, output, args) {
+    if (toolName === 'read_messages') {
+        return '[read_messages - peer activity reviewed]';
+    }
+    if (toolName === 'post_message') {
+        return '[post_message - coordination signal posted]';
+    }
     if (typeof output !== 'string') {
         return `[${toolName} tool execution completed]`;
     }
@@ -126,14 +132,25 @@ export class SubAgentRunner {
     globalContext;
     onProgress;
     onTool;
+    taskScope;
+    /** Max time without a tool call or response before the agent is considered stalled */
+    static STALL_TIMEOUT_MS = 300_000;
     chat;
-    lastHeartbeat = Date.now();
     creditsUsed = 0;
     inputTokens = 0;
+    lastHeartbeat = Date.now();
     outputTokens = 0;
-    /** Max time without a tool call or response before the agent is considered stalled */
-    static STALL_TIMEOUT_MS = 300_000;
-    constructor(taskId, intent, workspaceRoot, bus, locks, globalContext, onProgress, onTool) {
+    /**
+     * Updates the heartbeat. Passed to `executeScopedTool` to ensure the agent
+     * isn't marked as stalled while performing long-running commands.
+     */
+    pingHeartbeat = (msg) => {
+        this.lastHeartbeat = Date.now();
+        if (msg && this.onProgress) {
+            this.onProgress(msg);
+        }
+    };
+    constructor(taskId, intent, workspaceRoot, bus, locks, globalContext, onProgress, onTool, taskScope) {
         this.taskId = taskId;
         this.intent = intent;
         this.workspaceRoot = workspaceRoot;
@@ -142,6 +159,7 @@ export class SubAgentRunner {
         this.globalContext = globalContext;
         this.onProgress = onProgress;
         this.onTool = onTool;
+        this.taskScope = taskScope;
         let model = getGlobalActiveModel();
         if (model === GEMINI_MODELS.AUTO)
             model = GEMINI_MODELS.FLASH;
@@ -154,44 +172,56 @@ export class SubAgentRunner {
         });
     }
     /**
-     * Constructs the base system instruction for this specific agent,
-     * injecting scoped AST outlines for referenced workspace files to eliminate
-     * multi-megabyte context bloat during parallel sub-agent execution.
-     */
-    buildSystemInstruction() {
-        const scopedContext = scopeContext(this.globalContext);
-        return (`<identity>\n` +
-            `You are an autonomous Senior software developer sub-agent executing a specific portion of a larger task.\n` +
-            `</identity>\n\n` +
-            `<task_info>\n` +
-            `Your task ID is: ${this.taskId}\n` +
-            `Your objective: ${this.intent}\n` +
-            `</task_info>\n\n` +
-            `<reference_context>\n` +
-            `DO NOT IMPLEMENT THIS FULL REQUEST. THIS IS JUST FOR CONTEXT.\n\n` +
-            `${scopedContext}\n` +
-            `</reference_context>\n\n` +
-            `<critical_guidelines>\n` +
-            `1. You are ONE worker in a team. Focus EXCLUSIVELY on your specific objective: "${this.intent}".\n` +
-            `2. DO NOT attempt to fulfill the entire original user request in the reference context. Other agents handle other tasks.\n` +
-            `3. EXECUTION WORKFLOW:\n` +
-            `   - Step 1 (Investigate): Use 'grep_search', 'read_file', or 'list_directory' to inspect the codebase as needed.\n` +
-            `   - Step 2 (Execute): Use 'modify_file' or 'write_file' to implement the required changes.\n` +
-            `   - Step 3 (Verify): Use 'run_debug_script', 'run_fuzz_probe', 'check_heap_delta', 'check_behavioral_drift', or 'run_command' to test your changes if necessary.\n` +
-            `   - Step 4 (Conclude): Once your specific objective is fully met, stop calling tools and return a text summary of your changes.\n` +
-            `4. Coordinate: Use 'read_messages' to check for updates from other agents. Use 'post_message' if you discover breaking changes affecting others.\n` +
-            `</critical_guidelines>`);
-    }
-    /**
-     * Updates the heartbeat. Passed to `executeScopedTool` to ensure the agent
-     * isn't marked as stalled while performing long-running commands.
+     * Compacts older tool responses in the chat session history into concise references
+     * (e.g. `[Read X lines from file.ts - tool execution completed]`), drastically reducing
+     * context window bloat across multi-turn sub-agent executions while preserving
+     * Gemini's functionCall <-> functionResponse protocol.
+     *
+     * @param turnsToKeep Number of recent turns to preserve in full (default: 1).
      */
-    pingHeartbeat = (msg) => {
-        this.lastHeartbeat = Date.now();
-        if (msg && this.onProgress) {
-            this.onProgress(msg);
+    compactOlderToolResponses(turnsToKeep = 1) {
+        const rawHistory = this.chat.getRawHistory();
+        // 1 turn = 1 user Content + 1 model Content pair (2 entries)
+        const cutoffIndex = Math.max(0, rawHistory.length - turnsToKeep * 2);
+        if (cutoffIndex <= 0)
+            return;
+        for (let i = 0; i < cutoffIndex; i++) {
+            const entry = rawHistory[i];
+            if (entry && entry.role === 'user' && Array.isArray(entry.parts)) {
+                const prevModelEntry = i > 0 ? rawHistory[i - 1] : undefined;
+                let funcRespIdx = 0;
+                for (const part of entry.parts) {
+                    if (part && typeof part === 'object' && 'functionResponse' in part && part.functionResponse) {
+                        const funcResp = part.functionResponse;
+                        const toolName = funcResp.name || 'tool';
+                        const matchingCall = findMatchingFunctionCall(prevModelEntry, toolName, funcRespIdx);
+                        const args = matchingCall?.args;
+                        if (funcResp.response && typeof funcResp.response === 'object') {
+                            const respObj = funcResp.response;
+                            if (toolName === 'read_messages') {
+                                funcResp.response = { output: '[read_messages - peer activity reviewed]' };
+                            }
+                            else if (toolName === 'post_message') {
+                                funcResp.response = { output: '[post_message - coordination signal posted]' };
+                            }
+                            else if (typeof respObj.output === 'string') {
+                                respObj.output = createCompactToolReference(toolName, respObj.output, args);
+                            }
+                            else if (typeof respObj.result === 'string') {
+                                respObj.result = createCompactToolReference(toolName, respObj.result, args);
+                            }
+                            else if (typeof respObj.output === 'object' && respObj.output !== null) {
+                                respObj.output = createCompactToolReference(toolName, respObj.output, args);
+                            }
+                        }
+                        funcRespIdx++;
+                    }
+                }
+            }
         }
-    };
+        // Also trigger proxy chat session pruning to collapse any remaining long fields
+        this.chat.pruneToolOutputHistory();
+    }
     /**
      * Executes the sub-agent with a health monitor harness.
      * Runs the tool loop until the model stops returning function calls,
@@ -243,7 +273,7 @@ export class SubAgentRunner {
                         debugLog(`SubAgent [${this.taskId}]: Executing tool ${call.name}`);
                         let responseData;
                         try {
-                            responseData = await executeScopedTool(call.name, call.args, this.workspaceRoot, this.taskId, this.bus, this.locks, this.pingHeartbeat);
+                            responseData = await executeScopedTool(call.name, call.args, this.workspaceRoot, this.taskId, this.bus, this.locks, this.pingHeartbeat, undefined, this.taskScope);
                         }
                         catch (err) {
                             responseData = { error: err.message || String(err) };
@@ -309,46 +339,33 @@ export class SubAgentRunner {
         });
     }
     /**
-     * Compacts older tool responses in the chat session history into concise references
-     * (e.g. `[Read X lines from file.ts - tool execution completed]`), drastically reducing
-     * context window bloat across multi-turn sub-agent executions while preserving
-     * Gemini's functionCall <-> functionResponse protocol.
-     *
-     * @param turnsToKeep Number of recent turns to preserve in full (default: 1).
+     * Constructs the base system instruction for this specific agent,
+     * injecting scoped AST outlines for referenced workspace files to eliminate
+     * multi-megabyte context bloat during parallel sub-agent execution.
      */
-    compactOlderToolResponses(turnsToKeep = 1) {
-        const rawHistory = this.chat.getRawHistory();
-        // 1 turn = 1 user Content + 1 model Content pair (2 entries)
-        const cutoffIndex = Math.max(0, rawHistory.length - turnsToKeep * 2);
-        if (cutoffIndex <= 0)
-            return;
-        for (let i = 0; i < cutoffIndex; i++) {
-            const entry = rawHistory[i];
-            if (entry && entry.role === 'user' && Array.isArray(entry.parts)) {
-                const prevModelEntry = i > 0 ? rawHistory[i - 1] : undefined;
-                let funcRespIdx = 0;
-                for (const part of entry.parts) {
-                    if (part && typeof part === 'object' && 'functionResponse' in part && part.functionResponse) {
-                        const funcResp = part.functionResponse;
-                        const toolName = funcResp.name || 'tool';
-                        const matchingCall = findMatchingFunctionCall(prevModelEntry, toolName, funcRespIdx);
-                        const args = matchingCall?.args;
-                        if (funcResp.response && typeof funcResp.response === 'object') {
-                            const respObj = funcResp.response;
-                            if (typeof respObj.output === 'string') {
-                                respObj.output = createCompactToolReference(toolName, respObj.output, args);
-                            }
-                            if (typeof respObj.result === 'string') {
-                                respObj.result = createCompactToolReference(toolName, respObj.result, args);
-                            }
-                        }
-                        funcRespIdx++;
-                    }
-                }
-            }
-        }
-        // Also trigger proxy chat session pruning to collapse any remaining long fields
-        this.chat.pruneToolOutputHistory();
+    buildSystemInstruction() {
+        const scopedContext = scopeContext(this.globalContext);
+        return (`<identity>\n` +
+            `You are an autonomous Senior software developer sub-agent executing a specific portion of a larger task.\n` +
+            `</identity>\n\n` +
+            `<task_info>\n` +
+            `Your task ID is: ${this.taskId}\n` +
+            `Your objective: ${this.intent}\n` +
+            `</task_info>\n\n` +
+            `<reference_context>\n` +
+            `DO NOT IMPLEMENT THIS FULL REQUEST. THIS IS JUST FOR CONTEXT.\n\n` +
+            `${scopedContext}\n` +
+            `</reference_context>\n\n` +
+            `<critical_guidelines>\n` +
+            `1. You are ONE worker in a team. Focus EXCLUSIVELY on your specific objective: "${this.intent}".\n` +
+            `2. DO NOT attempt to fulfill the entire original user request in the reference context. Other agents handle other tasks.\n` +
+            `3. EXECUTION WORKFLOW:\n` +
+            `   - Step 1 (Investigate): Use 'grep_search', 'read_file', or 'list_directory' to inspect the codebase as needed.\n` +
+            `   - Step 2 (Execute): Use 'modify_file' or 'write_file' to implement the required changes.\n` +
+            `   - Step 3 (Verify): Use 'run_debug_script', 'run_fuzz_probe', 'check_heap_delta', 'check_behavioral_drift', or 'run_command' to test your changes if necessary.\n` +
+            `   - Step 4 (Conclude): Once your specific objective is fully met, stop calling tools and return a text summary of your changes.\n` +
+            `4. Coordinate: Use 'read_messages' to check for updates from other agents. Use 'post_message' if you discover breaking changes affecting others.\n` +
+            `</critical_guidelines>`);
     }
     /**
      * Accumulates token usage from the chat session.

package/dist/services/swebench/gitDiffExtractor.d.ts

@@ -0,0 +1,57 @@
+export interface DiffExtractionOptions {
+    baseCommit?: string;
+    includeUntracked?: boolean;
+    maxBuffer?: number;
+}
+/**
+ * Checks whether the target directory contains a valid git repository.
+ */
+export declare function isGitRepository(workspaceDir: string): Promise<boolean>;
+/**
+ * Gets the current HEAD commit hash of the git repository.
+ */
+export declare function getHeadCommit(workspaceDir: string): Promise<string>;
+/**
+ * Resets the workspace git repository to a clean state matching baseCommit or HEAD.
+ */
+export declare function resetWorkspaceRepo(workspaceDir: string, baseCommit?: string): Promise<void>;
+/**
+ * Extracts a unified git patch representing all modifications made by the model.
+ * Produces standard SWE-bench format (patch starting with `diff --git` or empty string).
+ */
+export declare function extractGitPatch(workspaceDir: string, options?: string | DiffExtractionOptions): Promise<string>;
+/**
+ * Normalizes git unified diff patch text:
+ * - Trims superfluous leading/trailing whitespace
+ * - Ensures empty diff returns exact empty string ""
+ * - Preserves trailing newline if content exists
+ */
+export declare function normalizePatch(patch: string): string;
+/**
+ * Validates whether a patch conforms to standard unified diff structure.
+ */
+export declare function validatePatchFormat(patch: string): {
+    valid: boolean;
+    issues?: string[];
+};
+/**
+ * Checks out a specific base commit in the repository.
+ */
+export declare function checkoutBaseCommit(workspaceDir: string, baseCommit: string, options?: {
+    fetchIfMissing?: boolean;
+}): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Clones a repository if it doesn't already exist or ensures it is checked out.
+ */
+export declare function cloneOrEnsureRepo(repo: string, targetDir: string, options?: {
+    cloneUrl?: string;
+    baseCommit?: string;
+    shallow?: boolean;
+}): Promise<{
+    success: boolean;
+    repoDir: string;
+    error?: string;
+}>;