mixdog 0.9.41 → 0.9.43

package/scripts/internal-comms-smoke.mjs

@@ -57,7 +57,6 @@ 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');
@@ -121,21 +120,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 +138,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 +163,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/,
@@ -234,7 +212,11 @@ Review the approved intent, diff, and tests with independent judgment. Prioritiz
 actionable correctness, regression, security, and verification risks; inspect
 affected boundaries. Do not reimplement the change or report non-risky nits.
 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/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/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]() {

package/scripts/result-classification-test.mjs

@@ -0,0 +1,75 @@
+#!/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';
+import { normalizeToolEnvelope } from '../src/runtime/agent/orchestrator/session/tool-envelope.mjs';
+import { executeTool } from '../src/runtime/agent/orchestrator/session/loop/tool-exec.mjs';
+
+async function classifyHandlerResult(handlerResult) {
+    setInternalToolsProvider({
+        tools: [{ name: 'result_classification_test' }],
+        executor: async () => handlerResult,
+    });
+    const returned = await executeInternalTool('result_classification_test', {});
+    const normalized = normalizeToolEnvelope(returned);
+    return classifyResultKind(normalized.result, normalized.explicitSuccess);
+}
+
+test('explicit success suppresses Error: text-prefix classification', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'Error: quoted log output' }],
+        isError: false,
+    }), 'normal');
+});
+
+test('explicit isError:true remains an error', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'handler failed' }],
+        isError: true,
+    }), 'error');
+});
+
+test('flag-less Error: text remains an error', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'Error: prefix-only failure' }],
+    }), 'error');
+});
+
+test('flag-less normal text remains normal', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'ordinary output' }],
+    }), 'normal');
+});
+
+test('afterToolHook receives unwrapped explicit-success text', async () => {
+    setInternalToolsProvider({
+        tools: [{ name: 'result_classification_test' }],
+        executor: async () => ({
+            content: [{ type: 'text', text: 'Error: quoted hook payload' }],
+            isError: false,
+        }),
+    });
+    let hookResult;
+    const returned = await executeTool(
+        'result_classification_test',
+        {},
+        process.cwd(),
+        'result-classification-test-session',
+        {
+            afterToolHook: async (input) => {
+                hookResult = input.result;
+            },
+        },
+        { toolCallId: 'result-classification-hook-call' },
+    );
+    assert.equal(hookResult, 'Error: quoted hook payload');
+    assert.equal(typeof hookResult, 'string');
+
+    const normalized = normalizeToolEnvelope(returned);
+    assert.equal(normalized.result, hookResult);
+    assert.equal(normalized.explicitSuccess, true);
+});

package/scripts/smoke.mjs

@@ -95,7 +95,7 @@ runNode(['--input-type=module', '-e', `
     stats: { currentContextTokens: 0 },
     agentJobs: [{ task_id: 'task_statusline_smoke', status: 'running', tag: 'bench-agent', startedAt: new Date().toISOString() }],
   });
-  if (!line.includes('Running') || !line.includes('bench-agent')) throw new Error('statusline must render live agent task state: ' + JSON.stringify(line));
+  if (!line.includes('Running 1 Agent') || line.includes('bench-agent')) throw new Error('statusline must render live agent count without task tags: ' + JSON.stringify(line));
 `], 'statusline live agent task smoke', { env: isolatedStatuslineEnv });
 
 runNode(['--input-type=module', '-e', `

package/scripts/submit-commandbusy-race-test.mjs

@@ -7,12 +7,39 @@ import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
 // command (commandBusy) or an auto-clear. Wires the real session-flow queue
 // (enqueue/drain) + the real submit() against a minimal bag whose set() mirrors
 // engine.mjs's commandBusy-release drain kick.
-function makeEngine({ autoClearBeforeSubmit } = {}) {
+function makeEngine({
+  autoClearBeforeSubmit,
+  autoClearEnabled = false,
+  runtimeClear = async () => true,
+} = {}) {
   let seq = 0;
   const executed = [];
-  let state = { queued: [], busy: false, commandBusy: false };
+  const providerRequests = [];
+  let resolveProviderDispatch;
+  const providerDispatch = new Promise((resolve) => { resolveProviderDispatch = resolve; });
+  let state = {
+    items: [{ kind: 'user', id: 'existing', text: 'existing prompt' }],
+    queued: [],
+    busy: false,
+    commandBusy: false,
+  };
   const bag = {
-    runtime: { id: null, consumePendingSessionReset: () => null },
+    runtime: {
+      id: 'session_1',
+      session: {
+        id: 'session_1',
+        messages: [{ role: 'user', content: 'existing prompt' }],
+        lastUsedAt: Date.now() - 1000,
+      },
+      getCompactionSettings: () => ({}),
+      clear: runtimeClear,
+      consumePendingSessionReset: () => null,
+      ask: async (text) => {
+        providerRequests.push(text);
+        resolveProviderDispatch(text);
+        return { result: { content: 'ok' }, session: bag.runtime.session };
+      },
+    },
     nextId: () => `id_${++seq}`,
     tuiDebug: () => {},
     flags: {},
@@ -30,12 +57,15 @@ function makeEngine({ autoClearBeforeSubmit } = {}) {
       if (released) queueMicrotask(() => { void bag.drain?.(); });
       return true;
     },
-    pushItem: () => {},
+    pushItem: (item) => { state = { ...state, items: [...state.items, item] }; },
     patchItem: () => {},
     replaceItems: (x) => x,
     pushNotice: () => {},
-    pushUserOrSyntheticItem: (text) => { executed.push(text); },
-    autoClearState: () => ({ enabled: false }),
+    pushUserOrSyntheticItem: (text, id) => {
+      executed.push(text);
+      state = { ...state, items: [...state.items, { kind: 'user', id, text }] };
+    },
+    autoClearState: () => ({ enabled: autoClearEnabled, idleMs: 0, minContextPercent: 0 }),
     agentStatusState: () => ({}),
     routeState: () => ({}),
     syncContextStats: () => {},
@@ -44,7 +74,10 @@ function makeEngine({ autoClearBeforeSubmit } = {}) {
     requeueEntriesFront: () => {},
     resetStatsAndSyncContext: () => {},
     flushDeferredExecutionPendingResumeKick: () => {},
-    runTurn: async () => 'ok',
+    runTurn: async (text) => {
+      await bag.runtime.ask(text);
+      return 'ok';
+    },
   };
   Object.assign(bag, createSessionFlow(bag));
   if (autoClearBeforeSubmit) bag.autoClearBeforeSubmit = autoClearBeforeSubmit;
@@ -53,6 +86,14 @@ function makeEngine({ autoClearBeforeSubmit } = {}) {
     api,
     bag,
     getExecuted: () => executed,
+    getProviderRequests: () => providerRequests,
+    waitForProviderDispatch: (timeoutMs = 250) => new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(`provider dispatch timed out after ${timeoutMs}ms`)), timeoutMs);
+      providerDispatch.then((text) => {
+        clearTimeout(timer);
+        resolve(text);
+      }, reject);
+    }),
     getState: () => bag.getState(),
     mutateState: (mutator) => { mutator(state); },
   };
@@ -107,6 +148,57 @@ test('submit still enqueues when autoClearBeforeSubmit rejects', async () => {
   assert.deepEqual(getExecuted(), ['survives rejection'], 'rejected auto-clear must not lose the prompt');
 });
 
+test('runtime clear false skips auto-clear and sends the first post-failure prompt to the provider', async () => {
+  const {
+    api, bag, getExecuted, getProviderRequests, getState,
+  } = makeEngine({ autoClearEnabled: true, runtimeClear: async () => false });
+
+  assert.equal(api.submit('first after failed auto-clear'), true);
+  await tick(); await tick();
+
+  assert.deepEqual(getExecuted(), ['first after failed auto-clear'], 'user card remains visible');
+  assert.deepEqual(getProviderRequests(), ['first after failed auto-clear'], 'first post-failure input reaches provider');
+  assert.equal(getState().items.some((item) => item.label === 'Auto-clear skipped'), true);
+  assert.equal(getState().items.some((item) => item.label === 'Auto-clear complete'), false);
+  assert.equal(getState().items.some((item) => item.id === 'existing'), true, 'failed clear preserves the existing session UI');
+  assert.equal(bag.runtime.session.messages[0].content, 'existing prompt', 'failed clear preserves the runtime session');
+});
+
+test('late runtime clear false keeps the UI skipped and sends the first post-timeout prompt', async () => {
+  let resolveClear;
+  let harness;
+  const autoClearBeforeSubmit = () => harness.bag.performSessionClear({
+    verb: 'Auto-clearing idle conversation',
+    doneLabel: 'Auto-clear complete',
+    skipLabel: 'Auto-clear skipped',
+    surface: 'auto-clear',
+    useCompaction: true,
+    compactTimeoutMs: 5,
+  });
+  harness = makeEngine({
+    autoClearBeforeSubmit,
+    runtimeClear: () => new Promise((resolve) => { resolveClear = resolve; }),
+  });
+  harness.bag.runtime.getCompactionSettings = () => ({ compactType: 'summary' });
+
+  assert.equal(harness.api.submit('first after timed-out auto-clear'), true);
+  await harness.waitForProviderDispatch();
+  assert.equal(typeof resolveClear, 'function', 'compacting clear started');
+  assert.deepEqual(
+    harness.getProviderRequests(),
+    ['first after timed-out auto-clear'],
+    'first post-timeout input reaches provider before late clear settles',
+  );
+
+  resolveClear(false);
+  await tick(); await tick();
+
+  assert.equal(harness.getState().items.some((item) => item.label === 'Auto-clear skipped'), true);
+  assert.equal(harness.getState().items.some((item) => item.label === 'Auto-clear complete'), false);
+  assert.equal(harness.getState().items.some((item) => item.id === 'existing'), true, 'late false preserves the existing session UI');
+  assert.equal(harness.bag.runtime.session.messages[0].content, 'existing prompt', 'late false preserves the runtime session');
+});
+
 test('empty and whitespace submits are still rejected', () => {
   const { api, bag } = makeEngine();
   assert.equal(api.submit('   '), false);

package/scripts/tui-transcript-perf-test.mjs

@@ -8,7 +8,7 @@ import { buildTranscriptRowIndexIncremental } from '../src/tui/app/transcript-wi
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-function makeTurnHarness(ask) {
+function makeTurnHarness(ask, stateOverrides = {}) {
   let seq = 0;
   let state = {
     items: [],
@@ -18,6 +18,7 @@ function makeTurnHarness(ask) {
     busy: false,
     spinner: null,
     thinking: null,
+    ...stateOverrides,
   };
   const itemIndexById = new Map();
   const set = (patch) => { state = { ...state, ...patch }; return true; };
@@ -43,6 +44,15 @@ function makeTurnHarness(ask) {
   const clearStreamingTail = (id = null) => {
     if (id == null || state.streamingTail?.id === id) set({ streamingTail: null });
   };
+  const replaceItems = (items, options = {}) => {
+    state = replaceEngineItemsState({
+      state,
+      items,
+      itemIndexById,
+      preserveStreamingTail: options.preserveStreamingTail === true,
+    });
+    return items;
+  };
   const bag = {
     runtime: { id: null, toolMode: 'auto', ask, abort: () => true },
     nextId: () => `id_${++seq}`,
@@ -55,6 +65,7 @@ function makeTurnHarness(ask) {
     set,
     pushItem,
     patchItem,
+    replaceItems,
     updateStreamingTail,
     settleStreamingTail,
     clearStreamingTail,
@@ -77,6 +88,50 @@ function makeTurnHarness(ask) {
   return { runTurn: createRunTurn(bag), getState: () => state };
 }
 
+test('successful mid-turn compact trims history but preserves live turn references', async () => {
+  let preservedTail = false;
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onTextDelta('before compact\n');
+    await wait(30);
+    options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
+    preservedTail = harness.getState().streamingTail?.text === 'before compact\n';
+    options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
+    options.onTextDelta('after compact\n');
+    return { result: { content: 'before compact\nafter compact\n' }, session: { messages: [] } };
+  }, {
+    items: [
+      { id: 'old', kind: 'assistant', text: 'old history' },
+      { id: 'current-user', kind: 'user', text: 'go' },
+    ],
+  });
+
+  assert.equal(await harness.runTurn('go', { submittedIds: ['current-user'] }), 'done');
+  assert.equal(preservedTail, true);
+  assert.equal(harness.getState().items.some((item) => item.id === 'old'), false);
+  assert.equal(harness.getState().items.some((item) => item.id === 'current-user'), true);
+  assert.equal(
+    harness.getState().items.filter((item) => item.label === 'Compact complete (overflow recovery)').length,
+    2,
+  );
+  assert.equal(
+    harness.getState().items.find((item) => item.kind === 'assistant')?.text,
+    'before compact\nafter compact\n',
+  );
+});
+
+test('failed mid-turn compact leaves prior transcript items untouched', async () => {
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onCompactEvent({ status: 'failed' });
+    return { result: { content: '' }, session: { messages: [] } };
+  }, {
+    items: [{ id: 'old', kind: 'assistant', text: 'old history' }],
+  });
+
+  assert.equal(await harness.runTurn('go'), 'done');
+  assert.equal(harness.getState().items.some((item) => item.id === 'old'), true);
+  assert.equal(harness.getState().items.some((item) => item.label === 'Compact failed'), true);
+});
+
 test('stream flush keeps settled items identity and finalize appends one assistant', async () => {
   let identityStable = false;
   const harness = makeTurnHarness(async (_text, options) => {

package/src/agents/reviewer/AGENT.md

@@ -9,6 +9,10 @@ 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.
+Treat implementer and Lead reports as claims to test rather than evidence;
+independently evaluate the final deliverable against the original request and
+available evidence 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.
 

package/src/runtime/agent/orchestrator/internal-tools.mjs

@@ -15,7 +15,8 @@
  * no-tool role guard) — not a permission check. No gating is needed here.
  */
 
-import { isToolEnvelope, makeToolEnvelope } from './session/tool-envelope.mjs';
+import { isToolEnvelope, makeToolEnvelope, normalizeToolEnvelope } from './session/tool-envelope.mjs';
+import { classifyResultKind } from './session/result-classification.mjs';
 
 let _executor = null;
 let _tools = [];
@@ -62,12 +63,24 @@ function _normalize(result) {
     // JSON.stringify below and the loop would see the stringified envelope as
     // the tool_result (body inlined + duplicated, no newMessages).
     if (isToolEnvelope(result)) {
-        return makeToolEnvelope(_normalize(result.result), result.newMessages);
+        const normalized = normalizeToolEnvelope(_normalize(result.result));
+        return makeToolEnvelope(normalized.result, result.newMessages, {
+            explicitSuccess: normalized.explicitSuccess || result.explicitSuccess === true,
+        });
     }
     if (result && typeof result === 'object' && Array.isArray(result.content)) {
-        return result.content
+        const text = result.content
             .map((c) => (c?.type === 'text' ? c.text || '' : JSON.stringify(c)))
             .join('\n');
+        // Preserve MCP-style handler outcome metadata across the object→string
+        // boundary. Explicit failures retain the canonical Error: convention;
+        // explicit successes use a transient envelope so legitimate output
+        // beginning with Error: is not mistaken for a failed execution.
+        if (result.isError === true) return !text.startsWith('Error:') ? `Error: ${text}` : text;
+        if (result.isError === false && classifyResultKind(text) === 'error') {
+            return makeToolEnvelope(text, [], { explicitSuccess: true });
+        }
+        return text;
     }
     if (typeof result === 'string') return result;
     return JSON.stringify(result);