mixdog 0.9.39 → 0.9.41

package/scripts/internal-comms-smoke.mjs

@@ -63,14 +63,23 @@ 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 BRIEF_FIELDS = ['Goal:', 'Anchors:', 'Allow/Forbid:', 'Deliver:', 'Verify:'];
+const OPTIONAL_BRIEF_FIELDS = ['Anchors:', 'Allow/Forbid:', 'Deliver:', 'Verify:'];
 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}`);
 }
 assert(TOKEN_PRINCIPLE.test(normalize(leadBrief)), 'lead-brief.md: brief must state min-char/max-info principle');
-for (const field of BRIEF_FIELDS) assert(leadBrief.includes(field), `lead-brief.md: brief missing labeled field ${field}`);
-assert(leadBrief.includes('Stop:'), 'lead-brief.md: brief must add Stop: for heavy-worker bound');
+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}`);
+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/,
+]);
 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');
 requireAll(leadBrief, 'Lead brief lifecycle', [
@@ -80,7 +89,7 @@ requireAll(leadBrief, 'Lead brief lifecycle', [
   /agent communication is english/,
 ]);
 assert(/lead brief contract/i.test(normalize(workflow)), 'WORKFLOW.md: must defer to the lead brief contract');
-assert(!BRIEF_FIELDS.every((field) => workflow.includes(field)), 'WORKFLOW.md: must not duplicate the full brief field list');
+assert(!OPTIONAL_BRIEF_FIELDS.every((field) => workflow.includes(field)), 'WORKFLOW.md: must not duplicate the optional brief field list');
 
 assert(/fragments/i.test(core), '00-core: handoff must require fragments');
 assert(/file:line/i.test(core), '00-core: handoff must anchor evidence to file:line');
@@ -112,19 +121,52 @@ 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/,
 ]);
-requireAll(workflow, 'Default routing', [
-  /delegate by default/, /only coordinates, does git, or an obvious 1-edit\/ 1-check change/,
-  /implementation\/research\/debugging to its matching agent/, /indicators, not automatic categories/,
-  /worker: bounded established path, low local risk\/coupling\/verification, clear local check/,
-  /heavy worker: high risk\/coupling\/verification \(including any high-risk scope\), or coupled staged work needing coordinated verification/,
-  /reviewer verifies an implementation/, /debugger handles requested debugging or root cause after a failed fix/,
-]);
+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/,
+  /never infer an exemption from a task name, file count, or perceived difficulty/,
+  /every other implementation, reverse engineering, debugging application, or artifact generation delegates to the matching agent/,
+  /debugger owns diagnosis and reverse engineering/,
+  /worker applies an established bounded change or fully specified artifact/,
+  /heavy worker owns implementation that must establish the change through investigation or staged delivery/,
+  /applying a debugger result is implementation, not diagnosis/,
+  /review is exempt only for pure read\/analysis with no edit, artifact, or state mutation; git\/configuration; or a request where the user explicitly supplies both the exact target and exact replacement\/output\. every non-exempt mutation or artifact/,
+  /every non-exempt mutation or artifact/,
+  /worker, heavy worker, debugger, or lead/,
+  /one reviewer .*lead integration\/cross-scope verification in parallel/,
+  /debugger analysis cannot substitute for implementation review/,
+  /applying a debugger result triggers the same reviewer \+ lead verification/,
+  /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 lifecycle', [
-  /draft before any implementation/, /parallel gain exceeds coordination\/merge cost/,
-  /all in one turn, with no count cap/, /real dependency, overlapping write, or inseparable coupling/,
-  /after async spawn, end the turn/, /every delegated implementation gets one reviewer/,
-  /lead integration\/cross-scope verification in parallel/, /high-risk scopes add distinct lenses/,
-  /original live session/, /loop fix -> re-verify \(same reviewer \+ lead re-check\) until clean/,
+  /draft before any implementation/, /all ready scopes in one turn, with no count cap/,
+  /real dependency, overlapping write, or inseparable coupling/,
+  /after async spawn, end the turn/,
+  /high-risk scopes add distinct lenses/,
+  /original live session/,
   /bug surviving 2\+ fix cycles/, /agent reports relay.*as in-progress, never conclusions/,
   /final \(not interim\) report/, /never forward raw agent output/,
   /explicit user request after issue-free feedback/, /outcome\/direction change, pause and re-consult/,
@@ -137,16 +179,13 @@ requireAll(solo, 'Solo lifecycle', [
   /scope change needs a revised plan and fresh approval/,
   /checks\/fixes directly until clean or reports a blocker/, /final \(not interim\) report/,
   /interim updates are in-progress, never conclusions/,
-  /issue-free user feedback/,
+  /issue-free feedback/,
 ]);
 requireAll(bench, 'Bench lifecycle', [
-  /never wait for approval or ask questions/, /verified complete or provably blocked/,
-  /maximum independent scopes/, /spawning every scope in one turn/,
-  /build\/test-green gate/, /no polling, guessing, or dependent work/,
-  /one reviewer per implementation scope/, /never deferred\/batched/,
-  /fact-check agent responses and cross-check implementation\/review yourself before acting/,
-  /return fixes to the original scope/, /loop verify -> fix -> re-verify until clean/,
-  /skip only simple, low-risk review/, /hard blocked/, /outcome and evidence/,
+  /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/,
@@ -220,7 +259,9 @@ const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-internal-comms-smoke-'));
 try {
   const leadRules = rulesBuilder.buildInjectionContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
   assert(TOKEN_PRINCIPLE.test(normalize(leadRules)), 'injected Lead rules must carry the brief token principle');
-  for (const field of BRIEF_FIELDS) assert(leadRules.includes(field), `injected Lead rules missing brief field ${field}`);
+  assert(leadRules.includes('Task:'), 'injected Lead rules missing mandatory brief field Task:');
+  assert(!leadRules.includes('Goal:'), 'injected Lead rules must not retain Goal:');
+  for (const field of OPTIONAL_BRIEF_FIELDS) assert(leadRules.includes(field), `injected Lead rules missing optional brief field ${field}`);
 } finally {
   rmSync(dataDir, { recursive: true, force: true });
 }

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

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+process.env.MIXDOG_DATA_DIR = mkdtempSync(join(tmpdir(), 'mixdog-max-output-persist-'));
+
+test('askSession persists recovery history without duplicating the returned aggregate', async () => {
+    const { initProviders, getProvider } = await import('../src/runtime/agent/orchestrator/providers/registry.mjs');
+    await initProviders({ gemini: { enabled: true, apiKey: 'test-only' } });
+    const provider = getProvider('gemini');
+    const responses = [
+        {
+            content: 'persisted partial ',
+            stopReason: 'MAX_TOKENS',
+            truncated: true,
+            usage: { inputTokens: 4, outputTokens: 3, cachedTokens: 1, promptTokens: 4 },
+        },
+        {
+            content: 'terminal segment',
+            stopReason: 'end_turn',
+            usage: { inputTokens: 2, outputTokens: 2, cachedTokens: 0, promptTokens: 2 },
+        },
+    ];
+    let sendIndex = 0;
+    const streamed = [];
+    provider.send = async (_messages, _model, _tools, opts = {}) => {
+        const response = responses[sendIndex++];
+        assert.ok(response, `unexpected provider send ${sendIndex}`);
+        opts.onTextDelta?.(response.content);
+        streamed.push(response.content);
+        return response;
+    };
+
+    const { createSession, askSession, getSession } = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
+    const session = createSession({
+        provider: 'gemini',
+        model: 'gemini-test',
+        tools: [],
+        cwd: process.cwd(),
+        skipAgentRules: true,
+        skipSkills: true,
+        compaction: { auto: false },
+    });
+
+    const result = await askSession(
+        session.id,
+        'produce a long answer',
+        null,
+        null,
+        process.cwd(),
+        null,
+        { onTextDelta: () => {} },
+    );
+    const persisted = getSession(session.id);
+    const partialRows = persisted.messages.filter((message) => message.role === 'assistant' && message.content === 'persisted partial ');
+    const terminalRows = persisted.messages.filter((message) => message.role === 'assistant' && message.content === 'terminal segment');
+    const aggregateRows = persisted.messages.filter((message) => message.role === 'assistant' && message.content === result.content);
+
+    assert.equal(result.content, 'persisted partial terminal segment');
+    assert.equal(streamed.join(''), result.content, 'streamed TUI text matches the aggregate without duplication');
+    assert.equal(partialRows.length, 1);
+    assert.equal(terminalRows.length, 1);
+    assert.equal(aggregateRows.length, 0, 'aggregate is returned but is not persisted over the recovery chain');
+    assert.equal(
+        persisted.messages.filter((message) => message?.meta?.source === 'max-output-recovery').length,
+        1,
+    );
+    assert.deepEqual(
+        {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            cachedTokens: result.usage.cachedTokens,
+            promptTokens: result.usage.promptTokens,
+        },
+        { inputTokens: 6, outputTokens: 5, cachedTokens: 1, promptTokens: 6 },
+    );
+});

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

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { agentLoop } from '../src/runtime/agent/orchestrator/session/agent-loop.mjs';
+
+function queuedProvider(responses, streamed = []) {
+    const sent = [];
+    let index = 0;
+    return {
+        sent,
+        async send(messages, _model, _tools, opts = {}) {
+            sent.push(structuredClone(messages));
+            const response = responses[index++];
+            assert.ok(response, `unexpected provider send ${index}`);
+            if (response instanceof Error) {
+                if (typeof response.partialContent === 'string') {
+                    opts.onTextDelta?.(response.partialContent);
+                    streamed.push(response.partialContent);
+                }
+                throw response;
+            }
+            if (typeof response.content === 'string') {
+                opts.onTextDelta?.(response.content);
+                streamed.push(response.content);
+            }
+            return {
+                usage: { inputTokens: 1, outputTokens: 1 },
+                ...response,
+            };
+        },
+    };
+}
+
+async function run(provider, messages = [{ role: 'user', content: 'answer fully' }], options = {}) {
+    return agentLoop(provider, messages, 'fake-model', [], options.onToolCall, process.cwd(), {
+        onTextDelta: options.onTextDelta,
+    });
+}
+
+function persistedAssistantText(messages, result) {
+    const terminal = typeof result.historyContent === 'string' ? result.historyContent : result.content;
+    return [
+        ...messages.filter((message) => message.role === 'assistant').map((message) => message.content),
+        terminal,
+    ].join('');
+}
+
+test('one max-output continuation resumes from preserved partial and returns one complete text', async () => {
+    const streamed = [];
+    const provider = queuedProvider([
+        { content: 'alpha ', stopReason: 'length', truncated: true },
+        { content: 'omega', stopReason: 'end_turn' },
+    ], streamed);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages, { onTextDelta: () => {} });
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.content, 'alpha omega');
+    assert.equal(streamed.join(''), result.content);
+    assert.equal(result.historyContent, 'omega');
+    assert.equal(result.maxOutputRecoveryAttempts, 1);
+    assert.equal(result.terminationReason, undefined);
+    assert.deepEqual(provider.sent[1].map((message) => message.role), ['user', 'assistant', 'user']);
+    assert.equal(provider.sent[1][1].content, 'alpha ');
+    assert.match(provider.sent[1][2].content, /Resume directly/);
+    assert.match(provider.sent[1][2].content, /no apology, no recap/i);
+    assert.equal(persistedAssistantText(messages, result), result.content);
+    assert.equal(messages.some((message) => message.role === 'assistant' && message.content === result.content), false);
+});
+
+test('Gemini MAX_TOKENS ProviderIncompleteError enters the same bounded recovery and aggregates usage', async () => {
+    const streamed = [];
+    const geminiIncomplete = Object.assign(new Error('Gemini response incomplete: finishReason=MAX_TOKENS'), {
+        name: 'ProviderIncompleteError',
+        code: 'PROVIDER_INCOMPLETE',
+        providerIncomplete: true,
+        finishReason: 'MAX_TOKENS',
+        partialContent: 'gemini ',
+        partialToolCalls: undefined,
+        model: 'gemini-test',
+        rawUsage: {
+            promptTokenCount: 10,
+            candidatesTokenCount: 4,
+            thoughtsTokenCount: 1,
+            cachedContentTokenCount: 3,
+        },
+    });
+    const provider = queuedProvider([
+        geminiIncomplete,
+        {
+            content: 'complete',
+            stopReason: 'end_turn',
+            usage: { inputTokens: 1, outputTokens: 2, cachedTokens: 1, promptTokens: 1 },
+        },
+    ], streamed);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages, { onTextDelta: () => {} });
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.content, 'gemini complete');
+    assert.equal(streamed.join(''), result.content, 'TUI-facing deltas and final aggregate contain each segment once');
+    assert.deepEqual(
+        {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            cachedTokens: result.usage.cachedTokens,
+            promptTokens: result.usage.promptTokens,
+        },
+        { inputTokens: 11, outputTokens: 7, cachedTokens: 4, promptTokens: 11 },
+    );
+    assert.equal(result.lastTurnUsage.outputTokens, 2);
+    assert.equal(provider.sent[1][1].content, 'gemini ');
+});
+
+test('pause_turn and Gemini OTHER preserve prior non-empty semantics and do not recover', async () => {
+    for (const stopReason of ['pause_turn', 'OTHER']) {
+        const provider = queuedProvider([{ content: `partial-${stopReason}`, stopReason }]);
+        const result = await run(provider);
+        assert.equal(provider.sent.length, 1, stopReason);
+        assert.equal(result.content, `partial-${stopReason}`, stopReason);
+        assert.equal(result.terminationReason, undefined, stopReason);
+        assert.equal(Object.hasOwn(result, 'historyContent'), false, stopReason);
+    }
+});
+
+test('non-output ProviderIncompleteError remains an error', async () => {
+    const other = Object.assign(new Error('Gemini response incomplete: finishReason=OTHER'), {
+        code: 'PROVIDER_INCOMPLETE',
+        providerIncomplete: true,
+        finishReason: 'OTHER',
+        partialContent: 'unsafe partial',
+        partialToolCalls: undefined,
+    });
+    await assert.rejects(run(queuedProvider([other])), (error) => error === other);
+});
+
+test('adaptive-thinking replay state is preserved on the partial assistant history turn', async () => {
+    const thinkingBlocks = [{ type: 'thinking', thinking: 'signed thought', signature: 'sig-123' }];
+    const reasoningItems = [{ type: 'reasoning', encrypted_content: 'enc-1' }];
+    const provider = queuedProvider([
+        {
+            content: 'first ',
+            stopReason: 'max_tokens',
+            truncated: true,
+            thinkingBlocks,
+            reasoningItems,
+            reasoningContent: 'display thought',
+        },
+        { content: 'second', stopReason: 'end_turn' },
+    ]);
+
+    const result = await run(provider);
+
+    assert.equal(result.content, 'first second');
+    assert.deepEqual(provider.sent[1][1].thinkingBlocks, thinkingBlocks);
+    assert.deepEqual(provider.sent[1][1].reasoningItems, reasoningItems);
+    assert.equal(provider.sent[1][1].reasoningContent, 'display thought');
+});
+
+test('max-output recovery stops after three continuations and surfaces explicit truncation', async () => {
+    const provider = queuedProvider([
+        { content: 'A', stopReason: 'max_tokens', truncated: true },
+        { content: 'B', stopReason: 'max_tokens', truncated: true },
+        { content: 'C', stopReason: 'max_tokens', truncated: true },
+        { content: 'D', stopReason: 'max_tokens', truncated: true },
+    ]);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages);
+
+    assert.equal(provider.sent.length, 4);
+    assert.equal(result.maxOutputRecoveryAttempts, 3);
+    assert.equal(result.terminationReason, 'truncated');
+    assert.match(result.content, /^ABCD/);
+    assert.match(result.content, /remained truncated after 3 continuation attempts/);
+    assert.equal(messages.filter((message) => message?.meta?.source === 'max-output-recovery').length, 3);
+    assert.equal(messages.filter((message) => message.role === 'assistant').length, 3);
+    assert.equal(persistedAssistantText(messages, result), result.content);
+});
+
+test('clean end_turn is unchanged and does not enter recovery', async () => {
+    const provider = queuedProvider([
+        { content: 'clean answer', stopReason: 'end_turn' },
+    ]);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages);
+
+    assert.equal(provider.sent.length, 1);
+    assert.equal(result.content, 'clean answer');
+    assert.equal(result.terminationReason, undefined);
+    assert.equal(Object.hasOwn(result, 'historyContent'), false);
+    assert.deepEqual(messages, [{ role: 'user', content: 'answer fully' }]);
+});
+
+test('tool-call turns keep the normal tool execution path', async () => {
+    const provider = queuedProvider([
+        {
+            content: '',
+            stopReason: 'tool_use',
+            toolCalls: [{ id: 'call-1', name: 'unknown_test_tool', arguments: {} }],
+        },
+        { content: 'done', stopReason: 'end_turn' },
+    ]);
+    const batches = [];
+    const messages = [{ role: 'user', content: 'use a tool' }];
+
+    const result = await run(provider, messages, {
+        onToolCall: (_iteration, calls) => batches.push(calls),
+    });
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.content, 'done');
+    assert.equal(result.toolCallsTotal, 1);
+    assert.equal(result.terminationReason, undefined);
+    assert.equal(Object.hasOwn(result, 'historyContent'), false);
+    assert.equal(batches.length, 1);
+    assert.deepEqual(messages.map((message) => message.role), ['user', 'assistant', 'tool']);
+});

package/scripts/provider-toolcall-test.mjs

@@ -52,6 +52,7 @@ import {
 } from '../src/runtime/agent/orchestrator/providers/gemini-cache.mjs';
 import { parseSSEStream as anthropicParseSSEStream } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
 import { _buildRequestBodyForCacheSmoke } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
+import { _toAnthropicMessagesForTest } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
 import {
     EFFORT_BETA_HEADER,
     LEGACY_EFFORT_BUDGET,
@@ -773,6 +774,37 @@ test('anthropic(-oauth): redacted_thinking round-trips exactly as {type,data} (n
     ]);
 });
 
+test('anthropic API-key and OAuth lower plain signed thinkingBlocks before text without tool calls', () => {
+    const thinkingBlocks = [
+        { type: 'thinking', thinking: 'resume state', signature: 'sig-recovery-1' },
+        { type: 'redacted_thinking', data: 'ENCRYPTED_RECOVERY_STATE' },
+    ];
+    const history = [
+        { role: 'user', content: 'write the answer' },
+        { role: 'assistant', content: 'partial answer', thinkingBlocks },
+        { role: 'user', content: 'resume directly' },
+    ];
+    const expectedAssistantContent = [
+        ...thinkingBlocks,
+        { type: 'text', text: 'partial answer' },
+    ];
+
+    const apiKeyMessages = _toAnthropicMessagesForTest(history);
+    const oauthMessages = _buildRequestBodyForCacheSmoke(
+        history,
+        'claude-sonnet-4-6',
+        [],
+        {},
+    ).messages;
+
+    for (const lowered of [apiKeyMessages, oauthMessages]) {
+        const assistant = lowered.find((message) => message.role === 'assistant');
+        assert.ok(assistant, 'plain recovery assistant turn must survive lowering');
+        assert.deepEqual(assistant.content, expectedAssistantContent);
+        assert.equal(assistant.content.some((block) => block.type === 'tool_use'), false);
+    }
+});
+
 test('anthropic effort: legacy claude-3-7-sonnet gets NO adaptive thinking / effort beta', () => {
     const model = 'claude-3-7-sonnet-20250219';
     assert.equal(modelSupportsEffort(model), false);