mixdog 0.9.9 → 0.9.11

package/src/runtime/agent/orchestrator/tools/builtin/search-tool.mjs

@@ -3,6 +3,7 @@ import { isAbsolute, resolve } from 'path';
 import { trueCasePath } from './path-utils.mjs';
 import {
     canonicalizeGlobSlashes,
+    coerceReadFamilyPathArg,
     coerceShapeFlex,
     extractGlobBaseDirectory,
     hasGlobMagic,
@@ -17,6 +18,7 @@ import {
     _suggestIndexedPaths,
     basePathDiagnostic,
     buildNotFoundHint,
+    tryReadFamilyEnoentRedirect,
     isUncOrSmbPath,
     relativePathPrefix,
     relativeSearchResultPath,
@@ -186,7 +188,179 @@ function parseGrepCountLine(line) {
     return { path, count };
 }
 
-function formatGrepOutput({ windowed, totalWindowed, totalKnown, headLimit, offset, outputMode, patterns: _patterns, beforeN, afterN, contextN, searchPath, grepResolvedPath: _grepResolvedPath, workDir, globPatterns: _globPatterns, fileType: _fileType, filenameOmitted = false, prefix = '', broadAdvisory: _broadAdvisory = true }) {
+const GREP_RESULT_LINE_SKIP = /^\[(?:Showing|total|pattern set|capped|warning|redirected|regex parse)/;
+const GREP_CHUNK_AGGREGATE_FLOOR = 200;
+const GREP_CHUNK_AGGREGATE_DEFAULT = 800;
+const GREP_CHUNK_AGGREGATE_MAX = 4000;
+
+function chunkPatternList(patterns, cap) {
+    const out = [];
+    for (let i = 0; i < patterns.length; i += cap) out.push(patterns.slice(i, i + cap));
+    return out;
+}
+
+function computeGrepChunkAggregateBudget(offset, headLimit, headLimitCoerced) {
+    if (headLimitCoerced === 0 && headLimit === Infinity) return GREP_CHUNK_AGGREGATE_MAX;
+    if (headLimit === Infinity) return GREP_CHUNK_AGGREGATE_DEFAULT;
+    const need = offset + headLimit;
+    return Math.min(GREP_CHUNK_AGGREGATE_MAX, Math.max(GREP_CHUNK_AGGREGATE_FLOOR, need * 2));
+}
+
+function compareGrepLinesByPathLine(a, b) {
+    const pa = splitGrepLinePrefix(a);
+    const pb = splitGrepLinePrefix(b);
+    if (!pa && !pb) return String(a).localeCompare(String(b));
+    if (!pa) return 1;
+    if (!pb) return -1;
+    const byPath = pa.path.localeCompare(pb.path);
+    if (byPath !== 0) return byPath;
+    return pa.lineNo - pb.lineNo;
+}
+
+function deriveGrepCountLinesFromMatchContent(lines) {
+    const byPath = new Map();
+    for (const line of lines) {
+        const split = splitGrepLinePrefix(line);
+        if (!split || split.delimiter !== ':') continue;
+        if (!byPath.has(split.path)) byPath.set(split.path, new Set());
+        byPath.get(split.path).add(split.lineNo);
+    }
+    return [...byPath.entries()]
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([path, lineNos]) => `${path}:${lineNos.size}`);
+}
+
+function isGrepMatchLine(line) {
+    const split = splitGrepLinePrefix(line);
+    return !!(split && split.delimiter === ':');
+}
+
+function grepMatchAnchorKey(line) {
+    const split = splitGrepLinePrefix(line);
+    if (!split || split.delimiter !== ':') return '';
+    return `${split.path}\0${split.lineNo}`;
+}
+
+function parseGrepContextBlocksInSegment(segmentLines) {
+    const blocks = [];
+    let pending = [];
+    let i = 0;
+    while (i < segmentLines.length) {
+        const line = segmentLines[i];
+        if (isGrepMatchLine(line)) {
+            const blockLines = pending.concat([line]);
+            pending = [];
+            i += 1;
+            while (i < segmentLines.length) {
+                const next = segmentLines[i];
+                if (next === '--' || isGrepMatchLine(next)) break;
+                blockLines.push(next);
+                i += 1;
+            }
+            const anchor = grepMatchAnchorKey(line);
+            if (anchor) blocks.push({ anchor, lines: blockLines });
+            continue;
+        }
+        pending.push(line);
+        i += 1;
+    }
+    return blocks;
+}
+
+function compareGrepAnchorKeys(a, b) {
+    const [pa, la] = String(a || '').split('\0');
+    const [pb, lb] = String(b || '').split('\0');
+    const byPath = pa.localeCompare(pb);
+    if (byPath !== 0) return byPath;
+    return Number(la) - Number(lb);
+}
+
+function mergeGrepContextChunkLines(lines) {
+    const segments = [];
+    let current = [];
+    for (const line of lines) {
+        if (line === '--') {
+            segments.push(current);
+            current = [];
+        } else {
+            current.push(line);
+        }
+    }
+    segments.push(current);
+    const seen = new Set();
+    const blocks = [];
+    for (const segment of segments) {
+        if (!segment.length) continue;
+        for (const block of parseGrepContextBlocksInSegment(segment)) {
+            if (!block.anchor || seen.has(block.anchor)) continue;
+            seen.add(block.anchor);
+            blocks.push(block);
+        }
+    }
+    blocks.sort((a, b) => compareGrepAnchorKeys(a.anchor, b.anchor));
+    const out = [];
+    for (const block of blocks) {
+        if (out.length) out.push('--');
+        out.push(...block.lines);
+    }
+    return out;
+}
+
+function mergeGrepChunkLines(lines, { outputMode, beforeN, afterN, contextN }) {
+    const hasContext = (beforeN > 0 || afterN > 0 || contextN > 0);
+    if (outputMode === 'count') {
+        return deriveGrepCountLinesFromMatchContent(lines);
+    }
+    if (outputMode === 'files_with_matches') {
+        const seen = new Set();
+        const out = [];
+        for (const line of lines) {
+            const path = String(line || '').trim();
+            if (!path || seen.has(path)) continue;
+            seen.add(path);
+            out.push(path);
+        }
+        out.sort((a, b) => a.localeCompare(b));
+        return out;
+    }
+    if (outputMode === 'content' && hasContext) {
+        return mergeGrepContextChunkLines(lines);
+    }
+    const matches = new Map();
+    for (const line of lines) {
+        const split = splitGrepLinePrefix(line);
+        if (split && split.delimiter === ':') {
+            const key = `${split.path}\0${split.lineNo}`;
+            if (!matches.has(key)) matches.set(key, line);
+        }
+    }
+    return [...matches.values()].sort(compareGrepLinesByPathLine);
+}
+
+function extractGrepChunkResultLines(body, room = Infinity) {
+    const text = String(body || '').trim();
+    if (!text || /^Error:/i.test(text)) return { error: text || 'Error: empty grep chunk result' };
+    if (/^\(no matches\)/i.test(text)) return { lines: [], truncated: false };
+    const rawLines = text.split('\n');
+    const childShowingTruncated = rawLines.some((line) => /^\[Showing /i.test(String(line || '').trim()));
+    const lines = rawLines.filter((line) => line && !GREP_RESULT_LINE_SKIP.test(line));
+    const truncated = childShowingTruncated
+        || (Number.isFinite(room) && room >= 0 && lines.length >= room);
+    return { lines, truncated };
+}
+
+function buildGrepChunkMergePrefix(patternChunkCount, truncated, aggregateBudget, outputMode = 'content') {
+    if (patternChunkCount <= 1 && !truncated) return '';
+    const parts = [];
+    if (patternChunkCount > 1) parts.push(`pattern set split into ${patternChunkCount} chunks`);
+    if (truncated) {
+        parts.push(`chunk results truncated at aggregate budget ${aggregateBudget} lines; results are partial`);
+        if (outputMode === 'count') parts.push('counts are lower bounds (>=)');
+    }
+    return `[${parts.join('; ')}]\n`;
+}
+
+function formatGrepOutput({ windowed, totalWindowed, totalKnown, headLimit, offset, outputMode, patterns: _patterns, beforeN, afterN, contextN, searchPath, grepResolvedPath: _grepResolvedPath, workDir, globPatterns: _globPatterns, fileType: _fileType, filenameOmitted = false, prefix = '', broadAdvisory: _broadAdvisory = true, disableContentGrouping = false }) {
     const lines = headLimit === Infinity ? windowed : windowed.slice(0, headLimit);
     const normalized = lines.map((line) => relativeGrepLine(line, workDir, outputMode === 'files_with_matches', outputMode, filenameOmitted));
     const remaining = Math.max(0, totalWindowed - lines.length);
@@ -210,7 +384,7 @@ function formatGrepOutput({ windowed, totalWindowed, totalKnown, headLimit, offs
         countSummary = `\n[total ${totalMatches} match${totalMatches === 1 ? '' : 'es'} across ${fileCount} file${fileCount === 1 ? '' : 's'}]`;
     }
     const hasContext = (beforeN > 0 || afterN > 0 || contextN > 0);
-    const groupedBody = (outputMode === 'content' && !hasContext && !filenameOmitted)
+    const groupedBody = (outputMode === 'content' && !hasContext && !filenameOmitted && !disableContentGrouping)
         ? groupGrepContentByFile(normalized)
         : normalized.join('\n');
     const body = groupedBody + truncated + countSummary;
@@ -219,6 +393,7 @@ function formatGrepOutput({ windowed, totalWindowed, totalKnown, headLimit, offs
 
 export async function executeGrepTool(args, workDir, executeChildBuiltinTool, readStateScope = null, options = {}) {
     args = normalizeGrepArgs(args);
+    args.path = coerceReadFamilyPathArg(args.path, workDir);
     // Fan-out guard: batch multiple string paths sequentially, mirroring
     // code_graph files[] batching. Recursive calls pass a single string
     // path, so recursion bottoms out after one level.
@@ -280,12 +455,6 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     // \n; an explicit multiline:true from the caller still wins outright.
     const patternsWantMultiline = patterns.some((p) => /\\n/.test(p));
     const multilineMode = args.multiline === true || patternsWantMultiline;
-    if (multilineMode && patterns.length > GREP_MULTILINE_PATTERN_CAP) {
-        return `Error: multiline:true with more than ${GREP_MULTILINE_PATTERN_CAP} patterns is not allowed (got ${patterns.length}); split into separate grep calls`;
-    }
-    if (patterns.length > GREP_ARRAY_PATTERN_CAP) {
-        return `Error: pattern array exceeds the ${GREP_ARRAY_PATTERN_CAP}-pattern cap (got ${patterns.length}); split into separate grep calls`;
-    }
     // Rescue: lookaround/backreference patterns are rejected by rg's default
     // Rust regex engine ("look-around ... is not supported" / "backreferences
     // ... not supported"). rg builds compiled with the optional `pcre2`
@@ -427,6 +596,80 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     }
     if (fileTypes.length > 1) fileType = fileTypes;
     else if (fileTypes.length === 1) fileType = fileTypes[0];
+
+    const patternChunkCap = multilineMode ? GREP_MULTILINE_PATTERN_CAP : GREP_ARRAY_PATTERN_CAP;
+    if (patterns.length > patternChunkCap) {
+        const patternChunks = chunkPatternList(patterns, patternChunkCap);
+        const aggregateBudget = computeGrepChunkAggregateBudget(offset, headLimit, headLimitCoerced);
+        let truncatedAggregate = false;
+        const chunkBaseArgs = {
+            ...args,
+            offset: 0,
+            ...(outputMode === 'count' ? { output_mode: 'content' } : {}),
+        };
+        const chunkMergeOptions = { ...options, _grepChunkMerge: true };
+        const mergedRaw = [];
+        for (const chunk of patternChunks) {
+            if (mergedRaw.length >= aggregateBudget) {
+                truncatedAggregate = true;
+                break;
+            }
+            const room = aggregateBudget - mergedRaw.length;
+            const chunkBody = await executeGrepTool(
+                { ...chunkBaseArgs, pattern: chunk, head_limit: room },
+                workDir,
+                executeChildBuiltinTool,
+                readStateScope,
+                chunkMergeOptions,
+            );
+            const extracted = extractGrepChunkResultLines(chunkBody, room);
+            if (extracted.error) return extracted.error.startsWith('Error:') ? extracted.error : `Error: ${extracted.error}`;
+            const slice = extracted.lines.slice(0, room);
+            mergedRaw.push(...slice);
+            if (extracted.truncated || extracted.lines.length > room) truncatedAggregate = true;
+        }
+        const chunkPrefix = buildGrepChunkMergePrefix(
+            patternChunks.length,
+            truncatedAggregate,
+            aggregateBudget,
+            outputMode,
+        );
+        const merged = mergeGrepChunkLines(mergedRaw, {
+            outputMode,
+            beforeN,
+            afterN,
+            contextN,
+        });
+        const sliced = offset > 0 ? merged.slice(offset) : merged;
+        const limit = headLimit === Infinity ? sliced.length : headLimit;
+        const windowed = limit === Infinity ? sliced : sliced.slice(0, limit);
+        if (!windowed.length) {
+            const patternStr = patterns.length === 1 ? JSON.stringify(patterns[0]) : JSON.stringify(patterns);
+            const globStr = normalizedGlobPatterns.length > 0 ? ` glob=${JSON.stringify(normalizedGlobPatterns)}` : '';
+            return `${chunkPrefix}(no matches) pattern=${patternStr} path=${searchPath}${globStr}`;
+        }
+        return formatGrepOutput({
+            windowed,
+            totalWindowed: merged.length,
+            totalKnown: !truncatedAggregate,
+            headLimit,
+            offset,
+            outputMode,
+            patterns,
+            beforeN,
+            afterN,
+            contextN,
+            searchPath,
+            grepResolvedPath,
+            workDir,
+            globPatterns: normalizedGlobPatterns,
+            fileType,
+            filenameOmitted: false,
+            prefix: chunkPrefix,
+        });
+    }
+
+    const forceGrepFilename = !!options._grepChunkMerge;
     const cacheKey = buildGrepCacheKey({
         patterns,
         searchPath: normalizeOutputPath(grepResolvedPath),
@@ -443,6 +686,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         onlyMatching: args['-o'] === true,
         fileType,
         pcre2: pcre2Mode,
+        withFilename: forceGrepFilename,
     });
     // Single-file grep registers a whole-file read snapshot (parity with
     // apply_patch), satisfying the read-before-edit guard while keeping drift
@@ -467,12 +711,27 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     let grepStat;
     try { grepStat = statSync(grepResolvedPath); }
     catch (err) {
+        const redirected = await tryReadFamilyEnoentRedirect({
+            workDir,
+            resolvedPath: grepResolvedPath,
+            requestedPath: searchPath,
+            errCode: err?.code,
+            options,
+            rerun: (target, opts) => executeGrepTool(
+                { ...args, path: target },
+                workDir,
+                executeChildBuiltinTool,
+                readStateScope,
+                opts,
+            ),
+        });
+        if (redirected) return redirected;
         const msg = `Error: path does not exist: ${normalizeOutputPath(grepResolvedPath)} (${err?.code || 'ENOENT'})`;
         const hint = buildNotFoundHint(workDir, grepResolvedPath, 'Search', err?.code);
         if (hint) return msg + hint;
         return msg + await _suggestIndexedPaths(grepResolvedPath, executeChildBuiltinTool, workDir);
     }
-    const filenameOmitted = grepStat.isFile();
+    const filenameOmitted = forceGrepFilename ? false : grepStat.isFile();
 
     // rg builds --glob overrides rooted at its process cwd and relativizes each
     // candidate against it with a CASE-SENSITIVE prefix strip; workDir is
@@ -507,6 +766,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
             fileType,
             onlyMatching: args['-o'] === true,
             pcre2: pcre2Mode,
+            withFilename: forceGrepFilename,
         });
         let windowed;
         let totalWindowed = 0;
@@ -565,6 +825,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
             globPatterns: normalizedGlobPatterns,
             fileType,
             filenameOmitted,
+            disableContentGrouping: !!options._grepChunkMerge,
         });
         if (!body) {
             const pathInfo = grepStat.isDirectory() ? 'path exists (dir)' : 'path exists (file)';
@@ -650,6 +911,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
                         fileType,
                         onlyMatching: args['-o'] === true,
                         fixedStrings: true,
+                        withFilename: forceGrepFilename,
                     });
                     const effectiveHeadLimit = headLimit === Infinity
                         ? (outputMode === 'content' ? GREP_CONTENT_HARD_CAP : Infinity)
@@ -723,11 +985,34 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
 
 export async function executeGlobTool(args, workDir, options = {}) {
     args = normalizeGlobArgs(args);
-    args.path = Array.isArray(args.path)
-        ? args.path.map((p) => stripEmbeddedPathQuotes(normalizeInputPath(p))).filter((p) => typeof p === 'string' && p)
-        : stripEmbeddedPathQuotes(normalizeInputPath(args.path));
+    args.path = coerceReadFamilyPathArg(args.path, workDir);
+    if (Array.isArray(args.path)) {
+        const GLOB_PATH_CAP = 10;
+        const seen = new Set();
+        const list = args.path
+            .map((p) => (typeof p === 'string' ? stripEmbeddedPathQuotes(normalizeInputPath(p)).trim() : ''))
+            .filter((p) => p && !seen.has(p) && seen.add(p));
+        if (list.length > 1) {
+            const capped = list.slice(0, GLOB_PATH_CAP);
+            const parts = [];
+            for (const p of capped) {
+                let body;
+                try {
+                    body = await executeGlobTool({ ...args, path: p }, workDir, options);
+                } catch (err) {
+                    body = `Error: ${err && err.message ? err.message : err}`;
+                }
+                parts.push(`# glob ${p}\n${body}`);
+            }
+            if (list.length > GLOB_PATH_CAP) parts.push(`[capped at ${GLOB_PATH_CAP} of ${list.length} paths]`);
+            return parts.join('\n\n');
+        }
+        args.path = list[0] ?? '.';
+    } else {
+        args.path = stripEmbeddedPathQuotes(normalizeInputPath(args.path));
+    }
     if (Array.isArray(args.path) && args.path.length === 0) {
-        return 'Error: path array must contain at least one base directory';
+        args.path = '.';
     }
     args.pattern = coerceShapeFlex(args.pattern);
     const rawPattern = args.pattern;
@@ -750,12 +1035,29 @@ export async function executeGlobTool(args, workDir, options = {}) {
         }
     }
     if (patterns.length === 0) {
-        return globMissingPatternMessage();
+        patterns = ['*'];
     }
 
     const basePaths = (Array.isArray(args.path) && args.path.length > 0)
         ? args.path
         : [args.path || '.'];
+    if (!options._enoentRedirectFrom) {
+        for (const only of basePaths) {
+            const resolvedOnly = resolveSearchScope(only, workDir);
+            try { statSync(resolvedOnly); }
+            catch (err) {
+                const redirected = await tryReadFamilyEnoentRedirect({
+                    workDir,
+                    resolvedPath: resolvedOnly,
+                    requestedPath: only,
+                    errCode: err?.code,
+                    options,
+                    rerun: (target, opts) => executeGlobTool({ ...args, path: target }, workDir, opts),
+                });
+                if (redirected) return redirected;
+            }
+        }
+    }
     // A base path carrying glob magic (path:'src/**/cache/*') names a SET of
     // directories, not a literal one — resolving it literally ENOENTs. Split
     // it the way grep's path handling does: walk from the static baseDir and
@@ -854,6 +1156,22 @@ export async function executeGlobTool(args, workDir, options = {}) {
         rgArgs.push('.');
         try { statSync(rgCwd); }
         catch (err) {
+            const redirected = await tryReadFamilyEnoentRedirect({
+                workDir,
+                resolvedPath: rgCwd,
+                requestedPath: root,
+                errCode: err?.code,
+                options,
+                rerun: (target, opts) => executeGlobTool({ ...args, path: target }, workDir, opts),
+            });
+            if (redirected) {
+                return {
+                    error: null,
+                    paths: [],
+                    stdoutTruncated: false,
+                    redirected,
+                };
+            }
             const hint = buildNotFoundHint(workDir, rgCwd, 'Search', err?.code);
             return {
                 error: `path does not exist: ${normalizeOutputPath(rgCwd)} (${err?.code || 'ENOENT'})${hint}`,
@@ -884,6 +1202,7 @@ export async function executeGlobTool(args, workDir, options = {}) {
     }));
 
     outer: for (const run of groupRuns) {
+        if (run.redirected) return run.redirected;
         if (run.error) {
             rgErrors.push(run.error);
             continue;

package/src/runtime/agent/orchestrator/tools/patch/dispatch.mjs

@@ -2,7 +2,9 @@
 // verbatim from patch.mjs; native protocol, cache/snapshot side effects, and
 // output formatting are unchanged.
 
-import { readFileSync } from 'node:fs';
+import { readFileSync, lstatSync, mkdirSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { dirname as pathDirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import {
   normalizeOutputPath,
@@ -10,8 +12,18 @@ import {
   recordReadSnapshotForPath,
   clearReadSnapshotForPath,
 } from '../builtin.mjs';
+import { atomicWrite } from '../builtin/atomic-write.mjs';
+import { isSpecialFileStat } from '../builtin/device-paths.mjs';
 import { markCodeGraphDirtyPaths } from '../code-graph-state.mjs';
-import { classifyEntry, stripDiffPrefix, resolveEntryPath } from './paths.mjs';
+import {
+  classifyEntry,
+  stripDiffPrefix,
+  resolveEntryPath,
+  parsedEntryResolvedPath,
+  isResolvedPathOutsideBase,
+  countHunkChanges,
+} from './paths.mjs';
+import { applyV4AHunksToLines } from './v4a-convert.mjs';
 import {
   getNativePatchServer,
   scheduleNativePatchIdleClose,
@@ -169,3 +181,118 @@ export async function dispatchNativePatch({ entries, basePath, nativePatchStr, f
   }
   return lines.join('\n');
 }
+
+function entryPathKey(fullPath) {
+  return process.platform === 'win32' ? String(fullPath || '').toLowerCase() : String(fullPath || '');
+}
+
+function joinTextLinesForPatch(lines) {
+  const body = (lines || []).join('\n');
+  return lines?.hasFinalNewline !== false ? `${body}\n` : body;
+}
+
+function lstatRegularPatchFile(fullPath, displayPath) {
+  const st = lstatSync(fullPath);
+  if (isSpecialFileStat(st)) {
+    throw new Error(
+      `apply_patch: cannot patch special file (FIFO / character / block device / socket): ${normalizeOutputPath(displayPath)}`,
+    );
+  }
+  return st;
+}
+
+function findParsedForRow(row, parsed, basePath) {
+  const key = entryPathKey(row.fullPath);
+  for (const entry of parsed || []) {
+    if (entryPathKey(parsedEntryResolvedPath(entry, basePath)) === key) return entry;
+  }
+  return null;
+}
+
+async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope }) {
+  const kind = classifyEntry(entry);
+  const headerName = kind === 'create' ? entry.newFileName : entry.oldFileName;
+  const fullPath = resolveEntryPath(basePath, headerName);
+  const displayPath = normalizeOutputPath(stripDiffPrefix(headerName));
+  if (!isResolvedPathOutsideBase(fullPath, basePath)) {
+    throw new Error(`apply_patch: internal JS dispatch invoked for in-base path ${displayPath}`);
+  }
+
+  if (kind === 'create') {
+    const addedLines = [];
+    for (const hunk of entry.hunks || []) {
+      for (const line of hunk.lines || []) {
+        if (line.startsWith('+')) addedLines.push(line.slice(1));
+      }
+    }
+    const content = joinTextLinesForPatch(addedLines);
+    if (!dryRun) {
+      mkdirSync(pathDirname(fullPath), { recursive: true });
+      await atomicWrite(fullPath, content, { sessionId: readStateScope });
+      invalidateBuiltinResultCache([fullPath]);
+      markCodeGraphDirtyPaths([fullPath]);
+      recordReadSnapshotForPath(fullPath, readStateScope, { source: 'apply_patch_js', isPartialView: false });
+    }
+    const { added, removed } = countHunkChanges(entry.hunks);
+    return { kind, fullPath, displayPath, added, removed };
+  }
+
+  if (kind === 'delete') {
+    lstatRegularPatchFile(fullPath, displayPath);
+    if (!dryRun) {
+      await unlink(fullPath);
+      invalidateBuiltinResultCache([fullPath]);
+      markCodeGraphDirtyPaths([fullPath]);
+      clearReadSnapshotForPath(fullPath, readStateScope);
+    }
+    const { added, removed } = countHunkChanges(entry.hunks);
+    return { kind, fullPath, displayPath, added, removed };
+  }
+
+  lstatRegularPatchFile(fullPath, displayPath);
+  const raw = readFileSync(fullPath);
+  const sourceLines = splitTextLinesForPatch(raw.toString('utf8'));
+  const v4aHunks = (entry.hunks || []).map((h) => ({ lines: h.lines || [] }));
+  const updatedLines = applyV4AHunksToLines(sourceLines, v4aHunks, { fuzzy });
+  const content = joinTextLinesForPatch(updatedLines);
+  if (!dryRun) {
+    await atomicWrite(fullPath, content, { sessionId: readStateScope });
+    invalidateBuiltinResultCache([fullPath]);
+    markCodeGraphDirtyPaths([fullPath]);
+    recordReadSnapshotForPath(fullPath, readStateScope, { source: 'apply_patch_js', isPartialView: false });
+  }
+  const { added, removed } = countHunkChanges(entry.hunks);
+  return { kind, fullPath, displayPath, added, removed };
+}
+
+export async function dispatchJsPatchEntries({ rows, parsed, basePath, dryRun, fuzzy, readStateScope }) {
+  const applied = [];
+  for (const row of rows || []) {
+    const entry = findParsedForRow(row, parsed, basePath);
+    if (!entry) throw new Error(`apply_patch: missing parsed entry for ${row.displayPath}`);
+    try {
+      applied.push(await applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope }));
+    } catch (err) {
+      return `Error: ${err?.message || String(err)}`;
+    }
+  }
+  const verbLabel = dryRun ? 'Checked' : 'Applied';
+  const countLabel = (count, singular, plural = `${singular}s`) => `${count} ${count === 1 ? singular : plural}`;
+  const kindLabel = (kind) => {
+    const text = String(kind || '').trim();
+    return text ? `${text.charAt(0).toUpperCase()}${text.slice(1).toLowerCase()}` : 'Update';
+  };
+  const lines = [`${verbLabel} ${countLabel(applied.length, 'File')} (JS)${dryRun ? ' Dry Run' : ''}`];
+  for (const entry of applied) {
+    const added = entry.added || 0;
+    const removed = entry.removed || 0;
+    const parts = [];
+    if (added > 0) parts.push(`+${countLabel(added, 'Line')}`);
+    if (removed > 0) parts.push(`-${countLabel(removed, 'Line')}`);
+    const detail = parts.join(' · ');
+    lines.push(detail
+      ? `  OK ${kindLabel(entry.kind)} ${entry.displayPath} — ${detail}`
+      : `  OK ${kindLabel(entry.kind)} ${entry.displayPath}`);
+  }
+  return lines.join('\n');
+}