minovative-mind-cli 2.11.4 → 2.11.5

package/dist/services/investigationComplexity.js

@@ -11,91 +11,370 @@
  * has already determined that context gathering is needed (SEARCH).
  */
 import { createInvestigationComplexitySession } from './ai.js';
+import { workspaceRegistry } from './workspaceRegistry.js';
 import { debugLog } from '../utils/logger.js';
-// ─── Evaluator ───────────────────────────────────────────────────────
+// ─── Helper Functions ────────────────────────────────────────────────
 /**
- * Evaluates whether the investigation phase should be parallelized.
+ * Checks whether the user's prompt contains an explicit path or workspace override
+ * that supersedes default primary sub-path auto-focusing.
  *
- * Uses `gemini-3.7-flash` (under auto mode) at temperature 0 to classify the prompt's
- * investigation complexity. The PM dynamically identifies domains and groups
- * them into agent assignments. Agent count = `agentAssignments.length`, which
- * may be fewer than `domains.length` when related domains are batched together.
+ * @param userRequest - The prompt text from the user
+ * @param activeSubPath - The currently active primary sub-path (if any)
+ * @returns The detected override identifier or null if no override exists
+ */
+export function detectSubPathOverride(userRequest, activeSubPath) {
+    if (!userRequest)
+        return null;
+    // Check for external workspace alias syntax (e.g. "@backend/...", "@calc", etc.)
+    const aliasMatch = userRequest.match(/@([a-zA-Z0-9_\-]+)(\/|\s|$)/);
+    if (aliasMatch) {
+        return `@${aliasMatch[1]}`;
+    }
+    // Check for explicit root-level or full-codebase directives
+    const lower = userRequest.toLowerCase();
+    if (lower.includes('whole project') ||
+        lower.includes('entire codebase') ||
+        lower.includes('full codebase') ||
+        lower.includes('across workspaces') ||
+        lower.includes('all workspaces') ||
+        lower.includes('root directory') ||
+        lower.includes('from root') ||
+        lower.includes('@root') ||
+        lower.includes('entire project') ||
+        lower.includes('entire repo') ||
+        lower.includes('all packages') ||
+        lower.includes('all modules') ||
+        lower.includes('across the project') ||
+        lower.includes('across the codebase') ||
+        lower.includes('every workspace')) {
+        return 'root';
+    }
+    // If an active sub-path is present (e.g. "src" or "packages/core"), check if root files outside it are targeted
+    if (activeSubPath) {
+        const rootFiles = [
+            // Package Managers & Dependencies
+            'package.json',
+            'package-lock.json',
+            'yarn.lock',
+            'pnpm-lock.yaml',
+            'pnpm-workspace.yaml',
+            'bun.lockb',
+            'bunfig.toml',
+            'cargo.toml',
+            'cargo.lock',
+            'go.mod',
+            'go.sum',
+            'go.work',
+            'pyproject.toml',
+            'requirements.txt',
+            'requirements-dev.txt',
+            'pipfile',
+            'pipfile.lock',
+            'setup.py',
+            'setup.cfg',
+            'poetry.lock',
+            'gemfile',
+            'gemfile.lock',
+            'composer.json',
+            'composer.lock',
+            'pom.xml',
+            'build.gradle',
+            'build.gradle.kts',
+            'settings.gradle',
+            'settings.gradle.kts',
+            'package.swift',
+            // Compilers, Bundlers & Frameworks
+            'tsconfig.json',
+            'jsconfig.json',
+            'next.config.ts',
+            'next.config.js',
+            'next.config.mjs',
+            'vite.config.ts',
+            'vite.config.js',
+            'vite.config.mjs',
+            'webpack.config.js',
+            'webpack.config.ts',
+            'rollup.config.js',
+            'rollup.config.ts',
+            'turbo.json',
+            'lerna.json',
+            'nx.json',
+            'babel.config.js',
+            'babel.config.json',
+            '.babelrc',
+            'postcss.config.js',
+            'tailwind.config.js',
+            'tailwind.config.ts',
+            'tailwind.config.mjs',
+            // Testing & Quality / Linters
+            'vitest.config.ts',
+            'vitest.config.mts',
+            'vitest.config.js',
+            'jest.config.js',
+            'jest.config.ts',
+            'jest.config.mjs',
+            'pytest.ini',
+            'tox.ini',
+            '.eslintrc',
+            '.eslintrc.json',
+            '.eslintrc.js',
+            '.eslintrc.cjs',
+            'eslint.config.js',
+            'eslint.config.mjs',
+            'eslint.config.cjs',
+            'eslint.config.ts',
+            '.prettierrc',
+            '.prettierrc.json',
+            '.prettierrc.js',
+            'prettier.config.js',
+            'prettier.config.mjs',
+            'biome.json',
+            'ruff.toml',
+            '.flake8',
+            'mypy.ini',
+            'playwright.config.ts',
+            'playwright.config.js',
+            'cypress.config.ts',
+            'cypress.config.js',
+            // C / C++ / Build Systems
+            'cmakelists.txt',
+            'makefile',
+            'gnumakefile',
+            'meson.build',
+            'rakefile',
+            // Cloud, Containers, Deployments & CI/CD
+            'dockerfile',
+            'containerfile',
+            'docker-compose.yml',
+            'docker-compose.yaml',
+            'compose.yaml',
+            'compose.yml',
+            '.dockerignore',
+            'fly.toml',
+            'vercel.json',
+            'netlify.toml',
+            'wrangler.toml',
+            'wrangler.json',
+            'firebase.json',
+            'firestore.rules',
+            'firestore.indexes.json',
+            'storage.rules',
+            'serverless.yml',
+            'procfile',
+            'app.yaml',
+            'cloudbuild.yaml',
+            'jenkinsfile',
+            '.gitlab-ci.yml',
+            // Environments & System Config
+            '.env',
+            '.env.local',
+            '.env.development',
+            '.env.production',
+            '.env.staging',
+            '.env.example',
+            '.env.test',
+            '.gitignore',
+            '.gitattributes',
+            '.editorconfig',
+            // Documentation & Project Metadata
+            'readme.md',
+            'contributing.md',
+            'changelog.md',
+            'license',
+            'license.md',
+            'architecture.md',
+            'features.md',
+            'roadmap.md',
+        ];
+        for (const rf of rootFiles) {
+            if (lower.includes(rf)) {
+                return rf;
+            }
+        }
+    }
+    return null;
+}
+// ─── Main Evaluator ──────────────────────────────────────────────────
+/**
+ * Evaluates whether a user request warrants parallel investigation or a single agent.
+ * Respects default primary sub-path auto-focusing while allowing explicit overrides.
  *
- * @param userRequest - The user's prompt.
- * @param projectType - Detected project type (e.g., "Node.js / TypeScript / React").
- * @param approximateFileCount - Rough file count from the project tree.
- * @param chatHistory - Recent conversation history for context.
- * @returns The complexity classification with domain decomposition.
+ * @param userRequest - The user's prompt/request
+ * @param projectType - Detected project type string (e.g., "Node.js / TypeScript")
+ * @param approximateFileCount - Approximate total file count in the project
+ * @param chatHistory - Formatted recent conversation history (optional)
+ * @param abortSignal - Optional signal to abort the LLM request
+ * @param options - Optional sub-path auto-focus and override configuration
+ * @returns Structured complexity result with strategy and domain assignments
  */
-export async function evaluateInvestigationComplexity(userRequest, projectType, approximateFileCount, chatHistory = '', abortSignal) {
+export async function evaluateInvestigationComplexity(userRequest, projectType, approximateFileCount, chatHistory = '', abortSignal, options) {
     if (abortSignal?.aborted) {
-        const err = new Error('Operation aborted');
-        err.name = 'AbortError';
-        throw err;
+        const error = new Error('The operation was aborted');
+        error.name = 'AbortError';
+        throw error;
     }
+    const configuredSubPath = options?.autoFocusSubPath !== undefined
+        ? options.autoFocusSubPath
+        : workspaceRegistry.getPrimarySubPath();
+    const activeSubPath = options?.disableAutoFocus ? null : configuredSubPath;
+    const explicitOverride = options?.subPathOverride ?? detectSubPathOverride(userRequest, activeSubPath);
+    const isAutoFocused = Boolean(activeSubPath && !explicitOverride);
     try {
-        const session = createInvestigationComplexitySession();
+        const session = await createInvestigationComplexitySession();
         let prompt = `User Request: "${userRequest}"
 Project Type: ${projectType}
 Approximate File Count: ${approximateFileCount}`;
-        if (chatHistory) {
-            prompt = `Previous Conversation Context:\n${chatHistory}\n\n${prompt}`;
+        if (activeSubPath) {
+            if (explicitOverride) {
+                prompt += `\nConfigured Primary Sub-Path: ${activeSubPath}\nSub-Path Override: Active (${explicitOverride}) - scope investigation to requested override.`;
+            }
+            else {
+                prompt += `\nConfigured Primary Sub-Path: ${activeSubPath}\nSub-Path Auto-Focus: Active - prioritize and decompose investigation within "${activeSubPath}" unless user request requires broader exploration.`;
+            }
         }
-        const result = await session.sendMessage(prompt, undefined, abortSignal);
-        const text = result.response.text()?.trim() || '{}';
-        const parsed = JSON.parse(text);
-        debugLog(`Investigation Complexity Parsed: ${JSON.stringify(parsed)}`);
-        // Validate the response shape
-        const strategy = parsed.strategy === 'PARALLEL' ? 'PARALLEL' : 'SINGLE';
-        if (strategy === 'SINGLE') {
+        if (chatHistory.trim()) {
+            prompt += `\n\nRecent Conversation:\n${chatHistory.trim()}`;
+        }
+        debugLog(`[InvestigationComplexity] Evaluating prompt complexity (autoFocus: ${activeSubPath || 'none'}, override: ${explicitOverride || 'none'})`);
+        const response = await session.sendMessage(prompt, undefined, abortSignal);
+        const rawText = typeof response?.response?.text === 'function'
+            ? response.response.text()
+            : typeof response?.text === 'function'
+                ? response.text()
+                : response?.text || '';
+        // Clean JSON response (strip markdown fences if present)
+        const cleaned = rawText.replace(/```(?:json)?\s*([\s\S]*?)```/g, '$1').trim();
+        const parsed = JSON.parse(cleaned);
+        // Determine semantic scope and override from AI response with fast token precedence
+        let finalScope = 'SUB_PATH';
+        let finalOverride = explicitOverride;
+        if (parsed.scope === 'FULL_WORKSPACE') {
+            finalScope = 'FULL_WORKSPACE';
+            if (!finalOverride)
+                finalOverride = parsed.subPathOverride || 'root';
+        }
+        else if (parsed.scope === 'EXTERNAL_WORKSPACE') {
+            finalScope = 'EXTERNAL_WORKSPACE';
+            if (!finalOverride)
+                finalOverride = parsed.subPathOverride || '@alias';
+        }
+        else if (parsed.scope === 'SUB_PATH') {
+            finalScope = 'SUB_PATH';
+            if (!options?.subPathOverride)
+                finalOverride = null;
+        }
+        else if (parsed.subPathOverride && !finalOverride) {
+            finalOverride = parsed.subPathOverride;
+            finalScope = (finalOverride && finalOverride.startsWith('@')) ? 'EXTERNAL_WORKSPACE' : 'FULL_WORKSPACE';
+        }
+        const finalIsAutoFocused = Boolean(activeSubPath && !finalOverride);
+        const rawStrategy = typeof parsed.strategy === 'string' ? parsed.strategy.toUpperCase() : '';
+        const rawDomains = Array.isArray(parsed.domains)
+            ? parsed.domains.map(String).filter(Boolean)
+            : [];
+        const rawAssignments = Array.isArray(parsed.agentAssignments) ? parsed.agentAssignments : [];
+        // Permissive strategy determination: trigger PARALLEL if explicitly requested OR if multiple domains/assignments exist
+        const isParallel = rawStrategy === 'PARALLEL' || rawAssignments.length >= 2 || rawDomains.length >= 2;
+        // If SINGLE without multi-domain signals, return SINGLE
+        if (!isParallel) {
+            debugLog(`[InvestigationComplexity] Strategy: SINGLE (Scope: ${finalScope}, Reason: ${parsed.reasoning || 'N/A'})`);
             return {
                 strategy: 'SINGLE',
+                scope: finalScope,
                 domains: [],
                 agentAssignments: [],
-                reasoning: parsed.reasoning || 'Simple prompt — single agent sufficient.',
+                reasoning: parsed.reasoning || 'Localized prompt — single agent sufficient.',
+                focusedSubPath: activeSubPath,
+                subPathOverride: finalOverride,
+                isAutoFocused: finalIsAutoFocused,
             };
         }
-        // Validate agentAssignments array
-        const agentAssignments = [];
-        if (Array.isArray(parsed.agentAssignments)) {
-            for (const assignment of parsed.agentAssignments) {
-                if (assignment.agentLabel && Array.isArray(assignment.domains) && assignment.domains.length > 0) {
-                    agentAssignments.push({
-                        agentLabel: String(assignment.agentLabel),
-                        domains: assignment.domains.map(String),
-                    });
-                }
+        // Validate agent assignments for PARALLEL
+        let agentAssignments = [];
+        for (const a of rawAssignments) {
+            if (typeof a?.agentLabel === 'string' && Array.isArray(a?.domains) && a.domains.length > 0) {
+                agentAssignments.push({
+                    agentLabel: a.agentLabel.trim(),
+                    domains: a.domains.map(String).filter(Boolean),
+                });
             }
         }
-        // If the PM said PARALLEL but produced no valid assignments, fall back to SINGLE
+        // Permissive Auto-Recovery: if agentAssignments was missing/incomplete but multiple domains were identified
+        if (agentAssignments.length < 2 && rawDomains.length >= 2) {
+            debugLog('[InvestigationComplexity] Auto-constructing agent assignments from identified domains');
+            if (rawDomains.length === 2) {
+                agentAssignments = rawDomains.map((d) => ({
+                    agentLabel: `${d} Specialist`,
+                    domains: [d],
+                }));
+            }
+            else {
+                const mid = Math.ceil(rawDomains.length / 2);
+                agentAssignments = [
+                    {
+                        agentLabel: `${rawDomains[0]} & Subsystems`,
+                        domains: rawDomains.slice(0, mid),
+                    },
+                    {
+                        agentLabel: `${rawDomains[mid]} & Related`,
+                        domains: rawDomains.slice(mid),
+                    },
+                ];
+            }
+        }
+        // If still fewer than 2 valid assignments after auto-recovery, fall back to SINGLE
         if (agentAssignments.length < 2) {
-            debugLog('Investigation Complexity: PM said PARALLEL but produced <2 valid assignments. Falling back to SINGLE.');
+            debugLog('[InvestigationComplexity] PARALLEL requested but <2 valid assignments — falling back to SINGLE');
             return {
                 strategy: 'SINGLE',
+                scope: finalScope,
                 domains: [],
                 agentAssignments: [],
-                reasoning: 'PM produced insufficient agent assignments — falling back to single agent.',
+                reasoning: parsed.reasoning || 'Insufficient domain separation for parallel investigation.',
+                focusedSubPath: activeSubPath,
+                subPathOverride: finalOverride,
+                isAutoFocused: finalIsAutoFocused,
             };
         }
+        let allDomains = rawDomains;
+        if (allDomains.length === 0 && agentAssignments.length > 0) {
+            allDomains = Array.from(new Set(agentAssignments.flatMap((a) => a.domains)));
+        }
+        debugLog(`[InvestigationComplexity] Strategy: PARALLEL with ${agentAssignments.length} agents: ${agentAssignments.map(a => a.agentLabel).join(', ')} (Scope: ${finalScope})`);
         return {
             strategy: 'PARALLEL',
-            domains: Array.isArray(parsed.domains) ? parsed.domains.map(String) : [],
+            scope: finalScope,
+            domains: allDomains,
             agentAssignments,
-            reasoning: parsed.reasoning || '',
+            reasoning: parsed.reasoning || 'Multi-domain parallel investigation dispatched.',
+            focusedSubPath: activeSubPath,
+            subPathOverride: finalOverride,
+            isAutoFocused: finalIsAutoFocused,
         };
     }
-    catch (e) {
-        if (abortSignal?.aborted || e?.name === 'AbortError' || e?.message?.includes('abort')) {
-            const err = new Error('Operation aborted');
-            err.name = 'AbortError';
+    catch (err) {
+        // If aborted, rethrow
+        if (abortSignal?.aborted ||
+            err?.name === 'AbortError' ||
+            err?.name === 'CanceledError' ||
+            err?.code === 'ABORT_ERR' ||
+            err?.message?.includes('aborted') ||
+            err?.message?.includes('abort') ||
+            err?.message?.includes('canceled')) {
+            if (err && !err.name)
+                err.name = 'AbortError';
             throw err;
         }
-        debugLog(`Investigation Complexity Router failed, falling back to SINGLE. Error: ${String(e)}`);
+        debugLog(`[InvestigationComplexity] Evaluation failed (${err?.message}) — falling back to SINGLE`);
         return {
             strategy: 'SINGLE',
+            scope: 'SUB_PATH',
             domains: [],
             agentAssignments: [],
             reasoning: 'Evaluator failed — falling back to single agent.',
+            focusedSubPath: activeSubPath,
+            subPathOverride: explicitOverride,
+            isAutoFocused,
         };
     }
 }

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

@@ -1,57 +1,34 @@
 import { MessageBus } from './messageBus.js';
 import { FileLockRegistry } from './fileLockRegistry.js';
+import { type PathResolutionOptions } from '../../utils/pathSecurity.js';
 /**
- * Extended tool declarations for sub-agents, merging the standard tools
- * with orchestration-specific ones (e.g., post_message, read_messages).
+ * Resolves a file path to its canonical absolute path for lock registry keying,
+ * accounting for multi-workspace alias resolution and default primary sub-path auto-focusing.
+ *
+ * @param workspaceRoot - The base primary workspace root directory
+ * @param filePath - The relative or aliased file path
+ * @param options - Optional sub-path override configuration
+ * @returns Absolute canonical file path
+ */
+export declare function resolveCanonicalLockPath(workspaceRoot: string, filePath: string, options?: PathResolutionOptions): string;
+/**
+ * Returns Gemini tool declarations available to sub-agents during orchestration.
+ * In addition to standard agent tools (read/write/search/command/etc.), includes
+ * inter-agent communication tools (post_message, read_messages).
  */
-export declare function getScopedToolDeclarations(): (import("@google/generative-ai").FunctionDeclaration | {
-    name: string;
-    description: string;
-    parameters: {
-        type: string;
-        properties: {
-            type: {
-                type: string;
-                description: string;
-            };
-            content: {
-                type: string;
-                description: string;
-            };
-            toAgent: {
-                type: string;
-                description: string;
-            };
-            affectedFiles: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-        };
-        required: string[];
-    };
-} | {
-    name: string;
-    description: string;
-    parameters: {
-        type: string;
-        properties: {
-            type?: undefined;
-            content?: undefined;
-            toAgent?: undefined;
-            affectedFiles?: undefined;
-        };
-        required?: undefined;
-    };
-})[];
+export declare function getScopedToolDeclarations(): any[];
 /**
- * Wraps the global executeTool to provide sub-agent context.
+ * Executes a tool within the sub-agent execution boundary.
+ * Handles concurrency locking for file-mutating operations, sends progress
+ * notifications to the orchestrator, and logs activity to the message bus.
  *
- * 1. Captures tool execution into the MessageBus (Layer 1: zero-cost logs).
- * 2. Implements FileLocks for write/modify operations to prevent race conditions.
- * 3. Handles `post_message` and `read_messages` directly.
- * 4. Calls a heartbeat callback to notify the orchestrator this agent is alive.
+ * @param name - Tool function name
+ * @param args - Tool arguments object
+ * @param workspaceRoot - Primary workspace root directory
+ * @param agentId - Unique ID of the executing agent
+ * @param bus - Shared message bus instance
+ * @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
  */
-export declare function executeScopedTool(name: string, args: Record<string, any>, workspaceRoot: string, agentId: string, bus: MessageBus, locks: FileLockRegistry, onProgress: (msg?: string) => void): 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): Promise<any>;

package/dist/services/orchestration/scopedTools.js

@@ -1,14 +1,34 @@
 import path from 'path';
 import { executeTool, getToolDeclarations as getBaseToolDeclarations } from '../agent-tools.js';
 import { MessageBus } from './messageBus.js';
+import { resolveAndValidateMultiWorkspacePath } from '../../utils/pathSecurity.js';
 import { debugLog } from '../../utils/logger.js';
 /**
- * Extended tool declarations for sub-agents, merging the standard tools
- * with orchestration-specific ones (e.g., post_message, read_messages).
+ * Resolves a file path to its canonical absolute path for lock registry keying,
+ * accounting for multi-workspace alias resolution and default primary sub-path auto-focusing.
+ *
+ * @param workspaceRoot - The base primary workspace root directory
+ * @param filePath - The relative or aliased file path
+ * @param options - Optional sub-path override configuration
+ * @returns Absolute canonical file path
+ */
+export function resolveCanonicalLockPath(workspaceRoot, filePath, options) {
+    try {
+        const resolved = resolveAndValidateMultiWorkspacePath(workspaceRoot, filePath, options);
+        return resolved.absolutePath;
+    }
+    catch {
+        return path.isAbsolute(filePath) ? filePath : path.resolve(workspaceRoot, filePath);
+    }
+}
+/**
+ * Returns Gemini tool declarations available to sub-agents during orchestration.
+ * In addition to standard agent tools (read/write/search/command/etc.), includes
+ * inter-agent communication tools (post_message, read_messages).
  */
 export function getScopedToolDeclarations() {
-    return [
-        ...getBaseToolDeclarations({ isExecutionAgent: true }),
+    const baseTools = getBaseToolDeclarations({ isExecutionAgent: true });
+    const orchestrationTools = [
         {
             name: 'post_message',
             description: 'Post a semantic message to the orchestration bus to coordinate with other agents.',
@@ -23,15 +43,15 @@ export function getScopedToolDeclarations() {
                         type: 'STRING',
                         description: 'The semantic intent or message content',
                     },
-                    toAgent: {
-                        type: 'STRING',
-                        description: 'Optional target agent ID (required for "request")',
-                    },
                     affectedFiles: {
                         type: 'ARRAY',
                         items: { type: 'STRING' },
                         description: 'Files involved (required for "discovery")',
                     },
+                    toAgent: {
+                        type: 'STRING',
+                        description: 'Optional target agent ID (required for "request")',
+                    },
                 },
                 required: ['type', 'content'],
             },
@@ -45,16 +65,23 @@ export function getScopedToolDeclarations() {
             },
         },
     ];
+    return [...baseTools, ...orchestrationTools];
 }
 /**
- * Wraps the global executeTool to provide sub-agent context.
+ * Executes a tool within the sub-agent execution boundary.
+ * Handles concurrency locking for file-mutating operations, sends progress
+ * notifications to the orchestrator, and logs activity to the message bus.
  *
- * 1. Captures tool execution into the MessageBus (Layer 1: zero-cost logs).
- * 2. Implements FileLocks for write/modify operations to prevent race conditions.
- * 3. Handles `post_message` and `read_messages` directly.
- * 4. Calls a heartbeat callback to notify the orchestrator this agent is alive.
+ * @param name - Tool function name
+ * @param args - Tool arguments object
+ * @param workspaceRoot - Primary workspace root directory
+ * @param agentId - Unique ID of the executing agent
+ * @param bus - Shared message bus instance
+ * @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
  */
-export async function executeScopedTool(name, args, workspaceRoot, agentId, bus, locks, onProgress) {
+export async function executeScopedTool(name, args, workspaceRoot, agentId, bus, locks, onProgress, options) {
     // Update heartbeat so the orchestrator knows we are making progress
     onProgress();
     const timestamp = Date.now();
@@ -97,10 +124,25 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
         let lockedFile = null;
         let diffContext = null;
         if (name === 'write_file' || name === 'modify_file' || name === 'delete_file') {
-            lockedFile = args.filePath;
-            if (lockedFile) {
-                debugLog(`Agent "${agentId}" requesting lock for "${lockedFile}" (tool: ${name})`);
-                onProgress(`waiting for lock on ${lockedFile.split('/').pop()}...`);
+            const rawPath = args.filePath;
+            if (rawPath) {
+                lockedFile = resolveCanonicalLockPath(workspaceRoot, rawPath, options);
+                debugLog(`Agent "${agentId}" requesting lock for "${lockedFile}" (raw: "${rawPath}", tool: ${name})`);
+                onProgress(`waiting for lock on ${path.basename(lockedFile)}...`);
+                const lockRes = await locks.acquire(lockedFile, agentId);
+                onProgress(`acquired lock, executing...`);
+                diffContext = lockRes.previousDiff;
+                if (lockRes.forceReleased) {
+                    debugLog(`Agent "${agentId}" got forced lock on "${lockedFile}" (previous owner stalled)`);
+                }
+            }
+        }
+        else if (name === 'rename_file') {
+            const rawPath = args.sourcePath;
+            if (rawPath) {
+                lockedFile = resolveCanonicalLockPath(workspaceRoot, rawPath, options);
+                debugLog(`Agent "${agentId}" requesting lock for "${lockedFile}" (raw: "${rawPath}", tool: ${name})`);
+                onProgress(`waiting for lock on ${path.basename(lockedFile)}...`);
                 const lockRes = await locks.acquire(lockedFile, agentId);
                 onProgress(`acquired lock, executing...`);
                 diffContext = lockRes.previousDiff;