mixdog 0.9.0 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -45,6 +45,13 @@
     "test:providers": "node --test scripts/provider-toolcall-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",
+    "diag:sessions": "node scripts/session-diag.mjs",
+    "diag:session": "node scripts/session-diag.mjs",
+    "bench:session": "node scripts/session-bench.mjs",
+    "bench:task": "node scripts/task-bench.mjs",
+    "bench:corpus": "node scripts/routing-corpus.mjs",
+    "bench:run": "node scripts/bench-run.mjs",
+    "patch:replay": "node scripts/patch-replay.mjs",
     "build:tui": "node scripts/build-tui.mjs"
   },
   "engines": {
@@ -57,6 +64,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
     "chalk": "^5.6.2",
+    "cli-highlight": "^2.1.11",
     "diff": "^9.0.0",
     "discord.js": "^14.26.4",
     "ink": "^7.1.0",
@@ -72,8 +80,7 @@
     "undici": "^8.5.0",
     "wrap-ansi": "^10.0.0",
     "ws": "^8.21.0",
-    "zod": "^3.25.76",
-    "zod-to-json-schema": "^3.25.2"
+    "zod": "^3.25.76"
   },
   "overrides": {
     "discord.js": {

package/scripts/_bench-cwc.json

@@ -0,0 +1,20 @@
+[
+  {
+    "id": "cwc-hookflow",
+    "agent": "worker",
+    "prompt": "In this repo (mixdog), what happens to a tool call when no hooks are configured? Verify the default observer/bypass path: where beforeTool() is invoked, what it returns with no configured rules, and where a configured custom hook rule could instead deny the call. Give file paths and function names. Do not modify anything.",
+    "cwd": "."
+  },
+  {
+    "id": "cwc-cacheusage",
+    "agent": "worker",
+    "prompt": "In this repo (mixdog), how are cached token counts recorded and surfaced in usage metrics? Find where cached_tokens comes from and how it flows into the usage record. Give file paths and function names. Do not modify anything.",
+    "cwd": "."
+  },
+  {
+    "id": "cwc-compacttrigger",
+    "agent": "worker",
+    "prompt": "In this repo (mixdog), what triggers a context compaction and where is that threshold decided? Trace the trigger condition to the compaction entry point. Give file paths and function names. Do not modify anything.",
+    "cwd": "."
+  }
+]

package/scripts/agent-loop-policy-test.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    resolveSessionMaxLoopIterations,
+    LEAD_MAX_LOOP_ITERATIONS,
+} from '../src/runtime/agent/orchestrator/agent-runtime/agent-loop-policy.mjs';
+
+// No low per-agent caps: every public/delegated agent shares the single high
+// runaway guard (LEAD_MAX_LOOP_ITERATIONS) unless a session pins its own value.
+test('agent owner session falls through to the shared runaway guard when unset', () => {
+    const cap = resolveSessionMaxLoopIterations({
+        owner: 'agent',
+        agent: 'heavy-worker',
+        permission: 'read-write',
+        maxLoopIterations: null,
+    });
+    assert.equal(cap, LEAD_MAX_LOOP_ITERATIONS);
+});
+
+test('lead session keeps the same shared ceiling when unset', () => {
+    assert.equal(resolveSessionMaxLoopIterations({ owner: 'user', agent: null }), LEAD_MAX_LOOP_ITERATIONS);
+});
+
+test('a session-pinned maxLoopIterations is honored', () => {
+    assert.equal(
+        resolveSessionMaxLoopIterations({ owner: 'agent', agent: 'heavy-worker', maxLoopIterations: 4 }),
+        4,
+    );
+});
+
+test('explicit override wins over everything', () => {
+    assert.equal(
+        resolveSessionMaxLoopIterations({ owner: 'agent', agent: 'heavy-worker', maxLoopIterations: 4 }, 50),
+        50,
+    );
+});

package/scripts/agent-parallel-smoke.mjs

@@ -15,6 +15,8 @@
 //      first-response watchdog is explicitly disabled (firstResponseTimeoutMs:0).
 //   5. spawnPrepTimeoutMs:0 disables the prep cap even when an env default cap
 //      is set (explicit per-call override beats the env default).
+//   6. A same-tag retry after a prep timeout cannot be blocked by the original
+//      timed-out prep binding the tag during late provider-init cleanup.
 //
 // Run: node scripts/agent-parallel-smoke.mjs
 import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
@@ -103,7 +105,7 @@ async function fakeAskSession(sessionId, prompt) {
   maxAskConcurrency = Math.max(maxAskConcurrency, askConcurrency);
   try {
     await sleep(300); // each agent's "work" lasts noticeably longer than spawn return
-    return { content: `ack ${session?.role || 'worker'}` };
+    return { content: `ack ${session?.agent || 'worker'}` };
   } finally {
     askConcurrency -= 1;
     if (session) { session.status = 'idle'; session.lastStreamDeltaAt = Date.now(); }
@@ -145,7 +147,7 @@ async function main() {
   const outs = await Promise.all(
     Array.from({ length: batchSize }, (_, i) => agent.execute({
       type: 'spawn',
-      role: i % 2 === 0 ? 'worker' : 'reviewer',
+      agent: i % 2 === 0 ? 'worker' : 'reviewer',
       tag: `par${i}`,
       cwd: root,
       prompt: `parallel task ${i}`,
@@ -176,7 +178,7 @@ async function main() {
   const initBatch = await Promise.all(
     Array.from({ length: 4 }, (_, i) => agent.execute({
       type: 'spawn',
-      role: 'worker',
+      agent: 'worker',
       tag: `init${i}`,
       cwd: root,
       prompt: `init task ${i}`,
@@ -195,14 +197,14 @@ async function main() {
   const callsBeforeChange = initProvidersCalls;
   // Same config first: must be skipped (no new init).
   await waitJob(await agent.execute({
-    type: 'spawn', role: 'worker', tag: 'cfgSame', cwd: root, prompt: 'cfg same',
+    type: 'spawn', agent: 'worker', tag: 'cfgSame', cwd: root, prompt: 'cfg same',
   }, { invocationSource: 'model-tool', cwd: root }), /ack worker/, 'cfg same');
   assert(initProvidersCalls === callsBeforeChange,
     `unchanged config must not re-init; before=${callsBeforeChange} after=${initProvidersCalls}`);
   // Now mutate the provider config and spawn again → must re-init once.
   providerConfig = { 'openai-oauth': { enabled: true, baseUrl: 'https://changed.example' } };
   await waitJob(await agent.execute({
-    type: 'spawn', role: 'worker', tag: 'cfgChanged', cwd: root, prompt: 'cfg changed',
+    type: 'spawn', agent: 'worker', tag: 'cfgChanged', cwd: root, prompt: 'cfg changed',
   }, { invocationSource: 'model-tool', cwd: root }), /ack worker/, 'cfg changed');
   assert(initProvidersCalls === callsBeforeChange + 1,
     `config change must trigger exactly one re-init; before=${callsBeforeChange} after=${initProvidersCalls}`);
@@ -267,7 +269,7 @@ async function main() {
   // Fire A (slow), then B and C back-to-back while A is still running. B is
   // superseded by C before A's chain link releases.
   const aOut = await raceAgent.execute({
-    type: 'spawn', role: 'worker', tag: 'raceA', cwd: raceRoot, prompt: 'race A',
+    type: 'spawn', agent: 'worker', tag: 'raceA', cwd: raceRoot, prompt: 'race A',
     spawnPrepTimeoutMs: 0, // testing init serialization, not the prep cap
   }, { invocationSource: 'model-tool', cwd: raceRoot });
   // Let A's deferred job reach ensureProvider and START its slow (200ms) init,
@@ -277,12 +279,12 @@ async function main() {
   await sleep(60);
   raceConfig = { providers: { 'openai-oauth': { enabled: true, baseUrl: 'gen-b' } } };
   const bOut = await raceAgent.execute({
-    type: 'spawn', role: 'worker', tag: 'raceB', cwd: raceRoot, prompt: 'race B',
+    type: 'spawn', agent: 'worker', tag: 'raceB', cwd: raceRoot, prompt: 'race B',
     spawnPrepTimeoutMs: 0,
   }, { invocationSource: 'model-tool', cwd: raceRoot });
   raceConfig = { providers: { 'openai-oauth': { enabled: true, baseUrl: 'gen-c' } } };
   const cOut = await raceAgent.execute({
-    type: 'spawn', role: 'worker', tag: 'raceC', cwd: raceRoot, prompt: 'race C',
+    type: 'spawn', agent: 'worker', tag: 'raceC', cwd: raceRoot, prompt: 'race C',
     spawnPrepTimeoutMs: 0,
   }, { invocationSource: 'model-tool', cwd: raceRoot });
   await Promise.all([
@@ -325,7 +327,7 @@ async function main() {
   const wedgeStart = Date.now();
   const wedged = await hangAgent.execute({
     type: 'spawn',
-    role: 'worker',
+    agent: 'worker',
     tag: 'wedge1',
     cwd: hangRoot,
     prompt: 'wedge prep',
@@ -341,6 +343,48 @@ async function main() {
   try { hangAgent.closeAll('agent-parallel-smoke-hang-end'); } catch {}
   rmSync(hangRoot, { recursive: true, force: true });
 
+  // --- 4b: same-tag retry after prep timeout must not race late bind/cleanup ---
+  const retryRoot = mkdtempSync(join(tmpdir(), 'mixdog-agent-retry-prep-'));
+  const retryDataDir = join(retryRoot, '.mixdog-data');
+  mkdirSync(retryDataDir, { recursive: true });
+  let releaseRetryInit;
+  const retryInitGate = new Promise((resolve) => { releaseRetryInit = resolve; });
+  let retryInitCalls = 0;
+  const retryReg = {
+    getProvider() { return undefined; }, // force every spawn through shared init
+    async initProviders(config) {
+      retryInitCalls += 1;
+      await retryInitGate;
+      return realInitProviders({ 'openai-oauth': { enabled: true }, ...config });
+    },
+  };
+  const retryAgent = createStandaloneAgent({ cfgMod, reg: retryReg, mgr, dataDir: retryDataDir, cwd: retryRoot });
+  const retryFirst = await retryAgent.execute({
+    type: 'spawn',
+    agent: 'worker',
+    tag: 'retrySameTag',
+    cwd: retryRoot,
+    prompt: 'retry first should timeout before provider init releases',
+    spawnPrepTimeoutMs: 50,
+  }, { invocationSource: 'model-tool', cwd: retryRoot });
+  await waitJob(retryFirst, /timed out|status: failed/, 'same-tag first prep timeout', 20);
+  assert(retryInitCalls === 1, `first retry spawn should start one gated init; calls=${retryInitCalls}`);
+  const retrySecond = await retryAgent.execute({
+    type: 'spawn',
+    agent: 'worker',
+    tag: 'retrySameTag',
+    cwd: retryRoot,
+    prompt: 'retry second should succeed after init releases',
+    spawnPrepTimeoutMs: 0,
+  }, { invocationSource: 'model-tool', cwd: retryRoot });
+  assert(/agent task:/.test(retrySecond), `same-tag retry should return a task: ${retrySecond}`);
+  await sleep(30); // let the retry join the gated provider init before release
+  releaseRetryInit();
+  const retrySecondResult = await waitJob(retrySecond, /ack worker/, 'same-tag retry success', 60);
+  assert(!/already exists/i.test(retrySecondResult), `same-tag retry hit stale bind: ${retrySecondResult}`);
+  try { retryAgent.closeAll('agent-parallel-smoke-retry-end'); } catch {}
+  rmSync(retryRoot, { recursive: true, force: true });
+
   // --- 5: spawnPrepTimeoutMs:0 disables the prep cap even when an env default
   // is set. The module captured ENV_PREP_CAP_MS (150ms) at load. A prep step
   // that runs longer than that (300ms) would normally be aborted by the env
@@ -362,7 +406,7 @@ async function main() {
   const slowStart = Date.now();
   const slowOut = await slowAgent.execute({
     type: 'spawn',
-    role: 'worker',
+    agent: 'worker',
     tag: 'slowprep1',
     cwd: slowRoot,
     prompt: 'slow prep override',

package/scripts/background-task-meta-smoke.mjs

@@ -11,7 +11,7 @@ const task = registerBackgroundTask({
   label: 'smoke',
   meta: {
     tag: 'w1',
-    role: 'worker',
+    agent: 'worker',
     firstResponseTimeoutMs: 30_000,
     idleTimeoutMs: 120_000,
     spawnPrepTimeoutMs: 90_000,

package/scripts/bench-run.mjs

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+// bench-run.mjs — repeatable internal A/B bench runner (mixdog).
+//
+// Runs a FIXED task set through the LIVE headless path (runHeadlessRole in a
+// fresh child node process = identical to `mixdog <agent> <msg>` and loads the
+// latest on-disk code), captures each task's session id, scores the round with
+// task-bench, and freezes it to a round file. Change rules/briefs between
+// rounds; the task set stays constant so rounds are comparable.
+//
+//   node scripts/bench-run.mjs --tasks tasks.json --round 1 --save round1.json
+//   (edit rules/briefs)
+//   node scripts/bench-run.mjs --tasks tasks.json --round 2 --save round2.json
+//   node scripts/task-bench.mjs --vs round1.json round2.json
+//
+// tasks.json: [{ "id":"...", "agent":"worker", "prompt":"...", "cwd":"." }, ...]
+//
+// This is INTERNAL A/B only (mixdog vs its own prior round). Cross-CLI compare
+// vs codex/claude (tree-total vs solo) is a separate future mode; codex/claude
+// runners are left as slots.
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __dir = dirname(fileURLToPath(import.meta.url));
+const HEADLESS = pathToFileURL(resolve(__dir, '../src/headless-role.mjs')).href;
+const TASK_BENCH = resolve(__dir, 'task-bench.mjs');
+
+function argValue(name, fallback = null) {
+  const idx = process.argv.indexOf(name);
+  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
+  const pref = `${name}=`;
+  const hit = process.argv.find((a) => a.startsWith(pref));
+  return hit ? hit.slice(pref.length) : fallback;
+}
+function hasFlag(name) { return process.argv.includes(name); }
+
+// Model aliases so a round switches model+provider with one flag
+// (--model opus|gpt|grok). Full provider/model pairs still work verbatim.
+const MODEL_ALIASES = {
+  opus:   { provider: 'anthropic-oauth', model: 'claude-opus-4-8' },
+  sonnet: { provider: 'anthropic-oauth', model: 'claude-sonnet-5' },
+  gpt:    { provider: 'openai-oauth', model: 'gpt-5.5' },
+  'gpt-5.5': { provider: 'openai-oauth', model: 'gpt-5.5' },
+  grok:   { provider: 'grok-oauth', model: 'grok-composer-2.5-fast' },
+};
+function resolveModelOpts(modelArg, providerArg) {
+  const key = String(modelArg || '').trim().toLowerCase();
+  if (MODEL_ALIASES[key] && !providerArg) return { ...MODEL_ALIASES[key] };
+  return { provider: providerArg || null, model: modelArg || null };
+}
+
+function extractSessionId(text) {
+  const s = String(text || '');
+  const m = s.match(/sessionId:\s*(sess_[A-Za-z0-9_]+)/) || s.match(/\b(sess_[A-Za-z0-9_]+)/);
+  return m ? m[1] : null;
+}
+
+const RUNNERS = {
+  mixdog(task, opts) {
+    const driver = [
+      `import { runHeadlessRole } from ${JSON.stringify(HEADLESS)};`,
+      `const out = [];`,
+      `const code = await runHeadlessRole({`,
+      `  agent: ${JSON.stringify(task.agent || 'worker')},`,
+      `  message: ${JSON.stringify(task.prompt || '')},`,
+      `  provider: ${JSON.stringify(opts.provider || null)},`,
+      `  model: ${JSON.stringify(opts.model || null)},`,
+      `  cwd: ${JSON.stringify(task.cwd ? resolve(task.cwd) : process.cwd())},`,
+      `  write: (t) => out.push(t),`,
+      `  writeErr: (t) => process.stderr.write(t),`,
+      `});`,
+      `process.stdout.write(out.join(''));`,
+      `process.exit(code);`,
+    ].join('\n');
+    const started = Date.now();
+    let raw = '';
+    let ok = false;
+    try {
+      raw = execFileSync('node', ['--input-type=module', '-e', driver], {
+        encoding: 'utf8',
+        maxBuffer: 64 * 1024 * 1024,
+        env: {
+          ...process.env,
+          ...(opts.effort ? { MIXDOG_AGENT_EFFORT: opts.effort } : {}),
+          ...(opts.fast ? { MIXDOG_AGENT_FAST: '1' } : {}),
+          ...(opts.env || {}),
+        },
+      });
+      ok = true;
+    } catch (e) {
+      raw = String(e.stdout || '') + String(e.stderr || '');
+      ok = false;
+    }
+    return { sessionId: extractSessionId(raw), ok, ms: Date.now() - started, raw };
+  },
+  codex() {
+    throw new Error('runner "codex" not implemented (slot: codex exec --json). Cross-CLI compare is a separate mode.');
+  },
+  claude() {
+    throw new Error('runner "claude" not implemented (slot: claude -p --output-format json). Cross-CLI compare is a separate mode.');
+  },
+};
+
+function scoreSessions(ids) {
+  if (!ids.length) return null;
+  const raw = execFileSync('node', [TASK_BENCH, '--session', ids.join(','), '--group', '--json'], {
+    encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
+  });
+  const s = raw.replace(/^\uFEFF/, '');
+  const i = s.indexOf('{');
+  return JSON.parse(i >= 0 ? s.slice(i) : s);
+}
+
+function sleepMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.max(0, ms));
+}
+
+function scoreSession(sessionId, { attempts = 5 } = {}) {
+  let lastError = null;
+  for (let i = 0; i < attempts; i += 1) {
+    try {
+      const raw = execFileSync('node', [TASK_BENCH, '--session', sessionId, '--json'], {
+        encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
+      });
+      const s = raw.replace(/^\uFEFF/, '');
+      const j = JSON.parse(s.slice(Math.max(0, s.indexOf('{'))));
+      const card = Array.isArray(j.cards) ? j.cards.find((c) => c?.session === sessionId) || j.cards[0] : null;
+      if (card) return { ok: true, card };
+      lastError = new Error(`no scorecard returned for ${sessionId}`);
+    } catch (e) {
+      lastError = e;
+    }
+    sleepMs(250 * (i + 1));
+  }
+  return { ok: false, error: lastError?.message || String(lastError || 'score failed') };
+}
+
+function num(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : 0;
+}
+
+function averageCards(cards) {
+  if (!cards.length) return null;
+  const keys = Object.keys(cards[0]).filter((k) => cards.some((c) => typeof c[k] === 'number' && Number.isFinite(c[k])));
+  const out = { n: cards.length };
+  for (const k of keys) {
+    const vals = cards.map((c) => num(c[k]));
+    out[k] = Math.round((vals.reduce((a, b) => a + b, 0) / vals.length) * 10) / 10;
+  }
+  return out;
+}
+
+// ---- main ----
+const tasksPath = argValue('--tasks', null);
+if (!tasksPath) {
+  console.error('usage: --tasks <tasks.json> [--round N] [--runner mixdog] [--provider P] [--model M] [--effort E] [--fast] [--save round.json] [--json]');
+  process.exit(1);
+}
+if (!existsSync(resolve(tasksPath))) { console.error(`tasks file not found: ${tasksPath}`); process.exit(1); }
+const tasks = JSON.parse(readFileSync(resolve(tasksPath), 'utf8'));
+if (!Array.isArray(tasks) || !tasks.length) { console.error('tasks.json must be a non-empty array'); process.exit(1); }
+
+const runnerName = argValue('--runner', 'mixdog');
+const runner = RUNNERS[runnerName];
+if (!runner) { console.error(`unknown runner "${runnerName}" (mixdog|codex|claude)`); process.exit(1); }
+const round = argValue('--round', '1');
+const savePath = argValue('--save', null);
+const jsonMode = hasFlag('--json');
+const _mo = resolveModelOpts(argValue('--model', null), argValue('--provider', null));
+// A/B knobs -> child env. --read-max-lines is a convenience for the read-policy
+// bench; --env KEY=VAL (repeatable) passes any override verbatim.
+const _env = {};
+const _readMax = argValue('--read-max-lines', null);
+if (_readMax) _env.MIXDOG_READ_MAX_LINES = String(_readMax);
+for (let i = 0; i < process.argv.length; i++) {
+  if (process.argv[i] === '--env' && process.argv[i + 1]) {
+    const eq = process.argv[i + 1].indexOf('=');
+    if (eq > 0) _env[process.argv[i + 1].slice(0, eq)] = process.argv[i + 1].slice(eq + 1);
+  }
+}
+const opts = {
+  provider: _mo.provider,
+  model: _mo.model,
+  effort: argValue('--effort', null),
+  fast: hasFlag('--fast'),
+  env: _env,
+};
+process.stderr.write(`[bench-run] model=${opts.model || '(agent default)'} provider=${opts.provider || '(agent default)'} effort=${opts.effort || '-'} fast=${opts.fast} env=${JSON.stringify(_env)}\n`);
+
+const results = [];
+for (const task of tasks) {
+  process.stderr.write(`[bench-run] round=${round} runner=${runnerName} task=${task.id || task.agent} ...\n`);
+  let r;
+  try { r = runner(task, opts); }
+  catch (e) { console.error(`[bench-run] runner error: ${e.message}`); process.exit(1); }
+  process.stderr.write(`[bench-run]   -> ${r.ok ? 'ok' : 'FAIL'} ${Math.round(r.ms / 1000)}s session=${r.sessionId || '(none)'}\n`);
+  const result = { id: task.id || null, agent: task.agent || null, ok: r.ok, ms: r.ms, sessionId: r.sessionId };
+  if (r.sessionId) {
+    const scored = scoreSession(r.sessionId);
+    if (scored.ok) {
+      result.card = scored.card;
+      process.stderr.write(`[bench-run]   -> scored ${r.sessionId.slice(0, 22)} turns=${scored.card.turns} tools=${scored.card.tool_calls}\n`);
+    } else {
+      result.scoreError = scored.error;
+      process.stderr.write(`[bench-run]   -> SCORE FAIL ${r.sessionId.slice(0, 22)} ${scored.error}\n`);
+    }
+  }
+  results.push(result);
+}
+
+const sessionIds = results.map((r) => r.sessionId).filter(Boolean);
+const scoredCards = results.map((r) => r.card).filter(Boolean);
+const scoreErrors = results
+  .filter((r) => !r.card)
+  .map((r) => ({ id: r.id, sessionId: r.sessionId || null, error: r.sessionId ? (r.scoreError || 'missing scorecard') : 'missing sessionId' }));
+const score = scoredCards.length ? { cards: scoredCards, group: averageCards(scoredCards.map(({ session, ...c }) => c)) } : null;
+const completed = results.filter((r) => r.ok).length;
+const taskErrors = results
+  .filter((r) => !r.ok)
+  .map((r) => ({ id: r.id, sessionId: r.sessionId || null, error: 'task failed' }));
+const roundResult = {
+  round, runner: runnerName, opts,
+  tasks: results.length, completed,
+  completion_rate: results.length ? Math.round((completed / results.length) * 100) : 0,
+  sessions: sessionIds, results,
+  task_complete: results.length > 0 && completed === results.length,
+  task_errors: taskErrors,
+  score_complete: results.length > 0 && taskErrors.length === 0 && scoreErrors.length === 0 && (score?.cards?.length || 0) === results.length,
+  score_errors: scoreErrors,
+  group: score?.group || null,
+  cards: score?.cards || null,
+};
+
+if (roundResult.task_complete === false) {
+  console.error(`[bench-run] incomplete tasks: completed=${completed}/${results.length}`);
+  for (const e of taskErrors) console.error(`[bench-run] task error ${e.id || '-'} ${e.sessionId || '(no session)'}`);
+}
+if (roundResult.score_complete === false) {
+  console.error(`[bench-run] incomplete scoring: scored=${roundResult.cards?.length || 0}/${results.length}`);
+  for (const e of scoreErrors) console.error(`[bench-run] score error ${e.id || '-'} ${e.sessionId || '(no session)'}: ${e.error}`);
+}
+if (savePath) {
+  if (roundResult.task_complete === false || roundResult.score_complete === false) {
+    console.error(`[bench-run] not saving incomplete round -> ${resolve(savePath)}`);
+  } else {
+  writeFileSync(resolve(savePath), JSON.stringify(roundResult, null, 2));
+  console.error(`[bench-run] saved round ${round} -> ${resolve(savePath)}`);
+  }
+}
+if (jsonMode) {
+  console.log(JSON.stringify(roundResult, null, 2));
+} else {
+  console.log(`round=${round} runner=${runnerName} tasks=${results.length} completed=${completed} (${roundResult.completion_rate}%)`);
+  for (const r of results) console.log(`- ${r.id || r.agent}: ${r.ok ? 'ok' : 'FAIL'} ${Math.round(r.ms / 1000)}s ${r.sessionId ? r.sessionId.slice(0, 22) : '(no session)'}`);
+  if (roundResult.group) {
+    const g = roundResult.group;
+    console.log(`group: wall=${Math.round((g.wall_ms || 0) / 1000)}s turns=${g.turns} tools=${g.tool_calls} tpt=${g.tools_per_turn} tool_ms=${Math.round((g.total_tool_ms || 0) / 1000)}s cache=${Math.round((g.cache_ratio || 0) * 100)}% antipatterns=${g.antipatterns}`);
+  }
+}
+if (roundResult.task_complete === false || roundResult.score_complete === false) process.exit(1);

package/scripts/compact-smoke.mjs

@@ -92,6 +92,18 @@ assert(semanticForced.semantic === true && semanticCalls === 1, 'forced semantic
 assert(semanticForced.compactType === COMPACT_TYPE_SEMANTIC, 'semantic compact should report compact type 1');
 assert(findSummary(semanticForced.messages), 'forced semantic compact should insert an anchored summary');
 
+let wholeTranscriptForcedCalls = 0;
+const wholeTranscriptProvider = {
+  name: 'whole-transcript-forced-smoke',
+  async send() {
+    wholeTranscriptForcedCalls += 1;
+    return { content: '## Goal\n- continue whole-transcript forced compact\n\n## Constraints & Preferences\n- (none)\n\n## Progress\n### Done\n- oldest turn summarized\n\n### In Progress\n- (none)\n\n### Blocked\n- (none)\n\n## Key Decisions\n- (none)\n\n## Next Steps\n- continue\n\n## Critical Context\n- compact.mjs\n\n## Relevant Files\n- compact.mjs' };
+  },
+};
+const wholeTranscriptForced = await semanticCompactMessages(wholeTranscriptProvider, semanticMessages, 'fake-model', 5_000, { force: true });
+assert(wholeTranscriptForced.semantic === true && wholeTranscriptForcedCalls === 1, 'forced semantic compact must summarize when tail budget would preserve the whole live transcript (default tailTurns)');
+assert(findSummary(wholeTranscriptForced.messages), 'whole-transcript forced semantic compact should insert an anchored summary');
+
 assert(normalizeCompactType('type1') === COMPACT_TYPE_SEMANTIC, 'type1 should resolve to semantic compact');
 assert(normalizeCompactType('recall-fasttrack') === COMPACT_TYPE_RECALL_FASTTRACK, 'type2 should resolve to recall fast-track compact');
 // Alias parity: snake_case + dash + no-dash spellings of fast-track must all

package/scripts/compact-trigger-migration-smoke.mjs

@@ -7,10 +7,16 @@ import {
   _compactTriggerForSession as compactTriggerForSession,
   _preserveBufferConfigFields as preserveBufferConfigFields,
 } from '../src/runtime/agent/orchestrator/session/manager.mjs';
-import { _autoCompactTokenLimit as routeMetaAutoCompactTokenLimit } from '../src/vendor/statusline/src/gateway/route-meta.mjs';
+import {
+  _autoCompactTokenLimit as routeMetaAutoCompactTokenLimit,
+  autoCompactWindowForRoute,
+  compactBoundaryDenominator,
+  summarizeGatewayUsage,
+} from '../src/vendor/statusline/src/gateway/route-meta.mjs';
 import {
   _routeContextMeta as routeContextMeta,
   _resolveStatusAutoCompactTokenLimit as resolveStatusAutoCompactTokenLimit,
+  compactBoundaryForStatus,
 } from '../src/vendor/statusline/bin/statusline-route.mjs';
 
 function assert(condition, message) {
@@ -184,4 +190,64 @@ function assert(condition, message) {
     `status: configured explicit limit should surface, got ${configuredExplicit}`);
 }
 
+// 10) Boundary / window denominators ignore autoCompactTokenLimit (trigger-only).
+{
+  const boundary = 200000;
+  const trigger = 150000;
+  const route = {
+    contextWindow: boundary,
+    compactBoundaryTokens: boundary,
+    rawContextWindow: boundary,
+    autoCompactTokenLimit: trigger,
+  };
+  assert(compactBoundaryForStatus(route) === boundary,
+    `status boundary should be ${boundary}, got ${compactBoundaryForStatus(route)}`);
+  assert(compactBoundaryForStatus({ contextWindow: boundary, autoCompactTokenLimit: trigger }) === boundary,
+    `status boundary should use contextWindow ${boundary}, got ${compactBoundaryForStatus({ contextWindow: boundary, autoCompactTokenLimit: trigger })}`);
+  assert(autoCompactWindowForRoute({ contextWindow: boundary, autoCompactTokenLimit: trigger }) === boundary,
+    `route compact window should be ${boundary}, got ${autoCompactWindowForRoute({ contextWindow: boundary, autoCompactTokenLimit: trigger })}`);
+  const trig = compactTriggerForSession({ autoCompactTokenLimit: trigger, compaction: {} }, boundary);
+  assert(trig === trigger, `trigger resolver should stay ${trigger}, got ${trig}`);
+}
+
+// 11) Boundary fallback order and compact boundary fields.
+{
+  const context = 200000;
+  const smallerBudget = 150000;
+  assert(
+    compactBoundaryForStatus({ contextWindow: context }, { budgetWindow: smallerBudget, compactLimitTokens: smallerBudget }) === context,
+    `contextWindow ${context} must win over smaller budgetWindow ${smallerBudget}`,
+  );
+  assert(
+    compactBoundaryDenominator({ contextWindow: context }, { budgetWindow: smallerBudget }) === context,
+    `route denominator: contextWindow must win over budgetWindow`,
+  );
+  assert(
+    compactBoundaryForStatus({ contextWindow: context }, { boundaryTokens: 180000 }) === 180000,
+    'compact.boundaryTokens should be honored',
+  );
+  assert(
+    compactBoundaryForStatus({ contextWindow: context }, { compactBoundaryTokens: 190000 }) === 190000,
+    'compact.compactBoundaryTokens should be honored',
+  );
+  assert(
+    compactBoundaryForStatus({ boundaryTokens: 175000, contextWindow: context }, { budgetWindow: smallerBudget }) === 175000,
+    'routeInfo.boundaryTokens should be honored',
+  );
+  const withLimitOnly = compactBoundaryForStatus(
+    { contextWindow: context, autoCompactTokenLimit: smallerBudget },
+    { compactLimitTokens: smallerBudget, budgetWindow: smallerBudget },
+  );
+  assert(withLimitOnly === context,
+    `compactLimitTokens/budget must not shrink boundary; expected ${context}, got ${withLimitOnly}`);
+  const usage = summarizeGatewayUsage(
+    { provider: 'openai-oauth', model: 'gpt-5.5', contextWindow: context },
+    { usage: { inputTokens: 1, outputTokens: 1 } },
+    { boundaryTokens: 180000, budgetWindow: smallerBudget, compactLimitTokens: smallerBudget, afterTokens: 90000 },
+    1,
+  );
+  assert(usage.contextUsedPct === 50,
+    `gateway usage pct should use compact.boundaryTokens denominator 180000; got ${usage.contextUsedPct}`);
+}
+
 process.stdout.write('compact-trigger-migration smoke passed ✓\n');