mixdog 1.0.1 → 1.0.3

package/src/session-runtime/cwd-plugins/plugin-status.mjs

@@ -1,6 +1,7 @@
 // cwd-plugins/plugin-status.mjs — the registered-plugin status list with its
 // per-root caches (manifest keyed on mtime, MCP discovery and skill-file count
 // on a short TTL).
+import { readFileSync } from 'node:fs';
 import { discoverPluginMcp } from '../../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
 import { pluginMetadata } from '../../runtime/shared/plugin-metadata.mjs';
 
@@ -35,11 +36,25 @@ export function createPluginStatus({
     }
     return key;
   }
+  // A manifest file that exists but is not a JSON object is breakage.
+  function manifestInvalid(root) {
+    for (const rel of ['.codex-plugin/plugin.json', 'plugin.json']) {
+      const file = resolve(root, rel);
+      if (!existsSync(file)) continue;
+      try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return true;
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  }
   function cachedPluginData(root) {
     const key = manifestMtimeKey(root);
     const hit = pluginRootCache.get(root);
     if (hit && hit.key === key) return hit;
-    const entry = { key, manifest: pluginManifest(root) };
+    const entry = { key, manifest: pluginManifest(root), invalid: manifestInvalid(root) };
     pluginRootCache.set(root, entry);
     return entry;
   }
@@ -65,8 +80,9 @@ export function createPluginStatus({
 
   function registeredPlugin(entry, configuredMcp) {
     const root = clean(entry.root);
-    if (!root || !existsSync(root)) return null;
-    const manifest = cachedPluginData(root).manifest;
+    if (!root) return null;
+    if (!existsSync(root)) return { missing: true, id: clean(entry.id) || clean(entry.name) || root, name: clean(entry.name) || clean(entry.id) || root.split(/[\\/]/).pop() || root };
+    const { manifest, invalid } = cachedPluginData(root);
     const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || root.split(/[\\/]/).pop() || root;
     const { mcpScript, mcpInline } = cachedMcpDiscovery(root);
     const plugin = {
@@ -89,6 +105,7 @@ export function createPluginStatus({
       mcpScript,
       mcpInline,
     };
+    if (invalid) plugin.invalid = true;
     plugin.mcpServerName = pluginMcpServerName(plugin);
     plugin.mcpEnabled =
       Object.hasOwn(configuredMcp, plugin.mcpServerName) ||
@@ -101,9 +118,11 @@ export function createPluginStatus({
     const dataDir = cfgMod.getPluginData?.();
     const configuredMcp = config?.mcpServers && typeof config.mcpServers === 'object' ? config.mcpServers : {};
     const plugins = [];
+    const missing = [];
     for (const entry of listRegisteredPlugins({ dataDir })) {
       const plugin = registeredPlugin(entry, configuredMcp);
-      if (plugin) plugins.push(plugin);
+      if (plugin?.missing) missing.push({ id: plugin.id, name: plugin.name, enabled: entry.enabled !== false });
+      else if (plugin) plugins.push(plugin);
     }
     plugins.sort((a, b) => {
       if (a.source !== b.source) return a.source.localeCompare(b.source);
@@ -113,6 +132,7 @@ export function createPluginStatus({
     return {
       count: plugins.length,
       plugins,
+      missing,
       roots: {
         registry: admin.registryPath,
         installed: admin.installRoot,

package/src/session-runtime/internal-tool-executor/feature-tools.mjs

@@ -27,7 +27,15 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
     media: async (args, { callerCtx, callerCwd }) => {
       requireEnabled(callerCtx, mediaToolEnabled, 'media');
       const { executeMediaTool } = await import('../../runtime/media/tool.mjs');
-      return await executeMediaTool(args, { cwd: callerCwd, signal: signalFor(callerCtx) });
+      const { getSession } = await import('../../runtime/agent/orchestrator/session/manager/session-crud.mjs');
+      // Generation spend is attributed to the calling session in the usage ledger.
+      const sessionId = sessionIdFor(callerCtx) || '';
+      return await executeMediaTool(args, {
+        cwd: callerCwd,
+        signal: signalFor(callerCtx),
+        sessionId,
+        sourceType: (sessionId && getSession(sessionId)?.sourceType) || '',
+      });
     },
     tidy: async (args, { callerCtx, callerCwd }) => {
       requireEnabled(callerCtx, tidyToolEnabled, 'tidy');

package/src/session-runtime/services/agent-tool/index-write-queue.mjs

@@ -51,6 +51,38 @@ function recordOps(args, run) {
   });
 }
 
+/**
+ * Collapse a sequence of op sets into one op set per argument slot with the
+ * same sequential outcome: every key ever deleted is deleted (so a foreign
+ * writer's key is still removed), then each surviving key is set once with its
+ * final value, ordered as sequential insertion would leave it (an overwrite
+ * keeps its position, a delete/reinsert moves to the end). Set adds are unioned.
+ */
+function compactOps(batch) {
+  const slots = [];
+  for (const ops of batch) {
+    ops.forEach((op, index) => {
+      if (!op) return;
+      let slot = slots[index];
+      if (!slot) {
+        slot = slots[index] = op.add ? { add: new Set() } : { del: new Set(), final: new Map() };
+      }
+      if (slot.add) {
+        for (const value of op.add) slot.add.add(value);
+        return;
+      }
+      for (const key of op.del) {
+        slot.del.add(key);
+        slot.final.delete(key);
+      }
+      for (const [key, json] of op.set) slot.final.set(key, json);
+    });
+  }
+  return slots.map((slot) =>
+    !slot ? null : slot.add ? { add: slot.add } : { del: slot.del, set: slot.final }
+  );
+}
+
 function replayOps(ops, args) {
   args.forEach((arg, index) => {
     const op = ops[index];
@@ -64,6 +96,10 @@ function replayOps(ops, args) {
   });
 }
 
+function replayBatch(batch, args) {
+  replayOps(compactOps(batch), args);
+}
+
 /**
  * @param {object} options
  * @param {string|null} options.file       index file; null → every write is a no-op
@@ -99,9 +135,7 @@ export function createIndexWriteQueue({ file, rewrite, readDoc, onPersisted = ()
         await updateJsonAtomic(
           file,
           (cur) =>
-            rewrite(cur, (...args) => {
-              for (const ops of batch) replayOps(ops, args);
-            }),
+            rewrite(cur, (...args) => replayBatch(batch, args)),
           { lock: true }
         );
         return;
@@ -153,9 +187,7 @@ export function createIndexWriteQueue({ file, rewrite, readDoc, onPersisted = ()
       updateJsonAtomicSync(
         file,
         (cur) =>
-          rewrite(cur, (...args) => {
-            for (const set of ops) replayOps(set, args);
-          }),
+          rewrite(cur, (...args) => replayBatch(ops, args)),
         { lock: true, timeoutMs: EXIT_LOCK_TIMEOUT_MS }
       );
     } catch {

package/src/session-runtime/services/agent-tool/worker-index/row-store.mjs

@@ -101,9 +101,15 @@ export function createWorkerRowStore(file) {
     return rows;
   }
 
+  // Rows and tombstones must come from the same read/projection. In
+  // particular, do not stat and reload the file between the two collections.
+  function readSnapshot() {
+    const rows = readAll();
+    return { rows, tombstones: (projectedView() || cache)?.tombstones || [] };
+  }
+
   function readTombstones() {
-    readAll();
-    return (projectedView() || cache)?.tombstones || [];
+    return readSnapshot().tombstones;
   }
 
   // Single writer path: the mutator runs now over keyed maps against the
@@ -113,6 +119,7 @@ export function createWorkerRowStore(file) {
 
   return {
     readAll,
+    readSnapshot,
     readTombstones,
     write,
     /** Resolves once every write so far is on disk. */

package/src/session-runtime/services/agent-tool/worker-index.mjs

@@ -27,16 +27,19 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
   const activeWorkerKeys = new Set();
 
   function readWorkerRows(context = {}) {
-    const rows = store.readAll();
+    const { rows, tombstones: savedTombstones } = store.readSnapshot();
     if (rows.length === 0) return rows;
-    const tombstones = new Map(readAllTagTombstones().map((row) => [tagTombstoneKey(row), row]));
+    const tombstones = new Map(recoverTombstoneOwners(savedTombstones).map((row) => [tagTombstoneKey(row), row]));
     return rows.filter(
       (row) => rowMatchesContext(row, context) && !tombstoneBlocksWork(row, findTagTombstone(row, tombstones))
     );
   }
 
   function readAllTagTombstones() {
-    const rows = store.readTombstones();
+    return recoverTombstoneOwners(store.readTombstones());
+  }
+
+  function recoverTombstoneOwners(rows) {
     if (!rows.some((row) => !clean(row.parentSessionId || row.ownerSessionId))) return rows;
     const sessions = typeof mgr.listSessions === 'function' ? mgr.listSessions({ includeClosed: true }) : [];
     // Resolve legacy ownership against all sessions, never just the caller's

package/src/session-runtime/services/hook-bus/event-runner.mjs

@@ -11,8 +11,8 @@ import { parseHandlerOutput } from './handlers.mjs';
 import { createHandlerDispatch } from './handler-dispatch.mjs';
 import { handlerDedupeKey, shellCountFor } from './rules.mjs';
 
-// A failed run is reported as a hook:error and skipped; returns the message
-// or null when the run produced usable output.
+// A failed run is reported as a hook:error and blocks PreToolUse; other events
+// skip it. Returns the message or null when the run produced usable output.
 function runFailure(run, handler) {
   if (run.timedOut)
     return `hook ${shellCountFor(handler)} timed out: ${handler.command || handler.url || handler.type}`;
@@ -23,6 +23,12 @@ function runFailure(run, handler) {
   return null;
 }
 
+function failClosed(agg, message) {
+  agg.blocked = true;
+  agg.reason = `PreToolUse policy check failed: ${message}`;
+  return agg;
+}
+
 function foldParsedOutput(agg, parsed) {
   if (parsed.additionalContext) agg.additionalContext.push(parsed.additionalContext);
   if (parsed.updatedInput && !agg.updatedInput) agg.updatedInput = parsed.updatedInput;
@@ -90,12 +96,14 @@ export function createEventRunner({ loadConfig, emit, cursor, pluginData, prompt
       } catch (error) {
         throwIfAborted(signal);
         emit('hook:error', { name: payload.tool_name || eventName, error: error?.message || String(error) });
+        if (eventName === 'PreToolUse') return failClosed(agg, error?.message || String(error));
         continue;
       }
       if (!run) continue;
       const failure = runFailure(run, handler);
       if (failure) {
         emit('hook:error', { name: payload.tool_name || eventName, error: failure });
+        if (eventName === 'PreToolUse') return failClosed(agg, failure);
         continue;
       }
       foldParsedOutput(agg, parseHandlerOutput(run, eventName));

package/src/session-runtime/services/hook-bus/tool-gate.mjs

@@ -65,8 +65,11 @@ export function createToolGate({ loadConfig, loadRules, runEventHandlers, emit,
       return standardDecision(agg, input) ?? legacyDecision(cfg, input);
     } catch (error) {
       throwIfAborted(signal);
-      emit('hook:error', { name: input.name || input.tool_name || 'tool', error: error?.message || String(error) });
-      return null;
+      const message = error?.message || String(error);
+      emit('hook:error', { name: input.name || input.tool_name || 'tool', error: message });
+      const reason = `PreToolUse policy check failed: ${message}`;
+      emit('tool:deny', { ...identityOf(input), reason });
+      return { action: 'deny', reason };
     }
   };
 }

package/src/session-runtime/setup-tool/tool-defs.mjs

@@ -204,7 +204,7 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         },
         name: {
           type: 'string',
-          description: `set_builtin_enabled: ${SETUP_BUILTIN_TOGGLE_FEATURES.join('|')}; install_builtin also accepts memory. Memory toggles use set_memory_enabled. set_first_use_approval: browser|computer; else MCP/plugin/provider id.`,
+          description: `set_builtin_enabled: ${SETUP_BUILTIN_TOGGLE_FEATURES.join('|')}; install_builtin also accepts memory. Memory toggles use set_memory_enabled. set_first_use_approval: browser|computer; revoke_linked_device: client id from status connection, not its display name; else MCP/plugin/provider id.`,
         },
         modelId: {
           type: 'string',

package/src/session-runtime/workflow-agents-api/agent-route.mjs

@@ -68,8 +68,10 @@ export function createAgentRouteApi(deps) {
     const requested = { ...(next || {}) };
     const stored = agentRouteFromConfig(getConfig(), id) || {};
     // Off is an explicit state, stored apart from the route so the model the
-    // user picked survives and comes back when the agent is switched on.
-    if (requested.disabled === true) {
+    // user picked survives and comes back when the agent is switched on. An
+    // off request that also carries a model saves that model and stays off.
+    const keepOff = requested.disabled === true;
+    if (keepOff && !(clean(requested.provider) && clean(requested.model))) {
       saveDisabled(id, true);
       return { ...stored, id, disabled: true };
     }
@@ -77,6 +79,7 @@ export function createAgentRouteApi(deps) {
       saveDisabled(id, false);
       return { ...stored, id, disabled: false, inherited: !stored.provider };
     }
+    delete requested.disabled;
     // Tuning-only edits must preserve the selected agent model, not silently inherit Main.
     const current = stored.provider ? stored : normalizeWorkflowRoute(resolveRoute(getConfig(), {})) || {};
     if (!hasOwn(requested, 'provider')) requested.provider = current.provider;
@@ -87,11 +90,11 @@ export function createAgentRouteApi(deps) {
     if (!clean(requested.model)) throw new Error('agent route requires provider and model');
     const routeToSave = normalizeWorkflowRoute(await resolveSelectedRoute(requested, stored));
     if (!routeToSave) throw new Error('agent route requires provider and model');
-    // Picking a model is also the "on" switch — the two states are exclusive.
-    const nextConfig = withAgentDisabled(getConfig(), id, false);
+    // Picking a model is also the "on" switch unless the request keeps it off.
+    const nextConfig = withAgentDisabled(getConfig(), id, keepOff);
     nextConfig.agents = { ...(nextConfig.agents || {}), [id]: routeToSave };
     saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
-    return routeToSave;
+    return keepOff ? { ...routeToSave, id, disabled: true } : routeToSave;
   }
 
   return { setAgentRoute };

package/src/tui/app/doctor.mjs

@@ -15,6 +15,7 @@
 import { compareSemver } from '../../runtime/shared/update-checker.mjs';
 import { resolvePluginData } from '../../runtime/shared/plugin-paths.mjs';
 import { hasEnabledAutomation } from '../../runtime/shared/automation-presence.mjs';
+import { builtinFeatureActive } from '../../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 import { providerRowUsable } from './provider-usable.mjs';
 import { constants as fsConstants, readFileSync } from 'node:fs';
 import { access, readdir, readFile } from 'node:fs/promises';
@@ -247,16 +248,78 @@ function reportRegistry(label) {
     const broken = active.filter(
       (entry) => entry.broken || entry.error || entry.invalid || entry.dependencyIssues?.length
     );
+    const missing = Array.isArray(status.missing)
+      ? status.missing.filter((entry) => entry.enabled !== false)
+      : [];
     let detail = `${active.length}/${entries.length} active${scopeDetail}`;
-    if (!broken.length) {
+    const issues = [...broken, ...(label === 'plugins' ? missing : [])];
+    if (!issues.length) {
       row('ok', detail);
       return;
     }
-    detail += ` · issues: ${broken.map((entry) => entry.name || entry.id).join(', ')}`;
+    detail += ` · issues: ${issues.map((entry) => entry.name || entry.id).join(', ')}`;
     row('warn', detail, { command: `/${label}` });
   };
 }
 
+function reportLocalProvider(local, row) {
+  if (typeof local.installed !== 'boolean') {
+    row('warn', 'status unavailable');
+    return;
+  }
+  if (!local.installed) {
+    row('ok', 'not installed');
+    return;
+  }
+  if (local.enabled !== true) {
+    row('ok', 'installed · disabled');
+    return;
+  }
+  const fix = { command: '/providers' };
+  const models = Array.isArray(local.models) ? local.models.filter((model) => model.installed === true).length : 0;
+  const jobs = Array.isArray(local.installations) ? local.installations : [];
+  const latest = jobs.reduce((a, b) => (a && (a.updatedAt || 0) > (b.updatedAt || 0) ? a : b), null);
+  if (latest?.state === 'failed') {
+    row('warn', `installed · enabled · ${models} models · latest installation failed`, fix);
+  } else if (!models) {
+    row('warn', 'installed · enabled · no model installed', fix);
+  } else row('ok', `installed · enabled · ${models} models installed`);
+}
+
+function reportBuiltins(settings, row) {
+  const groups = { enabled: [], disabled: [], 'not installed': [] };
+  for (const id of ['git', 'office', 'tidy']) {
+    const entry = settings[id];
+    if (!entry || typeof entry.installed !== 'boolean') {
+      row('warn', 'status unavailable');
+      return;
+    }
+    if (!entry.installed) groups['not installed'].push(id);
+    else groups[entry.enabled === false ? 'disabled' : 'enabled'].push(id);
+  }
+  const parts = Object.entries(groups)
+    .filter(([, ids]) => ids.length)
+    .map(([state, ids]) => `${state}: ${ids.join(', ')}`);
+  const bridge = (id) => (builtinFeatureActive(undefined, id) ? 'bridge active' : 'no bridge');
+  row('ok', `${parts.join(' · ')} · browser use ${bridge('browser')} · computer use ${bridge('computer')}`);
+}
+
+function reportVoice(voice, row) {
+  if (typeof voice.enabled !== 'boolean') {
+    row('warn', 'status unavailable');
+    return;
+  }
+  if (!voice.enabled) {
+    row('ok', 'disabled');
+    return;
+  }
+  if (voice.installed !== true || voice.components?.model === false) {
+    row('warn', 'enabled · runtime or model not installed', { hint: 'reinstall voice from Extensions' });
+    return;
+  }
+  row('ok', 'enabled · runtime and model installed');
+}
+
 function reportHooks(hooks, row) {
   if (
     typeof hooks.enabled !== 'boolean' ||
@@ -333,6 +396,19 @@ export async function runDoctorChecks(runtime = {}, getState = () => ({}), optio
     ['providers', 'providers', () => runtime.getProviderSetup?.(), reportProviders(getState)],
     ['mcp', 'mcp', () => runtime.mcpStatus?.(), reportMcp],
     ['memory', 'memory', async () => (await runtime.getToolModuleSettings?.())?.memory, reportMemory(runtime)],
+    [
+      'localProvider',
+      'local provider',
+      async () => (await runtime.getToolModuleSettings?.())?.localProvider,
+      reportLocalProvider,
+    ],
+    ['builtins', 'built-ins', async () => runtime.getToolModuleSettings?.(), reportBuiltins],
+    [
+      'voice',
+      'voice',
+      async () => (runtime.getVoiceStatus || (await import('../lib/voice-setup.mjs')).getVoiceStatus)(),
+      reportVoice,
+    ],
     [
       'channels',
       'channels',

package/src/tui/dist/index.mjs

@@ -47669,7 +47669,11 @@ var LITELLM_NUMBER_FIELDS = [
   "input_cost_per_token",
   "output_cost_per_token",
   "cache_read_input_token_cost",
-  "cache_creation_input_token_cost"
+  "cache_creation_input_token_cost",
+  "output_cost_per_image",
+  "output_cost_per_image_token",
+  "output_cost_per_video_token",
+  "output_cost_per_second"
 ];
 var LITELLM_FLAG_FIELDS = [
   "supports_vision",
@@ -47688,9 +47692,9 @@ function projectLitellmRow(row) {
     if (typeof value === "number" && Number.isFinite(value)) out[field] = value;
   }
   for (const [field, value] of Object.entries(row)) {
-    if (/^(?:input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)(?:_above_\d+k_tokens)?(?:_priority)?$/.test(
+    if ((/^(?:input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)(?:_above_\d+k_tokens)?(?:_priority)?$/.test(
       field
-    ) && typeof value === "number" && Number.isFinite(value))
+    ) || /^output_cost_per_second_\w+$/.test(field)) && typeof value === "number" && Number.isFinite(value))
       out[field] = value;
   }
   for (const field of LITELLM_FLAG_FIELDS) {

package/scripts/lib/bench-sandbox.test.mjs

@@ -1,54 +0,0 @@
-import assert from 'node:assert/strict';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-import {
-  authArtifactNamesForSandbox,
-  copyAuthArtifacts,
-  extractSessionId,
-  readUnifiedConfig,
-} from './bench-sandbox.mjs';
-
-function withDir(run) {
-  const dir = mkdtempSync(join(tmpdir(), 'bench-sandbox-'));
-  try {
-    return run(dir);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-}
-
-test('extractSessionId prefers the labelled id, then any sess_ token', () => {
-  assert.equal(extractSessionId('sessionId: sess_abc123 other sess_zzz'), 'sess_abc123');
-  assert.equal(extractSessionId('noise sess_q9 end'), 'sess_q9');
-  assert.equal(extractSessionId('nothing here'), null);
-  assert.equal(extractSessionId(undefined), null);
-});
-
-test('readUnifiedConfig returns an object, and {} for a missing or non-object file', () => {
-  withDir((dir) => {
-    assert.deepEqual(readUnifiedConfig(dir), {});
-    writeFileSync(join(dir, 'mixdog-config.json'), '{"a":1}');
-    assert.deepEqual(readUnifiedConfig(dir), { a: 1 });
-    writeFileSync(join(dir, 'mixdog-config.json'), 'null');
-    assert.deepEqual(readUnifiedConfig(dir), {});
-  });
-});
-
-test('auth artifacts: provider files plus every oauth/credentials json in the real dir', () => {
-  withDir((real) => {
-    writeFileSync(join(real, 'grok-oauth.json'), 'g');
-    writeFileSync(join(real, 'extra-credentials.json'), 'c');
-    writeFileSync(join(real, 'unrelated.json'), 'u');
-    const names = authArtifactNamesForSandbox(real, 'grok-oauth').sort();
-    assert.deepEqual(names, ['extra-credentials.json', 'grok-oauth-models.json', 'grok-oauth.json']);
-    const sandbox = join(real, 'sandbox');
-    mkdirSync(sandbox);
-    const { copied, skipped } = copyAuthArtifacts(real, sandbox, 'grok-oauth');
-    assert.deepEqual(copied.sort(), ['extra-credentials.json', 'grok-oauth.json']);
-    assert.deepEqual(skipped, ['grok-oauth-models.json']);
-    assert.equal(readFileSync(join(sandbox, 'grok-oauth.json'), 'utf8'), 'g');
-    assert.equal(existsSync(join(sandbox, 'unrelated.json')), false);
-  });
-});

package/scripts/lib/cli-args.test.mjs

@@ -1,64 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { argValue, hasFlag, intArg, numArg, positionalArgs } from './cli-args.mjs';
-
-test('argValue reads both the separated and the joined option form', () => {
-  const argv = ['node', 'bench.mjs', '--model', 'opus', '--round=3', '--trailing'];
-  assert.equal(argValue('--model', null, argv), 'opus');
-  assert.equal(argValue('--round', null, argv), '3');
-  assert.equal(argValue('--missing', null, argv), null);
-  assert.equal(argValue('--missing', 'fallback', argv), 'fallback');
-  // An explicit `undefined` fallback takes the parameter default, so a
-  // missing option always reads as null rather than undefined.
-  assert.equal(argValue('--missing', undefined, argv), null);
-});
-
-test('argValue falls back when the separated form has no value left', () => {
-  assert.equal(argValue('--save', 'default', ['node', 'bench.mjs', '--save']), 'default');
-  // An empty joined value is a value, not a missing option.
-  assert.equal(argValue('--save', 'default', ['node', 'bench.mjs', '--save=']), '');
-  // The next argument is taken verbatim, even when it looks like a flag.
-  assert.equal(argValue('--save', null, ['node', 'bench.mjs', '--save', '--json']), '--json');
-});
-
-test('hasFlag reports presence only', () => {
-  const argv = ['node', 'bench.mjs', '--json', '--limit=5'];
-  assert.equal(hasFlag('--json', argv), true);
-  assert.equal(hasFlag('--limit', argv), false);
-  assert.equal(hasFlag('--quiet', argv), false);
-});
-
-test('intArg accepts positive integers and keeps the fallback otherwise', () => {
-  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '5']), 5);
-  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit=12']), 12);
-  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs']), 30);
-  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', 'abc']), 30);
-  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '0']), 30);
-  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '-4']), 30);
-  // parseInt stops at the first non-digit, as the CLIs have always accepted.
-  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '7x']), 7);
-});
-
-test('numArg keeps a deliberate 0 and falls back only on missing or non-numeric values', () => {
-  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', '0']), 0);
-  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget=0']), 0);
-  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', '2500']), 2500);
-  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', '0.5']), 0.5);
-  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs']), 16000);
-  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget=']), 16000);
-  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', 'lots']), 16000);
-  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget']), 16000);
-});
-
-test('positionalArgs never lets a boolean flag or a joined value swallow a positional', () => {
-  const booleans = new Set(['--render']);
-  assert.deepEqual(positionalArgs(['--render', 'deck.js', 'deck.pptx', '--mode', 'auto'], booleans), [
-    'deck.js',
-    'deck.pptx',
-  ]);
-  assert.deepEqual(positionalArgs(['--mode=auto', 'deck.js', 'deck.pptx'], booleans), ['deck.js', 'deck.pptx']);
-  assert.deepEqual(positionalArgs(['deck.js', '--out', 'result.json', 'deck.pptx', '--render'], booleans), [
-    'deck.js',
-    'deck.pptx',
-  ]);
-});

package/scripts/lib/embedding-model-bench-core.test.mjs

@@ -1,47 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { selectDeterministicCorpus } from './embedding-model-bench-core.mjs';
-
-const documents = Object.freeze([6, 3, 2, 5, 4, 1, 3].map((id) => Object.freeze({ id })));
-
-test('negative sampling preserves SHA-256 order, document order, and duplicate rows', () => {
-  // SHA-256("4") starts 4b22, then "3" starts 4e07; the other IDs sort after both.
-  const selection = selectDeterministicCorpus(documents, [{ positiveIdsByTarget: [[6]] }], 3);
-  assert.deepEqual(selection, {
-    documents: [{ id: 6 }, { id: 3 }, { id: 4 }, { id: 3 }],
-    sourceDocuments: 7,
-    selectedDocuments: 3,
-    positiveDocuments: 1,
-    method: 'all-positive-roots + sha256(document-id) negatives',
-  });
-});
-
-test('positive caps use the same hash ordering without counting duplicate IDs twice', () => {
-  const selection = selectDeterministicCorpus(documents, [{ positiveIdsByTarget: [[1, 2, 3, 4, 5, 6, 3]] }], 2, 2);
-  assert.deepEqual(selection, {
-    documents: [{ id: 3 }, { id: 4 }, { id: 3 }],
-    sourceDocuments: 7,
-    selectedDocuments: 2,
-    positiveDocuments: 2,
-    method: 'up-to-2-positive-roots-per-target + sha256(document-id) negatives',
-  });
-});
-
-test('full-corpus selections retain the original array and capped positive count', () => {
-  for (const limit of [0, 1.5, 7, 9]) {
-    const selection = selectDeterministicCorpus(
-      documents,
-      [{ positiveIdsByTarget: [[1, 2, 3, 4, 5, 6, 3]] }],
-      limit,
-      2
-    );
-    assert.equal(selection.documents, documents);
-    assert.deepEqual(selection, {
-      documents,
-      sourceDocuments: 7,
-      selectedDocuments: 7,
-      positiveDocuments: 2,
-      method: 'full-corpus',
-    });
-  }
-});

package/scripts/lib/smoke-loop-shared.test.mjs

@@ -1,22 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { parseDuration, summarize } from './smoke-loop-shared.mjs';
-
-test('parseDuration reads bare milliseconds and unit suffixes', () => {
-  assert.equal(parseDuration('1500'), 1500);
-  assert.equal(parseDuration('30s'), 30_000);
-  assert.equal(parseDuration('5M'), 300_000);
-  assert.equal(parseDuration('1.5h'), 5_400_000);
-  assert.equal(parseDuration('0ms'), 1);
-});
-
-test('parseDuration returns the fallback when empty and throws on garbage', () => {
-  assert.equal(parseDuration('', 7), 7);
-  assert.equal(parseDuration(undefined), null);
-  assert.throws(() => parseDuration('soon'), /invalid duration: soon/);
-});
-
-test('summarize rounds min/max/avg to one decimal, zeros when empty', () => {
-  assert.deepEqual(summarize([]), { min: 0, max: 0, avg: 0 });
-  assert.deepEqual(summarize([1.04, 2.06, 3.31]), { min: 1, max: 3.3, avg: 2.1 });
-});