mixdog 1.2.0 → 1.2.1

package/src/runtime/agent/orchestrator/tools/builtin/read-source-windows.mjs

@@ -45,7 +45,10 @@ async function scanSourceWindows(path, intervals, signal) {
     let parts = [];
     let partBytes = 0;
     const lines = new Map();
-    const buffer = Buffer.allocUnsafe(64 * 1024);
+    const minChunkBytes = 64 * 1024;
+    const maxChunkBytes = 1024 * 1024;
+    let chunkBytes = minChunkBytes;
+    let buffer = Buffer.allocUnsafe(chunkBytes);
     const deadline = Date.now() + READ_STREAM_TIMEOUT_MS;
     const check = () => {
       signal?.throwIfAborted();
@@ -70,7 +73,11 @@ async function scanSourceWindows(path, intervals, signal) {
     };
     while (interval < intervals.length) {
       check();
-      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (buffer.length < chunkBytes) buffer = Buffer.allocUnsafe(chunkBytes);
+      // Consume every byte inside the budget, even when a seeking chunk would
+      // cross it. The one-byte EOF probe never becomes usable source text.
+      const readBytes = Math.min(chunkBytes, Math.max(1, READ_MAX_SCAN_BYTES - scanned));
+      const { bytesRead } = await handle.read(buffer, 0, readBytes, position);
       check();
       if (!bytesRead) {
         if (partBytes) save(Buffer.alloc(0), true);
@@ -95,6 +102,12 @@ async function scanSourceWindows(path, intervals, signal) {
         start = end + 1;
       }
       position += bytesRead;
+      // Deep windows still validate coordinates from current bytes. Amortize
+      // positional IO while skipping, then return to small reads in a window.
+      chunkBytes =
+        interval < intervals.length && line < intervals[interval].start
+          ? Math.min(maxChunkBytes, chunkBytes * 2)
+          : minChunkBytes;
     }
     // Publication checks after its async stats, immediately before committing.
     // An unpublished result still owes a final deadline/cancellation check.

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

@@ -254,8 +254,8 @@ function absolutePaths(lines, rgCwd) {
   return lines.map((line) => (isAbsolute(line) ? line : resolveAgainstCwd(line, rgCwd)));
 }
 
-function missingGlobRoot(scan, root, rgCwd, err) {
-  const hint = buildNotFoundHint(scan.workDir, rgCwd, 'Search', err?.code);
+async function missingGlobRoot(scan, root, rgCwd, err) {
+  const hint = await buildNotFoundHint(scan.workDir, rgCwd, 'Search', err?.code);
   return {
     error: `path does not exist: ${normalizeOutputPath(rgCwd)} (${err?.code || 'ENOENT'})${finalizeReadFamilyEnoentTail(hint, root, err?.code)}`,
     paths: [],
@@ -422,14 +422,14 @@ function globMoreSuffix({ rgWindowIncomplete, remaining, totalBeforeOffset, next
   return '';
 }
 
-function globEmptyDiagnostic(scan, { totalBeforeOffset }) {
+async function globEmptyDiagnostic(scan, { totalBeforeOffset }) {
   const { patterns, basePath, baseEntries, workDir, statCache, offset } = scan;
   const patternStr = patterns.length === 1 ? JSON.stringify(patterns[0]) : JSON.stringify(patterns);
   const baseLabel = normalizeOutputPath(basePath);
   if (totalBeforeOffset > 0 && offset >= totalBeforeOffset) {
     return `(no entries after offset=${offset}; total=${totalBeforeOffset}) pattern=${patternStr} path=${baseLabel}`;
   }
-  const diagnostic = basePathDiagnostic(
+  const diagnostic = await basePathDiagnostic(
     baseEntries.map((e) => e.root),
     workDir,
     statCache
@@ -473,7 +473,7 @@ async function scanGlobGroups(scan) {
     const shown = await directAbsoluteMatches({ patterns, headLimit, offset });
     if (shown.length > 0) return patternCapNote + shown.join('\n');
   }
-  const out = patternCapNote + renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, miss });
+  const out = patternCapNote + (await renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, miss }));
   settleGlobScanCache(scan, merged, out, remaining);
   reportToolProgress(options, `found ${totalBeforeOffset} files`);
   return out;
@@ -482,7 +482,7 @@ async function scanGlobGroups(scan) {
 // The page body with its more/integrity suffixes. Empty partials are not
 // proof of absence: diagnostics are preserved even when there is no path
 // body, rather than silently dropping the integrity suffix.
-function renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, miss }) {
+async function renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, miss }) {
   const { offset } = scan;
   const errSuffix = globIntegritySuffix(merged);
   const moreSuffix = globMoreSuffix({
@@ -492,7 +492,7 @@ function renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, mi
     nextOffset: offset + capped.length,
   });
   if (capped.length > 0) return `${capped.join('\n')}${moreSuffix}${errSuffix}`;
-  const emptyDiag = miss ? globEmptyDiagnostic(scan, { totalBeforeOffset }) : '';
+  const emptyDiag = miss ? await globEmptyDiagnostic(scan, { totalBeforeOffset }) : '';
   const emptyBody = (emptyDiag || '(no files found)').replace(
     '(no files found)',
     merged.rgStdoutPartial || merged.rgWindowIncomplete ? '(no files found yet)' : '(no files found)'
@@ -608,9 +608,12 @@ export async function executeGlobTool(args, workDir, options = {}) {
   };
   return await runScopedSearchInFlight(
     cacheKey,
-    ({ signal: sharedSignal, scopedCacheOutcome }) => scanGlobGroups({
-      ...scan, sharedSignal, options: { ...options, scopedCacheOutcome },
-    }),
+    ({ signal: sharedSignal, scopedCacheOutcome }) =>
+      scanGlobGroups({
+        ...scan,
+        sharedSignal,
+        options: { ...options, scopedCacheOutcome },
+      }),
     { signal: options?.signal || options?.abortSignal || null, scopes },
     options?.scopedCacheOutcome
   );

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

@@ -211,7 +211,7 @@ async function runGrepSearch(request, sharedSignal) {
 
 async function grepMissingPathResult({ workDir, grepResolvedPath, searchPath, executeChildBuiltinTool }, err) {
   const msg = `Error: path does not exist: ${normalizeOutputPath(grepResolvedPath)} (${err?.code || 'ENOENT'})`;
-  let hint = buildNotFoundHintBody(workDir, grepResolvedPath, 'Search', err?.code, {});
+  let hint = await buildNotFoundHintBody(workDir, grepResolvedPath, 'Search', err?.code, {});
   if (!hint) hint = await _suggestIndexedPaths(grepResolvedPath, executeChildBuiltinTool, workDir);
   return msg + finalizeReadFamilyEnoentTail(appendNotFoundCwdNote(hint, workDir, err?.code), searchPath, err?.code);
 }

package/src/runtime/agent/orchestrator/tools/builtin/search-path-diagnostics.mjs

@@ -65,10 +65,10 @@ const ENOENT_ABSENT =
 
 // Share diagnostic lookup results within one invocation without changing
 // the requested operand or executing a replacement operation.
-function cachedFileByBasename(workDir, missingPath, cache) {
+async function cachedFileByBasename(workDir, missingPath, cache) {
   if (!cache) return findFileByBasename(workDir, missingPath);
   if (!('fileHits' in cache)) cache.fileHits = findFileByBasename(workDir, missingPath);
-  return cache.fileHits;
+  return await cache.fileHits;
 }
 
 // A missing ABSOLUTE path that resolves outside the project cannot be
@@ -180,15 +180,15 @@ export function appendNotFoundCwdNote(hint, workDir, errCode = 'ENOENT') {
   return `${hint} (relative paths resolve from ${normalizeOutputPath(workDir)})`;
 }
 
-export function buildNotFoundHint(workDir, missingPath, actionVerb, errCode = 'ENOENT', cache = null) {
+export async function buildNotFoundHint(workDir, missingPath, actionVerb, errCode = 'ENOENT', cache = null) {
   return appendNotFoundCwdNote(
-    buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode, cache),
+    await buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode, cache),
     workDir,
     errCode
   );
 }
 
-export function buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode = 'ENOENT', cache = null) {
+export async function buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode = 'ENOENT', cache = null) {
   if (!NOT_FOUND_CODES.has(String(errCode || 'ENOENT'))) return '';
   // `C:tmpsmp` shape: a Windows path whose separators were eaten by JSON
   // escaping (`"C:\\tmp\\smp"` written as `"C:\tmp\smp"`). Name the cause —
@@ -200,12 +200,12 @@ export function buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode
   if (missingPathIsOutsideProject(workDir, missingPath)) {
     return outsideProjectNotFoundHint(missingPath, actionVerb);
   }
-  const elsewhere = cachedFileByBasename(workDir, missingPath, cache);
+  const elsewhere = await cachedFileByBasename(workDir, missingPath, cache);
   if (elsewhere.length) {
     return ` Not found at this path; the same filename exists at: ${elsewhere.map((p) => `"${normalizeOutputPath(p)}"`).join(', ')}. ${actionVerb} that path directly.`;
   }
   if (isDirectoryPathGuess(missingPath)) {
-    const dirHits = findDirectoryByBasename(workDir, missingPath, { limit: 5 });
+    const dirHits = await findDirectoryByBasename(workDir, missingPath, { limit: 5 });
     if (dirHits.length > 1) {
       return ` Not found at this path; same-named directories exist at: ${dirHits
         .slice(0, 5)
@@ -268,9 +268,9 @@ export function uncRefusalMessage(toolName, original, resolved) {
   return `Error: ${toolName} refuses UNC/SMB path ${JSON.stringify(shown)}; remote share access is blocked to prevent NTLM credential leaks`;
 }
 
-export function basePathDiagnostic(basePaths, workDir, statCache = null) {
-  return basePaths
-    .map((basePath) => {
+export async function basePathDiagnostic(basePaths, workDir, statCache = null) {
+  const parts = await Promise.all(
+    basePaths.map(async (basePath) => {
       const resolved = resolveSearchScope(basePath, workDir);
       // Reuse the caller's call-scoped stat cache (glob preflight + per-group
       // rg runs already stat'd this same resolved root) instead of re-stating.
@@ -291,8 +291,13 @@ export function basePathDiagnostic(basePaths, workDir, statCache = null) {
       }
       return (
         `${normalizeOutputPath(basePath)}: path does not exist (${err?.code || 'ENOENT'})` +
-        finalizeReadFamilyEnoentTail(buildNotFoundHint(workDir, resolved, 'Search', err?.code), basePath, err?.code)
+        finalizeReadFamilyEnoentTail(
+          await buildNotFoundHint(workDir, resolved, 'Search', err?.code),
+          basePath,
+          err?.code
+        )
       );
     })
-    .join('; ');
+  );
+  return parts.join('; ');
 }

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch/root-resolution.mjs

@@ -79,10 +79,10 @@ export function resolveAggregateAnchorRoot(name, args, baseCwd, { explicitCwdArg
  * One `file` anchor: an error string when it does not exist, otherwise the
  * root it re-homes the call to (null keeps the current cwd).
  */
-export function resolveFileAnchorRoot(name, args, fileArg, baseCwd) {
+export async function resolveFileAnchorRoot(name, args, fileArg, baseCwd) {
   const abs = _absFrom(baseCwd, fileArg);
   if (!existsSync(abs)) {
-    const elsewhere = findFileByBasename(pathResolve(baseCwd), abs);
+    const elsewhere = await findFileByBasename(pathResolve(baseCwd), abs);
     const hint = elsewhere.length
       ? ` Same filename exists at: ${elsewhere.map((p) => `"${toDisplayPath(p, baseCwd).replace(/\\/g, '/')}"`).join(', ')}. Use that path.`
       : '';

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

@@ -345,7 +345,7 @@ async function executeCodeGraphToolRaw(name, rawArgs, cwd, signal = null, option
     args = resolved.args;
   }
   if (fileArg && !hasAggregateFileArgs) {
-    const anchor = resolveFileAnchorRoot(name, args, fileArg, baseCwd);
+    const anchor = await resolveFileAnchorRoot(name, args, fileArg, baseCwd);
     if (anchor.error) return anchor.error;
     if (anchor.root) effectiveCwd = anchor.root;
   }

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

@@ -47,7 +47,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
   let v4aRenamePlan = null;
   if (isV4APatchInput(patchStr, requestedFormat)) {
     try {
-      const parsedSections = preParsedV4ASections || rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
+      const parsedSections = preParsedV4ASections || (await rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath));
       const allSections = coalesceCompatibleV4ASections(parsedSections, basePath);
       v4aRenamePlan = await planV4ARenameSections(allSections, basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(v4aRenamePlan.remainingSections, basePath, v4aConvertOpts);
@@ -56,7 +56,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
     }
   } else if (requestedFormat !== 'unified' && hasUnifiedBareV4AHunk(patchStr)) {
     try {
-      const sections = rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath);
+      const sections = await rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(sections, basePath, v4aConvertOpts);
     } catch (err) {
       throw new Error(`apply_patch: bare @@ parse failed — ${err?.message || String(err)}`);
@@ -82,7 +82,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
       );
     }
     try {
-      const sections = rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath);
+      const sections = await rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(sections, basePath, v4aConvertOpts);
       parsed = parsePatch(prepareInput(inputPatchStr));
     } catch (fallbackErr) {
@@ -91,7 +91,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
       );
     }
   }
-  parsed = rewriteParsedReadRedirects(parsed, basePath);
+  parsed = await rewriteParsedReadRedirects(parsed, basePath);
   if (!Array.isArray(parsed) || parsed.length === 0) {
     return { error: 'Error: patch contained no file sections' };
   }

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

@@ -7,11 +7,11 @@ import { pathKey, resolveV4AEntryPath } from '../paths.mjs';
 import { rewriteV4AReadRedirects } from '../read-redirects.mjs';
 import { isV4ARenameSection } from '../v4a-convert.mjs';
 
-export function selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath }) {
+export async function selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath }) {
   let preParsedV4ASections = null;
   if (isV4APatchInput(patchStr, requestedFormat)) {
     try {
-      preParsedV4ASections = rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
+      preParsedV4ASections = await rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
     } catch {
       // The selected execution path reports the authoritative parse error.
     }

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 });
+  const route = await selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath });
   if (route.useSequence) {
     const seqOut = await applyPatchSequence(patchStr, requestedFormat, basePath, {
       v4aConvertOpts,

package/src/runtime/agent/orchestrator/tools/patch/read-redirects.mjs

@@ -6,7 +6,7 @@ import { resolve as pathResolve, relative as pathRelative, isAbsolute } from 'no
 import { findBySuffixStrip, findFileByBasename } from '../builtin/path-diagnostics.mjs';
 import { resolveEntryPath, resolveV4AEntryPath, classifyEntry, pathKey } from './paths.mjs';
 
-function uniqueExistingPatchTarget(basePath, requestedFullPath) {
+async function uniqueExistingPatchTarget(basePath, requestedFullPath) {
   // Auto-relocation is only valid for a missing target lexically inside the
   // patch root. An explicit outside-root path must never be pulled back into
   // the project merely because a basename happens to match.
@@ -23,14 +23,14 @@ function uniqueExistingPatchTarget(basePath, requestedFullPath) {
   };
   const suffix = asFile(findBySuffixStrip(basePath, requestedFullPath));
   if (suffix) return suffix;
-  const basenameHits = findFileByBasename(basePath, requestedFullPath, { limit: 2 });
+  const basenameHits = await findFileByBasename(basePath, requestedFullPath, { limit: 2 });
   return basenameHits.length === 1 ? asFile(basenameHits[0]) : null;
 }
 
-function redirectedPatchPath(requestedFullPath, basePath) {
+async function redirectedPatchPath(requestedFullPath, basePath) {
   // An existing requested path always wins over relocation.
   if (!requestedFullPath || existsSync(requestedFullPath)) return requestedFullPath;
-  return uniqueExistingPatchTarget(basePath, requestedFullPath) || requestedFullPath;
+  return (await uniqueExistingPatchTarget(basePath, requestedFullPath)) || requestedFullPath;
 }
 
 export function patchHeaderPathForResolved(basePath, fullPath) {
@@ -41,33 +41,37 @@ export function patchHeaderPathForResolved(basePath, fullPath) {
   return fullPath;
 }
 
-export function rewriteV4AReadRedirects(sections, basePath) {
-  return (sections || []).map((section) => {
-    if (!section || section.kind === 'add' || !section.path) return section;
-    const requested = resolveV4AEntryPath(basePath, section.path);
-    const redirected = redirectedPatchPath(requested, basePath);
-    if (pathKey(redirected) === pathKey(requested)) return section;
-    return { ...section, path: patchHeaderPathForResolved(basePath, redirected) };
-  });
+export async function rewriteV4AReadRedirects(sections, basePath) {
+  return Promise.all(
+    (sections || []).map(async (section) => {
+      if (!section || section.kind === 'add' || !section.path) return section;
+      const requested = resolveV4AEntryPath(basePath, section.path);
+      const redirected = await redirectedPatchPath(requested, basePath);
+      if (pathKey(redirected) === pathKey(requested)) return section;
+      return { ...section, path: patchHeaderPathForResolved(basePath, redirected) };
+    })
+  );
 }
 
-export function rewriteParsedReadRedirects(parsed, basePath) {
-  return (parsed || []).map((entry) => {
-    const kind = classifyEntry(entry);
-    if (kind === 'create' || !entry?.oldFileName) return entry;
-    const requested = resolveEntryPath(basePath, entry.oldFileName);
-    const redirected = redirectedPatchPath(requested, basePath);
-    if (pathKey(redirected) === pathKey(requested)) return entry;
-    const rewritten = {
-      ...entry,
-      oldFileName: patchHeaderPathForResolved(basePath, redirected),
-    };
-    if (kind === 'modify' && entry.newFileName) {
-      const newRequested = resolveEntryPath(basePath, entry.newFileName);
-      if (pathKey(newRequested) === pathKey(requested)) {
-        rewritten.newFileName = rewritten.oldFileName;
+export async function rewriteParsedReadRedirects(parsed, basePath) {
+  return Promise.all(
+    (parsed || []).map(async (entry) => {
+      const kind = classifyEntry(entry);
+      if (kind === 'create' || !entry?.oldFileName) return entry;
+      const requested = resolveEntryPath(basePath, entry.oldFileName);
+      const redirected = await redirectedPatchPath(requested, basePath);
+      if (pathKey(redirected) === pathKey(requested)) return entry;
+      const rewritten = {
+        ...entry,
+        oldFileName: patchHeaderPathForResolved(basePath, redirected),
+      };
+      if (kind === 'modify' && entry.newFileName) {
+        const newRequested = resolveEntryPath(basePath, entry.newFileName);
+        if (pathKey(newRequested) === pathKey(requested)) {
+          rewritten.newFileName = rewritten.oldFileName;
+        }
       }
-    }
-    return rewritten;
-  });
+      return rewritten;
+    })
+  );
 }

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

@@ -84,10 +84,10 @@ function parsedEntryUnit(entry, basePath) {
 // Parse the patch body into V4A-style sections (V4A envelope, bare-@@ hunks,
 // or counted-unified salvaged as V4A), or into parsed unified entries for a
 // plain unified diff.
-function parsePatchSections(patchStr, requestedFormat, basePath, { coalesceByFile }) {
+async function parsePatchSections(patchStr, requestedFormat, basePath, { coalesceByFile }) {
   if (isV4APatchInput(patchStr, requestedFormat)) {
     try {
-      const parsedSections = rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
+      const parsedSections = await rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
       return { sections: coalesceByFile ? coalesceCompatibleV4ASections(parsedSections, basePath) : parsedSections };
     } catch (err) {
       throw new Error(`apply_patch: V4A parse failed — ${err?.message || String(err)}`);
@@ -98,7 +98,7 @@ function parsePatchSections(patchStr, requestedFormat, basePath, { coalesceByFil
     // section's conversion into its own unit (ordered-stop preserved) rather
     // than converting the whole patch up front.
     try {
-      return { sections: rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath) };
+      return { sections: await rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath) };
     } catch (err) {
       throw new Error(`apply_patch: bare @@ parse failed — ${err?.message || String(err)}`);
     }
@@ -116,18 +116,18 @@ function parsePatchSections(patchStr, requestedFormat, basePath, { coalesceByFil
     // V4A-style sections and defer per-section conversion — same ordered-stop
     // guarantee as the V4A path (no whole-patch up-front convert).
     try {
-      return { sections: rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath) };
+      return { sections: await rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath) };
     } catch (fallbackErr) {
       throw new Error(
         `apply_patch: parse failed — ${err?.message || String(err)}; V4A fallback failed — ${fallbackErr?.message || String(fallbackErr)}`
       );
     }
   }
-  return { parsed: rewriteParsedReadRedirects(parsed, basePath) };
+  return { parsed: await rewriteParsedReadRedirects(parsed, basePath) };
 }
 
-export function buildPatchUnits(patchStr, requestedFormat, basePath, ctx) {
-  const { sections, parsed } = parsePatchSections(patchStr, requestedFormat, basePath, ctx);
+export async function buildPatchUnits(patchStr, requestedFormat, basePath, ctx) {
+  const { sections, parsed } = await parsePatchSections(patchStr, requestedFormat, basePath, ctx);
   if (sections) return sections.map((section) => sectionUnit(section, basePath, ctx));
   return (parsed || []).map((entry) => parsedEntryUnit(entry, basePath));
 }

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

@@ -30,7 +30,7 @@ export async function applyPatchSequence(patchStr, requestedFormat, basePath, ct
     coalesceByFile = false,
   } = ctx;
 
-  const units = buildPatchUnits(patchStr, requestedFormat, basePath, {
+  const units = await buildPatchUnits(patchStr, requestedFormat, basePath, {
     v4aConvertOpts,
     dryRun,
     readStateScope,

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

@@ -18,6 +18,7 @@ import { randomUUID } from 'node:crypto';
 import { getPluginData } from '../config.mjs';
 import { scrubLoaderVars, scrubProviderSecrets, scrubRuntimeRootVars } from './env-scrub.mjs';
 import { spawnShellWithRetry } from './lib/shell-spawn-retry.mjs';
+import { ensureSkillLauncherDir } from '../../../shared/skill-script-runtime.mjs';
 
 const SNAPSHOT_TIMEOUT_MS = 10_000;
 
@@ -146,6 +147,9 @@ echo "# Shell options" >> "$SNAPSHOT_FILE"
 ${optDump}
 echo "# Aliases" >> "$SNAPSHOT_FILE"
 ${aliasDump}
+# The sourced PATH replaces the model shell's own, so it carries the
+# skill-launcher entry buildShellSpawnEnv prepends (mixdog-skill-node).
+PATH=${_shellQuote(ensureSkillLauncherDir())}:"$PATH"
 # PATH may contain $, backticks, or quotes that would re-expand if we
 # emitted it inside double quotes. Emit a shell-safe single-quoted PATH
 # export line via printf %q-style escaping inside the dump shell.

package/src/runtime/attachments/store.d.mts

@@ -0,0 +1,3 @@
+export function readAttachmentBuffer(value: string | { attachmentRef?: string }): Buffer;
+export function isPermanentAttachmentError(error: unknown): boolean;
+export function isAttachmentReference(value: unknown): boolean;

package/src/runtime/channels/lib/owned-runtime/owned-start.mjs

@@ -97,7 +97,7 @@ export function createOwnedStarter({
     state.automationRunning = true;
   }
   // DEGRADED MODE: a messaging connect failure — packaged runtime without
-  // discord.js, bad token, gateway outage — must not take schedules/webhooks
+  // the provider library, bad token, gateway outage — must not take schedules/webhooks
   // down with it. Sends stay dead (connected=false) but session runs, the
   // webhook server and the relay tunnel keep working.
   async function degradeToAutomation() {

package/src/runtime/channels/lib/webhook/session-dispatch.mjs

@@ -27,6 +27,14 @@ ${payload}
 <<<${_UNTRUSTED}_END>>>`;
 }
 
+/** The run's model-visible prompt (endpoint instructions + fenced external
+ *  payload) and its trusted skill-selection input: the endpoint-authored
+ *  instructions alone, so nothing in the payload or headers selects a skill. */
+function webhookRunPrompt(instructions, body, headers) {
+  const trusted = String(instructions ?? '');
+  return { prompt: `${trusted}\n\n${buildFencedPayload(body, headers)}`, skillSelection: trusted };
+}
+
 function trackDispatch({ name, deliveryId, dispatchP, controller }) {
   let settled = false;
   const timeoutHandle = setTimeout(
@@ -89,6 +97,10 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
         workflow: extra.workflow || null,
         attachments: extra.attachments || null,
         delivery: extra.delivery || null,
+        // Trusted skill-selection input: only the endpoint-authored
+        // instructions, never the fenced external body/headers that share
+        // the model-visible prompt.
+        skillSelection: String(extra.skillSelection ?? ''),
         context: {
           source: 'webhook',
           endpoint: name,
@@ -105,14 +117,14 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
   async function dispatchEndpoint({ name, body, headers, res, deliveryId, endpoint }) {
     try {
       const { model, instructions, cwd, workflow, attachments, delivery } = endpoint;
-      const payloadContent = buildFencedPayload(body, headers);
+      const run = webhookRunPrompt(instructions, body, headers);
       if (!getBridgeDispatch()) throw new Error(`[webhook] session dispatch requires bridgeDispatch`);
-      const fullPrompt = `${instructions}\n\n${payloadContent}`;
-      await dispatchSessionRun(name, model || null, fullPrompt, headers, deliveryId, res, {
+      await dispatchSessionRun(name, model || null, run.prompt, headers, deliveryId, res, {
         cwd: cwd || null,
         workflow: workflow || null,
         attachments: attachments || null,
         delivery: delivery || null,
+        skillSelection: run.skillSelection,
       });
       return true;
     } catch (err) {
@@ -125,4 +137,4 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
   return { dispatchEndpoint };
 }
 
-export { buildFencedPayload, createWebhookSessionDispatcher };
+export { buildFencedPayload, createWebhookSessionDispatcher, webhookRunPrompt };

package/src/runtime/channels/lib/worker-main.mjs

@@ -218,20 +218,23 @@ function wireWebhookHandlers() {
   webhookServer.setEventPipeline(eventPipeline);
   // Webhook fires run as sessions (schedules parity); the Automations
   // session row is the only surface (channel relay retired).
-  webhookServer.setBridgeDispatch(async ({ prompt, model, cwd, workflow, attachments, context, signal }) => {
-    const { runWebhookSession } = await import('../../../session-runtime/webhook-session-run.mjs');
-    const run = await runWebhookSession({
-      name: context?.endpoint || 'webhook',
-      model: model || null,
-      cwd: cwd || null,
-      workflow: workflow || null,
-      attachments: attachments || null,
-      // Dispatch-timeout cancellation only works if the signal reaches the run.
-      signal: signal || null,
-      prompt,
-    });
-    return run;
-  });
+  webhookServer.setBridgeDispatch(
+    async ({ prompt, skillSelection, model, cwd, workflow, attachments, context, signal }) => {
+      const { runWebhookSession } = await import('../../../session-runtime/webhook-session-run.mjs');
+      const run = await runWebhookSession({
+        name: context?.endpoint || 'webhook',
+        model: model || null,
+        cwd: cwd || null,
+        workflow: workflow || null,
+        attachments: attachments || null,
+        // Dispatch-timeout cancellation only works if the signal reaches the run.
+        signal: signal || null,
+        prompt,
+        skillSelection,
+      });
+      return run;
+    }
+  );
 }
 function wireEventQueueHandlers(eventQueue) {
   if (!eventQueue) return;

package/src/runtime/computer-bridge/linux-readiness.mjs

@@ -17,8 +17,6 @@ export const INPUT_GROUP_SECURITY_NOTE =
 export const GNOME_EXTENSION_UUID = 'mixdog-windows@mixdog.io';
 /** The oldest helper interface this app can use (2 added Screenshot and StopRequested, 3 the in-shell indicator). */
 export const MIN_WINDOW_HELPER_VERSION = 3;
-export const WINDOW_CONTROL_HINT =
-  'wayland_window_control_unavailable: this compositor offers no window control to other programs; on GNOME the Mixdog Windows extension (mixdog-windows@mixdog.io) provides it and must be enabled and loaded';
 export const WINDOW_HELPER_RELOGIN_HINT =
   'wayland_window_control_unavailable: the Mixdog Windows GNOME extension is installed and enabled but GNOME Shell has not loaded it yet; the user must sign out and sign in again once';
 export const WINDOW_HELPER_ENABLE_HINT =