imcodes 2026.4.1422-dev.1406 → 2026.4.1427-dev.1416

package/dist/src/daemon/command-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-handler.d.ts","sourceRoot":"","sources":["../../../src/daemon/command-handler.ts"],"names":[],"mappings":"AAQA,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEpG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAoBnD,OAAO,EAAsE,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAoO3H,wBAAsB,yBAAyB,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBtF;AAwFD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,SAAS,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzE,uEAAuE;IACvE,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAcD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAoCxD;AAgHD,wGAAwG;AACxG,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAEzD;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAmM3E;AA+7BD,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAE7F;AAED,yFAAyF;AACzF,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,OAAO,CAStF;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,CAStF;AA4uBD,wBAAgB,qCAAqC,CAAC,IAAI,2CAAgB,4CAEzE;AA+hBD,wBAAgB,0BAA0B,IAAI,IAAI,CASjD;AA6PD,KAAK,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAEzD,iFAAiF;AACjF,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAa3E;AAED,gEAAgE;AAChE,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAI5E;AAED,wCAAwC;AACxC,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAEtE;AAED,uDAAuD;AACvD,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAEhL"}
+{"version":3,"file":"command-handler.d.ts","sourceRoot":"","sources":["../../../src/daemon/command-handler.ts"],"names":[],"mappings":"AAQA,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEpG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAqBnD,OAAO,EAAsE,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAoO3H,wBAAsB,yBAAyB,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBtF;AAwFD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,SAAS,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzE,uEAAuE;IACvE,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAcD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAoCxD;AAgHD,wGAAwG;AACxG,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAEzD;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAsP3E;AA+7BD,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAE7F;AAED,yFAAyF;AACzF,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,OAAO,CAStF;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,CAStF;AA4uBD,wBAAgB,qCAAqC,CAAC,IAAI,2CAAgB,4CAEzE;AA0tBD,wBAAgB,0BAA0B,IAAI,IAAI,CAcjD;AA2QD,KAAK,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAEzD,iFAAiF;AACjF,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAa3E;AAED,gEAAgE;AAChE,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAI5E;AAED,wCAAwC;AACxC,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAEtE;AAED,uDAAuD;AACvD,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAEhL"}

package/dist/src/daemon/command-handler.js

@@ -16,10 +16,12 @@ import logger from '../util/logger.js';
 import { homedir } from 'os';
 import { readdir as fsReaddir, realpath as fsRealpath, readFile as fsReadFileRaw, stat as fsStat, writeFile as fsWriteFile } from 'node:fs/promises';
 import * as nodePath from 'node:path';
-import { exec as execCb } from 'node:child_process';
+import { exec as execCb, execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
 const execAsync = promisify(execCb);
+const execFileAsync = promisify(execFileCb);
 import { startP2pRun, cancelP2pRun, getP2pRun, listP2pRuns, serializeP2pRun } from './p2p-orchestrator.js';
+import { buildSessionList } from './session-list.js';
 import { getComboRoundCount, parseModePipeline, P2P_CONFIG_MODE } from '../../shared/p2p-modes.js';
 import { CRON_MSG } from '../../shared/cron-types.js';
 import { executeCronJob } from './cron-executor.js';
@@ -184,7 +186,6 @@ import { resolveContextWindow } from '../util/model-context.js';
 import { QWEN_MODEL_IDS } from '../../shared/qwen-models.js';
 import { getQwenRuntimeConfig } from '../agent/qwen-runtime-config.js';
 import { getQwenDisplayMetadata } from '../agent/provider-display.js';
-import { buildSessionList } from './session-list.js';
 import { getQwenOAuthQuotaUsageLabel, recordQwenOAuthRequest } from '../agent/provider-quota.js';
 import { listProviderSessions as listProviderSessionsImpl } from './provider-sessions.js';
 function describeTransportSendError(err) {
@@ -574,12 +575,66 @@ export function handleWebCommand(msg, serverLink) {
             break;
         case 'subsession.rename': {
             const sName = cmd.sessionName;
-            const label = cmd.label;
+            const label = cmd.label === null
+                ? null
+                : (typeof cmd.label === 'string' ? cmd.label : undefined);
             if (sName && label !== undefined) {
                 const record = getSession(sName);
                 if (record) {
-                    upsertSession({ ...record, label, updatedAt: Date.now() });
+                    const nextLabel = label ?? undefined;
+                    upsertSession({ ...record, label: nextLabel, updatedAt: Date.now() });
                     logger.info({ sessionName: sName, label }, 'subsession.rename: label updated');
+                    const id = sName.replace(/^deck_sub_/, '');
+                    void buildSubSessionSync(id, { label: nextLabel }).then((payload) => {
+                        try {
+                            serverLink.send(payload);
+                        }
+                        catch {
+                            // not connected
+                        }
+                    });
+                }
+            }
+            break;
+        }
+        case 'session.rename': {
+            const sessionName = cmd.sessionName;
+            const projectName = typeof cmd.projectName === 'string' ? cmd.projectName.trim() : '';
+            if (sessionName && projectName) {
+                const record = getSession(sessionName);
+                if (record) {
+                    upsertSession({ ...record, projectName, updatedAt: Date.now() });
+                    logger.info({ sessionName, projectName }, 'session.rename: project name updated');
+                    void buildSessionList().then((sessions) => {
+                        try {
+                            serverLink.send({ type: 'session_list', daemonVersion: serverLink.daemonVersion, sessions });
+                        }
+                        catch {
+                            // not connected
+                        }
+                    });
+                }
+            }
+            break;
+        }
+        case 'session.relabel': {
+            const sessionName = cmd.sessionName;
+            const label = cmd.label === null
+                ? null
+                : (typeof cmd.label === 'string' ? cmd.label : undefined);
+            if (sessionName && label !== undefined) {
+                const record = getSession(sessionName);
+                if (record) {
+                    upsertSession({ ...record, label: label ?? undefined, updatedAt: Date.now() });
+                    logger.info({ sessionName, label }, 'session.relabel: label updated');
+                    void buildSessionList().then((sessions) => {
+                        try {
+                            serverLink.send({ type: 'session_list', daemonVersion: serverLink.daemonVersion, sessions });
+                        }
+                        catch {
+                            // not connected
+                        }
+                    });
                 }
             }
             break;
@@ -2664,7 +2719,9 @@ async function handleFsListInner(resolved, rawPath, requestId, includeFiles, inc
 const FS_READ_SIZE_LIMIT = 512 * 1024; // 512 KB
 const fsReadCache = new Map();
 const fsReadInflight = new Map();
+const fsReadGenerations = new Map();
 const FS_READ_CACHE_TTL_MS = 5_000;
+const REPO_CONTEXT_CACHE_TTL_MS = 5_000;
 async function loadFsReadSnapshot(realPath, fileSignature) {
     const ext = nodePath.extname(realPath).toLowerCase().slice(1);
     const IMAGE_MIME = { png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp', ico: 'image/x-icon', bmp: 'image/bmp', svg: 'image/svg+xml' };
@@ -2677,6 +2734,7 @@ async function loadFsReadSnapshot(realPath, fileSignature) {
     if (mimeType) {
         const buf = await fsReadFileRaw(realPath);
         return {
+            path: realPath,
             fileSignature,
             status: 'ok',
             content: buf.toString('base64'),
@@ -2688,6 +2746,7 @@ async function loadFsReadSnapshot(realPath, fileSignature) {
     const sample = content.slice(0, 8192);
     if (sample.includes('\0')) {
         return {
+            path: realPath,
             fileSignature,
             status: 'error',
             error: 'binary_file',
@@ -2695,6 +2754,7 @@ async function loadFsReadSnapshot(realPath, fileSignature) {
         };
     }
     return {
+        path: realPath,
         fileSignature,
         status: 'ok',
         content,
@@ -2705,18 +2765,23 @@ async function getFsReadSnapshot(realPath, fileSignature) {
     if (cached && cached.expiresAt > Date.now() && cached.value.fileSignature === fileSignature) {
         return cached.value;
     }
-    const inflight = fsReadInflight.get(realPath);
+    const generation = getResourceGeneration(fsReadGenerations, realPath);
+    const inflightKey = `${realPath}::${fileSignature}::${generation}`;
+    const inflight = fsReadInflight.get(inflightKey);
     if (inflight)
         return await inflight;
     const promise = loadFsReadSnapshot(realPath, fileSignature)
-        .then((value) => {
-        fsReadCache.set(realPath, { value, expiresAt: Date.now() + FS_READ_CACHE_TTL_MS });
+        .then(async (value) => {
+        const currentSignature = await safeStatSignature(realPath);
+        if (getResourceGeneration(fsReadGenerations, realPath) === generation && currentSignature === value.fileSignature) {
+            fsReadCache.set(realPath, { value, expiresAt: Date.now() + FS_READ_CACHE_TTL_MS });
+        }
         return value;
     })
         .finally(() => {
-        fsReadInflight.delete(realPath);
+        fsReadInflight.delete(inflightKey);
     });
-    fsReadInflight.set(realPath, promise);
+    fsReadInflight.set(inflightKey, promise);
     return await promise;
 }
 async function handleFsRead(cmd, serverLink) {
@@ -2793,15 +2858,25 @@ async function handleFsRead(cmd, serverLink) {
 }
 const GIT_STATUS_CACHE_TTL_MS = 5_000;
 const GIT_DIFF_CACHE_TTL_MS = 5_000;
+const repoContextCache = new Map();
+const repoSignatureCache = new Map();
 const gitStatusCache = new Map();
 const gitStatusInflight = new Map();
 const gitNumstatCache = new Map();
 const gitNumstatInflight = new Map();
 const gitDiffCache = new Map();
 const gitDiffInflight = new Map();
+const gitRepoGenerations = new Map();
+const gitDiffGenerations = new Map();
 function normalizeFsPath(value) {
     return nodePath.resolve(value);
 }
+function getResourceGeneration(map, key) {
+    return map.get(key) ?? 0;
+}
+function bumpResourceGeneration(map, key) {
+    map.set(key, getResourceGeneration(map, key) + 1);
+}
 function isPathInside(root, candidate) {
     const normalizedRoot = normalizeFsPath(root);
     const normalizedCandidate = normalizeFsPath(candidate);
@@ -2833,56 +2908,126 @@ async function resolveGitDir(dotGitPath, repoRoot) {
         return null;
     }
 }
-async function findRepoRoot(startPath) {
+async function findRepoContextBase(startPath) {
     let current = normalizeFsPath(startPath);
+    const traversed = [];
+    const now = Date.now();
     while (true) {
+        const cached = repoContextCache.get(current);
+        if (cached && cached.expiresAt > now) {
+            for (const traversedPath of traversed) {
+                repoContextCache.set(traversedPath, { expiresAt: now + REPO_CONTEXT_CACHE_TTL_MS, value: cached.value });
+            }
+            return cached.value;
+        }
+        traversed.push(current);
         const dotGit = nodePath.join(current, '.git');
         const gitDir = await resolveGitDir(dotGit, current);
-        if (gitDir)
-            return { repoRoot: current, gitDir };
+        if (gitDir) {
+            const value = { repoRoot: current, gitDir };
+            for (const traversedPath of traversed) {
+                repoContextCache.set(traversedPath, { expiresAt: Date.now() + REPO_CONTEXT_CACHE_TTL_MS, value });
+            }
+            return value;
+        }
         const parent = nodePath.dirname(current);
         if (parent === current)
             break;
         current = parent;
     }
+    for (const traversedPath of traversed) {
+        repoContextCache.set(traversedPath, { expiresAt: Date.now() + REPO_CONTEXT_CACHE_TTL_MS, value: null });
+    }
     return null;
 }
-async function buildRepoSignature(gitDir) {
-    const indexSig = await safeStatSignature(nodePath.join(gitDir, 'index'));
+async function buildRepoSignatureState(gitDir, indexSig, headSig) {
+    const resolvedIndexSig = indexSig ?? await safeStatSignature(nodePath.join(gitDir, 'index'));
     const headPath = nodePath.join(gitDir, 'HEAD');
-    const headSig = await safeStatSignature(headPath);
+    const resolvedHeadSig = headSig ?? await safeStatSignature(headPath);
+    let refPath = null;
     let refSig = 'none';
     try {
         const headRaw = await fsReadFileRaw(headPath, 'utf8');
         const match = headRaw.match(/^ref:\s*(.+)\s*$/m);
         if (match?.[1]) {
-            refSig = await safeStatSignature(nodePath.join(gitDir, match[1].trim()));
+            refPath = match[1].trim();
+            refSig = await safeStatSignature(nodePath.join(gitDir, refPath));
         }
     }
     catch {
         refSig = 'missing';
     }
-    return `${indexSig}|${headSig}|${refSig}`;
+    return {
+        repoSignature: `${resolvedIndexSig}|${resolvedHeadSig}|${refSig}`,
+        indexSig: resolvedIndexSig,
+        headSig: resolvedHeadSig,
+        refPath,
+        refSig,
+    };
+}
+async function getRepoSignature(repoRoot, gitDir) {
+    const indexSig = await safeStatSignature(nodePath.join(gitDir, 'index'));
+    const headPath = nodePath.join(gitDir, 'HEAD');
+    const headSig = await safeStatSignature(headPath);
+    const cached = repoSignatureCache.get(repoRoot);
+    if (cached && cached.indexSig === indexSig && cached.headSig === headSig) {
+        if (!cached.refPath || await safeStatSignature(nodePath.join(gitDir, cached.refPath)) === cached.refSig) {
+            return cached.repoSignature;
+        }
+    }
+    const next = await buildRepoSignatureState(gitDir, indexSig, headSig);
+    repoSignatureCache.set(repoRoot, next);
+    return next.repoSignature;
 }
 async function resolveRepoContext(startPath) {
-    const repo = await findRepoRoot(startPath);
+    const repo = await findRepoContextBase(startPath);
     if (!repo)
         return null;
     return {
         repoRoot: repo.repoRoot,
         gitDir: repo.gitDir,
-        repoSignature: await buildRepoSignature(repo.gitDir),
+        repoSignature: await getRepoSignature(repo.repoRoot, repo.gitDir),
     };
 }
+function decodeGitPath(rawPath) {
+    return rawPath.replace(/\\([\\\"abfnrtv])/g, (_match, escaped) => {
+        switch (escaped) {
+            case 'a': return '\u0007';
+            case 'b': return '\b';
+            case 'f': return '\f';
+            case 'n': return '\n';
+            case 'r': return '\r';
+            case 't': return '\t';
+            case 'v': return '\v';
+            case '\\': return '\\';
+            case '"': return '"';
+            default: return escaped;
+        }
+    }).replace(/\\([0-7]{1,3})/g, (_match, octal) => String.fromCharCode(parseInt(octal, 8)));
+}
+function parseZRecords(stdout) {
+    return stdout.split('\0').filter((entry) => entry.length > 0);
+}
+function normalizeRepoRelativePath(repoRoot, relativePath) {
+    return nodePath.join(repoRoot, decodeGitPath(relativePath));
+}
 async function loadRepoGitStatusSnapshot(repoRoot, repoSignature) {
-    const { stdout } = await execAsync('git status --porcelain -u', { cwd: repoRoot, timeout: 5000 });
+    const { stdout } = await execAsync('git status --porcelain=v1 -z -u', { cwd: repoRoot, timeout: 5000, encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
     const files = [];
-    for (const line of stdout.split('\n')) {
-        if (!line.trim())
-            continue;
-        const code = line.slice(0, 2).trim();
-        const filePath = line.slice(3).trim().replace(/^"(.*)"$/, '$1');
-        files.push({ path: nodePath.join(repoRoot, filePath), code });
+    const records = parseZRecords(stdout);
+    for (let idx = 0; idx < records.length; idx++) {
+        const record = records[idx];
+        const code = record.slice(0, 2).trim();
+        const firstPath = record.slice(3);
+        let logicalPath = firstPath;
+        if (code.startsWith('R') || code.startsWith('C')) {
+            const renamedTo = records[idx + 1];
+            if (renamedTo) {
+                logicalPath = renamedTo;
+                idx += 1;
+            }
+        }
+        files.push({ path: normalizeRepoRelativePath(repoRoot, logicalPath), code });
     }
     return { repoRoot, repoSignature, files };
 }
@@ -2894,41 +3039,60 @@ async function getRepoGitStatusSnapshot(startPath) {
     if (cached && cached.expiresAt > Date.now() && cached.value.repoSignature === context.repoSignature) {
         return cached.value;
     }
-    const inflight = gitStatusInflight.get(context.repoRoot);
+    const generation = getResourceGeneration(gitRepoGenerations, context.repoRoot);
+    const inflightKey = `${context.repoRoot}::${context.repoSignature}::${generation}`;
+    const inflight = gitStatusInflight.get(inflightKey);
     if (inflight)
         return await inflight;
     const promise = loadRepoGitStatusSnapshot(context.repoRoot, context.repoSignature)
-        .then((value) => {
-        gitStatusCache.set(context.repoRoot, { value, expiresAt: Date.now() + GIT_STATUS_CACHE_TTL_MS });
+        .then(async (value) => {
+        const currentSignature = await getRepoSignature(context.repoRoot, context.gitDir);
+        if (getResourceGeneration(gitRepoGenerations, context.repoRoot) === generation && currentSignature === value.repoSignature) {
+            gitStatusCache.set(context.repoRoot, { value, expiresAt: Date.now() + GIT_STATUS_CACHE_TTL_MS });
+        }
         return value;
     })
         .finally(() => {
-        gitStatusInflight.delete(context.repoRoot);
+        gitStatusInflight.delete(inflightKey);
     });
-    gitStatusInflight.set(context.repoRoot, promise);
+    gitStatusInflight.set(inflightKey, promise);
     return await promise;
 }
 async function loadRepoGitNumstatSnapshot(repoRoot, repoSignature) {
     let stdout = '';
     try {
-        ({ stdout } = await execAsync('git diff --numstat HEAD', { cwd: repoRoot, timeout: 5000 }));
+        ({ stdout } = await execAsync('git diff --numstat -z HEAD', { cwd: repoRoot, timeout: 5000, encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 }));
     }
     catch {
         try {
-            ({ stdout } = await execAsync('git diff --numstat', { cwd: repoRoot, timeout: 5000 }));
+            ({ stdout } = await execAsync('git diff --numstat -z', { cwd: repoRoot, timeout: 5000, encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 }));
         }
         catch {
             stdout = '';
         }
     }
     const stats = new Map();
-    for (const line of stdout.split('\n')) {
-        const match = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
-        if (!match)
+    const records = parseZRecords(stdout);
+    for (let idx = 0; idx < records.length; idx++) {
+        const header = records[idx];
+        const firstTab = header.indexOf('\t');
+        const secondTab = firstTab >= 0 ? header.indexOf('\t', firstTab + 1) : -1;
+        if (firstTab < 0 || secondTab < 0)
             continue;
-        const additions = match[1] === '-' ? undefined : parseInt(match[1], 10);
-        const deletions = match[2] === '-' ? undefined : parseInt(match[2], 10);
-        stats.set(nodePath.join(repoRoot, match[3].trim()), { additions, deletions });
+        const additionsRaw = header.slice(0, firstTab);
+        const deletionsRaw = header.slice(firstTab + 1, secondTab);
+        const pathRaw = header.slice(secondTab + 1);
+        const additions = additionsRaw === '-' ? undefined : parseInt(additionsRaw, 10);
+        const deletions = deletionsRaw === '-' ? undefined : parseInt(deletionsRaw, 10);
+        let logicalPath = pathRaw;
+        if (pathRaw === '') {
+            const renamedTo = records[idx + 2];
+            if (!renamedTo)
+                continue;
+            logicalPath = renamedTo;
+            idx += 2;
+        }
+        stats.set(normalizeRepoRelativePath(repoRoot, logicalPath), { additions, deletions });
     }
     return { repoRoot, repoSignature, stats };
 }
@@ -2940,89 +3104,163 @@ async function getRepoGitNumstatSnapshot(startPath) {
     if (cached && cached.expiresAt > Date.now() && cached.value.repoSignature === context.repoSignature) {
         return cached.value;
     }
-    const inflight = gitNumstatInflight.get(context.repoRoot);
+    const generation = getResourceGeneration(gitRepoGenerations, context.repoRoot);
+    const inflightKey = `${context.repoRoot}::${context.repoSignature}::${generation}`;
+    const inflight = gitNumstatInflight.get(inflightKey);
     if (inflight)
         return await inflight;
     const promise = loadRepoGitNumstatSnapshot(context.repoRoot, context.repoSignature)
-        .then((value) => {
-        gitNumstatCache.set(context.repoRoot, { value, expiresAt: Date.now() + GIT_STATUS_CACHE_TTL_MS });
+        .then(async (value) => {
+        const currentSignature = await getRepoSignature(context.repoRoot, context.gitDir);
+        if (getResourceGeneration(gitRepoGenerations, context.repoRoot) === generation && currentSignature === value.repoSignature) {
+            gitNumstatCache.set(context.repoRoot, { value, expiresAt: Date.now() + GIT_STATUS_CACHE_TTL_MS });
+        }
         return value;
     })
         .finally(() => {
-        gitNumstatInflight.delete(context.repoRoot);
+        gitNumstatInflight.delete(inflightKey);
     });
-    gitNumstatInflight.set(context.repoRoot, promise);
+    gitNumstatInflight.set(inflightKey, promise);
     return await promise;
 }
-async function loadFileGitDiffSnapshot(realPath, repoRoot, repoSignature, fileSignature) {
+async function loadFileGitDiffSnapshot(logicalPath, repoRoot, repoSignature, fileSignature) {
     let diff = '';
+    const repoRelativePath = nodePath.relative(repoRoot, logicalPath).split(nodePath.sep).join('/');
     try {
-        const { stdout } = await execAsync(`git diff HEAD -- ${JSON.stringify(realPath)}`, { cwd: repoRoot, timeout: 5000 });
+        const { stdout } = await execFileAsync('git', ['diff', 'HEAD', '--', repoRelativePath], { cwd: repoRoot, timeout: 5000, encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
         diff = stdout;
     }
     catch { /* ignore */ }
     if (!diff) {
         try {
-            const { stdout } = await execAsync(`git diff -- ${JSON.stringify(realPath)}`, { cwd: repoRoot, timeout: 5000 });
+            const { stdout } = await execFileAsync('git', ['diff', '--', repoRelativePath], { cwd: repoRoot, timeout: 5000, encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
             diff = stdout;
         }
         catch { /* ignore */ }
     }
-    return { repoRoot, repoSignature, fileSignature, diff };
+    return { logicalPath, repoRoot, repoSignature, fileSignature, diff };
 }
-async function getFileGitDiffSnapshot(realPath) {
-    const context = await resolveRepoContext(nodePath.dirname(realPath));
+async function getFileGitDiffSnapshot(logicalPath) {
+    const context = await resolveRepoContext(nodePath.dirname(logicalPath));
     if (!context)
         return null;
-    const fileSignature = await safeStatSignature(realPath);
-    const cached = gitDiffCache.get(realPath);
+    const fileSignature = await safeStatSignature(logicalPath);
+    const cached = gitDiffCache.get(logicalPath);
     if (cached
         && cached.expiresAt > Date.now()
         && cached.value.repoSignature === context.repoSignature
         && cached.value.fileSignature === fileSignature) {
         return cached.value;
     }
-    const inflight = gitDiffInflight.get(realPath);
+    const generation = getResourceGeneration(gitDiffGenerations, logicalPath);
+    const inflightKey = `${logicalPath}::${context.repoSignature}::${fileSignature}::${generation}`;
+    const inflight = gitDiffInflight.get(inflightKey);
     if (inflight)
         return await inflight;
-    const promise = loadFileGitDiffSnapshot(realPath, context.repoRoot, context.repoSignature, fileSignature)
-        .then((value) => {
-        gitDiffCache.set(realPath, { value, expiresAt: Date.now() + GIT_DIFF_CACHE_TTL_MS });
+    const promise = loadFileGitDiffSnapshot(logicalPath, context.repoRoot, context.repoSignature, fileSignature)
+        .then(async (value) => {
+        const currentContext = await resolveRepoContext(nodePath.dirname(logicalPath));
+        const currentFileSignature = await safeStatSignature(logicalPath);
+        if (getResourceGeneration(gitDiffGenerations, logicalPath) === generation
+            && currentContext
+            && currentContext.repoSignature === value.repoSignature
+            && currentFileSignature === value.fileSignature) {
+            gitDiffCache.set(logicalPath, { value, expiresAt: Date.now() + GIT_DIFF_CACHE_TTL_MS });
+        }
         return value;
     })
         .finally(() => {
-        gitDiffInflight.delete(realPath);
+        gitDiffInflight.delete(inflightKey);
     });
-    gitDiffInflight.set(realPath, promise);
+    gitDiffInflight.set(inflightKey, promise);
     return await promise;
 }
-function filterRepoFilesForPath(files, requestedPath) {
-    return files.filter((file) => isPathInside(requestedPath, file.path));
+function collectAffectedRepoRoots(targetPath) {
+    const affected = new Set();
+    for (const key of gitStatusCache.keys()) {
+        if (isPathInside(key, targetPath))
+            affected.add(key);
+    }
+    for (const key of gitNumstatCache.keys()) {
+        if (isPathInside(key, targetPath))
+            affected.add(key);
+    }
+    for (const key of gitStatusInflight.keys()) {
+        const repoRoot = key.split('::')[0] ?? '';
+        if (repoRoot && isPathInside(repoRoot, targetPath))
+            affected.add(repoRoot);
+    }
+    for (const key of gitNumstatInflight.keys()) {
+        const repoRoot = key.split('::')[0] ?? '';
+        if (repoRoot && isPathInside(repoRoot, targetPath))
+            affected.add(repoRoot);
+    }
+    for (const entry of repoContextCache.values()) {
+        const repoRoot = entry.value?.repoRoot;
+        if (repoRoot && isPathInside(repoRoot, targetPath))
+            affected.add(repoRoot);
+    }
+    return affected;
 }
 function invalidateGitCachesForPath(targetPath) {
     const normalized = normalizeFsPath(targetPath);
+    bumpResourceGeneration(fsReadGenerations, normalized);
+    bumpResourceGeneration(gitDiffGenerations, normalized);
+    for (const repoRoot of collectAffectedRepoRoots(normalized)) {
+        bumpResourceGeneration(gitRepoGenerations, repoRoot);
+    }
     fsReadCache.delete(normalized);
-    fsReadInflight.delete(normalized);
     gitDiffCache.delete(normalized);
-    gitDiffInflight.delete(normalized);
+    for (const key of fsReadInflight.keys()) {
+        if (key.startsWith(`${normalized}::`))
+            fsReadInflight.delete(key);
+    }
+    for (const key of gitDiffInflight.keys()) {
+        if (key.startsWith(`${normalized}::`))
+            gitDiffInflight.delete(key);
+    }
     for (const key of gitStatusCache.keys()) {
         if (isPathInside(key, normalized))
             gitStatusCache.delete(key);
+        if (isPathInside(key, normalized))
+            repoSignatureCache.delete(key);
+    }
+    for (const key of repoContextCache.keys()) {
+        if (isPathInside(key, normalized))
+            repoContextCache.delete(key);
     }
     for (const key of gitNumstatCache.keys()) {
         if (isPathInside(key, normalized))
             gitNumstatCache.delete(key);
+        if (isPathInside(key, normalized))
+            repoSignatureCache.delete(key);
+    }
+    for (const key of gitStatusInflight.keys()) {
+        if (isPathInside(key.split('::')[0] ?? '', normalized))
+            gitStatusInflight.delete(key);
+    }
+    for (const key of gitNumstatInflight.keys()) {
+        if (isPathInside(key.split('::')[0] ?? '', normalized))
+            gitNumstatInflight.delete(key);
     }
 }
 export function __resetFsGitCachesForTests() {
     fsReadCache.clear();
     fsReadInflight.clear();
+    fsReadGenerations.clear();
+    repoContextCache.clear();
+    repoSignatureCache.clear();
     gitStatusCache.clear();
     gitStatusInflight.clear();
     gitNumstatCache.clear();
     gitNumstatInflight.clear();
     gitDiffCache.clear();
     gitDiffInflight.clear();
+    gitRepoGenerations.clear();
+    gitDiffGenerations.clear();
+}
+function filterRepoFilesForPath(files, requestedPath) {
+    return files.filter((file) => isPathInside(requestedPath, file.path));
 }
 /** fs.git_status — return git modified file list for a directory */
 async function handleFsGitStatus(cmd, serverLink) {
@@ -3075,8 +3313,20 @@ async function handleFsGitDiff(cmd, serverLink) {
     const expanded = rawPath.startsWith('~') ? rawPath.replace(/^~/, homedir()) : rawPath;
     const resolved = nodePath.resolve(expanded);
     try {
-        const real = await fsRealpath(resolved);
-        const allowed = isPathAllowed(real);
+        let allowedProbe = resolved;
+        while (true) {
+            try {
+                allowedProbe = await fsRealpath(allowedProbe);
+                break;
+            }
+            catch {
+                const parent = nodePath.dirname(allowedProbe);
+                if (parent === allowedProbe)
+                    throw new Error(`ENOENT: no such file or directory, realpath '${resolved}'`);
+                allowedProbe = parent;
+            }
+        }
+        const allowed = isPathAllowed(allowedProbe);
         if (!allowed) {
             try {
                 serverLink.send({ type: 'fs.git_diff_response', requestId, path: rawPath, status: 'error', error: 'forbidden_path' });
@@ -3084,11 +3334,11 @@ async function handleFsGitDiff(cmd, serverLink) {
             catch { /* ignore */ }
             return;
         }
-        const snapshot = await getFileGitDiffSnapshot(real);
+        const snapshot = await getFileGitDiffSnapshot(resolved);
         const diff = snapshot?.diff ?? '';
         // Untracked files: no diff (nothing meaningful to compare against)
         try {
-            serverLink.send({ type: 'fs.git_diff_response', requestId, path: rawPath, resolvedPath: real, status: 'ok', diff });
+            serverLink.send({ type: 'fs.git_diff_response', requestId, path: rawPath, resolvedPath: resolved, status: 'ok', diff });
         }
         catch { /* ignore */ }
     }