mixdog 0.8.1 → 0.9.1

package/README.md

@@ -1,8 +1,25 @@
 # mixdog
 
-Standalone coding-agent CLI/TUI workspace for **mixdog**.
-
-An Ink (React) terminal UI front-end driving multi-provider LLM agents (Anthropic, OpenAI, Google) over MCP, with Mixdog's Ink renderer (`vendor/ink`) for full-screen alt-screen rendering, cursor handling, and scroll support.
+Mixdog is a standalone coding-agent CLI/TUI workspace for developers who want
+one terminal experience across multiple LLM providers.
+
+It combines an Ink-based terminal UI, a multi-provider runtime, workflow agents,
+MCP/plugin/skill loading, memory, web search, channel integrations, and focused
+repo tools for reading, editing, testing, and reviewing code.
+
+## Highlights
+
+- Multi-provider model routing for Anthropic, OpenAI-compatible APIs, Google,
+  XAI/Grok, OAuth-backed providers, and local endpoints.
+- Full-screen TUI with slash commands, model/workflow pickers, provider setup,
+  usage dashboards, tool cards, statusline integration, and resumable sessions.
+- Agent task delegation through the `agent` tool and `/agent` command.
+- Focused repo tools for `read`, `grep`, `glob`, `list`, `code_graph`,
+  `apply_patch`, `shell`, `cwd`, `explore`, web search, and memory recall.
+- Workflow agents for implementation, review, debugging, maintenance, web
+  research, and heavier model routes.
+- Optional Discord/channel/webhook/schedule integrations for remote or event
+  driven workflows.
 
 ## Requirements
 
@@ -24,37 +41,44 @@ mixdog --help
 ## Usage
 
 ```bash
-# Run the CLI from any project directory
+# Run the TUI from any project directory
 mixdog
 
-# Build the Ink (React) TUI bundle
-npm run build:tui
-
-# Smoke test
+# Run the basic smoke test
 npm run smoke
 
+# Run the core smoke suite
+npm run smoke:all
 ```
 
-## Project layout
+Inside the TUI, use `/providers` to configure model access, `/model` to switch
+models, `/workflow` to select a workflow, `/agents` to inspect available
+workflow agents, and `/agent` to manage active agent tasks.
 
-```
+## Project Layout
+
+```text
 src/
-  cli.mjs        # entry point (bin: mixdog)
+  cli.mjs        # CLI entry point (bin: mixdog)
   app.mjs        # app wiring
-  repl.mjs       # REPL loop
-  runtime/       # agent runtime
-  tui/           # canonical Ink (React) TUI (bundled to dist/)
-  lib/ ui/ hooks/ defaults/ vendor/
+  repl.mjs       # plain REPL loop
+  runtime/       # provider runtime, tools, memory, channels
+  tui/           # canonical Ink TUI (bundled to dist/)
+  agents/        # workflow agent definitions
+  rules/         # Lead and agent instructions
 scripts/
-  build-tui.mjs  # esbuild bundle of the React TUI
-  smoke.mjs      # smoke test
+  smoke*.mjs     # smoke checks
+  build-tui.mjs  # esbuild bundle for the React TUI
 vendor/
-  ink/           # Mixdog Ink renderer (alt-screen / cursor / scroll fixes)
+  ink/           # Mixdog Ink renderer
 ```
 
-## Notes
+## Data And Configuration
+
+Standalone Mixdog uses `~/.mixdog` as its home root. Runtime data lives in
+`~/.mixdog/data` by default. Set `MIXDOG_HOME` to move the root, or
+`MIXDOG_DATA_DIR` to override only the data directory.
 
-- `vendor/ink` is bundled directly into the TUI dist; the build does not rewrite installed dependencies.
-- Standalone Mixdog uses `~/.mixdog` as its home root. Runtime data lives in `~/.mixdog/data` by default. Set `MIXDOG_HOME` to move the root, or `MIXDOG_DATA_DIR` to override only the data directory.
-- Pi/Codex/OpenCode reference snapshots live outside this package under `C:\Project\refs`.
-- The TUI uses alt-screen mode and app-owned mouse wheel scrolling / drag selection by default so redraws during streaming do not clear selections. Set `MIXDOG_TUI_MOUSE=0` to opt into terminal-native mouse behavior.
+The TUI uses alt-screen mode and app-owned mouse wheel scrolling / drag
+selection by default. Set `MIXDOG_TUI_MOUSE=0` to opt into terminal-native mouse
+behavior.

package/package.json

@@ -1,6 +1,6 @@
-{
+{
   "name": "mixdog",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -25,7 +25,6 @@
   },
   "files": [
     "README.md",
-    "docs/",
     "scripts/",
     "src/",
     "vendor/"
@@ -42,32 +41,39 @@
     "smoke:loop:report": "node scripts/smoke-loop-report.mjs",
     "smoke:tools": "node scripts/tool-smoke.mjs",
     "smoke:output": "node scripts/output-style-smoke.mjs",
+    "test:toolcall": "node --test scripts/toolcall-args-test.mjs",
+    "test:providers": "node --test scripts/provider-toolcall-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
+    "trace:llm": "node scripts/llm-trace-summary.mjs",
     "build:tui": "node scripts/build-tui.mjs"
   },
-  "engines": {
-    "node": ">=22.0.0"
-  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.105.0",
-    "@google/generative-ai": "^0.24.1",
-    "@huggingface/transformers": "^3.8.1",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@mozilla/readability": "^0.6.0",
-    "diff": "^9.0.0",
-    "discord.js": "^14.26.4",
-    "ink": "^7.1.0",
-    "jsdom": "^26.1.0",
-    "marked": "^14.1.4",
-    "node-cron": "^4.5.0",
-    "openai": "^6.44.0",
-    "pg": "^8.22.0",
-    "puppeteer-core": "^25.2.0",
-    "react": "^19.2.7",
-    "undici": "^8.5.0",
-    "ws": "^8.21.0",
-    "zod": "^3.25.76",
-    "zod-to-json-schema": "^3.25.2"
+    "@anthropic-ai/sdk": "^0.105.0",
+    "@google/generative-ai": "^0.24.1",
+    "@huggingface/transformers": "^3.8.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@mozilla/readability": "^0.6.0",
+    "chalk": "^5.6.2",
+    "cli-highlight": "^2.1.11",
+    "diff": "^9.0.0",
+    "discord.js": "^14.26.4",
+    "ink": "^7.1.0",
+    "jsdom": "^26.1.0",
+    "marked": "^14.1.4",
+    "node-cron": "^4.5.0",
+    "openai": "^6.44.0",
+    "pg": "^8.22.0",
+    "puppeteer-core": "^25.2.0",
+    "react": "^19.2.7",
+    "string-width": "^8.2.1",
+    "strip-ansi": "^7.2.0",
+    "undici": "^8.5.0",
+    "wrap-ansi": "^10.0.0",
+    "ws": "^8.21.0",
+    "zod": "^3.25.76"
   },
   "overrides": {
     "discord.js": {
@@ -78,6 +84,6 @@
     }
   },
   "devDependencies": {
-    "esbuild": "^0.28.1"
-  }
-}
+    "esbuild": "^0.28.1"
+  }
+}

package/scripts/_test-folder-dialog.mjs

@@ -0,0 +1,30 @@
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+
+const src = readFileSync('src/standalone/folder-dialog.mjs', 'utf8');
+const fn = src.match(/function powershellScript[\s\S]*?return \[([\s\S]*?)\]\.join/);
+if (!fn) throw new Error('parse failed');
+// Re-eval powershellScript by importing - use dynamic compile
+const modUrl = new URL('../src/standalone/folder-dialog.mjs', import.meta.url);
+// Call pickFolder with a hook - instead duplicate minimal import
+const { pickFolder } = await import(modUrl.href);
+
+const child = spawn('powershell.exe', [
+  '-NoLogo', '-NoProfile', '-STA', '-Command',
+  [
+    '$ErrorActionPreference = "Continue"',
+    'try {',
+    ...readFileSync('src/standalone/folder-dialog.mjs', 'utf8')
+      .split('\n')
+      .filter((l) => l.includes('Add-Type -AssemblyName') || l.includes('Add-Type -TypeDefinition') || l.includes('GetDialogOwnerCenter')),
+    '} catch { Write-Error $_; exit 1 }',
+  ].join('; '),
+], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+
+let err = '';
+child.stderr.on('data', (d) => { err += d.toString(); });
+child.on('close', (code) => {
+  console.log('code', code);
+  console.log(err.slice(0, 2000));
+});
+

package/scripts/agent-parallel-smoke.mjs

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+// Focused parallelism smoke for the agent spawn fanout.
+//
+// Goals validated here (no network, fake askSession):
+//   1. A batch of independent spawns fired together each return a task_id
+//      *immediately* (sync return is fast and never blocks on prep/model).
+//   2. The fanout returns all task_ids well before any single agent's work
+//      finishes — i.e. spawn returns are non-blocking.
+//   3. ensureProvider() is collapsed: N same-provider spawns trigger at most
+//      one initProviders() pass (shared in-flight + already-registered guard).
+//   3b. A provider CONFIG CHANGE still re-runs initProviders() (the de-dup is
+//      keyed on provider + effective-config signature, not on "is registered"),
+//      while an unchanged config is skipped.
+//   4. A wedged prep step trips the independent spawn-prep cap even when the
+//      first-response watchdog is explicitly disabled (firstResponseTimeoutMs:0).
+//   5. spawnPrepTimeoutMs:0 disables the prep cap even when an env default cap
+//      is set (explicit per-call override beats the env default).
+//
+// Run: node scripts/agent-parallel-smoke.mjs
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  closeSession,
+  getSession,
+  getSessionLastProgressAt,
+  getSessionRuntime,
+  enqueuePendingMessage,
+  listSessions,
+} from '../src/runtime/agent/orchestrator/session/manager.mjs';
+import {
+  getProvider as realGetProvider,
+  initProviders as realInitProviders,
+} from '../src/runtime/agent/orchestrator/providers/registry.mjs';
+
+// Trace flush is irrelevant here and must never hold the loop open.
+process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+// Set a real env prep-cap BEFORE importing agent-tool.mjs so its module-load
+// `DEFAULT_SPAWN_PREP_TIMEOUT_MS` actually captures this value — that is what
+// makes the "spawnPrepTimeoutMs:0 disables prep even with an env default"
+// assertion below genuine. Kept large enough that normal (fast) prep never
+// trips it, but small enough that a deliberately slow 200ms prep would.
+const ENV_PREP_CAP_MS = 150;
+process.env.MIXDOG_AGENT_SPAWN_PREP_TIMEOUT_MS = String(ENV_PREP_CAP_MS);
+// Dynamic import AFTER the env is set (static imports hoist and would capture
+// the default before this line runs).
+const { createStandaloneAgent } = await import('../src/standalone/agent-tool.mjs');
+
+const root = mkdtempSync(join(tmpdir(), 'mixdog-agent-parallel-'));
+const dataDir = join(root, '.mixdog-data');
+mkdirSync(dataDir, { recursive: true });
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+function taskId(text) { return String(text).match(/agent task: (\S+)/)?.[1] || null; }
+
+// Wrap the REAL registry so createSession()'s internal getProvider() resolves a
+// genuine provider instance, while we still count initProviders() passes and can
+// simulate "not yet registered" to exercise ensureProvider's collapse path.
+let initProvidersCalls = 0;
+let forceProviderMiss = false;
+const reg = {
+  getProvider(name) { return forceProviderMiss ? undefined : realGetProvider(name); },
+  async initProviders(config) {
+    initProvidersCalls += 1;
+    await sleep(5); // simulate a small async cost
+    return realInitProviders(config);
+  },
+};
+
+// Mutable provider config so a regression test can change it and assert the
+// signature-keyed ensureProvider() re-runs initProviders().
+let providerConfig = { 'openai-oauth': { enabled: true } };
+const cfgMod = {
+  loadConfig() {
+    return {
+      providers: providerConfig,
+      agents: {
+        worker: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low', fast: true },
+        reviewer: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low' },
+        debugger: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low' },
+      },
+      presets: [
+        { id: 'fake-worker', name: 'Fake Worker', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'full', effort: 'low', fast: true },
+      ],
+    };
+  },
+  resolveRuntimeSpec(preset, ctx) {
+    return { lane: 'agent', scopeKey: `parallel:${ctx.agentId}`, provider: preset.provider, model: preset.model };
+  },
+};
+
+const askStartedAt = [];
+let askConcurrency = 0;
+let maxAskConcurrency = 0;
+async function fakeAskSession(sessionId, prompt) {
+  const session = getSession(sessionId);
+  if (session) { session.status = 'running'; session.lastStreamDeltaAt = Date.now(); }
+  askStartedAt.push(Date.now());
+  askConcurrency += 1;
+  maxAskConcurrency = Math.max(maxAskConcurrency, askConcurrency);
+  try {
+    await sleep(300); // each agent's "work" lasts noticeably longer than spawn return
+    return { content: `ack ${session?.role || 'worker'}` };
+  } finally {
+    askConcurrency -= 1;
+    if (session) { session.status = 'idle'; session.lastStreamDeltaAt = Date.now(); }
+  }
+}
+
+const mgr = {
+  getSession,
+  listSessions,
+  closeSession,
+  getSessionRuntime,
+  enqueuePendingMessage,
+  getSessionLastProgressAt,
+  askSession: fakeAskSession,
+};
+
+const agent = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root });
+
+async function waitJob(out, pattern, label, tries = 60) {
+  const id = taskId(out);
+  assert(id, `missing task ID for ${label}: ${out}`);
+  let last = '';
+  for (let i = 0; i < tries; i += 1) {
+    last = await agent.execute({ type: 'read', task_id: id }, { invocationSource: 'model-tool', cwd: root });
+    if (pattern.test(last)) return last;
+    if (/status: error/.test(last)) return last;
+    await sleep(50);
+  }
+  throw new Error(`${label} did not finish with ${pattern}: ${last}`);
+}
+
+async function main() {
+  // Register the real provider once so createSession() can resolve it.
+  await realInitProviders({ 'openai-oauth': { enabled: true } });
+
+  // --- 1+2: parallel spawns return task_ids fast and non-blocking ---
+  const batchSize = 6;
+  const t0 = Date.now();
+  const outs = await Promise.all(
+    Array.from({ length: batchSize }, (_, i) => agent.execute({
+      type: 'spawn',
+      role: i % 2 === 0 ? 'worker' : 'reviewer',
+      tag: `par${i}`,
+      cwd: root,
+      prompt: `parallel task ${i}`,
+    }, { invocationSource: 'model-tool', cwd: root })),
+  );
+  const spawnReturnMs = Date.now() - t0;
+  assert(outs.every((o) => /agent task:/.test(o)), `all spawns must return task ids: ${outs.join('\n---\n')}`);
+  assert(outs.every((o) => /status: running/.test(o)), 'spawns must report running immediately');
+  // The whole batch must return long before any single agent finishes (300ms each).
+  assert(spawnReturnMs < 250, `parallel spawn return too slow (${spawnReturnMs}ms) — fanout is blocking`);
+
+  // Wait for all to finish; they must have overlapped.
+  await Promise.all(outs.map((o, i) => waitJob(o, /ack (worker|reviewer)/, `parallel ${i}`)));
+  assert(maxAskConcurrency >= 2, `agents did not overlap; maxAskConcurrency=${maxAskConcurrency}`);
+
+  // --- 3: provider init collapsed across the first fanout ---
+  // ensureProvider has no completed-skip entry yet (first run this process), so
+  // the batch DOES init once — but the in-flight collapse must keep it to a
+  // SINGLE initProviders() pass across all 6 spawns, not one per spawn.
+  assert(initProvidersCalls === 1, `first fanout must share a single init; calls=${initProvidersCalls}`);
+
+  // Force getProvider() to report a miss across a parallel batch so the
+  // completed-skip cannot short-circuit; every spawn routes through the init
+  // path again, but the in-flight collapse must still produce exactly ONE more
+  // init for the batch (before+1).
+  forceProviderMiss = true;
+  const beforeMissBatch = initProvidersCalls;
+  const initBatch = await Promise.all(
+    Array.from({ length: 4 }, (_, i) => agent.execute({
+      type: 'spawn',
+      role: 'worker',
+      tag: `init${i}`,
+      cwd: root,
+      prompt: `init task ${i}`,
+    }, { invocationSource: 'model-tool', cwd: root })),
+  );
+  await Promise.all(initBatch.map((o, i) => waitJob(o, /ack worker/, `init ${i}`)));
+  assert(initProvidersCalls === beforeMissBatch + 1,
+    `forced-miss fanout must share a single init; before=${beforeMissBatch} after=${initProvidersCalls}`);
+  forceProviderMiss = false;
+
+  // --- 3b: provider CONFIG CHANGE must re-run initProviders() ---
+  // The completed-skip cache is keyed on provider + effective-config signature,
+  // not on "is the provider registered". The provider stays registered here, so
+  // a registered-only fast path would WRONGLY skip init after a config edit.
+  // Changing the config must flip the signature and force exactly one new init.
+  const callsBeforeChange = initProvidersCalls;
+  // Same config first: must be skipped (no new init).
+  await waitJob(await agent.execute({
+    type: 'spawn', role: 'worker', tag: 'cfgSame', cwd: root, prompt: 'cfg same',
+  }, { invocationSource: 'model-tool', cwd: root }), /ack worker/, 'cfg same');
+  assert(initProvidersCalls === callsBeforeChange,
+    `unchanged config must not re-init; before=${callsBeforeChange} after=${initProvidersCalls}`);
+  // Now mutate the provider config and spawn again → must re-init once.
+  providerConfig = { 'openai-oauth': { enabled: true, baseUrl: 'https://changed.example' } };
+  await waitJob(await agent.execute({
+    type: 'spawn', role: 'worker', tag: 'cfgChanged', cwd: root, prompt: 'cfg changed',
+  }, { invocationSource: 'model-tool', cwd: root }), /ack worker/, 'cfg changed');
+  assert(initProvidersCalls === callsBeforeChange + 1,
+    `config change must trigger exactly one re-init; before=${callsBeforeChange} after=${initProvidersCalls}`);
+
+  // --- 3c: A(slow) -> B(superseded) -> C(latest) ---
+  // Three rapid-fire config generations on the same provider:
+  //   A: baseUrl 'gen-a', init is SLOW (200ms)
+  //   B: baseUrl 'gen-b', requested while A is still running → SUPERSEDED by C
+  //   C: baseUrl 'gen-c', the LATEST config, init fast (20ms)
+  // Two invariants the guard must hold:
+  //   (i)  the registry ends on the LATEST config (C) — no stale init lands last
+  //   (ii) NO spawn (incl. the superseded B) runs prepareSpawn/askSession before
+  //        the LATEST init that was current at its request time has completed.
+  //        A superseded request must not resolve early against an unprepared
+  //        provider — it must transitively wait for C.
+  const raceRoot = mkdtempSync(join(tmpdir(), 'mixdog-agent-race-'));
+  const raceDataDir = join(raceRoot, '.mixdog-data');
+  mkdirSync(raceDataDir, { recursive: true });
+  let lastAppliedConfig = null;      // last config initProviders() actually applied
+  let raceInitCalls = 0;
+  let providerReadyGen = null;       // signature most recently made live
+  const askViolations = [];
+  const raceReg = {
+    getProvider() { return undefined; }, // always force the init path
+    async initProviders(config) {
+      raceInitCalls += 1;
+      const url = config?.['openai-oauth']?.baseUrl || 'base';
+      await sleep(url === 'gen-a' ? 200 : 20); // A slow, others fast
+      lastAppliedConfig = url;
+      providerReadyGen = url;
+    },
+  };
+  let raceConfig = { providers: { 'openai-oauth': { enabled: true, baseUrl: 'gen-a' } } };
+  // Each spawn records which config gen was the LATEST at its spawn time; the
+  // fake askSession asserts the provider is ready (init completed) before it
+  // runs. If a spawn proceeds before ANY init completed, providerReadyGen is
+  // null → violation.
+  const raceCfgMod = {
+    loadConfig() {
+      return {
+        providers: raceConfig.providers,
+        agents: { worker: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low' } },
+        presets: [{ id: 'fake-worker', name: 'Fake Worker', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'full', effort: 'low' }],
+      };
+    },
+    resolveRuntimeSpec(preset, ctx) {
+      return { lane: 'agent', scopeKey: `race:${ctx.agentId}`, provider: preset.provider, model: preset.model };
+    },
+  };
+  async function raceAsk(sessionId, prompt) {
+    // Provider MUST be ready (some init completed) before any spawn runs.
+    if (providerReadyGen === null) {
+      askViolations.push(`${prompt}: ran before any provider init completed`);
+    }
+    const session = getSession(sessionId);
+    if (session) { session.status = 'running'; session.lastStreamDeltaAt = Date.now(); }
+    try { await sleep(10); return { content: `ack worker (${providerReadyGen})` }; }
+    finally { if (session) { session.status = 'idle'; session.lastStreamDeltaAt = Date.now(); } }
+  }
+  const raceMgr = { ...mgr, askSession: raceAsk };
+  const raceAgent = createStandaloneAgent({ cfgMod: raceCfgMod, reg: raceReg, mgr: raceMgr, dataDir: raceDataDir, cwd: raceRoot });
+  // Fire A (slow), then B and C back-to-back while A is still running. B is
+  // superseded by C before A's chain link releases.
+  const aOut = await raceAgent.execute({
+    type: 'spawn', role: 'worker', tag: 'raceA', cwd: raceRoot, prompt: 'race A',
+    spawnPrepTimeoutMs: 0, // testing init serialization, not the prep cap
+  }, { invocationSource: 'model-tool', cwd: raceRoot });
+  // Let A's deferred job reach ensureProvider and START its slow (200ms) init,
+  // so B/C arrive while A's init is genuinely in flight — this is what makes the
+  // "slow A completes and would clobber the newer config" path real. With the
+  // per-provider serialization, the latest (C) still lands last.
+  await sleep(60);
+  raceConfig = { providers: { 'openai-oauth': { enabled: true, baseUrl: 'gen-b' } } };
+  const bOut = await raceAgent.execute({
+    type: 'spawn', role: 'worker', tag: 'raceB', cwd: raceRoot, prompt: 'race B',
+    spawnPrepTimeoutMs: 0,
+  }, { invocationSource: 'model-tool', cwd: raceRoot });
+  raceConfig = { providers: { 'openai-oauth': { enabled: true, baseUrl: 'gen-c' } } };
+  const cOut = await raceAgent.execute({
+    type: 'spawn', role: 'worker', tag: 'raceC', cwd: raceRoot, prompt: 'race C',
+    spawnPrepTimeoutMs: 0,
+  }, { invocationSource: 'model-tool', cwd: raceRoot });
+  await Promise.all([
+    waitJob(aOut, /ack worker/, 'race A'),
+    waitJob(bOut, /ack worker/, 'race B'),
+    waitJob(cOut, /ack worker/, 'race C'),
+  ]);
+  // Give any (incorrectly) un-serialized slow A init time to land last.
+  await sleep(250);
+  // (i) registry ends on the latest config C.
+  assert(lastAppliedConfig === 'gen-c',
+    `stale init overwrote newer config; lastApplied=${lastAppliedConfig}`);
+  // (ii) no spawn ran before the provider was ready (incl. superseded B).
+  assert(askViolations.length === 0,
+    `spawn ran before latest provider init completed: ${askViolations.join('; ')}`);
+  // The superseded B must have observed a READY provider that is the latest
+  // (gen-c), never gen-a/gen-b stale-then-proceed.
+  const bResult = await raceAgent.execute({ type: 'read', task_id: taskId(bOut) }, { invocationSource: 'model-tool', cwd: raceRoot });
+  assert(/ack worker \(gen-c\)/.test(bResult),
+    `superseded B must proceed only after latest (gen-c) init; got ${bResult}`);
+  // B and C must NOT have triggered their own separate inits landing last — the
+  // dedup must keep total inits small (A + the latest C = 2; B is dropped).
+  assert(raceInitCalls <= 2, `superseded gen must not add an extra init; raceInitCalls=${raceInitCalls}`);
+  raceAgent.closeAll('agent-parallel-smoke-race-end');
+  rmSync(raceRoot, { recursive: true, force: true });
+
+  // --- 4: spawn-prep cap fires even with firstResponseTimeoutMs:0 ---
+  // Dedicated agent whose provider init hangs forever, so prep can never
+  // resolve. The model watchdog is disabled (firstResponseTimeoutMs:0) but the
+  // independent prep cap must still abort the job so a single hung prep cannot
+  // wedge the whole fanout.
+  const hangRoot = mkdtempSync(join(tmpdir(), 'mixdog-agent-hang-'));
+  const hangDataDir = join(hangRoot, '.mixdog-data');
+  mkdirSync(hangDataDir, { recursive: true });
+  const hangReg = {
+    getProvider() { return undefined; },           // never registered → init runs
+    initProviders() { return new Promise(() => {}); }, // hangs forever
+  };
+  const hangAgent = createStandaloneAgent({ cfgMod, reg: hangReg, mgr, dataDir: hangDataDir, cwd: hangRoot });
+  const wedgeStart = Date.now();
+  const wedged = await hangAgent.execute({
+    type: 'spawn',
+    role: 'worker',
+    tag: 'wedge1',
+    cwd: hangRoot,
+    prompt: 'wedge prep',
+    firstResponseTimeoutMs: 0,   // model watchdog disabled
+    spawnPrepTimeoutMs: 150,     // but prep cap is short
+  }, { invocationSource: 'model-tool', cwd: hangRoot });
+  assert(/agent task:/.test(wedged), 'wedge spawn should still return a task id immediately');
+  // Spawn return itself must be immediate even though prep will hang.
+  assert(Date.now() - wedgeStart < 100, 'wedge spawn return must not block on hung prep');
+  const wedgeResult = await waitJob(wedged, /status: error|timed out/, 'wedge prep cap', 40);
+  assert(/timed out/.test(wedgeResult) || /status: error/.test(wedgeResult),
+    `prep cap did not abort hung spawn: ${wedgeResult}`);
+  try { hangAgent.closeAll('agent-parallel-smoke-hang-end'); } catch {}
+  rmSync(hangRoot, { recursive: true, force: true });
+
+  // --- 5: spawnPrepTimeoutMs:0 disables the prep cap even when an env default
+  // is set. The module captured ENV_PREP_CAP_MS (150ms) at load. A prep step
+  // that runs longer than that (300ms) would normally be aborted by the env
+  // cap, but the explicit per-call spawnPrepTimeoutMs:0 must win and let prep
+  // finish.
+  const slowRoot = mkdtempSync(join(tmpdir(), 'mixdog-agent-slowprep-'));
+  const slowDataDir = join(slowRoot, '.mixdog-data');
+  mkdirSync(slowDataDir, { recursive: true });
+  let slowInitDone = false;
+  const slowReg = {
+    getProvider() { return undefined; }, // force init path
+    async initProviders(config) {
+      await sleep(300); // longer than the 150ms env cap
+      slowInitDone = true;
+      return realInitProviders({ 'openai-oauth': { enabled: true }, ...config });
+    },
+  };
+  const slowAgent = createStandaloneAgent({ cfgMod, reg: slowReg, mgr, dataDir: slowDataDir, cwd: slowRoot });
+  const slowStart = Date.now();
+  const slowOut = await slowAgent.execute({
+    type: 'spawn',
+    role: 'worker',
+    tag: 'slowprep1',
+    cwd: slowRoot,
+    prompt: 'slow prep override',
+    spawnPrepTimeoutMs: 0, // explicit disable beats the env cap
+  }, { invocationSource: 'model-tool', cwd: slowRoot });
+  const slowResult = await waitJob(slowOut, /ack worker/, 'slow prep override', 40);
+  assert(/ack worker/.test(slowResult),
+    `spawnPrepTimeoutMs:0 must disable prep cap despite env default; got ${slowResult}`);
+  assert(slowInitDone, 'slow prep init should have completed, not been aborted by env cap');
+  assert(Date.now() - slowStart >= 280,
+    'slow prep should have run its full duration (cap was disabled), not been cut short');
+  try { slowAgent.closeAll('agent-parallel-smoke-slowprep-end'); } catch {}
+  rmSync(slowRoot, { recursive: true, force: true });
+
+  process.stdout.write(`agent parallel smoke passed (spawnReturn=${spawnReturnMs}ms, maxConcurrency=${maxAskConcurrency}, initCalls=${initProvidersCalls})\n`);
+}
+
+try {
+  await main();
+} finally {
+  try { agent.closeAll('agent-parallel-smoke-end'); } catch {}
+  rmSync(root, { recursive: true, force: true });
+}