mixdog 0.9.96 → 0.9.99

package/src/runtime/agent/orchestrator/tools/code-graph/search.mjs

@@ -1,7 +1,8 @@
 // Symbol search / callers / callees / references / impact query layer over a
 // built graph. Pure over {graph,cwd,args}; owns no cache state. Extracted
 // verbatim from code-graph.mjs.
-import { readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { codeGraphSourceIoAdmission } from '../../../../shared/tool-workload-gates.mjs';
 import { _isJsLike } from './lang-predicates.mjs';
 import { _maskNonCodeText } from './text-mask.mjs';
 import {
@@ -30,7 +31,7 @@ import {
   _keywordMatchesSymbolName,
 } from './keyword-match.mjs';
 
-export { _formatRelated, _formatImpact, _findSymbolAcrossGraph, _resolveReferenceLanguageNode, _formatCallerReferences, _formatTransitiveCallers } from './search-references.mjs';
+export { _formatRelated, _formatImpact, _impactSourceNodes, _findSymbolAcrossGraph, _resolveReferenceLanguageNode, _formatCallerReferences, _formatTransitiveCallers } from './search-references.mjs';
 export function _extractCallees(graph, declHit, _cwd, { cap = 200, callerSymbol = null, language = null } = {}) {
   if (!declHit || !_CALLEES_BRACE_LANGS.has(declHit.lang)) return [];
   const declNode = graph.nodes.get(declHit.rel);
@@ -253,28 +254,64 @@ export function _formatCalleeRow(row) {
   const enclosing = row.enclosing ? `(in ${row.enclosing})` : '(in ?)';
   return `${row.name}\t${callsite}\t${decl}\t${enclosing}`;
 }
-export async function _prewarmReferenceSourceText(graph, symbol, language) {
-  const candidateNodes = _lookupCandidateNodes(graph, symbol, language);
-  // Return the resolved candidate set so the immediately-following
-  // _cheapReferenceSearch (references/callers dispatch) can reuse it instead
-  // of recomputing _lookupCandidateNodes for the same (symbol, language) —
-  // which on a token-index miss is a full-graph scan run twice per symbol.
-  if (!candidateNodes.length) return candidateNodes;
+const CODE_GRAPH_SOURCE_READ_CONCURRENCY = Math.max(
+  1,
+  Math.min(32, Math.floor(Number(process.env.MIXDOG_CODE_GRAPH_SOURCE_READ_CONCURRENCY) || 8)),
+);
+
+export async function _prewarmSourceTextNodes(graph, nodes, {
+  concurrency = CODE_GRAPH_SOURCE_READ_CONCURRENCY,
+  readFileImpl = readFile,
+  signal = null,
+  ownerKey = null,
+} = {}) {
+  const sourceNodes = [];
+  const seen = new Set();
+  for (const node of Array.isArray(nodes) ? nodes : []) {
+    if (!node?.rel || !node?.abs || seen.has(node.rel)) continue;
+    seen.add(node.rel);
+    sourceNodes.push(node);
+  }
   const uncached = [];
-  for (const node of candidateNodes) {
+  for (const node of sourceNodes) {
     const cached = graph._sourceTextCache?.get(node.rel);
     if (!cached || cached.fingerprint !== (node.fingerprint || '')) {
       uncached.push(node);
     }
   }
-  if (uncached.length === 0) return candidateNodes;
-  const { readFile } = await import('fs/promises');
-  await Promise.all(uncached.map(async (node) => {
-    try {
-      const text = await readFile(node.abs, 'utf8');
-      graph._sourceTextCache?.set(node.rel, { fingerprint: node.fingerprint || '', text });
-    } catch { /* skip unreadable file */ }
-  }));
+  let next = 0;
+  const worker = async () => {
+    while (!signal?.aborted) {
+      const index = next++;
+      if (index >= uncached.length) return;
+      const node = uncached[index];
+      try {
+        const text = await codeGraphSourceIoAdmission.run(
+          ownerKey,
+          () => readFileImpl(node.abs, 'utf8'),
+          { signal },
+        );
+        graph._sourceTextCache?.set(node.rel, { fingerprint: node.fingerprint || '', text });
+      } catch { /* skip unreadable/aborted file */ }
+    }
+  };
+  const workerCount = Math.min(
+    Math.max(1, Math.floor(Number(concurrency) || CODE_GRAPH_SOURCE_READ_CONCURRENCY)),
+    Math.max(1, uncached.length),
+  );
+  if (uncached.length > 0) {
+    await Promise.all(Array.from({ length: workerCount }, worker));
+  }
+  return sourceNodes;
+}
+
+export async function _prewarmReferenceSourceText(graph, symbol, language, options = {}) {
+  const candidateNodes = _lookupCandidateNodes(graph, symbol, language);
+  // Return the resolved candidate set so the immediately-following
+  // _cheapReferenceSearch (references/callers dispatch) can reuse it instead
+  // of recomputing _lookupCandidateNodes for the same (symbol, language) —
+  // which on a token-index miss is a full-graph scan run twice per symbol.
+  await _prewarmSourceTextNodes(graph, candidateNodes, options);
   return candidateNodes;
 }
 

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

@@ -14,6 +14,7 @@ export const CODE_GRAPH_TOOL_DEFS = [
         limit: { type: 'number', minimum: 1, description: 'Max results.' },
         depth: { type: 'number', minimum: 1, maximum: 5, description: 'Caller depth.' },
         page: { type: 'number', minimum: 1, description: 'Caller page.' },
+        cwd: { type: 'string', description: 'Explicit root.' },
       },
       required: ['mode'],
       additionalProperties: false,

package/src/runtime/agent/orchestrator/tools/env-scrub.mjs

@@ -120,8 +120,7 @@ export function scrubRuntimeRootVars(env) {
     // Daemon IDENTITY leak: user-facing children must not inherit host/worker
     // ownership or the daemon's terminal-lead PID. Internal daemon/worker
     // spawns set every identity value explicitly after this boundary.
-    delete env.MIXDOG_ENGINE_DAEMON_HOST;
-    delete env.MIXDOG_CHANNEL_DAEMON;
+    delete env.MIXDOG_DAEMON_HOST;
     delete env.MIXDOG_WORKER_MODE;
     delete env.MIXDOG_DAEMON_SPAWNED_FOR;
     delete env.MIXDOG_SUPERVISOR_PID;

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

@@ -43,11 +43,11 @@ export function _resolvePwshPoolTarget({
         if (Number.isFinite(n) && n >= 0) return Math.min(8, n);
     }
     if (platform !== 'win32') return 0;
-    // Tools now execute in the machine-global backend daemon. Keep client/test
+    // Tools now execute in the machine-global daemon. Keep client/test
     // processes at zero by default, but let that ONE host maintain a short-lived
     // warm burst sized to the machine instead of making every shell call pay the
     // ~300ms pwsh startup cost.
-    if (env?.MIXDOG_ENGINE_DAEMON_HOST !== '1' && env?.MIXDOG_CHANNEL_DAEMON !== '1') return 0;
+    if (env?.MIXDOG_DAEMON_HOST !== '1') return 0;
     let cores = Number(parallelism);
     if (!Number.isFinite(cores) || cores < 1) {
         try { cores = availableParallelism(); } catch { cores = 1; }

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

@@ -2,7 +2,7 @@
 // mode gating, binary resolution, prewarm/idle lifecycle, and the char-indexed
 // EDIT client. Split out of patch.mjs; behavior is identical.
 //
-// Backend: NATIVE-ONLY. Every supported apply/edit case is dispatched to the
+// Executor: NATIVE-ONLY. Every supported apply/edit case is dispatched to the
 // mixdog-patch Rust engine via the persistent stdio server. There is NO JS
 // apply fallback: unsupported / unsafe input returns a clean Error string.
 

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

@@ -144,8 +144,8 @@ function restorePatchRollbackState(snapshots, readStateScope) {
 }
 
 // Apply one "wave" (a set of unique-target parsed entries) via the native
-// (+ JS out-of-base) split. Returns { backend, text } on success or
-// { backend, error } so the caller decides whether earlier waves already
+// (+ JS out-of-base) split. Returns { executor, text } on success or
+// { executor, error } so the caller decides whether earlier waves already
 // committed to disk. Extracted verbatim from the inline applyWave closure so
 // both the default wave loop and sequence mode share identical apply
 // semantics.
@@ -156,7 +156,7 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
   const parsedInside = (wparsed || []).filter(
     (entry) => !isResolvedPathOutsideBase(parsedEntryResolvedPath(entry, basePath), basePath),
   );
-  const backend = outsideEntries.length > 0
+  const executor = outsideEntries.length > 0
     ? (insideEntries.length > 0 ? 'native+js-patch' : 'js-patch')
     : 'native-patch';
   const resultParts = [];
@@ -173,7 +173,7 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
       signal: abortSignal,
       parsed: parsedInside,
     });
-    if (isPatchErrorText(nativeResult)) return { backend, error: nativeResult };
+    if (isPatchErrorText(nativeResult)) return { executor, error: nativeResult };
     resultParts.push(nativeResult);
   }
   if (outsideEntries.length > 0) {
@@ -187,10 +187,10 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
       fuzzy,
       readStateScope,
     });
-    if (isPatchErrorText(jsResult)) return { backend, error: jsResult };
+    if (isPatchErrorText(jsResult)) return { executor, error: jsResult };
     resultParts.push(jsResult);
   }
-  return { backend, text: resultParts.join('\n') };
+  return { executor, text: resultParts.join('\n') };
 }
 
 // Default ordered section mode. Apply each file section in listed order,
@@ -200,7 +200,7 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
 async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
   const {
     v4aConvertOpts, dryRun, fuzz, fuzzy, rejectPartial,
-    readStateScope, abortSignal, mutationPlan, rollbackOnFailure,
+    readStateScope, abortSignal, mutationPlan,
     toolCallId, sessionId,
   } = ctx;
 
@@ -328,52 +328,8 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
 
   return withBuiltinPathLocks(lockPaths, () =>
     withAdvisoryLocks(lockPaths, async () => {
-      // Most multi-file failures are stale context in a later, independent
-      // file. For unique targets, validate every section against current bytes
-      // before the first write. Same-target sequences retain the existing
-      // ordered conversion/rollback path because later sections may
-      // intentionally depend on earlier edits.
-      const preparedUnits = new Map();
-      const uniqueTargets = new Set(lockPaths.map(patchPathKey)).size === units.length;
-      if (!dryRun && rollbackOnFailure && uniqueTargets) {
-        for (let i = 0; i < units.length; i++) {
-          const unit = units[i];
-          if (abortSignal?.aborted) return 'Error: apply_patch aborted during preflight; no files were written';
-          let parsed;
-          try {
-            parsed = await unit.buildParsed();
-          } catch (err) {
-            return `Error: apply_patch preflight rejected section ${i + 1}/${units.length} (${unit.displayPath}); no files were written.\n${err?.message || String(err)}`;
-          }
-          if (!Array.isArray(parsed) || parsed.length === 0) {
-            preparedUnits.set(i, { parsed, wave: null });
-            continue;
-          }
-          let wave;
-          try {
-            const { entries, headerRewrites } = await preValidateNativeBatch(parsed, basePath);
-            wave = { parsed, entries, headerRewrites };
-          } catch (err) {
-            return `Error: apply_patch preflight rejected section ${i + 1}/${units.length} (${unit.displayPath}); no files were written.\n${err?.message || String(err)}`;
-          }
-          const checked = await applyParsedWave(wave, basePath, { ...waveOpts, dryRun: true });
-          if (checked.error) {
-            const detail = checked.error.replace(/^Error:\s*/, '');
-            return `Error: apply_patch preflight rejected section ${i + 1}/${units.length} (${unit.displayPath}); no files were written.\n${detail}`;
-          }
-          preparedUnits.set(i, { parsed, wave });
-        }
-      }
-      let rollbackSnapshots = [];
       let uiBeforeSnapshots = [];
-      if (!dryRun && rollbackOnFailure) {
-        try {
-          rollbackSnapshots = capturePatchRollbackState(lockPaths);
-          uiBeforeSnapshots = rollbackSnapshots;
-        } catch (err) {
-          return `Error: ${err?.message || String(err)}`;
-        }
-      } else if (!dryRun && toolCallId && sessionId) {
+      if (!dryRun && toolCallId && sessionId) {
         try {
           uiBeforeSnapshots = capturePatchRollbackState(lockPaths);
         } catch {
@@ -384,7 +340,7 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
       const skipped = [];
       let failed = null;
       let failedIndex = -1;
-      let backend = 'native-patch';
+      let executor = 'native-patch';
       for (let i = 0; i < units.length; i++) {
         const unit = units[i];
         if (failed) { skipped.push(unit.displayPath); continue; }
@@ -393,15 +349,13 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
           failedIndex = i;
           continue;
         }
-        let parsed = preparedUnits.get(i)?.parsed;
-        if (!preparedUnits.has(i)) {
-          try {
-            parsed = await unit.buildParsed();
-          } catch (err) {
-            failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
-            failedIndex = i;
-            continue;
-          }
+        let parsed;
+        try {
+          parsed = await unit.buildParsed();
+        } catch (err) {
+          failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
+          failedIndex = i;
+          continue;
         }
         if (!Array.isArray(parsed) || parsed.length === 0) {
           // Section produced no applicable hunks (all skipped / no-op). Nothing
@@ -409,19 +363,17 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
           applied.push({ displayPath: unit.displayPath, text: `(no changes) ${unit.displayPath}` });
           continue;
         }
-        let wave = preparedUnits.get(i)?.wave;
-        if (!wave) {
-          try {
-            const { entries, headerRewrites } = await preValidateNativeBatch(parsed, basePath);
-            wave = { parsed, entries, headerRewrites };
-          } catch (err) {
-            failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
-            failedIndex = i;
-            continue;
-          }
+        let wave;
+        try {
+          const { entries, headerRewrites } = await preValidateNativeBatch(parsed, basePath);
+          wave = { parsed, entries, headerRewrites };
+        } catch (err) {
+          failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
+          failedIndex = i;
+          continue;
         }
         const res = await applyParsedWave(wave, basePath, waveOpts);
-        backend = res.backend;
+        executor = res.executor;
         if (res.error) {
           failed = { displayPath: unit.displayPath, error: res.error };
           failedIndex = i;
@@ -459,16 +411,13 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
         }
         const head = `apply_patch: ${verb} ${units.length} section(s)`;
         const body = (appliedTexts ? `${head}\n${appliedTexts}` : head) + dryNote + rejectedTail;
-        return wrapPatchMutationOutput(body, mutationPlan, { backend });
+        return wrapPatchMutationOutput(body, mutationPlan, { executor });
       }
       const failMsg = failed.error.replace(/^Error:\s*/, '');
-      const rollbackErrors = (!dryRun && rollbackOnFailure)
-        ? restorePatchRollbackState(rollbackSnapshots, readStateScope)
-        : [];
       if (
         !dryRun
         && uiBeforeSnapshots.length > 0
-        && ((!rollbackOnFailure && applied.length > 0) || rollbackErrors.length > 0)
+        && applied.length > 0
       ) {
         registerCommittedPatchUiDiff({
           callId: toolCallId,
@@ -480,26 +429,22 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
       }
       const committedPhrase = dryRun
         ? `${applied.length} earlier section(s) were validated`
-        : (rollbackOnFailure
-          ? (rollbackErrors.length === 0
-            ? `${applied.length} earlier section(s) were applied, then all touched paths were rolled back to their pre-patch state`
-            : `${applied.length} earlier section(s) were applied, but rollback was incomplete`)
-          : `${applied.length} earlier section(s) were applied to disk (committed) and left in place`);
+        : `${applied.length} earlier section(s) were applied to disk (committed) and left in place`;
       const lines = [
         `Error: apply_patch sequence stopped at section ${failedIndex + 1}/${units.length} (${failed.displayPath}); `
           + `${committedPhrase}; ${skipped.length} later section(s) were skipped (not attempted).`,
       ];
+      if (!dryRun) {
+        lines.push('Retry only the failed and skipped sections; do not resend committed sections.');
+      }
       if (appliedTexts) {
-        lines.push(`--- ${dryRun ? 'validated' : (rollbackOnFailure ? 'applied before rollback' : 'applied (committed to disk)')} ---`, appliedTexts);
+        lines.push(`--- ${dryRun ? 'validated' : 'applied (committed to disk)'} ---`, appliedTexts);
       }
       lines.push(`--- failed section: ${failed.displayPath} ---`, failMsg);
-      if (rollbackErrors.length > 0) {
-        lines.push('--- rollback incomplete ---', ...rollbackErrors);
-      }
       if (skipped.length > 0) {
         lines.push(`--- skipped (not attempted): ${skipped.join(', ')} ---`);
       }
-      return wrapPatchMutationOutput(lines.join('\n') + dryNote + rejectedTail, mutationPlan, { backend });
+      return wrapPatchMutationOutput(lines.join('\n') + dryNote + rejectedTail, mutationPlan, { executor });
     }));
 }
 
@@ -723,9 +668,41 @@ function salvageShatteredV4APatchArgs(args) {
   return cleaned;
 }
 
+function extractInlinePatchRoot(patchText) {
+  const text = String(patchText || '');
+  const match = /^(\*\*\* Begin Patch\r?\n)\*\*\* Root:[ \t]*(.*?)\r?\n/.exec(text);
+  if (!match) return { patch: text, root: null };
+  const root = String(match[2] || '').trim();
+  if (!root) throw new Error('apply_patch: "*** Root:" requires a containing directory');
+  return {
+    patch: `${match[1]}${text.slice(match[0].length)}`,
+    root,
+  };
+}
+
+function isFilesystemRootSpecifier(value, cwd) {
+  const raw = String(value || '').trim();
+  if (!raw) return false;
+  // Keep Windows semantics testable on every host and reject the ambiguous
+  // drive-relative spelling (`C:`) alongside an actual drive root.
+  if (/^[A-Za-z]:(?:[\\/]?)$/.test(raw)) return true;
+  const resolved = resolveBasePath(cwd, raw);
+  return pathDirname(resolved) === resolved;
+}
+
 async function apply_patch(args, cwd, options = {}) {
   args = salvageShatteredV4APatchArgs(args);
-  const patchStr = salvageV4AOpening((typeof args?.patch === 'string' ? args.patch : '').replace(/^\uFEFF/, ''));
+  let patchStr = salvageV4AOpening((typeof args?.patch === 'string' ? args.patch : '').replace(/^\uFEFF/, ''));
+  const inlineRoot = extractInlinePatchRoot(patchStr);
+  patchStr = inlineRoot.patch;
+  if (inlineRoot.root) {
+    const argumentRoot = typeof args?.root === 'string' ? args.root.trim() : '';
+    if (argumentRoot
+        && pathResolve(resolveBasePath(cwd, argumentRoot)) !== pathResolve(resolveBasePath(cwd, inlineRoot.root))) {
+      throw new Error('apply_patch: root argument conflicts with the "*** Root:" directive');
+    }
+    args = { ...(args || {}), root: inlineRoot.root };
+  }
   if (!patchStr.trim()) {
     throw new Error('apply_patch: "patch" is required (unified diff or V4A patch string)');
   }
@@ -761,7 +738,21 @@ async function apply_patch(args, cwd, options = {}) {
   // a mis-scoped working directory can never silently rewrite another tree.
   // Editing outside stays possible, but only as a deliberate act: name the
   // root that contains those targets in the same call.
-  const writeRoot = resolveBasePath(cwd, args?.root ?? args?.base_path ?? null);
+  const explicitRoot = typeof args?.root === 'string' && args.root.trim() ? args.root.trim() : null;
+  if (explicitRoot && isFilesystemRootSpecifier(explicitRoot, cwd)) {
+    throw new Error(`apply_patch: refusing filesystem root as write root: ${normalizeOutputPath(explicitRoot)}`);
+  }
+  const writeRoot = resolveBasePath(cwd, explicitRoot ?? args?.base_path ?? null);
+  if (explicitRoot) {
+    try {
+      await assertPathReachable(writeRoot);
+      if (!statSync(writeRoot).isDirectory()) {
+        throw new Error(`not a directory — ${normalizeOutputPath(writeRoot)}`);
+      }
+    } catch (err) {
+      throw new Error(`apply_patch: invalid write root ${normalizeOutputPath(writeRoot)}: ${err?.message || String(err)}`);
+    }
+  }
   const outsideTargets = [];
   for (const rel of patchTargetPaths(patchStr, basePath)) {
     const abs = isAbsolute(rel) ? pathResolve(rel) : pathResolve(basePath, rel);
@@ -773,7 +764,7 @@ async function apply_patch(args, cwd, options = {}) {
     const more = shown.length > 3 ? ` (+${shown.length - 3} more)` : '';
     throw new Error(
       `apply_patch: ${shown.length} target(s) fall outside the write root ${normalizeOutputPath(writeRoot)}: ${head}${more}. `
-      + 'Check the paths first; if they are intended, re-issue the same patch with root set to the directory that contains them.',
+      + 'Check the paths first; if intended, set root (JSON) or add "*** Root: <containing directory>" after "*** Begin Patch" (freeform).',
     );
   }
   const rejectPartial = args?.reject_partial !== false;
@@ -784,11 +775,10 @@ async function apply_patch(args, cwd, options = {}) {
   let inputPatchStr = patchStr;
   const rejectedV4AHunks = [];
   const v4aConvertOpts = { rejectPartial, rejectedHunks: rejectedV4AHunks, fuzzy, dryRun, readStateScope };
-  // Default internal ordered mode: apply sections in listed order, stop at the
-  // first failure, and roll every touched path back to its pre-patch state.
-  // mode:"partial" retains the old committed-prefix behavior for internal
-  // callers that explicitly need it.
-  // The legacy bulk/atomic path remains available as an explicit escape hatch.
+  // Default ordered mode mirrors Codex's lower executor: apply sections in
+  // listed order, stop at the first failure, and keep the committed prefix.
+  // The model-visible schema stays unchanged; legacy bulk/atomic rollback
+  // remains an internal escape hatch.
   const patchMode = String(args?.mode || '').toLowerCase();
   const legacyBulkMode = args?.sequence === false
     || ['atomic', 'bulk'].includes(patchMode);
@@ -796,7 +786,6 @@ async function apply_patch(args, cwd, options = {}) {
     const seqOut = await applyPatchSequence(patchStr, requestedFormat, basePath, {
       v4aConvertOpts, dryRun, fuzz, fuzzy, rejectPartial,
       readStateScope, abortSignal, mutationPlan,
-      rollbackOnFailure: patchMode !== 'partial',
       toolCallId: options?.toolCallId || null,
       sessionId: options?.sessionId || null,
     });
@@ -917,17 +906,17 @@ async function apply_patch(args, cwd, options = {}) {
     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, { backend: 'v4a-rename' });
+      return wrapPatchMutationOutput(`${lines.join('\n')}\n`, mutationPlan, { executor: 'v4a-rename' });
     }
     // Apply one wave (a set of unique targets) via applyParsedWave (native +
-    // JS split). Returns { backend, text } on success or { backend, error }.
+    // JS split). Returns { executor, text } on success or { executor, error }.
     const applyWave = (wave) => applyParsedWave(wave, basePath, { fuzz, rejectPartial, dryRun, fuzzy, readStateScope, abortSignal });
 
     // 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';
+    let executor = '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
@@ -935,9 +924,9 @@ async function apply_patch(args, cwd, options = {}) {
     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;
+      executor = res.executor;
       if (res.error) {
-        if (w === 0) return wrapPatchMutationOutput(res.error, mutationPlan, { backend });
+        if (w === 0) return wrapPatchMutationOutput(res.error, mutationPlan, { executor });
         // 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.
@@ -948,7 +937,7 @@ async function apply_patch(args, cwd, options = {}) {
           '--- failing block ---',
           failMsg,
         ].join('\n');
-        return wrapPatchMutationOutput(note, mutationPlan, { backend });
+        return wrapPatchMutationOutput(note, mutationPlan, { executor });
       }
       waveTexts.push(res.text);
     }
@@ -970,9 +959,9 @@ async function apply_patch(args, cwd, options = {}) {
         `hunk-level rejected (rejectPartial=false, V4A): ${rejectedV4AHunks.length}`,
         ...rejectedV4AHunks.map((r) => `  REJECT ${r.file || '(unknown)'} — ${String(r.reason || '').split(';')[0].trim()}`),
       ];
-      return wrapPatchMutationOutput(`${combined}\n${tail.join('\n')}`, mutationPlan, { backend });
+      return wrapPatchMutationOutput(`${combined}\n${tail.join('\n')}`, mutationPlan, { executor });
     }
-    return wrapPatchMutationOutput(combined, mutationPlan, { backend });
+    return wrapPatchMutationOutput(combined, mutationPlan, { executor });
   };
 
   return withBuiltinPathLocks(_lockPaths, () =>

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

@@ -1,5 +1,6 @@
-const APPLY_PATCH_LARK_GRAMMAR = `start: begin_patch hunk+ end_patch
+const APPLY_PATCH_LARK_GRAMMAR = `start: begin_patch root_line? hunk+ end_patch
 begin_patch: "*** Begin Patch" LF
+root_line: "*** Root: " filename LF
 end_patch: "*** End Patch" LF?
 
 hunk: add_hunk | delete_hunk | update_hunk

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

@@ -20,7 +20,7 @@
 //   ./patch/orchestrator.mjs  — apply_patch orchestration + executePatchTool
 //     + replay capture + UI-diff side-channel.
 //
-// Backend is unchanged: NATIVE-ONLY dispatch to the mixdog-patch Rust engine,
+// Executor is unchanged: NATIVE-ONLY dispatch to the mixdog-patch Rust engine,
 // no JS apply fallback. Public exports below match the pre-split surface.
 
 // Side-effect import: schedules the native-patch prewarm on module load, as

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

@@ -258,6 +258,7 @@ export function execShellCommand({
   ownerSessionId,
   backgroundOnTimeout,
   promotedTimeoutMs = 0,
+  backgroundDeadlineMs = 0,
   admission = resourceAdmission,
 }) {
   return new Promise(async (resolve) => {
@@ -791,7 +792,12 @@ export function execShellCommand({
       const stdoutPath = taskOutput.spilled ? taskOutput.stdoutPath : null;
       const stderrPath = taskOutput.spilled ? taskOutput.stderrPath : null;
       let job = null;
-      const adoptedTimeoutMs = reason === 'timeout' ? promotedTimeoutMs : 0;
+      const elapsedMs = Math.max(0, Date.now() - _startMs);
+      const adoptedTimeoutMs = reason === 'timeout'
+        ? promotedTimeoutMs
+        : (backgroundDeadlineMs > 0
+          ? Math.max(1, backgroundDeadlineMs - elapsedMs)
+          : 0);
       try {
         job = adoptForegroundShellJob({
           command,

package/src/runtime/attachments/pdf-extract.mjs

@@ -0,0 +1,83 @@
+/**
+ * Bounded PDF inspection/text extraction shared by prompt intake and `read`.
+ *
+ * Native PDF-capable providers receive the original content-addressed file.
+ * OpenAI-compatible providers without a document contract receive page-ordered
+ * text extracted here, so they never see an unsupported inline Base64 block.
+ */
+const DEFAULT_MAX_PAGES = 100;
+const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+
+function boundedUtf8(value, maxBytes) {
+  const buffer = Buffer.from(String(value || ''), 'utf8');
+  if (buffer.length <= maxBytes) return { text: buffer.toString('utf8'), bytes: buffer.length, truncated: false };
+  if (maxBytes <= 0) return { text: '', bytes: 0, truncated: true };
+  const text = buffer.subarray(0, maxBytes).toString('utf8').replace(/\uFFFD+$/g, '');
+  return { text, bytes: Buffer.byteLength(text, 'utf8'), truncated: true };
+}
+
+export async function inspectPdfBuffer(buffer, {
+  extractText = false,
+  maxPages = DEFAULT_MAX_PAGES,
+  maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES,
+  pageRange = null,
+} = {}) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) throw new TypeError('PDF payload is empty');
+  const { getDocumentProxy } = await import('unpdf');
+  const pdf = await getDocumentProxy(new Uint8Array(buffer));
+  try {
+    const pageCount = Math.max(0, Number(pdf?.numPages) || 0);
+    const pageLimit = Number.isFinite(Number(maxPages)) ? Math.max(1, Math.floor(Number(maxPages))) : Infinity;
+    if (pageCount > pageLimit) {
+      throw new RangeError(`PDF has ${pageCount} pages; maximum supported attachment is ${pageLimit} pages`);
+    }
+    if (!extractText) return { pageCount, text: '', truncated: false };
+
+    const from = Math.max(1, Number(pageRange?.from) || 1);
+    const to = Math.min(pageCount, Math.max(from, Number(pageRange?.to) || pageCount));
+    const byteLimit = Math.max(1, Number(maxOutputBytes) || DEFAULT_MAX_OUTPUT_BYTES);
+    const chunks = [];
+    let bytes = 0;
+    let truncated = false;
+    for (let pageNumber = from; pageNumber <= to; pageNumber += 1) {
+      const page = await pdf.getPage(pageNumber);
+      try {
+        const content = await page.getTextContent();
+        const body = (content?.items || [])
+          .map((item) => typeof item?.str === 'string' ? item.str : '')
+          .filter(Boolean)
+          .join(' ')
+          .trim();
+        const block = `--- Page ${pageNumber} ---\n${body || '(no extractable text on this page)'}`;
+        const separatorBytes = chunks.length ? 2 : 0;
+        const remaining = byteLimit - bytes - separatorBytes;
+        if (remaining <= 0) {
+          truncated = true;
+          break;
+        }
+        const bounded = boundedUtf8(block, remaining);
+        if (chunks.length) {
+          chunks.push('\n\n');
+          bytes += 2;
+        }
+        chunks.push(bounded.text);
+        bytes += bounded.bytes;
+        if (bounded.truncated) {
+          truncated = true;
+          break;
+        }
+      } finally {
+        try { page.cleanup?.(); } catch {}
+      }
+    }
+    if (truncated) {
+      const suffix = '\n\n... [PDF text truncated to the prompt input budget]';
+      const room = Math.max(0, byteLimit - Buffer.byteLength(suffix, 'utf8'));
+      const bounded = boundedUtf8(chunks.join(''), room);
+      return { pageCount, text: `${bounded.text}${suffix}`, truncated: true };
+    }
+    return { pageCount, text: chunks.join(''), truncated: false };
+  } finally {
+    try { await pdf.destroy?.(); } catch {}
+  }
+}