mixdog 0.9.23 → 0.9.24

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

@@ -17,8 +17,7 @@ import {
   resolveV4AEntryPath,
   parsedEntryResolvedPath,
   isResolvedPathOutsideBase,
-  assertNoDuplicateParsedModifyTargets,
-  mergeDuplicateParsedModifyEntries,
+  splitParsedModifyWaves,
   renderParsedUnifiedPatch,
   rewriteHeaderPaths,
   preValidateNativeBatch,
@@ -190,17 +189,17 @@ async function apply_patch(args, cwd, options = {}) {
   if (!v4aRenameOnly && (!Array.isArray(parsed) || parsed.length === 0)) {
     return 'Error: patch contained no file sections';
   }
+  // Split duplicate modify-target blocks into sequential waves: occurrence i
+  // of a path lands in wave i so each duplicate applies against the prior
+  // wave's on-disk result. Non-duplicate patches yield exactly one wave, so
+  // single-target behavior is unchanged.
+  let parsedWaves = v4aRenameOnly ? [] : [parsed];
   if (!v4aRenameOnly) {
     try {
-      assertNoDuplicateParsedModifyTargets(parsed, basePath);
+      parsedWaves = splitParsedModifyWaves(parsed, basePath);
     } catch (err) {
       return `Error: ${err?.message || String(err)}`;
     }
-    const merged = mergeDuplicateParsedModifyEntries(parsed, basePath);
-    if (merged.changed) {
-      parsed = merged.parsed;
-      normalizedPatchStr = renderParsedUnifiedPatch(parsed);
-    }
   }
 
   if (!v4aRenameOnly) {
@@ -210,18 +209,22 @@ async function apply_patch(args, cwd, options = {}) {
       return `Error: ${err?.message || String(err)}`;
     }
   }
-  let entries = [];
-  let headerRewrites = [];
+  // Pre-validate each wave independently: a wave only ever holds unique
+  // targets, so the native batch's per-file semantics stay intact.
+  const waveDispatch = [];
   if (!v4aRenameOnly) {
     try {
-      ({ entries, headerRewrites } = await preValidateNativeBatch(parsed, basePath));
+      for (const wparsed of parsedWaves) {
+        const { entries, headerRewrites } = await preValidateNativeBatch(wparsed, basePath);
+        waveDispatch.push({ parsed: wparsed, entries, headerRewrites });
+      }
     } catch (err) {
       return `Error: ${err?.message || String(err)}`;
     }
   }
 
   const _lockPaths = [
-    ...entries.map((entry) => entry.fullPath),
+    ...new Set(waveDispatch.flatMap((wd) => wd.entries.map((entry) => entry.fullPath))),
     ...(v4aRenamePlan?.renameSections || []).flatMap((section) => {
       const src = resolveV4AEntryPath(basePath, section.path);
       const dest = resolveV4AEntryPath(basePath, section.movePath);
@@ -240,56 +243,96 @@ async function apply_patch(args, cwd, options = {}) {
       if (lines.length === 0) return 'Error: patch contained no applicable file sections';
       return wrapPatchMutationOutput(`${lines.join('\n')}\n`, mutationPlan, { backend: 'v4a-rename' });
     }
-    const insideEntries = entries.filter((entry) => !isResolvedPathOutsideBase(entry.fullPath, basePath));
-    const outsideEntries = entries.filter((entry) => isResolvedPathOutsideBase(entry.fullPath, basePath));
-    const parsedInside = (parsed || []).filter(
-      (entry) => !isResolvedPathOutsideBase(parsedEntryResolvedPath(entry, basePath), basePath),
-    );
-    const backend = outsideEntries.length > 0
-      ? (insideEntries.length > 0 ? 'native+js-patch' : 'js-patch')
-      : 'native-patch';
-    const resultParts = [];
-    if (insideEntries.length > 0) {
-      const nativePatchStr = rewriteHeaderPaths(renderParsedUnifiedPatch(parsedInside), headerRewrites);
-      const nativeResult = await dispatchNativePatch({
-        entries: insideEntries,
-        basePath,
-        nativePatchStr,
-        fuzz,
-        rejectPartial,
-        dryRun,
-        readStateScope,
-        signal: abortSignal,
-        parsed: parsedInside,
-      });
-      if (isPatchErrorText(nativeResult)) {
-        return wrapPatchMutationOutput(nativeResult, mutationPlan, { backend });
+    // Apply one wave (a set of unique targets) via the existing native(+js)
+    // split. Returns { backend, text } on success or { backend, error } so the
+    // caller can decide whether earlier waves already committed to disk.
+    const applyWave = async ({ parsed: wparsed, entries: wentries, headerRewrites: whr }) => {
+      const insideEntries = wentries.filter((entry) => !isResolvedPathOutsideBase(entry.fullPath, basePath));
+      const outsideEntries = wentries.filter((entry) => isResolvedPathOutsideBase(entry.fullPath, basePath));
+      const parsedInside = (wparsed || []).filter(
+        (entry) => !isResolvedPathOutsideBase(parsedEntryResolvedPath(entry, basePath), basePath),
+      );
+      const backend = outsideEntries.length > 0
+        ? (insideEntries.length > 0 ? 'native+js-patch' : 'js-patch')
+        : 'native-patch';
+      const resultParts = [];
+      if (insideEntries.length > 0) {
+        const nativePatchStr = rewriteHeaderPaths(renderParsedUnifiedPatch(parsedInside), whr);
+        const nativeResult = await dispatchNativePatch({
+          entries: insideEntries,
+          basePath,
+          nativePatchStr,
+          fuzz,
+          rejectPartial,
+          dryRun,
+          readStateScope,
+          signal: abortSignal,
+          parsed: parsedInside,
+        });
+        if (isPatchErrorText(nativeResult)) return { backend, error: nativeResult };
+        resultParts.push(nativeResult);
       }
-      resultParts.push(nativeResult);
-    }
-    if (outsideEntries.length > 0) {
-      // Out-of-base targets are applied via the JS dispatcher (no base-path
-      // confinement); write permission is enforced at the hook layer.
-      const jsResult = await dispatchJsPatchEntries({
-        rows: outsideEntries,
-        parsed,
-        basePath,
-        dryRun,
-        fuzzy,
-        readStateScope,
-      });
-      if (isPatchErrorText(jsResult)) {
-        return wrapPatchMutationOutput(jsResult, mutationPlan, { backend });
+      if (outsideEntries.length > 0) {
+        // Out-of-base targets are applied via the JS dispatcher (no base-path
+        // confinement); write permission is enforced at the hook layer.
+        const jsResult = await dispatchJsPatchEntries({
+          rows: outsideEntries,
+          parsed: wparsed,
+          basePath,
+          dryRun,
+          fuzzy,
+          readStateScope,
+        });
+        if (isPatchErrorText(jsResult)) return { backend, error: jsResult };
+        resultParts.push(jsResult);
+      }
+      return { backend, text: resultParts.join('\n') };
+    };
+
+    // Duplicate-target blocks were split into contiguous sequential groups
+    // (listed order preserved); apply them in order, each against the prior
+    // group's on-disk result.
+    const waveTexts = [];
+    let backend = 'native-patch';
+    // dry_run never writes, so a later group would validate against unchanged
+    // disk and false-fail on any block that depends on an earlier edit. Only
+    // the first group is validated under dry_run; the rest are reported as
+    // unsimulated below (no false failures).
+    const groupCount = (dryRun && waveDispatch.length > 1) ? 1 : waveDispatch.length;
+    for (let w = 0; w < groupCount; w++) {
+      const res = await applyWave(waveDispatch[w]);
+      backend = res.backend;
+      if (res.error) {
+        if (w === 0) return wrapPatchMutationOutput(res.error, mutationPlan, { backend });
+        // A later group failed. rejectPartial makes each group all-or-nothing,
+        // so every block in groups 1..w is fully committed to disk and left in
+        // place. List them all so the caller knows the true on-disk state.
+        const failMsg = res.error.replace(/^Error:\s*/, '');
+        const note = [
+          `Error: apply_patch: a block failed in sequential group ${w + 1}/${waveDispatch.length}; every edit listed below was already applied to disk (writes committed) and left in place:`,
+          waveTexts.join('\n'),
+          '--- failing block ---',
+          failMsg,
+        ].join('\n');
+        return wrapPatchMutationOutput(note, mutationPlan, { backend });
       }
-      resultParts.push(jsResult);
+      waveTexts.push(res.text);
+    }
+
+    let combined = waveTexts.join('\n');
+    if (dryRun && waveDispatch.length > 1) {
+      const skipped = [...new Set(
+        waveDispatch.slice(1).flatMap((wd) => wd.entries.map((e) => e.displayPath)),
+      )];
+      combined += `\n(dry_run: only the first sequential group was validated against disk; blocks depending on earlier edits were not simulated: ${skipped.join(', ')})`;
     }
-    let combined = resultParts.join('\n');
     const renameLines = formatV4ARenameSuccessLines(v4aRenameResults);
     if (renameLines.length > 0 && !isPatchErrorText(combined)) {
       combined = `${renameLines.join('\n')}\n${combined}`;
     }
     if (!isPatchErrorText(combined) && options?.toolCallId) {
-      registerApplyPatchUiDiff(options.toolCallId, rewriteHeaderPaths(normalizedPatchStr, headerRewrites));
+      const allRewrites = waveDispatch.flatMap((wd) => wd.headerRewrites);
+      registerApplyPatchUiDiff(options.toolCallId, rewriteHeaderPaths(normalizedPatchStr, allRewrites));
     }
     if (!isPatchErrorText(combined) && rejectedV4AHunks.length > 0) {
       const tail = [

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

@@ -88,42 +88,60 @@ function parsedEntryTargetKey(entry, basePath) {
   return process.platform === 'win32' ? fullPath.toLowerCase() : fullPath;
 }
 
-export function mergeDuplicateParsedModifyEntries(parsed, basePath) {
-  const out = [];
-  const byTarget = new Map();
-  let changed = false;
-  for (const entry of parsed || []) {
-    const key = parsedEntryTargetKey(entry, basePath);
-    if (!key) {
-      out.push(entry);
-      continue;
-    }
-    const existing = byTarget.get(key);
-    if (!existing) {
-      byTarget.set(key, entry);
-      out.push(entry);
-      continue;
+// Group parsed entries into sequential application "waves". When a file is
+// listed as a modify target N times, occurrence i is placed in wave i, so
+// each duplicate block applies against the on-disk result of the previous
+// one — the native engine re-reads the file per apply() call, giving true
+// sequential semantics ("block 2 against block 1's output"). Unique and
+// non-modify entries always land in wave 0.
+//
+// Genuinely unsupported same-path combos (a create/delete mixed with any
+// other block for that path) cannot be sequenced and throw with guidance to
+// merge hunks into one block or send separate apply_patch calls.
+export function splitParsedModifyWaves(parsed, basePath) {
+  const entries = Array.isArray(parsed) ? parsed : [];
+  const kindsByPath = new Map();
+  for (const entry of entries) {
+    const kind = classifyEntry(entry);
+    const headerName = kind === 'create' ? entry.newFileName : entry.oldFileName;
+    if (!headerName || DEV_NULL.test(headerName)) continue;
+    const full = resolveEntryPath(basePath, headerName);
+    const key = process.platform === 'win32' ? full.toLowerCase() : full;
+    const rec = kindsByPath.get(key) || { kinds: [], headerName };
+    rec.kinds.push(kind);
+    kindsByPath.set(key, rec);
+  }
+  for (const { kinds, headerName } of kindsByPath.values()) {
+    if (kinds.length > 1 && kinds.some((k) => k !== 'modify')) {
+      const display = normalizeOutputPath(stripDiffPrefix(headerName));
+      throw new Error(
+        `apply_patch: unsupported duplicate target ${display} — a create/delete block cannot `
+        + 'be combined with other blocks for the same path. Merge the hunks into one block or '
+        + 'send separate apply_patch calls.',
+      );
     }
-    existing.hunks.push(...(entry.hunks || []));
-    changed = true;
   }
-  return { parsed: out, changed };
-}
-
-
-export function assertNoDuplicateParsedModifyTargets(parsed, basePath) {
-  const seenPaths = new Set();
-  for (const entry of parsed || []) {
-    if (classifyEntry(entry) !== 'modify') continue;
+  // Split into contiguous sequential groups that PRESERVE the patch's block
+  // listing order: accumulate blocks until a target path would repeat within
+  // the current group, then start a new group beginning with that block.
+  // Every group holds unique targets (the native batch stays valid) and
+  // groups apply in listed order, so the effective apply order — and thus the
+  // set of committed blocks at any failure point — equals the on-wire order.
+  const groups = [];
+  let current = [];
+  let currentKeys = new Set();
+  for (const entry of entries) {
     const key = parsedEntryTargetKey(entry, basePath);
-    if (!key) continue;
-    if (seenPaths.has(key)) {
-      const headerName = entry.oldFileName || entry.newFileName;
-      const display = normalizeOutputPath(stripDiffPrefix(headerName));
-      throw new Error(`apply_patch: duplicate target ${display} — patch lists the same path twice.`);
+    if (key && currentKeys.has(key)) {
+      groups.push(current);
+      current = [];
+      currentKeys = new Set();
     }
-    seenPaths.add(key);
+    current.push(entry);
+    if (key) currentKeys.add(key);
   }
+  if (current.length > 0) groups.push(current);
+  return groups;
 }
 
 function headerRelFromBase(basePath, absNorm) {

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

@@ -526,10 +526,19 @@ function readRawBufForV4AConversion(fullPath) {
   return buf;
 }
 
+// win32 filesystems are case-insensitive, so `Foo` and `foo` are the same
+// file: the V4A source-line cache MUST key on this normalized form at every
+// get/set, otherwise a mixed-case duplicate section refreshed under one
+// casing is missed under another and converts against stale/original lines.
+export function v4aLinesCacheKey(fullPath) {
+  return process.platform === 'win32' ? String(fullPath).toLowerCase() : String(fullPath);
+}
+
 function v4aConversionSourceLines(fullPath, linesCache) {
-  if (linesCache.has(fullPath)) return linesCache.get(fullPath);
+  const cacheKey = v4aLinesCacheKey(fullPath);
+  if (linesCache.has(cacheKey)) return linesCache.get(cacheKey);
   const lines = splitTextLinesForPatch(readRawBufForV4AConversion(fullPath).toString('utf-8'));
-  linesCache.set(fullPath, lines);
+  linesCache.set(cacheKey, lines);
   return lines;
 }
 
@@ -552,6 +561,20 @@ export async function convertV4ASectionsToUnifiedPatch(sections, basePath, optio
   const fuzzy = options.fuzzy !== false;
   const out = [];
   const v4aLinesCache = new Map();
+  // Paths that appear as update targets more than once: their duplicate
+  // sections must be converted against the PRIOR section's result so the
+  // emitted unified hunks line up for sequential (wave) application. We
+  // refresh v4aLinesCache after each such section below.
+  const dupUpdatePaths = new Set();
+  {
+    const seenUpd = new Set();
+    for (const s of sections || []) {
+      if (!s || s.kind === 'add' || s.kind === 'delete' || typeof s.path !== 'string' || !s.path) continue;
+      const fp = resolveV4AEntryPath(basePath, s.path);
+      const key = v4aLinesCacheKey(fp);
+      if (seenUpd.has(key)) dupUpdatePaths.add(key); else seenUpd.add(key);
+    }
+  }
   for (const section of sections) {
     const displayPath = section.path.replace(/\\/g, '/');
     if (section.kind === 'add') {
@@ -646,6 +669,16 @@ export async function convertV4ASectionsToUnifiedPatch(sections, basePath, optio
       out.push(`+++ b/${displayPath}`);
       for (const line of sectionHunks) out.push(line);
     }
+    // If this path is edited again later, the next section must resolve
+    // against this section's applied result, not the original file — apply
+    // these hunks to the cached lines so duplicate V4A blocks convert to a
+    // sequentially-appliable unified patch. Best-effort: on any mismatch we
+    // keep the original cache and let native wave application surface it.
+    if (dupUpdatePaths.has(v4aLinesCacheKey(fullPath))) {
+      try {
+        v4aLinesCache.set(v4aLinesCacheKey(fullPath), applyV4AHunksToLines(sourceLines, section.hunks, { fuzzy }));
+      } catch { /* leave original cached lines */ }
+    }
   }
   return out.join('\n') + '\n';
 }

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

@@ -37,7 +37,7 @@ import { startChildGuardian } from '../../../shared/child-guardian.mjs';
 // transition). shell-jobs.mjs imports stripAnsi from this module, so this is
 // a static cycle — safe because neither binding is touched at module-eval
 // time, only when the respective functions actually run.
-import { adoptForegroundShellJob } from './builtin/shell-jobs.mjs';
+import { adoptForegroundShellJob, killShellJob } from './builtin/shell-jobs.mjs';
 import {
   _maybeEncodePowerShellCommand,
   extractPowerShellCommandInner,
@@ -494,6 +494,7 @@ export function execShellCommand({
   autoBackgroundMs,
   onProgress,
   clientHostPid,
+  backgroundOnTimeout,
 }) {
   return new Promise(async (resolve) => {
     const taskId = `shell_${randomUUID().slice(0, 8)}`;
@@ -723,16 +724,20 @@ export function execShellCommand({
       if (grace.unref) grace.unref();
     });
 
-    // Auto-background transition (CC ASSISTANT_BLOCKING_BUDGET_MS +
-    // startBackgrounding analogue). Fires once, autoBackgroundMs after spawn,
-    // IFF the child is still running and the run has not already settled /
-    // been killed / timed out. It adopts the child into the shell-jobs
-    // registry while keeping it owned by this CLI process, then resolves the
-    // call immediately with a 'backgrounded' result so the tool stops hanging.
-    // The 600 s timeoutMs upper bound is carried into the adopted job detail
-    // so refreshShellJob still enforces it. Mutually exclusive with settle()
-    // via the autoBackgrounded flag set synchronously at the top before any await.
-    const _autoBackground = async () => {
+    // Auto-background transition (CC startBackgrounding analogue). Two triggers
+    // resolve the call immediately with a 'backgrounded' result while the
+    // child keeps running, adopted into the shell-jobs registry but still
+    // owned by this CLI process:
+    //   1. the optional autoBackgroundMs soft threshold (MIXDOG_SHELL_AUTO_
+    //      BACKGROUND_MS opt-in) — an EARLIER promotion before the timeout, and
+    //   2. the foreground timeout deadline (backgroundOnTimeout) — the default
+    //      promote-on-timeout that replaces the old tree-kill.
+    // Either way the adopted job runs UNLIMITED (timeoutMs 0, matching the
+    // async default): the original foreground timeout no longer bounds it, and
+    // the adopted-job cap poll still enforces the 100 MB output ceiling.
+    // Mutually exclusive with settle() via the autoBackgrounded flag set
+    // synchronously at the top before any await.
+    const _autoBackground = async ({ reason = 'threshold' } = {}) => {
       // Win the race: bail if a terminal transition already happened, and
       // claim the transition synchronously so a concurrently-queued settle()
       // (which checks autoBackgrounded) becomes inert.
@@ -740,16 +745,18 @@ export function execShellCommand({
       if (child.exitCode != null || child.signalCode != null) return;
       autoBackgrounded = true;
       // The foreground capture is over; stop the local watchdogs/timers so
-      // they cannot treeKill the now-adopted child. The 600 s bound lives
-      // on in the adopted job detail (timeoutMs) for refreshShellJob.
+      // they cannot treeKill the now-adopted child. The adopted job runs
+      // unlimited; refreshShellJob only enforces the output cap.
       if (timer) { clearTimeout(timer); timer = null; }
       _clearProgressTimer();
       if (sizeWatchdog) { clearInterval(sizeWatchdog); sizeWatchdog = null; }
       if (autoBgTimer) { clearTimeout(autoBgTimer); autoBgTimer = null; }
-      if (abortSignal && abortHandler) {
-        try { abortSignal.removeEventListener('abort', abortHandler); } catch {}
-        abortHandler = null;
-      }
+      // Keep the abort handler ATTACHED through the promotion window. A user
+      // cancel racing in after promotion starts must still bring the adopted
+      // child down — the handler's treeKill(child) does exactly that (settle()
+      // is inert once autoBackgrounded, but the kill itself still lands, and
+      // refreshShellJob then flags the job failed). We only detach on a real
+      // settle() or on the adoption-failure fallback below.
       // Every subsequent stdout/stderr chunk must hit disk — the call is
       // about to resolve and nobody will drain the in-memory buffers again.
       try { taskOutput.forceSpill(); } catch {}
@@ -766,7 +773,9 @@ export function execShellCommand({
           command,
           cwd,
           pid: child.pid,
-          timeoutMs,
+          // Unlimited: the promoted job is no longer bounded by the foreground
+          // timeout (matches the async omitted-default behavior).
+          timeoutMs: 0,
           mergeStderr: false,
           stdoutPath,
           stderrPath,
@@ -777,6 +786,18 @@ export function execShellCommand({
       } catch {
         job = null;
       }
+      // Adoption failed AFTER the foreground timers/size-watchdog were already
+      // torn down. Do NOT resolve as backgrounded — that would leave the child
+      // running unlimited with no task_id and no watcher. Release the claim and
+      // fall back to the old kill path so the command never outlives a failed
+      // promotion. (The abort handler is still attached, so an in-flight cancel
+      // is honored by the kill path too.)
+      if (!job) {
+        autoBackgrounded = false;
+        if (reason === 'timeout') timedOut = true; else killed = true;
+        _treeKillForceSettle();
+        return;
+      }
       // Wire the lifecycle: on close, write the exit-code file FIRST then
       // touch donePath STRICTLY AFTER — the exact ordering refreshShellJob()
       // gates completion on (donePath visible ⇒ exit file fully flushed).
@@ -787,6 +808,14 @@ export function execShellCommand({
           try { writeFileSync(job.donePath, ''); } catch {}
         });
       }
+      // Adoption committed. If a cancel already fired (before or during the
+      // adoption window), bring the now-adopted child down via its jobId so the
+      // promotion can't outlive a user abort. Idempotent with the still-attached
+      // abort handler's treeKill.
+      if (abortSignal && abortSignal.aborted) {
+        try { killShellJob(job.jobId); } catch {}
+        try { treeKill(child); } catch {}
+      }
       // Snapshot the partial output captured so far for the immediate result.
       let stdout = '';
       let stderr = '';
@@ -795,7 +824,10 @@ export function execShellCommand({
       try { stderr = await taskOutput.getStderr(); }
       catch (err) { taskOutput.writeError = taskOutput.writeError || err; }
       const jobId = job ? job.jobId : null;
-      const secs = Math.round(autoBackgroundMs / 1000);
+      const secs = Math.max(0, Math.round((Date.now() - _startMs) / 1000));
+      const _verb = reason === 'timeout'
+        ? `moved to background at timeout after ${secs}s`
+        : `auto-backgrounded after ${secs}s`;
       resolve(
         new ExecResult({
           stdout,
@@ -814,14 +846,31 @@ export function execShellCommand({
           backgrounded: true,
           jobId,
           backgroundMessage: jobId
-            ? `auto-backgrounded after ${secs}s; still running — completion will be delivered as a background task notification. Use task with task_id:${jobId} only for manual wait/status/read/cancel.`
-            : `auto-backgrounded after ${secs}s; still running`,
+            ? `${_verb}; still running — completion will be delivered as a background task notification. Use task with task_id:${jobId} only for manual wait/status/read/cancel.`
+            : `${_verb}; still running`,
         }),
       );
     };
 
     if (timeoutMs > 0) {
       timer = setTimeout(() => {
+        // Promote-on-timeout: if the caller allows backgrounding and the child
+        // is still running (not a trailing-`&` detach), adopt it as a tracked
+        // background job instead of tree-killing it. Falls through to the old
+        // kill path for disallowed/opted-out commands (backgroundOnTimeout
+        // false) or when a terminal transition already won the race.
+        if (
+          backgroundOnTimeout &&
+          !_isBackground &&
+          !settled &&
+          !autoBackgrounded &&
+          !killed &&
+          child.exitCode == null &&
+          child.signalCode == null
+        ) {
+          _autoBackground({ reason: 'timeout' });
+          return;
+        }
         timedOut = true;
         _treeKillForceSettle();
       }, timeoutMs);

package/src/runtime/channels/lib/crash-log.mjs

@@ -23,8 +23,9 @@ function isChannelsDegraded() { return _channelsDegraded; }
 try {
   process.stderr.on('error', (e) => {
     if (e && (e.code === 'EPIPE' || /EPIPE/.test(String(e.message || '')))) {
+      // Parent stdio pipe loss stops stderr writes only. It is NOT runtime
+      // corruption, so it must not degrade tool dispatch (_channelsDegraded).
       _stderrBroken = true;
-      _channelsDegraded = true;
     }
   });
 } catch {}
@@ -75,7 +76,8 @@ ${err instanceof Error ? err.stack : ""}
     _writeCrashLine(crashLog, msg);
   }
   if (err instanceof Error && err.message.includes("EPIPE")) {
-    _channelsDegraded = true;
+    // EPIPE = a broken pipe (parent stdio/IPC gone), not corrupted runtime
+    // state. Stop writing to the dead pipe but keep serving tool calls.
     _stderrBroken = true;
   }
   crashLogging = false;

package/src/runtime/channels/lib/output-forwarder.mjs

@@ -6,6 +6,7 @@ import {
   formatToolSurface,
   isExplorerSurface,
   isMemorySurface,
+  stripToolPrefix,
 } from "../../shared/tool-surface.mjs";
 import {
   cwdToProjectSlug,
@@ -726,7 +727,7 @@ ${_bt.trim()}` : _bt.trim();
     // The non-set checks are inlined rather than delegated to the imported
     // isHidden, because that helper would re-consult the module-local
     // HIDDEN_TOOLS Set and ignore the OutputForwarder static.
-    if (OutputForwarder.HIDDEN_TOOLS.has(name)) return true;
+    if (OutputForwarder.HIDDEN_TOOLS.has(name) || OutputForwarder.HIDDEN_TOOLS.has(stripToolPrefix(name))) return true;
     if (name === "reply" || name === "fetch") return true;
     return false;
   };