mixdog 0.9.46 → 0.9.49

package/scripts/deferred-tool-loading-test.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  applyDeferredToolSurface,
+  rebuildDeferredToolSurfaceForProvider,
+  reconcileDeferredMcpToolCatalog,
+  renderToolSearch,
+} from '../src/session-runtime/tool-catalog.mjs';
+import { prepareDeferredToolCallThrough } from '../src/runtime/agent/orchestrator/session/loop/deferred-call-through.mjs';
+import { buildRequestBody } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
+import { _buildRequestBodyForCacheSmoke as buildAnthropicRequestBody } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
+
+const schema = { type: 'object', properties: {} };
+const catalog = [
+  { name: 'load_tool', description: 'Load deferred tools.', annotations: { readOnlyHint: true }, inputSchema: schema },
+  { name: 'read', description: 'Read.', annotations: { readOnlyHint: true }, inputSchema: schema },
+  { name: 'mcp__demo__ping', description: 'Ping.', annotations: { readOnlyHint: true }, inputSchema: schema },
+];
+
+test('OpenAI first/repeated load uses history schemas and keeps base tools/cache key stable', () => {
+  const session = { id: 'deferred-openai', provider: 'openai-oauth', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  const baseTools = JSON.stringify(session.tools);
+  const firstBody = buildRequestBody(
+    [{ role: 'user', content: 'load ping' }],
+    'gpt-5.4',
+    session.tools,
+    { sessionId: session.id, session },
+  );
+
+  const first = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  assert.deepEqual(first.loaded, ['mcp__demo__ping']);
+  assert.equal(session.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+  assert.equal(JSON.stringify(session.tools), baseTools);
+
+  const history = [
+    { role: 'user', content: 'load ping' },
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{
+        id: 'search-1',
+        name: 'load_tool',
+        arguments: { names: ['mcp__demo__ping'] },
+        nativeType: 'tool_search_call',
+      }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'search-1',
+      content: first.nativeToolSearch.summary,
+      nativeToolSearch: first.nativeToolSearch,
+    },
+  ];
+  const followup = buildRequestBody(history, 'gpt-5.4', session.tools, {
+    sessionId: session.id,
+    session,
+  });
+  assert.equal(JSON.stringify(followup.tools), JSON.stringify(firstBody.tools));
+  assert.equal(followup.prompt_cache_key, firstBody.prompt_cache_key);
+  assert.equal(followup.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+  assert.equal(
+    followup.input.find((item) => item.type === 'tool_search_output').tools[0].name,
+    'mcp__demo__ping',
+  );
+
+  const repeated = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  assert.deepEqual(repeated.loaded, []);
+  assert.deepEqual(repeated.alreadyActive, ['mcp__demo__ping']);
+  assert.deepEqual(repeated.nativeToolSearch.toolReferences, []);
+  assert.deepEqual(repeated.nativeToolSearch.openaiTools, []);
+  assert.equal(JSON.stringify(session.tools), baseTools);
+
+  const repeatedFollowup = buildRequestBody([
+    ...history,
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{
+        id: 'search-2',
+        name: 'load_tool',
+        arguments: { names: ['mcp__demo__ping'] },
+        nativeType: 'tool_search_call',
+      }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'search-2',
+      content: repeated.nativeToolSearch.summary,
+      nativeToolSearch: repeated.nativeToolSearch,
+    },
+  ], 'gpt-5.4', session.tools, { sessionId: session.id, session });
+  const repeatedOutput = repeatedFollowup.input.at(-1);
+  assert.equal(JSON.stringify(repeatedFollowup.tools), JSON.stringify(firstBody.tools));
+  assert.equal(repeatedFollowup.prompt_cache_key, firstBody.prompt_cache_key);
+  assert.equal(repeatedFollowup.input.at(-2).type, 'tool_search_call');
+  assert.equal(repeatedOutput.type, 'tool_search_output');
+  assert.deepEqual(repeatedOutput.tools, []);
+});
+
+test('Anthropic repeated native loads retain an empty provider envelope', () => {
+  const session = { provider: 'anthropic-oauth', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  const first = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  const before = JSON.stringify(session.tools);
+  const repeated = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+
+  assert.deepEqual(first.nativeToolSearch.toolReferences, ['mcp__demo__ping']);
+  assert.deepEqual(repeated.loaded, []);
+  assert.deepEqual(repeated.alreadyActive, ['mcp__demo__ping']);
+  assert.deepEqual(repeated.nativeToolSearch.toolReferences, []);
+  assert.deepEqual(repeated.nativeToolSearch.openaiTools, []);
+  assert.equal(JSON.stringify(session.tools), before);
+  assert.equal(session.deferredCallableTools.includes('mcp__demo__ping'), true);
+  assert.equal(session.deferredDiscoveredTools.includes('mcp__demo__ping'), true);
+
+  const body = buildAnthropicRequestBody([
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{ id: 'load-a1', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] } }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'load-a1',
+      content: first.nativeToolSearch.summary,
+      nativeToolSearch: first.nativeToolSearch,
+    },
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{ id: 'load-a2', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] } }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'load-a2',
+      content: repeated.nativeToolSearch.summary,
+      nativeToolSearch: repeated.nativeToolSearch,
+    },
+  ], 'claude-sonnet-4-6', session.tools, { session });
+  const results = body.messages.flatMap((message) => (
+    Array.isArray(message.content) ? message.content.filter((block) => block.type === 'tool_result') : []
+  ));
+  assert.deepEqual(results.map((block) => block.tool_use_id), ['load-a1', 'load-a2']);
+  assert.deepEqual(results[0].content, [{ type: 'tool_reference', tool_name: 'mcp__demo__ping' }]);
+  assert.equal(results[1].content, 'Already active: mcp__demo__ping');
+  assert.equal(body.tools.find((tool) => tool.name === 'mcp__demo__ping')?.defer_loading, true);
+});
+
+test('OpenAI API-key path accepts its own native tool_search_output history', () => {
+  const session = { id: 'deferred-openai-direct', provider: 'openai', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  const loaded = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  const body = buildRequestBody([
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{
+        id: 'search-direct',
+        name: 'load_tool',
+        arguments: { names: ['mcp__demo__ping'] },
+        nativeType: 'tool_search_call',
+      }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'search-direct',
+      content: loaded.nativeToolSearch.summary,
+      nativeToolSearch: loaded.nativeToolSearch,
+    },
+  ], 'gpt-5.4', session.tools, {
+    sessionId: session.id,
+    session,
+    promptCacheProvider: 'openai',
+  });
+  assert.equal(body.input[0].type, 'tool_search_call');
+  assert.equal(body.input[1].type, 'tool_search_output');
+});
+
+test('subsequent ordinary MCP calls use the callable registry, not session.tools promotion', () => {
+  const session = { provider: 'openai-oauth', toolSpec: 'full', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  const before = JSON.stringify(session.tools);
+  assert.equal(prepareDeferredToolCallThrough(session, 'mcp__demo__ping', {}), null);
+  assert.equal(JSON.stringify(session.tools), before);
+  assert.equal(session.deferredCallableTools.includes('mcp__demo__ping'), true);
+});
+
+test('xAI/Grok and unsupported providers use a fixed canonical non-native surface', () => {
+  for (const provider of ['xai', 'grok-oauth', 'opencode-go']) {
+    const session = { provider, tools: [], messages: [] };
+    applyDeferredToolSurface(session, 'full', catalog, { provider });
+    const before = JSON.stringify(session.tools);
+    const result = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+    assert.equal(session.deferredNativeTools, false);
+    assert.equal(result.nativeToolSearch, undefined);
+    assert.deepEqual(result.alreadyActive, ['mcp__demo__ping']);
+    assert.equal(JSON.stringify(session.tools), before);
+  }
+});
+
+test('Gemini manifest changes only at the next user-turn reconciliation', () => {
+  const session = { provider: 'gemini', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog.slice(0, 2), { provider: session.provider });
+  const duringTurn = JSON.stringify(session.tools);
+  const orderedBaseNames = session.tools.map((tool) => tool.name);
+  assert.equal(JSON.stringify(session.tools), duringTurn);
+
+  reconcileDeferredMcpToolCatalog(session, [catalog[2]]);
+  assert.deepEqual(session.tools.map((tool) => tool.name), [...orderedBaseNames, 'mcp__demo__ping']);
+  assert.equal(session.deferredProviderMode, 'manifest');
+});
+
+test('live provider switching rebuilds native and canonical surfaces in both directions', () => {
+  const session = { provider: 'openai-oauth', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  assert.equal(session.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+
+  rebuildDeferredToolSurfaceForProvider(session, 'xai');
+  session.provider = 'xai';
+  assert.equal(session.deferredProviderMode, 'canonical');
+  assert.deepEqual(session.tools.map((tool) => tool.name), session.deferredCallableTools);
+  assert.equal(session.tools.some((tool) => tool.name === 'mcp__demo__ping'), true);
+
+  rebuildDeferredToolSurfaceForProvider(session, 'openai');
+  session.provider = 'openai';
+  assert.equal(session.deferredProviderMode, 'native');
+  assert.equal(session.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+  assert.equal(session.deferredCallableTools.includes('mcp__demo__ping'), false);
+});

package/scripts/execution-completion-dedup-test.mjs

@@ -155,3 +155,51 @@ test('bodyless failure preview does not suppress its later body', () => {
   deliver({ content: 'Async agent task task_fail completed.\n\nResult:\n> retry', meta: { type: 'background_task_result', execution_id: 'task_fail', status: 'finished' } });
   assert.equal(cardPushes(), 2, 'same-body retry remains idempotent');
 });
+
+test('parallel agent status bursts coalesce to one status snapshot per frame', async () => {
+  let handler = null;
+  let setCalls = 0;
+  const statusArgs = [];
+  const feed = createAgentJobFeed({
+    runtime: { onNotification: (fn) => { handler = fn; return () => {}; } },
+    getState: () => ({ busy: false }),
+    set: () => { setCalls += 1; },
+    nextId: () => 'id',
+    getDisposed: () => false,
+    patchItem: () => {},
+    enqueue: () => true,
+    drain: () => Promise.resolve(),
+    pushUserOrSyntheticItem: () => {},
+    makeQueueEntry: (text, opts = {}) => ({ text, ...opts }),
+    getPending: () => [],
+    agentStatusState: (args) => {
+      statusArgs.push(args);
+      return {};
+    },
+    displayedExecutionNotificationKeys: new Set(),
+    pushNotice: () => {},
+  });
+  const unsubscribe = feed.subscribeRuntimeNotifications();
+
+  for (let i = 0; i < 24; i += 1) {
+    handler({
+      content: `agent task: burst_${i}\nstatus: running`,
+      meta: { type: 'agent_task_status', execution_id: `burst_${i}`, status: 'running' },
+    });
+  }
+  assert.equal(setCalls, 0, 'burst stays deferred until the coalesce boundary');
+  await new Promise((resolve) => setTimeout(resolve, 30));
+  assert.equal(setCalls, 1);
+  assert.equal(statusArgs.length, 1);
+
+  for (let i = 0; i < 24; i += 1) {
+    handler({
+      content: `agent task: burst_${i}\nstatus: completed`,
+      meta: { type: 'agent_task_result', execution_id: `burst_${i}`, status: 'completed' },
+    });
+  }
+  await new Promise((resolve) => setTimeout(resolve, 30));
+  assert.equal(setCalls, 2);
+  assert.deepEqual(statusArgs.at(-1), { force: true }, 'terminal burst forces one fresh snapshot');
+  unsubscribe();
+});

package/scripts/explore-prompt-policy-test.mjs

@@ -6,7 +6,14 @@ import { buildExplorerPrompt } from '../src/standalone/explore-tool.mjs';
 import { EXPLORE_TOOL } from '../src/standalone/explore-tool.mjs';
 import { BUILTIN_TOOLS } from '../src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs';
 import { CODE_GRAPH_TOOL_DEFS } from '../src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs';
-import { isEagerDispatchable } from '../src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs';
+import { TOOL_SEARCH_TOOL } from '../src/session-runtime/tool-defs.mjs';
+import { createEagerDispatcher } from '../src/runtime/agent/orchestrator/session/eager-dispatch.mjs';
+import { crossTurnSignature } from '../src/runtime/agent/orchestrator/session/loop/completion-guards.mjs';
+import {
+  isEagerDispatchable,
+  isToolCallDedupEligible,
+} from '../src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs';
+import { assertCodeGraphDescriptionContract } from './code-graph-description-contract.mjs';
 
 test('explore per-query prompt contains only escaped query XML', () => {
   const prompt = buildExplorerPrompt('display model usage show usage model_usage provider_usage session cache usage state');
@@ -89,9 +96,19 @@ test('explorer locator policy retains its compact behavioral contract', () => {
 });
 
 test('canonical schemas advertise safe batching without changing tool shapes', () => {
-  const graph = readFileSync(new URL('../src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs', import.meta.url), 'utf8');
+  const graph = CODE_GRAPH_TOOL_DEFS[0];
   const patch = readFileSync(new URL('../src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs', import.meta.url), 'utf8');
-  assert.match(graph, /Batch symbols\[\]\/files\[\] by mode/i);
+  const mode = graph?.inputSchema?.properties?.mode?.description || '';
+  const description = graph?.description || '';
+  const symbols = graph?.inputSchema?.properties?.symbols?.description || '';
+  assert.doesNotThrow(() => assertCodeGraphDescriptionContract({
+    description,
+    modeDescription: mode,
+    symbolsDescription: symbols,
+  }));
+  assert.deepEqual(graph?.inputSchema?.required, ['mode']);
+  assert.equal(graph?.inputSchema?.properties?.file, undefined);
+  assert.equal(graph?.inputSchema?.properties?.symbol, undefined);
   assert.match(patch, /one patch/i);
   assert.match(patch, /one file block per target/i);
 });
@@ -121,6 +138,74 @@ test('code graph and eager-dispatch boundaries preserve runtime shape', () => {
   assert.equal(isEagerDispatchable('shell', tools), false);
   assert.equal(isEagerDispatchable('mcp_read', tools), true);
   assert.equal(isEagerDispatchable('mcp_write', tools), false);
+  assert.equal(isToolCallDedupEligible('read', tools), true);
+  assert.equal(isToolCallDedupEligible('mcp_read', tools), true);
+});
+
+test('same-batch load_tool and legacy tool_search repeats all execute eagerly', async () => {
+  const tools = [...BUILTIN_TOOLS, TOOL_SEARCH_TOOL];
+  assert.equal(isEagerDispatchable('load_tool', tools), true);
+  assert.equal(isEagerDispatchable('tool_search', tools), true);
+  assert.equal(isToolCallDedupEligible('load_tool', tools), false);
+  assert.equal(isToolCallDedupEligible('tool_search', tools), false);
+  assert.equal(isToolCallDedupEligible('read', tools), true);
+
+  const args = { names: ['shell'] };
+  const calls = [
+    { id: 'load-1', name: 'load_tool', arguments: args },
+    { id: 'load-2', name: 'load_tool', arguments: args },
+    { id: 'legacy-1', name: 'tool_search', arguments: args },
+    { id: 'legacy-2', name: 'tool_search', arguments: args },
+  ];
+  const executed = [];
+  const crossTurnCalls = new Map([
+    [crossTurnSignature('load_tool', args), { count: 1, firstIteration: 1 }],
+    [crossTurnSignature('tool_search', args), { count: 1, firstIteration: 1 }],
+  ]);
+  const dispatcher = createEagerDispatcher({
+    tools,
+    cwd: process.cwd(),
+    sessionId: null,
+    sessionRef: {},
+    signal: null,
+    opts: {},
+    crossTurnCalls,
+    getIterations: () => 2,
+    getNextIteration: () => 2,
+    repeatFailLimit: 3,
+    executeToolFn: async (name) => {
+      executed.push(name);
+      return '{}';
+    },
+  });
+  dispatcher.startEagerRun(calls, 0, new Set());
+  assert.equal(dispatcher.pending.size, 4);
+  await Promise.all([...dispatcher.pending.values()].map((entry) => entry.promise));
+  assert.deepEqual(executed, ['load_tool', 'load_tool', 'tool_search', 'tool_search']);
+
+  const normalExecuted = [];
+  const normalDispatcher = createEagerDispatcher({
+    tools,
+    cwd: process.cwd(),
+    sessionId: null,
+    sessionRef: {},
+    signal: null,
+    opts: {},
+    crossTurnCalls: new Map(),
+    getIterations: () => 1,
+    getNextIteration: () => 1,
+    repeatFailLimit: 3,
+    executeToolFn: async (name) => {
+      normalExecuted.push(name);
+      return 'ok';
+    },
+  });
+  normalDispatcher.startEagerRun([
+    { id: 'read-1', name: 'read', arguments: { path: 'same.txt' } },
+    { id: 'read-2', name: 'read', arguments: { path: 'same.txt' } },
+  ], 0, new Set());
+  await Promise.all([...normalDispatcher.pending.values()].map((entry) => entry.promise));
+  assert.deepEqual(normalExecuted, ['read']);
 });
 
 test('code graph descriptions partition file and symbol targets', () => {

package/scripts/live-worker-smoke.mjs

@@ -19,6 +19,10 @@ 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);
@@ -28,6 +32,33 @@ 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;
 }
@@ -45,13 +76,16 @@ async function main() {
     .split(/[.!?]\s+|;|,\s+(?=(?:but|however|yet)\b)/)
     .some((clause) => {
       const hasReview = /\b(review|reviewer|verification)\b/.test(clause);
-      const hasSkip = /\b(skip|skipping|skipped|omit|omits|omitting|omitted)\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 negated = /\b(?:never|(?:must|shall|may)\s+not|can(?:not|'t)|do\s+not|don't|not)\b[^;]{0,40}\b(?:skip|skipping|skipped|omit|omitting|omitted)\b/.test(clause) ||
-        /\b(?:skip|skipping|skipped|omit|omitting|omitted)\b[^;]{0,40}\b(?:not allowed|forbidden|prohibited)\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);
+      return hasReview && ((hasSkip && (!negated || exception)) ||
+        (weakRequirement && (!negatedWeakRequirement || exception)));
     });
   for (const [phrase, expected] of [
     ['Never skip Reviewer verification', false],
@@ -63,16 +97,24 @@ async function main() {
     ['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, 'after approval', 'delegate', 'by default'), 'default workflow must delegate after approval');
-  assert(hasAll(workflow, 'coordinates', 'git', '1-edit', '1-check'), 'default workflow must limit Lead direct work');
-  assert(hasAll(workflow, 'implementation/research/debugging', 'matching agent'), 'default workflow must route other work to matching agents');
-  assert(hasAll(workflow, 'parallel', 'independent', 'every delegated implementation'), 'workflow rules must keep independent work parallel');
-  assert(hasAll(workflow, 'every delegated implementation', 'reviewer', 'lead integration', 'fix', 're-verify'), 'default workflow must require review and the fix loop');
+  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'), '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, 'never spawn', 'send', 'delegate', 'ask agents'), 'Solo workflow must forbid delegation');
+  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 });
@@ -112,7 +154,7 @@ async function main() {
     maxActiveAsks = Math.max(maxActiveAsks, activeAsks);
     try {
       if (/parallel slow/i.test(prompt)) await sleep(600);
-      if (/long busy/i.test(prompt)) await sleep(350);
+      if (/long busy/i.test(prompt)) await waitForBusyRelease();
       if (/write implementation/i.test(prompt)) {
         const out = await executePatchTool('apply_patch', {
           base_path: cwdOverride,
@@ -163,7 +205,7 @@ async function main() {
     getSessionLastProgressAt,
     askSession: fakeAskSession,
   };
-  const agentRunner = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
+  agentRunner = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
 
   async function waitJob(out, pattern, label) {
     const id = taskId(out);
@@ -180,10 +222,11 @@ async function main() {
 
   async function waitAgentTag(tag, label) {
     for (let i = 0; i < 20; i += 1) {
-      if (listSessions().some((session) => session?.agentTag === tag && !session.closed)) return;
+      if (agentRunner.getStatus({ cwd: root }).workers
+        .some((worker) => worker?.tag === tag && worker.status === 'running')) return;
       await sleep(25);
     }
-    throw new Error(`${label} did not register agent tag ${tag}`);
+    throw new Error(`${label} did not start agent tag ${tag}`);
   }
 
   const spawnOut = await agentRunner.execute({
@@ -265,17 +308,26 @@ async function main() {
     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');
-  agentRunner.closeAll('live-worker-smoke-end');
+  closeAgentRunner();
   process.stdout.write('live worker smoke passed\n');
 }
 
 try {
   await main();
 } finally {
-  rmSync(root, { recursive: true, force: true });
+  try {
+    releaseBusyWorker();
+  } finally {
+    try {
+      closeAgentRunner();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }
 }