mixdog 0.9.126 → 0.9.128

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.126",
+  "version": "0.9.128",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -43,7 +43,7 @@
     "vendor/"
   ],
   "scripts": {
-    "postinstall": "node scripts/prune-embedding-runtime.mjs",
+    "postinstall": "node scripts/prune-embedding-runtime.mjs && node scripts/prepare-native-assets.mjs",
     "prepack": "npm run build:tui",
     "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run npm run release:patch');process.exit(1)}\"",
     "start": "node src/cli.mjs",
@@ -61,7 +61,7 @@
     "test:shellhardening": "npm run build:spawn:test && node --test scripts/suite-shellhardening-test.mjs scripts/suite-shell-direct-exe-test.mjs",
     "test:providers": "node --test scripts/provider-toolcall-test.mjs scripts/provider-contract-test.mjs scripts/provider-stream-outcome-test.mjs",
     "test:embedding-runtime:warmup": "node scripts/verify-embedding-runtime.mjs --warmup",
-    "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/release-gate-test.mjs && node --test scripts/release-gate-test.mjs",
+    "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/release-gate-test.mjs && node --check scripts/prepare-native-assets.mjs && node --test scripts/release-gate-test.mjs scripts/prepare-native-assets-test.mjs",
     "test:native-edit-wire": "node scripts/native-edit-wire-test.mjs",
     "test:release-focused": "npm run test:release-critical && npm run test:compact && npm run test:shellhardening && npm run test:tool-contracts && npm run test:session && npm run test:session-transport",
     "test:release-critical": "npm run test:release-assets && npm run smoke:patch && npm run test:providers",

package/scripts/prepare-native-assets.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+import {
+  chmod,
+  copyFile,
+  mkdir,
+  mkdtemp,
+  rename,
+  rm,
+} from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import {
+  NATIVE_TOOL_FILENAMES,
+  packageNativeToolsDir,
+} from '../src/runtime/shared/native-tool-paths.mjs';
+import { ensureGraphBinary } from '../src/runtime/agent/orchestrator/tools/graph-binary-fetcher.mjs';
+import { ensurePatchBinary } from '../src/runtime/agent/orchestrator/tools/patch-binary-fetcher.mjs';
+import { ensureSpawnBinary } from '../src/runtime/agent/orchestrator/tools/spawn-binary-fetcher.mjs';
+import { ensureTokenAddon } from '../src/runtime/agent/orchestrator/tools/token-addon-fetcher.mjs';
+
+const DEFAULT_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+export const REQUIRED_NATIVE_INSTALLERS = Object.freeze({
+  graph: ensureGraphBinary,
+  patch: ensurePatchBinary,
+  spawn: ensureSpawnBinary,
+  token: ensureTokenAddon,
+});
+
+export async function prepareRequiredNativeAssets({
+  packageRoot = DEFAULT_PACKAGE_ROOT,
+  installers = REQUIRED_NATIVE_INSTALLERS,
+} = {}) {
+  const root = resolve(String(packageRoot || ''));
+  const target = packageNativeToolsDir(root);
+  const stagingRoot = await mkdtemp(join(root, '.native-tools-install-'));
+  const downloadDataDir = join(stagingRoot, 'downloads');
+  const stagedToolsDir = join(stagingRoot, 'native-tools');
+  try {
+    await mkdir(stagedToolsDir, { recursive: true });
+    const entries = await Promise.all(
+      Object.entries(NATIVE_TOOL_FILENAMES).map(async ([name, fileName]) => {
+        const install = installers[name];
+      if (typeof install !== 'function') {
+        throw new Error(`native asset installer is invalid: ${name}`);
+      }
+        const installedPath = await install(downloadDataDir);
+      if (typeof installedPath !== 'string' || installedPath.length === 0) {
+        throw new Error(`native asset installer returned no path: ${name}`);
+      }
+        const destination = join(stagedToolsDir, fileName);
+        await copyFile(installedPath, destination);
+        if (process.platform !== 'win32' && name !== 'token') {
+          await chmod(destination, 0o755);
+        }
+        return [name, join(target, fileName)];
+      }),
+    );
+    await rm(target, { recursive: true, force: true });
+    await rename(stagedToolsDir, target);
+    return Object.fromEntries(entries);
+  } finally {
+    await rm(stagingRoot, { recursive: true, force: true });
+  }
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : '';
+if (invokedPath === import.meta.url) {
+  try {
+    const prepared = await prepareRequiredNativeAssets();
+    console.log(`[native-assets] ready: ${Object.keys(prepared).join(', ')}`);
+  } catch (error) {
+    console.error(`[native-assets] install failed: ${error?.message || String(error)}`);
+    process.exitCode = 1;
+  }
+}

package/scripts/tool-overhead-microbench.mjs

@@ -1,12 +1,12 @@
 // Micro-bench: fixed per-call overhead of the shell tool path vs raw spawn.
-// Usage: node scripts/tool-overhead-microbench.mjs [bash|powershell] [N]
+// Usage: node scripts/tool-overhead-microbench.mjs [N]
 // Prints per-call ms for executeBashTool('echo hi') and raw child spawn,
 // so (tool - raw) isolates our tool-layer overhead (policy, wrappers, I/O).
 import { spawn } from 'node:child_process';
 import { executeBashTool } from '../src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs';
 
-const shell = process.argv[2] || (process.platform === 'win32' ? 'powershell' : 'bash');
-const N = Number(process.argv[3] || 15);
+const shell = process.platform === 'win32' ? 'powershell' : 'bash';
+const N = Number(process.argv[2] || 15);
 
 const stats = (arr) => {
   const s = [...arr].sort((a, b) => a - b);
@@ -30,7 +30,7 @@ const rawOnce = () => new Promise((resolveDone, reject) => {
 });
 
 const toolOnce = async () => {
-  const out = await executeBashTool({ command: 'echo hi', shell }, process.cwd(), {});
+  const out = await executeBashTool({ command: 'echo hi' }, process.cwd(), {});
   return String(out);
 };
 

package/scripts/tool-stress.mjs

@@ -119,7 +119,7 @@ try {
 
   // ── Phase D: cancellation under load ─────────────────────────────────────
   const bg = await timed('shell-async', /task_id/, () => executeBuiltinTool('shell', {
-    command: 'node -e "setTimeout(()=>{}, 30000)"', mode: 'async', timeout: 60_000,
+    command: 'node -e "setTimeout(()=>{}, 30000)"', run_in_background: true, timeout_ms: 60_000,
   }, root, { sessionId: 'stress-cancel' }));
   const bgId = (/task_id:\s*(\S+)/.exec(String(bg)) || [])[1];
   if (!bgId) failures.push('async shell did not return task_id');

package/src/rules/shared/01-tool.md

@@ -12,7 +12,7 @@
   prior work→`recall` (history only, never current local state);
   durable compact English memory→`memory`;
   explicit Project change→`cwd`
-  (`shell.cwd` is call-local and never changes the Project);
+  (a shell-local `cd` never changes the Project);
   explicit user-requested conversation reset→`session_manage`.
   Use only named tools present in the current tool surface.
 - Requirements define what must be true; evidence establishes what is true.
@@ -35,8 +35,9 @@
   tool, and launch independent facets together — never split or duplicate a
   facet across tools, mutate merely to widen retrieval, reserve known work, or
   cap fanout.
-  Guesses go wide in one batch, scopes narrow only on verified cues — returned
-  siblings/conventions or known literals — and returned output is fully mined
+  Cover every independent facet of the round in one batch — one best-routed
+  call per facet; extra tools on the same facet add cost, not progress.
+  Returned output is fully mined
   before the next round. `code_graph references` supplies the declaration and
   scoped usages and ends that facet; values/locations end at the context grep returns; `read`
   covers only what returned spans cannot, as an anchored offset/limit
@@ -59,7 +60,7 @@
   execution, runtime/state operations, calculations, data transformation, file
   generation, or formats unsupported by file tools. Do not use `shell` instead
   of an available file tool for ordinary file-content inspection.
-- Start shell commands sync. Use async only when their result is not needed
+- Start shell commands in the foreground. Set `run_in_background:true` only when their result is not needed
   immediately and completion notification is sufficient. Tracked sync/async
   commands belong to the current run. Only when the request explicitly requires
   a service to survive after the run exits, detach it at shell level (for

package/src/runtime/agent/orchestrator/providers/model-catalog.mjs

@@ -8,10 +8,10 @@
  *
  * Source: https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json
  *
- * The catalog is cached on disk for 24h. On fetch failure, providers fall
- * back to whatever metadata their native endpoint exposed (usually nothing
- * beyond the id). Pricing stays null in that case; UI shows "-" instead of
- * a stale number.
+ * Overlay catalogs (LiteLLM + models.dev) are fetched once per process.
+ * Disk is a stale-ok fallback when the remote fetch fails. On fetch
+ * failure with no disk copy, providers keep whatever metadata their
+ * native endpoint exposed (usually nothing beyond the id).
  */
 
 import { existsSync, readFileSync } from 'fs';
@@ -25,14 +25,13 @@ import {
 
 const CATALOG_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
 const CATALOG_CACHE_FILE = 'litellm-catalog.json';
-const CATALOG_TTL_MS = 24 * 60 * 60_000;
 
 // Second auto pricing source: models.dev publishes per-PROVIDER model
 // catalogs (cost in $/M) for 140+ providers — including ones LiteLLM does not
 // track yet (e.g. opencode-go). Because it is keyed provider→model, a
 // provider-scoped lookup is collision-free: deepseek-v4-pro under `deepseek`
-// and under `opencode-go` resolve to their own distinct rates. Same 24h TTL
-// + disk cache shape as the LiteLLM catalog above.
+// and under `opencode-go` resolve to their own distinct rates. Same
+// process-lifetime fetch + disk fallback as the LiteLLM catalog above.
 const MODELSDEV_URL = 'https://models.dev/api.json';
 const MODELSDEV_CACHE_FILE = 'modelsdev-catalog.json';
 
@@ -193,28 +192,28 @@ const PRICING_OVERRIDES = {
 
 let _memCache = null;
 let _memCacheAt = 0;
+// Disk warm must not count as "fetched this process" — otherwise a sync
+// lookup before startup refresh would pin a stale overlay for the whole run.
+let _catalogFetchedRemote = false;
 // Single-flight: concurrent loadCatalog callers share the same in-flight
-// Promise so a cold cache only triggers one disk read + one remote fetch.
+// Promise so a cold process only triggers one remote fetch.
 let _loadPromise = null;
 
 function cachePath() {
     return join(getPluginData(), CATALOG_CACHE_FILE);
 }
 
-async function _loadCatalogImpl(fetchFn = fetch, force = false) {
-    // Disk cache first
+function readDiskCatalog(filePath) {
     try {
-        if (force) throw new Error('forced refresh');
-        if (existsSync(cachePath())) {
-            const raw = JSON.parse(readFileSync(cachePath(), 'utf-8'));
-            if (raw?.fetchedAt && (Date.now() - raw.fetchedAt) < CATALOG_TTL_MS && raw.data) {
-                _memCache = raw.data;
-                _memCacheAt = raw.fetchedAt;
-                return _memCache;
-            }
-        }
-    } catch { /* fall through */ }
-    // Remote fetch
+        if (!existsSync(filePath)) return null;
+        const raw = JSON.parse(readFileSync(filePath, 'utf-8'));
+        return raw?.data ? raw : null;
+    } catch {
+        return null;
+    }
+}
+
+async function _loadCatalogImpl(fetchFn = fetch) {
     try {
         const res = await fetchFn(CATALOG_URL, { signal: AbortSignal.timeout(10_000) });
         if (!res.ok) throw new Error('HTTP ' + res.status);
@@ -224,14 +223,23 @@ async function _loadCatalogImpl(fetchFn = fetch, force = false) {
         } catch { /* cache is best-effort */ }
         _memCache = data;
         _memCacheAt = Date.now();
+        _catalogFetchedRemote = true;
         return data;
     } catch (err) {
         process.stderr.write(`[model-catalog] fetch failed: ${err.message}\n`);
+        const raw = readDiskCatalog(cachePath());
+        if (raw?.data) {
+            _memCache = raw.data;
+            _memCacheAt = raw.fetchedAt || Date.now();
+            _catalogFetchedRemote = true;
+            return _memCache;
+        }
         if (fetchFn !== fetch) {
             _memCache = _memCache || {};
             _memCacheAt = Date.now();
+            _catalogFetchedRemote = true;
         }
-        return {};
+        return _memCache || {};
     }
 }
 
@@ -250,9 +258,9 @@ export async function loadCatalog({ fetchFn, force = false } = {}) {
     if (typeof fetchFn === 'function' && fetchFn !== fetch) {
         return _loadCatalogInjected(fetchFn);
     }
-    if (!force && _memCache && (Date.now() - _memCacheAt) < CATALOG_TTL_MS) return _memCache;
+    if (!force && _catalogFetchedRemote && _memCache) return _memCache;
     if (_loadPromise) return _loadPromise;
-    _loadPromise = _loadCatalogImpl(fetchFn, force).finally(() => { _loadPromise = null; });
+    _loadPromise = _loadCatalogImpl(fetchFn).finally(() => { _loadPromise = null; });
     return _loadPromise;
 }
 
@@ -271,21 +279,11 @@ function warmFromDiskSync() {
 let _mdCache = null;
 let _mdCacheAt = 0;
 let _mdLoadPromise = null;
+let _mdFetchedRemote = false;
 function mdCachePath() {
     return join(getPluginData(), MODELSDEV_CACHE_FILE);
 }
-async function _loadModelsDevImpl(fetchFn = fetch, force = false) {
-    try {
-        if (force) throw new Error('forced refresh');
-        if (existsSync(mdCachePath())) {
-            const raw = JSON.parse(readFileSync(mdCachePath(), 'utf-8'));
-            if (raw?.fetchedAt && (Date.now() - raw.fetchedAt) < CATALOG_TTL_MS && raw.data) {
-                _mdCache = raw.data;
-                _mdCacheAt = raw.fetchedAt;
-                return _mdCache;
-            }
-        }
-    } catch { /* fall through to remote */ }
+async function _loadModelsDevImpl(fetchFn = fetch) {
     try {
         const res = await fetchFn(MODELSDEV_URL, { signal: AbortSignal.timeout(10_000) });
         if (!res.ok) throw new Error('HTTP ' + res.status);
@@ -295,12 +293,21 @@ async function _loadModelsDevImpl(fetchFn = fetch, force = false) {
         } catch { /* cache is best-effort */ }
         _mdCache = data;
         _mdCacheAt = Date.now();
+        _mdFetchedRemote = true;
         return data;
     } catch (err) {
         process.stderr.write(`[model-catalog] models.dev fetch failed: ${err.message}\n`);
+        const raw = readDiskCatalog(mdCachePath());
+        if (raw?.data) {
+            _mdCache = raw.data;
+            _mdCacheAt = raw.fetchedAt || Date.now();
+            _mdFetchedRemote = true;
+            return _mdCache;
+        }
         if (fetchFn !== fetch) {
             _mdCache = _mdCache || {};
             _mdCacheAt = Date.now();
+            _mdFetchedRemote = true;
         }
         return _mdCache || {};
     }
@@ -319,9 +326,9 @@ export async function loadModelsDevCatalog({ fetchFn, force = false } = {}) {
     if (typeof fetchFn === 'function' && fetchFn !== fetch) {
         return _loadModelsDevInjected(fetchFn);
     }
-    if (!force && _mdCache && (Date.now() - _mdCacheAt) < CATALOG_TTL_MS) return _mdCache;
+    if (!force && _mdFetchedRemote && _mdCache) return _mdCache;
     if (_mdLoadPromise) return _mdLoadPromise;
-    _mdLoadPromise = _loadModelsDevImpl(fetchFn, force).finally(() => { _mdLoadPromise = null; });
+    _mdLoadPromise = _loadModelsDevImpl(fetchFn).finally(() => { _mdLoadPromise = null; });
     return _mdLoadPromise;
 }
 function warmModelsDevFromDiskSync() {
@@ -598,13 +605,15 @@ export async function enrichModels(models, { fetchFn, force = false } = {}) {
 /**
  * Force-refresh the catalog by ignoring cached data and re-fetching.
  * Exposed so a user-initiated "refresh catalog" action in the UI can
- * bypass the 24h TTL.
+ * bypass the process-lifetime overlay cache.
  */
 export async function refreshCatalog() {
     _memCache = null;
     _memCacheAt = 0;
+    _catalogFetchedRemote = false;
     _mdCache = null;
     _mdCacheAt = 0;
+    _mdFetchedRemote = false;
     try {
         if (existsSync(cachePath())) {
             const fs = await import('fs');
@@ -626,7 +635,7 @@ export async function warmModelMetadataCatalogs() {
     return litellm;
 }
 
-/** Fire-and-forget warm of both in-memory catalog caches (disk-first, then remote). */
+/** Fire-and-forget warm of both overlay catalogs (remote once per process). */
 export async function warmCatalogsInBackground() {
     try {
         await Promise.all([loadCatalog(), loadModelsDevCatalog()]);

package/src/runtime/agent/orchestrator/session/loop/tool-exec.mjs

@@ -23,6 +23,53 @@ import { preDispatchDenyForSession, routeWebFetchCall } from './pre-dispatch-den
 import { runWithToolExecutionOwner } from '../../../../shared/tool-execution-owner.mjs';
 import { runWithLocalSearchTelemetry } from '../../tools/builtin/local-search-telemetry.mjs';
 
+const READ_ONLY_IO_TOOL_NAMES = new Set([
+    'read', 'head', 'tail', 'wc', 'summary', 'hex',
+    'grep', 'glob', 'find', 'find_files', 'list', 'tree',
+]);
+const READ_ONLY_IO_TIMEOUT_MS = 20_000;
+
+function readOnlyIoTimeoutMs() {
+    const raw = String(process.env.MIXDOG_IO_TOOL_TIMEOUT_MS ?? '').trim();
+    if (raw === '0') return 0;
+    const configured = Number(raw);
+    return Number.isFinite(configured) && configured > 0
+        ? Math.max(1, Math.floor(configured))
+        : READ_ONLY_IO_TIMEOUT_MS;
+}
+
+async function runReadOnlyIoWithDeadline(name, parentSignal, run) {
+    if (!READ_ONLY_IO_TOOL_NAMES.has(name)) return await run(parentSignal || null);
+    const timeoutMs = readOnlyIoTimeoutMs();
+    if (timeoutMs <= 0) return await run(parentSignal || null);
+    const controller = new AbortController();
+    let rejectAbort;
+    const aborted = new Promise((_, reject) => { rejectAbort = reject; });
+    const abortWith = (reason) => {
+        if (controller.signal.aborted) return;
+        const error = reason instanceof Error ? reason : new Error(String(reason || `tool "${name}" aborted`));
+        rejectAbort(error);
+        controller.abort(error);
+    };
+    const onParentAbort = () => abortWith(parentSignal?.reason);
+    if (parentSignal?.aborted) onParentAbort();
+    else parentSignal?.addEventListener?.('abort', onParentAbort, { once: true });
+    const timeoutError = new Error(`read-only I/O tool "${name}" timed out after ${timeoutMs}ms; work was cancelled`);
+    timeoutError.code = 'READ_ONLY_IO_TIMEOUT';
+    const timer = setTimeout(() => abortWith(timeoutError), timeoutMs);
+    try {
+        return await Promise.race([
+            Promise.resolve().then(() => run(controller.signal)),
+            aborted,
+        ]);
+    } finally {
+        clearTimeout(timer);
+        parentSignal?.removeEventListener?.('abort', onParentAbort);
+    }
+}
+
+export { runReadOnlyIoWithDeadline as _runReadOnlyIoWithDeadlineForTest };
+
 let codeGraphRuntimePromise = null;
 async function executeCodeGraphToolLazy(name, args, cwd, signal = null, options = {}) {
     codeGraphRuntimePromise ??= import('../../tools/code-graph.mjs');
@@ -166,7 +213,12 @@ async function executeToolOwned(name, args, cwd, callerSessionId, sessionRef, ex
         : sessionRef?.afterToolHook;
     const deferredPrep = prepareDeferredToolCallThrough(sessionRef, name, args);
     if (deferredPrep?.deny) return deferredPrep.deny;
-    const __result = await (async () => {
+    const __result = await runReadOnlyIoWithDeadline(name, executeOpts.signal || null, async (deadlineSignal) => {
+    if (deadlineSignal !== executeOpts.signal) {
+        executeOpts = { ...executeOpts, signal: deadlineSignal };
+        completionToolOpts.signal = deadlineSignal;
+    }
+    return await (async () => {
     if (name === 'Skill') {
         return viewSkill(cwd, args?.name);
     }
@@ -238,6 +290,7 @@ async function executeToolOwned(name, args, cwd, callerSessionId, sessionRef, ex
     }
     return formatUnknownBuiltinToolMessage(name, args, 'tool');
     })();
+    });
     if (typeof afterToolHook === 'function') {
         try {
             // Tool outcome metadata is runtime-internal. Hooks receive the same

package/src/runtime/agent/orchestrator/session/token-native.mjs

@@ -13,6 +13,7 @@ import { Worker } from 'node:worker_threads';
 import { getPluginData } from '../config.mjs';
 import { ensureTokenAddon, findCachedTokenAddon } from '../tools/token-addon-fetcher.mjs';
 import { safeIpcSend } from '../../../shared/safe-ipc-send.mjs';
+import { packageNativeToolPath } from '../../../shared/native-tool-paths.mjs';
 
 const PLUGIN_ROOT = process.env.MIXDOG_ROOT
     || pathResolve(pathDirname(fileURLToPath(import.meta.url)), '../../../../..');
@@ -51,6 +52,7 @@ function _resolveAddon() {
         String(process.env.MIXDOG_TOKEN_NATIVE_ADDON || '').trim() || null,
         String(process.env.MIXDOG_TOKEN_NATIVE_BIN || '').trim() || null,
         LOCAL_ADDON,
+        packageNativeToolPath('token'),
     ].filter(Boolean);
     _addonPath = candidates.find((candidate) => {
         try { return existsSync(candidate); } catch { return false; }