mixdog 0.9.174 → 1.0.0

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

@@ -113,7 +113,7 @@ function _residentDiskBytes() {
   return total;
 }
 
-function _pruneDiskCodeGraphEntries(_now = Date.now()) {
+function _pruneDiskCodeGraphEntries() {
   for (const [cwd, entry] of _diskCodeGraphCache) {
     if (!entry || typeof entry !== 'object') {
       _dropDiskEntry(cwd);
@@ -326,7 +326,7 @@ function _loadDiskCodeGraphCache(now = Date.now()) {
     process.stderr.write(`[code-graph] disk manifest load failed: ${err?.message || err}\n`);
   }
   if (!_diskManifest) _diskManifest = {};
-  _pruneDiskCodeGraphEntries(now);
+  _pruneDiskCodeGraphEntries();
   try {
     const dir = _codeGraphDiskDir();
     mkdirSync(dir, { recursive: true });

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

@@ -52,12 +52,12 @@ export async function callees(ctx) {
 // The symbol, language and limit a scoped call query runs with, or the error
 // answer when the file anchor does not resolve.
 async function scopedCallContext(mode, ctx) {
-  const { args, cwd, signal, graph, normFile, rel, node, scopeRelPrefix } = ctx;
+  const { args, signal, graph, normFile, rel, node, scopeRelPrefix } = ctx;
   const symbol = requiredSymbol(mode, args);
   const explicitLanguage = languageArg(args);
   const narrowedByCaller = Boolean(rel || scopeRelPrefix || explicitLanguage);
   if (node) await _prewarmSourceTextNodes(graph, [node], { signal });
-  const resolved = _resolveReferenceLanguageNode(graph, symbol, rel, cwd, explicitLanguage);
+  const resolved = _resolveReferenceLanguageNode(graph, symbol, rel, explicitLanguage);
   if (rel && resolved.kind === 'file-not-found') return { error: fileNotFound(mode, ctx) };
   if (rel && resolved.kind === 'symbol-not-present') {
     return { error: `Error: code_graph ${mode}: symbol "${symbol}" not found in ${normFile || rel}` };
@@ -83,7 +83,7 @@ export async function references(ctx) {
   if (scoped.error) return scoped.error;
   const { symbol, lang, narrowedByCaller, userLimit } = scoped;
   const refNodes = await _prewarmReferenceSourceText(graph, symbol, lang, { signal });
-  const refResult = _cheapReferenceSearch(graph, symbol, cwd, {
+  const refResult = _cheapReferenceSearch(graph, symbol, {
     language: lang,
     fileRel: rel,
     scopeRelPrefix,

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

@@ -3,6 +3,7 @@
 import { resolve as pathResolve, dirname, join } from 'node:path';
 import { existsSync, readdirSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
+import { canonicalGraphPath } from '../code-graph-state.mjs';
 
 // P1: project-root sentinels. A directory containing any of these (or with one
 // at an ancestor) is treated as a real project we may index.
@@ -41,11 +42,6 @@ function _userBoundaryDirs() {
   return dirs.filter(Boolean);
 }
 
-function _dirKey(dir) {
-  const resolved = pathResolve(dir);
-  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
-}
-
 // P1: resolve a file to its nearest project root (sentinel ancestor).
 // Returns null when no root found; caller throws rather than falling back.
 // `opts` forwards to the directory walk, so a file anchor can decline the same
@@ -65,10 +61,10 @@ export function _resolveFileProjectRoot(file, opts = {}) {
 // there. `boundaries` is injectable so the boundary rule stays testable.
 export function _findDirProjectRoot(dir, { stopAtUserBoundary = false, boundaries = null } = {}) {
   if (!dir) return null;
-  const stops = stopAtUserBoundary ? new Set((boundaries || _userBoundaryDirs()).map(_dirKey)) : null;
+  const stops = stopAtUserBoundary ? new Set((boundaries || _userBoundaryDirs()).map(canonicalGraphPath)) : null;
   let d = pathResolve(dir);
   while (d && d !== dirname(d)) {
-    if (stops?.has(_dirKey(d))) return null;
+    if (stops?.has(canonicalGraphPath(d))) return null;
     if (_PROJECT_ROOT_SENTINELS.some((s) => existsSync(join(d, s)))) return d;
     d = dirname(d);
   }

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

@@ -4,6 +4,7 @@ import { relative } from 'node:path';
 import { _graphRel, _getSourceTextForNode, _getSourceLinesForNode } from './source-access.mjs';
 import { _astCallerCallSites, _astFileCallSites, _astCallDisplayCol, _astRelInScope } from './ast-calls.mjs';
 import {
+  _escapeRegExp,
   _unicodeBoundaryPattern,
   _lookupCandidateNodes,
   _getTokenSymbolsForNode,
@@ -81,16 +82,23 @@ export function _impactSourceNodes(node, graph, targetSymbol = '') {
   return out;
 }
 
-function _buildImpactSummary(node, graph, cwd, targetSymbol = '') {
+// A file's import edges, reverse edges, and their union — the structural
+// neighbourhood `related` lists and `impact` starts from.
+function _structuralNeighbors(node, graph, cwd) {
   const imports = node.resolvedImports.map((p) => _graphRel(p, cwd));
   const dependents = [...(graph.reverse.get(node.rel) || [])].sort();
   const related = [...new Set([...imports, ...dependents])].sort();
+  return { imports, dependents, related };
+}
+
+function _buildImpactSummary(node, graph, cwd, targetSymbol = '') {
+  const { imports, dependents, related } = _structuralNeighbors(node, graph, cwd);
   const symbols = targetSymbol ? [targetSymbol] : _collectImpactSymbols(node).slice(0, 8);
   const symbolImpact = [];
   const externalCallers = new Set();
   let externalReferences = 0;
   for (const symbol of symbols) {
-    const refs = _parseReferenceEntries(_cheapReferenceSearch(graph, symbol, cwd, { language: node.lang })).filter(
+    const refs = _parseReferenceEntries(_cheapReferenceSearch(graph, symbol, { language: node.lang })).filter(
       (entry) => entry.file !== node.rel
     );
     if (refs.length === 0) continue;
@@ -112,9 +120,7 @@ function _buildImpactSummary(node, graph, cwd, targetSymbol = '') {
 }
 
 export function _formatRelated(node, graph, cwd) {
-  const imports = node.resolvedImports.map((p) => _graphRel(p, cwd));
-  const dependents = [...(graph.reverse.get(node.rel) || [])].sort();
-  const related = [...new Set([...imports, ...dependents])].sort();
+  const { imports, dependents, related } = _structuralNeighbors(node, graph, cwd);
   const lines = [
     `file\t${node.rel}`,
     `language\t${node.lang}`,
@@ -321,7 +327,7 @@ export function _findSymbolAcrossGraph(
   return lines.join('\n');
 }
 
-export function _resolveReferenceLanguageNode(graph, symbol, rel, _cwd, language = null) {
+export function _resolveReferenceLanguageNode(graph, symbol, rel, language = null) {
   if (rel) {
     const node = graph.nodes.get(rel);
     if (!node) return { kind: 'file-not-found', node: null, file: rel };
@@ -339,7 +345,7 @@ export function _resolveReferenceLanguageNode(graph, symbol, rel, _cwd, language
 }
 
 function _referenceKind(line, symbol, lang = null) {
-  const escaped = String(symbol || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const escaped = _escapeRegExp(symbol);
   if (!escaped) return 'reference';
   const text = String(line || '');
   if (
@@ -440,13 +446,12 @@ function _textReferenceEntries(graph, symbol, referenceText) {
   for (const entry of _parseReferenceEntries(referenceText)) {
     const node = graph.nodes.get(entry.file);
     if (!node) continue;
-    const sourceText = _getSourceTextForNode(graph, node);
-    const sourceLines = sourceText.split(/\r?\n/);
+    const sourceLines = _getSourceLinesForNode(graph, node);
     const line = String(sourceLines[entry.line - 1] || '').trim();
     if (!line) continue;
     if (_referenceKind(line, symbol, node.lang) !== 'reference') continue;
     const _encByteCol = _toByteColumn(sourceLines[entry.line - 1] || '', entry.col);
-    const owner = _symbolPathForPosition(node, sourceText, entry.line, _encByteCol);
+    const owner = _symbolPathForPosition(node, entry.line, _encByteCol);
     detailed.push({
       ...entry,
       kind: 'reference',

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

@@ -12,7 +12,7 @@ import {
   _graphRel,
   _isExistingFile,
 } from './source-access.mjs';
-import { _unicodeBoundaryPattern, _lookupCandidateNodes, _symbolLine } from './symbol-index.mjs';
+import { _escapeRegExp, _unicodeBoundaryPattern, _lookupCandidateNodes, _symbolLine } from './symbol-index.mjs';
 import { CODE_GRAPH_MAX_FILES } from './constants.mjs';
 import { _symbolPathForSymbol } from './text-columns.mjs';
 import { _keywordSymbolSortKey, _tokenizeKeyword, _keywordMatchesSymbolName } from './keyword-match.mjs';
@@ -202,10 +202,9 @@ export async function _prewarmReferenceSourceText(graph, symbol, language, optio
 export function _cheapReferenceSearch(
   graph,
   symbol,
-  _cwd,
   { language = null, fileRel = null, scopeRelPrefix = null, nodes = null } = {}
 ) {
-  const escaped = String(symbol || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const escaped = _escapeRegExp(symbol);
   if (!escaped) return '(no references)';
   // No `limit` in the key: the raw hit set is limit-independent (see below),
   // so every limit shares one cached scan.
@@ -242,8 +241,7 @@ export function _cheapReferenceSearch(
       if (!line.trim()) continue;
       const boundaryLang = language || node.lang;
       const re = new RegExp(_unicodeBoundaryPattern(escaped, boundaryLang, symbol), 'gu');
-      let match = null;
-      while ((match = re.exec(line))) {
+      for (const match of line.matchAll(re)) {
         if (lines.length < REFERENCE_HIT_CAP) {
           const trimmed = (rawLines[i] ?? line).trim().slice(0, REFERENCE_LINE_CAP);
           lines.push(`${node.rel}:${i + 1}:${match.index + 1}    ${trimmed}`);
@@ -417,7 +415,7 @@ export function _findSymbolHits(graph, symbol, { language = null } = {}) {
 // it just declares nothing.
 function _findSymbolHitsOnNodes(graph, cleanSymbol, candidateNodes, { language = null } = {}) {
   if (!cleanSymbol) return [];
-  const escaped = cleanSymbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const escaped = _escapeRegExp(cleanSymbol);
   const hits = [];
   for (const node of candidateNodes) {
     const nativeSymbols = (Array.isArray(node.symbols) ? node.symbols : []).filter(
@@ -454,10 +452,8 @@ function _findSymbolHitsOnNodes(graph, cleanSymbol, candidateNodes, { language =
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
       if (!line.trim()) continue;
-      re.lastIndex = 0;
       let localHit = false;
-      let match = null;
-      while ((match = re.exec(line))) {
+      for (const match of line.matchAll(re)) {
         matchCount += 1;
         localHit = true;
         if (firstLine == null) {
@@ -621,7 +617,7 @@ const _IMPORT_SPECIFIER_PATTERNS = [
 ];
 
 function _importedSpecifierForSymbol(graph, node, symbol) {
-  const escaped = String(symbol || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const escaped = _escapeRegExp(symbol);
   if (!escaped) return null;
   const mention = new RegExp(_unicodeBoundaryPattern(escaped, node?.lang, symbol), 'u');
   for (const line of _getSourceLinesForNode(graph, node)) {

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

@@ -15,6 +15,10 @@ import { _getSourceTextForNode, _graphRel } from './source-access.mjs';
 import { _symbolParentIndex, _symbolLevel } from './text-columns.mjs';
 import { oneLine } from '../../../../shared/clean.mjs';
 
+export function _escapeRegExp(text) {
+  return String(text ?? '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 // Unicode-aware word-boundary wrapper for an already-regex-escaped
 // symbol. JS `\b` only fires at ASCII [A-Za-z0-9_] transitions, so
 // CJK / Cyrillic / Greek identifiers never matched the legacy shape.

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

@@ -8,7 +8,7 @@ export function _toByteColumn(lineText, charCol) {
   return Buffer.byteLength(prefix, 'utf8') + 1;
 }
 
-export function _nearestEnclosingSymbol(node, _sourceText, lineNumber, col = null) {
+export function _nearestEnclosingSymbol(node, lineNumber, col = null) {
   const FUNCTION_LIKE = FUNCTION_LIKE_SYMBOL_KINDS;
   const symbols = Array.isArray(node?.symbols) ? node.symbols : [];
   const inRange = (item) => {
@@ -118,7 +118,7 @@ export function _symbolPathForSymbol(node, symbol) {
   return [..._symbolAncestors(node, symbol), symbol].map((item) => item.name).join('/');
 }
 
-export function _symbolPathForPosition(node, sourceText, lineNumber, col = null) {
-  const symbol = _nearestEnclosingSymbol(node, sourceText, lineNumber, col);
+export function _symbolPathForPosition(node, lineNumber, col = null) {
+  const symbol = _nearestEnclosingSymbol(node, lineNumber, col);
   return symbol ? _symbolPathForSymbol(node, symbol) : '';
 }

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

@@ -1,7 +1,8 @@
 import { statSync } from 'node:fs';
 import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
-import { listProjects } from '../../../../../standalone/projects.mjs';
+import { listProjects } from '../../../../shared/projects.mjs';
 import { explicitSessionCwd, readLastSessionCwd } from '../../../../shared/user-cwd.mjs';
+import { canonicalGraphPath } from '../code-graph-state.mjs';
 import { listCachedCodeGraphRoots } from './disk-cache.mjs';
 import { _findDirProjectRoot } from './project-root.mjs';
 
@@ -30,11 +31,6 @@ export function _isFilesystemRootPath(value) {
   }
 }
 
-function pathKey(path) {
-  const abs = resolve(path);
-  return process.platform === 'win32' ? abs.toLowerCase() : abs;
-}
-
 export function _pathIsWithin(root, candidate) {
   try {
     const rel = relative(resolve(root), resolve(candidate));
@@ -83,7 +79,7 @@ export function collectTrustedCodeGraphRoots(
     const detected = row.detect ? projectRoot(candidate) : null;
     if (detected) candidate = resolve(detected);
     if (_isFilesystemRootPath(candidate) || !directory(candidate) || !_pathIsWithin(root, candidate)) continue;
-    const key = pathKey(candidate);
+    const key = canonicalGraphPath(candidate);
     if (!found.has(key)) found.set(key, candidate);
   }
   return [...found.values()].sort((a, b) => a.localeCompare(b));

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

@@ -1,84 +1 @@
-import { existsSync } from 'node:fs';
-import { dirname, join, resolve as pathResolve } from 'node:path';
-
-export const codeGraphCache = new Map();
-const codeGraphDirtyPaths = new Map();
-
-const codeGraphDirtyGen = new Map();
-let drainCodeGraphCacheFn = null;
-
-export function canonicalGraphCwd(cwd) {
-  if (!cwd) throw new Error('code_graph requires cwd - caller did not provide a working directory');
-  const full = pathResolve(cwd);
-  return process.platform === 'win32' ? full.toLowerCase() : full;
-}
-
-function canonicalGraphPath(p) {
-  const full = pathResolve(String(p || ''));
-  return process.platform === 'win32' ? full.toLowerCase() : full;
-}
-
-export function getCodeGraphGen(graphCwd) {
-  return codeGraphDirtyGen.get(graphCwd) || 0;
-}
-
-function bumpCodeGraphGen(graphCwd) {
-  codeGraphDirtyGen.set(graphCwd, (codeGraphDirtyGen.get(graphCwd) || 0) + 1);
-}
-
-export function consumeCodeGraphDirtyPaths(cwd) {
-  const key = canonicalGraphCwd(cwd);
-  const set = codeGraphDirtyPaths.get(key);
-  if (!set || set.size === 0) return [];
-  codeGraphDirtyPaths.delete(key);
-  return [...set];
-}
-
-// Accept absolute written paths only; resolve affected indexed roots centrally.
-export function markCodeGraphDirtyPaths(paths) {
-  const values = Array.isArray(paths) ? paths : [paths];
-  const cleaned = values.filter(Boolean).map((p) => canonicalGraphPath(p));
-  if (cleaned.length === 0) return;
-
-  const knownRoots = new Set([...codeGraphDirtyPaths.keys(), ...codeGraphCache.keys()]);
-  const affectedRoots = new Set();
-  for (const absPath of cleaned) {
-    let matchedThisPath = false;
-    for (const root of knownRoots) {
-      const canonRoot = canonicalGraphPath(root);
-      if (absPath.startsWith(`${canonRoot}/`) || absPath.startsWith(`${canonRoot}\\`) || absPath === canonRoot) {
-        affectedRoots.add(root);
-        matchedThisPath = true;
-      }
-    }
-    if (!matchedThisPath) {
-      let dir = dirname(absPath);
-      while (dir && dir !== dirname(dir)) {
-        if (existsSync(join(dir, 'package.json')) || existsSync(join(dir, '.git'))) {
-          affectedRoots.add(canonicalGraphCwd(dir));
-          break;
-        }
-        dir = dirname(dir);
-      }
-    }
-  }
-
-  for (const root of affectedRoots) {
-    if (!codeGraphDirtyPaths.has(root)) codeGraphDirtyPaths.set(root, new Set());
-    const set = codeGraphDirtyPaths.get(root);
-    for (const p of cleaned) set.add(p);
-
-    const canonRoot = canonicalGraphCwd(root);
-    codeGraphCache.delete(canonRoot);
-    bumpCodeGraphGen(canonRoot);
-  }
-}
-
-export function registerCodeGraphDrain(fn) {
-  drainCodeGraphCacheFn = typeof fn === 'function' ? fn : null;
-}
-
-export function drainCodeGraphCache() {
-  if (!drainCodeGraphCacheFn) return;
-  drainCodeGraphCacheFn();
-}
+export * from '../../../shared/code-graph-state.mjs';

package/src/runtime/agent/orchestrator/tools/destructive-warning.mjs

@@ -7,7 +7,7 @@
 // hard blocks remain in the shared shell policy scan.
 
 import { SHELL_NAMES as _SHELL_NAMES, WRAPPER_NAMES as _WRAPPER_NAMES } from './shell-policy.mjs';
-import { extractPowerShellCommandInner } from './shell-command.mjs';
+import { extractPowerShellCommandInner } from './shell-powershell.mjs';
 
 export function stripQuotedAndHeredoc(s) {
   return String(s || '')
@@ -21,8 +21,7 @@ export function stripQuotedAndHeredoc(s) {
 export function extractHeredocBodies(s) {
   const out = [];
   const re = /<<-?\s*['"]?(\w+)['"]?([\s\S]*?)\n\1\b/g;
-  let m;
-  while ((m = re.exec(String(s || ''))) !== null) out.push(m[2]);
+  for (const m of String(s || '').matchAll(re)) out.push(m[2]);
   return out;
 }
 
@@ -251,6 +250,13 @@ export function extractShellCInner(s) {
   return out;
 }
 
+function _removalWarning(recursive, force) {
+  if (recursive && force) return 'may recursively force-remove files';
+  if (recursive) return 'may recursively remove files';
+  if (force) return 'may force-remove files';
+  return null;
+}
+
 // rm: detect -r/-R/--recursive AND -f/--force across split or combined
 // short-flag tokens.
 function _classifyRm(args) {
@@ -274,10 +280,7 @@ function _classifyRm(args) {
     if (t.startsWith('-')) continue;
     break;
   }
-  if (r && f) return 'may recursively force-remove files';
-  if (r) return 'may recursively remove files';
-  if (f) return 'may force-remove files';
-  return null;
+  return _removalWarning(r, f);
 }
 
 // PowerShell Remove-Item (and aliases): -Recurse/-Force, including :$true forms.
@@ -303,10 +306,7 @@ function _classifyRemoveItem(args) {
     }
     break;
   }
-  if (r && f) return 'may recursively force-remove files';
-  if (r) return 'may recursively remove files';
-  if (f) return 'may force-remove files';
-  return null;
+  return _removalWarning(r, f);
 }
 
 // git: skip global options (-C path, -c key=val, --git-dir=..., --no-pager

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

@@ -1,30 +1,30 @@
 {
-  "version": "0.1.29",
+  "version": "0.1.30",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.29/mixdog-graph-darwin-arm64",
-      "sha256": "ef72b6b963a896e2b77cda2c1a5766186b334ff2abde1d8a4998d8fac767e742"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-darwin-arm64",
+      "sha256": "cf306f716eeacb46b4a6a99b94ceb97f20be6facc7e4c6aa3274124e38a13efc"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.29/mixdog-graph-darwin-x64",
-      "sha256": "d2496ad6c6f220f6da507aafd4d410ea287a54e5fa4b88be3bebb6757201f55f"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-darwin-x64",
+      "sha256": "2ed1d6d98bee1db750c5b9df86ee2affa59f0afce28e2753772dca1dcdf9dd6d"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.29/mixdog-graph-linux-arm64",
-      "sha256": "e8d134ea95ee6e2ab5491a71069e80d83db9d6b2cd2625c7278e21e71d912c14"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-linux-arm64",
+      "sha256": "9963d0fb086bcd99341436458b207b6e521e9750bf75f817f0e6e99ebf7a30db"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.29/mixdog-graph-linux-x64",
-      "sha256": "e1009ba702af6c8fc906b6ef66db4b6bc3f9f5874ac62f7b11f09d45f5b591b7"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-linux-x64",
+      "sha256": "79c6811c6bb3e05f4e048ebbe98bf28429e4b82763106c488d929668a2326cba"
     },
     "win32-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.29/mixdog-graph-win32-arm64.exe",
-      "sha256": "32d9ef461ad87b46d4b78aa67b48717d0c83fab7326e4a639a4ddc09b85e72f1"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-win32-arm64.exe",
+      "sha256": "8a1c8d623ee6e54948da2c77f5a8def5c9eafc3c6f2866c0c46c91bdaae393d0"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.29/mixdog-graph-win32-x64.exe",
-      "sha256": "42f50e7c5b3faf84ae5b54bb028a7e03ac47a1c689525d5cf13089fc2d91469a"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-win32-x64.exe",
+      "sha256": "8d123e5044aee4b41e820361bd0dd1012a09a2da93a0074d21774602505784f4"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/io-trace.mjs

@@ -0,0 +1,28 @@
+// MIXDOG_IO_TRACE stderr tracing shared by the builtin, atomic-write and patch layers.
+import { performance } from 'node:perf_hooks';
+import { envFlag } from '../../../shared/env.mjs';
+
+export function createIoTrace(enabled) {
+  const start = () => (enabled() ? performance.now() : 0);
+  const trace = (event, fields = {}) => {
+    if (!enabled()) return;
+    try {
+      process.stderr.write(`[io-trace] ${JSON.stringify({ event, ts: Date.now(), ...fields })}\n`);
+    } catch {}
+  };
+  const done = (event, started, fields = {}) => {
+    if (!started || !enabled()) return;
+    trace(event, {
+      ...fields,
+      ms: Number((performance.now() - started).toFixed(3)),
+    });
+  };
+  return { enabled, start, trace, done };
+}
+
+export const {
+  enabled: ioTraceEnabled,
+  start: ioTraceStart,
+  trace: ioTrace,
+  done: ioTraceDone,
+} = createIoTrace(() => envFlag('MIXDOG_IO_TRACE'));

package/src/runtime/agent/orchestrator/tools/lib/shell-run-spawn.mjs

@@ -3,10 +3,15 @@
 // delayed live foreground record once the command has reached a shell.
 import { acquire as acquireChildSpawnSlot } from '../../../../shared/child-spawn-gate.mjs';
 import { publishForegroundShellRecord, trackForegroundShellJob } from '../builtin/shell-jobs.mjs';
-import { nativeSpawnFileCaptureReady, setNativeTaskStartedAt } from './native-spawn-client.mjs';
+import {
+  nativeSpawnFileCaptureReady,
+  nativeSpawnSupportsStdinPipe,
+  setNativeTaskStartedAt,
+  warmNativeSpawnServer,
+} from './native-spawn-client.mjs';
 import { _maybeEncodePowerShellCommand } from '../shell-powershell.mjs';
 import { spawnShellWithRetry as _spawnShellWithRetry } from './shell-spawn-retry.mjs';
-import { takeWarmShellStandby } from './shell-warm-standby.mjs';
+import { STANDBY_ARGS, takeWarmShellStandby } from './shell-warm-standby.mjs';
 import { SHELL_OUTPUT_DISK_CAP } from '../shell-exec-output.mjs';
 
 // Foreground visibility threshold. Every shell readout (CLI statusline,
@@ -40,7 +45,7 @@ async function takeStandby({ run, useDirectArgv, shell, shellArg, env, cwd, comm
   if (useDirectArgv || shellArg !== '-Command') return null;
   let standby = null;
   try {
-    standby = takeWarmShellStandby({ shell, env, cwd });
+    standby = takeWarmShellStandby({ shell, env });
   } catch {
     standby = null;
   }
@@ -74,6 +79,7 @@ async function takeStandby({ run, useDirectArgv, shell, shellArg, env, cwd, comm
 async function gatedSpawn({
   run,
   argv,
+  stdinPipe,
   shell,
   shellArg,
   env,
@@ -119,6 +125,7 @@ async function gatedSpawn({
         command,
         ownerSessionId,
         clientHostPid,
+        ...(stdinPipe ? { stdinPipe: true } : {}),
         ...(capture
           ? {
               stdoutPath: taskOutput.stdoutPath,
@@ -174,14 +181,40 @@ export async function spawnShellChild({
     ownerSessionId,
     clientHostPid,
   });
+  // Standby miss on pwsh: spawn a fresh pwsh with the standby bootstrap and
+  // feed the script through stdin, so a parse error is still reported in
+  // UTF-8 and both paths run the script identically. Spawn servers without
+  // stdin-pipe support keep the -Command argv delivery.
+  const stdinScript =
+    !standby &&
+    !useDirectArgv &&
+    shellArg === '-Command' &&
+    (await warmNativeSpawnServer()) &&
+    nativeSpawnSupportsStdinPipe()
+      ? spawnCommand
+      : null;
   const spawned =
     standby?.spawned ??
-    (await gatedSpawn({ run, argv, shell, shellArg, env, cwd, abortSignal, command, ownerSessionId, clientHostPid }));
+    (await gatedSpawn({
+      run,
+      argv: stdinScript === null ? argv : STANDBY_ARGS,
+      stdinPipe: stdinScript !== null,
+      shell,
+      shellArg,
+      env,
+      cwd,
+      abortSignal,
+      command,
+      ownerSessionId,
+      clientHostPid,
+    }));
   run.child = spawned.child;
   spawned.attachErrorHandler(onChildError);
-  // Feed the standby only after the error handler is attached; server
+  // Feed the script only after the error handler is attached; server
   // messages cannot be processed before this synchronous block yields.
+  // Single atomic write+EOF, as for the standby.
   if (standby) standby.feed(spawnCommand, cwd);
+  else if (stdinScript !== null) spawned.child.writeStdin(stdinScript, { close: true });
   // The command has now reached a shell. This is the start moment every
   // readout measures from, and the point from which a still-running
   // command deserves to be visible in the shell readouts.

package/src/runtime/agent/orchestrator/tools/lib/shell-warm-standby.mjs

@@ -9,13 +9,19 @@ import { nativeSpawnSupportsStdinPipe, setNativeSpawnRequestIdle, tryNativeSpawn
 import { SHELL_OUTPUT_DISK_CAP } from '../shell-exec-output.mjs';
 
 // Bootstrap: pre-warm scriptblock compilation while parked, re-decode stdin
-// as UTF-8 (console input encoding would mangle non-ASCII), then dot-source
-// the fed script. Dot-sourcing itself can reset $? after a failed external
+// as UTF-8 (console input encoding would mangle non-ASCII), set UTF-8 output
+// before the fed script compiles (a parse error is reported before the
+// script's own encoding prefix runs, and would otherwise surface in the OEM
+// code page), then dot-source the fed script. A parse failure surfaces as
+// Create()'s MethodInvocation wrapper; report the underlying parse error
+// instead, with -Command's exit 1. Dot-sourcing itself can reset $? after a failed external
 // script (including npm.ps1), so preserve the final status inside the block.
 // Explicit exit codes still exit immediately; ordinary failure maps to 1,
 // matching -Command rather than leaking an earlier $LASTEXITCODE.
+// Fresh (non-standby) pwsh spawns use the same bootstrap with the script fed
+// through stdin, so both paths share one delivery and one set of semantics.
 const STANDBY_BOOTSTRAP =
-  '$null = . ([scriptblock]::Create(\'$null\')); [Console]::InputEncoding=[System.Text.UTF8Encoding]::new($false); . ([scriptblock]::Create([Console]::In.ReadToEnd() + "`nif (-not `$?) { exit 1 }"))';
+  "$null = . ([scriptblock]::Create('$null')); [Console]::InputEncoding=[System.Text.UTF8Encoding]::new($false); [Console]::OutputEncoding=[System.Text.UTF8Encoding]::new($false); try { $__mixdogScript = [scriptblock]::Create([Console]::In.ReadToEnd() + \"`nif (-not `$?) { exit 1 }\") } catch { [Console]::Error.WriteLine('ParserError: ' + $_.Exception.GetBaseException().Message); exit 1 }; . $__mixdogScript";
 export const STANDBY_ARGS = ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', STANDBY_BOOTSTRAP];
 const _configuredIdleMs = Number(process.env.MIXDOG_SHELL_WARM_STANDBY_IDLE_MS);
 const STANDBY_TTL_MS =
@@ -113,7 +119,7 @@ function ensureWarmShellStandby({ shell, env }) {
 
 /** Take the parked standby for immediate use, or null on any mismatch.
  *  Always refills so the NEXT call finds a warm one. */
-export function takeWarmShellStandby({ shell, env, cwd: _cwd }) {
+export function takeWarmShellStandby({ shell, env }) {
   if (_disabled() || !shell) return null;
   const slot = _slot;
   const refill = () => {