mixdog 0.9.41 → 0.9.44

package/scripts/internal-comms-smoke.mjs

@@ -57,13 +57,12 @@ function frontmatter(text, label) {
 const workflow = readSrc('workflows', 'default', 'WORKFLOW.md');
 const leadBrief = readSrc('rules', 'lead', 'lead-brief.md');
 const solo = readSrc('workflows', 'solo', 'WORKFLOW.md');
-const bench = readSrc('workflows', 'bench', 'WORKFLOW.md');
 const general = readSrc('rules', 'lead', '01-general.md');
 const leadTool = readSrc('rules', 'lead', 'lead-tool.md');
 const core = readSrc('rules', 'agent', '00-core.md');
 const common = readSrc('rules', 'agent', '00-common.md');
 const skip = readSrc('rules', 'agent', '20-skip-protocol.md');
-const OPTIONAL_BRIEF_FIELDS = ['Anchors:', 'Allow/Forbid:', 'Deliver:', 'Verify:'];
+const OPTIONAL_BRIEF_FIELDS = ['Anchors:', 'Allow/Forbid:', 'Deliver:'];
 const TOKEN_PRINCIPLE = /minimum (?:characters|chars), maximum (?:information|info)/i;
 function requireAll(text, label, patterns) {
   for (const pattern of patterns) assert(pattern.test(normalize(text).toLowerCase()), `${label}: missing ${pattern}`);
@@ -72,16 +71,21 @@ assert(TOKEN_PRINCIPLE.test(normalize(leadBrief)), 'lead-brief.md: brief must st
 assert(leadBrief.includes('Task:'), 'lead-brief.md: brief must require labeled field Task:');
 assert(!leadBrief.includes('Goal:'), 'lead-brief.md: Goal: must be replaced by Task:');
 for (const field of OPTIONAL_BRIEF_FIELDS) assert(leadBrief.includes(field), `lead-brief.md: brief missing optional labeled field ${field}`);
+assert(!leadBrief.includes('Verify:'), 'lead-brief.md: must not prescribe Verify:');
+assert(
+  !/copy a prior role(?:'s)? brief|worker\s*(?:->|→)\s*debugger\s*(?:->|→)\s*reviewer|\blead\s*\/\s*worker\b/i.test(leadBrief),
+  'lead-brief.md: must not restore cross-role Task copying or lineage',
+);
 requireAll(leadBrief, 'Lead brief task', [
   /`task:` is mandatory and lossless/, /intent/, /required outcomes/, /negative outcomes/,
   /completion\/stop boundary/, /all other fields are optional task-specific deltas/,
   /preserve user-supplied exact targets and exact replacements\/outputs in `task:`/,
   /never infer exactness from a task name, file count, or perceived difficulty/,
-  /exact same `task:` across worker -> debugger -> reviewer/,
-  /never summarize, rewrite, or replace it/,
+  /each role independently constructs a role-appropriate, lossless `task:` from/,
+  /the original request and official spec\/test acceptance criteria/,
 ]);
 assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(normalize(leadBrief)), 'lead-brief.md: brief must ban restating known rules/background as cost');
-assert(/spec\/test beats its summary/i.test(normalize(leadBrief)), 'lead-brief.md: spec/test must beat summary');
+assert(/original request and official spec\/test acceptance criteria/i.test(normalize(leadBrief)), 'lead-brief.md: original request and official acceptance criteria must beat summary');
 requireAll(leadBrief, 'Lead brief lifecycle', [
   /full brief only for fresh spawn\/`respawned: true`/, /live follow-ups are delta/,
   /dead-tag send is cold: re-supply anchors/, /never `send` mid-run/,
@@ -110,6 +114,15 @@ const roles = {
   'reviewer/AGENT.md': readSrc('agents', 'reviewer', 'AGENT.md'),
   'debugger/AGENT.md': readSrc('agents', 'debugger', 'AGENT.md'),
 };
+const reviewerRole = roles['reviewer/AGENT.md'];
+assert(
+  !/construct the review\s*`task:` independently/i.test(reviewerRole),
+  'reviewer/AGENT.md: must not restore Reviewer-specific Task construction',
+);
+assert(
+  !/treat prior reports as unverified claims rather than evidence/i.test(reviewerRole),
+  'reviewer/AGENT.md: must not restore prior-report framing',
+);
 
 // Semantic contracts deliberately avoid prose snapshots.
 function snapshot(actual, expected, label) {
@@ -121,21 +134,6 @@ requireAll(workflow, 'Default approval', [
   /initial\/additional\/changed requests reset planning/, /scope change needs a revised plan and fresh approval/,
   /no edits, state mutation, or delegation/,
 ]);
-function routingReviewBlocks(text, label) {
-  const source = String(text).replace(/\r\n/g, '\n');
-  return {
-    routing: block(source, 'Lead orchestrates and verifies.', '1. Plan:', `${label} routing policy`),
-    review: block(source, '3. Review:', '\n4.', `${label} review policy`),
-  };
-}
-const defaultPolicy = routingReviewBlocks(workflow, 'Default');
-const benchPolicy = routingReviewBlocks(bench, 'Bench');
-for (const section of ['routing', 'review']) {
-  assert(
-    defaultPolicy[section] === benchPolicy[section],
-    `Default/Bench ${section} policy must be identical after normalization`,
-  );
-}
 const ROUTING_REVIEW_POLICY = [
   /lead-direct work is allowed only for pure read\/analysis, git\/configuration/,
   /user explicitly supplies both the exact target and exact replacement\/output/,
@@ -154,13 +152,11 @@ const ROUTING_REVIEW_POLICY = [
   /loop fix -> re-verify \(same reviewer \+ lead re-check\) until clean/,
   /exempt mutations still require shell self-verification/,
 ];
-for (const [label, text] of [['Default', workflow], ['Bench', bench]]) {
-  requireAll(text, `${label} routing/review parity`, ROUTING_REVIEW_POLICY);
-  assert(
-    !/(high clarity|low structural complexity|immediate 1-step|genuinely simple)/i.test(text),
-    `${label}: heuristic routing/review language must not return`,
-  );
-}
+requireAll(workflow, 'Default routing/review policy', ROUTING_REVIEW_POLICY);
+assert(
+  !/(high clarity|low structural complexity|immediate 1-step|genuinely simple)/i.test(workflow),
+  'Default: heuristic routing/review language must not return',
+);
 requireAll(workflow, 'Default lifecycle', [
   /draft before any implementation/, /all ready scopes in one turn, with no count cap/,
   /real dependency, overlapping write, or inseparable coupling/,
@@ -181,19 +177,15 @@ requireAll(solo, 'Solo lifecycle', [
   /interim updates are in-progress, never conclusions/,
   /issue-free feedback/,
 ]);
-requireAll(bench, 'Bench lifecycle', [
-  /never ask questions, propose plans for approval, or end the turn waiting/,
-  /verified complete or provably blocked/, /all ready scopes in one turn, with no count cap/,
-  /after async spawn, end the turn/, /original live session/,
-  /hard blocked/, /outcome and evidence/,
-]);
 requireAll(leadTool, 'Lead tools', [
   /write-role agents self-verify/, /cross-scope verification.*benches.*all git/,
-  /workflow permits delegation/, /no-delegation workflow.*controls/,
 ]);
 requireAll(general, 'General safety', [
   /identify as mixdog\/current coding agent/, /destructive\/hard-to-reverse action needs explicit confirmation/,
-  /never push, build, deploy without explicit user request/, /implementation approval is not deploy approval/,
+]);
+requireAll(workflow, 'Default ship safety', [
+  /build\/deploy\/commit\/push require an explicit user request after issue-free feedback/,
+  /implementation approval alone is insufficient/,
 ]);
 requireAll(skip, 'Silent skip', [
   /webhook-handler/, /scheduler-task/, /label-only, duplicate\/dedup, no action needed\/report/,
@@ -230,11 +222,18 @@ Self-verify each checkpoint and the final slice with shell (targeted test/build)
   'reviewer/AGENT.md': `# Reviewer
 Independent regression/risk review agent.
 
-Review the approved intent, diff, and tests with independent judgment. Prioritize
-actionable correctness, regression, security, and verification risks; inspect
-affected boundaries. Do not reimplement the change or report non-risky nits.
+Review the diff and tests with independent judgment. Prioritize actionable
+correctness, regression, security, and verification risks; inspect affected
+boundaries. Do not reimplement the change or report non-risky nits. Independently
+evaluate the final deliverable with a critical lens, actively seeking errors,
+unsupported assumptions, and counterexamples before confirming.
+
 Report findings first, severity-ordered, with one line per \`file:line\`. If clean,
-say so in one line and include only material residual risk.`,
+say so in one line and include only material residual risk.
+
+When the work comes with stated criteria or reference material for judging
+it, verify against those as given — substituting your own interpretation or
+a self-built check is a verification risk to report.`,
   'debugger/AGENT.md': `# Debugger
 Root-cause analysis agent.
 

package/scripts/internal-tools-normalization-test.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    executeInternalTool,
+    setInternalToolsProvider,
+} from '../src/runtime/agent/orchestrator/internal-tools.mjs';
+import { classifyResultKind } from '../src/runtime/agent/orchestrator/session/result-classification.mjs';
+
+async function normalizeToolResult(result) {
+    setInternalToolsProvider({
+        tools: [{ name: 'normalization_test' }],
+        executor: async () => result,
+    });
+    return executeInternalTool('normalization_test', {});
+}
+
+test('already-prefixed handler errors keep one canonical Error: prefix', async () => {
+    const result = await normalizeToolResult({
+        content: [{ type: 'text', text: 'Error: web search failed' }],
+        isError: true,
+    });
+    assert.equal(result, 'Error: web search failed');
+    assert.equal(classifyResultKind(result), 'error');
+});
+
+test('ordinary handler error text receives the canonical Error: prefix', async () => {
+    const result = await normalizeToolResult({
+        content: [{ type: 'text', text: 'core add: project_id required' }],
+        isError: true,
+    });
+    assert.equal(result, 'Error: core add: project_id required');
+    assert.equal(classifyResultKind(result), 'error');
+});
+
+test('successful empty output stays normal', async () => {
+    const result = await normalizeToolResult({
+        content: [{ type: 'text', text: '' }],
+        isError: false,
+    });
+    assert.equal(result, '');
+    assert.equal(classifyResultKind(result), 'normal');
+});
+
+test('isError:false output stays normal', async () => {
+    const result = await normalizeToolResult({
+        content: [{ type: 'text', text: 'search complete' }],
+        isError: false,
+    });
+    assert.equal(result, 'search complete');
+    assert.equal(classifyResultKind(result), 'normal');
+});

package/scripts/maintenance-default-routes-test.mjs

@@ -0,0 +1,164 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { DEFAULT_MAINTENANCE } from '../src/runtime/agent/orchestrator/config.mjs';
+import { resolveMaintenanceRoute } from '../src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs';
+import { resolveAgentSpawnPreset } from '../src/standalone/agent-tool.mjs';
+import { exploreResultCacheKey, resolveExploreRoute } from '../src/standalone/explore-tool.mjs';
+
+const main = { id: 'main', name: 'MAIN', type: 'agent', provider: 'main-provider', model: 'main-model', tools: 'full' };
+const configWithMain = (overrides = {}) => ({
+  default: 'main',
+  presets: [main],
+  maintenance: { ...DEFAULT_MAINTENANCE },
+  ...overrides,
+});
+const normalizedRoute = (route, provider = route.provider || 'anthropic-oauth') => ({
+  provider,
+  model: route.model,
+  effort: undefined,
+  fast: false,
+});
+
+test('empty Explore and Maintainer routes inherit Main in hidden and public dispatch', () => {
+  assert.equal(DEFAULT_MAINTENANCE.explore, undefined);
+  assert.equal(DEFAULT_MAINTENANCE.memory, undefined);
+  assert.deepEqual(DEFAULT_MAINTENANCE.scheduler, DEFAULT_MAINTENANCE.webhook);
+  assert.equal(DEFAULT_MAINTENANCE.scheduler.provider, 'anthropic-oauth');
+  assert.match(DEFAULT_MAINTENANCE.scheduler.model, /haiku/i);
+
+  const config = configWithMain();
+  assert.equal(resolveMaintenanceRoute({ agent: 'explorer', config }), 'main');
+  assert.equal(resolveMaintenanceRoute({ agent: 'cycle1-agent', config }), 'main');
+  assert.equal(resolveMaintenanceRoute({ agent: 'scheduler-task', config }), DEFAULT_MAINTENANCE.scheduler);
+  assert.equal(resolveAgentSpawnPreset(config, { agent: 'explore' }).preset, main);
+  assert.equal(resolveAgentSpawnPreset(config, { agent: 'maintainer' }).preset, main);
+});
+
+test('public agent, workflow, and maintenance routes override Main inheritance', () => {
+  const exploreAgent = { provider: 'agent-provider', model: 'agent-model' };
+  const maintainerWorkflow = { provider: 'workflow-provider', model: 'workflow-model' };
+  const exploreMaintenance = { provider: 'maintenance-provider', model: 'maintenance-model' };
+  assert.deepEqual(
+    resolveAgentSpawnPreset(configWithMain({ agents: { explore: exploreAgent } }), { agent: 'explore' }).preset,
+    { id: 'agent-explore', name: 'AGENT EXPLORE', type: 'agent', ...exploreAgent, effort: undefined, fast: false, tools: 'full' },
+  );
+  assert.deepEqual(
+    resolveAgentSpawnPreset(configWithMain({
+      workflowRoutes: { memory: maintainerWorkflow },
+      maintenance: { ...DEFAULT_MAINTENANCE, memory: { provider: 'ignored-provider', model: 'ignored-model' } },
+    }), { agent: 'maintainer' }).preset,
+    { id: 'agent-maintainer', name: 'AGENT MAINTAINER', type: 'agent', ...maintainerWorkflow, effort: undefined, fast: false, tools: 'full' },
+  );
+  const config = configWithMain({
+    maintenance: {
+      ...DEFAULT_MAINTENANCE,
+      explore: exploreMaintenance,
+    },
+  });
+  assert.deepEqual(resolveMaintenanceRoute({ agent: 'explorer', config }), normalizedRoute(exploreMaintenance));
+  assert.deepEqual(
+    resolveAgentSpawnPreset(config, { agent: 'explore' }).preset,
+    { id: 'agent-explore', name: 'AGENT EXPLORE', type: 'agent', ...exploreMaintenance, effort: undefined, fast: false, tools: 'full' },
+  );
+});
+
+test('hidden Explore and Maintainer routes use public precedence, including the legacy maintainer alias', () => {
+  const agentRoute = { provider: 'agent-provider', model: 'agent-model' };
+  const workflowRoute = { provider: 'workflow-provider', model: 'workflow-model' };
+  const maintenanceRoute = { provider: 'maintenance-provider', model: 'maintenance-model' };
+  assert.deepEqual(resolveMaintenanceRoute({
+    agent: 'explorer',
+    config: configWithMain({
+      agents: { explore: agentRoute },
+      workflowRoutes: { explorer: workflowRoute },
+      maintenance: { ...DEFAULT_MAINTENANCE, explore: maintenanceRoute },
+    }),
+  }), normalizedRoute(agentRoute));
+  assert.deepEqual(resolveMaintenanceRoute({
+    agent: 'cycle1-agent',
+    config: configWithMain({
+      workflowRoutes: { memory: workflowRoute },
+      maintenance: { ...DEFAULT_MAINTENANCE, memory: maintenanceRoute },
+    }),
+  }), normalizedRoute(workflowRoute));
+  assert.deepEqual(resolveMaintenanceRoute({
+    agent: 'cycle2-agent',
+    config: configWithMain({
+      maintenance: { ...DEFAULT_MAINTENANCE, memory: maintenanceRoute },
+    }),
+  }), normalizedRoute(maintenanceRoute));
+  assert.deepEqual(resolveMaintenanceRoute({
+    agent: 'cycle3-agent',
+    config: configWithMain({ agents: { maintenance: agentRoute } }),
+  }), normalizedRoute(agentRoute));
+});
+
+test('Explore cache identity follows the effective route when Main changes', () => {
+  const first = configWithMain();
+  const secondMain = { ...main, model: 'replacement-main-model' };
+  const second = configWithMain({ presets: [secondMain] });
+  const query = 'locate the route';
+  const cwd = '/tmp/project';
+  assert.deepEqual(resolveExploreRoute(first), main);
+  assert.deepEqual(resolveExploreRoute(second), secondMain);
+  assert.notEqual(
+    exploreResultCacheKey({ cwd, route: resolveExploreRoute(first), query }),
+    exploreResultCacheKey({ cwd, route: resolveExploreRoute(second), query }),
+  );
+});
+
+test('hidden precedence normalizes model-only routes with the public provider fallback', () => {
+  const modelOnly = { model: 'model-only' };
+  assert.deepEqual(
+    resolveMaintenanceRoute({ agent: 'explorer', config: configWithMain({ defaultProvider: 'openai', agents: { explore: modelOnly } }) }),
+    normalizedRoute(modelOnly, 'openai'),
+  );
+  assert.deepEqual(
+    resolveMaintenanceRoute({ agent: 'cycle1-agent', config: configWithMain({ defaultProvider: 'gemini', agents: { maintenance: modelOnly } }) }),
+    normalizedRoute(modelOnly, 'gemini'),
+  );
+  assert.deepEqual(
+    resolveMaintenanceRoute({ agent: 'explorer', config: configWithMain({ defaultProvider: 'xai', workflowRoutes: { explorer: modelOnly } }) }),
+    normalizedRoute(modelOnly, 'xai'),
+  );
+  assert.deepEqual(
+    resolveMaintenanceRoute({ agent: 'cycle2-agent', config: configWithMain({ maintenance: { ...DEFAULT_MAINTENANCE, memory: modelOnly } }) }),
+    normalizedRoute(modelOnly),
+  );
+});
+
+test('loadConfig preserves persisted model-only Explore and Maintainer routes with the configured provider', () => {
+  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-maintenance-config-'));
+  writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({
+    agent: {
+      defaultProvider: 'openai',
+      maintenance: {
+        explore: { model: 'gpt-test' },
+        memory: { model: 'gpt-maintainer-test' },
+      },
+    },
+  }));
+  const runner = [
+    "import { loadConfig } from './src/runtime/agent/orchestrator/config.mjs';",
+    "console.log(JSON.stringify(loadConfig({ secrets: false }).maintenance));",
+  ].join(' ');
+  const result = spawnSync(process.execPath, ['--input-type=module', '--eval', runner], {
+    cwd: process.cwd(),
+    env: { ...process.env, MIXDOG_DATA_DIR: dataDir },
+    encoding: 'utf8',
+  });
+  assert.equal(result.status, 0, result.stderr);
+  const maintenance = JSON.parse(result.stdout);
+  assert.deepEqual(maintenance.explore, { provider: 'openai', model: 'gpt-test' });
+  assert.deepEqual(maintenance.memory, { provider: 'openai', model: 'gpt-maintainer-test' });
+});
+
+test('config maintenance migration has no standalone provider runtime dependency', () => {
+  const source = readFileSync(new URL('../src/runtime/agent/orchestrator/config.mjs', import.meta.url), 'utf8');
+  assert.doesNotMatch(source, /standalone\/provider-admin/);
+  assert.match(source, /CONFIG_PROVIDER_IDS/);
+});

package/scripts/max-output-recovery-test.mjs

@@ -3,6 +3,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 
 import { agentLoop } from '../src/runtime/agent/orchestrator/session/agent-loop.mjs';
+import { HIDDEN_AGENT_NAMES } from '../src/runtime/agent/orchestrator/session/loop/hidden-agents.mjs';
 
 function queuedProvider(responses, streamed = []) {
     const sent = [];
@@ -35,6 +36,7 @@ function queuedProvider(responses, streamed = []) {
 async function run(provider, messages = [{ role: 'user', content: 'answer fully' }], options = {}) {
     return agentLoop(provider, messages, 'fake-model', [], options.onToolCall, process.cwd(), {
         onTextDelta: options.onTextDelta,
+        session: options.session,
     });
 }
 
@@ -126,6 +128,53 @@ test('pause_turn and Gemini OTHER preserve prior non-empty semantics and do not
     }
 });
 
+test('empty safety refusal gets one context-changing retry, then terminates as refusal', async () => {
+    const provider = queuedProvider([
+        { content: '', stopReason: 'refusal', stopDetails: { category: 'safety' } },
+        { content: '', stopReason: 'refusal', stopDetails: { category: 'safety' } },
+    ]);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages);
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.terminationReason, 'refusal');
+    assert.equal(messages.filter((message) => message?.meta?.source === 'refusal-recovery').length, 1);
+    assert.match(provider.sent[1].at(-1).content, /safety classifier/);
+    assert.match(provider.sent[1].at(-1).content, /within policy/);
+});
+
+test('one refusal retry can recover to a normal answer', async () => {
+    const provider = queuedProvider([
+        { content: '', stopReason: 'refusal' },
+        { content: 'compliant answer', stopReason: 'end_turn' },
+    ]);
+
+    const result = await run(provider);
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.content, 'compliant answer');
+    assert.equal(result.terminationReason, undefined);
+});
+
+test('hidden-agent empty refusal gets one retry, then terminates as refusal', async () => {
+    const hiddenAgent = HIDDEN_AGENT_NAMES.values().next().value;
+    assert.ok(hiddenAgent, 'expected at least one configured hidden agent');
+    const provider = queuedProvider([
+        { content: '', stopReason: 'refusal' },
+        { content: '', stopReason: 'refusal' },
+    ]);
+    const messages = [{ role: 'user', content: 'complete the assigned output' }];
+
+    const result = await run(provider, messages, { session: { agent: hiddenAgent } });
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.terminationReason, 'refusal');
+    assert.equal(messages.filter((message) => message?.meta?.source === 'refusal-recovery').length, 1);
+    assert.match(provider.sent[1].at(-1).content, /assigned output within policy/);
+    assert.doesNotMatch(provider.sent[1].at(-1).content, /answer the user/i);
+});
+
 test('non-output ProviderIncompleteError remains an error', async () => {
     const other = Object.assign(new Error('Gemini response incomplete: finishReason=OTHER'), {
         code: 'PROVIDER_INCOMPLETE',

package/scripts/mcp-client-normalization-test.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { normalizeMcpToolResult } from '../src/runtime/agent/orchestrator/mcp/client.mjs';
+import { classifyResultKind } from '../src/runtime/agent/orchestrator/session/result-classification.mjs';
+import { normalizeToolEnvelope } from '../src/runtime/agent/orchestrator/session/tool-envelope.mjs';
+
+test('isError:true plain MCP text receives one canonical Error: prefix', () => {
+    const result = normalizeMcpToolResult({
+        content: [{ type: 'text', text: 'connection refused' }],
+        isError: true,
+    });
+    assert.equal(result, 'Error: connection refused');
+    assert.equal(classifyResultKind(result), 'error');
+});
+
+test('isError:true already-prefixed MCP text is unchanged', () => {
+    const result = normalizeMcpToolResult({
+        content: [{ type: 'text', text: 'Error: connection refused' }],
+        isError: true,
+    });
+    assert.equal(result, 'Error: connection refused');
+});
+
+test('absent or false isError leaves MCP text untouched', () => {
+    for (const isError of [undefined, false]) {
+        const result = normalizeMcpToolResult({
+            content: [{ type: 'text', text: 'search complete' }],
+            ...(isError === undefined ? {} : { isError }),
+        });
+        assert.equal(result, 'search complete');
+        assert.equal(classifyResultKind(result), 'normal');
+    }
+});
+
+test('isError:false Error:-leading MCP text stays untouched and normal', () => {
+    const returned = normalizeMcpToolResult({
+        content: [{ type: 'text', text: 'Error: quoted search result' }],
+        isError: false,
+    });
+    const normalized = normalizeToolEnvelope(returned);
+    assert.equal(normalized.result, 'Error: quoted search result');
+    assert.equal(normalized.explicitSuccess, true);
+    assert.equal(classifyResultKind(normalized.result, normalized.explicitSuccess), 'normal');
+});

package/scripts/openai-oauth-ws-1006-retry-test.mjs

@@ -0,0 +1,123 @@
+// Regression: OpenAI OAuth WS abnormal-close recovery before visible output.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { OpenAIOAuthProvider } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
+import { sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
+
+function close1006() {
+    const err = new Error('WebSocket closed abnormally');
+    err.wsCloseCode = 1006;
+    return err;
+}
+
+function entry() {
+    return { socket: { close() {} } };
+}
+
+function wsArgs(overrides = {}) {
+    return {
+        auth: { access_token: 'test-token' },
+        body: { model: 'gpt-5.5', input: [{ role: 'user', content: 'retry me' }] },
+        poolKey: 'openai-oauth-ws-1006-test',
+        cacheKey: 'openai-oauth-ws-1006-test',
+        useModel: 'gpt-5.5',
+        _sendFrameFn: async () => {},
+        _sleepFn: async () => {},
+        ...overrides,
+    };
+}
+
+test('pre-response 1006 opens a fresh WS and replays the same request', async () => {
+    const acquires = [];
+    const frames = [];
+    let streams = 0;
+    const result = await sendViaWebSocket(wsArgs({
+        _acquireWithRetryFn: async (opts) => {
+            acquires.push(opts.forceFresh);
+            return { entry: entry(), reused: false };
+        },
+        _sendFrameFn: async (_entry, frame) => { frames.push(frame); },
+        _streamFn: async () => {
+            streams += 1;
+            if (streams === 1) throw close1006();
+            return { content: 'recovered', model: 'gpt-5.5', toolCalls: [], usage: {}, closeSocket: true };
+        },
+    }));
+
+    assert.equal(result.content, 'recovered');
+    assert.deepEqual(acquires, [false, true], 'retry must acquire a fresh socket');
+    assert.equal(frames.length, 2);
+    assert.deepEqual(frames[1].input, frames[0].input, 'retry must replay the same input');
+    assert.equal(result.__midstreamRetries, 1);
+});
+
+test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async () => {
+    const savedEnv = Object.fromEntries([
+        'MIXDOG_OAI_TRANSPORT',
+        'MIXDOG_OPENAI_HTTP_FALLBACK',
+        'MIXDOG_OPENAI_OAUTH_WS_WARMUP',
+        'MIXDOG_OPENAI_OAUTH_FAST_HTTP_FALLBACK',
+        'MIXDOG_AGENT_TRACE_DISABLE',
+    ].map((name) => [name, process.env[name]]));
+    Object.assign(process.env, {
+        MIXDOG_OAI_TRANSPORT: 'auto',
+        MIXDOG_OPENAI_HTTP_FALLBACK: '1',
+        MIXDOG_OPENAI_OAUTH_WS_WARMUP: '0',
+        MIXDOG_OPENAI_OAUTH_FAST_HTTP_FALLBACK: '0',
+        MIXDOG_AGENT_TRACE_DISABLE: '1',
+    });
+    try {
+        const provider = new OpenAIOAuthProvider({});
+        provider.ensureAuth = async () => ({ access_token: 'test-token' });
+        let streamAttempts = 0;
+        let httpCalls = 0;
+        const result = await provider.send([], 'gpt-5.5', [], {
+            sessionId: 'openai-oauth-ws-1006-fallback-test',
+            _prebuiltBody: { model: 'gpt-5.5', input: [], prompt_cache_key: 'openai-oauth-ws-1006-fallback-test' },
+            _sendViaWebSocketFn: (args) => sendViaWebSocket({
+                ...args,
+                _acquireWithRetryFn: async () => ({ entry: entry(), reused: false }),
+                _sendFrameFn: async () => {},
+                _streamFn: async () => {
+                    streamAttempts += 1;
+                    throw close1006();
+                },
+                _sleepFn: async () => {},
+            }),
+            _sendViaHttpSseFn: async () => {
+                httpCalls += 1;
+                return { content: 'http-recovered', toolCalls: [], usage: {} };
+            },
+        });
+
+        assert.equal(streamAttempts, 5, 'all bounded ws_1006 attempts must run before fallback');
+        assert.equal(httpCalls, 1);
+        assert.equal(result.content, 'http-recovered');
+    } finally {
+        for (const [name, value] of Object.entries(savedEnv)) {
+            if (value == null) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('post-emission 1006 refuses replay after text or tool output', async () => {
+    for (const emitted of ['emittedText', 'emittedToolCall']) {
+        let acquires = 0;
+        await assert.rejects(
+            sendViaWebSocket(wsArgs({
+                poolKey: `openai-oauth-ws-1006-${emitted}-test`,
+                _acquireWithRetryFn: async () => {
+                    acquires += 1;
+                    return { entry: entry(), reused: false };
+                },
+                _streamFn: async ({ state }) => {
+                    state[emitted] = true;
+                    throw close1006();
+                },
+            })),
+            (err) => err.wsCloseCode === 1006 && err.unsafeToRetry === true,
+        );
+        assert.equal(acquires, 1, `${emitted} must prevent a replay`);
+    }
+});

package/scripts/provider-toolcall-test.mjs

@@ -95,6 +95,29 @@ function anthropicSseResponse(events) {
     };
 }
 
+test('anthropic SSE exposes refusal stop details and category metadata', async () => {
+    const result = await anthropicParseSSEStream(
+        anthropicSseResponse([
+            { type: 'message_start', message: { model: 'claude-fable-5', usage: { input_tokens: 1 } } },
+            {
+                type: 'message_delta',
+                delta: {
+                    stop_reason: 'refusal',
+                    stop_details: { classifier: 'safety' },
+                    category: 'policy',
+                },
+                usage: { output_tokens: 0 },
+            },
+            { type: 'message_stop' },
+        ]),
+        null, () => {}, () => {}, () => {}, {}, null,
+    );
+
+    assert.equal(result.stopReason, 'refusal');
+    assert.deepEqual(result.stopDetails, { classifier: 'safety', category: 'policy' });
+    assert.equal(result.content, '');
+});
+
 function compatResponsesEventStream(events) {
     return {
         async *[Symbol.asyncIterator]() {