mixdog 0.9.135 → 0.9.136

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

@@ -520,7 +520,13 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     // Skipped for pattern arrays and when `-i` is already set.
     const caseHintSuffix = async () => {
         const caseInsensitive = args['-i'] === true;
-        if (caseInsensitive || patterns.length !== 1 || !/[A-Za-z]/.test(patterns[0])) return '';
+        // A broad no-match must not trigger a second whole-tree scan just to
+        // produce an advisory casing hint. The requested case-sensitive result
+        // is already complete; retain the hint only for explicit file scopes.
+        if (grepStat.isDirectory()
+            || caseInsensitive
+            || patterns.length !== 1
+            || !/[A-Za-z]/.test(patterns[0])) return '';
         try {
             const probeArgs = buildGrepRgArgs({
                 patterns,

package/src/runtime/agent/orchestrator/tools/builtin/shell-analysis.mjs

@@ -568,7 +568,10 @@ export function preflightPowerShellHygiene(command, { shellType, shellName } = {
     // regex/search args are never mistaken for real syntax.
     const masked = maskQuotedRegions(rewritten);
 
-    for (const segment of shellSplitSegments(rewritten)) {
+    // Only command heads matter here. Scan the quote-masked copy so PowerShell
+    // literals use PowerShell escaping rules (`\` is literal, backtick escapes)
+    // and nested bash snippets remain opaque.
+    for (const segment of shellSplitSegments(masked)) {
         for (const stage of shellSplitPipelineSegments(segment)) {
             const tokens = stripShellProbeWrappers(shellTokenize(stage) || []);
             if (tokens.length === 0) continue;

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

@@ -3,6 +3,7 @@
 // race), isCodeGraphTool. Extracted verbatim from code-graph.mjs.
 import { resolve as pathResolve, isAbsolute, relative as pathRelative, basename as pathBasename, extname } from 'node:path';
 import { homedir as osHomedir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { existsSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { normalizeInputPath, toDisplayPath } from '../builtin.mjs';
@@ -29,6 +30,8 @@ import {
   _stripEmptyArgs,
 } from './project-root.mjs';
 import { buildCodeGraphAsync, prewarmCodeGraph, prewarmCodeGraphSymbols } from './build.mjs';
+import { _fileInfoFromRustRecord, _runGraphFiles } from './graph-binary.mjs';
+import { _attachGraphRuntimeCaches } from './graph-model.mjs';
 import {
   _isFilesystemRootPath,
   collectTrustedCodeGraphRoots,
@@ -87,6 +90,74 @@ function _outlineLanguageForPath(file) {
   return null;
 }
 
+const _exactFileGraphInflight = new Map();
+const _exactFileGraphCache = new Map();
+const EXACT_FILE_GRAPH_CACHE_MAX = 64;
+
+async function _buildExactFileGraph(cwd, abs, signal = null) {
+  const root = pathResolve(cwd);
+  const file = pathResolve(abs);
+  const rel = _graphRel(file, root);
+  const key = `${root}\0${rel}`;
+  const sourceText = await readFile(file, { encoding: 'utf8', signal: signal || undefined });
+  const sourceHash = createHash('sha256').update(sourceText).digest('hex');
+  const cached = _exactFileGraphCache.get(key);
+  if (cached?.sourceHash === sourceHash) {
+    _exactFileGraphCache.delete(key);
+    _exactFileGraphCache.set(key, cached);
+    return cached.graph;
+  }
+  const existing = _exactFileGraphInflight.get(key);
+  if (existing?.sourceHash === sourceHash) return existing.promise;
+  const pending = (async () => {
+    const records = await _runGraphFiles(root, [rel], [], signal);
+    const record = records.find((item) => _graphRel(pathResolve(root, item.rel), root) === rel);
+    if (!record) return null;
+    const info = _fileInfoFromRustRecord(record, root);
+    const node = {
+      abs: info.abs,
+      rel: info.rel,
+      lang: info.lang,
+      fingerprint: info.fingerprint,
+      rawImports: info.rawImports,
+      resolvedImportsRel: [],
+      resolvedImports: [],
+      importedBy: [],
+      packageName: info.packageName,
+      namespaceName: info.namespaceName,
+      goPackageName: info.goPackageName,
+      topLevelTypes: info.topLevelTypes,
+      tokenSymbols: info.tokenSymbols,
+      symbols: Array.isArray(info.symbols) ? info.symbols : [],
+    };
+    const graph = _attachGraphRuntimeCaches({
+      cwd: root,
+      nodes: new Map([[node.rel, node]]),
+      reverse: new Map(),
+      builtAt: Date.now(),
+      signature: info.fingerprint || '',
+      truncated: false,
+    });
+    graph._sourceTextCache.set(node.rel, {
+      fingerprint: node.fingerprint || '',
+      text: sourceText,
+    });
+    _exactFileGraphCache.delete(key);
+    _exactFileGraphCache.set(key, { sourceHash, graph });
+    while (_exactFileGraphCache.size > EXACT_FILE_GRAPH_CACHE_MAX) {
+      _exactFileGraphCache.delete(_exactFileGraphCache.keys().next().value);
+    }
+    return graph;
+  })();
+  const inflight = { sourceHash, promise: pending };
+  _exactFileGraphInflight.set(key, inflight);
+  try {
+    return await pending;
+  } finally {
+    if (_exactFileGraphInflight.get(key) === inflight) _exactFileGraphInflight.delete(key);
+  }
+}
+
 async function _mapWithConcurrency(values, mapper) {
   const out = new Array(values.length);
   let cursor = 0;
@@ -693,9 +764,17 @@ async function findSymbolTool(args, cwd, signal = null, options = {}) {
     else prewarmCodeGraph(cwd);
     return `prewarm scheduled: cwd=${cwd} symbols=${symbols.length}${symbols.length ? ` (${symbols.slice(0, 5).join(',')}${symbols.length > 5 ? `,+${symbols.length - 5}` : ''})` : ''}`;
   }
-  const graph = await buildCodeGraphAsync(cwd, signal, {
-    excludedProjectRoots: options?.excludedProjectRoots,
-  });
+  const normFile = normalizeInputPath(args?.file);
+  const abs = normFile ? (isAbsolute(normFile) ? pathResolve(normFile) : pathResolve(cwd, normFile)) : null;
+  let exactFile = false;
+  if (abs && _outlineLanguageForPath(abs)) {
+    try { exactFile = statSync(abs).isFile(); } catch { exactFile = false; }
+  }
+  const graph = exactFile
+    ? await _buildExactFileGraph(cwd, abs, signal)
+    : await buildCodeGraphAsync(cwd, signal, {
+        excludedProjectRoots: options?.excludedProjectRoots,
+      });
   if (!graph) throw new Error(`find_symbol: cwd '${cwd}' is not an indexed/known project root or contains zero eligible files`);
   if (options?.scopedCacheOutcome && graph.truncated) {
     markScopedCacheIncomplete(options.scopedCacheOutcome);
@@ -703,8 +782,6 @@ async function findSymbolTool(args, cwd, signal = null, options = {}) {
   const symbol = String(args?.symbol || '').trim();
   const language = String(args?.language || '').trim() || null;
   const limit = Math.max(1, Math.min(50, Number(args?.limit || 20)));
-  const normFile = normalizeInputPath(args?.file);
-  const abs = normFile ? (isAbsolute(normFile) ? pathResolve(normFile) : pathResolve(cwd, normFile)) : null;
   const fileRel = abs ? _graphRel(abs, cwd) : null;
   if (fileRel && !graph.nodes.get(fileRel)) {
     return _appendSameBasenameHint(`Error: find_symbol: file not found in graph: ${normFile}`, normFile, graph);

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

@@ -248,7 +248,7 @@ export function _runGraphWalk(absRoot) { return _runGraphBinaryJsonl(absRoot, []
 // topLevelTypes}. Rust builds the index + resolves over ALL nodes (fresh +
 // reused) and emits fresh rels as full records, reused rels as lightweight
 // {rel, resolvedImports, importedBy}.
-export function _runGraphFiles(absRoot, rels, reusedMetas) {
+export function _runGraphFiles(absRoot, rels, reusedMetas, signal = null) {
   const lines = Array.isArray(reusedMetas)
     ? reusedMetas.map((m) => JSON.stringify({
         rel: m.rel,
@@ -260,7 +260,7 @@ export function _runGraphFiles(absRoot, rels, reusedMetas) {
         topLevelTypes: Array.isArray(m.topLevelTypes) ? m.topLevelTypes : [],
       }))
     : [];
-  return _runGraphBinaryJsonl(absRoot, ['--files', ...rels], lines);
+  return _runGraphBinaryJsonl(absRoot, ['--files', ...rels], lines, signal);
 }
 
 // Map a Rust FileRecord (rel/lang/fp/tokens/rawImports/resolvedImports/

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

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.17",
+  "version": "0.1.18",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.17/mixdog-graph-darwin-arm64",
-      "sha256": "3b8850422ad267b45572ceef7993fb57c2b7b9c71cc4c026056335828a28a65a"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.18/mixdog-graph-darwin-arm64",
+      "sha256": "c89403d4a4cd08aa27427b65e9f0efe4885fb35cbe788527b81279e03edc82eb"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.17/mixdog-graph-darwin-x64",
-      "sha256": "0d793977ddd1d84851d1a9e3244415e7dc5b35f2f636a43f17af4745ea4485a8"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.18/mixdog-graph-darwin-x64",
+      "sha256": "43765bb6598f0b7db3ba5df8348bb7221fc0e4fec5f8ad9d4d53887d4951e42f"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.17/mixdog-graph-linux-arm64",
-      "sha256": "036dcc5f16a5cfc72e95de198de8b5d2ad56d62e88677bb90222206624268a6a"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.18/mixdog-graph-linux-arm64",
+      "sha256": "ada18e0d9ca3ab8fe65098b81c8856d01992eb2f33a2f2923e886280e2b635a4"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.17/mixdog-graph-linux-x64",
-      "sha256": "7bd4325dc1761f3fcf77cc8926a45e007f85d1b6954bfea819fafb6625635904"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.18/mixdog-graph-linux-x64",
+      "sha256": "724d219ec72828662f34ba7b0edf00938e8f9f00df76cb6c41675551e2c0137e"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.17/mixdog-graph-win32-x64.exe",
-      "sha256": "c0441052d0a09ddb3a3c291c7e7bffcf767dac9b6353e2f2e3e6954be2994712"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.18/mixdog-graph-win32-x64.exe",
+      "sha256": "c24f4ffb0beec3f355bc4e33c02adafce2ba966df34922ec0ff2ce2cde23fe65"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/lib/native-spawn-client.mjs

@@ -1,13 +1,16 @@
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import { dirname, resolve as pathResolve } from 'node:path';
 import { createInterface } from 'node:readline';
 import { EventEmitter } from 'node:events';
+import { fileURLToPath } from 'node:url';
 import { hiddenSpawnOpts } from '../../../../shared/spawn-flags.mjs';
 import { packageNativeToolPath } from '../../../../shared/native-tool-paths.mjs';
 import { getPluginData } from '../../config.mjs';
 import { ensureSpawnBinary, findCachedSpawnBinary } from '../spawn-binary-fetcher.mjs';
 
 const RESTART_BACKOFF_MS = 30_000;
+const SERVER_READY_TIMEOUT_MS = 5_000;
 
 let _server = null;
 let _binaryPath = undefined;
@@ -57,22 +60,24 @@ function acceptTask(message) {
 class LineStream extends EventEmitter {
   constructor() {
     super();
-    this._pending = '';
+    this._pending = [];
   }
   setEncoding() { return this; }
   emit(event, ...args) {
     if (event === 'data' && this.listenerCount('data') === 0) {
-      this._pending += args[0] == null ? '' : String(args[0]);
+      if (args[0] != null) this._pending.push(args[0]);
       return false;
     }
     return super.emit(event, ...args);
   }
   on(event, listener) {
     const ret = super.on(event, listener);
-    if (event === 'data' && this._pending) {
+    if (event === 'data' && this._pending.length > 0) {
       const pending = this._pending;
-      this._pending = '';
-      queueMicrotask(() => listener(pending));
+      this._pending = [];
+      queueMicrotask(() => {
+        for (const chunk of pending) listener(chunk);
+      });
     }
     return ret;
   }
@@ -142,6 +147,17 @@ function _resolveBinary() {
     _binaryPath = explicit;
     return _binaryPath;
   }
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const binName = process.platform === 'win32' ? 'mixdog-spawn.exe' : 'mixdog-spawn';
+  const localBuild = pathResolve(
+    moduleDir,
+    '../../../../../../native/mixdog-spawn/target/release',
+    binName,
+  );
+  if (existsSync(localBuild)) {
+    _binaryPath = localBuild;
+    return _binaryPath;
+  }
   const installed = packageNativeToolPath('spawn');
   if (existsSync(installed)) {
     _binaryPath = installed;
@@ -243,13 +259,23 @@ function _ensureServer() {
     _lastFailureAt = Date.now();
     return null;
   }
-  const server = { child, pending: new Map(), sequence: 0 };
+  const server = { child, pending: new Map(), sequence: 0, ready: false, caps: {} };
+  let resolveReady;
+  server.readyPromise = new Promise((resolve) => { resolveReady = resolve; });
+  const settleReady = (value) => {
+    if (!resolveReady) return;
+    const resolve = resolveReady;
+    resolveReady = null;
+    resolve(value);
+  };
   const lines = createInterface({ input: child.stdout });
   lines.on('line', (line) => {
     let message;
     try { message = JSON.parse(line); } catch { return; }
     if (message?.ready === true) {
       server.caps = (message.caps && typeof message.caps === 'object') ? message.caps : {};
+      server.ready = true;
+      settleReady(true);
       return;
     }
     if (String(message?.event || '').startsWith('task_')) acceptTask(message);
@@ -257,8 +283,14 @@ function _ensureServer() {
     if (!pending) return;
     pending.onMessage(message);
   });
-  child.on('error', (error) => { if (_server === server) _teardown(error); });
-  child.on('exit', () => { if (_server === server) _teardown(); });
+  child.on('error', (error) => {
+    settleReady(false);
+    if (_server === server) _teardown(error);
+  });
+  child.on('exit', () => {
+    settleReady(false);
+    if (_server === server) _teardown();
+  });
   child.stdin.on('error', (error) => { if (_server === server) _teardown(error); });
   _setServerReferenced(server, false);
   _server = server;
@@ -274,17 +306,40 @@ export async function warmNativeSpawnServer() {
 }
 
 export async function ensureNativeSpawnServer() {
-  if (_server) return true;
+  if (_server?.ready) return true;
   let binary = _resolveBinary();
   if (!binary) {
     binary = await ensureSpawnBinary(getPluginData());
     _binaryPath = binary;
   }
-  if (!_ensureServer()) {
+  const server = _ensureServer();
+  if (!server) {
     throw Object.assign(new Error('verified native spawn server could not be started'), {
       code: 'NATIVE_SPAWN_UNAVAILABLE',
     });
   }
+  if (!server.ready) {
+    let timer;
+    let ready;
+    _setServerReferenced(server, true);
+    try {
+      ready = await Promise.race([
+        server.readyPromise,
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(false), SERVER_READY_TIMEOUT_MS);
+        }),
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+      if (_server === server) _recomputeServerRef(server);
+    }
+    if (!ready) {
+      if (_server === server) _teardown(new Error('native spawn server ready timeout'));
+      throw Object.assign(new Error('verified native spawn server did not become ready'), {
+        code: 'NATIVE_SPAWN_UNAVAILABLE',
+      });
+    }
+  }
   return true;
 }
 
@@ -311,6 +366,7 @@ export function tryNativeSpawn({ shell, argv, spawnOptions = {}, cwd } = {}) {
     timeoutMs: Math.max(0, Number(spawnOptions.timeoutMs) || 0),
     outputLimit: Math.max(0, Number(spawnOptions.outputLimit) || 0),
     mergeStderr: spawnOptions.mergeStderr === true,
+    rawOutput: spawnOptions.rawOutput === true,
     ...(spawnOptions.stdinPipe === true ? { stdinPipe: true } : {}),
     command: spawnOptions.command || undefined,
     shellType: spawnOptions.shellType || undefined,
@@ -338,8 +394,18 @@ export function tryNativeSpawn({ shell, argv, spawnOptions = {}, cwd } = {}) {
         fake.emit('spawn');
         return;
       }
-      if (event === 'stdout' && message.text) fake.stdout.emit('data', String(message.text));
-      else if (event === 'stderr' && message.text) fake.stderr.emit('data', String(message.text));
+      if (event === 'stdout' && (message.dataBase64 || message.text)) {
+        const chunk = message.dataBase64
+          ? Buffer.from(String(message.dataBase64), 'base64')
+          : String(message.text);
+        fake.stdout.emit('data', chunk);
+      }
+      else if (event === 'stderr' && (message.dataBase64 || message.text)) {
+        const chunk = message.dataBase64
+          ? Buffer.from(String(message.dataBase64), 'base64')
+          : String(message.text);
+        fake.stderr.emit('data', chunk);
+      }
       else if (event === 'root_exit') {
         fake.exitCode = message.code == null ? null : Number(message.code);
         fake.signalCode = message.signal || null;

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

@@ -14,9 +14,30 @@ import { SHELL_OUTPUT_DISK_CAP } from '../shell-exec-output.mjs';
 // exactly like `-Command <script>`.
 const STANDBY_BOOTSTRAP = "$null = . ([scriptblock]::Create('$null')); [Console]::InputEncoding=[System.Text.UTF8Encoding]::new($false); . ([scriptblock]::Create([Console]::In.ReadToEnd()))";
 const STANDBY_ARGS = ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', STANDBY_BOOTSTRAP];
-const STANDBY_TTL_MS = 10 * 60_000;
+const _configuredIdleMs = Number(process.env.MIXDOG_SHELL_WARM_STANDBY_IDLE_MS);
+const STANDBY_TTL_MS = Number.isFinite(_configuredIdleMs) && _configuredIdleMs >= 100
+    ? Math.floor(_configuredIdleMs)
+    : 2 * 60_000;
 
 let _slot = null; // { native, shell, envSig, createdAt }
+let _slotIdleTimer = null;
+
+function _clearSlotIdleTimer() {
+    if (!_slotIdleTimer) return;
+    clearTimeout(_slotIdleTimer);
+    _slotIdleTimer = null;
+}
+
+function _armSlotIdleTimer(slot) {
+    _clearSlotIdleTimer();
+    _slotIdleTimer = setTimeout(() => {
+        _slotIdleTimer = null;
+        if (_slot !== slot) return;
+        _slot = null;
+        try { slot.native.child.kill(); } catch { /* best-effort */ }
+    }, STANDBY_TTL_MS);
+    _slotIdleTimer.unref?.();
+}
 
 function _disabled() {
     return process.env.MIXDOG_SHELL_WARM_STANDBY === '0';
@@ -57,6 +78,7 @@ export function ensureWarmShellStandby({ shell, env }) {
                 env,
                 cwd: process.cwd(),
                 outputLimit: SHELL_OUTPUT_DISK_CAP,
+                rawOutput: true,
                 stdinPipe: true,
                 shellType: 'powershell',
                 command: '(warm shell standby)',
@@ -73,9 +95,15 @@ export function ensureWarmShellStandby({ shell, env }) {
         envSig: envSignature(env),
         createdAt: Date.now(),
     };
-    native.child.once('close', () => { if (_slot === slot) _slot = null; });
-    native.child.once('error', () => { if (_slot === slot) _slot = null; });
+    const release = () => {
+        if (_slot !== slot) return;
+        _slot = null;
+        _clearSlotIdleTimer();
+    };
+    native.child.once('close', release);
+    native.child.once('error', release);
     _slot = slot;
+    _armSlotIdleTimer(slot);
 }
 
 /** Take the parked standby for immediate use, or null on any mismatch.
@@ -98,12 +126,14 @@ export function takeWarmShellStandby({ shell, env, cwd }) {
                 || Date.now() - slot.createdAt > STANDBY_TTL_MS
                 || slot.envSig !== envSignature(env))) {
             _slot = null;
+            _clearSlotIdleTimer();
             try { slot.native.child.kill(); } catch { /* best-effort */ }
         }
         refill();
         return null;
     }
     _slot = null;
+    _clearSlotIdleTimer();
     // Back to active: the caller is about to run a real command on it and the
     // host must stay alive until that command settles.
     setNativeSpawnRequestIdle(slot.native.child, false);
@@ -125,6 +155,7 @@ export function takeWarmShellStandby({ shell, env, cwd }) {
 export function _resetWarmShellStandbyForTest() {
     const slot = _slot;
     _slot = null;
+    _clearSlotIdleTimer();
     if (slot?.native?.child) {
         try { slot.native.child.kill(); } catch { /* best-effort */ }
     }

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

@@ -35,7 +35,7 @@ export {
 // renders a path marker instead of pasting the tail. Matches the
 // SHELL_OUTPUT_MAX_CHARS used by the smart-truncate renderer in
 // builtin.mjs so spilled output and inline output share the same boundary.
-import { SHELL_OUTPUT_INLINE_CAP, SHELL_OUTPUT_DISK_CAP, stripAnsi, treeKill, TaskOutput, ExecResult } from './shell-exec-output.mjs';
+import { SHELL_OUTPUT_INLINE_CAP, SHELL_OUTPUT_DISK_CAP, stripAnsi, treeKill, TaskOutput, ExecResult, ShellTextDecoder } from './shell-exec-output.mjs';
 export { stripAnsi, ExecResult } from './shell-exec-output.mjs';
 
 async function _execPolicyBlockMessage(command) {
@@ -221,6 +221,8 @@ export function execShellCommand({
     };
     const taskId = `shell_${randomUUID().slice(0, 8)}`;
     const taskOutput = new TaskOutput(taskId);
+    const stdoutDecoder = new ShellTextDecoder();
+    const stderrDecoder = new ShellTextDecoder();
     let timedOut = false;
     let killed = false;
     let killCause = null;
@@ -379,6 +381,7 @@ export function execShellCommand({
         env,
         cwd,
         outputLimit: SHELL_OUTPUT_DISK_CAP,
+        rawOutput: true,
         // NOTE (child-spawn-gate): the full command lifetime is intentionally
         // NOT gated — bash/pwsh commands can run for minutes and would starve
         // rg/code_graph. Only the spawn window above holds a slot.
@@ -429,21 +432,21 @@ export function execShellCommand({
     }
 
     const _stdoutData = (chunk) => {
-      taskOutput.writeStdout(chunk);
+      const text = stdoutDecoder.write(chunk);
+      if (text) taskOutput.writeStdout(text);
       if (taskOutput.binaryOutput && !settled && !autoBackgrounded) _treeKillForceSettle('binary-output');
       if (taskOutput.writeError && !settled && !autoBackgrounded) _treeKillForceSettle('output-capture-error');
     };
     const _stderrData = (chunk) => {
-      taskOutput.writeStderr(chunk);
+      const text = stderrDecoder.write(chunk);
+      if (text) taskOutput.writeStderr(text);
       if (taskOutput.binaryOutput && !settled && !autoBackgrounded) _treeKillForceSettle('binary-output');
       if (taskOutput.writeError && !settled && !autoBackgrounded) _treeKillForceSettle('output-capture-error');
     };
     if (child.stdout) {
-      child.stdout.setEncoding('utf-8');
       child.stdout.on('data', _stdoutData);
     }
     if (child.stderr) {
-      child.stderr.setEncoding('utf-8');
       child.stderr.on('data', _stderrData);
     }
 
@@ -460,6 +463,10 @@ export function execShellCommand({
         autoBgTimer = null;
       }
       detachAbortHandler();
+      const stdoutTail = stdoutDecoder.end();
+      const stderrTail = stderrDecoder.end();
+      if (stdoutTail) taskOutput.writeStdout(stdoutTail);
+      if (stderrTail) taskOutput.writeStderr(stderrTail);
       // getStdout/getStderr can throw on a spilled-file read failure (EBADF
       // after unlink race, EACCES). Without this catch the rejection bubbles
       // up and leaves the outer settle promise unresolved, hanging the call.

package/src/runtime/agent/orchestrator/tools/shell-exec-output.mjs

@@ -15,6 +15,7 @@ import {
   statSync,
 } from 'node:fs';
 import { join } from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
 import * as nodeUtil from 'node:util';
 import { getPluginData } from '../config.mjs';
 
@@ -86,6 +87,92 @@ export function inspectShellTextChunk(value, channel = 'stdout') {
   };
 }
 
+function detectShellTextEncoding(buffer, final = false) {
+  if (buffer.length >= 2) {
+    if (buffer[0] === 0xff && buffer[1] === 0xfe) return { encoding: 'utf16le', bom: 2 };
+    if (buffer[0] === 0xfe && buffer[1] === 0xff) return { encoding: 'utf16be', bom: 2 };
+  }
+  const pairs = Math.min(Math.floor(buffer.length / 2), 128);
+  if (pairs >= 4) {
+    let evenNuls = 0;
+    let oddNuls = 0;
+    let printablePartners = 0;
+    for (let i = 0; i < pairs * 2; i += 2) {
+      if (buffer[i] === 0) evenNuls++;
+      if (buffer[i + 1] === 0) oddNuls++;
+      const partner = buffer[i] === 0 ? buffer[i + 1] : buffer[i];
+      if (partner === 9 || partner === 10 || partner === 13 || (partner >= 0x20 && partner <= 0x7e)) {
+        printablePartners++;
+      }
+    }
+    const dominantNuls = Math.max(evenNuls, oddNuls);
+    const minorityNuls = Math.min(evenNuls, oddNuls);
+    if (
+      dominantNuls / pairs >= 0.6
+      && minorityNuls / pairs <= 0.1
+      && printablePartners / pairs >= 0.75
+    ) {
+      return { encoding: oddNuls > evenNuls ? 'utf16le' : 'utf16be', bom: 0 };
+    }
+  }
+  if (!final && buffer.length < 4) return null;
+  return { encoding: 'utf8', bom: 0 };
+}
+
+export class ShellTextDecoder {
+  constructor() {
+    this.encoding = null;
+    this.decoder = null;
+    this.pending = Buffer.alloc(0);
+    this.byteRemainder = Buffer.alloc(0);
+  }
+
+  _decode(buffer) {
+    if (this.encoding !== 'utf16be') return this.decoder.write(buffer);
+    const joined = this.byteRemainder.length > 0
+      ? Buffer.concat([this.byteRemainder, buffer])
+      : buffer;
+    const evenLength = joined.length - (joined.length % 2);
+    this.byteRemainder = evenLength < joined.length ? joined.subarray(evenLength) : Buffer.alloc(0);
+    if (evenLength === 0) return '';
+    return this.decoder.write(Buffer.from(joined.subarray(0, evenLength)).swap16());
+  }
+
+  _start(final = false) {
+    const detected = detectShellTextEncoding(this.pending, final);
+    if (!detected) return '';
+    this.encoding = detected.encoding;
+    this.decoder = new StringDecoder(this.encoding === 'utf16be' ? 'utf16le' : this.encoding);
+    const buffered = this.pending.subarray(detected.bom);
+    this.pending = Buffer.alloc(0);
+    return this._decode(buffered);
+  }
+
+  write(value) {
+    if (value == null || value.length === 0) return '';
+    if (typeof value === 'string') {
+      const prefix = this.encoding ? '' : this._start(true);
+      return prefix + value;
+    }
+    const buffer = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    if (!this.encoding) {
+      this.pending = this.pending.length > 0 ? Buffer.concat([this.pending, buffer]) : buffer;
+      return this._start(false);
+    }
+    return this._decode(buffer);
+  }
+
+  end() {
+    let text = this.encoding ? '' : this._start(true);
+    if (this.encoding === 'utf16be' && this.byteRemainder.length > 0) {
+      text += '\uFFFD';
+      this.byteRemainder = Buffer.alloc(0);
+    }
+    if (this.decoder) text += this.decoder.end();
+    return text;
+  }
+}
+
 // Delegate process-tree termination to the native manager.
 export function treeKill(child) {
   if (!child?.__nativeSpawn || typeof child.kill !== 'function') return false;

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

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.2",
+  "version": "0.1.3",
   "_comment": "Synced from immutable spawn-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.2/mixdog-spawn-darwin-arm64",
-      "sha256": "3c2eb5ecf47dccb4aeea113f422ede24f6dde22dceab7c9c77f6963ef9aded7d"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.3/mixdog-spawn-darwin-arm64",
+      "sha256": "44b26d0a7bf2a1a32f3eaac9faff370540d1fa34bd1154e2dcbba283e6ee80da"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.2/mixdog-spawn-darwin-x64",
-      "sha256": "7288b073b940d82b64e9e888e723ae95204a28472053676fb6650d5c68362836"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.3/mixdog-spawn-darwin-x64",
+      "sha256": "bb20f01607aef01c62b7a7cac172b8f2493d7320aab1381ce1c18a366c9ace37"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.2/mixdog-spawn-linux-arm64",
-      "sha256": "308a53b7c9dbae5ce8c36dc98ab35ac869f0251671829cbdcb09162261b063bf"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.3/mixdog-spawn-linux-arm64",
+      "sha256": "ba638ce7ada9f9602bc81ec2bc47095d978e97068fd659fbe33b281eab8c1993"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.2/mixdog-spawn-linux-x64",
-      "sha256": "9f619c17d13e2786e38a2a6017a5e9b1e2f88370132d2c0ff8ee80245b64d0c3"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.3/mixdog-spawn-linux-x64",
+      "sha256": "4ca31eeba80af2073776ffbf62f9fb9e59d48d55e120cd25deab02023a586558"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.2/mixdog-spawn-win32-x64.exe",
-      "sha256": "ee229f2ee2066b2c1a7c984b2ac4cd5bcfed5758173115de366defb1f97c7b51"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.3/mixdog-spawn-win32-x64.exe",
+      "sha256": "dd8f47b94d877958e5522619d561f6286af02cc7ee7e60a3e7d4102a6c516f40"
     }
   }
 }