mixdog 0.9.63 → 0.9.64

package/scripts/lifecycle-api-test.mjs

@@ -1,137 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-
-import { createConfigLifecycle } from '../src/session-runtime/config-lifecycle.mjs';
-import { createLifecycleApi } from '../src/session-runtime/lifecycle-api.mjs';
-import {
-  _clearWebSocketPoolForTest,
-  _seedWebSocketEntryForTest,
-  closeOpenaiWsPoolForSession,
-} from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
-
-function socket() {
-  return {
-    closed: [],
-    close(_code, reason) {
-      this.closed.push(reason);
-    },
-  };
-}
-
-function lifecycleFor(session, overrides = {}) {
-  let current = session;
-  return createLifecycleApi({
-    getSession: () => current,
-    setSession: (value) => { current = value; },
-    getRoute: () => ({}),
-    setRoute: () => {},
-    getConfig: () => ({}),
-    getMode: () => 'full',
-    getCurrentCwd: () => '/test',
-    setCloseRequested: () => {},
-    getMemoryModPromise: () => null,
-    setMemoryModPromise: () => {},
-    setSessionNeedsCwdRefresh: () => {},
-    hooks: { dispatch: () => {}, flushRules: () => {} },
-    hookCommonPayload: (payload) => payload,
-    mgr: {
-      closeSession: (id, reason) => {
-        closeOpenaiWsPoolForSession(id, `session-close:${reason}`);
-        return true;
-      },
-    },
-    statusRoutes: { clearGatewaySessionRoute: () => {} },
-    channels: { stop: () => null },
-    agentTool: { closeAll: () => {} },
-    mcpClient: { disconnectAll: () => null },
-    warmupTimers: {},
-    prewarmTimers: {},
-    flushAllConfigSavesAsync: async () => {},
-    withTeardownDeadline: (promise) => promise,
-    closePatchRuntimeIfLoaded: () => null,
-    invalidateContextStatusCache: () => {},
-    invalidatePreSessionToolSurface: () => {},
-    notificationListeners: { clear: () => {} },
-    remoteStateListeners: { clear: () => {} },
-    ...overrides,
-  });
-}
-
-test('lifecycle drains the OpenAI WS pool only for process exit', async () => {
-  _clearWebSocketPoolForTest();
-  globalThis.__mixdogOpenaiWsRuntimeLoaded = true;
-  const replacementSocket = socket();
-  const retainedSocket = socket();
-  _seedWebSocketEntryForTest({ poolKey: 'replacement', auth: {}, cacheKey: '', entry: { socket: replacementSocket } });
-  _seedWebSocketEntryForTest({ poolKey: 'retained', auth: {}, cacheKey: '', entry: { socket: retainedSocket } });
-
-  await lifecycleFor({ id: 'replacement', messages: [], liveTurnMessages: [] }).close('engine-replace');
-
-  assert.deepEqual(replacementSocket.closed, ['session-close:engine-replace']);
-  assert.deepEqual(retainedSocket.closed, []);
-
-  await lifecycleFor({ id: 'exit-session', messages: [], liveTurnMessages: [] }).close('cli-exit');
-
-  assert.deepEqual(retainedSocket.closed, ['cli-exit']);
-});
-
-test('lifecycle barrier drains a direct updateSectionAsync with no queued lifecycle save', async () => {
-  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-lifecycle-config-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  const previousBackupRoot = process.env.MIXDOG_USER_DATA_BACKUP_ROOT;
-  process.env.MIXDOG_DATA_DIR = dataDir;
-  process.env.MIXDOG_USER_DATA_BACKUP_ROOT = join(dataDir, 'backups');
-  const sharedCfgMod = await import(`../src/runtime/shared/config.mjs?lifecycle-tail=${Date.now()}`);
-  const configLifecycle = createConfigLifecycle({
-    getConfig: () => ({}),
-    setConfig: () => {},
-    getSearchRoute: () => null,
-    setSearchRoute: () => {},
-    getConfigHasSecrets: () => false,
-    setConfigHasSecrets: () => {},
-    getRoute: () => ({}),
-    cfgMod: {
-      saveConfigAsync: async () => {},
-      patchSkillsDisabledAsync: async () => {},
-      getPluginData: () => dataDir,
-    },
-    sharedCfgMod,
-    setBackendAsync: async () => {},
-    setConfiguredShell: () => {},
-    normalizeSystemShellConfig: () => ({ command: '' }),
-    normalizeSearchRouteConfig: () => null,
-    outputStyleStatus: () => ({}),
-    LAZY_SECRET_PROVIDERS: new Set(),
-    clean: (value) => String(value || ''),
-    resolve: (value) => value,
-    STANDALONE_DATA_DIR: dataDir,
-  });
-
-  const events = [];
-  let directSettled = false;
-  try {
-    const directWrite = sharedCfgMod.updateSectionAsync('cycle3', () => ({ value: 'direct' }))
-      .finally(() => { directSettled = true; events.push('direct:settled'); });
-    assert.equal(directSettled, false);
-
-    const lifecycle = lifecycleFor(
-      { id: 'tail-drain', messages: [], liveTurnMessages: [] },
-      {
-        flushAllConfigSavesAsync: configLifecycle.flushAllConfigSavesAsync,
-        closePatchRuntimeIfLoaded: async () => { events.push('teardown:continued'); },
-      },
-    );
-    await lifecycle.close('engine-replace');
-    await directWrite;
-    assert.deepEqual(events, ['direct:settled', 'teardown:continued']);
-  } finally {
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    if (previousBackupRoot == null) delete process.env.MIXDOG_USER_DATA_BACKUP_ROOT;
-    else process.env.MIXDOG_USER_DATA_BACKUP_ROOT = previousBackupRoot;
-    rmSync(dataDir, { recursive: true, force: true });
-  }
-});

package/scripts/live-share-test.mjs

@@ -1,148 +0,0 @@
-// Integration test for src/tui/engine/live-share.mjs: a real owner pipe
-// server and viewer client exchange full/delta/tail frames and submits over
-// the platform transport (named pipe / unix socket).
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createLiveShare } from '../src/tui/engine/live-share.mjs';
-
-const PIPE_ID = `livetest_${process.pid}_${Date.now()}`;
-const pipePath = process.platform === 'win32'
-  ? `\\\\.\\pipe\\mixdog-live-${PIPE_ID}`
-  : join(tmpdir(), `mixdog-live-${PIPE_ID}.sock`);
-
-function waitFor(check, label, timeoutMs = 4000) {
-  return new Promise((resolvePromise, rejectPromise) => {
-    const startedAt = Date.now();
-    const tick = () => {
-      let result = false;
-      try { result = check(); } catch { result = false; }
-      if (result) return resolvePromise(result);
-      if (Date.now() - startedAt > timeoutMs) {
-        return rejectPromise(new Error(`timeout waiting for ${label}`));
-      }
-      setTimeout(tick, 20);
-    };
-    tick();
-  });
-}
-
-function createViewerStore() {
-  const store = {
-    items: [{ id: 'disk-only', kind: 'user', text: 'persisted last user message' }],
-    streamingTail: null,
-    spinner: null,
-  };
-  return {
-    store,
-    apply: {
-      getState: () => store,
-      set: (patch) => Object.assign(store, patch),
-      replaceItems: (items) => { store.items = [...items]; },
-      patchItem: (id, patch) => {
-        const index = store.items.findIndex((item) => item?.id === id);
-        if (index < 0) return false;
-        store.items[index] = { ...store.items[index], ...patch };
-        return true;
-      },
-      appendItems: (items) => { store.items = [...store.items, ...items]; },
-      updateStreamingTail: (id, patch) => {
-        const current = store.streamingTail?.id === id ? store.streamingTail : { id, text: '' };
-        store.streamingTail = { ...current, ...patch, id };
-      },
-      clearStreamingTail: () => { store.streamingTail = null; },
-    },
-  };
-}
-
-test('live-share mirrors owner deltas and routes viewer submits', async () => {
-  const listeners = new Set();
-  let ownerState = {
-    items: [{ id: 'a1', kind: 'assistant', text: 'hello' }],
-    streamingTail: null,
-    spinner: null,
-  };
-  const receivedSubmits = [];
-  const owner = createLiveShare({
-    ownerSessionId: () => PIPE_ID,
-    viewerSessionId: () => '',
-    socketPathFor: () => pipePath,
-    getPublishedState: () => ownerState,
-    listeners,
-    onRemoteSubmit: (text) => receivedSubmits.push(text),
-    onOwnerClosed: () => {},
-    viewerApply: null,
-  });
-  const publish = (next) => {
-    ownerState = next;
-    for (const listener of listeners) listener();
-  };
-
-  const viewer = createViewerStore();
-  let ownerClosedCount = 0;
-  const viewerShare = createLiveShare({
-    ownerSessionId: () => '',
-    viewerSessionId: () => PIPE_ID,
-    socketPathFor: () => pipePath,
-    getPublishedState: () => ({ items: [], streamingTail: null, spinner: null }),
-    listeners: new Set(),
-    onRemoteSubmit: () => {},
-    onOwnerClosed: () => { ownerClosedCount += 1; },
-    viewerApply: viewer.apply,
-  });
-
-  try {
-    owner.ensure();
-    const initialSync = viewerShare.waitForViewerSync(PIPE_ID, 1_000);
-    await waitFor(() => {
-      viewerShare.ensure();
-      return viewerShare.viewerConnected();
-    }, 'viewer connect');
-    // Initial full frame mirrors the owner transcript.
-    assert.equal(await initialSync, true);
-    await waitFor(() => viewer.store.items.length === 1
-      && viewer.store.items[0].id === 'a1', 'initial full frame');
-    assert.equal(viewer.store.items.some((item) => item.id === 'disk-only'), false,
-      'the initial sync barrier must replace the incomplete persisted transcript');
-
-    // Appended item + streaming tail start.
-    publish({
-      ...ownerState,
-      items: [...ownerState.items, { id: 'u1', kind: 'user', text: 'hi from owner side' }],
-      streamingTail: { kind: 'assistant', id: 't1', text: 'stream', streaming: true },
-      spinner: { active: true, mode: 'responding' },
-    });
-    await waitFor(() => viewer.store.items.length === 2
-      && viewer.store.streamingTail?.text === 'stream'
-      && viewer.store.spinner?.active === true, 'append + tail frame');
-
-    // Append-only tail growth rides the suffix protocol.
-    publish({
-      ...ownerState,
-      streamingTail: { kind: 'assistant', id: 't1', text: 'streaming more', streaming: true },
-    });
-    await waitFor(() => viewer.store.streamingTail?.text === 'streaming more', 'tail suffix frame');
-
-    // Patched item (owner edited an existing row) arrives as a change.
-    publish({
-      ...ownerState,
-      items: [{ ...ownerState.items[0], text: 'hello edited' }, ownerState.items[1]],
-      streamingTail: null,
-    });
-    await waitFor(() => viewer.store.items[0].text === 'hello edited'
-      && viewer.store.streamingTail === null, 'patch + tail clear frame');
-
-    // Viewer submit reaches the owner queue.
-    assert.equal(viewerShare.sendSubmit('typed on viewer'), true);
-    await waitFor(() => receivedSubmits.length === 1, 'viewer submit');
-    assert.equal(receivedSubmits[0], 'typed on viewer');
-
-    // Owner shutdown notifies the viewer promotion path.
-    owner.dispose();
-    await waitFor(() => ownerClosedCount === 1, 'owner close notification');
-  } finally {
-    owner.dispose();
-    viewerShare.dispose();
-  }
-});

package/scripts/live-worker-smoke.mjs

@@ -1,333 +0,0 @@
-#!/usr/bin/env node
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { AGENT_TOOL, createStandaloneAgent } from '../src/standalone/agent-tool.mjs';
-import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
-import { executeBuiltinTool } from '../src/runtime/agent/orchestrator/tools/builtin.mjs';
-import { initProviders } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
-import {
-  closeSession,
-  enqueuePendingMessage,
-  getSession,
-  getSessionLastProgressAt,
-  getSessionRuntime,
-  listSessions,
-} from '../src/runtime/agent/orchestrator/session/manager.mjs';
-
-const root = mkdtempSync(join(tmpdir(), 'mixdog-live-worker-'));
-const dataDir = join(root, '.mixdog-data');
-let activeAsks = 0;
-let maxActiveAsks = 0;
-let releaseBusyGate = null;
-let busySafetyTimer = null;
-let agentRunner = null;
-let runnerClosed = false;
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function waitForBusyRelease() {
-  return new Promise((resolve) => {
-    const release = () => {
-      if (busySafetyTimer) clearTimeout(busySafetyTimer);
-      busySafetyTimer = null;
-      if (releaseBusyGate === release) releaseBusyGate = null;
-      resolve();
-    };
-    releaseBusyGate = release;
-    busySafetyTimer = setTimeout(release, 10_000);
-  });
-}
-
-function releaseBusyWorker() {
-  const release = releaseBusyGate;
-  releaseBusyGate = null;
-  if (busySafetyTimer) clearTimeout(busySafetyTimer);
-  busySafetyTimer = null;
-  release?.();
-}
-
-function closeAgentRunner() {
-  if (!agentRunner || runnerClosed) return;
-  runnerClosed = true;
-  agentRunner.closeAll('live-worker-smoke-end');
-}
-
-function taskId(text) {
-  return String(text).match(/agent task: (\S+)/)?.[1] || null;
-}
-
-async function main() {
-  const leadToolRules = readFileSync('src/rules/lead/lead-tool.md', 'utf8');
-  const workflowRules = readFileSync('src/workflows/default/WORKFLOW.md', 'utf8');
-  const soloRules = readFileSync('src/workflows/solo/WORKFLOW.md', 'utf8');
-  const compact = (text) => text.toLowerCase().replace(/\s+/g, ' ');
-  const hasAll = (text, ...terms) => terms.every((term) => text.includes(term));
-  const lead = compact(leadToolRules);
-  const workflow = compact(workflowRules);
-  const solo = compact(soloRules);
-  const reviewSkipViolation = (text) => compact(text)
-    .split(/[.!?]\s+|;|,\s+(?=(?:but|however|yet)\b)/)
-    .some((clause) => {
-      const hasReview = /\b(review|reviewer|verification)\b/.test(clause);
-      const hasSkip = /\b(skip|skipping|skipped|skippable|omit|omits|omitting|omitted)\b/.test(clause) ||
-        /\bwithout\s+(?:any\s+)?(?:a\s+)?(?:review|reviewer|verification)\b/.test(clause);
-      const weakRequirement = /\b(?:optional|unnecessary|not required|need not)\b/.test(clause);
-      const negated = /\b(?:never|(?:must|shall|may)\s+not|can(?:not|'t)|do\s+not|don't|not)\b[^;]{0,40}\b(?:skip|skipping|skipped|skippable|omit|omitting|omitted)\b/.test(clause) ||
-        /\b(?:skip|skipping|skipped|skippable|omit|omitting|omitted)\b[^;]{0,40}\b(?:not allowed|forbidden|prohibited)\b/.test(clause) ||
-        /\b(?:never|(?:must|shall|may)\s+not|can(?:not|'t)|do\s+not|don't|not)\b[^;]{0,40}\bwithout\s+(?:any\s+)?(?:a\s+)?(?:review|reviewer|verification)\b/.test(clause);
-      const negatedWeakRequirement = /\b(?:not|never)\s+(?:optional|unnecessary)\b/.test(clause);
-      const exception = /\b(?:unless|except(?:\s+when)?|only\s+if)\b/.test(clause);
-      return hasReview && ((hasSkip && (!negated || exception)) ||
-        (weakRequirement && (!negatedWeakRequirement || exception)));
-    });
-  for (const [phrase, expected] of [
-    ['Never skip Reviewer verification', false],
-    ['Reviewer verification must not be skipped', false],
-    ['Must not proceed without review', false],
-    ['Never skip risky review, but may skip simple review', true],
-    ['Never skip review unless low-risk', true],
-    ['Never skip review except when low-risk', true],
-    ['Never skip review only if low-risk', true],
-    ['May omit review', true],
-    ['Proceed without review', true],
-    ['Review is optional', true],
-    ['Review is unnecessary', true],
-    ['Review is not required', true],
-    ['Review is skippable for low-risk work', true],
-    ['Review is not optional', false],
-    ['Review is not unnecessary', false],
-  ]) assert(reviewSkipViolation(phrase) === expected, `review-skip detector case failed: ${phrase}`);
-  const skipsReview = reviewSkipViolation(workflow);
-  assert(hasAll(lead, 'write-role agents self-verify', 'cross-scope verification', 'benches', 'all git', 'current project/workspace'), 'lead tool rules must preserve verification, git, and workspace ownership');
-  assert(hasAll(workflow, 'before the user explicitly approves the latest plan', 'no edits, no state mutation, no delegation'), 'default workflow must require latest-plan approval before work');
-  assert(hasAll(workflow, 'on approval, fan out at maximum width', 'one agent per independent scope', 'all spawned in one turn', 'split the plan into as many scopes as possible', 'disjoint file/module sets are independent', 'merge only on a true output dependency', 'prefer parallel scopes over sequential slices in one agent'), 'default workflow must fan out independent scopes at maximum width');
-  assert(hasAll(workflow, 'simple, well-understood implementation goes to worker', 'complex or investigative implementation goes to heavy worker', 'lead itself edits only a local, one-turn configuration/git change', 'debugger only on a defect needing deep root-cause analysis or a bug surviving 2+ review/fix cycles'), 'default workflow must enforce role routing and Lead/Debugger limits');
-  assert(hasAll(workflow, 'every implementation gets its own reviewer, attached per scope', 'only the local lead-direct edits above are exempt', 'lead itself edits only a local, one-turn configuration/git change', 'keep the same reviewer through the fix loop', 'fix -> re-verify until clean', 'lead cross-verifies'), 'default workflow must require a Reviewer for every implementation except local Lead-direct one-turn config/git edits');
-  assert(hasAll(workflow, 'build, deploy, commit, and push happen only on an explicit user request', 'on direction change, pause and re-consult the user'), 'default workflow must require user authorization and re-consultation');
-  assert(!skipsReview, 'default workflow must not permit delegated-review skips');
-  assert(hasAll(solo, 'before the user explicitly approves the latest plan', 'read-only investigation and planning — no edits, no state mutation', 'a new or changed request resets planning; a scope change requires fresh approval'), 'Solo workflow must require latest-plan approval and reset it for request or scope changes');
-  assert(hasAll(solo, 'on approval, lead executes all work itself', 'never spawn, send, or delegate to agents', 'verify directly: check and fix until clean, or report the blocker'), 'Solo workflow must keep work with Lead, forbid delegation, and verify directly');
-  assert(hasAll(solo, 'build, deploy, commit, and push happen only on an explicit user request', 'on direction change, pause and re-consult the user'), 'Solo workflow must require user authorization and re-consultation');
-  assert(/always start background tasks/i.test(AGENT_TOOL.description || '') && /distinct tags?/i.test(AGENT_TOOL.description || '') && /completion notification/i.test(AGENT_TOOL.description || ''), 'agent tool description must expose async parallel tags');
-
-  mkdirSync(dataDir, { recursive: true });
-  await initProviders({ 'openai-oauth': { enabled: true } });
-  writeFileSync(join(root, 'feature.txt'), 'alpha\nbeta\n', 'utf8');
-  writeFileSync(join(root, 'notes.txt'), 'TODO investigate timeout\n', 'utf8');
-
-  const cfgMod = {
-    loadConfig() {
-      return {
-        providers: { 'openai-oauth': { enabled: true } },
-        agents: {
-          worker: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'medium', 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: 'medium', fast: true },
-          { id: 'fake-reviewer', name: 'Fake Reviewer', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'readonly', effort: 'low' },
-          { id: 'fake-debugger', name: 'Fake Debugger', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'readonly', effort: 'low' },
-        ],
-      };
-    },
-    resolveRuntimeSpec(preset, ctx) {
-      return { lane: 'agent', scopeKey: `smoke:${ctx.agentId}`, provider: preset.provider, model: preset.model };
-    },
-  };
-  const reg = { initProviders };
-
-  async function fakeAskSession(sessionId, prompt, _context, _onToolCall, cwdOverride) {
-    const session = getSession(sessionId);
-    if (session) {
-      session.status = 'running';
-      session.lastStreamDeltaAt = Date.now();
-    }
-    activeAsks += 1;
-    maxActiveAsks = Math.max(maxActiveAsks, activeAsks);
-    try {
-      if (/parallel slow/i.test(prompt)) await sleep(600);
-      if (/long busy/i.test(prompt)) await waitForBusyRelease();
-      if (/write implementation/i.test(prompt)) {
-        const out = await executePatchTool('apply_patch', {
-          base_path: cwdOverride,
-          patch: `*** Begin Patch
-*** Update File: feature.txt
-@@
- alpha
--beta
-+beta from worker
-*** End Patch
-`,
-        }, cwdOverride);
-        return { content: `worker wrote feature\n${String(out).split(/\r?\n/)[0]}` };
-      }
-      if (/run verification/i.test(prompt)) {
-        const out = await executeBuiltinTool('shell', {
-          command: 'Get-Content feature.txt',
-          cwd: cwdOverride,
-          shell: 'powershell',
-          timeout: 30_000,
-        }, cwdOverride);
-        return { content: `verification\n${out}` };
-      }
-      if (/review/i.test(prompt)) {
-        const body = readFileSync(join(cwdOverride, 'feature.txt'), 'utf8');
-        return { content: body.includes('worker') ? 'reviewer ok' : 'reviewer missing worker change' };
-      }
-      if (/debug/i.test(prompt)) {
-        return { content: `debugger ${readFileSync(join(cwdOverride, 'notes.txt'), 'utf8').trim()}` };
-      }
-      return { content: `ack ${session?.agent || 'worker'}` };
-    } finally {
-      activeAsks -= 1;
-      if (session) {
-        session.status = 'idle';
-        session.lastUsedAt = new Date().toISOString();
-        session.lastStreamDeltaAt = Date.now();
-      }
-    }
-  }
-
-  const mgr = {
-    getSession,
-    listSessions,
-    closeSession,
-    getSessionRuntime,
-    enqueuePendingMessage,
-    getSessionLastProgressAt,
-    askSession: fakeAskSession,
-  };
-  agentRunner = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
-
-  async function waitJob(out, pattern, label) {
-    const id = taskId(out);
-    assert(id, `missing task ID for ${label}: ${out}`);
-    let last = '';
-    for (let i = 0; i < 40; i += 1) {
-      last = await agentRunner.execute({ type: 'read', task_id: id }, { invocationSource: 'model-tool', cwd: root });
-      if (pattern.test(last)) return last;
-      if (/^Error[\s:[]/.test(last) || /status: error/.test(last)) break;
-      await sleep(100);
-    }
-    throw new Error(`${label} did not finish with ${pattern}: ${last}`);
-  }
-
-  async function waitAgentTag(tag, label) {
-    for (let i = 0; i < 20; i += 1) {
-      if (agentRunner.getStatus({ cwd: root }).workers
-        .some((worker) => worker?.tag === tag && worker.status === 'running')) return;
-      await sleep(25);
-    }
-    throw new Error(`${label} did not start agent tag ${tag}`);
-  }
-
-  const spawnOut = await agentRunner.execute({
-    type: 'spawn',
-    agent: 'worker',
-    tag: 'impl1',
-    cwd: root,
-    prompt: 'write implementation: update feature.txt with apply_patch',
-  }, { invocationSource: 'model-tool', cwd: root });
-  await waitJob(spawnOut, /worker wrote feature/, 'worker write');
-
-  const sendOut = await agentRunner.execute({
-    type: 'send',
-    tag: 'impl1',
-    message: 'run verification: inspect feature.txt using bash',
-  }, { invocationSource: 'model-tool', cwd: root });
-  assert(/agent task:/.test(sendOut), `completed worker send should be async task, got ${sendOut}`);
-  await waitJob(sendOut, /beta from worker/, 'worker verify');
-
-  const reviewOut = await agentRunner.execute({
-    type: 'spawn',
-    agent: 'reviewer',
-    tag: 'rev1',
-    cwd: root,
-    prompt: 'review feature.txt for the worker change',
-  }, { invocationSource: 'model-tool', cwd: root });
-  const debugOut = await agentRunner.execute({
-    type: 'spawn',
-    agent: 'debugger',
-    tag: 'dbg1',
-    cwd: root,
-    prompt: 'debug notes.txt timeout clue',
-  }, { invocationSource: 'model-tool', cwd: root });
-  await waitJob(reviewOut, /reviewer ok/, 'reviewer');
-  await waitJob(debugOut, /debugger TODO/, 'debugger');
-
-  const parallelSpawns = await Promise.all([
-    agentRunner.execute({
-      type: 'spawn',
-      agent: 'worker',
-      tag: 'parWorker',
-      cwd: root,
-      prompt: 'parallel slow worker task',
-    }, { invocationSource: 'model-tool', cwd: root }),
-    agentRunner.execute({
-      type: 'spawn',
-      agent: 'reviewer',
-      tag: 'parReviewer',
-      cwd: root,
-      prompt: 'parallel slow review task',
-    }, { invocationSource: 'model-tool', cwd: root }),
-    agentRunner.execute({
-      type: 'spawn',
-      agent: 'debugger',
-      tag: 'parDebugger',
-      cwd: root,
-      prompt: 'parallel slow debug task',
-    }, { invocationSource: 'model-tool', cwd: root }),
-  ]);
-  assert(parallelSpawns.every((out) => /agent task:/.test(out)), `parallel spawns must return tasks: ${parallelSpawns.join('\n---\n')}`);
-  await Promise.all([
-    waitJob(parallelSpawns[0], /ack worker/, 'parallel worker'),
-    waitJob(parallelSpawns[1], /reviewer ok/, 'parallel reviewer'),
-    waitJob(parallelSpawns[2], /debugger TODO/, 'parallel debugger'),
-  ]);
-  assert(maxActiveAsks >= 2, `agents did not overlap; maxActiveAsks=${maxActiveAsks}`);
-
-  const busyOut = await agentRunner.execute({
-    type: 'spawn',
-    agent: 'worker',
-    tag: 'busy1',
-    cwd: root,
-    prompt: 'long busy worker task',
-  }, { invocationSource: 'model-tool', cwd: root });
-  await waitAgentTag('busy1', 'busy worker');
-  const queued = await agentRunner.execute({
-    type: 'send',
-    tag: 'busy1',
-    message: 'follow-up while still busy',
-  }, { invocationSource: 'model-tool', cwd: root });
-  assert(/agent message queued/.test(queued), `busy send should queue, got ${queued}`);
-  releaseBusyWorker();
-  await waitJob(busyOut, /ack worker/, 'busy worker');
-
-  const missing = await agentRunner.execute({ type: 'read', task_id: 'task_missing_live_smoke' }, { invocationSource: 'model-tool', cwd: root });
-  assert(/^Error[\s:[]/.test(missing), 'missing agent task should be Error result');
-  assert(readFileSync(join(root, 'feature.txt'), 'utf8').includes('beta from worker'), 'final file missing worker edit');
-  closeAgentRunner();
-  process.stdout.write('live worker smoke passed\n');
-}
-
-try {
-  await main();
-} finally {
-  try {
-    releaseBusyWorker();
-  } finally {
-    try {
-      closeAgentRunner();
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  }
-}