minovative-mind-cli 2.6.4 → 2.8.0

package/README.md

@@ -7,7 +7,7 @@ and hope for the best.
 
 This CLI does the opposite — it uses a custom built agentic system called,
 **Precision-Context Verification (PCV)** engine to feed lightweight Flash models
-exactly the right context, execute code, verify the output compiles, and self-correct (if it even needs to), until
+exactly the right context, execute code, verify compilation, execute Property-Based Testing (PBT) suites and diff-scoped mutation audits, and self-correct (if it even needs to), until
 the build/performance metrics are green.
 
 > The result: **Genuine Pro reasoning accuracy at Flash-level speed and efficiency.**
@@ -142,7 +142,7 @@ By prefixing file paths with `@alias/` (e.g., `@backend/src/api.ts` and `@fronte
 
 Minovative Mind CLI fundamentally supports **ALL programming languages** for chat, code generation, planning, and execution, as it relies on Gemini's vast training data.
 
-However, the PCV engine features deep, context-aware analysis across **12 major programming language families**. Our core advanced engines—**Smart Dependency Tracing**, **Performance Auditing** (across 9 language families), and **Ephemeral Analysis Scripts**—provide tailored support depending on the language's syntax and runtime model:
+However, the PCV engine features deep, context-aware analysis across **12 major programming language families**. Our core advanced engines—**Smart Dependency Tracing**, **Property-Based & Mutation Verification**, **Performance Auditing** (across 9 language families), and **Ephemeral Analysis Scripts**—provide tailored support depending on the language's syntax and runtime model:
 
 | Language Family              | Supported Extensions                         | Dependency Tracing | Performance Auditing | Ephemeral Analysis |
 | :--------------------------- | :------------------------------------------- | :----------------: | :------------------: | :----------------: |
@@ -165,7 +165,7 @@ _⚠️\*Support is limited or requires custom local system tooling/environment
 
 1. **Dependency Tracing:** Fully supported across language families. It uses lightning-fast static regex pattern matching to resolve local import structures and determine the "blast radius" of code changes without requiring local compilations.
 2. **Performance Auditing:** Executed natively across 9 major language families (JavaScript/TypeScript, Python, Go, Rust, PHP, C#, Java, C/C++, and Ruby). It uses zero-dependency, ultra-fast (<50ms) language-aware regex heuristics with comment/string stripping and line-preserving offset tracking to detect severe runtime anti-patterns (such as unbounded loops, synchronous I/O, chained array allocations, unnecessary allocations, and unclosed resources).
-3. **Ephemeral Analysis Scripts:** Runs temporary files in sandbox directories to parse and extract local symbols. Also used for infrastructure probing (detecting available runtimes, checking ports, identifying project type), post-change validation (importing modified modules and asserting expected behavior), and lightweight ML-powered analysis (e.g., TF-IDF file ranking, anomaly detection, Big-O estimation). Defaults to Node.js as a safe baseline, but natively leverages host-installed runtimes (Python, Rust, Go compilers) and standard libraries whenever available in the workspace.
+3. **Ephemeral Analysis & Property-Based Probing:** Defaults to Node.js as a safe baseline, but natively leverages host-installed runtimes (Python, Rust, Go compilers) and standard libraries whenever available in the workspace.
 
 ---
 

package/dist/services/agent/slashCommands.js

@@ -223,20 +223,27 @@ export async function handleSlashCommand(command, context) {
         try {
             const { getInvestigationCacheStats } = await import('../orchestration/investigationCache.js');
             const invStats = getInvestigationCacheStats(workspaceRoot);
-            const memBankSizeKB = (invStats.sizeBytes / 1024).toFixed(1);
-            console.log(`${pc.bold('Memory Bank:')}      ${pc.cyan(`${invStats.entries} cached investigations (${memBankSizeKB} KB / 5 MB)`)}`);
+            const formatBytesToSize = (bytes) => {
+                if (bytes >= 1024 * 1024) {
+                    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+                }
+                return `${(bytes / 1024).toFixed(1)} KB`;
+            };
+            const memBankSizeStr = formatBytesToSize(invStats.sizeBytes);
+            console.log(`${pc.bold('Memory Bank:')}      ${pc.cyan(`${invStats.entries} cached investigations (${memBankSizeStr} / 5 MB)`)}`);
             const { readCache } = await import('../../utils/projectStorage.js');
             const contextCache = readCache(workspaceRoot, 'context_cache.json');
             const contextEntries = contextCache ? Object.keys(contextCache).length : 0;
-            let contextSizeKB = '0.0';
+            let contextSizeBytes = 0;
             try {
                 const fs = await import('node:fs');
                 const path = await import('node:path');
                 const stat = await fs.promises.stat(path.join(workspaceRoot, '.minovativemind', 'context_cache.json'));
-                contextSizeKB = (stat.size / 1024).toFixed(1);
+                contextSizeBytes = stat.size;
             }
             catch (e) { }
-            console.log(`${pc.bold('Context Cache:')}    ${pc.cyan(`${contextEntries} file summaries (${contextSizeKB} KB / 5 MB)`)}`);
+            const contextSizeStr = formatBytesToSize(contextSizeBytes);
+            console.log(`${pc.bold('Context Cache:')}    ${pc.cyan(`${contextEntries} file summaries (${contextSizeStr} / 5 MB)`)}`);
         }
         catch (e) {
             // Ignored if cache stats fail

package/dist/services/agent/toolLoop.js

@@ -1,3 +1,4 @@
+import path from 'path';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { debugLog } from '../../utils/logger.js';
@@ -24,6 +25,9 @@ const TOOL_ICONS = {
     find_dependencies: '🔗',
     run_analysis_script: '🔬',
     run_debug_script: '🧪',
+    run_fuzz_probe: '🎯',
+    check_heap_delta: '📊',
+    check_behavioral_drift: '🔀',
 };
 /**
  * Human-readable translations for tool actions.
@@ -41,6 +45,9 @@ const TOOL_LABELS = {
     find_dependencies: 'Tracing dependencies',
     run_analysis_script: 'Analyzing workspace',
     run_debug_script: 'Executing debug/validation script',
+    run_fuzz_probe: 'Executing fuzz testing probe',
+    check_heap_delta: 'Inspecting memory heap delta',
+    check_behavioral_drift: 'Comparing behavioral drift',
 };
 // ─── Helpers ─────────────────────────────────────────────────────────
 /**
@@ -52,8 +59,20 @@ const TOOL_LABELS = {
  * @returns A fully colorized and formatted ANSI console string.
  */
 export function formatToolCall(name, args) {
-    const icon = TOOL_ICONS[name] ?? '🔧';
-    const label = TOOL_LABELS[name] ?? name;
+    let icon = TOOL_ICONS[name] ?? '🔧';
+    let label = TOOL_LABELS[name] ?? name;
+    if (name === 'rename_file') {
+        const src = String(args.sourcePath ?? '');
+        const tgt = String(args.targetPath ?? '');
+        if (src && tgt && path.dirname(src) === path.dirname(tgt)) {
+            label = 'Renaming file';
+            icon = '🏷️';
+        }
+        else {
+            label = 'Moving file';
+            icon = '🚚';
+        }
+    }
     const formatPath = (path) => pc.cyan(path);
     const argsMap = {
         read_file: () => {
@@ -86,6 +105,37 @@ export function formatToolCall(name, args) {
         find_dependencies: () => `: ${formatPath(String(args.filePath))}${args.direction ? ` (${args.direction})` : ''}`,
         run_analysis_script: () => `: ${formatPath(String(args.targetFile ?? 'workspace'))}`,
         run_debug_script: () => `: ${pc.dim(`(${String(args.language ?? 'script')})`)}`,
+        run_fuzz_probe: () => {
+            const lang = String(args.language ?? 'node');
+            const extras = [];
+            if (args.iterations !== undefined)
+                extras.push(`${args.iterations} iterations`);
+            if (args.seed !== undefined)
+                extras.push(`seed: ${args.seed}`);
+            const meta = extras.length > 0 ? `, ${extras.join(', ')}` : '';
+            return `: ${pc.dim(`(${lang}${meta})`)}`;
+        },
+        check_heap_delta: () => {
+            const lang = String(args.language ?? 'node');
+            const extras = [];
+            if (args.testIterations !== undefined)
+                extras.push(`${args.testIterations} iterations`);
+            if (args.samplingIntervalMs !== undefined)
+                extras.push(`${args.samplingIntervalMs}ms interval`);
+            const meta = extras.length > 0 ? `, ${extras.join(', ')}` : '';
+            return `: ${pc.dim(`(${lang}${meta})`)}`;
+        },
+        check_behavioral_drift: () => {
+            const lang = String(args.language ?? 'node');
+            const extras = [];
+            if (args.tolerance !== undefined)
+                extras.push(`tol: ${args.tolerance}`);
+            if (Array.isArray(args.compareKeys) && args.compareKeys.length > 0) {
+                extras.push(`keys: ${args.compareKeys.join(', ')}`);
+            }
+            const meta = extras.length > 0 ? `, ${extras.join(', ')}` : '';
+            return `: ${pc.dim(`(${lang}${meta})`)}`;
+        },
     };
     const formatter = argsMap[name];
     const details = formatter ? formatter() : '';

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

@@ -183,6 +183,32 @@ export declare function findRecentChanges(workspaceRoot: string, dirPath?: strin
  * @returns A promise resolving to a {@link ToolResult} containing execution output.
  */
 export declare function runDebugScript(workspaceRoot: string, language: string, code: string, abortSignal?: AbortSignal): Promise<ToolResult>;
+/**
+ * Executes a fuzz probing analysis script and formats the resulting pass/fail and crash statistics.
+ */
+export declare function executeFuzzProbe(workspaceRoot: string, code: string, language?: string, config?: {
+    iterations?: number;
+    maxInputLength?: number;
+    seed?: number;
+    timeoutMs?: number;
+}, abortSignal?: AbortSignal): Promise<ToolResult>;
+/**
+ * Executes a heap memory inspection script and formats memory consumption and growth delta metrics.
+ */
+export declare function executeHeapDelta(workspaceRoot: string, code: string, language?: string, config?: {
+    warmupIterations?: number;
+    testIterations?: number;
+    samplingIntervalMs?: number;
+    timeoutMs?: number;
+}, abortSignal?: AbortSignal): Promise<ToolResult>;
+/**
+ * Executes baseline and candidate scripts, returning output diffs and behavioral drift findings.
+ */
+export declare function executeBehavioralDrift(workspaceRoot: string, baselineCode: string, candidateCode: string, language?: string, config?: {
+    tolerance?: number;
+    compareKeys?: string[];
+    timeoutMs?: number;
+}, abortSignal?: AbortSignal): Promise<ToolResult>;
 /**
  * Central tool dispatcher that resolves multi-workspace paths, executes the requested tool
  * with the provided arguments, records metrics, and returns the standardized {@link ToolResult}.

package/dist/services/agent-tools.js

@@ -24,6 +24,7 @@ import { extractSymbols } from '../utils/symbolExtractor.js';
 import { getMetricCollector } from './metrics.js';
 import { getCurrentAgentId } from '../utils/asyncContext.js';
 import { recordFileRead, hasAgentReadFile } from '../utils/fileReadGuard.js';
+import { runFuzzProbe, checkHeapDelta as runCheckHeapDelta, checkBehavioralDrift as runCheckBehavioralDrift, } from '../utils/analysisRunner.js';
 import ignore from 'ignore';
 const execAsync = promisify(exec);
 // ─── Tool Declarations for Gemini Function Calling ───────────────────
@@ -341,6 +342,109 @@ export const toolDeclarations = [
             required: ['summary'],
         },
     },
+    {
+        name: 'run_fuzz_probe',
+        description: 'Execute a fuzz testing probe script to detect edge-case failures, unhandled exceptions, or unexpected crashes under randomized or boundary inputs.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                code: {
+                    type: SchemaType.STRING,
+                    description: 'The fuzz test script or probe code to execute.',
+                },
+                language: {
+                    type: SchemaType.STRING,
+                    description: 'Runtime environment: "node", "ts-node", "python", "bash", "go", or "rust". Defaults to "node".',
+                },
+                iterations: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Number of fuzz test iterations to run.',
+                },
+                maxInputLength: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Maximum length/size for generated fuzz input vectors.',
+                },
+                seed: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Random seed for deterministic fuzz generation.',
+                },
+                timeoutMs: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Execution timeout in milliseconds.',
+                },
+            },
+            required: ['code'],
+        },
+    },
+    {
+        name: 'check_heap_delta',
+        description: 'Execute a heap memory inspection script to measure memory consumption, detect heap growth/leaks, and evaluate memory delta statistics.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                code: {
+                    type: SchemaType.STRING,
+                    description: 'The script or code snippet to execute for heap memory analysis.',
+                },
+                language: {
+                    type: SchemaType.STRING,
+                    description: 'Runtime environment: "node", "ts-node", "python", "bash", "go", or "rust". Defaults to "node".',
+                },
+                warmupIterations: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Number of warmup iterations prior to initial heap snapshot.',
+                },
+                testIterations: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Number of test iterations executed between snapshots.',
+                },
+                samplingIntervalMs: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Memory sampling interval in milliseconds.',
+                },
+                timeoutMs: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Execution timeout in milliseconds.',
+                },
+            },
+            required: ['code'],
+        },
+    },
+    {
+        name: 'check_behavioral_drift',
+        description: 'Execute baseline and candidate scripts in parallel or sequence to detect output differences, return value mismatches, or behavioral drift.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                baselineCode: {
+                    type: SchemaType.STRING,
+                    description: 'The baseline implementation script source code.',
+                },
+                candidateCode: {
+                    type: SchemaType.STRING,
+                    description: 'The candidate implementation script source code to compare against baseline.',
+                },
+                language: {
+                    type: SchemaType.STRING,
+                    description: 'Runtime environment: "node", "ts-node", "python", "bash", "go", or "rust". Defaults to "node".',
+                },
+                tolerance: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Numerical tolerance threshold for floating point comparison.',
+                },
+                compareKeys: {
+                    type: SchemaType.ARRAY,
+                    items: { type: SchemaType.STRING },
+                    description: 'Optional. Specific JSON object keys/fields to compare for drift.',
+                },
+                timeoutMs: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Execution timeout in milliseconds.',
+                },
+            },
+            required: ['baselineCode', 'candidateCode'],
+        },
+    },
 ];
 let currentApprovalMode = 'ask';
 /**
@@ -1312,6 +1416,112 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
         }
     }
 }
+/**
+ * Executes a fuzz probing analysis script and formats the resulting pass/fail and crash statistics.
+ */
+export async function executeFuzzProbe(workspaceRoot, code, language = 'node', config, abortSignal) {
+    try {
+        const res = await runFuzzProbe(workspaceRoot, code, language, {
+            ...config,
+            abortSignal,
+        });
+        let output = `Fuzz Probe Result: ${res.passed ? 'PASSED' : 'FAILED'}\n`;
+        if (res.totalFuzzRuns > 0)
+            output += `Total Fuzz Runs: ${res.totalFuzzRuns}\n`;
+        if (res.seed !== undefined)
+            output += `Seed: ${res.seed}\n`;
+        if (res.failingInputs && res.failingInputs.length > 0) {
+            output += `Failing Inputs / Counterexamples:\n${res.failingInputs.map((inp) => `  - ${inp}`).join('\n')}\n`;
+        }
+        if (res.errorSummary) {
+            output += `Error Summary:\n${res.errorSummary}\n`;
+        }
+        if (res.stdout)
+            output += `\n[STDOUT]\n${res.stdout}\n`;
+        if (res.stderr)
+            output += `\n[STDERR]\n${res.stderr}\n`;
+        return {
+            output: output.trim(),
+            ...(res.exitCode !== 0 && !res.passed ? { error: `Fuzz probe failed with exit code ${res.exitCode}` } : {}),
+        };
+    }
+    catch (err) {
+        return { output: '', error: `Fuzz probe error: ${err.message || String(err)}` };
+    }
+}
+/**
+ * Executes a heap memory inspection script and formats memory consumption and growth delta metrics.
+ */
+export async function executeHeapDelta(workspaceRoot, code, language = 'node', config, abortSignal) {
+    try {
+        const res = await runCheckHeapDelta(workspaceRoot, code, language, {
+            ...config,
+            abortSignal,
+        });
+        let output = `Heap Delta Analysis Result:\n`;
+        output += `Initial Heap: ${res.initialHeapBytes} bytes\n`;
+        output += `Final Heap: ${res.finalHeapBytes} bytes\n`;
+        output += `Delta: ${res.deltaBytes} bytes\n`;
+        output += `Leak Detected: ${res.leakDetected ? 'YES' : 'NO'}\n`;
+        if (res.growthRateBytesPerIter !== undefined) {
+            output += `Growth Rate: ${res.growthRateBytesPerIter} bytes/iter\n`;
+        }
+        if (res.samples && res.samples.length > 0) {
+            output += `Samples (${res.samples.length}):\n`;
+            for (const s of res.samples) {
+                output += `  Iter ${s.iteration}: ${s.heapBytes} bytes\n`;
+            }
+        }
+        if (res.stdout)
+            output += `\n[STDOUT]\n${res.stdout}\n`;
+        if (res.stderr)
+            output += `\n[STDERR]\n${res.stderr}\n`;
+        return {
+            output: output.trim(),
+            ...(res.exitCode !== 0 ? { error: `Heap delta failed with exit code ${res.exitCode}` } : {}),
+        };
+    }
+    catch (err) {
+        return { output: '', error: `Heap delta error: ${err.message || String(err)}` };
+    }
+}
+/**
+ * Executes baseline and candidate scripts, returning output diffs and behavioral drift findings.
+ */
+export async function executeBehavioralDrift(workspaceRoot, baselineCode, candidateCode, language = 'node', config, abortSignal) {
+    try {
+        const res = await runCheckBehavioralDrift(workspaceRoot, baselineCode, candidateCode, language, {
+            ...config,
+            abortSignal,
+        });
+        let output = `Behavioral Drift Analysis Result:\n`;
+        output += `Has Drift: ${res.hasDrift ? 'YES' : 'NO'}\n`;
+        if (res.diffSummary) {
+            output += `Diff Summary:\n${res.diffSummary}\n`;
+        }
+        if (res.driftDetails && res.driftDetails.length > 0) {
+            output += `Drift Details:\n`;
+            for (const detail of res.driftDetails) {
+                output += `  - ${detail.field ? `[${detail.field}] ` : ''}Baseline: ${JSON.stringify(detail.baseline)} vs Candidate: ${JSON.stringify(detail.candidate)}${detail.diff ? ` (${detail.diff})` : ''}\n`;
+            }
+        }
+        if (res.baselineOutput)
+            output += `\n[BASELINE OUTPUT]\n${res.baselineOutput}\n`;
+        if (res.candidateOutput)
+            output += `\n[CANDIDATE OUTPUT]\n${res.candidateOutput}\n`;
+        if (res.stdout)
+            output += `\n[STDOUT]\n${res.stdout}\n`;
+        if (res.stderr)
+            output += `\n[STDERR]\n${res.stderr}\n`;
+        return {
+            output: output.trim(),
+            ...(res.exitCode !== 0 ? { error: `Behavioral drift check failed with exit code ${res.exitCode}` } : {}),
+        };
+    }
+    catch (err) {
+        return { output: '', error: `Behavioral drift error: ${err.message || String(err)}` };
+    }
+}
 /**
  * Resolves `@alias/` prefixed paths in tool arguments to the correct workspace root
  * and relative path. Returns the effective workspaceRoot and the cleaned arguments.
@@ -1424,6 +1634,15 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
     else if (normalizedToolName === 'finish_investigation') {
         normalizedToolName = 'finish_task';
     }
+    else if (normalizedToolName === 'fuzz_probe' || normalizedToolName === 'run_fuzz') {
+        normalizedToolName = 'run_fuzz_probe';
+    }
+    else if (normalizedToolName === 'heap_delta' || normalizedToolName === 'check_heap') {
+        normalizedToolName = 'check_heap_delta';
+    }
+    else if (normalizedToolName === 'behavioral_drift' || normalizedToolName === 'check_drift') {
+        normalizedToolName = 'check_behavioral_drift';
+    }
     // ─── Multi-Workspace Path Resolution ─────────────────────────────
     // Intercept @alias/ prefixed paths and swap workspaceRoot + relative path
     // before dispatching to the underlying tool functions (which remain unchanged).
@@ -1620,6 +1839,42 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
         case 'find_recent_changes':
             result = await findRecentChanges(effectiveRoot, resolvedArgs.dirPath, resolvedArgs.minutes, resolvedArgs.maxDepth);
             break;
+        case 'run_fuzz_probe': {
+            const code = resolvedArgs.code;
+            const language = resolvedArgs.language || 'node';
+            const config = {
+                iterations: resolvedArgs.iterations,
+                maxInputLength: resolvedArgs.maxInputLength,
+                seed: resolvedArgs.seed,
+                timeoutMs: resolvedArgs.timeoutMs,
+            };
+            result = await executeFuzzProbe(effectiveRoot, code, language, config, abortSignal);
+            break;
+        }
+        case 'check_heap_delta': {
+            const code = resolvedArgs.code;
+            const language = resolvedArgs.language || 'node';
+            const config = {
+                warmupIterations: resolvedArgs.warmupIterations,
+                testIterations: resolvedArgs.testIterations,
+                samplingIntervalMs: resolvedArgs.samplingIntervalMs,
+                timeoutMs: resolvedArgs.timeoutMs,
+            };
+            result = await executeHeapDelta(effectiveRoot, code, language, config, abortSignal);
+            break;
+        }
+        case 'check_behavioral_drift': {
+            const baselineCode = resolvedArgs.baselineCode;
+            const candidateCode = resolvedArgs.candidateCode;
+            const language = resolvedArgs.language || 'node';
+            const config = {
+                tolerance: resolvedArgs.tolerance,
+                compareKeys: resolvedArgs.compareKeys,
+                timeoutMs: resolvedArgs.timeoutMs,
+            };
+            result = await executeBehavioralDrift(effectiveRoot, baselineCode, candidateCode, language, config, abortSignal);
+            break;
+        }
         default:
             result = { output: '', error: `Unknown tool: "${toolName}"` };
             break;

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

@@ -83,6 +83,7 @@ export declare class MessageBus {
     private signals;
     private activityCursors;
     private signalCursors;
+    private persistQueue;
     private readonly persistPath;
     private readonly workspaceRoot;
     /** Maximum semantic signals any single agent can post */

package/dist/services/orchestration/messageBus.js

@@ -35,6 +35,7 @@ export class MessageBus {
     signals = [];
     activityCursors = new Map();
     signalCursors = new Map();
+    persistQueue = Promise.resolve();
     persistPath;
     workspaceRoot;
     /** Maximum semantic signals any single agent can post */
@@ -172,8 +173,10 @@ export class MessageBus {
             activityCursors: Object.fromEntries(this.activityCursors),
             signalCursors: Object.fromEntries(this.signalCursors),
         };
-        // Fire-and-forget — don't block the calling agent's tool loop
-        atomicWriteFile(this.persistPath, JSON.stringify(snapshot)).catch((err) => {
+        // Fire-and-forget — don't block the calling agent's tool loop, but serialize writes sequentially
+        this.persistQueue = this.persistQueue
+            .then(() => atomicWriteFile(this.persistPath, JSON.stringify(snapshot)))
+            .catch((err) => {
             debugLog(`MessageBus: Failed to persist to disk: ${err}`);
         });
     }

package/dist/services/orchestration/scopedTools.js

@@ -1,3 +1,4 @@
+import path from 'path';
 import { executeTool, getToolDeclarations as getBaseToolDeclarations } from '../agent-tools.js';
 import { MessageBus } from './messageBus.js';
 import { debugLog } from '../../utils/logger.js';
@@ -149,6 +150,31 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
             const matchCount = (outputText.match(/\.\/[^:]+:\d+:/g) || []).length;
             resultSummary = `${matchCount} matches`;
         }
+        else if (name === 'rename_file') {
+            const src = String(args.sourcePath ?? '');
+            const tgt = String(args.targetPath ?? '');
+            targetDesc = `${src} -> ${tgt}`;
+            actionDesc = (src && tgt && path.dirname(src) === path.dirname(tgt)) ? 'Renamed' : 'Moved';
+        }
+        else if (name === 'delete_file') {
+            targetDesc = String(args.filePath);
+            actionDesc = 'Deleted';
+        }
+        else if (name === 'run_fuzz_probe') {
+            targetDesc = String(args.language ?? 'node');
+            actionDesc = 'Ran fuzz probe';
+            resultSummary = typeof result === 'object' && result?.error ? result.error : 'Completed fuzz probe';
+        }
+        else if (name === 'check_heap_delta') {
+            targetDesc = String(args.language ?? 'node');
+            actionDesc = 'Inspected heap delta';
+            resultSummary = typeof result === 'object' && result?.error ? result.error : 'Completed heap analysis';
+        }
+        else if (name === 'check_behavioral_drift') {
+            targetDesc = String(args.language ?? 'node');
+            actionDesc = 'Checked behavioral drift';
+            resultSummary = typeof result === 'object' && result?.error ? result.error : 'Completed drift comparison';
+        }
         return result;
     }
     catch (error) {

package/dist/services/orchestration/subAgent.js

@@ -72,7 +72,7 @@ export class SubAgentRunner {
             `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' or 'run_command' to test your changes if necessary.\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>`);

package/dist/services/verificationService.d.ts

@@ -5,11 +5,53 @@ export interface VerificationResult {
     errors: string[];
     aborted?: boolean;
 }
+export interface Mutant {
+    id: string;
+    filePath: string;
+    line: number;
+    originalCode: string;
+    mutatedCode: string;
+    operator: string;
+}
+export interface MutationTestResult {
+    totalMutants: number;
+    killedMutants: number;
+    survivedMutants: number;
+    mutationScore: number;
+    mutants: Array<Mutant & {
+        killed: boolean;
+        output?: string;
+    }>;
+}
 export declare function detectVerificationCommand(workspaceRoot: string): Promise<string | null>;
 export declare function runVerification(workspaceRoot: string, abortSignal?: AbortSignal): Promise<VerificationResult | null>;
 export declare function formatVerificationForModel(result: VerificationResult): string;
 export interface FullVerificationResult {
     errors: string | null;
     warnings: string | null;
+    mutationResult?: MutationTestResult | null;
 }
 export declare function verifyChangedFiles(workspaceRoot: string, filePaths: string[], abortSignal?: AbortSignal): Promise<FullVerificationResult | '[Verification Aborted]'>;
+/**
+ * Generates mutants scoped specifically to modified lines of a source file.
+ */
+export declare function generateDiffScopedMutants(filePath: string, content: string, modifiedLines?: number[]): Mutant[];
+/**
+ * Runs diff-scoped mutation testing on modified files within the workspace.
+ * Mutates target lines in-memory/temp copy, executes workspace tests, and ensures mutants are killed.
+ */
+export declare function runDiffScopedMutationTesting(workspaceRoot: string, filePaths: string[], modifiedLineMap?: Record<string, number[]>, abortSignal?: AbortSignal, options?: {
+    maxMutantsPerFile?: number;
+    timeoutMs?: number;
+}): Promise<MutationTestResult>;
+/**
+ * Detects whether property-based testing framework configuration or dependencies exist in workspace.
+ */
+export declare function detectPropertyBasedTests(workspaceRoot: string): Promise<{
+    hasPbt: boolean;
+    framework?: string;
+}>;
+/**
+ * Executes workspace property-based tests if detected.
+ */
+export declare function runPropertyBasedVerification(workspaceRoot: string, abortSignal?: AbortSignal): Promise<VerificationResult | null>;