mixdog 0.9.122 → 0.9.123

package/package.json

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

package/src/rules/shared/01-tool.md

@@ -61,7 +61,8 @@
   evidence unavailable to file tools — an independent facet, batched with
   the rest; independent probes are parallel shell calls, never one serial
   script per round.
-- A long or uncertain command runs async — never nohup — and its
-  `task_id` ends the turn; completion resumes work. Never poll in any
-  form — sleep/status probes included; task control is for recovery or a
-  required blocking result only.
+- Run long/uncertain commands async—never nohup—and omit timeout unless a real
+  total deadline is required; explicit timeout kills even async jobs. Do not
+  poll a notified `task_id`; completion resumes. Else poll only when requested
+  or no notification exists, with cadence/stop condition; task control only
+  serves recovery/blocking.

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

@@ -83,7 +83,7 @@ export const BUILTIN_TOOLS = [
                 cwd: { type: 'string', description: 'Omit to use the current Project root; use a project-relative subdir or explicit external path for this call only.' },
                 timeout: {
                     type: 'number',
-                    description: `Timeout ms; default ${_shellDefaultTimeoutMs()}. Explicit values are deadlines; sync may return task_id.`,
+                    description: `Total deadline ms. Omit for sync default ${_shellDefaultTimeoutMs()}; omit for unlimited async. Explicit values kill at deadline; sync may return task_id.`,
                 },
                 mode: { type: 'string', enum: ['sync', 'async'], description: executionModeSchemaDescription('sync') },
                 shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell.' },

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

@@ -447,6 +447,29 @@ function invalidateFindEnumerationRoot(root) {
         if (findEnumerationRootFromKey(key) === root) FIND_ENUM_INFLIGHT.delete(key);
     }
 }
+// Trailing-edge prewarm throttle: sustained write bursts (builds, installs)
+// fire the watcher continuously; re-running the two full sweeps on every
+// flush kept the serve bulk queue permanently busy. Invalidation stays
+// immediate — only the warm rebuild is coalesced to one run per interval
+// per root, scheduled at the trailing edge so the cache re-arms after the
+// burst settles.
+const FIND_ENUM_PREWARM_STATE = new Map(); // root -> { lastAt, timer }
+const FIND_ENUM_PREWARM_MIN_INTERVAL_MS = 15_000;
+function scheduleFindEnumerationPrewarm(root, delayMs = 100) {
+    let state = FIND_ENUM_PREWARM_STATE.get(root);
+    if (!state) {
+        state = { lastAt: 0, timer: null };
+        FIND_ENUM_PREWARM_STATE.set(root, state);
+    }
+    if (state.timer) return;
+    const wait = Math.max(delayMs, state.lastAt + FIND_ENUM_PREWARM_MIN_INTERVAL_MS - Date.now());
+    state.timer = setTimeout(() => {
+        state.timer = null;
+        state.lastAt = Date.now();
+        void prewarmFindEnumeration(root);
+    }, wait);
+    state.timer.unref?.();
+}
 function ensureFindEnumerationWatcher(root) {
     const existing = FIND_ENUM_WATCHERS.get(root);
     if (existing) {
@@ -461,8 +484,7 @@ function ensureFindEnumerationWatcher(root) {
             const paths = [...pending];
             pending.clear();
             invalidateBuiltinResultCache(paths.length ? paths : [root]);
-            const warm = setTimeout(() => void prewarmFindEnumeration(root), 100);
-            warm.unref?.();
+            scheduleFindEnumerationPrewarm(root);
         };
         record.watcher = watch(root, { recursive: true, persistent: false }, (_event, filename) => {
             const rel = filename == null ? '' : String(filename);
@@ -649,6 +671,21 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMo
     return subscribeToFindEnumeration(key, entry, signal);
 }
 
+// Cache-only peek: returns the SHARED files array of a still-valid broad
+// sweep for these dimensions, or null. Never spawns, joins, or waits — the
+// targeted find path below must not block behind a full-tree enumeration.
+function peekBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMode }) {
+    if (findEnumTtlMs() <= 0) return null;
+    const key = findEnumKey({ root, hidden, depth, includeNoise, ignoreMode });
+    const hit = FIND_ENUM_CACHE.get(key);
+    if (hit && hit.gen === FIND_ENUM_GEN
+        && hit.rootGen === findEnumerationRootGeneration(root)
+        && hit.expiresAt > Date.now()) {
+        return hit.files;
+    }
+    return null;
+}
+
 // Best-effort warm of the broad enumeration for a root using the `find` tool's
 // DEFAULT flags (hidden:true, includeNoise:false, depth:unbounded). Swallows
 // all errors — a failed prewarm must never surface or block the caller.
@@ -695,38 +732,27 @@ async function getTargetedFindEnumeration({
     const key = JSON.stringify([root, hidden, depth ?? '', includeNoise, terms]);
     const runs = context?.targetedRuns;
     if (runs?.has(key)) return runs.get(key);
-    try {
-        const inventoryArgs = ['--files', '--no-ignore'];
-        if (hidden) inventoryArgs.push('--hidden');
-        if (depth != null) inventoryArgs.push('--max-depth', String(depth));
-        if (!includeNoise) {
-            for (const ex of DEFAULT_IGNORE_GLOBS) inventoryArgs.push('--glob', ex);
-        }
-        inventoryArgs.push('.');
-        const inventory = await getBroadEnumeration({
-            root: normalizeOutputPath(root),
-            hidden,
-            depth,
-            includeNoise,
-            ignoreMode: 'targeted-all',
-            rgArgs: inventoryArgs,
-            cwd: root,
-            runRgImpl,
-            signal,
-        });
-        if (!inventory.truncated && !inventory.partial) {
-            const lowerTerms = terms.map((term) => term.toLowerCase());
-            return {
-                files: inventory.files.filter((path) => {
-                    const lower = path.toLowerCase();
-                    return lowerTerms.some((term) => lower.includes(term));
-                }),
-                truncated: false,
-                partial: false,
-            };
-        }
-    } catch {
-        if (signal?.aborted) throw findEnumerationAbortError(signal);
+    // Reuse a WARM broad inventory only (cache peek). A cold cache goes
+    // straight to the cheap targeted --iglob batch below: front-running the
+    // full `--no-ignore` sweep made cold finds stall behind the serve bulk
+    // queue for tens of seconds.
+    const inventory = peekBroadEnumeration({
+        root: normalizeOutputPath(root),
+        hidden,
+        depth,
+        includeNoise,
+        ignoreMode: 'targeted-all',
+    });
+    if (inventory) {
+        const lowerTerms = terms.map((term) => term.toLowerCase());
+        return {
+            files: inventory.filter((path) => {
+                const lower = path.toLowerCase();
+                return lowerTerms.some((term) => lower.includes(term));
+            }),
+            truncated: false,
+            partial: false,
+        };
     }
     let batches = FIND_TARGETED_BATCHES_BY_RUNNER.get(runRgImpl);
     if (!batches) {

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

@@ -154,6 +154,15 @@ export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
   const server = _ensureServer();
   if (!server) return null;
   const id = ++server.sequence;
+  // Honor the caller's rg deadline: the resident server must never wait
+  // LONGER than the spawn fallback it replaces (glob passes 10s while the
+  // serve ceiling is 20s), otherwise a queued/stuck serve request delays the
+  // fallback instead of accelerating it. The fixed ceiling still bounds
+  // callers that pass no timeout.
+  const callerTimeoutMs = Number(execOptions.timeout);
+  const deadlineMs = Number.isFinite(callerTimeoutMs) && callerTimeoutMs > 0
+    ? Math.min(callerTimeoutMs, REQUEST_TIMEOUT_MS)
+    : REQUEST_TIMEOUT_MS;
   _setServerReferenced(server, true);
   const request = {
     id,
@@ -185,7 +194,7 @@ export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
     const timer = setTimeout(() => {
       server.pending.delete(id);
       settle(null, true);
-    }, REQUEST_TIMEOUT_MS);
+    }, deadlineMs);
     timer.unref?.();
     server.pending.set(id, { resolve: settle, reject: () => settle(null) });
     onAbort = () => {

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

@@ -76,6 +76,12 @@ export async function windowsPidDescendants(pid) {
     if (process.platform !== 'win32') return new Map();
     let rows = null;
     try { rows = await windowsProcessSnapshot({ fresh: true }); } catch { rows = null; }
+    if (!rows) {
+        // One retry before giving up: a single missed 750ms native-snapshot
+        // deadline (server busy with a bulk enumeration) otherwise marks
+        // every standby dirty and collapses the pool into cold spawns.
+        try { rows = await windowsProcessSnapshot({ fresh: true }); } catch { rows = null; }
+    }
     if (!rows) return null;
     const owned = new Set([pid]);
     const descendants = new Map();

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

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.6",
+  "version": "0.1.7",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-darwin-arm64",
-      "sha256": "43df904a60384761e6a0f848feec93fce0d6a3db6246695475b52cf355891a35"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.7/mixdog-graph-darwin-arm64",
+      "sha256": "a8d95602fd2beb2901dded0b1fe728adfde8075d73557442e4c540b39e64fe8d"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-darwin-x64",
-      "sha256": "1bfbf4bc4ff0a55ed04477919e3a22a30de41af7404b8895e74d5ca0216e0285"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.7/mixdog-graph-darwin-x64",
+      "sha256": "788e6e0fb32d8d8ba3b4c22e31492dc99bba039a3186a5b3f2420df3778f45d6"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-linux-arm64",
-      "sha256": "60512d468674105997b9171b9d9cc23c341144ada555cdc21f2e9b5cfbdd7ecb"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.7/mixdog-graph-linux-arm64",
+      "sha256": "43f723df7b452e75bde9839c2ce027982fa329c08560f6888442c65ac0ef7ddf"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-linux-x64",
-      "sha256": "9bddb7e78922081c550197ad7e34044fa4486ba57372dd0b662f3805c84f1561"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.7/mixdog-graph-linux-x64",
+      "sha256": "a7a390fb2e446fb7a9d16ac68c42c1989622beab0d6711b610a16e43360e7e84"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-win32-x64.exe",
-      "sha256": "0ad9198a5c5cf61993cb1bf76b2e4652f06542e8cf8f22601b7ca065a96b65f1"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.7/mixdog-graph-win32-x64.exe",
+      "sha256": "75e7dafd4df2f56c889b3c77643cfe95526c8ada1c1ffd1711539677737950c2"
     }
   }
 }