mixdog 0.9.127 → 0.9.129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.127",
+  "version": "0.9.129",
   "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/app.mjs

@@ -86,6 +86,8 @@ export async function run(argv = [], classifiedInvocation = null) {
       model: opts.model,
       effort: opts.effort,
       fast: opts.fast,
+      webSearch: opts.webSearch,
+      memory: opts.memory,
       json: opts.json,
       cwd: process.cwd(),
     });

package/src/headless-command.mjs

@@ -4,7 +4,7 @@ const FLAG_OPTIONS = new Set([
   '--web-search', '--memory', '--json',
 ]);
 const EXEC_UNSUPPORTED_FLAGS = new Set([
-  '--readonly', '--remote', '--onboarding', '--web-search', '--memory',
+  '--readonly', '--remote', '--onboarding',
 ]);
 const HEADLESS_WORKFLOW_ERROR = 'option --workflow is not supported for mixdog exec';
 

package/src/headless-exec.mjs

@@ -90,6 +90,8 @@ function createJsonLifecycle({
   effort,
   fast,
   cwd,
+  webSearch = false,
+  memory = false,
 }) {
   let threadId = `exec_${randomUUID().replace(/-/g, '')}`;
   const turnId = 'turn_1';
@@ -143,6 +145,8 @@ function createJsonLifecycle({
         tool_mode: 'full',
         approval_mode: 'implicit',
         delegation: false,
+        web_search: webSearch === true,
+        memory: memory === true,
       },
     }, turnStartedAt);
     emit({
@@ -540,6 +544,8 @@ export async function runHeadlessExec({
   model,
   effort,
   fast,
+  webSearch = false,
+  memory = false,
   json = false,
   cwd = process.cwd(),
   write = (text) => stdout.write(text),
@@ -571,6 +577,8 @@ export async function runHeadlessExec({
     effort,
     fast,
     cwd,
+    webSearch,
+    memory,
   }) : null;
   let boundary = null;
   let runtime = null;
@@ -602,6 +610,12 @@ export async function runHeadlessExec({
     const createRuntime = runtimeFactory || (
       await import('./mixdog-session-runtime.mjs')
     ).createMixdogSessionRuntime;
+    // Headless defaults: web research and memory tools stay OFF unless the
+    // caller opts in via --web-search / --memory. Delegation is already
+    // disallowed below, completing the solo surface. The per-process
+    // MIXDOG_FEATURE_* overrides are the runtime's canonical switches.
+    process.env.MIXDOG_FEATURE_WEB_SEARCH = webSearch === true ? '1' : '0';
+    process.env.MIXDOG_FEATURE_MEMORY = memory === true ? '1' : '0';
     runtime = await createRuntime({
       provider,
       model,

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/agent-loop.mjs

@@ -1009,6 +1009,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         // server-side cache prefix stable.
         const _assistantTurnMsg = attachAssistantTranscriptMetadata({
             role: 'assistant',
+            createdAt: Date.now(),
             // Sub-agent tool-call turns carry only mid-turn preamble in
             // response.content (the real result rides the later final-answer
             // turn). Blank it so it never accumulates as input tokens.