mixdog 0.9.90 → 0.9.91

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -5,7 +5,8 @@
 // pass), and unrecoverable errors throw. Behavior identical to the inline
 // try/catch it replaced.
 import { appendAgentTrace } from '../agent-trace.mjs';
-import { isContextOverflowError } from '../providers/retry-classifier.mjs';
+import { classifyError, isContextOverflowError } from '../providers/retry-classifier.mjs';
+import { setTimeout as sleepMs } from 'timers/promises';
 import { readStreamOutcome } from '../providers/lib/stream-outcome.mjs';
 import { resolveWorkerCompactPolicy } from './loop/compact-policy.mjs';
 import { agentContextOverflowError } from './loop/context-overflow.mjs';
@@ -35,21 +36,96 @@ function normalizedIncompleteUsage(raw) {
     };
 }
 
+// Loop-level transport replay (codex retry_transport parity). The provider
+// layer already retries transient failures with a ~15s total envelope
+// (PROVIDER_RETRY_BACKOFF_MS); a real network blip (router/VPN flap — the
+// 2026-08-02 17:37 incident also dropped the Discord gateway) outlasts it and
+// used to surface as a failed turn. When the stream exposed NOTHING
+// (replaySafe: no relayed text/reasoning, no dispatched tool call), re-sending
+// the identical request is side-effect-free, so wait out the blip and retry
+// the send at the loop level. Two attempts, 5s/15s — combined with the
+// provider envelope this covers ~50s outages before failing honestly.
+const TRANSPORT_RETRY_BACKOFF_MS = Object.freeze([5_000, 15_000]);
+export const TRANSPORT_RETRY_MAX = TRANSPORT_RETRY_BACKOFF_MS.length;
+
 export async function sendWithRecovery(ctx) {
     const {
         provider, messages, model, sendTools, tools, opts,
         sessionId, sessionRef, nextIteration, contextOverflowRetryUsed,
+        transportRetriesUsed = 0, signal,
     } = ctx;
     let response;
+    // Bench-only turn timing (MIXDOG_TURN_TIMING=1): one stderr line per
+    // provider request — TTFT (first stream delta) and total stream time.
+    // Inert unless the env flag is set; used to profile harness vs model
+    // latency in Terminal-Bench runs.
+    const turnT0 = process.env.MIXDOG_TURN_TIMING === '1' ? Date.now() : 0;
+    let turnFirstDelta = 0;
+    let timedOpts = opts;
+    if (turnT0) {
+        const prevDelta = typeof opts?.onStreamDelta === 'function' ? opts.onStreamDelta : null;
+        timedOpts = {
+            ...(opts || {}),
+            onStreamDelta: (kind) => {
+                if (!turnFirstDelta) turnFirstDelta = Date.now();
+                if (prevDelta) prevDelta(kind);
+            },
+        };
+    }
+    const logTurnTiming = (status) => {
+        if (!turnT0) return;
+        const now = Date.now();
+        const ttft = turnFirstDelta ? turnFirstDelta - turnT0 : -1;
+        try {
+            console.error(`[turn-timing] status=${status} ttft=${ttft}ms total=${now - turnT0}ms model=${model}`);
+        } catch { /* logging must never break the send path */ }
+    };
+    // Loop-side exposure witness. Some providers throw truncation/stall
+    // errors that carry only partialContent — neither liveTextEmitted nor
+    // unsafeToRetry — so an outcome read from the ERROR alone can report
+    // replaySafe even though this very send already relayed text to the
+    // client through opts.onTextDelta, or dispatched a tool call through
+    // opts.onToolCall. Replaying such a send would duplicate output the user
+    // already saw (or re-run a side effect), so record what THIS send
+    // actually exposed and merge it into every outcome read below. The
+    // callbacks are wrapped in place and restored conditionally: the
+    // overflow-retry branch intentionally clears opts.onToolCall, and that
+    // clear must survive the restore.
+    const relayWitness = { textEmitted: false, toolCallsDispatched: 0 };
+    const prevOnTextDelta = typeof opts?.onTextDelta === 'function' ? opts.onTextDelta : null;
+    const prevOnToolCall = typeof opts?.onToolCall === 'function' ? opts.onToolCall : null;
+    const witnessedOnTextDelta = prevOnTextDelta
+        ? (...args) => {
+            if (typeof args[0] === 'string' && args[0].length > 0) relayWitness.textEmitted = true;
+            return prevOnTextDelta(...args);
+        }
+        : null;
+    const witnessedOnToolCall = prevOnToolCall
+        ? (...args) => {
+            relayWitness.toolCallsDispatched += 1;
+            return prevOnToolCall(...args);
+        }
+        : null;
+    if (opts) {
+        if (witnessedOnTextDelta) opts.onTextDelta = witnessedOnTextDelta;
+        if (witnessedOnToolCall) opts.onToolCall = witnessedOnToolCall;
+    }
+    if (timedOpts !== opts && timedOpts) {
+        if (witnessedOnTextDelta) timedOpts.onTextDelta = witnessedOnTextDelta;
+        if (witnessedOnToolCall) timedOpts.onToolCall = witnessedOnToolCall;
+    }
+    try {
         try {
-            response = await provider.send(messages, model, sendTools.length ? sendTools : undefined, opts);
+            response = await provider.send(messages, model, sendTools.length ? sendTools : undefined, timedOpts);
+            logTurnTiming('ok');
         } catch (sendErr) {
+            logTurnTiming(`err:${sendErr?.code || sendErr?.name || 'unknown'}`);
             // Canonical stream outcome: ONE fail-closed read of what the
             // provider stream actually produced (terminal vs continuation,
             // observed text/reasoning, partial/complete/dispatched tool calls).
             // Every branch below consumes it instead of re-inferring safety
             // from provider-specific flags.
-            const outcome = readStreamOutcome(sendErr);
+            const outcome = readStreamOutcome(sendErr, relayWitness);
             // Gemini REST/SDK reports MAX_TOKENS by throwing a typed
             // ProviderIncompleteError after preserving the streamed candidate.
             // Normalize only that exact, safe no-tool output-limit shape into a
@@ -185,6 +261,35 @@ export async function sendWithRecovery(ctx) {
                 };
                 return { action: 'proceed', response };
             } else
+            // Clean transient transport failure with zero exposure: replay the
+            // send after a bounded wait instead of failing the turn.
+            if (
+                transportRetriesUsed < TRANSPORT_RETRY_MAX
+                && outcome.replaySafe === true
+                && classifyError(sendErr) === 'transient'
+            ) {
+                const waitMs = TRANSPORT_RETRY_BACKOFF_MS[transportRetriesUsed];
+                try {
+                    process.stderr.write(
+                        `[loop] transient send failure with no observed output (sess=${sessionId || 'unknown'} `
+                        + `iter=${nextIteration} code=${sendErr?.code ?? sendErr?.status ?? 'n/a'}); `
+                        + `transport retry ${transportRetriesUsed + 1}/${TRANSPORT_RETRY_MAX} after ${waitMs}ms\n`,
+                    );
+                } catch { /* best-effort */ }
+                try {
+                    appendAgentTrace({
+                        kind: 'transport_retry',
+                        sessionId: sessionId || null,
+                        iteration: nextIteration,
+                        attempt: transportRetriesUsed + 1,
+                        waitMs,
+                        code: sendErr?.code ?? null,
+                        status: sendErr?.status ?? null,
+                    });
+                } catch { /* best-effort */ }
+                await sleepMs(waitMs, undefined, signal ? { signal } : undefined);
+                return { action: 'retry_transport' };
+            } else
             // Context-window-exceeded is a deterministic refusal from the API.
             // Recover context overflow reactively by compacting and retrying
             // in the same active turn. MixDog's proactive estimator can miss a
@@ -236,5 +341,13 @@ export async function sendWithRecovery(ctx) {
                 messageTokensEst: estimateMessagesTokensSafe(messages),
             }, sendErr);
         }
+    } finally {
+        // Conditional restore: only unwind our own wrappers. An intentional
+        // opts.onToolCall = undefined (overflow-retry branch) stays cleared.
+        if (opts) {
+            if (witnessedOnTextDelta && opts.onTextDelta === witnessedOnTextDelta) opts.onTextDelta = prevOnTextDelta;
+            if (witnessedOnToolCall && opts.onToolCall === witnessedOnToolCall) opts.onToolCall = prevOnToolCall;
+        }
+    }
     return { action: 'proceed', response };
 }

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

@@ -1,5 +1,5 @@
 import { getAbortSignalForSession } from '../../session/abort-lookup.mjs';
-import { execShellCommand, stripAnsi } from '../shell-command.mjs';
+import { acquireShellLeaseBounded, execShellCommand, stripAnsi } from '../shell-command.mjs';
 import { wrapCommandWithSnapshot } from '../shell-snapshot.mjs';
 import { getDestructiveCommandWarning } from '../destructive-warning.mjs';
 import { maybeRewriteWmicProcessCommand } from '../shell-policy.mjs';
@@ -21,6 +21,11 @@ import {
 } from './shell-jobs.mjs';
 import {
     analyzeShellCommandEffects,
+    buildPowerShellFilterTeePlan,
+    consumeFilterTeeCapture,
+    detectBlockedSleepPattern,
+    detectLongForegroundReason,
+    extractShellApplyPatchInvocation,
     foregroundLongCommandHint,
     isAutobackgroundingAllowed,
     preflightPowerShellHygiene,
@@ -241,7 +246,7 @@ export async function executeBashTool(args, workDir, options = {}) {
     const bashWorkDir = resolveSessionCwd(_sessionCwdKey, _hasExplicitCwd ? cwdResult.cwd : null, cwdResult.cwd);
     const _readStateScope = options?.readStateScope ?? options?.sessionId ?? null;
     const executionMode = resolveExecutionMode(args || {}, args?.run_in_background === true ? 'async' : 'sync');
-    const runInBackground = executionMode === 'async';
+    let runInBackground = executionMode === 'async';
 
     // Run hard-block policy BEFORE branching into the persistent-shell tool.
     // The persistent path used to bypass the one-shot block scan because the
@@ -251,6 +256,21 @@ export async function executeBashTool(args, workDir, options = {}) {
     // decode + rm token guard; calling it here applies the same allowlist
     // to both persistent and stateless paths.
     const _rawCmd = String(args && args.command != null ? args.command : '');
+    // Codex-parity: `apply_patch` typed into the shell (heredoc/argument/bare
+    // patch forms) routes to the internal patch engine instead of failing as
+    // an unknown binary. Runs BEFORE the exec-policy scan so patch BODY lines
+    // (e.g. `+ rm -rf …`) are never misread as shell commands. Dynamic import
+    // avoids a bash-tool <-> patch/orchestrator module cycle.
+    if (_rawCmd) {
+        const _apCall = extractShellApplyPatchInvocation(_rawCmd);
+        if (_apCall?.error) {
+            return formatShellToolFailure(`${_apCall.error}. Call the apply_patch tool with the patch string instead of the shell.`);
+        }
+        if (_apCall?.patch) {
+            const { executePatchTool } = await import('../patch/orchestrator.mjs');
+            return executePatchTool('apply_patch', { patch: _apCall.patch }, bashWorkDir, options);
+        }
+    }
     if (_rawCmd) {
         // R5-③: persistent:true used to route into bash_session BEFORE the
         // stripQuotedAndHeredoc / extractShellCInner / unquote sweep ran
@@ -339,6 +359,29 @@ export async function executeBashTool(args, workDir, options = {}) {
         return formatShellToolFailure(_execPolicyBlock);
     }
 
+    // Sleep-chain auto-promotion: a leading `sleep N && …` / `Start-Sleep N; …`
+    // used to be DENIED preflight (CC detectBlockedSleepPattern parity).
+    // Measured over 10 days the deny fired 46× and every hit was a wasted
+    // turn, so the command is promoted to a background task instead — the
+    // exact remedy the deny message pointed at, without the failure. Only
+    // possible while background tasks are enabled; with them disabled the
+    // command runs foreground as before (the deny never fired there either).
+    const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
+        String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
+    );
+    let autoAsyncReason = '';
+    if (!runInBackground && !_bgTasksDisabled) {
+        // Long-foreground shapes (watch-like dev servers/watchers, 30s+ sleeps
+        // anywhere in the chain) used to hard-fail via foregroundLongCommandHint
+        // (~22 wasted turns/14d measured). Promote them to a background task —
+        // the exact remedy the deny message pointed at — same as sleep chains.
+        const _blockedSleep = detectBlockedSleepPattern(command) || detectLongForegroundReason(command);
+        if (_blockedSleep) {
+            runInBackground = true;
+            autoAsyncReason = _blockedSleep;
+        }
+    }
+
     let shellEffects;
     let combinedBashAbort = null;
     try {
@@ -372,9 +415,6 @@ export async function executeBashTool(args, workDir, options = {}) {
         : DEFAULT_BASH_TIMEOUT_MS;
     const hasExplicitTimeout = typeof args.timeout === 'number' && args.timeout > 0;
     const timeoutMs = hasExplicitTimeout ? args.timeout : defaultTimeoutMs;
-    const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
-        String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
-    );
     const backgroundOnTimeout = !runInBackground
         && !_bgTasksDisabled
         && isAutobackgroundingAllowed(command, resolvedSpec.shellType);
@@ -429,11 +469,20 @@ export async function executeBashTool(args, workDir, options = {}) {
         scrubLoaderVars(spawnEnv);
         scrubRuntimeRootVars(spawnEnv);
         let wrappedCommand;
+        let _teePlan = null;
         // PowerShell UTF-8 prefix is PS-only: the Windows Git Bash path
         // (shellType==='posix') must NOT receive it. Snapshot wrapper stays
         // POSIX-host-only for now — no snapshot for Windows Git Bash initially.
         if (process.platform === 'win32' && shellType === 'powershell') {
-            wrappedCommand = _prefixPowerShellUtf8(command);
+            // Filter-swallow rescue (sync path only): tee the unfiltered
+            // producer stream of an exactly-recognized filter pipeline so a
+            // failing run can attach the original output tail in THIS call
+            // instead of returning `[exit code: N]` + `(no output)`. Any
+            // ambiguity yields a null plan and the command runs untouched.
+            if (!runInBackground) {
+                try { _teePlan = buildPowerShellFilterTeePlan(command); } catch { _teePlan = null; }
+            }
+            wrappedCommand = _prefixPowerShellUtf8(_teePlan ? _teePlan.command : command);
         } else if (process.platform !== 'win32' && (shell.includes('bash') || shell.includes('zsh'))) {
             try {
                 wrappedCommand = await wrapCommandWithSnapshot(shell, command);
@@ -451,8 +500,8 @@ export async function executeBashTool(args, workDir, options = {}) {
             let asyncLease = null;
             let job;
             try {
-                asyncLease = await (options?.resourceAdmission || resourceAdmission).acquire('shell', {
-                    signal: combinedAsyncAbort.signal,
+                asyncLease = await acquireShellLeaseBounded(options?.resourceAdmission || resourceAdmission, {
+                    abortSignal: combinedAsyncAbort.signal,
                     label: String(command).replace(/\s+/g, ' ').slice(0, 120),
                     dependency: 'detached',
                 });
@@ -525,7 +574,10 @@ export async function executeBashTool(args, workDir, options = {}) {
                         clientHostPid: options?.clientHostPid,
                     });
                 } catch { /* watcher arm is best-effort; never blocks the spawn */ }
-                return _prependDestructiveWarning(command, renderBackgroundTask(task));
+                const _autoAsyncNote = autoAsyncReason
+                    ? `[auto-async] ${autoAsyncReason} — promoted to a background task; act on its completion notification instead of blocking (do not poll).\n`
+                    : '';
+                return _prependDestructiveWarning(command, _autoAsyncNote + renderBackgroundTask(task));
             } catch (error) {
                 if (job?.jobId && !job.error) {
                     try { killShellJob(job.jobId); } catch {}
@@ -643,6 +695,17 @@ export async function executeBashTool(args, workDir, options = {}) {
         const benignExitOne = _isBenignSearchExitOne(command, exitCode, signal, stderr);
         const shellRunFailed = !shellToolFailed && (!!signal || (exitCode !== 0 && exitCode !== null && !benignExitOne));
         const isReallyErrored = shellToolFailed || shellRunFailed;
+        // Filter-swallow rescue: the tee file is ALWAYS consumed (deleted)
+        // here; its tail is attached only when the run failed with an empty
+        // visible capture — the exact `(no output)` shape that previously
+        // cost the model extra diagnostic turns.
+        let _rescueNote = '';
+        if (_teePlan) {
+            const _rescueTail = consumeFilterTeeCapture(_teePlan.teePath);
+            if (isReallyErrored && _rescueTail && !stdout.trim() && !stderr.trim()) {
+                _rescueNote = `\n\n[filter-swallowed output rescue] the command failed but its trailing filter(s) matched nothing, so the visible output was empty. Unfiltered pipeline output (tail):\n${smartMiddleTruncate(_rescueTail)}`;
+            }
+        }
         const _driftNote = '';
         // Distinct timeout marker so callers see "killed by timeout after Nms"
         // vs an external signal (e.g. user Ctrl-C, OOM kill). result.timedOut
@@ -666,7 +729,7 @@ export async function executeBashTool(args, workDir, options = {}) {
             // cross-stream interleaving. Acceptable for most diagnostic
             // outputs; flag in shell-command if exact interleaving is required.
             const merged = stdout + stderr;
-            if (statusMarker) return _prependDestructiveWarning(command, errorPrefix + smartMiddleTruncate(`${statusMarker}\n\n${merged || '(no output)'}`) + _driftNote);
+            if (statusMarker) return _prependDestructiveWarning(command, errorPrefix + smartMiddleTruncate(`${statusMarker}\n\n${merged || '(no output)'}`) + _rescueNote + _driftNote);
             return _prependDestructiveWarning(command, smartMiddleTruncate(merged || '(no output)') + _driftNote);
         }
         const truncatedStdout = smartMiddleTruncate(stdout);
@@ -688,7 +751,7 @@ export async function executeBashTool(args, workDir, options = {}) {
         const warningBlock = [
             wmicRewrite?.note || '',
         ].filter(Boolean).join('\n');
-        const payload = `${body}${stderrBlock}${spillBlock}${_driftNote}`;
+        const payload = `${body}${stderrBlock}${spillBlock}${_rescueNote}${_driftNote}`;
         if (statusMarker) return _prependDestructiveWarning(command, _composeShellFailure(statusMarker, errorPrefix, warningBlock, payload));
         return _prependDestructiveWarning(command, warningBlock ? `${warningBlock}\n${payload}` : payload);
     }

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

@@ -65,7 +65,7 @@ export const BUILTIN_TOOLS = [
                     description: 'File path, or {path,offset,limit}[] regions. Pass real arrays, not JSON strings.',
                 },
                 offset: { type: 'number', minimum: 0, description: 'Lines to skip.' },
-                limit: { type: 'number', minimum: 1, description: 'Max lines after offset.' },
+                limit: { type: 'number', minimum: 1, description: 'Max lines after offset. Defaults to 2000.' },
             },
             required: ['path'],
         },
@@ -74,7 +74,7 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: 'Run programs/change state; not file inspection. Use async for sleep/watch/dev loops.'
+        description: 'Runs a shell command and returns its output. Use async for sleep/watch/dev loops.'
             + `${_shellSyntaxCheat} ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
         inputSchema: {
             type: 'object',
@@ -139,7 +139,7 @@ export const BUILTIN_TOOLS = [
                     description: 'Glob filter.',
                 },
                 output_mode: { type: 'string', enum: ['content_with_context', 'files_with_matches', 'count'], description: 'content_with_context (default); files_with_matches/count for existence.' },
-                head_limit: { type: 'number', minimum: 0, description: 'Max results.' },
+                head_limit: { type: 'number', minimum: 0, description: 'Max results. Defaults to 250; 0 = unlimited.' },
                 offset: { type: 'number', minimum: 0, description: 'Skip results for paging.' },
                 '-C': { type: 'number', minimum: 0, description: 'Lines before/after each match.' },
             },
@@ -171,7 +171,7 @@ export const BUILTIN_TOOLS = [
                     ],
                     description: 'Base directory(ies); path[] batches.',
                 },
-                head_limit: { type: 'number', description: 'Max entries.' },
+                head_limit: { type: 'number', description: 'Max entries. Defaults to 100; 0 = unlimited.' },
                 offset: { type: 'number', description: 'Skip entries.' },
             },
             required: ['pattern'],
@@ -193,7 +193,7 @@ export const BUILTIN_TOOLS = [
                     description: 'Partial path/name words; query[] batches.',
                 },
                 path: { type: 'string', description: 'Base directory.' },
-                head_limit: { type: 'number', description: 'Max paths.' },
+                head_limit: { type: 'number', description: 'Max paths. Defaults to 25.' },
             },
             required: ['query'],
         },
@@ -213,7 +213,7 @@ export const BUILTIN_TOOLS = [
                     ],
                     description: 'Directory; path[] batches.',
                 },
-                head_limit: { type: 'number', description: 'Max entries.' },
+                head_limit: { type: 'number', description: 'Max entries. Defaults to 200; 0 = no cap.' },
                 offset: { type: 'number', description: 'Skip N entries for paging.' },
             },
             required: [],

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

@@ -40,6 +40,18 @@ const FIND_WALK_TIMEOUT_MS = 20_000;
 const LIST_WALK_TIMEOUT_MS = 20_000;
 const LIST_ABSOLUTE_CAP = 50_000;
 
+// A/B override surface for the default result caps (stock: list/tree 200,
+// fuzzy find 25). Env-gated so bench variants can match competitor-style
+// generous caps without changing the shipped defaults.
+function _listDefaultHeadLimit(fallback) {
+    const parsed = parseInt(process.env.MIXDOG_LIST_DEFAULT_HEAD_LIMIT ?? '', 10);
+    return parsed > 0 ? parsed : fallback;
+}
+function _findDefaultHeadLimit(fallback) {
+    const parsed = parseInt(process.env.MIXDOG_FIND_DEFAULT_HEAD_LIMIT ?? '', 10);
+    return parsed > 0 ? parsed : fallback;
+}
+
 export async function executeListTool(args, workDir, options = {}) {
     args.path = coerceReadFamilyPathArg(args.path, workDir);
     if (Array.isArray(args.path)) {
@@ -108,7 +120,7 @@ export async function executeListTool(args, workDir, options = {}) {
     const hidden = Boolean(args.hidden);
     const sort = ['name', 'mtime', 'size'].includes(args.sort) ? args.sort : 'name';
     const typeFilter = ['any', 'file', 'dir'].includes(args.type) ? args.type : 'any';
-    const headLimit = normalizeListHeadLimit(args.head_limit, 200);
+    const headLimit = normalizeListHeadLimit(args.head_limit, _listDefaultHeadLimit(200));
     const offset = typeof args.offset === 'number' && args.offset > 0 ? args.offset : 0;
     const needsGlobalStat = sort === 'mtime' || sort === 'size';
     const includeNoise = Boolean(args.include_noise);
@@ -246,7 +258,7 @@ export async function executeTreeTool(args, workDir, options = {}) {
     const inputPath = args.path || '.';
     const depth = Math.min(Math.max(parseInt(args.depth ?? 3, 10) || 3, 1), 6);
     const hidden = Boolean(args.hidden);
-    const headLimit = normalizeListHeadLimit(args.head_limit, 200);
+    const headLimit = normalizeListHeadLimit(args.head_limit, _listDefaultHeadLimit(200));
     const offset = typeof args.offset === 'number' && args.offset > 0 ? args.offset : 0;
     const includeNoise = Boolean(args.include_noise);
     const _treeGuard = listGuardPath(inputPath);
@@ -589,7 +601,7 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     const includeNoise = Boolean(args.include_noise);
     // head_limit:0 means "no cap" per list semantics; default is intentionally
     // compact so ambiguous discovery does not dump a huge candidate list.
-    const headLimit = normalizeListHeadLimit(args.head_limit, 25);
+    const headLimit = normalizeListHeadLimit(args.head_limit, _findDefaultHeadLimit(25));
     const depth = args.depth != null ? Math.max(parseInt(args.depth, 10) || 1, 1) : null;
     const cacheKey = buildListCacheKey({
         mode: 'fuzzy_find',

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

@@ -3,6 +3,7 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { accessSync, constants, statSync } from 'node:fs';
 import { promisify } from 'node:util';
+import { createRequire } from 'node:module';
 import os from 'node:os';
 import {
     acquire as acquireChildSpawnSlot,
@@ -181,6 +182,14 @@ export async function _resolveRgExecutable() {
             if (existsSync(candidate) && _usableRgCandidate(candidate, isWin)) return candidate;
         }
     }
+    // Vendored fallback: the optional @vscode/ripgrep dependency ships a
+    // platform rg binary with the package, so a machine without system
+    // ripgrep still gets a working search family (grep/find/explore). System
+    // rg on PATH always wins above; this only fills the gap.
+    try {
+        const { rgPath } = createRequire(import.meta.url)('@vscode/ripgrep');
+        if (rgPath && _usableRgCandidate(String(rgPath), isWin)) return String(rgPath);
+    } catch { /* optional dependency absent — continue to where/which */ }
     try {
         const cmd = isWin ? 'where' : 'which';
         const { stdout: out } = await execFileAsync(cmd, ['rg'], { encoding: 'utf8', windowsHide: true });

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

@@ -103,6 +103,20 @@ import {
 } from './lib/grep-output.mjs';
 
 
+// Default grep result cap when head_limit is unspecified. 250 matches the
+// Claude Code default (GrepTool DEFAULT_HEAD_LIMIT); the tool-result offload
+// layer still bounds oversized results. MIXDOG_GREP_DEFAULT_HEAD_LIMIT
+// overrides for A/B runs.
+function _grepDefaultHeadLimit() {
+    const parsed = parseInt(process.env.MIXDOG_GREP_DEFAULT_HEAD_LIMIT ?? '', 10);
+    return parsed > 0 ? parsed : 250;
+}
+// Same A/B override surface for glob (stock default 100).
+function _globDefaultHeadLimit() {
+    const parsed = parseInt(process.env.MIXDOG_GLOB_DEFAULT_HEAD_LIMIT ?? '', 10);
+    return parsed > 0 ? parsed : 100;
+}
+
 export async function executeGrepTool(args, workDir, executeChildBuiltinTool, readStateScope = null, options = {}) {
     args = normalizeGrepArgs(args);
     args.path = coerceReadFamilyPathArg(args.path, workDir);
@@ -290,7 +304,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         return `Error: invalid head_limit ${JSON.stringify(headLimitRaw)}; expected a non-negative integer (0 = unlimited)`;
     }
     const headLimit = headLimitCoerced === null
-        ? 80
+        ? _grepDefaultHeadLimit()
         : (headLimitCoerced === 0 ? Infinity : headLimitCoerced);
     const offsetCoerced = coerceNonNegInt(args.offset);
     if (Number.isNaN(offsetCoerced)) {
@@ -988,7 +1002,7 @@ export async function executeGlobTool(args, workDir, options = {}) {
         return `Error: invalid head_limit ${JSON.stringify(headLimitRaw)}; expected a non-negative integer (0 = unlimited)`;
     }
     const headLimit = headLimitCoerced === null
-        ? 100
+        ? _globDefaultHeadLimit()
         : (headLimitCoerced === 0 ? Infinity : headLimitCoerced);
     const offsetCoerced = coerceNonNegInt(args.offset);
     if (Number.isNaN(offsetCoerced)) {