minovative-mind-cli 2.12.0 → 2.13.1

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]`;
     }
@@ -73,8 +79,8 @@ export function createCompactToolReference(toolName, output, args) {
     }
     const lineCount = output.split('\n').length;
     if (toolName === 'read_file') {
-        const file = args?.filePath ? `from ${args.filePath}` : 'from file';
-        return `[Read ${lineCount} lines ${file} - tool execution completed]`;
+        // Preserve full workspace_file content so the sub-agent retains source code in working memory
+        return output;
     }
     if (toolName === 'grep_search' || toolName === 'search_codebase') {
         const pattern = args?.pattern ? `for "${args.pattern}"` : '';
@@ -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/utils/fuzzyMatch.d.ts

@@ -1,53 +1,83 @@
 import { ValidationResult } from './localSyntaxValidator.js';
+/**
+ * Represents the result of a successful fuzzy match operation within a source file.
+ */
 export interface MatchResult {
+    /** The starting character byte offset of the matched region in the file content. */
     start: number;
+    /** The ending character byte offset of the matched region in the file content. */
     end: number;
+    /** The specific matching strategy that successfully resolved the snippet (e.g. 'Exact Match', 'Whitespace-Normalized Match', or Levenshtein details). */
     strategy: string;
 }
+/**
+ * Represents a discrete search-and-replace block within a multi-block patch operation.
+ */
 export interface PatchBlock {
+    /** The target search snippet to locate within the source file. */
     search: string;
+    /** The replacement content to substitute into the matched region. */
     replace: string;
 }
+/**
+ * Represents the comprehensive result of applying one or more patch blocks to a file.
+ */
 export interface PatchApplicationResult {
+    /** Indicates whether all patch blocks were successfully applied and optional syntax validation passed. */
     success: boolean;
+    /** The final transformed file content after patch application. */
     content: string;
+    /** The count of successfully applied patch blocks. */
     appliedBlocks: number;
+    /** The count of patch blocks that failed matching or application. */
     failedBlocks: number;
+    /** A collection of error or diagnostic messages encountered during patching. */
     errors: string[];
+    /** Optional syntax validation results from {@link localValidate} when syntax validation is enabled. */
     syntaxValidation?: ValidationResult;
 }
+/**
+ * Configuration options governing patch application behavior.
+ */
 export interface ApplyPatchOptions {
+    /** Whether to perform local AST-aware syntax validation on the resulting content. Defaults to false. */
     validateSyntax?: boolean;
 }
 /**
- * Trims each line, collapses multiple spaces/tabs to single space,
- * and normalizes line endings.
+ * Normalizes whitespace in a text snippet by trimming each line, collapsing internal
+ * runs of spaces and tabs into a single space, and standardizing line endings.
+ *
+ * @param text - The raw input text string to normalize.
+ * @returns The whitespace-normalized string.
  */
 export declare function normalizeWhitespace(text: string): string;
 /**
- * Returns 0-1 similarity ratio.
- * 1.0 is exact match, 0.0 is completely different.
+ * Calculates the normalized Levenshtein similarity ratio between two strings on a scale from 0.0 to 1.0.
+ *
+ * @param a - The first string to compare.
+ * @param b - The second string to compare.
+ * @returns A similarity score between 0.0 (completely dissimilar) and 1.0 (identical).
  */
 export declare function levenshteinSimilarity(a: string, b: string): number;
 /**
- * Finds the best match for `searchContent` inside `fileContent`.
- * Uses a pipeline of strategies: Exact -> Whitespace-normalized -> Levenshtein.
- * Enforces uniqueness and higher confidence thresholds for non-unique search snippets across repetitive files.
+ * Finds the best match for a `searchContent` snippet inside `fileContent` using a robust 3-tier
+ * deterministic strategy pipeline:
+ *
+ * 1. **Exact Match**: Checks for literal substring occurrence. Enforces strict uniqueness (fails if ambiguous).
+ * 2. **Whitespace-Normalized Match**: Compares line-by-line after stripping leading/trailing whitespace and collapsing interior spaces. Enforces uniqueness.
+ * 3. **Levenshtein Similarity Matching**: Evaluates sliding window similarity across file regions with adaptive confidence thresholds (0.92 for short snippets, 0.88 for longer content) and distinct region grouping to disambiguate repetitive code blocks.
+ *
+ * @param fileContent - The full content of the source file being searched.
+ * @param searchContent - The search snippet to locate within the file.
+ * @returns A {@link MatchResult} containing start/end offsets and strategy metadata, or `null` if no unique or confident match could be determined.
  */
 export declare function findBestMatch(fileContent: string, searchContent: string): MatchResult | null;
-export declare function applyMatch(fileContent: string, match: MatchResult, replaceContent: string): string;
 /**
- * Parses differential patch block string into structured PatchBlock objects.
- * Supports blocks formatted as:
- * <<<<< SEARCH
- * search content
- * =====
- * replace content
- * >>>>> REPLACE
+ * Applies a specific match result substitution to source file content.
+ *
+ * @param fileContent - The original source file content.
+ * @param match - The {@link MatchResult} specifying character offsets where the replacement occurs.
+ * @param replaceContent - The replacement string to substitute into the matched region.
+ * @returns The transformed file content string.
  */
-export declare function parsePatchBlocks(patchText: string): PatchBlock[];
-/**
- * Applies a sequence of search/replace patch blocks to file content
- * using fuzzy matching, and validates local syntax on the result.
- */
-export declare function applyPatch(fileContent: string, patchTextOrBlocks: string | PatchBlock[], filePath?: string, options?: ApplyPatchOptions): PatchApplicationResult;
+export declare function applyMatch(fileContent: string, match: MatchResult, replaceContent: string): string;