mixdog 0.8.1 → 0.9.0

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

@@ -12,23 +12,6 @@ function snapshotBodyWasReturnedByRead(snapshot) {
     return String(snapshot?.source || '').startsWith('read');
 }
 
-// Optional context-budget for a whole-file read: `max_lines:N` requests a
-// TIGHTER head+tail elision than the default 600-line / 200+100 cap, to bound
-// lead-context cost when only a glance is needed. Returns null (= default) when
-// unset. No heuristic guessing — the budget is explicit and reuses the existing
-// smartReadTruncate head/tail invariant. (`budget:'compact'` is a SEPARATE,
-// pre-existing knob handled upstream in read-tool.mjs applyCompactReadBudget —
-// it remaps a whole-file read to mode:'count' stats, not head+tail content.)
-function resolveReadBudget(args) {
-    const ml = Number(args?.max_lines);
-    if (Number.isFinite(ml) && ml > 0) {
-        const maxLines = Math.trunc(ml);
-        const headLines = Math.max(1, Math.ceil(maxLines * 0.7));
-        return { maxLines, headLines, tailLines: Math.max(0, maxLines - headLines) };
-    }
-    return null;
-}
-
 function withSymbolReadNote(text, args) {
     const note = typeof args?._symbolReadNote === 'string' ? args._symbolReadNote.trim() : '';
     if (!note || typeof text !== 'string') return text;
@@ -159,9 +142,6 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
     // emits a compact truncation marker when rendered bytes overflow
     // READ_MAX_OUTPUT_BYTES.
     const limit = parseLineLimitArg(args.limit, wantFull ? Infinity : 2000);
-    // Context-budget (compact / max_lines) — only meaningful on a whole-file
-    // read (no range, not full). Ignored otherwise.
-    const _readBudget = (!hasRangeArgs && !wantFull) ? resolveReadBudget(args) : null;
     let st;
     let _statErr;
     try {
@@ -265,7 +245,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         }
         return _ipynbOut;
     }
-    const cacheKey = `read|${fullPath}|${st.mtimeMs}|${st.size}|${hasOffsetArg ? offset : 'd'}|${hasLimitArg ? limit : 'd'}|${wantFull ? 'f' : 's'}|${_readBudget ? `b${_readBudget.maxLines}` : 'd'}`;
+    const cacheKey = `read|${fullPath}|${st.mtimeMs}|${st.size}|${hasOffsetArg ? offset : 'd'}|${hasLimitArg ? limit : 'd'}|${wantFull ? 'f' : 's'}`;
     // Race-guard helper: same-mtime same-size rapid rewrite (NTFS / exFAT 1 s
     // resolution) can pass mtimeMs+size yet differ in content. When the cache
     // entry stores a contentPrefixHash, recompute the current prefix and bail
@@ -358,7 +338,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
             _recordReadSnapshot(fullPath, st, readStateScope, cachedEntry.readSnapshotMeta || { source: 'read_cached' });
             // G6: file_unchanged stub. The full body is already in the
             // prior tool_result; resending it wastes cache_creation
-            // tokens (Claude Code upstream measured ~18% on Read calls).
+            // tokens (reference upstream measured ~18% on Read calls).
             // The stub keeps the snapshot tracking intact (Edit
             // validation still works) while collapsing the response
             // payload. Falls back to the full body when the cached
@@ -496,19 +476,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
                 ? await streamSmartReadSummary(fullPath, st, 'read_smart_stream')
                 : null;
             if (_streamSmart?.text) {
-                let out = _streamSmart.text;
-                // Honor a compact/max_lines budget on a large file: the stream
-                // already elided to head 200/tail 100; re-apply the tighter
-                // head+tail so the lead sees only the requested glance.
-                if (_readBudget) {
-                    // Use the file's REAL line count from the stream pass
-                    // (snapshotMeta.fileLineCount — the result has no top-level
-                    // totalLines), not the already-elided output's row count: the
-                    // re-budget marker otherwise reports "[TRUNCATED - 301 lines]"
-                    // for a 3800-line file.
-                    const _rebud = smartReadTruncate(out, _streamSmart.snapshotMeta?.fileLineCount || out.split('\n').length, st.size, filePath, _readBudget);
-                    if (_rebud?.truncated) out = _rebud.text;
-                }
+                const out = _streamSmart.text;
                 const snapshotMeta = _streamSmart.snapshotMeta || {
                     source: 'read_smart_stream',
                     ranges: [],
@@ -625,7 +593,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         // green-light an overwrite against bytes the read never returned.
         let _byteCapTruncated = false;
         const smart = (!hasRangeArgs && !wantFull && typeof smartReadTruncate === 'function')
-            ? smartReadTruncate(rendered, lineCount, st.size, filePath, _readBudget)
+            ? smartReadTruncate(rendered, lineCount, st.size, filePath)
             : null;
         let _smartTruncated = false;
         let _smartVisibleRanges = null;

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

@@ -79,34 +79,6 @@ async function _readReachPreflight(rawPath, workDir, helpers) {
     catch (e) { return `Error: ${e?.message || e}`; }
 }
 
-function capPositiveNumber(value, max, fallback = max) {
-    const n = Number(value);
-    if (!Number.isFinite(n) || n <= 0) return fallback;
-    return Math.min(max, Math.max(1, Math.trunc(n)));
-}
-
-function applyCompactReadBudget(entry) {
-    if (!entry || String(entry.budget || '').toLowerCase() !== 'compact') return entry;
-    const next = { ...entry };
-    const isFullMode = !next.mode || next.mode === 'full';
-    const hasLine = next.line !== undefined && next.line !== null;
-    const hasRange = next.offset !== undefined || next.limit !== undefined;
-    const hasPathLine = hasLineCoordinate(next.path);
-    if (hasLine && (next.context === undefined || next.context === null || Number(next.context) > 20)) {
-        next.context = 20;
-    }
-    if (hasRange && (next.limit === undefined || next.limit === null || Number(next.limit) > 120)) {
-        next.limit = 120;
-    }
-    if ((next.mode === 'head' || next.mode === 'tail') && (next.n === undefined || next.n === null || Number(next.n) > 80)) {
-        next.n = capPositiveNumber(next.n, 80, 80);
-    }
-    if (isFullMode && !hasLine && !hasRange && !hasPathLine && next.full !== true) {
-        next.mode = 'count';
-    }
-    return next;
-}
-
 export async function executeReadTool(args, workDir, readStateScope, executeChildBuiltinTool, options = {}, helpers = {}) {
     const {
         classifyResultKind,
@@ -217,10 +189,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             if (r?.line !== undefined) entry.line = r.line;
             if (r?.context !== undefined) entry.context = r.context;
             if (r?.full !== undefined) entry.full = r.full;
-            if (r?.budget !== undefined) entry.budget = r.budget;
-            entry = applyCompactReadBudget(entry);
             entry = normaliseReadLineWindowArgs(entry, workDir);
-            entry = applyCompactReadBudget(entry);
             return entry;
         });
         const _invertedRawEntry = rawEntries.find((e) => e && e._invertedRangeError);
@@ -269,10 +238,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             if (args.line !== undefined) entry.line = args.line;
             if (args.context !== undefined) entry.context = args.context;
             if (args.full !== undefined) entry.full = args.full;
-            if (args.budget !== undefined) entry.budget = args.budget;
-            entry = applyCompactReadBudget(entry);
             entry = normaliseReadLineWindowArgs(entry, workDir);
-            entry = applyCompactReadBudget(entry);
             return entry;
         });
         const _invertedStrEntry = entries.find((e) => e && e._invertedRangeError);
@@ -450,9 +416,9 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         args.path = normalizeInputPath(args.path);
         // Symbol reads are span-driven. Models (notably gpt-5.5) co-send the whole
         // schema filled with placeholder/zero values (offset:0, limit:0, line:0,
-        // context:0, pages:'', max_lines:0, mode, budget) alongside symbol, which
+        // context:0, pages:'', mode) alongside symbol, which
         // otherwise makes the symbol branch think a window was requested and falls
-        // back to a 0-window read. Treat those zero/empty/mode/budget params as
+        // back to a 0-window read. Treat those zero/empty/mode params as
         // absent so the whole symbol body returns in ONE call; a MEANINGFUL window
         // (offset>0 / limit>0 / non-empty pages / real line) is kept and overrides.
         if (typeof args.symbol === 'string' && args.symbol.trim()) {
@@ -460,11 +426,8 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             if (args.limit === 0) delete args.limit;
             if (args.line === 0) delete args.line;
             if (args.pages === '') delete args.pages;
-            if (args.max_lines === 0) delete args.max_lines;
-            if (args.budget !== undefined) delete args.budget;
             if (args.mode !== undefined) delete args.mode;
         }
-        args = applyCompactReadBudget(args);
         const sym = typeof args.symbol === 'string' ? args.symbol.trim() : '';
         if (sym) {
             const hasOffset = args.offset !== undefined && args.offset !== null;
@@ -515,7 +478,6 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         }
         args = normaliseReadLineWindowArgs(args, workDir);
         if (args._invertedRangeError) return args._invertedRangeError;
-        args = applyCompactReadBudget(args);
     }
     // Mode routing. A window already dropped any conflicting head/tail/summary
     // glance above (so the window is served by executeSingleReadTool); what

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

@@ -1,15 +1,105 @@
-import { spawn, execFileSync } from 'child_process';
+import { spawn, execFile } from 'child_process';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { startChildGuardian } from '../../../../shared/child-guardian.mjs';
+import { promisify } from 'node:util';
+import os from 'node:os';
+import { acquire as acquireChildSpawnSlot } from '../../../../shared/child-spawn-gate.mjs';
+
+const execFileAsync = promisify(execFile);
+
+// ── rg orphan-reap policy (accepted risk) ────────────────────────────────
+// The previous design started a 1:1 node child-guardian per rg spawn so a
+// hard daemon kill (SIGKILL, no chance to run our own cleanup) could not leave
+// an rg orphaned. That per-process guardian is exactly what over-saturated the
+// box (each grep doubled the process count), so it has been REMOVED here and
+// deliberately NOT replaced with another per-rg guardian.
+//
+// Accepted residual risk: on a hard daemon SIGKILL an in-flight rg can briefly
+// outlive the daemon. This is judged acceptable because (a) on every NORMAL
+// path rg is reaped by this module's own timeout → SIGTERM → grace → force-kill
+// plus the force-settle backstop, so it is always collected when the daemon is
+// alive to settle the promise; (b) rg is a short-lived, self-terminating
+// (bounded by the 20s timeout) read-only process, not a long-running server; a
+// stray instance exits on its own shortly after. A shared/OS-job-based reaper
+// (one guardian for the whole daemon, or a Windows Job Object / POSIX process
+// group kill on daemon teardown) is the right long-term fix but is out of scope
+// for this change and intentionally not added per-spawn.
+
+// ── rg --threads cap ─────────────────────────────────────────────────────
+// Each rg process otherwise fans out across EVERY core; with several agents
+// running grep at once the box over-saturates and the whole batch trips the
+// 20s deadline together. Cap rg's worker threads to a fraction of the host so
+// concurrent greps share the machine. Internal dynamic default; env override
+// only — deliberately NOT exposed on any tool schema / parameter surface.
+function _rgThreadCap() {
+    const override = Number(process.env.MIXDOG_RG_THREADS);
+    if (Number.isFinite(override) && override >= 1) return Math.floor(override);
+    let cpus = 0;
+    try { cpus = os.cpus()?.length || 0; } catch { cpus = 0; }
+    return Math.max(2, Math.ceil((cpus || 4) / 4));
+}
+
+// Single source of truth for "did the caller already pin rg's thread count?".
+// Detects every form rg accepts: separated (`-j`, `--threads`) where the count
+// is the NEXT arg, short-attached (`-j8`), and long-attached (`--threads=8`).
+// Used by both the _withRgThreads injection guard and the EAGAIN retry guard
+// so the two never disagree.
+function _hasRgThreadArg(argsList) {
+    for (const a of argsList) {
+        if (typeof a !== 'string') continue;
+        if (a === '-j' || a === '--threads') return true;
+        if (/^-j\d+$/.test(a)) return true;
+        if (a.startsWith('--threads=')) return true;
+    }
+    return false;
+}
+
+// Inject `--threads N` unless the caller already pinned thread count
+// (`-j`/`--threads`/`-jN`/`--threads=N`, e.g. the EAGAIN `-j 1` retry). Does
+// not mutate; may return the ORIGINAL array unchanged when already
+// thread-pinned (callers must not assume a fresh copy).
+function _withRgThreads(argsList) {
+    if (_hasRgThreadArg(argsList)) return argsList;
+    return ['--threads', String(_rgThreadCap()), ...argsList];
+}
+
+// Build the EAGAIN single-thread retry args. If the caller already pinned a
+// thread count we strip the existing flag(s) first, then prepend `-j 1`, so the
+// retry is unambiguously single-threaded (never `-j 8 ... -j 1`). Drops both the
+// separated form (`-j N` / `--threads N` → flag + following count) and the
+// attached forms (`-jN` / `--threads=N`).
+function _rgEagainRetryArgs(argsList) {
+    const out = [];
+    for (let i = 0; i < argsList.length; i++) {
+        const a = argsList[i];
+        if (a === '-j' || a === '--threads') { i++; continue; } // skip flag + its count
+        if (typeof a === 'string' && (/^-j\d+$/.test(a) || a.startsWith('--threads='))) continue;
+        out.push(a);
+    }
+    return ['-j', '1', ...out];
+}
+
+// True only when the args are ALREADY exactly single-threaded — i.e. an EAGAIN
+// retry would change nothing. Matches the separated `-j 1` / `--threads 1` form
+// and the attached `-j1` / `--threads=1` form. Any other thread pin (e.g. -j8)
+// is NOT "single-thread pinned": the retry should still run and downshift it.
+function _isRgSingleThreadPinned(argsList) {
+    for (let i = 0; i < argsList.length; i++) {
+        const a = argsList[i];
+        if (typeof a !== 'string') continue;
+        if ((a === '-j' || a === '--threads') && String(argsList[i + 1]).trim() === '1') return true;
+        if (a === '-j1' || a === '--threads=1') return true;
+    }
+    return false;
+}
 
 let _rgExecutableResolved = null;
 
-function _resolveRgExecutable() {
+async function _resolveRgExecutable() {
     const isWin = process.platform === 'win32';
     try {
         const cmd = isWin ? 'where' : 'which';
-        const out = execFileSync(cmd, ['rg'], { encoding: 'utf8', windowsHide: true }).trim();
+        const { stdout: out } = await execFileAsync(cmd, ['rg'], { encoding: 'utf8', windowsHide: true });
         const first = out.split(/\r?\n/).map((l) => l.trim()).find(Boolean);
         if (first && existsSync(first)) return first;
     } catch { /* fall through to PATH scan */ }
@@ -33,11 +123,27 @@ function _resolveRgExecutable() {
     return 'rg';
 }
 
+// Synchronous accessor for the spawn call sites — only valid AFTER
+// ensureRgResolved() has run (runRg/runRgWindowedLines await it first). Falls
+// back to the bare 'rg' if somehow called before resolution.
 function rgExecutable() {
-    if (_rgExecutableResolved === null) {
-        _rgExecutableResolved = _resolveRgExecutable();
+    return _rgExecutableResolved ?? 'rg';
+}
+
+// Async resolver: the `where`/`which` lookup used to run via execFileSync,
+// blocking the event loop ~90ms on the first grep/glob/find of a session
+// (freezing the TUI). Resolve asynchronously and cache the result; subsequent
+// calls return immediately.
+let _rgResolvePromise = null;
+async function ensureRgResolved() {
+    if (_rgExecutableResolved !== null) return _rgExecutableResolved;
+    if (!_rgResolvePromise) {
+        _rgResolvePromise = _resolveRgExecutable().then((resolved) => {
+            _rgExecutableResolved = resolved;
+            return resolved;
+        });
     }
-    return _rgExecutableResolved;
+    return _rgResolvePromise;
 }
 
 // When _resolveRgExecutable() exhausts `where`/`which` and the PATH scan and
@@ -48,13 +154,13 @@ function rgExecutable() {
 const RG_FALLBACK_FAIL_TTL_MS = 30000;
 let _rgFallbackUsable = null;
 let _rgFallbackFailAt = 0;
-function rgFallbackUsable() {
+async function rgFallbackUsable() {
     if (_rgFallbackUsable === true) return true;
     if (_rgFallbackUsable === false && (Date.now() - _rgFallbackFailAt) < RG_FALLBACK_FAIL_TTL_MS) {
         return false;
     }
     try {
-        execFileSync('rg', ['--version'], { stdio: 'ignore', windowsHide: true, timeout: 3000 });
+        await execFileAsync('rg', ['--version'], { windowsHide: true, timeout: 3000 });
         _rgFallbackUsable = true;
     } catch {
         _rgFallbackUsable = false;
@@ -65,10 +171,11 @@ function rgFallbackUsable() {
 
 // Throws a clear error only when the bare 'rg' fallback was reached AND it is
 // not actually runnable. A real resolved path short-circuits with no probe, so
-// behavior is unchanged whenever rg exists.
-function assertRgAvailable() {
-    if (rgExecutable() !== 'rg') return;
-    if (rgFallbackUsable()) return;
+// behavior is unchanged whenever rg exists. Async so the underlying lookups
+// (`where`/`which`, `rg --version`) never block the event loop.
+async function assertRgAvailable() {
+    if (await ensureRgResolved() !== 'rg') return;
+    if (await rgFallbackUsable()) return;
     const e = new Error('ripgrep (rg) not found on PATH — install ripgrep or add it to PATH');
     e.code = 'ERG_NOT_FOUND';
     throw e;
@@ -168,14 +275,19 @@ function _armRgForceSettle({ timeoutMs, isSettled, timers, proc, onForceSettle }
 // surfaced as empty stdout so callers can render "(no matches)" uniformly.
 function spawnRg(argsList, execOptions) {
     const timeoutMs = Number(execOptions?.timeout ?? 20000);
-    return new Promise((resolve, reject) => {
-        const proc = spawn(rgExecutable(), argsList, {
+    const gateSignal = execOptions?.abortSignal || execOptions?.signal || null;
+    // Gate the spawn (not the whole call) so over-saturation queues here while
+    // the cap's worth of rg keep running. The rg timeout timer is armed AFTER
+    // spawn below, so queue-wait time is excluded from the 20s deadline. No
+    // node guardian is started: rg owns its full SIGTERM→grace→force-kill +
+    // force-settle teardown, so the 1:1 guardian process was pure overhead.
+    return acquireChildSpawnSlot(gateSignal).then((releaseSlot) => new Promise((resolve, reject) => {
+        const proc = spawn(rgExecutable(), _withRgThreads(argsList), {
             cwd: execOptions?.cwd,
             env: execOptions?.env || process.env,
             windowsHide: true,
             stdio: ['ignore', 'pipe', 'pipe'],
         });
-        startChildGuardian({ childPid: proc.pid, label: 'rg-runner' });
         let stdout = '';
         let stderr = '';
         let timedOut = false;
@@ -282,17 +394,23 @@ function spawnRg(argsList, execOptions) {
             e.stderr = stderr;
             reject(e);
         });
-    });
+    // Release the gate slot exactly once on ANY settle path (resolve/reject:
+    // close, error, or force-settle). releaseSlot is idempotent.
+    }).finally(() => releaseSlot()));
 }
 
 export async function runRg(argsList, execOptions = {}) {
-    assertRgAvailable();
+    await assertRgAvailable();
     try {
         return await spawnRg(argsList, execOptions);
     } catch (err) {
         const msg = String(err?.message || err?.stderr || '');
-        if (/EAGAIN/i.test(msg) && !argsList.includes('-j')) {
-            return spawnRg(['-j', '1', ...argsList], execOptions);
+        // Retry single-threaded on EAGAIN. Skip only when the caller already
+        // pinned threads AND that pin is already -j 1 (nothing to gain); any
+        // other pin (-j8/--threads=N) is rewritten to a clean -j 1 by
+        // _rgEagainRetryArgs so we never emit conflicting thread flags.
+        if (/EAGAIN/i.test(msg) && !_isRgSingleThreadPinned(argsList)) {
+            return spawnRg(_rgEagainRetryArgs(argsList), execOptions);
         }
         throw err;
     }
@@ -304,14 +422,17 @@ function spawnRgWindowedLines(argsList, execOptions, opts = {}) {
     const lineLimit = Number.isFinite(opts.limit) ? Math.max(0, Math.floor(Number(opts.limit) || 0)) : Infinity;
     const summaryLimit = Math.max(0, Math.floor(Number(opts.summaryLimit) || 0));
     const collectLimit = lineLimit === Infinity ? Infinity : Math.max(lineLimit, summaryLimit);
-    return new Promise((resolve, reject) => {
-        const proc = spawn(rgExecutable(), argsList, {
+    const gateSignal = execOptions?.abortSignal || execOptions?.signal || null;
+    // Same gate + thread-cap + no-guardian treatment as spawnRg; queue-wait is
+    // excluded from the rg timeout (armed after spawn). releaseSlot is fired
+    // once via .finally on every settle path.
+    return acquireChildSpawnSlot(gateSignal).then((releaseSlot) => new Promise((resolve, reject) => {
+        const proc = spawn(rgExecutable(), _withRgThreads(argsList), {
             cwd: execOptions?.cwd,
             env: execOptions?.env || process.env,
             windowsHide: true,
             stdio: ['ignore', 'pipe', 'pipe'],
         });
-        startChildGuardian({ childPid: proc.pid, label: 'rg-runner-windowed' });
         let buffer = '';
         let stderr = '';
         let skipped = 0;
@@ -448,17 +569,17 @@ function spawnRgWindowedLines(argsList, execOptions, opts = {}) {
             e.stderr = stderr;
             reject(e);
         });
-    });
+    }).finally(() => releaseSlot()));
 }
 
 export async function runRgWindowedLines(argsList, execOptions = {}, opts = {}) {
-    assertRgAvailable();
+    await assertRgAvailable();
     try {
         return await spawnRgWindowedLines(argsList, execOptions, opts);
     } catch (err) {
         const msg = String(err?.message || err?.stderr || '');
-        if (/EAGAIN/i.test(msg) && !argsList.includes('-j')) {
-            return spawnRgWindowedLines(['-j', '1', ...argsList], execOptions, opts);
+        if (/EAGAIN/i.test(msg) && !_isRgSingleThreadPinned(argsList)) {
+            return spawnRgWindowedLines(_rgEagainRetryArgs(argsList), execOptions, opts);
         }
         throw err;
     }

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

@@ -114,13 +114,13 @@ export function buildGrepRgArgs(parts) {
     return rgArgs;
 }
 
-export function buildGlobCacheKey({ patterns, basePath, headLimit, offset, extraIgnore }) {
+export function buildGlobCacheKey({ patterns, basePath, headLimit, offset, extraIgnore, sort }) {
     // extraIgnore (rg ignore globs from _extraIgnoreDirs) alters which files
     // match, so it MUST partake in the key — otherwise calls that differ only
     // by extra ignores collide and return stale over-/under-filtered results.
     // Sorted so the same ignore set in any order maps to one key.
     const extra = Array.isArray(extraIgnore) && extraIgnore.length ? [...extraIgnore].sort().join('\x01') : '';
-    return ['glob', patterns.join('\x01'), basePath, headLimit ?? '', offset ?? '', extra].join('|');
+    return ['glob', patterns.join('\x01'), basePath, headLimit ?? '', offset ?? '', sort || 'natural', extra].join('|');
 }
 
 export function buildListCacheKey(parts) {