mixdog 0.9.90 → 0.9.92

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)) {

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

@@ -1,6 +1,8 @@
-import { statSync } from 'fs';
+import { closeSync, openSync, readSync, statSync, unlinkSync } from 'fs';
 import { assertPathReachable, assertPathsReachable } from './fs-reachability.mjs';
-import { isAbsolute, resolve } from 'path';
+import { isAbsolute, join, resolve } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
 import { WRAPPER_NAMES } from '../shell-policy.mjs';
 import {
     cwdRelativePath,
@@ -761,7 +763,10 @@ export async function analyzeShellCommandEffects(command, cwd) {
 // its deadline. Only the first top-level segment is considered — sleeps inside
 // pipelines/subshells/scripts are legitimate pacing and pass through. Float
 // durations (sleep 0.5) are allowed, mirroring the reference CLI.
-function detectBlockedSleepPattern(command) {
+// Exported: bash-tool promotes a detected sleep-chain to a background task
+// BEFORE foregroundLongCommandHint runs, so in the one-shot shell path this
+// deny only survives for callers that do not promote (task-tool preflight).
+export function detectBlockedSleepPattern(command) {
     const cmd = String(command || '').trim();
     if (!cmd) return null;
     const sep = cmd.match(/&&|\|\||;|\|/);
@@ -782,22 +787,62 @@ function detectBlockedSleepPattern(command) {
     return rest ? `sleep ${secs} followed by: ${rest.slice(0, 80)}` : `standalone sleep ${secs}`;
 }
 
-export function foregroundLongCommandHint(command, timeoutMs, args = {}, opts = {}) {
-    if (args.run_in_background === true) return '';
-    const cmd = String(command || '').trim();
-    if (!cmd) return '';
-    // CC validateInput parity: block only while background tasks are enabled —
-    // the remedy we point at (async mode / completion notification) must exist.
-    if (opts.backgroundTasksDisabled !== true) {
-        const blocked = detectBlockedSleepPattern(cmd);
-        if (blocked) {
-            return `Error: blocked — ${blocked}. Run blocking commands as a background task (mode:"async") and act on the completion notification, or use task wait on an existing task_id. If you genuinely need a delay (rate limiting, pacing), keep it under 2 seconds.`;
+// Codex-parity shell interception (core maybe_parse_apply_patch_verified):
+// codex-trained models type `apply_patch <<'EOF' … EOF` INTO THE SHELL. No
+// such binary exists here, so the invocation is extracted and routed to the
+// internal apply_patch engine instead of dying as "command not found".
+// Returns null when the command is not an apply_patch invocation, { patch }
+// when one was extracted, or { error } for a recognized-but-malformed call.
+export function extractShellApplyPatchInvocation(command) {
+    let cmd = String(command || '').trim();
+    if (!cmd) return null;
+    // Unwrap one `bash|sh|zsh -lc '<script>'` / `-c "<script>"` layer.
+    const wrap = /^(?:bash|sh|zsh)\s+-l?c\s+(['"])([\s\S]*)\1\s*$/.exec(cmd);
+    if (wrap) cmd = wrap[2].trim();
+    // A bare patch pasted into the shell (codex ImplicitInvocation case) is
+    // unambiguous — route it to the engine directly.
+    if (cmd.startsWith('*** Begin Patch')) return { patch: cmd };
+    if (!/^apply_patch(?:\s|$)/.test(cmd)) return null;
+    const rest = cmd.slice('apply_patch'.length).trim();
+    // Heredoc form: apply_patch <<'EOF' \n <patch> \n EOF
+    const heredoc = /^<<-?\s*(['"]?)(\w+)\1\s*\n([\s\S]*)$/.exec(rest);
+    if (heredoc) {
+        const terminator = heredoc[2];
+        const lines = heredoc[3].split('\n');
+        const endIdx = lines.findIndex((l) => l.trim() === terminator);
+        const patch = (endIdx === -1 ? lines : lines.slice(0, endIdx)).join('\n').trim();
+        if (patch) return { patch };
+        return { error: 'apply_patch heredoc contained no patch body' };
+    }
+    // Single-argument form: apply_patch '<patch>' / "<patch>" / bare.
+    if (rest) {
+        const q = rest[0];
+        let patch = rest;
+        if ((q === "'" || q === '"') && rest.length >= 2 && rest.endsWith(q)) {
+            patch = rest.slice(1, -1);
+            if (q === '"') patch = patch.replace(/\\([\\"$`])/g, '$1');
+            else patch = patch.replace(/'\\''/g, "'");
         }
+        patch = patch.trim();
+        if (patch.startsWith('*** Begin Patch')) return { patch };
+        return { error: 'apply_patch argument did not contain a V4A patch (expected "*** Begin Patch")' };
     }
-    const longTimeout = Number(timeoutMs) >= 120_000;
+    return { error: 'apply_patch requires the patch text (heredoc or single argument)' };
+}
+
+// Watch-like / long-blocking-sleep detection shared by bash-tool's auto-async
+// promotion and foregroundLongCommandHint. Returns a short human reason when
+// the command would block the foreground for a long time (dev server, watcher,
+// or a 30s+ sleep anywhere in the chain), else null. bash-tool promotes these
+// to a background task instead of failing the call — measured 2026-08: the
+// old hard deny fired ~22×/14d and every hit was a wasted turn.
+export function detectLongForegroundReason(command) {
+    const cmd = String(command || '').trim();
+    if (!cmd) return null;
     const watchLike = /^\s*gh\s+run\s+watch(?:\s|$)/i.test(cmd)
         || /^\s*(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|watch|serve)(?:\s|$)/i.test(cmd)
         || /^\s*(?:vite|webpack-dev-server|next|nuxt|astro)\s+(?:dev|start)(?:\s|$)/i.test(cmd);
+    if (watchLike) return 'watch-like long-running command (dev server / watcher)';
     const longPowerShellSleep = [...cmd.matchAll(/\bStart-Sleep\b([^;&|\r\n]*)/gi)].some((m) => {
         const part = String(m[1] || '');
         const ms = part.match(/-(?:Milliseconds|m)\s+(\d+)/i);
@@ -806,8 +851,23 @@ export function foregroundLongCommandHint(command, timeoutMs, args = {}, opts =
         return sec ? Number(sec[1]) >= 30 : false;
     });
     const longSleep = /\bsleep\s+(?:[3-9]\d|\d{3,}|\d+[mh])\b/i.test(cmd) || longPowerShellSleep;
-    if (!watchLike && !longSleep) return '';
-    if (!longTimeout && !watchLike && !longSleep) return '';
+    if (longSleep) return 'long blocking sleep (30s+) in command';
+    return null;
+}
+
+export function foregroundLongCommandHint(command, timeoutMs, args = {}, opts = {}) {
+    if (args.run_in_background === true) return '';
+    const cmd = String(command || '').trim();
+    if (!cmd) return '';
+    // CC validateInput parity: block only while background tasks are enabled —
+    // the remedy we point at (async mode / completion notification) must exist.
+    if (opts.backgroundTasksDisabled !== true) {
+        const blocked = detectBlockedSleepPattern(cmd);
+        if (blocked) {
+            return `Error: blocked — ${blocked}. Run blocking commands as a background task (mode:"async") and act on the completion notification, or use task wait on an existing task_id. If you genuinely need a delay (rate limiting, pacing), keep it under 2 seconds.`;
+        }
+    }
+    if (!detectLongForegroundReason(cmd)) return '';
     return 'Error: long foreground command detected. Use mode:"async" (background task) or task wait instead of blocking sleeps/watch loops.';
 }
 
@@ -870,3 +930,103 @@ export function isAutobackgroundingAllowed(command, shellType) {
     }
     return true;
 }
+
+// ---------------------------------------------------------------------------
+// Filter-swallow rescue (PowerShell one-shot path). Measured 2026-08: ~37
+// failures/14d were `<producer> 2>&1 | Select-String … | Select-Object …`
+// pipelines where the producer failed but the trailing filters matched
+// nothing — the model saw `[exit code: 1]` + `(no output)` and burned turns
+// re-running with different capture tricks. Plan: insert a Tee-Object spill
+// of the UNFILTERED producer stream so a failing run can attach the original
+// tail in the SAME call. Applies only to the exactly-recognized shape; any
+// ambiguity returns null and the original command runs untouched:
+//   - single-line command, no backticks / $( ) / ${ } / here-strings / procsub
+//   - no existing Tee-Object
+//   - last top-level segment is a byte-exact suffix of the command
+//   - >= 2 pipeline stages; stage 0 is NOT a pure filter; stages 1..n are ALL
+//     known pure pass-through filters; no stage redirects to a file
+// Tee-Object passes objects through unchanged and does not touch
+// $LASTEXITCODE, so success-path output and exit semantics are identical.
+const _PS_PURE_FILTER_HEADS = new Set([
+    'select-string', 'sls', 'select-object', 'select',
+    'where-object', 'where', 'foreach-object', '%', 'findstr',
+]);
+const _TEE_AMBIGUOUS_RE = /[`]|\$\(|\$\{|@['"]|<\(|>\(/;
+
+function _teeStageHead(tokens) {
+    return String(tokens?.[0] || '').toLowerCase().replace(/^.*[\\/]/, '').replace(/\.exe$/, '');
+}
+
+function _stageRedirectsToFile(tokens) {
+    for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i] === '>' || tokens[i] === '>>') {
+            const next = String(tokens[i + 1] || '');
+            if (!next.startsWith('&')) return true; // `> file` (2>&1-style stays allowed)
+        }
+    }
+    return false;
+}
+
+export function buildPowerShellFilterTeePlan(command) {
+    const cmd = String(command || '');
+    if (!cmd.trim()) return null;
+    if (/\r|\n/.test(cmd)) return null;
+    if (/tee-object/i.test(cmd)) return null;
+    if (_TEE_AMBIGUOUS_RE.test(cmd)) return null;
+    const segments = shellSplitSegments(cmd);
+    if (segments.length === 0) return null;
+    const last = segments[segments.length - 1];
+    const trimmed = cmd.trimEnd();
+    if (!trimmed.endsWith(last)) return null;
+    const stages = shellSplitPipelineSegments(last);
+    if (stages.length < 2) return null;
+    const tokenized = [];
+    for (const stage of stages) {
+        const tokens = shellTokenize(stage);
+        if (!tokens || tokens.length === 0) return null;
+        if (_stageRedirectsToFile(tokens)) return null;
+        const stripped = stripShellProbeWrappers(tokens);
+        if (stripped.length === 0) return null;
+        tokenized.push(stripped);
+    }
+    if (_PS_PURE_FILTER_HEADS.has(_teeStageHead(tokenized[0]))) return null;
+    for (let i = 1; i < tokenized.length; i++) {
+        if (!_PS_PURE_FILTER_HEADS.has(_teeStageHead(tokenized[i]))) return null;
+    }
+    const teePath = join(tmpdir(), `mixdog-tee-${randomUUID().slice(0, 8)}.log`);
+    if (teePath.includes("'")) return null;
+    const head = trimmed.slice(0, trimmed.length - last.length);
+    const rewritten = `${head}${stages[0]} | Tee-Object -FilePath '${teePath}' | ${stages.slice(1).join(' | ')}`;
+    return { command: rewritten, teePath };
+}
+
+// Read the tail of a tee spill file (BOM-sniffed: Windows PowerShell 5.1
+// writes UTF-16LE, pwsh 7 writes UTF-8) and ALWAYS delete the file. Returns
+// null when the file is missing/empty/unreadable.
+export function consumeFilterTeeCapture(teePath, { maxBytes = 16384 } = {}) {
+    let out = null;
+    try {
+        const st = statSync(teePath);
+        if (st.size > 0) {
+            const fd = openSync(teePath, 'r');
+            try {
+                const bom = Buffer.alloc(2);
+                readSync(fd, bom, 0, 2, 0);
+                const utf16 = bom[0] === 0xff && bom[1] === 0xfe;
+                let start = Math.max(0, st.size - maxBytes);
+                if (utf16 && start % 2 === 1) start += 1;
+                const len = st.size - start;
+                const buf = Buffer.alloc(len);
+                readSync(fd, buf, 0, len, start);
+                out = buf.toString(utf16 ? 'utf16le' : 'utf8');
+                if (start === 0 && out.charCodeAt(0) === 0xfeff) out = out.slice(1);
+            } finally {
+                closeSync(fd);
+            }
+        }
+    } catch {
+        out = null;
+    }
+    try { unlinkSync(teePath); } catch { /* best-effort cleanup */ }
+    return out && out.trim() ? out : null;
+}

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

@@ -206,6 +206,11 @@ export async function executeTaskTool(args, options = {}) {
             // consumed synchronously, so no re-arm. Drop the persisted ctx here
             // or it leaks (cleanup only runs on a real watcher settle, which
             // never happens for a never-re-armed entry).
+            // EXCEPT when this wait's tool call was aborted: its result was
+            // discarded, so nobody consumed the outcome — re-arm so the
+            // watcher delivers the completion notification instead of
+            // swallowing it.
+            else if (options?.signal?.aborted) watchBackgroundShellJob(taskId);
             else clearShellJobNotifyCtx(taskId);
         }
     }

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

@@ -48,6 +48,12 @@ const EXPECTED_ARGS = Object.freeze(['-NoLogo', '-NoProfile', '-NonInteractive',
 // with the same `$?`→0/1 exit mapping pwsh -Command applies implicitly, then
 // emits `<<<MIXDOG_DONE_<nonce>:<code>>>>` on stdout and
 // `<<<MIXDOG_DONE_<nonce>>>>` on stderr (both streams provably drained).
+// Each command pipes through Microsoft.PowerShell.Core\Out-Default: the whole
+// marker loop is ONE top-level pipeline, so without an explicit per-command
+// formatting terminator Format-Table kept object output buffered PAST the done
+// sentinel and captures came back empty (`Get-ChildItem | Select-Object` →
+// no output). The per-command Out-Default flushes formatted output before the
+// sentinel is written, restoring one-shot `pwsh -Command` parity.
 // stdin EOF exits the process with the LAST command's code — that is exactly
 // what background-promotion relies on for its exit-file. A user script that
 // calls `exit N` terminates the whole process with N (identical code to the
@@ -63,6 +69,20 @@ function _standbyBootScript(nonce) {
         '$__baseEnv = @{}',
         'Get-ChildItem env: | ForEach-Object { $__baseEnv[$_.Name] = $_.Value }',
         '$__baseLoc = (Get-Location).ProviderPath',
+        // Session-isolation baselines: env+cwd alone leaked GLOBAL functions,
+        // aliases, variables, modules, and preference values across commands
+        // (the pool is daemon-global, so across SESSIONS too). Only global
+        // scope can leak — a scriptblock's local defs die with `& $__sc`.
+        '$__baseFn = @{}',
+        'Get-ChildItem function: | ForEach-Object { $__baseFn[$_.Name] = $true }',
+        '$__baseAlias = @{}',
+        'Get-ChildItem alias: | ForEach-Object { $__baseAlias[$_.Name] = $_.Definition }',
+        '$__baseVar = @{}',
+        'Get-Variable -Scope Global -ErrorAction SilentlyContinue | ForEach-Object { $__baseVar[$_.Name] = $true }',
+        '$__baseMod = @{}',
+        'Get-Module | ForEach-Object { $__baseMod[$_.Name] = $true }',
+        '$__basePref = @{}',
+        "foreach ($__p in @('ErrorActionPreference','ProgressPreference','VerbosePreference','WarningPreference','InformationPreference','DebugPreference','ConfirmPreference')) { $__basePref[$__p] = Get-Variable -Name $__p -ValueOnly -Scope Global -ErrorAction SilentlyContinue }",
         '$__code = 0',
         'while ($true) {',
         '  $__buf = New-Object System.Text.StringBuilder',
@@ -74,12 +94,21 @@ function _standbyBootScript(nonce) {
         '  }',
         '  foreach ($__n in @(Get-ChildItem env: | ForEach-Object Name)) { if (-not $__baseEnv.ContainsKey($__n)) { Remove-Item ("env:$__n") -ErrorAction SilentlyContinue } }',
         '  foreach ($__k in $__baseEnv.Keys) { Set-Item ("env:$__k") $__baseEnv[$__k] }',
+        // Strip global state the previous command left behind; restore
+        // overwritten alias definitions and preference values. `__*` variable
+        // names are the loop's own internals (created after baseline) and are
+        // never removed.
+        '  foreach ($__n in @(Get-ChildItem function: | ForEach-Object Name)) { if (-not $__baseFn.ContainsKey($__n)) { Remove-Item ("function:$__n") -Force -ErrorAction SilentlyContinue } }',
+        '  foreach ($__a in @(Get-ChildItem alias:)) { if (-not $__baseAlias.ContainsKey($__a.Name)) { Remove-Item ("alias:$($__a.Name)") -Force -ErrorAction SilentlyContinue } elseif ($__a.Definition -ne $__baseAlias[$__a.Name]) { Set-Alias -Name $__a.Name -Value $__baseAlias[$__a.Name] -Scope Global -Force -ErrorAction SilentlyContinue } }',
+        '  foreach ($__n in @(Get-Variable -Scope Global -ErrorAction SilentlyContinue | ForEach-Object Name)) { if ($__n -notlike "__*" -and -not $__baseVar.ContainsKey($__n)) { Remove-Variable -Name $__n -Scope Global -Force -ErrorAction SilentlyContinue } }',
+        '  foreach ($__n in @(Get-Module | ForEach-Object Name)) { if (-not $__baseMod.ContainsKey($__n)) { Remove-Module -Name $__n -Force -ErrorAction SilentlyContinue } }',
+        '  foreach ($__n in @($__basePref.Keys)) { Set-Variable -Name $__n -Value $__basePref[$__n] -Scope Global -Force -ErrorAction SilentlyContinue }',
         '  Set-Location -LiteralPath $__baseLoc',
         '  $global:LASTEXITCODE = 0',
         '  $global:__MIXDOG_RC = 1',
         '  try {',
         "    $__sc = [ScriptBlock]::Create($__buf.ToString() + [Environment]::NewLine + 'if ($?) { $global:__MIXDOG_RC = 0 } else { $global:__MIXDOG_RC = 1 }')",
-        '    & $__sc',
+'    & $__sc | Microsoft.PowerShell.Core\\Out-Default',
         '  } catch {',
         '    $global:__MIXDOG_RC = 1',
         "    [Console]::Error.WriteLine('Exception: ' + $_.Exception.Message)",

package/src/runtime/agent/orchestrator/tools/patch/matcher.mjs

@@ -383,7 +383,7 @@ export function splitBufferLinesForPatch(buf) {
   return lines;
 }
 
-function longestCommonSubstringLen(a, b, cap = 4000) {
+export function longestCommonSubstringLen(a, b, cap = 4000) {
   if (!a || !b) return 0;
   const A = a.length > cap ? a.slice(0, cap) : a;
   const B = b.length > cap ? b.slice(0, cap) : b;

package/src/runtime/agent/orchestrator/tools/patch/orchestrator.mjs

@@ -14,7 +14,6 @@ import {
   withBuiltinPathLocks,
 } from '../builtin.mjs';
 import { withAdvisoryLocks } from '../builtin/advisory-lock.mjs';
-import { wrapMutationRouteOutput } from '../mutation-planner.mjs';
 import { getPluginData } from '../../config.mjs';
 import { markCodeGraphDirtyPaths } from '../code-graph-state.mjs';
 import { prepareInput, isV4APatchInput, hasUnifiedBareV4AHunk, canFallbackCountedUnified, parseV4APatch, parseUnifiedBareV4APatch, parseUnifiedCountedAsV4APatch, isCompactedPlaceholderPatch, salvageV4AOpening } from './parsing.mjs';
@@ -509,9 +508,100 @@ function planApplyPatchMutationRoute(args, patchStr, requestedFormat) {
   };
 }
 
-function wrapPatchMutationOutput(text, plan, extras = {}) {
-  if (isPatchErrorText(text)) return text;
-  return wrapMutationRouteOutput(text, plan, extras);
+// Model-surface success outputs deliberately DROP the `mutation_route:`
+// diagnostic header (codex parity: `Success. Updated the following files:`).
+// Errors were never wrapped, the UI diff side-channel is independent, and no
+// script/UI parses the header — measured saving ~30 tokens x ~125 successful
+// patch calls/day. Route diagnostics stay available via plan/extras callers.
+function wrapPatchMutationOutput(text, _plan, _extras = {}) {
+  return text;
+}
+
+// Post-patch excerpt: a successful patch result carries the changed span's
+// CURRENT on-disk lines (numbered, verbatim). This embeds the follow-up
+// look-up INSIDE the mutation turn — the next patch to the same region has
+// byte-exact context in-session without spending a read/grep turn, which
+// removes the fuel for stale-own-edit context misses (the measured top
+// remaining failure class).
+//
+// REPEAT-GATED: batched one-shot patches (the common case under the
+// all-edits-in-one-patch rule) rarely get a follow-up, so the FIRST patch of
+// a file in a session appends nothing — zero cost. Only a repeat patch of
+// the same file (the iterative fix-loop signal, exactly where stale-own-edit
+// misses happen) pays for the excerpt.
+const _patchedFilesByScope = new Map(); // scopeKey -> Map(fileKey -> ts)
+const PATCHED_FILES_SCOPE_CAP = 64;
+const PATCHED_FILES_PER_SCOPE_CAP = 300;
+function _scopePatchedFiles(scopeKey) {
+  let seen = _patchedFilesByScope.get(scopeKey);
+  if (!seen) {
+    seen = new Map();
+    _patchedFilesByScope.set(scopeKey, seen);
+    while (_patchedFilesByScope.size > PATCHED_FILES_SCOPE_CAP) {
+      _patchedFilesByScope.delete(_patchedFilesByScope.keys().next().value);
+    }
+  }
+  return seen;
+}
+const POST_PATCH_EXCERPT_MAX_FILES = 3;
+const POST_PATCH_EXCERPT_MAX_LINES = 10;
+const POST_PATCH_EXCERPT_MAX_CHARS = 1400;
+export function appendPostPatchExcerpts(outputText, patchStr, requestedFormat, basePath, readStateScope) {
+  try {
+    if (isPatchErrorText(outputText)) return outputText;
+    if (!isV4APatchInput(patchStr, requestedFormat)) return outputText;
+    const sections = parseV4APatch(patchStr).filter((s) => s.kind === 'update' && s.hunks?.length);
+    if (!sections.length) return outputText;
+    const seen = _scopePatchedFiles(String(readStateScope || 'global'));
+    const repeats = [];
+    for (const section of sections) {
+      const target = section.movePath || section.path;
+      let fileKey;
+      try { fileKey = resolveV4AEntryPath(basePath, target); } catch { continue; }
+      if (process.platform === 'win32') fileKey = fileKey.toLowerCase();
+      if (seen.has(fileKey)) repeats.push(section);
+      seen.set(fileKey, Date.now());
+      while (seen.size > PATCHED_FILES_PER_SCOPE_CAP) seen.delete(seen.keys().next().value);
+    }
+    if (!repeats.length) return outputText;
+    const chunks = [];
+    let chars = 0;
+    for (const section of repeats.slice(0, POST_PATCH_EXCERPT_MAX_FILES)) {
+      const target = section.movePath || section.path;
+      let fileLines;
+      try {
+        fileLines = readFileSync(resolveV4AEntryPath(basePath, target), 'utf8').replace(/\r\n/g, '\n').split('\n');
+      } catch { continue; }
+      const hunk = section.hunks[0];
+      const newSide = (hunk.lines || [])
+        .filter((l) => l && (l[0] === ' ' || l[0] === '+'))
+        .map((l) => l.slice(1));
+      if (!newSide.length) continue;
+      let at = -1;
+      outer: for (let i = 0; i + newSide.length <= fileLines.length; i++) {
+        for (let k = 0; k < newSide.length; k++) {
+          if (fileLines[i + k] !== newSide[k]) continue outer;
+        }
+        at = i; break;
+      }
+      if (at < 0) continue;
+      const shown = Math.min(newSide.length, POST_PATCH_EXCERPT_MAX_LINES);
+      const rows = [];
+      for (let i = 0; i < shown; i++) {
+        rows.push(`${String(at + i + 1).padStart(5, ' ')}| ${fileLines[at + i]}`);
+      }
+      if (newSide.length > shown) rows.push('     | …');
+      const more = section.hunks.length > 1 ? ` (+${section.hunks.length - 1} more hunk${section.hunks.length > 2 ? 's' : ''})` : '';
+      const block = `${String(target).replace(/\\/g, '/')} lines ${at + 1}-${at + shown}${more}:\n${rows.join('\n')}`;
+      chars += block.length;
+      if (chars > POST_PATCH_EXCERPT_MAX_CHARS) break;
+      chunks.push(block);
+    }
+    if (!chunks.length) return outputText;
+    return `${outputText}\npost-patch state (verbatim — use for follow-up patches):\n${chunks.join('\n')}`;
+  } catch {
+    return outputText;
+  }
 }
 
 const APPLY_PATCH_SCHEMA_KEYS = new Set(['patch', 'format', 'base_path', 'dry_run', 'reject_partial', 'fuzzy', 'sequence', 'mode']);
@@ -583,11 +673,12 @@ async function apply_patch(args, cwd, options = {}) {
   const legacyBulkMode = args?.sequence === false
     || ['atomic', 'bulk'].includes(patchMode);
   if (!legacyBulkMode) {
-    return applyPatchSequence(patchStr, requestedFormat, basePath, {
+    const seqOut = await applyPatchSequence(patchStr, requestedFormat, basePath, {
       v4aConvertOpts, dryRun, fuzz, fuzzy, rejectPartial,
       readStateScope, abortSignal, mutationPlan,
       rollbackOnFailure: patchMode !== 'partial',
     });
+    return dryRun ? seqOut : appendPostPatchExcerpts(seqOut, patchStr, requestedFormat, basePath, readStateScope);
   }
   let v4aRenamePlan = null;
   if (isV4APatchInput(patchStr, requestedFormat)) {