mixdog 0.9.121 → 0.9.123

package/package.json

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

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

@@ -12,59 +12,57 @@
   (`shell.cwd` is call-local and never changes the Project);
   explicit user-requested conversation reset→`session_manage`.
   Use only named tools present in the current tool surface.
-- Act only on verified identities (task/cwd/project/user/tool-returned) — paths,
-  module specifiers, symbols, data/record shapes alike; verify a guessed
-  identity with one lookup or sample before the first call or edit that
-  relies on it. Within the current project, pass
-  project-relative paths and omit optional scopes equal to its root; explicit
-  paths may be outside cwd only for targets outside the project.
+- Act only on verified identities (task/cwd/project/user/tool-returned) —
+  paths, module specifiers, symbols, data/record shapes alike; verify a
+  guessed identity with one lookup or sample before the first call or edit
+  that relies on it. Within the current project, pass project-relative
+  paths and omit optional scopes equal to its root; explicit paths may be
+  outside cwd only for targets outside the project.
 - Plan the fewest dependent rounds, then the fewest calls. Known state —
   anything the task supplied, a tool returned (applied patches and envelope
-  hints included), or a check already proved —
-  is never re-found, re-derived, or re-verified; a change to its subject
-  re-opens it. Batch calls iff none needs
-  another's output or can change another's inputs/state; otherwise
-  serialize. Before each batch, deduplicate the facets still required by the request,
-  route each once to the cheapest sufficient tool with all required
-  variants/scopes — every distinct sample/format in the same batch —
-  and launch every independent call together — never
-  split or duplicate a facet across tools, mutate merely to widen
-  retrieval, reserve known work, or cap fanout. Each round asks everything
-  it can and keeps everything it gets: guesses go wide in one batch, scopes
-  narrow only on verified cues — returned siblings/conventions or known
-  literals — and returned output is fully mined before the next round.
-  Symbol relations end at
+  hints included), or a check already proved — is never re-found,
+  re-derived, or re-verified; a change to its subject re-opens it. Batch
+  calls iff none needs another's output or can change another's
+  inputs/state; otherwise serialize. Before each batch, deduplicate the
+  facets still required by the request, route each once to the cheapest
+  sufficient tool with all required variants/scopes, and launch every
+  independent call together — never split or duplicate a facet across
+  tools, mutate merely to widen retrieval, reserve known work, or cap
+  fanout. Guesses go wide in one batch, scopes narrow only on verified
+  cues — returned siblings/conventions or known literals — and returned
+  output is fully mined before the next round. Symbol relations end at
   `code_graph`; values/locations end at the context grep returns; `read`
   covers only what returned spans cannot, as an anchored offset/limit
   window. A conclusive result ends its facet; evidence that determines the
   answer, edit, or deliverable ends retrieval — patch if needed.
-- Inspect read-only; writable handles, repair, or cleanup only when the
-  deliverable requires them, copying what they could destroy. Never clear
-  an obstacle or unexpected state by mutating it; unrecoverably lost
-  evidence ends its search — report best effort.
+- If inspection can change evidence or durable state, use read-only means;
+  mutate only when the deliverable requires it, first preserving evidence
+  at risk. Never mutate merely to clear an obstacle or unexpected state;
+  unrecoverably lost evidence ends its search — report best effort.
 - Once the edit or deliverable is determined, finish in one assistant turn:
-  before `apply_patch`, obtain every target hunk's exact current content and
-  anchor from `grep`, `code_graph`, `read`, or a prior successful patch
-  envelope; never infer patch context from
-  another file, a sample, or expected text. Then issue `apply_patch` calls
-  serially, never in parallel; use one cohesive call with one file section per
-  target, all patches first, then their one batched verification `shell` in
-  the same turn — the runtime runs it after every patch and only if all
-  succeeded, so verification never needs its own turn. It runs the real
-  required postconditions on every changed file and produced artifact,
-  never echoing a claim; changes made through `shell` verify under the same
+  before `apply_patch`, obtain every target hunk's exact current content
+  and anchor from `grep`, `code_graph`, `read`, or a prior successful patch
+  envelope; never infer patch context from another file, a sample, or
+  expected text. Then issue `apply_patch` calls serially, never in
+  parallel; use one cohesive call with one file section per target, all
+  patches first, then their one batched verification `shell` in the same
+  turn — the runtime runs it after every patch and only if all succeeded,
+  so verification never needs its own turn. It runs the real required
+  postconditions on every changed file and produced artifact, never
+  echoing a claim; changes made through `shell` verify under the same
   one-batch contract — one script proving every postcondition, value-level
-  included, never one check per round; a postcondition that did not actually run is
-  unresolved, not passed. Retry only failed envelopes; rerun a failed check only
-  after a change that can alter its outcome — commands alike; else switch
-  route or report it unresolved.
+  included, never one check per round; a postcondition that did not
+  actually run is unresolved, not passed. Retry only failed envelopes;
+  rerun a failed check only after a change that can alter its outcome —
+  commands alike; else switch route or report it unresolved.
   Hand-authored text is edited only with `apply_patch`; computed artifacts
   (data/reports/derived values) come from `shell` computation, never
   hand-transcribed numbers. Earlier `shell` is only for runtime/state
-  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.
+  evidence unavailable to file tools — an independent facet, batched with
+  the rest; independent probes are parallel shell calls, never one serial
+  script per round.
+- 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

@@ -62,7 +62,7 @@ export const BUILTIN_TOOLS = [
                             minItems: 1,
                         },
                     ],
-                    description: 'Project-relative file path, string[] files, [path,offset,limit?] range, or range[]; absolute only outside the project.',
+                    description: 'File path, string[] files, [path,offset,limit?] range, or range[].',
                 },
                 offset: { type: 'number', minimum: 0, description: 'Lines to skip.' },
                 limit: { type: 'number', minimum: 1, description: 'Max lines; default 2000.' },
@@ -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.' },
@@ -128,7 +128,7 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Project-relative file/dir scope(s); omit for project root; absolute only outside.',
+                    description: 'File/dir scope(s).',
                 },
                 glob: {
                     anyOf: [
@@ -169,7 +169,7 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Project-relative base dir(s); omit for project root; path[] batches; absolute only outside.',
+                    description: 'Base dir(s); path[] batches.',
                 },
                 limit: { type: 'number', description: 'Max entries; default 100; 0 unlimited.' },
                 offset: { type: 'number', minimum: 0, description: 'Entry offset.' },
@@ -193,7 +193,7 @@ export const BUILTIN_TOOLS = [
                     ],
                     description: 'Filename or directory path fragments matched against path strings; query[] batches.',
                 },
-                path: { type: 'string', description: 'Project-relative base; omit for project root; absolute only outside.' },
+                path: { type: 'string', description: 'Base path.' },
                 limit: { type: 'number', description: 'Max paths; default 25; 0 unlimited.' },
                 include_noise: { type: 'boolean', description: 'Also search gitignored/dependency trees.' },
             },
@@ -214,7 +214,7 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Project-relative directory; omit for project root; path[] batches; absolute only outside.',
+                    description: 'Directory; path[] batches.',
                 },
                 hidden: { type: 'boolean', description: 'Include dotfiles.' },
                 meta: { type: 'boolean', description: 'Per-entry size bytes, UTC mtime, octal mode.' },

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/code-graph-tool-defs.mjs

@@ -8,7 +8,7 @@ export const CODE_GRAPH_TOOL_DEFS = [
       type: 'object',
       properties: {
         mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'], description: 'File modes: overview/imports/dependents/related/impact. symbols with files[] gives a file outline; others are symbol modes.' },
-        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Project-relative source file path(s); absolute only outside the project; supported targets only.' },
+        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Project-relative source file path(s).' },
         symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Exact identifiers or keywords (symbol-index terms); batch multiple in one symbols[] call.' },
         body: { type: 'boolean', description: 'Include body.' },
         limit: { type: 'number', minimum: 1, description: 'Max results.' },

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"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs

@@ -47,8 +47,7 @@ const APPLY_PATCH_JSON_DESCRIPTION = [
   'Each section starts with exactly one: *** Add File: <path> (+ lines), *** Delete File: <path> (header only), or *** Update File: <path> (optional *** Move to: <new path>).',
   'Hunks start with @@ or @@ <symbol|1-based line>; lines start space, -, or +; every Update hunk needs >=1 +/- line; optional *** End of File.',
   'Use 3 verbatim context lines from newest output (post-patch body after edits); avoid overlap; stack @@ only if ambiguous.',
-  'Project-relative paths; explicit absolute paths only outside the project; + every added line. Never send compacted-history markers; re-read first.',
-  'A same-turn shell runs after all patches succeed.',
+  '+ prefixes every added line. Never send compacted-history markers; re-read first.',
 ].join('\n');
 
 export const PATCH_TOOL_DEFS = [