mixdog 0.9.89 → 0.9.91

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

@@ -3,7 +3,7 @@ export const CODE_GRAPH_TOOL_DEFS = [
     name: 'code_graph',
     title: 'Code Graph',
     annotations: { title: 'Code Graph', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Repo code structure/flow over verified source files only. IDs→graph; literal/zero→grep. File modes take files[]; symbol modes find_symbol/symbol_search/search/references/callers/callees take symbols[]. Exact identifiers use find_symbol/references/callers/callees and keywords use symbol_search/search. Unsupported target arrays are omitted, never silently mixed. Batch targets per mode.',
+    description: 'Repo code structure/flow over source files only. File modes take files[]; symbol modes find_symbol/symbol_search/search/references/callers/callees take symbols[]. Exact identifiers use find_symbol/references/callers/callees and keywords use symbol_search/search. Unsupported target arrays are omitted, never silently mixed.',
     inputSchema: {
       type: 'object',
       properties: {

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

package/src/runtime/agent/orchestrator/tools/patch/v4a-convert.mjs

@@ -27,6 +27,7 @@ import {
 import {
   findLineSequence,
   findLineSequenceEscapeEquiv,
+  longestCommonSubstringLen,
   splitTextLinesForPatch,
   firstMeaningfulPatchLine,
   nearestPatchLineHint,
@@ -42,6 +43,7 @@ function v4AHunkLineStats(hunk) {
   let newCount = 0;
   const oldLines = [];
   const newLines = [];
+  const oldTags = [];
   for (const raw of hunk.lines || []) {
     if (!raw) continue;
     const tag = raw[0];
@@ -51,15 +53,17 @@ function v4AHunkLineStats(hunk) {
       newCount++;
       oldLines.push(body);
       newLines.push(body);
+      oldTags.push(' ');
     } else if (tag === '-') {
       oldCount++;
       oldLines.push(body);
+      oldTags.push('-');
     } else if (tag === '+') {
       newCount++;
       newLines.push(body);
     }
   }
-  return { oldCount, newCount, oldLines, newLines };
+  return { oldCount, newCount, oldLines, newLines, oldTags };
 }
 
 function findAnchorLine(lines, anchors, fromLine) {
@@ -164,6 +168,46 @@ function eofInsertionIndex(sourceLines) {
   return len > 0 && sourceLines[len - 1] === '' ? len - 1 : len;
 }
 
+// Bounded context-tolerance tier (fuzzy, non-EOF, last resort before the
+// context-miss error). Recovers the measured top remaining failure class —
+// 1-2 nearby context lines drifted since the model last saw the file — under
+// guards that make mis-application practically impossible:
+//   - every '-' (deletion) line must match the file byte-exactly;
+//   - only ' ' (context) lines may mismatch, at most 2, and each drifted
+//     line must still resemble the file line (shared substring >= half);
+//   - at least 2 exact non-blank matches must anchor the window;
+//   - the qualifying window must be UNIQUE across the ENTIRE file;
+//   - the caller REMAPS tolerated context to the file's on-disk lines, so a
+//     drifted patch line never overwrites file content it did not target.
+function findContextTolerantWindow(sourceLines, oldLines, oldTags) {
+  const n = oldLines.length;
+  if (n < 3 || !Array.isArray(oldTags) || oldTags.length !== n) return null;
+  const collapse = (s) => String(s ?? '').replace(/\s+/g, ' ').trim();
+  const similar = (a, b) => {
+    const ca = collapse(a);
+    const cb = collapse(b);
+    if (!ca || !cb) return false;
+    return longestCommonSubstringLen(ca, cb) >= Math.max(4, Math.ceil(Math.max(ca.length, cb.length) / 2));
+  };
+  const windows = [];
+  for (let i = 0; i + n <= sourceLines.length && windows.length < 2; i++) {
+    let mismatches = 0;
+    let exactNonBlank = 0;
+    let ok = true;
+    for (let k = 0; k < n; k++) {
+      const pat = oldLines[k];
+      const src = sourceLines[i + k];
+      if (src === pat) {
+        if (collapse(pat)) exactNonBlank++;
+        continue;
+      }
+      if (oldTags[k] !== ' ' || ++mismatches > 2 || !similar(pat, src)) { ok = false; break; }
+    }
+    if (ok && mismatches > 0 && exactNonBlank >= 2) windows.push(i);
+  }
+  return windows.length === 1 ? { start: windows[0] } : null;
+}
+
 function resolveV4AHunkPosition(sourceLines, hunk, nextSearchLine, options = {}) {
   const stats = v4AHunkLineStats(hunk);
   if (stats.oldCount === 0 && stats.newCount === 0) return { skip: true };
@@ -242,6 +286,33 @@ function resolveV4AHunkPosition(sourceLines, hunk, nextSearchLine, options = {})
       }
     }
   }
+  // Context-tolerance tier: see findContextTolerantWindow. Tolerated context
+  // lines are remapped to the file's actual lines on BOTH the old and new
+  // side (same shape as the escape-equiv remap above); remapping bails on any
+  // string ambiguity so an unrelated occurrence can never be rewritten.
+  if (oldStartIdx < 0 && fuzzy && !eof && oldLinesPattern.length >= 3) {
+    const tolTags = trimmedTrailing ? stats.oldTags.slice(0, -1) : stats.oldTags;
+    const tol = findContextTolerantWindow(sourceLines, oldLinesPattern, tolTags);
+    if (tol) {
+      const remapped = new Map();
+      let ambiguous = false;
+      for (let k = 0; k < oldLinesPattern.length; k++) {
+        const pat = oldLinesPattern[k];
+        const src = sourceLines[tol.start + k];
+        if (src === pat) continue;
+        if (
+          oldLinesPattern.filter((l) => l === pat).length > 1
+          || (remapped.has(pat) && remapped.get(pat) !== src)
+        ) { ambiguous = true; break; }
+        remapped.set(pat, src);
+      }
+      if (!ambiguous) {
+        newLinesPattern = newLinesPattern.map((l) => remapped.get(l) ?? l);
+        oldLinesPattern = oldLinesPattern.map((_, k) => sourceLines[tol.start + k]);
+        oldStartIdx = tol.start;
+      }
+    }
+  }
   if (oldStartIdx < 0) {
     const msg = `V4A hunk context not found: ${formatV4AHunkLocator(hunk)};${formatV4AContextMissHint(sourceLines, stats, anchorLine)}`;
     return { error: msg };

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

@@ -48,7 +48,7 @@ const APPLY_PATCH_JSON_DESCRIPTION = [
   '- *** Delete File: <path> with nothing after it.',
   '- *** Update File: <path>, optionally followed by *** Move to: <new path>.',
   'Updates contain hunks introduced by @@ or @@ <enclosing class/function>. Prefix every hunk line with space (context), - (remove), or + (add); a hunk at end of file may close with *** End of File.',
-  'Copy 3 context lines above and below verbatim from the file. Do not duplicate overlapping context. If context is not unique, add one or more enclosing @@ headers.',
+  'Copy 3 context lines above and below verbatim from the newest tool output of the file (never retype from memory; after your own patch, use post-patch content). Do not duplicate overlapping context. If context is not unique, add one or more enclosing @@ headers.',
   'Use project-relative paths. Every added file line needs +. Never submit a compacted-history marker; re-read and create a fresh patch.',
 ].join('\n');
 

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -115,9 +115,39 @@ function _admissionSaturationError(admission, waitMs) {
   return error;
 }
 
-async function _acquireShellLeaseBounded(admission, { abortSignal, label }) {
+// Memory-pressure rejections from resource-admission are TRANSIENT: they clear
+// when concurrent work finishes releasing RSS/host memory. Measured 2026-08:
+// ~25 shell calls/14d failed instantly on `[resource pressure]` during
+// parallel bench/build waves. Instead of failing the tool call, retry the
+// acquire on a short backoff inside the existing admission deadline so most
+// of those become slightly-delayed successes. Non-memory errors (queue full,
+// detached-dependency, saturation deadline, aborts) still throw immediately.
+function _isMemoryPressureError(err) {
+  if (!err || err.code !== 'ERESOURCEPRESSURE') return false;
+  if (err.metric === 'rss' || err.metric === 'free-memory') return true;
+  return /memory metrics unavailable/i.test(String(err.message || ''));
+}
+
+function _abortableDelay(ms, signal) {
+  return new Promise((resolveDelay) => {
+    let onAbort = null;
+    // NOT unref'd: this delay is awaited foreground work — an unref'd timer
+    // lets the event loop drain and strands the retry loop forever.
+    const timer = setTimeout(() => {
+      if (onAbort && signal) { try { signal.removeEventListener('abort', onAbort); } catch {} }
+      resolveDelay();
+    }, ms);
+    if (signal) {
+      onAbort = () => { clearTimeout(timer); resolveDelay(); };
+      if (signal.aborted) onAbort();
+      else signal.addEventListener('abort', onAbort, { once: true });
+    }
+  });
+}
+
+export async function acquireShellLeaseBounded(admission, { abortSignal, label, dependency = 'scoped' } = {}) {
   if (!(SHELL_ADMISSION_WAIT_MS > 0)) {
-    return admission.acquire('shell', { signal: abortSignal || null, label });
+    return admission.acquire('shell', { signal: abortSignal || null, label, dependency });
   }
   const ctl = new AbortController();
   const onAbort = () => {
@@ -127,17 +157,26 @@ async function _acquireShellLeaseBounded(admission, { abortSignal, label }) {
     if (abortSignal.aborted) onAbort();
     else abortSignal.addEventListener('abort', onAbort, { once: true });
   }
+  const deadlineAt = Date.now() + SHELL_ADMISSION_WAIT_MS;
   const deadline = setTimeout(() => {
     try { ctl.abort(_admissionSaturationError(admission, SHELL_ADMISSION_WAIT_MS)); } catch {}
   }, SHELL_ADMISSION_WAIT_MS);
   if (deadline.unref) deadline.unref();
   try {
-    const lease = await admission.acquire('shell', { signal: ctl.signal, label });
-    // Hand governance back to the caller's signal: the internal deadline
-    // controller may still fire in a lost race after grant, and a stale
-    // aborted signal on the lease would poison later parent-restore paths.
-    lease.signal = abortSignal || null;
-    return lease;
+    for (;;) {
+      try {
+        const lease = await admission.acquire('shell', { signal: ctl.signal, label, dependency });
+        // Hand governance back to the caller's signal: the internal deadline
+        // controller may still fire in a lost race after grant, and a stale
+        // aborted signal on the lease would poison later parent-restore paths.
+        lease.signal = abortSignal || null;
+        return lease;
+      } catch (err) {
+        const remainingMs = deadlineAt - Date.now();
+        if (!_isMemoryPressureError(err) || ctl.signal.aborted || remainingMs <= 1_200) throw err;
+        await _abortableDelay(Math.min(1_000, remainingMs), ctl.signal);
+      }
+    }
   } finally {
     clearTimeout(deadline);
     if (abortSignal) { try { abortSignal.removeEventListener('abort', onAbort); } catch {} }
@@ -320,7 +359,7 @@ export function execShellCommand({
     let _markerFilters = null;
     let _onChildErrorRef = null;
     try {
-      resourceLease = await _acquireShellLeaseBounded(admission, {
+      resourceLease = await acquireShellLeaseBounded(admission, {
         abortSignal,
         label: String(command || '').slice(0, 120),
       });