mixdog 0.9.2 → 0.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -51,6 +51,7 @@
     "bench:task": "node scripts/task-bench.mjs",
     "bench:corpus": "node scripts/routing-corpus.mjs",
     "bench:run": "node scripts/bench-run.mjs",
+    "bench:recall": "node scripts/recall-bench.mjs",
     "patch:replay": "node scripts/patch-replay.mjs",
     "build:tui": "node scripts/build-tui.mjs"
   },

package/scripts/anthropic-maxtokens-test.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { _test } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
+import { _test as _apiKeyTest } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
+
+const { resolveMaxTokens } = _test;
+const { resolveMaxTokens: resolveMaxTokensApiKey } = _apiKeyTest;
+const ENV_VAR = 'MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS';
+
+function withEnvOverride(value, fn) {
+    const had = Object.prototype.hasOwnProperty.call(process.env, ENV_VAR);
+    const prev = process.env[ENV_VAR];
+    try {
+        if (value == null) delete process.env[ENV_VAR];
+        else process.env[ENV_VAR] = value;
+        fn();
+    } finally {
+        if (had) process.env[ENV_VAR] = prev;
+        else delete process.env[ENV_VAR];
+    }
+}
+
+test('claude-sonnet-5 resolves to 65536 (catalog or fallback)', () => {
+    withEnvOverride(null, () => {
+        assert.equal(resolveMaxTokens('claude-sonnet-5'), 65536);
+    });
+});
+
+test('unknown model id falls back to a sane >=8192 value', () => {
+    withEnvOverride(null, () => {
+        const result = resolveMaxTokens('claude-totally-unknown-model-xyz');
+        assert.equal(typeof result, 'number');
+        assert.ok(Number.isFinite(result));
+        assert.ok(result >= 8192, `expected >=8192, got ${result}`);
+    });
+});
+
+test('MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS=32768 overrides the result', () => {
+    withEnvOverride('32768', () => {
+        assert.equal(resolveMaxTokens('claude-sonnet-5'), 32768);
+        assert.equal(resolveMaxTokens('claude-totally-unknown-model-xyz'), 32768);
+    });
+});
+
+test('invalid MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS=0 does not override', () => {
+    withEnvOverride(null, () => {
+        const baseline = resolveMaxTokens('claude-sonnet-5');
+        withEnvOverride('0', () => {
+            assert.equal(resolveMaxTokens('claude-sonnet-5'), baseline);
+            assert.notEqual(baseline, 0);
+        });
+    });
+});
+
+// Regression guard for the reviewer-caught masking gap: sonnet-5's baseline
+// already equals DEFAULT_SAFETY_CAP (65536), so an invalid override that
+// wrongly returns the default cap is invisible on sonnet-5. Assert on models
+// whose baseline is BELOW the cap — an invalid env value must leave them at
+// their catalog/fallback value, never jump them to 65536.
+test('invalid env values do not bypass catalog/fallback on low-cap models', () => {
+    withEnvOverride(null, () => {
+        const sonnet46 = resolveMaxTokens('claude-sonnet-4-6');
+        const unknown = resolveMaxTokens('claude-totally-unknown-model-xyz');
+        for (const bad of ['0', '-1', 'garbage', '   ']) {
+            withEnvOverride(bad, () => {
+                assert.equal(resolveMaxTokens('claude-sonnet-4-6'), sonnet46, `env=${JSON.stringify(bad)}`);
+                assert.equal(resolveMaxTokens('claude-totally-unknown-model-xyz'), unknown, `env=${JSON.stringify(bad)}`);
+            });
+        }
+    });
+});
+
+// --- API-key provider (anthropic.mjs) — shares the anthropic-max-tokens.mjs
+// helper and reads the same on-disk anthropic-oauth-models.json catalog.
+
+test('API-key provider: claude-sonnet-5 resolves to 65536 (catalog or fallback)', () => {
+    withEnvOverride(null, () => {
+        assert.equal(resolveMaxTokensApiKey('claude-sonnet-5'), 65536);
+    });
+});
+
+test('API-key provider: claude-sonnet-4-6 stays at legacy 16384 when catalog has no entry', () => {
+    withEnvOverride(null, () => {
+        const result = resolveMaxTokensApiKey('claude-sonnet-4-6');
+        assert.ok(result === 16384 || result >= 16384, `expected >=16384, got ${result}`);
+    });
+});
+
+test('API-key provider: haiku no longer starves visible output at 8192-only ceiling', () => {
+    withEnvOverride(null, () => {
+        const result = resolveMaxTokensApiKey('claude-haiku-4-5-20251001');
+        assert.ok(result >= 8192, `expected >=8192, got ${result}`);
+    });
+});
+
+test('API-key provider: unknown model id falls back to a sane >=8192 value', () => {
+    withEnvOverride(null, () => {
+        const result = resolveMaxTokensApiKey('claude-totally-unknown-model-xyz');
+        assert.equal(typeof result, 'number');
+        assert.ok(Number.isFinite(result));
+        assert.ok(result >= 8192, `expected >=8192, got ${result}`);
+    });
+});
+
+test('API-key provider: MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS=32768 overrides the result', () => {
+    withEnvOverride('32768', () => {
+        assert.equal(resolveMaxTokensApiKey('claude-sonnet-5'), 32768);
+        assert.equal(resolveMaxTokensApiKey('claude-totally-unknown-model-xyz'), 32768);
+    });
+});
+
+test('OAuth and API-key providers agree on fallback heuristic for the same model id', () => {
+    withEnvOverride(null, () => {
+        for (const id of ['claude-opus-4-8', 'claude-sonnet-4-6', 'claude-sonnet-5', 'claude-haiku-4-5-20251001', 'claude-totally-unknown-model-xyz']) {
+            assert.equal(resolveMaxTokens(id), resolveMaxTokensApiKey(id), `mismatch for ${id}`);
+        }
+    });
+});

package/scripts/build-tui.mjs

@@ -44,7 +44,19 @@ await build({
   // Only `ink` is redirected to Mixdog's checked-in renderer instead of
   // node_modules/ink.
   packages: 'external',
-  external: ['../vendor/*', '../../vendor/*'],
+  external: [
+    '../vendor/*',
+    '../../vendor/*',
+    // Voice runtime modules stay external (lazy dynamic imports by design):
+    // voice-runtime-fetcher.mjs resolves its bundled manifest via
+    // import.meta.url ('../data/voice-runtime-manifest.json'), which breaks
+    // when inlined into src/tui/dist/index.mjs (resolves to src/tui/data/).
+    // The '../../runtime/...' specifier is depth-safe: src/tui/lib/* and
+    // src/tui/dist/* are both 2 levels below src/, so the relative path
+    // resolves to src/runtime/channels/lib/* either way.
+    '../../runtime/channels/lib/voice-runtime-fetcher.mjs',
+    '../../runtime/channels/lib/whisper-server.mjs',
+  ],
   plugins: [mixdogInkAliasPlugin],
   logLevel: 'info',
 });

package/scripts/explore-bench.mjs

@@ -0,0 +1,124 @@
+// Explore quality bench — round-based tuning harness.
+//
+// Runs a fixed query set through runExplore against this repo, then reads
+// agent-trace.jsonl to report per-session tool-call counts, wall time, and
+// anchor quality. Usage:
+//   node scripts/explore-bench.mjs [roundLabel]
+// Fresh process per run = no in-memory result cache carryover.
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { runExplore } from '../src/standalone/explore-tool.mjs';
+
+const ROUND = process.argv[2] || 'r0';
+const CWD = 'C:/Project/mixdog';
+
+// Representative locator queries with ground truth: expect = substrings, at
+// least one must appear in the anchor output (quality hit). expectFail = the
+// correct answer is EXPLORATION_FAILED (miss discipline).
+const QUERIES = [
+  {
+    q: 'where is the tool-call stall watchdog policy resolved and what defaults does it use',
+    expect: ['agent-progress-watchdog', 'stall-policy'],
+  },
+  {
+    q: 'session compact / smart compact trigger threshold logic',
+    expect: ['compact'],
+  },
+  {
+    q: 'where are hidden agent tool schema profiles defined (read / read-write-search)',
+    expect: ['agent-dispatch', 'agents.json', 'internal-agents'],
+  },
+  {
+    q: 'recall memory chunk importance scoring implementation',
+    expect: ['importance', 'memory'],
+  },
+  {
+    q: 'websocket reconnect backoff handling',
+    expect: ['openai-oauth-ws', 'retry-classifier'],
+  },
+  // ── extended set: symbol-exact, filename, error-string, korean, flow, config ──
+  {
+    q: 'buildExplorerPrompt definition', // exact known symbol
+    expect: ['explore-tool'],
+  },
+  {
+    q: 'where does the explore tool cache results and what is the TTL',
+    expect: ['explore-tool'],
+  },
+  {
+    q: 'error text "maintenance route unresolved for agent" — where is it thrown',
+    expect: ['agent-dispatch'],
+  },
+  {
+    q: '에이전트 세션의 최대 루프 반복 횟수는 어디서 정해져?', // korean concept query
+    expect: ['agent-loop-policy'],
+  },
+  {
+    q: 'how does a fixed agent slot map to a workflow slot (explore/explorer)',
+    expect: ['mixdog-session-runtime', 'internal-agents'],
+  },
+  {
+    q: 'where is the mixdog config json file path resolved (data dir)',
+    expect: ['config', 'plugin-paths'],
+  },
+  {
+    q: 'GraphQL schema stitching resolver implementation', // not in this repo
+    expectFail: true,
+  },
+];
+
+function tracePath() {
+  return process.env.MIXDOG_AGENT_TRACE_PATH
+    || join(process.env.MIXDOG_DATA_DIR || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data'), 'history', 'agent-trace.jsonl');
+}
+
+function readTraceSince(ts) {
+  const p = tracePath();
+  if (!existsSync(p)) return [];
+  const rows = [];
+  for (const line of readFileSync(p, 'utf8').split('\n')) {
+    if (!line) continue;
+    try {
+      const r = JSON.parse(line);
+      if (r.ts >= ts && r.agent === 'explorer') rows.push(r);
+    } catch { /* skip */ }
+  }
+  return rows;
+}
+
+const t0 = Date.now();
+const results = [];
+for (const { q, expect, expectFail } of QUERIES) {
+  const qt0 = Date.now();
+  const res = await runExplore({ query: q, cwd: CWD }, { callerCwd: CWD });
+  const text = res?.content?.[0]?.text || '';
+  const anchors = text.split('\n').filter((l) => /:\d+/.test(l)).length;
+  const failed = /EXPLORATION_FAILED/.test(text);
+  const lower = text.toLowerCase();
+  const hit = expectFail
+    ? (failed && anchors === 0)
+    : (!failed && (expect || []).some((e) => lower.includes(e.toLowerCase())));
+  results.push({ q: q.slice(0, 48), ms: Date.now() - qt0, anchors, failed, hit, bytes: text.length });
+}
+
+// Attribute tool calls per explorer session spawned during this run.
+const rows = readTraceSince(t0);
+const bySession = new Map();
+for (const r of rows) {
+  if (r.kind !== 'tool') continue;
+  const s = bySession.get(r.session_id) || { calls: 0, tools: [] };
+  s.calls++; s.tools.push(r.tool_name);
+  bySession.set(r.session_id, s);
+}
+const callCounts = [...bySession.values()].map((s) => s.calls).sort((a, b) => a - b);
+const p50 = callCounts[Math.floor(callCounts.length / 2)] ?? 0;
+
+console.log(`\n=== explore-bench round=${ROUND} ===`);
+for (const r of results) {
+  console.log(`  [${String(r.ms).padStart(6)}ms] ${r.hit ? 'HIT ' : 'MISS'} anchors=${r.anchors} failed=${r.failed} bytes=${r.bytes}  ${r.q}`);
+}
+console.log(`  quality: ${results.filter((r) => r.hit).length}/${results.length} hits`);
+console.log(`  sessions=${bySession.size} toolcalls p50=${p50} max=${callCounts[callCounts.length - 1] ?? 0} total=${callCounts.reduce((a, b) => a + b, 0)}`);
+for (const [id, s] of bySession) console.log(`    ${id.slice(-8)}: ${s.tools.join(',')}`);
+console.log(`  wall total=${((Date.now() - t0) / 1000).toFixed(1)}s`);

package/scripts/hook-bus-test.mjs

@@ -328,3 +328,194 @@ console.log(JSON.stringify({ hookSpecificOutput: {
     else process.env.MIXDOG_HOOKS_FILE = prev;
   }
 });
+
+test('mcp_tool handler routes output through parseHandlerOutput', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'shell',
+        hooks: [{ type: 'mcp_tool', server: 'guard', tool: 'check' }],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    let seenName = null;
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      mcpToolRunner: async ({ name }) => {
+        seenName = name;
+        return JSON.stringify({ hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: 'mcp denied',
+        }});
+      },
+    });
+    const denied = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(seenName, 'mcp__guard__check');
+    assert.equal(denied.action, 'deny');
+    assert.match(denied.reason, /mcp denied/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt handler ok:false maps to deny', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'shell',
+        hooks: [{ type: 'prompt', prompt: 'is this safe?' }],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      promptRunner: async () => JSON.stringify({ ok: false, reason: 'unsafe' }),
+    });
+    const denied = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(denied.action, 'deny');
+    assert.match(denied.reason, /unsafe/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('unconfigured prompt/mcp_tool and unsupported agent emit hook:error and skip', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'shell',
+        hooks: [
+          { type: 'prompt', prompt: 'x' },
+          { type: 'mcp_tool', server: 'g', tool: 't' },
+          { type: 'agent', agent: 'a' },
+        ],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({ dataDir: root });
+    const result = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(result, null);
+    const errs = bus.status().recent.filter((e) => e.name === 'hook:error');
+    assert.ok(errs.some((e) => /prompt not configured/.test(e.payload?.error || '')));
+    assert.ok(errs.some((e) => /mcp_tool not configured/.test(e.payload?.error || '')));
+    assert.ok(errs.some((e) => /unsupported hook type: agent/.test(e.payload?.error || '')));
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('setRewakeHandler fires on async child exit code 2', async () => {
+  const root = tempRoot();
+  const hookScript = join(root, 'rewake.mjs');
+  writeFileSync(hookScript, `process.stderr.write('needs rewake'); process.exit(2);`, 'utf8');
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      Stop: [{
+        hooks: [{ type: 'command', command: process.execPath, args: [hookScript], asyncRewake: true }],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({ dataDir: root });
+    const fired = new Promise((resolve) => bus.setRewakeHandler((info) => resolve(info)));
+    await bus.dispatch('Stop', { session_id: 's', cwd: root });
+    const info = await fired;
+    assert.equal(info.eventName, 'Stop');
+    assert.match(info.text, /needs rewake/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt handler plain-text "no" denies', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{ matcher: 'shell', hooks: [{ type: 'prompt', prompt: 'safe?' }] }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({ dataDir: root, promptRunner: async () => 'no' });
+    const denied = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(denied.action, 'deny');
+    assert.match(denied.reason, /no/i);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt handler timeout does not hang and reports error', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{ matcher: 'shell', hooks: [{ type: 'prompt', prompt: 'x', timeout: 0.05 }] }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      promptRunner: () => new Promise(() => {}),
+    });
+    const result = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(result, null);
+    const errs = bus.status().recent.filter((e) => e.name === 'hook:error');
+    assert.ok(errs.some((e) => /timed out/i.test(e.payload?.error || '')));
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt deny uses universal exit-2 path on Stop event', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      Stop: [{ hooks: [{ type: 'prompt', prompt: 'done?' }] }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      promptRunner: async () => JSON.stringify({ ok: false, reason: 'not done' }),
+    });
+    const result = await bus.dispatch('Stop', { session_id: 's', cwd: root });
+    assert.equal(result.blocked, true);
+    assert.match(result.reason, /not done/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});

package/scripts/path-suffix-test.mjs

@@ -0,0 +1,57 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { findBySuffixStrip } from '../src/runtime/agent/orchestrator/tools/builtin/path-diagnostics.mjs';
+
+function makeRepo() {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-suffix-test-'));
+    mkdirSync(join(root, 'src', 'tui'), { recursive: true });
+    writeFileSync(join(root, 'src', 'tui', 'input-editing.mjs'), '// real file\n');
+    mkdirSync(join(root, 'vendor', 'ink', 'build'), { recursive: true });
+    writeFileSync(join(root, 'vendor', 'ink', 'build', 'index.js'), '// vendored\n');
+    return root;
+}
+
+test('resolves a hallucinated absolute prefix to the real repo-relative file', () => {
+    const root = makeRepo();
+    try {
+        const hallucinated = '/Users/danma/Local/Project/ink/src/tui/input-editing.mjs';
+        const hit = findBySuffixStrip(root, hallucinated);
+        assert.equal(hit, 'src/tui/input-editing.mjs');
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('resolves a hallucinated prefix onto a vendor/ path (no skip-dir filtering)', () => {
+    const root = makeRepo();
+    try {
+        const hallucinated = '/Users/danma/Local/Project/vendor/ink/build/index.js';
+        const hit = findBySuffixStrip(root, hallucinated);
+        assert.equal(hit, 'vendor/ink/build/index.js');
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('returns null when no tail length matches a real file', () => {
+    const root = makeRepo();
+    try {
+        const hit = findBySuffixStrip(root, '/Users/danma/Local/Project/does/not/exist.mjs');
+        assert.equal(hit, null);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('a bare basename (1 segment) is never matched', () => {
+    const root = makeRepo();
+    try {
+        const hit = findBySuffixStrip(root, 'input-editing.mjs');
+        assert.equal(hit, null);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});