mixdog 0.9.117 → 0.9.118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.117",
+  "version": "0.9.118",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/tool-stress.mjs

@@ -11,6 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { executeBuiltinTool } from '../src/runtime/agent/orchestrator/tools/builtin.mjs';
 import { executeCodeGraphTool } from '../src/runtime/agent/orchestrator/tools/code-graph.mjs';
 import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+import { normalizeToolEnvelope } from '../src/runtime/agent/orchestrator/session/tool-envelope.mjs';
 
 const root = join(fileURLToPath(new URL('.', import.meta.url)), '..');
 const SESSIONS = 8;
@@ -30,7 +31,8 @@ function record(tool, ms, result, expectRe) {
 async function timed(tool, expectRe, fn) {
   const t0 = Date.now();
   try {
-    const out = await fn();
+    const raw = await fn();
+    const out = normalizeToolEnvelope(raw).result;
     record(tool, Date.now() - t0, out, expectRe);
     return out;
   } catch (err) {

package/src/runtime/agent/orchestrator/tools/builtin/cache-layers.mjs

@@ -357,19 +357,17 @@ export async function lstatPathsForMtime(paths, workDir, concurrency = Infinity,
     return out;
 }
 
-// Extra invalidation listeners: sibling modules with their own derived caches
-// (e.g. the broad find-enumeration cache in list-tool) register a clear
-// callback here so every write-invalidation event that drops the result/stat/
-// raw caches also drops theirs. Full clear is intentional — those entries are
-// cheap to rebuild and a path-scoped diff is not worth the coupling.
+// Extra invalidation listeners: sibling modules with derived caches receive
+// the normalized affected paths, or null for a full clear, so unrelated
+// project inventories survive writes in another temporary/project root.
 const EXTRA_INVALIDATION_LISTENERS = new Set();
 export function registerCacheInvalidationListener(fn) {
     if (typeof fn === 'function') EXTRA_INVALIDATION_LISTENERS.add(fn);
     return () => EXTRA_INVALIDATION_LISTENERS.delete(fn);
 }
-function runExtraInvalidationListeners() {
+function runExtraInvalidationListeners(affectedPaths = null) {
     for (const fn of EXTRA_INVALIDATION_LISTENERS) {
-        try { fn(); } catch { /* best-effort: one listener must not block others */ }
+        try { fn(affectedPaths); } catch { /* best-effort: one listener must not block others */ }
     }
 }
 
@@ -411,9 +409,7 @@ function cacheInvalidatePaths(paths) {
         deleteReadRangeIndexForPath(affected);
         bumpPathMutationGeneration(affected);
     }
-    // Broad enumeration entries are not path-scoped, so any partial
-    // invalidation still fully drops them (cheap to rebuild).
-    runExtraInvalidationListeners();
+    runExtraInvalidationListeners(affectedPaths);
 }
 
 export function invalidateBuiltinResultCache(paths = null) {

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

@@ -1,5 +1,5 @@
 import { readdirSync } from 'fs';
-import { basename, relative } from 'path';
+import { basename, isAbsolute, relative } from 'path';
 import {
     coerceReadFamilyPathArg,
     extractGlobBaseDirectory,
@@ -415,17 +415,52 @@ export async function executeTreeTool(args, workDir, options = {}) {
 // known-incomplete and are NEVER cached.
 const FIND_ENUM_CACHE = new Map(); // key -> { files, expiresAt, gen }
 const FIND_ENUM_INFLIGHT = new Map(); // key -> { promise, controller, subscribers }
+const FIND_TARGETED_BATCHES_BY_RUNNER = new WeakMap();
+const FIND_ENUM_ROOT_GEN = new Map();
 let FIND_ENUM_GEN = 0;
 
 // The broad enumeration is a DERIVED cache the scope/path invalidation layer
-// does not otherwise know about — a file created/renamed after a sweep would
-// stay invisible to broad find reuse for the whole TTL. Drop all entries on any
-// write-invalidation event (TTL remains the secondary bound). Full clear is
-// fine: entries are cheap to rebuild.
-registerCacheInvalidationListener(() => {
-    FIND_ENUM_GEN += 1;
-    FIND_ENUM_CACHE.clear();
-    FIND_ENUM_INFLIGHT.clear();
+// does not otherwise know about. Invalidate only inventories whose roots
+// overlap the written paths; a patch in an isolated temp root must not force
+// every active Project to rescan.
+function findEnumerationPathsOverlap(left, right) {
+    const contains = (base, target) => {
+        const rel = relative(base, target);
+        return rel === '' || (!isAbsolute(rel) && !/^\.\.(?:[\\/]|$)/.test(rel));
+    };
+    return contains(left, right) || contains(right, left);
+}
+function findEnumerationRootFromKey(key) {
+    return String(key).split('\u0000', 1)[0];
+}
+function findEnumerationRootGeneration(root) {
+    return FIND_ENUM_ROOT_GEN.get(root) || 0;
+}
+registerCacheInvalidationListener((affectedPaths) => {
+    if (!Array.isArray(affectedPaths) || affectedPaths.length === 0) {
+        FIND_ENUM_GEN += 1;
+        FIND_ENUM_ROOT_GEN.clear();
+        FIND_ENUM_CACHE.clear();
+        FIND_ENUM_INFLIGHT.clear();
+        return;
+    }
+    const keys = new Set([...FIND_ENUM_CACHE.keys(), ...FIND_ENUM_INFLIGHT.keys()]);
+    const affectedRoots = new Set();
+    for (const key of keys) {
+        const root = findEnumerationRootFromKey(key);
+        if (affectedPaths.some((affected) => findEnumerationPathsOverlap(root, affected))) {
+            affectedRoots.add(root);
+        }
+    }
+    for (const root of affectedRoots) {
+        FIND_ENUM_ROOT_GEN.set(root, findEnumerationRootGeneration(root) + 1);
+        for (const key of [...FIND_ENUM_CACHE.keys()]) {
+            if (findEnumerationRootFromKey(key) === root) FIND_ENUM_CACHE.delete(key);
+        }
+        for (const key of [...FIND_ENUM_INFLIGHT.keys()]) {
+            if (findEnumerationRootFromKey(key) === root) FIND_ENUM_INFLIGHT.delete(key);
+        }
+    }
 });
 
 function findEnumTtlMs() {
@@ -503,9 +538,10 @@ function subscribeToFindEnumeration(key, entry, signal = null) {
 async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMode, rgArgs, cwd, runRgImpl = runRg, bestEffort = false, signal = null }) {
     const ttl = findEnumTtlMs();
     const key = findEnumKey({ root, hidden, depth, includeNoise, ignoreMode });
+    const rootGen = findEnumerationRootGeneration(root);
     if (ttl > 0) {
         const hit = FIND_ENUM_CACHE.get(key);
-        if (hit && hit.gen === FIND_ENUM_GEN && hit.expiresAt > Date.now()) {
+        if (hit && hit.gen === FIND_ENUM_GEN && hit.rootGen === rootGen && hit.expiresAt > Date.now()) {
             return { files: hit.files, truncated: false, partial: false };
         }
         if (hit) FIND_ENUM_CACHE.delete(key); // expired
@@ -525,6 +561,7 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMo
         return { files: [], truncated: false, partial: true };
     }
     const genAtStart = FIND_ENUM_GEN;
+    const rootGenAtStart = rootGen;
     const controller = new AbortController();
     const entry = { promise: null, controller, subscribers: new Set() };
     entry.promise = (async () => {
@@ -536,8 +573,15 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMo
         // later query with a larger head_limit must re-run the enumeration.
         // Also never let an in-flight prewarm/real sweep repopulate after a
         // write invalidation cleared the cache during the sweep.
-        if (ttl > 0 && !truncated && !partial && FIND_ENUM_GEN === genAtStart) {
-            FIND_ENUM_CACHE.set(key, { files, expiresAt: Date.now() + ttl, gen: genAtStart });
+        if (ttl > 0 && !truncated && !partial
+            && FIND_ENUM_GEN === genAtStart
+            && findEnumerationRootGeneration(root) === rootGenAtStart) {
+            FIND_ENUM_CACHE.set(key, {
+                files,
+                expiresAt: Date.now() + ttl,
+                gen: genAtStart,
+                rootGen: rootGenAtStart,
+            });
         }
         return { files, truncated, partial };
     })();
@@ -585,21 +629,82 @@ async function getTargetedFindEnumeration({
     const key = JSON.stringify([root, hidden, depth ?? '', includeNoise, terms]);
     const runs = context?.targetedRuns;
     if (runs?.has(key)) return runs.get(key);
-    const run = (async () => {
-        const rgArgs = ['--files', '--no-ignore'];
-        if (hidden) rgArgs.push('--hidden');
-        if (depth != null) rgArgs.push('--max-depth', String(depth));
-        for (const query of terms) rgArgs.push('--iglob', `*${escapeFindGlobLiteral(query)}*`);
-        rgArgs.push('.');
-        const stdout = await runRgImpl(rgArgs, { cwd: root, signal });
-        const paths = parseRgFileList(stdout).filter((path) =>
-            includeNoise || !path.split('/').some((segment) => NOISE_DIR_NAMES.has(segment)));
-        return {
-            files: paths,
-            truncated: Boolean(stdout && typeof stdout === 'object' && stdout.truncated),
-            partial: Boolean(stdout && typeof stdout === 'object' && stdout.partial),
+    let batches = FIND_TARGETED_BATCHES_BY_RUNNER.get(runRgImpl);
+    if (!batches) {
+        batches = new Map();
+        FIND_TARGETED_BATCHES_BY_RUNNER.set(runRgImpl, batches);
+    }
+    const batchKey = JSON.stringify([root, hidden, depth ?? '', includeNoise]);
+    let batch = batches.get(batchKey);
+    if (!batch) {
+        batch = {
+            terms: new Set(),
+            waiters: new Set(),
+            controller: new AbortController(),
         };
-    })();
+        batches.set(batchKey, batch);
+        setImmediate(async () => {
+            if (batches.get(batchKey) === batch) batches.delete(batchKey);
+            if (batch.waiters.size === 0) return;
+            const rgArgs = ['--files', '--no-ignore'];
+            if (hidden) rgArgs.push('--hidden');
+            if (depth != null) rgArgs.push('--max-depth', String(depth));
+            for (const query of batch.terms) {
+                rgArgs.push('--iglob', `*${escapeFindGlobLiteral(query)}*`);
+            }
+            if (!includeNoise) {
+                for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
+            }
+            rgArgs.push('.');
+            try {
+                const stdout = await runRgImpl(rgArgs, {
+                    cwd: root,
+                    signal: batch.controller.signal,
+                });
+                const paths = parseRgFileList(stdout).filter((path) =>
+                    includeNoise || !path.split('/').some((segment) => NOISE_DIR_NAMES.has(segment)));
+                const result = {
+                    files: paths,
+                    truncated: Boolean(stdout && typeof stdout === 'object' && stdout.truncated),
+                    partial: Boolean(stdout && typeof stdout === 'object' && stdout.partial),
+                };
+                for (const waiter of [...batch.waiters]) waiter.resolve(result);
+            } catch (error) {
+                for (const waiter of [...batch.waiters]) waiter.reject(error);
+            }
+        });
+    }
+    for (const term of terms) batch.terms.add(term);
+    const run = new Promise((resolve, reject) => {
+        let settled = false;
+        const waiter = {
+            resolve(value) {
+                if (settled) return;
+                settled = true;
+                batch.waiters.delete(waiter);
+                if (signal instanceof AbortSignal) signal.removeEventListener('abort', onAbort);
+                resolve(value);
+            },
+            reject(error) {
+                if (settled) return;
+                settled = true;
+                batch.waiters.delete(waiter);
+                if (signal instanceof AbortSignal) signal.removeEventListener('abort', onAbort);
+                reject(error);
+            },
+        };
+        const onAbort = () => {
+            waiter.reject(findEnumerationAbortError(signal));
+            if (batch.waiters.size === 0) {
+                try { batch.controller.abort(findEnumerationAbortError(signal)); } catch {}
+            }
+        };
+        batch.waiters.add(waiter);
+        if (signal instanceof AbortSignal) {
+            if (signal.aborted) onAbort();
+            else signal.addEventListener('abort', onAbort, { once: true });
+        }
+    });
     if (runs) runs.set(key, run);
     return run;
 }

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

@@ -113,6 +113,42 @@ export async function warmNativeSearchServer() {
   }
 }
 
+/** Fast Windows process table snapshot served by the resident native helper.
+ *  Returns [{pid,parentPid,identity}] or null; callers stay conservative when
+ *  the binary is unavailable or the request misses its short deadline. */
+export async function tryNativeProcessSnapshot({ timeoutMs = 750 } = {}) {
+  if (process.platform !== 'win32' || process.env.MIXDOG_SEARCH_SERVER === '0') return null;
+  let server = _ensureServer();
+  if (!server && await warmNativeSearchServer()) server = _ensureServer();
+  if (!server) return null;
+  const id = ++server.sequence;
+  _setServerReferenced(server, true);
+  const response = await new Promise((resolve) => {
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+      if (server.pending.size === 0) _setServerReferenced(server, false);
+    };
+    const timer = setTimeout(() => {
+      server.pending.delete(id);
+      settle(null);
+    }, Math.max(1, Number(timeoutMs) || 750));
+    timer.unref?.();
+    server.pending.set(id, { resolve: settle, reject: () => settle(null) });
+    try {
+      server.child.stdin.write(`${JSON.stringify({ id, processSnapshot: true })}\n`);
+    } catch {
+      server.pending.delete(id);
+      settle(null);
+    }
+  });
+  if (!response || response.error || !Array.isArray(response.rows)) return null;
+  return response.rows;
+}
+
 export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
   if (process.env.MIXDOG_SEARCH_SERVER === '0') return null;
   const server = _ensureServer();

package/src/runtime/agent/orchestrator/tools/builtin/shell-job-process.mjs

@@ -1,4 +1,5 @@
 import { spawn, spawnSync } from 'child_process';
+import { tryNativeProcessSnapshot } from './native-search-client.mjs';
 
 // Process/pid lifecycle helpers for background shell jobs: liveness probing,
 // tree-kill, the module-level live-job pid registry, and the CLI-shutdown exit
@@ -31,75 +32,25 @@ function isProcessTreeAlive(pid) {
     }
 }
 
-const windowsSnapshotCaches = new WeakMap();
-function windowsProcessSnapshot({ fresh = false, spawnFn = spawn } = {}) {
-    let windowsSnapshotCache = windowsSnapshotCaches.get(spawnFn);
-    if (!windowsSnapshotCache) {
-        windowsSnapshotCache = { at: 0, rows: null, inFlight: null };
-        windowsSnapshotCaches.set(spawnFn, windowsSnapshotCache);
-    }
+const windowsSnapshotCache = { at: 0, rows: null, inFlight: null };
+function windowsProcessSnapshot({ fresh = false } = {}) {
     const now = Date.now();
     if (!fresh && windowsSnapshotCache.rows && now - windowsSnapshotCache.at < 750) {
         return Promise.resolve(windowsSnapshotCache.rows);
     }
     if (windowsSnapshotCache.inFlight) return windowsSnapshotCache.inFlight;
-    const command = [
-        "$ErrorActionPreference='Stop'",
-        'Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,CreationDate | ForEach-Object {',
-        '  [Console]::Out.WriteLine(("{0}`t{1}`t{2}" -f $_.ProcessId,$_.ParentProcessId,$_.CreationDate))',
-        '}',
-    ].join('; ');
-    windowsSnapshotCache.inFlight = new Promise((resolve) => {
-        let child;
-        let stdout = '';
-        let settled = false;
-        let timeout = null;
-        const finish = (rows) => {
-            if (settled) return;
-            settled = true;
-            if (timeout) clearTimeout(timeout);
-            windowsSnapshotCache.inFlight = null;
+    windowsSnapshotCache.inFlight = Promise.resolve(tryNativeProcessSnapshot()).then(
+        (snapshot) => {
+            const rows = normalizeWindowsSnapshot(snapshot);
             if (rows) {
                 windowsSnapshotCache.at = Date.now();
                 windowsSnapshotCache.rows = rows;
             }
-            resolve(rows);
-        };
-        try {
-            child = spawnFn('powershell.exe', [
-            '-NoLogo', '-NoProfile', '-NonInteractive', '-Command', command,
-            ], {
-                windowsHide: true,
-                stdio: ['ignore', 'pipe', 'ignore'],
-            });
-            child.stdout.setEncoding('utf8');
-            child.stdout.on('data', (chunk) => {
-                if (stdout.length <= 4 * 1024 * 1024) stdout += chunk;
-            });
-            child.once('error', () => finish(null));
-            child.once('close', (code) => {
-                if (code !== 0 || !stdout) {
-                    finish(null);
-                    return;
-                }
-                const rows = new Map();
-                for (const line of stdout.split(/\r?\n/)) {
-                    const [pidText, parentText, identity = ''] = line.split('\t');
-                    const rowPid = Number(pidText);
-                    const parentPid = Number(parentText);
-                    if (!Number.isFinite(rowPid) || rowPid <= 0 || !Number.isFinite(parentPid)) continue;
-                    rows.set(rowPid, { pid: rowPid, parentPid, identity });
-                }
-                finish(rows);
-            });
-            timeout = setTimeout(() => {
-                try { child.kill(); } catch {}
-                finish(null);
-            }, 2000);
-            if (typeof timeout.unref === 'function') timeout.unref();
-        } catch {
-            finish(null);
-        }
+            return rows;
+        },
+        () => null,
+    ).finally(() => {
+        windowsSnapshotCache.inFlight = null;
     });
     return windowsSnapshotCache.inFlight;
 }
@@ -117,28 +68,39 @@ function normalizeWindowsSnapshot(snapshot) {
     return rows;
 }
 
-// Standby-pool support: does `pid` currently own live descendant processes?
-// FRESH snapshot on purpose — the 750ms cache could miss a just-spawned
-// grandchild and wrongly certify a polluted standby shell as clean. Unknown
-// snapshots answer true (conservative: the pool discards instead of reusing).
-export async function windowsPidHasDescendants(pid, { spawnFn = spawn } = {}) {
-    if (!Number.isFinite(pid) || pid <= 0) return false;
-    if (process.platform !== 'win32') return false;
+// Standby-pool support: capture every current descendant with a creation-time
+// identity so a PID reused after the baseline snapshot cannot be allowlisted.
+// Unknown snapshots stay conservative: callers discard instead of reusing.
+export async function windowsPidDescendants(pid) {
+    if (!Number.isFinite(pid) || pid <= 0) return new Map();
+    if (process.platform !== 'win32') return new Map();
     let rows = null;
-    try { rows = await windowsProcessSnapshot({ fresh: true, spawnFn }); } catch { rows = null; }
-    if (!rows) return true;
+    try { rows = await windowsProcessSnapshot({ fresh: true }); } catch { rows = null; }
+    if (!rows) return null;
     const owned = new Set([pid]);
+    const descendants = new Map();
     let discovered = true;
     while (discovered) {
         discovered = false;
         for (const row of rows.values()) {
             if (!owned.has(row.pid) && owned.has(row.parentPid)) {
                 owned.add(row.pid);
+                descendants.set(row.pid, row.identity);
                 discovered = true;
             }
         }
     }
-    return owned.size > 1;
+    return descendants;
+}
+
+export async function windowsPidHasDescendants(pid, { allowedDescendants = null } = {}) {
+    const descendants = await windowsPidDescendants(pid);
+    if (!descendants) return true;
+    if (!(allowedDescendants instanceof Map)) return descendants.size > 0;
+    for (const [descendantPid, identity] of descendants) {
+        if (allowedDescendants.get(descendantPid) !== identity) return true;
+    }
+    return false;
 }
 
 // Invoke onQuiescent exactly once, synchronously when already quiescent or
@@ -165,7 +127,7 @@ export function trackProcessTreeQuiescence(
         // The PID returned by spawn is durable pre-exit ownership evidence.
         // Seed it before the first asynchronous snapshot so a child whose
         // parent is this PID remains attributable even if the root is already
-        // absent when CIM returns.
+        // absent when the native snapshot returns.
         ownedWindowsProcesses.set(pid, null);
     }
     const finish = () => {

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs

@@ -2,9 +2,10 @@
 // resolveSymbolReadSpan, executeCodeGraphTool (entry with cwd re-rooting +
 // batch fan-out + abort race), isCodeGraphTool. Extracted verbatim from
 // code-graph.mjs.
-import { resolve as pathResolve, isAbsolute, relative as pathRelative, basename as pathBasename } from 'node:path';
+import { resolve as pathResolve, isAbsolute, relative as pathRelative, basename as pathBasename, extname } from 'node:path';
 import { homedir as osHomedir } from 'node:os';
 import { existsSync, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { normalizeInputPath, toDisplayPath } from '../builtin.mjs';
 import { findFileByBasename } from '../builtin/path-diagnostics.mjs';
 import { markScopedCacheIncomplete } from '../../session/cache/scoped-cache-outcome.mjs';
@@ -55,6 +56,32 @@ const CODE_GRAPH_BATCHABLE_MODES = new Set(['symbol', 'find_symbol', 'symbol_sea
 const CODE_GRAPH_FILE_BATCHABLE_MODES = new Set(['imports', 'dependents', 'related', 'impact', 'symbols', 'overview']);
 const CODE_GRAPH_BATCH_CONCURRENCY = 20;
 
+function _outlineLanguageForPath(file) {
+  const ext = extname(String(file || '')).slice(1);
+  if (['js', 'mjs', 'cjs', 'jsx'].includes(ext)) return 'javascript';
+  if (['ts', 'tsx', 'mts', 'cts'].includes(ext)) return 'typescript';
+  if (ext === 'py') return 'python';
+  if (ext === 'go') return 'go';
+  if (ext === 'rs') return 'rust';
+  if (ext === 'java') return 'java';
+  if (ext === 'kt' || ext === 'kts') return 'kotlin';
+  if (ext === 'cs') return 'csharp';
+  if (ext === 'rb') return 'ruby';
+  if (ext === 'php') return 'php';
+  if (ext === 'swift') return 'swift';
+  if (ext === 'c' || ext === 'h') return 'c';
+  if (['cpp', 'cc', 'cxx', 'hpp', 'hxx'].includes(ext)) return 'cpp';
+  if (ext === 'scala' || ext === 'sc') return 'scala';
+  if (ext === 'sh' || ext === 'bash' || ext === 'zsh') return 'bash';
+  if (ext === 'lua') return 'lua';
+  if (ext === 'dart') return 'dart';
+  if (ext === 'm' || ext === 'mm') return 'objc';
+  if (ext === 'ex' || ext === 'exs') return 'elixir';
+  if (ext === 'zig') return 'zig';
+  if (ext === 'r' || ext === 'R') return 'r';
+  return null;
+}
+
 async function _mapWithConcurrency(values, mapper) {
   const out = new Array(values.length);
   let cursor = 0;
@@ -265,6 +292,28 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
     return `prewarm scheduled: cwd=${cwd} symbols=${symbols.length}${symbols.length ? ` (${symbols.slice(0, 5).join(',')}${symbols.length > 5 ? `,+${symbols.length - 5}` : ''})` : ''}`;
   }
 
+  // A file outline is source-local: it needs neither imports nor reverse
+  // edges. Read the explicit file directly instead of waiting for a cold
+  // whole-project graph build. Relationship and name-search modes keep the
+  // full graph path below.
+  if (mode === 'symbols') {
+    const normFile = normalizeInputPath(args?.file);
+    const abs = normFile
+      ? (isAbsolute(normFile) ? pathResolve(normFile) : pathResolve(cwd, normFile))
+      : null;
+    const lang = abs ? _outlineLanguageForPath(abs) : null;
+    if (abs && lang) {
+      if (signal?.aborted) throw new Error('aborted');
+      try {
+        const text = await readFile(abs, { encoding: 'utf8', signal: signal || undefined });
+        return _extractSymbolsCheap(text, lang);
+      } catch (error) {
+        if (signal?.aborted) throw new Error('aborted');
+        if (error?.code !== 'ENOENT' && error?.code !== 'EISDIR') throw error;
+      }
+    }
+  }
+
   const graph = await buildCodeGraphAsync(cwd, signal, {
     excludedProjectRoots: options?.excludedProjectRoots,
   });

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.4",
+  "version": "0.1.5",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-darwin-arm64",
-      "sha256": "1531098011a3c32ad9a6d002e7240b829352fda60afc5708699dd0d335405201"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-darwin-arm64",
+      "sha256": "8124df97acdac619126c0686896c8b419fca9c3f2fc605547c21459b840deb3b"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-darwin-x64",
-      "sha256": "ead5684bebc2ef001724b2d71f23f3e7fc6e52d60d6deb5cea17b73fc3768a1b"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-darwin-x64",
+      "sha256": "64a4f2d5bb4e769373beb4aec7d355bcf53882af9ab8a401338f99441ee2e99b"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-linux-arm64",
-      "sha256": "8d6d24490dfff31f66967b8384f4afe8f85051f9352c3866a2da32e6ef52d644"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-linux-arm64",
+      "sha256": "ac9aae52012267b37139eeae45f6d2de780ec8f3e128a06a3843884f34434fa4"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-linux-x64",
-      "sha256": "ed26c40956d90d9863d18c028cc7766e9abf5af33405a9cab02f7cbc4a3c7eac"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-linux-x64",
+      "sha256": "12314eaf7d2168ff203edf0d45dff315fba00d49704183f61f0eba9cfc1cab72"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-win32-x64.exe",
-      "sha256": "f87bd63e70ecc0a7639f0143b5954a2b673d84e6c59e1ca8f7a8e5cdcc50a21a"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-win32-x64.exe",
+      "sha256": "b7d724ec01e5af4bee1764a08796bf0e1cefc2e2b841e6285f7b669a54774d10"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/lib/pwsh-standby-pool.mjs

@@ -27,7 +27,11 @@ import { spawn } from 'node:child_process';
 import { basename } from 'node:path';
 import { createHash, randomBytes } from 'node:crypto';
 import { availableParallelism, freemem } from 'node:os';
-import { killProcessTree, windowsPidHasDescendants } from '../builtin/shell-job-process.mjs';
+import {
+    killProcessTree,
+    windowsPidDescendants,
+    windowsPidHasDescendants,
+} from '../builtin/shell-job-process.mjs';
 
 const MB = 1024 * 1024;
 
@@ -269,6 +273,8 @@ function _spawnStandby(shell, env, sig) {
         sig,
         nonce,
         ready: false,
+        baselinePending: false,
+        baselineDescendants: null,
         taken: false,
         consumed: false,
         idleTimer: null,
@@ -281,9 +287,27 @@ function _spawnStandby(shell, env, sig) {
             if (readyTail.length > readyMarker.length * 2) readyTail = readyTail.slice(-readyMarker.length * 2);
             return;
         }
-        entry.ready = true;
         try { child.stdout.removeListener('data', onReadyData); } catch {}
-        _signalStandbyChange();
+        if (entry.baselinePending) return;
+        entry.baselinePending = true;
+        // pwsh owns a persistent conhost child before it becomes READY. Record
+        // that clean baseline once; recycle rejects only NEW descendants, with
+        // creation identities preventing PID-reuse false negatives.
+        void windowsPidDescendants(child.pid).then((baseline) => {
+            entry.baselinePending = false;
+            if (!baseline || child.exitCode !== null || child.signalCode !== null) {
+                _discardIdle(entry);
+                _killEntry(entry);
+                return;
+            }
+            entry.baselineDescendants = baseline;
+            entry.ready = true;
+            _signalStandbyChange();
+        }, () => {
+            entry.baselinePending = false;
+            _discardIdle(entry);
+            _killEntry(entry);
+        });
     };
     child.stdout.setEncoding('utf8');
     child.stdout.on('data', onReadyData);
@@ -428,7 +452,11 @@ export function takePwshStandby({ shell, shellArgs, env }) {
             const alive = () => c.exitCode === null && c.signalCode === null;
             let dirty = true;
             if (alive() && c.stdin && !c.stdin.destroyed) {
-                try { dirty = await windowsPidHasDescendants(c.pid); } catch { dirty = true; }
+                try {
+                    dirty = await windowsPidHasDescendants(c.pid, {
+                        allowedDescendants: entry.baselineDescendants,
+                    });
+                } catch { dirty = true; }
             }
             if (dirty || !alive() || !c.stdin || c.stdin.destroyed
                 || _idle.length >= POOL_TARGET || _envSig !== entry.sig) {

package/src/runtime/shared/tool-card-model.mjs

@@ -79,6 +79,31 @@ export function normalizeTerminalStatus(value) {
   return normalizeToolTerminalStatus(value);
 }
 
+// Semantic outcome shared by TUI and desktop. A returned command/task failure
+// means the tool transport worked, so it is warning-yellow; red is reserved
+// for a failed invocation. A failed mutation that still committed a diff is
+// likewise partial success, not a total failure.
+export function deriveToolOutcomeTone({
+  pending = false,
+  groupCount = 1,
+  callFailedCount = 0,
+  exitFailedCount = 0,
+  terminalStatus = '',
+  partialMutation = false,
+} = {}) {
+  if (pending) return 'running';
+  const status = normalizeTerminalStatus(terminalStatus);
+  if (status === 'cancelled' || status === 'denied') return 'warning';
+  const count = Math.max(1, Number(groupCount) || 1);
+  const callFailures = Math.max(0, Number(callFailedCount) || 0);
+  if (callFailures > 0) {
+    if (partialMutation || (count > 1 && callFailures < count)) return 'warning';
+    return 'error';
+  }
+  if (status === 'failed' || Number(exitFailedCount) > 0) return 'warning';
+  return 'success';
+}
+
 export function displayTerminalStatus(value) {
   // 'exit' is a shell-only pseudo-status (command RAN but exited non-zero); it
   // is intentionally NOT a normalized terminal status so it never colors red.

package/src/tui/components/ToolExecution.jsx

@@ -50,7 +50,7 @@ const TOOL_PENDING_SHOW_DELAY_MS = 1000;
 // One shared-tick cadence covers both the 500ms blink and per-second elapsed;
 // finer than either boundary so both stay crisp off a single timer.
 const TOOL_ANIM_TICK_MS = TOOL_BLINK_MS;
-export function ToolExecution({ name, args, result, rawResult, isError, errorCount, callErrorCount, exitErrorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, doneCategories = null, headerFinalized = true, deferredDisplayReady = false, agentResponseAggregate = false }) {
+export function ToolExecution({ name, args, result, rawResult, uiDiff, isError, errorCount, callErrorCount, exitErrorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, doneCategories = null, headerFinalized = true, deferredDisplayReady = false, agentResponseAggregate = false }) {
   const rowWidth = Math.max(1, Number(columns || 80));
   const groupCount = Math.max(1, Number(count || 1));
   const doneCount = Math.max(0, Math.min(groupCount, Number(completedCount || (result == null ? 0 : groupCount))));
@@ -105,6 +105,12 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   // Shell command-exits (ran, non-zero exit). Counted separately so the dot
   // paints the neutral warning "Exit" color instead of red or green success.
   const exitFailedCount = clampFailureCount(exitErrorCount, groupCount, false);
+  // apply_patch can commit an ordered prefix before a later section fails.
+  // The runtime-provided uiDiff is authoritative evidence of that partial
+  // mutation; an empty/missing diff means the invocation failed completely.
+  const partialMutation = callFailedCount > 0
+    && typeof uiDiff === 'string'
+    && Boolean(uiDiff.trim());
   const displayGroupCount = groupCount;
   const displayCategories = normalizeCountMap(categories || {});
   // In the DONE state the engine-supplied doneCategories map counts ATTEMPTS
@@ -178,7 +184,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
     const aggregateTerminalStatus = pending
       ? 'running'
       : (resultTerminalStatus(rt) || (isError || failedCount > 0 ? 'failed' : 'completed'));
-    const dotColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus: aggregateTerminalStatus });
+    const dotColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus: aggregateTerminalStatus, partialMutation });
     const dotText = pending && !blinkOn ? ' ' : TURN_MARKER;
     const gutter = 2;
     const showHeaderExpandHint = hasRawResult;
@@ -306,7 +312,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   const detailColor = isPendingPlaceholderDetail ? theme.subtle : theme.text;
   // Skill/agent collapsed gating lives in the shared model (detailLine).
   const visibleDetailLines = detailLines;
-  const finalStatusColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus });
+  const finalStatusColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus, partialMutation });
   const dotColor = finalStatusColor;
   // Agent surface cards use directional markers: `←` for requests going OUT
   // (spawn/send/etc.) and `→` for the response coming back IN. Background

package/src/tui/components/TranscriptItem.jsx

@@ -80,7 +80,7 @@ export const Item = React.memo(function Item({ item, prevKind, columns, toolOutp
       // Every tool card keeps its one-row gap above (user reverted the earlier
       // "stack consecutive cards flush" experiment: attached rows read broken).
       // Keep transcript-window.mjs row estimation in sync (attachedTool=false).
-      node = <ToolExecution name={item.name} args={item.args} result={item.result} rawResult={item.rawResult} isError={item.isError} errorCount={item.errorCount} callErrorCount={item.callErrorCount} exitErrorCount={item.exitErrorCount} expanded={toolOutputExpanded || item.expanded} columns={columns} attached={false} count={item.count} completedCount={item.completedCount} startedAt={item.startedAt} completedAt={item.completedAt} aggregate={item.aggregate} categories={item.categories} doneCategories={item.doneCategories} headerFinalized={item.headerFinalized} deferredDisplayReady={item.deferredDisplayReady} agentResponseAggregate={item.agentResponseAggregate} />;
+      node = <ToolExecution name={item.name} args={item.args} result={item.result} rawResult={item.rawResult} uiDiff={item.uiDiff} isError={item.isError} errorCount={item.errorCount} callErrorCount={item.callErrorCount} exitErrorCount={item.exitErrorCount} expanded={toolOutputExpanded || item.expanded} columns={columns} attached={false} count={item.count} completedCount={item.completedCount} startedAt={item.startedAt} completedAt={item.completedAt} aggregate={item.aggregate} categories={item.categories} doneCategories={item.doneCategories} headerFinalized={item.headerFinalized} deferredDisplayReady={item.deferredDisplayReady} agentResponseAggregate={item.agentResponseAggregate} />;
       break;
     }
     case 'notice':

package/src/tui/components/tool-execution/surface-detail.mjs

@@ -6,7 +6,7 @@
  * existing TUI imports and keeps only the theme-dependent dot color.
  */
 import { theme } from '../../theme.mjs';
-import { normalizeTerminalStatus } from '../../../runtime/shared/tool-card-model.mjs';
+import { deriveToolOutcomeTone } from '../../../runtime/shared/tool-card-model.mjs';
 
 export {
   isShellTool,
@@ -35,29 +35,12 @@ export {
   clampFailureCount,
 } from '../../../runtime/shared/tool-card-model.mjs';
 
-// Single source of truth for the tool-card dot (●) color. Both the aggregate
-// and normal (single-tool) render paths must call this with a resolved
-// `terminalStatus` — do not recompute color inline elsewhere.
-//   running/pending  -> theme.text (white; blink handled by caller)
-//   success          -> theme.success
-//   partial failure  -> mixdogOrange || warning (some, not all, of the group failed)
-//   all failed       -> theme.error
-//   cancelled        -> theme.warning
-// The RED/orange failure color is driven ONLY by real tool-call errors
-// (`callFailedCount` — provider isError / error toolKind), NOT by command/result
-// failures like a `[status: failed]` result. A shell command-exit
-// (`exitFailedCount`) is its own distinct neutral state: warning color, never
-// red. `terminalStatus` is still consulted so a cancelled card stays warning.
-export function toolStatusColor({ pending, groupCount, callFailedCount = 0, exitFailedCount = 0, terminalStatus = '' }) {
-  if (pending) return theme.text;
-  const status = normalizeTerminalStatus(terminalStatus);
-  if (status === 'cancelled') return theme.warning;
-  if (status === 'denied') return theme.warning;
-  if (callFailedCount > 0) {
-    if (groupCount > 1 && callFailedCount < groupCount) return theme.mixdogOrange || theme.warning;
-    return theme.error;
-  }
-  // Command-exit(s) with no real tool-call failure: distinct warning state.
-  if (exitFailedCount > 0) return theme.warning;
+// Theme binding only; semantic outcome lives in the shared card model so the
+// TUI and desktop cannot disagree about success, warning, and failure.
+export function toolStatusColor(input) {
+  const tone = deriveToolOutcomeTone(input);
+  if (tone === 'running') return theme.text;
+  if (tone === 'warning') return theme.warning;
+  if (tone === 'error') return theme.error;
   return theme.success;
 }

package/src/tui/dist/index.mjs

@@ -15172,6 +15172,26 @@ function shellResultStatus(value) {
 function normalizeTerminalStatus(value) {
   return normalizeToolTerminalStatus(value);
 }
+function deriveToolOutcomeTone({
+  pending = false,
+  groupCount = 1,
+  callFailedCount = 0,
+  exitFailedCount = 0,
+  terminalStatus = "",
+  partialMutation = false
+} = {}) {
+  if (pending) return "running";
+  const status = normalizeTerminalStatus(terminalStatus);
+  if (status === "cancelled" || status === "denied") return "warning";
+  const count = Math.max(1, Number(groupCount) || 1);
+  const callFailures = Math.max(0, Number(callFailedCount) || 0);
+  if (callFailures > 0) {
+    if (partialMutation || count > 1 && callFailures < count) return "warning";
+    return "error";
+  }
+  if (status === "failed" || Number(exitFailedCount) > 0) return "warning";
+  return "success";
+}
 function displayTerminalStatus(value) {
   if (String(value || "").trim().toLowerCase() === "exit") return "Exit";
   const status = normalizeTerminalStatus(value);
@@ -15771,16 +15791,11 @@ function truncateToWidth(text, maxWidth) {
 }
 
 // src/tui/components/tool-execution/surface-detail.mjs
-function toolStatusColor({ pending, groupCount, callFailedCount = 0, exitFailedCount = 0, terminalStatus = "" }) {
-  if (pending) return theme.text;
-  const status = normalizeTerminalStatus(terminalStatus);
-  if (status === "cancelled") return theme.warning;
-  if (status === "denied") return theme.warning;
-  if (callFailedCount > 0) {
-    if (groupCount > 1 && callFailedCount < groupCount) return theme.mixdogOrange || theme.warning;
-    return theme.error;
-  }
-  if (exitFailedCount > 0) return theme.warning;
+function toolStatusColor(input) {
+  const tone = deriveToolOutcomeTone(input);
+  if (tone === "running") return theme.text;
+  if (tone === "warning") return theme.warning;
+  if (tone === "error") return theme.error;
   return theme.success;
 }
 
@@ -15809,7 +15824,7 @@ import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
 var TOOL_BLINK_MS = 500;
 var TOOL_PENDING_SHOW_DELAY_MS = 1e3;
 var TOOL_ANIM_TICK_MS = TOOL_BLINK_MS;
-function ToolExecution({ name, args, result, rawResult, isError, errorCount, callErrorCount, exitErrorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, doneCategories = null, headerFinalized = true, deferredDisplayReady = false, agentResponseAggregate = false }) {
+function ToolExecution({ name, args, result, rawResult, uiDiff, isError, errorCount, callErrorCount, exitErrorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, doneCategories = null, headerFinalized = true, deferredDisplayReady = false, agentResponseAggregate = false }) {
   const rowWidth = Math.max(1, Number(columns || 80));
   const groupCount = Math.max(1, Number(count || 1));
   const doneCount = Math.max(0, Math.min(groupCount, Number(completedCount || (result == null ? 0 : groupCount))));
@@ -15834,6 +15849,7 @@ function ToolExecution({ name, args, result, rawResult, isError, errorCount, cal
   const failedCount = clampFailureCount(errorCount, groupCount, isError);
   const callFailedCount = clampFailureCount(callErrorCount, groupCount, false);
   const exitFailedCount = clampFailureCount(exitErrorCount, groupCount, false);
+  const partialMutation = callFailedCount > 0 && typeof uiDiff === "string" && Boolean(uiDiff.trim());
   const displayGroupCount = groupCount;
   const displayCategories = normalizeCountMap(categories || {});
   const normalizedDoneCategories = doneCategories ? normalizeCountMap(doneCategories) : displayCategories;
@@ -15859,7 +15875,7 @@ function ToolExecution({ name, args, result, rawResult, isError, errorCount, cal
       detailText = "";
     }
     const aggregateTerminalStatus = pending ? "running" : resultTerminalStatus(rt) || (isError || failedCount > 0 ? "failed" : "completed");
-    const dotColor2 = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus: aggregateTerminalStatus });
+    const dotColor2 = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus: aggregateTerminalStatus, partialMutation });
     const dotText2 = pending && !blinkOn ? " " : TURN_MARKER;
     const gutter2 = 2;
     const showHeaderExpandHint2 = hasRawResult;
@@ -15943,7 +15959,7 @@ function ToolExecution({ name, args, result, rawResult, isError, errorCount, cal
   const isPendingPlaceholderDetail = !showRawResult && detailIsPlaceholder;
   const detailColor = isPendingPlaceholderDetail ? theme.subtle : theme.text;
   const visibleDetailLines = detailLines;
-  const finalStatusColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus });
+  const finalStatusColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus, partialMutation });
   const dotColor = finalStatusColor;
   const markerGlyph = isAgentResponse ? AGENT_RESPONSE_MARKER : isAgentSurfaceCard ? AGENT_CALL_MARKER : TURN_MARKER;
   const isDirectionalMarker = isAgentResponse || isAgentSurfaceCard;
@@ -16149,7 +16165,7 @@ var Item = React19.memo(function Item2({ item, prevKind, columns, toolOutputExpa
         node = /* @__PURE__ */ jsx19(ToolHookDenialCard, { item, columns });
         break;
       }
-      node = /* @__PURE__ */ jsx19(ToolExecution, { name: item.name, args: item.args, result: item.result, rawResult: item.rawResult, isError: item.isError, errorCount: item.errorCount, callErrorCount: item.callErrorCount, exitErrorCount: item.exitErrorCount, expanded: toolOutputExpanded || item.expanded, columns, attached: false, count: item.count, completedCount: item.completedCount, startedAt: item.startedAt, completedAt: item.completedAt, aggregate: item.aggregate, categories: item.categories, doneCategories: item.doneCategories, headerFinalized: item.headerFinalized, deferredDisplayReady: item.deferredDisplayReady, agentResponseAggregate: item.agentResponseAggregate });
+      node = /* @__PURE__ */ jsx19(ToolExecution, { name: item.name, args: item.args, result: item.result, rawResult: item.rawResult, uiDiff: item.uiDiff, isError: item.isError, errorCount: item.errorCount, callErrorCount: item.callErrorCount, exitErrorCount: item.exitErrorCount, expanded: toolOutputExpanded || item.expanded, columns, attached: false, count: item.count, completedCount: item.completedCount, startedAt: item.startedAt, completedAt: item.completedAt, aggregate: item.aggregate, categories: item.categories, doneCategories: item.doneCategories, headerFinalized: item.headerFinalized, deferredDisplayReady: item.deferredDisplayReady, agentResponseAggregate: item.agentResponseAggregate });
       break;
     }
     case "notice":