mixdog 0.9.174 → 1.0.0

package/src/runtime/agent/orchestrator/tools/patch/apply-patch/codex-batch.mjs

@@ -33,14 +33,7 @@ import { applyParsedWave, isPatchErrorText } from '../wave.mjs';
 // Convert the body to a unified patch (V4A / bare-@@ / counted-unified
 // fallback), split it into unique-target waves and pre-validate each. Returns
 // { error } for the outcomes the tool reports as text; parse failures throw.
-export async function prepareCodexBatch({
-  patchStr,
-  requestedFormat,
-  basePath,
-  preParsedV4ASections,
-  v4aConvertOpts,
-  mutationPlan,
-}) {
+export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, preParsedV4ASections, v4aConvertOpts }) {
   let inputPatchStr = patchStr;
   let v4aRenamePlan = null;
   if (isV4APatchInput(patchStr, requestedFormat)) {
@@ -49,12 +42,6 @@ export async function prepareCodexBatch({
       const allSections = coalesceCompatibleV4ASections(parsedSections, basePath);
       v4aRenamePlan = await planV4ARenameSections(allSections, basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(v4aRenamePlan.remainingSections, basePath, v4aConvertOpts);
-      if (v4aRenamePlan.renameSections.length > 0) {
-        mutationPlan =
-          v4aRenamePlan.remainingSections.length > 0
-            ? { sourceTool: 'apply_patch', engine: 'v4a-patch', reason: 'v4a-mixed' }
-            : { sourceTool: 'apply_patch', engine: 'v4a-rename', reason: 'v4a-move' };
-      }
     } catch (err) {
       throw new Error(`apply_patch: V4A parse failed — ${err?.message || String(err)}`);
     }
@@ -72,7 +59,6 @@ export async function prepareCodexBatch({
       waveDispatch: [],
       v4aRenamePlan,
       v4aRenameOnly,
-      mutationPlan,
       lockPaths: renameLockPaths(v4aRenamePlan, basePath),
     };
   }
@@ -90,11 +76,6 @@ export async function prepareCodexBatch({
       const sections = rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(sections, basePath, v4aConvertOpts);
       parsed = parsePatch(prepareInput(inputPatchStr));
-      mutationPlan = {
-        sourceTool: 'apply_patch',
-        engine: 'v4a-patch',
-        reason: 'unified-count-fallback',
-      };
     } catch (fallbackErr) {
       throw new Error(
         `apply_patch: parse failed — ${err?.message || String(err)}; V4A fallback failed — ${fallbackErr?.message || String(fallbackErr)}`
@@ -134,7 +115,7 @@ export async function prepareCodexBatch({
     ...new Set(waveDispatch.flatMap((wd) => wd.entries.map((entry) => entry.fullPath))),
     ...renameLockPaths(v4aRenamePlan, basePath),
   ];
-  return { waveDispatch, v4aRenamePlan, v4aRenameOnly, mutationPlan, lockPaths };
+  return { waveDispatch, v4aRenamePlan, v4aRenameOnly, lockPaths };
 }
 
 function renameLockPaths(v4aRenamePlan, basePath) {
@@ -147,7 +128,7 @@ function renameLockPaths(v4aRenamePlan, basePath) {
 // Apply the validated batch in one shot: renames first, then the single wave
 // via applyParsedWave (native + JS split). Returns the model-surface text.
 export async function runCodexBatch({ batch, basePath, v4aConvertOpts, rejectedV4AHunks, waveOpts }) {
-  const { waveDispatch, v4aRenamePlan, v4aRenameOnly, mutationPlan } = batch;
+  const { waveDispatch, v4aRenamePlan, v4aRenameOnly } = batch;
   let v4aRenameResults = [];
   if (v4aRenamePlan?.renameSections?.length) {
     v4aRenameResults = await applyV4ARenameSections(v4aRenamePlan.renameSections, basePath, v4aConvertOpts);
@@ -155,18 +136,17 @@ export async function runCodexBatch({ batch, basePath, v4aConvertOpts, rejectedV
   if (v4aRenameOnly) {
     const lines = formatV4ARenameSuccessLines(v4aRenameResults);
     if (lines.length === 0) return 'Error: patch contained no applicable file sections';
-    return wrapPatchMutationOutput(`${lines.join('\n')}\n`, mutationPlan, { executor: 'v4a-rename' });
+    return wrapPatchMutationOutput(`${lines.join('\n')}\n`);
   }
   const res = await applyParsedWave(waveDispatch[0], basePath, waveOpts);
-  const executor = res.executor;
-  if (res.error) return wrapPatchMutationOutput(res.error, mutationPlan, { executor });
+  if (res.error) return wrapPatchMutationOutput(res.error);
   let combined = res.text;
   if (!isPatchErrorText(combined)) {
     const renameLines = formatV4ARenameSuccessLines(v4aRenameResults);
     if (renameLines.length > 0) combined = `${renameLines.join('\n')}\n${combined}`;
     combined += rejectedHunkTail(rejectedV4AHunks);
   }
-  return wrapPatchMutationOutput(combined, mutationPlan, { executor });
+  return wrapPatchMutationOutput(combined);
 }
 
 // Codex mode applies the validated batch in one shot. A batch that mixes

package/src/runtime/agent/orchestrator/tools/patch/apply-patch/request.mjs

@@ -1,7 +1,6 @@
 // apply_patch request intake: argument salvage, body/format validation, the
 // abort signal, base path and the option flags every execution path shares.
 import { getAbortSignalForSession } from '../../../session/abort-lookup.mjs';
-import { planApplyPatchMutationRoute } from '../mutation-output.mjs';
 import { isCompactedPlaceholderPatch, salvageV4AOpening } from '../parsing.mjs';
 import { resolveBasePath } from '../paths.mjs';
 
@@ -65,7 +64,6 @@ export async function resolveApplyPatchRequest(rawArgs, cwd, options = {}) {
   if (requestedFormat && requestedFormat !== 'unified' && requestedFormat !== 'v4a') {
     throw new Error('apply_patch: "format" must be "unified" or "v4a"');
   }
-  const mutationPlan = options?.mutationPlan || planApplyPatchMutationRoute(args, patchStr, requestedFormat);
   const readStateScope = options?.readStateScope ?? options?.sessionId ?? null;
   let abortSignal = options?.signal || options?.abortSignal || null;
   if (!abortSignal && options?.sessionId) {
@@ -84,7 +82,6 @@ export async function resolveApplyPatchRequest(rawArgs, cwd, options = {}) {
     args,
     patchStr,
     requestedFormat,
-    mutationPlan,
     readStateScope,
     abortSignal,
     basePath,

package/src/runtime/agent/orchestrator/tools/patch/dispatch/native-report.mjs

@@ -1,6 +1,7 @@
 // What a native apply reports: the io/patch trace lines and the human-readable
 // summary the model receives.
-import { ioTrace, nativePatchTraceEnabled, patchTraceEnabled } from '../native-server.mjs';
+import { ioTrace } from '../../io-trace.mjs';
+import { nativePatchTraceEnabled, patchTraceEnabled } from '../native-server.mjs';
 
 const ms = (value) => Number(value.toFixed(3));
 

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

@@ -26,6 +26,7 @@ import {
   parsedEntryResolvedPath,
   countHunkChanges,
   pathKey,
+  specialFilePatchMessage,
 } from './paths.mjs';
 import { NATIVE_PATCH_TRANSPORT_DEAD, runServerApply, scheduleNativePatchIdleClose } from './native-server.mjs';
 import {
@@ -270,11 +271,7 @@ function applyUnifiedHunksToLines(sourceLines, hunks, { fuzz, displayPath, eol }
 
 function lstatRegularPatchFile(fullPath, displayPath) {
   const st = lstatSync(fullPath);
-  if (isSpecialFileStat(st)) {
-    throw new Error(
-      `apply_patch: cannot patch special file (FIFO / character / block device / socket): ${normalizeOutputPath(displayPath)}`
-    );
-  }
+  if (isSpecialFileStat(st)) throw new Error(specialFilePatchMessage(displayPath));
   return st;
 }
 
@@ -299,11 +296,7 @@ function resolvePatchWriteTarget(fullPath, displayPath, lst) {
         ` (${err?.code || err?.message || String(err)})`
     );
   }
-  if (isSpecialFileStat(snapshotStat)) {
-    throw new Error(
-      `apply_patch: cannot patch special file (FIFO / character / block device / socket): ${normalizeOutputPath(displayPath)}`
-    );
-  }
+  if (isSpecialFileStat(snapshotStat)) throw new Error(specialFilePatchMessage(displayPath));
   if (!snapshotStat.isFile()) {
     throw new Error(`apply_patch: symlink target is not a regular file: ${normalizeOutputPath(displayPath)}`);
   }

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

@@ -658,7 +658,7 @@ function escapeNonAsciiForPatch(line) {
   return out;
 }
 
-export function findLineSequenceEscapeEquiv(sourceLines, pattern, minStart, _preferred) {
+export function findLineSequenceEscapeEquiv(sourceLines, pattern, minStart) {
   if (!pattern || pattern.length === 0) return -1;
   const starts = [];
   const from = Math.max(0, Number.isFinite(minStart) ? minStart : 0);

package/src/runtime/agent/orchestrator/tools/patch/mutation-output.mjs

@@ -1,24 +1,11 @@
-// Mutation-route planning and the model-surface output wrapper shared by the
-// Codex batch and the ordered sequence.
-import { hasUnifiedBareV4AHunk, isV4APatchInput } from './parsing.mjs';
+// Model-surface output wrapper shared by the Codex batch and the ordered
+// sequence.
 import { drainV4AAmbiguityNotices } from './v4a-convert.mjs';
 
-export function planApplyPatchMutationRoute(_args, patchStr, requestedFormat) {
-  const v4aInput =
-    isV4APatchInput(patchStr, requestedFormat) || (requestedFormat !== 'unified' && hasUnifiedBareV4AHunk(patchStr));
-  return {
-    sourceTool: 'apply_patch',
-    engine: v4aInput ? 'v4a-patch' : 'unified-patch',
-    reason: 'direct',
-  };
-}
-
-// Model-surface success outputs deliberately DROP the `mutation_route:`
-// diagnostic header (the surface stays `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.
-export function wrapPatchMutationOutput(text, _plan, _extras = {}) {
+// Model-surface success outputs deliberately carry no `mutation_route:`
+// diagnostic header (the surface stays `Success. Updated the following files:`);
+// no script/UI parses one, and dropping it saves ~30 tokens per successful patch call.
+export function wrapPatchMutationOutput(text) {
   // Per-file success rows already identify the edits; retain warnings/errors.
   text = text.replace(/^Applied \d+ Files? \((?:Native|JS)\)\r?\n(?= {2}OK )/gm, '');
   // Non-fatal duplicate-context notices ride the success output: the edit

package/src/runtime/agent/orchestrator/tools/patch/native-server.mjs

@@ -17,7 +17,7 @@ import { performance } from 'node:perf_hooks';
 import { packageNativeToolPath } from '../../../../shared/native-tool-paths.mjs';
 import { getPluginData } from '../../config.mjs';
 import { ensurePatchBinary, findCachedPatchBinary } from '../patch-binary-fetcher.mjs';
-import { envFlag } from '../../../../shared/env.mjs';
+import { ioTraceEnabled } from '../io-trace.mjs';
 
 const PLUGIN_ROOT =
   process.env.MIXDOG_ROOT ||
@@ -54,17 +54,6 @@ export function nativePatchTraceEnabled() {
   return /^(1|true|yes)$/i.test(process.env.MIXDOG_PATCH_NATIVE_TRACE || '');
 }
 
-function ioTraceEnabled() {
-  return envFlag('MIXDOG_IO_TRACE');
-}
-
-export function ioTrace(event, fields = {}) {
-  if (!ioTraceEnabled()) return;
-  try {
-    process.stderr.write(`[io-trace] ${JSON.stringify({ event, ts: Date.now(), ...fields })}\n`);
-  } catch {}
-}
-
 export function patchTraceEnabled() {
   return (
     ioTraceEnabled() ||
@@ -92,9 +81,10 @@ function nativePatchPersistent() {
 // The engine contract is proven by the RUNNING SESSION, never by a separate
 // probe of a path: the process that will execute the work ANSWERS `CONTRACT`
 // over the real protocol — bytes that merely appear (a startup printer) are
-// not an answer, and the artifact judged is always the one about to run. A wrapper that prints the marker cannot serve the
-// protocol, a swapped artifact cannot change a process that is already
-// running, and one session means one verification for any number of callers.
+// not an answer, and the artifact judged is always the one about to run. A
+// wrapper that prints the marker cannot serve the protocol, a swapped artifact
+// cannot change a process that is already running, and one session means one
+// verification for any number of callers.
 // The marker search below is only a negative pre-filter (skip spawning an
 // artifact that cannot possibly answer); it is never the proof.
 export const NATIVE_PATCH_ENGINE_CONTRACT = 'mixdog-patch-engine-contract:3';

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

@@ -34,7 +34,7 @@ async function apply_patch(rawArgs, cwd, options = {}) {
   }
   const rejectedV4AHunks = [];
   const v4aConvertOpts = { rejectPartial, rejectedHunks: rejectedV4AHunks, fuzzy, dryRun, readStateScope };
-  const route = selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath, readStateScope });
+  const route = selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath });
   if (route.useSequence) {
     const seqOut = await applyPatchSequence(patchStr, requestedFormat, basePath, {
       v4aConvertOpts,
@@ -44,7 +44,6 @@ async function apply_patch(rawArgs, cwd, options = {}) {
       rejectPartial,
       readStateScope,
       abortSignal,
-      mutationPlan: request.mutationPlan,
       toolCallId: options?.toolCallId || null,
       sessionId: options?.sessionId || null,
       replayCapture: options?.replayCapture || null,
@@ -60,7 +59,6 @@ async function apply_patch(rawArgs, cwd, options = {}) {
     readStateScope,
     preParsedV4ASections: route.preParsedV4ASections,
     v4aConvertOpts,
-    mutationPlan: request.mutationPlan,
   });
   if (batch.error) return batch.error;
   return applyCodexBatchWithRollback({

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

@@ -18,6 +18,10 @@ export function stripDiffPrefix(name) {
   return m ? m[1] : name;
 }
 
+export function specialFilePatchMessage(displayPath) {
+  return `apply_patch: cannot patch special file (FIFO / character / block device / socket): ${normalizeOutputPath(displayPath)}`;
+}
+
 export function resolveEntryPath(basePath, rawName) {
   // A parsed entry without a header path (jsdiff parses arbitrary non-diff
   // text into a headerless entry) must fail as a patch-format error, not as a

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

@@ -10,7 +10,6 @@ export async function runPatchUnits(units, basePath, { waveOpts, abortSignal, co
   const failures = [];
   let failed = null;
   let failedIndex = -1;
-  let executor = 'native-patch';
   const noteFailure = (unit, index, error) => {
     const row = { displayPath: unit.displayPath, error, index };
     failures.push(row);
@@ -59,12 +58,11 @@ export async function runPatchUnits(units, basePath, { waveOpts, abortSignal, co
       continue;
     }
     const res = await applyParsedWave(wave, basePath, waveOpts);
-    executor = res.executor;
     if (res.error) {
       noteFailure(unit, i, res.error);
       continue;
     }
     applied.push({ displayPath: unit.displayPath, text: res.text });
   }
-  return { applied, skipped, failures, failed, failedIndex, executor };
+  return { applied, skipped, failures, failed, failedIndex };
 }

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

@@ -64,17 +64,11 @@ function sectionUnit(section, basePath, { v4aConvertOpts, readStateScope, dryRun
 }
 
 function parsedEntryUnit(entry, basePath) {
-  const headerName = entryHeaderName(entry);
-  if (!headerName) {
-    throw new Error(
-      'apply_patch: a file section header could not be parsed (no target path) — the patch body is not a valid diff. ' +
-        'Each section must start with `*** Update File: <path>` / `*** Add File: <path>` / `*** Delete File: <path>` ' +
-        '(V4A, wrapped in `*** Begin Patch` / `*** End Patch`), or a `--- a/<path>` + `+++ b/<path>` pair (unified).'
-    );
-  }
+  // Throws the "header could not be parsed (no target path)" error for a headerless entry.
+  const fullPath = parsedEntryResolvedPath(entry, basePath);
   return {
-    displayPath: normalizeOutputPath(stripDiffPrefix(headerName)),
-    fullPath: parsedEntryResolvedPath(entry, basePath),
+    displayPath: normalizeOutputPath(stripDiffPrefix(entryHeaderName(entry))),
+    fullPath,
     buildParsed: async () => [entry],
   };
 }

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

@@ -23,7 +23,6 @@ export async function applyPatchSequence(patchStr, requestedFormat, basePath, ct
     rejectPartial,
     readStateScope,
     abortSignal,
-    mutationPlan,
     toolCallId,
     sessionId,
     replayCapture = null,
@@ -78,7 +77,7 @@ export async function applyPatchSequence(patchStr, requestedFormat, basePath, ct
         rejectedHunks: v4aConvertOpts?.rejectedHunks,
         continueAfterFailure,
       });
-      return wrapPatchMutationOutput(report, mutationPlan, { executor: outcome.executor });
+      return wrapPatchMutationOutput(report);
     })
   );
 }

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

@@ -10,7 +10,7 @@ import { atomicWrite } from '../builtin/atomic-write.mjs';
 import { assertPathReachable, assertPathsReachable } from '../builtin/fs-reachability.mjs';
 import { markCodeGraphDirtyPaths } from '../code-graph-state.mjs';
 import { isSpecialFileStat } from '../builtin/device-paths.mjs';
-import { pathKey, resolveV4AEntryPath } from './paths.mjs';
+import { pathKey, resolveV4AEntryPath, specialFilePatchMessage } from './paths.mjs';
 import { isV4AEndOfFileMarker } from './parsing.mjs';
 import {
   findLineSequence,
@@ -262,7 +262,7 @@ function recoverHunkWindow(sourceLines, hunk, stats, anchorLine, window, eof) {
   if (windowUnlocated(window)) {
     if (eof) window.eofSignalIgnored = true;
     const from = Math.max(0, anchorLine - 1);
-    const alt = findLineSequenceEscapeEquiv(sourceLines, window.oldLinesPattern, from, from);
+    const alt = findLineSequenceEscapeEquiv(sourceLines, window.oldLinesPattern, from);
     if (alt >= 0) adoptRemappedWindow(sourceLines, window, alt);
   }
   // Context-tolerance tier: see findContextTolerantWindow. Tolerated context
@@ -494,15 +494,9 @@ function renameTargetsSamePhysicalFile(srcFull, destFull) {
   }
 }
 
-function v4aSpecialFileStatMessage(displayPath) {
-  return `apply_patch: cannot patch special file (FIFO / character / block device / socket): ${normalizeOutputPath(displayPath)}`;
-}
-
 function lstatV4APatchTarget(fullPath, displayPath) {
   const st = lstatSync(fullPath);
-  if (isSpecialFileStat(st)) {
-    throw new Error(v4aSpecialFileStatMessage(displayPath));
-  }
+  if (isSpecialFileStat(st)) throw new Error(specialFilePatchMessage(displayPath));
   return st;
 }
 
@@ -537,7 +531,7 @@ export function validateV4ARenameSection(section, basePath, seenDestKeys) {
 function v4aRenameSourceIssue(srcFull, displayPath) {
   try {
     const st = lstatSync(srcFull);
-    if (isSpecialFileStat(st)) return v4aSpecialFileStatMessage(displayPath);
+    if (isSpecialFileStat(st)) return specialFilePatchMessage(displayPath);
     if (!st.isFile())
       return `apply_patch: V4A rename source is not a regular file: ${normalizeOutputPath(displayPath)}`;
   } catch (err) {
@@ -549,7 +543,7 @@ function v4aRenameSourceIssue(srcFull, displayPath) {
 function v4aRenameDestinationIssue(srcFull, destFull, displayPath, caseOnlyRename) {
   try {
     const destSt = lstatSync(destFull);
-    if (isSpecialFileStat(destSt)) return v4aSpecialFileStatMessage(displayPath);
+    if (isSpecialFileStat(destSt)) return specialFilePatchMessage(displayPath);
     if (destSt.isDirectory()) {
       return `apply_patch: V4A rename destination is a directory: ${normalizeOutputPath(displayPath)}`;
     }

package/src/runtime/agent/orchestrator/tools/patch-binary-fetcher.mjs

@@ -11,7 +11,7 @@
 //   { bundledManifest, download }.
 
 import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { BUNDLED_PATCH_MANIFEST_PATH as BUNDLED_MANIFEST_PATH } from './patch-manifest-path.mjs';
 import {
   binSuffix,
   createBinaryDownloader,
@@ -28,7 +28,6 @@ import {
   validSha256,
 } from '../../../shared/native-asset.mjs';
 
-const BUNDLED_MANIFEST_PATH = fileURLToPath(new URL('./patch-manifest.json', import.meta.url));
 const MANIFEST_URL =
   'https://raw.githubusercontent.com/tribgames/mixdog/main/src/runtime/agent/orchestrator/tools/patch-manifest.json';
 

package/src/runtime/agent/orchestrator/tools/patch-manifest-path.mjs

@@ -0,0 +1,3 @@
+import { fileURLToPath } from 'node:url';
+
+export const BUNDLED_PATCH_MANIFEST_PATH = fileURLToPath(new URL('./patch-manifest.json', import.meta.url));

package/src/runtime/agent/orchestrator/tools/patch-manifest.json

@@ -1,30 +1,30 @@
 {
-  "version": "0.7.32",
+  "version": "0.7.33",
   "_comment": "Rewritten by .github/workflows/patch-release.yml on each tagged release. assets maps platformKey (process.platform-process.arch, e.g. win32-x64, linux-x64, darwin-arm64) to { url, sha256 } of the mixdog-patch binary on the GitHub release. A local cargo build under native/mixdog-patch/target/release always takes precedence; otherwise the binary is fetched per this manifest into the data dir (apply is native-only — no JS apply engine).",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.32/mixdog-patch-darwin-arm64",
-      "sha256": "56739a16777fa0823394b5df26b09a657f1f783dc53dfbb868b4bdc763b4b7f3"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.33/mixdog-patch-darwin-arm64",
+      "sha256": "c2cb3b4a7e519aa9ddf97537578cf31eae48c371453f46b4501f46b16311c0a5"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.32/mixdog-patch-darwin-x64",
-      "sha256": "b1fc701932f6305e918d9e868f0b11bcedac62db578e0b115fb956706337418a"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.33/mixdog-patch-darwin-x64",
+      "sha256": "a4a138765dfc76b39fa3ea20638c0526eb857a19f6d8ea59b0e02f3f552bbaf8"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.32/mixdog-patch-linux-arm64",
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.33/mixdog-patch-linux-arm64",
       "sha256": "8ba081125ab7658a3353ced9dd487d393dc8b252ac98636da3b8745724798e68"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.32/mixdog-patch-linux-x64",
-      "sha256": "99701f20e073d7e27f9d9336a8a505467b593d9745c856a2f7765f2bc2ef813d"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.33/mixdog-patch-linux-x64",
+      "sha256": "bec7bdfc1129d5e99d15c7bc961a2b865868a68e0163a65b506be2aa70ad0bff"
     },
     "win32-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.32/mixdog-patch-win32-arm64.exe",
-      "sha256": "f0a1b2088239da8cfbc5becdc8e06582ecead2d474c64835c44a98d7c398e129"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.33/mixdog-patch-win32-arm64.exe",
+      "sha256": "85374d85f5e966f9ba82f52ed58c799339d591a1afa32a4902ae0c8715506cb5"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.32/mixdog-patch-win32-x64.exe",
-      "sha256": "22b9914b8288c93cd734e62859975fb57f81060c32b7411f169b83969842b6e0"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.33/mixdog-patch-win32-x64.exe",
+      "sha256": "b0826bb2e7462d072fdc2250fc42662d7da80589d0589a4c4781decc1fd5f008"
     }
   }
 }

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

@@ -15,6 +15,7 @@
 // (lib/shell-run-settle.mjs) and the auto-background promotion
 // (lib/shell-run-background.mjs). This module owns admission, preflight and
 // the wiring between those phases.
+import { startBackgroundTask } from '../../../shared/background-tasks.mjs';
 import { resourceAdmission } from '../../../shared/resource-admission.mjs';
 import { ExecResult, treeKill } from './shell-exec-output.mjs';
 import {
@@ -70,6 +71,7 @@ function _admissionSaturationError(admission, waitMs) {
       'check task list, cancel stale tasks, kill lingering child processes, or restart the CLI.'
   );
   error.code = 'ERESOURCEPRESSURE';
+  error.admissionSaturated = true;
   return error;
 }
 
@@ -119,7 +121,7 @@ function _abortableDelay(ms, signal) {
  *  guess. (A union of "plausible" families was worse than the ambiguity: it
  *  rewrote a valid CMD `echo literal ^&` into `echo literal ^`.) */
 // Arguments are accepted for call-site convenience but never classify.
-export function _shellFamilyForSpawn({ shell = '', shellArg: _shellArg = '', shellArgs: _shellArgs = null } = {}) {
+export function _shellFamilyForSpawn({ shell = '' } = {}) {
   const name = String(shell || '')
     .toLowerCase()
     .replace(/\.exe$/, '')
@@ -139,9 +141,9 @@ export function _shellFamilyForSpawn({ shell = '', shellArg: _shellArg = '', she
 
 async function acquireShellLeaseBounded(
   admission,
-  { abortSignal, label, dependency = 'scoped', ownerKey = null } = {}
+  { abortSignal, label, dependency = 'scoped', ownerKey = null, waitMs = SHELL_ADMISSION_WAIT_MS } = {}
 ) {
-  if (!(SHELL_ADMISSION_WAIT_MS > 0)) {
+  if (!(waitMs > 0)) {
     return admission.acquire('shell', {
       signal: abortSignal || null,
       label,
@@ -163,12 +165,12 @@ async function acquireShellLeaseBounded(
     if (abortSignal.aborted) onAbort();
     else abortSignal.addEventListener('abort', onAbort, { once: true });
   }
-  const deadlineAt = Date.now() + SHELL_ADMISSION_WAIT_MS;
+  const deadlineAt = Date.now() + waitMs;
   const deadline = setTimeout(() => {
     try {
-      ctl.abort(_admissionSaturationError(admission, SHELL_ADMISSION_WAIT_MS));
+      ctl.abort(_admissionSaturationError(admission, waitMs));
     } catch {}
-  }, SHELL_ADMISSION_WAIT_MS);
+  }, waitMs);
   if (deadline.unref) deadline.unref();
   try {
     for (;;) {
@@ -215,11 +217,12 @@ const failedResult = (run, stderr, failureReason) =>
 
 // Admission lease, policy preflight, then the spawn. Resolves the run with a
 // tool-phase failure and returns false when the command never reaches a shell.
-async function admitAndSpawn(run, params) {
+async function admitAndSpawn(run, params, { admissionWaitMs, onSaturated }) {
   const { admission, command, ownerSessionId, abortSignal } = params;
   try {
     run.resourceLease = await acquireShellLeaseBounded(admission, {
       abortSignal,
+      waitMs: admissionWaitMs,
       label: String(command || '').slice(0, 120),
       ownerKey: ownerSessionId,
     });
@@ -232,6 +235,7 @@ async function admitAndSpawn(run, params) {
     await spawnShellChild({ run, ...params });
     return true;
   } catch (err) {
+    if (err?.admissionSaturated && !abortSignal?.aborted && onSaturated(err)) return false;
     const cleanupError = await releaseResourceLease(run);
     const spawnText = String(err?.message || err);
     const cleanupText = cleanupError
@@ -248,6 +252,61 @@ async function admitAndSpawn(run, params) {
   }
 }
 
+// A saturated shell lane must not fail the call: the command becomes a tracked
+// background task that waits (no admission ceiling) for a lease, runs, and
+// completes like any other task. The call returns its task_id immediately.
+function queueSaturatedAsTask(run, saturation, spec) {
+  const queuedAbort = new AbortController();
+  let task;
+  try {
+    task = startBackgroundTask({
+      taskId: run.taskId,
+      surface: 'shell',
+      operation: 'shell',
+      label: String(spec.command || '').replace(/\s+/g, ' ').slice(0, 120),
+      context: { callerSessionId: spec.ownerSessionId, clientHostPid: spec.clientHostPid },
+      input: { command: spec.command, cwd: spec.cwd },
+      meta: { task_id: run.taskId, stdout: null, stderr: null, cwd: spec.cwd, timeoutMs: spec.timeoutMs },
+      resultType: 'shell_task_result',
+      cancel: () => queuedAbort.abort(),
+      run: async () => {
+        const result = await execShellCommand({
+          ...spec,
+          abortSignal: queuedAbort.signal,
+          autoBackgroundMs: 0,
+          backgroundOnTimeout: false,
+          admissionWaitMs: 0,
+        });
+        const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
+        if (result.exitCode !== 0) {
+          throw new Error(`exit code ${result.exitCode ?? result.signal ?? 'unknown'}${output ? `\n${output}` : ''}`);
+        }
+        return { task_id: run.taskId, status: 'completed', exit_code: 0, output };
+      },
+    });
+  } catch {
+    return false;
+  }
+  detachAbortHandler(run);
+  const reason = String(saturation.message || '').split(' —')[0];
+  run.resolveResult(
+    new ExecResult({
+      stdout: '',
+      stderr: '',
+      exitCode: null,
+      signal: null,
+      taskId: run.taskId,
+      backgrounded: true,
+      partialOutput: true,
+      settled: task.promise,
+      backgroundMessage:
+        `${reason}; queued as background task [task_id: ${task.taskId}] that starts when an execution slot frees. ` +
+        'Completion arrives automatically; call task wait (not task read polling) when the result is due.',
+    })
+  );
+  return true;
+}
+
 // A fault in the wiring BELOW admitAndSpawn (capture, settle, deadlines) has
 // no phase of its own to report it: nothing is armed yet, so no timer, exit
 // handler or settle() can ever resolve the run. Tear the half-built run down
@@ -413,11 +472,8 @@ function armDeadlines(run, { timeoutMs, autoBackgroundMs, backgroundOnTimeout, a
   }
 }
 
-// Windows Defender intermittently fails node→PowerShell spawns with EPERM
-// while it scans the child image (see shell-runtime.mjs Trojan false-positive
-// note). The failure is at spawn() time — before any stdio/side effect — so a
-// short bounded retry is safe and never re-runs a command that already ran
-// (lib/shell-spawn-retry.mjs).
+// Run one command to a terminal ExecResult. Spawn-time EPERM retries (Windows
+// Defender scanning the child image) live in lib/shell-spawn-retry.mjs.
 export function execShellCommand({
   shell,
   shellArg,
@@ -435,6 +491,7 @@ export function execShellCommand({
   backgroundOnTimeout,
   promotedTimeoutMs = 0,
   backgroundDeadlineMs = 0,
+  admissionWaitMs = SHELL_ADMISSION_WAIT_MS,
   admission = resourceAdmission,
   directArgv = null,
   // What the shell PARSES, when that must differ from what the caller shows.
@@ -464,6 +521,24 @@ export function execShellCommand({
         execScript,
         ownerSessionId,
         clientHostPid,
+      }, {
+        admissionWaitMs,
+        onSaturated: (err) =>
+          backgroundOnTimeout &&
+          queueSaturatedAsTask(run, err, {
+            shell,
+            shellArg,
+            shellArgs,
+            command,
+            env,
+            cwd,
+            timeoutMs: backgroundDeadlineMs,
+            clientHostPid,
+            ownerSessionId,
+            admission,
+            directArgv,
+            execScript,
+          }),
       });
       if (!spawned) return;