mixdog 0.9.62 → 0.9.64

package/scripts/agent-terminal-reap-test.mjs

@@ -1,252 +0,0 @@
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import {
-  AUTO_CLEAR_PROVIDER_IDLE_MS,
-  resolveAgentTerminalReapMs,
-} from '../src/session-runtime/config-helpers.mjs';
-
-const root = mkdtempSync(join(tmpdir(), 'mixdog-agent-terminal-reap-'));
-process.env.MIXDOG_DATA_DIR = root;
-process.env.MIXDOG_AGENT_TERMINAL_REAP_MS = '1';
-
-function assertEqual(actual, expected, label) {
-  assert.equal(actual, expected, `${label}: expected ${expected}, got ${actual}`);
-}
-
-try {
-  const builtIns = Object.entries(AUTO_CLEAR_PROVIDER_IDLE_MS).filter(([provider]) => provider !== 'default');
-  for (const [provider, idleMs] of builtIns) {
-    assertEqual(resolveAgentTerminalReapMs({ autoClear: {} }, provider), idleMs, `${provider} built-in`);
-  }
-
-  const overrideConfig = {
-    autoClear: {
-      idleMs: 12 * 60 * 60 * 1000,
-      providerIdleMs: { 'openai-oauth': 60_000, default: 90_000, unlisted: 60_000 },
-    },
-  };
-  assertEqual(resolveAgentTerminalReapMs(overrideConfig, 'openai-oauth'), 60_000, 'provider override');
-  assertEqual(
-    resolveAgentTerminalReapMs(overrideConfig, 'anthropic'),
-    AUTO_CLEAR_PROVIDER_IDLE_MS.anthropic,
-    'global idleMs and default row are ignored for listed providers',
-  );
-  assert.equal(resolveAgentTerminalReapMs(overrideConfig, 'default'), 90_000, 'default row applies to default provider');
-  assert.equal(resolveAgentTerminalReapMs(overrideConfig, 'unlisted'), 90_000, 'default row applies to unlisted provider');
-  assert.equal(resolveAgentTerminalReapMs({ autoClear: {} }, 'unknown'), AUTO_CLEAR_PROVIDER_IDLE_MS.default, 'unknown provider uses built-in default');
-
-  mkdirSync(join(root, 'sessions'), { recursive: true });
-  writeFileSync(join(root, 'mixdog-config.json'), JSON.stringify({
-    agent: { autoClear: overrideConfig.autoClear },
-  }));
-  const {
-    deleteSession,
-    markSessionClosed,
-    saveSession,
-    sweepStaleSessions,
-  } = await import('../src/runtime/agent/orchestrator/session/store.mjs');
-  const old = Date.now() - 181_000;
-  const known = {
-    id: 'sess_known_reap',
-    owner: 'agent',
-    status: 'idle',
-    provider: 'openai-oauth',
-    createdAt: old,
-    updatedAt: old,
-    messages: [],
-  };
-  const shortOverride = {
-    id: 'sess_short_override',
-    owner: 'agent',
-    status: 'idle',
-    provider: 'openai-oauth',
-    createdAt: Date.now() - 120_000,
-    updatedAt: Date.now() - 120_000,
-    messages: [],
-  };
-  const unknown = {
-    id: 'sess_unknown_keep',
-    owner: 'agent',
-    status: 'idle',
-    provider: 'unlisted',
-    createdAt: old,
-    updatedAt: old,
-    messages: [],
-  };
-  writeFileSync(join(root, 'sessions', `${known.id}.json`), JSON.stringify(known));
-  writeFileSync(join(root, 'sessions', `${shortOverride.id}.json`), JSON.stringify(shortOverride));
-  writeFileSync(join(root, 'sessions', `${unknown.id}.json`), JSON.stringify(unknown));
-  for (const id of [known.id, unknown.id]) utimesSync(join(root, 'sessions', `${id}.json`), old / 1000, old / 1000);
-  utimesSync(join(root, 'sessions', `${shortOverride.id}.json`), shortOverride.updatedAt / 1000, shortOverride.updatedAt / 1000);
-  const defaultSweep = sweepStaleSessions({ retainOpenSessions: false });
-  assert.ok(
-    defaultSweep.details.some((detail) => detail.id === shortOverride.id),
-    'short provider override bypasses the default sweep freshness gate',
-  );
-  assert.ok(defaultSweep.details.some((detail) => detail.id === known.id), 'store reaps a listed provider at its Advanced duration');
-  assert.ok(defaultSweep.details.some((detail) => detail.id === unknown.id), 'store reaps an unlisted provider at the default duration');
-
-  const locallyLive = {
-    ...known,
-    id: 'sess_locally_live_keep',
-  };
-  writeFileSync(join(root, 'sessions', `${locallyLive.id}.json`), JSON.stringify(locallyLive));
-  utimesSync(join(root, 'sessions', `${locallyLive.id}.json`), old / 1000, old / 1000);
-  const protectedSweep = sweepStaleSessions({
-    retainOpenSessions: false,
-    isSessionLive: (id) => id === locallyLive.id,
-  });
-  assert.ok(!protectedSweep.details.some((detail) => detail.id === locallyLive.id), 'store does not reap a locally live stale session');
-  assert.notEqual(JSON.parse(readFileSync(join(root, 'sessions', `${locallyLive.id}.json`), 'utf8')).closed, true);
-  const settledSweep = sweepStaleSessions({ retainOpenSessions: false });
-  assert.ok(settledSweep.details.some((detail) => detail.id === locallyLive.id), 'store reaps the session once local work settles');
-
-  const heartbeatRace = {
-    ...known,
-    id: 'sess_heartbeat_race_keep',
-  };
-  const heartbeatRacePath = join(root, 'sessions', `${heartbeatRace.id}.json`);
-  writeFileSync(heartbeatRacePath, JSON.stringify(heartbeatRace));
-  utimesSync(heartbeatRacePath, old / 1000, old / 1000);
-  let livenessChecks = 0;
-  const heartbeatRaceSweep = sweepStaleSessions({
-    retainOpenSessions: false,
-    isSessionLive: (id) => {
-      if (id !== heartbeatRace.id) return false;
-      livenessChecks++;
-      if (livenessChecks === 3) {
-        writeFileSync(join(root, 'sessions', `${id}.hb`), '');
-      }
-      return false;
-    },
-  });
-  assert.ok(livenessChecks >= 3, 'store performs the final runtime probe before taking the close lock');
-  assert.ok(!heartbeatRaceSweep.details.some((detail) => detail.id === heartbeatRace.id), 'heartbeat landing before the locked re-stat vetoes close');
-  assert.notEqual(JSON.parse(readFileSync(heartbeatRacePath, 'utf8')).closed, true);
-
-  const retentionHeartbeat = {
-    ...known,
-    id: 'sess_retention_heartbeat_keep',
-    createdAt: Date.now() - 1_000,
-    updatedAt: Date.now() - 1_000,
-  };
-  const retentionPath = join(root, 'sessions', `${retentionHeartbeat.id}.json`);
-  writeFileSync(retentionPath, JSON.stringify(retentionHeartbeat));
-  let retentionLivenessChecks = 0;
-  const retentionSweep = sweepStaleSessions({
-    ttlMs: 60_000,
-    openMaxAgeMs: 24 * 60 * 60 * 1000,
-    openMaxCount: 0,
-    isSessionLive: (id) => {
-      if (id !== retentionHeartbeat.id) return false;
-      retentionLivenessChecks++;
-      if (retentionLivenessChecks === 2) {
-        writeFileSync(join(root, 'sessions', `${id}.hb`), '');
-      }
-      return false;
-    },
-  });
-  assert.ok(retentionLivenessChecks >= 2, 'retention performs its runtime probe before taking the delete lock');
-  assert.ok(!retentionSweep.openPrunedDetails.some((detail) => detail.id === retentionHeartbeat.id), 'commit-edge heartbeat vetoes retention hard-delete');
-  assert.ok(existsSync(retentionPath), 'heartbeating retention candidate survives');
-
-  const pendingClose = { ...known, id: 'sess_vetoed_close_pending', messages: [] };
-  const pendingDelete = { ...known, id: 'sess_vetoed_delete_pending', messages: [] };
-  for (const session of [pendingClose, pendingDelete]) {
-    writeFileSync(join(root, 'sessions', `${session.id}.json`), JSON.stringify(session));
-    saveSession({ ...session, messages: [{ role: 'user', content: 'pending save survived' }] });
-  }
-  assert.equal(markSessionClosed(pendingClose.id, 'idle-sweep', { isSessionLive: () => true }), null);
-  assert.equal(deleteSession(pendingDelete.id, { isSessionLive: () => true }), false);
-  await new Promise((resolve) => setTimeout(resolve, 250));
-  for (const session of [pendingClose, pendingDelete]) {
-    const saved = JSON.parse(readFileSync(join(root, 'sessions', `${session.id}.json`), 'utf8'));
-    assert.equal(saved.messages[0]?.content, 'pending save survived', 'veto leaves debounce persistence intact');
-    assert.notEqual(saved.closed, true);
-  }
-
-  const {
-    _clearSessionRuntime,
-    _getRuntimeEntry,
-    markSessionAskStart,
-  } = await import('../src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs');
-  const {
-    _finalizeSweptSessionRuntime,
-    _runCleanupCycle,
-  } = await import('../src/runtime/agent/orchestrator/session/manager/idle-cleanup.mjs');
-
-  const busy = {
-    ...known,
-    id: 'sess_unrelated_busy_keep',
-    status: 'running',
-  };
-  const terminalDuringBusy = {
-    ...known,
-    id: 'sess_terminal_during_busy_reap',
-  };
-  for (const session of [busy, terminalDuringBusy]) {
-    const path = join(root, 'sessions', `${session.id}.json`);
-    writeFileSync(path, JSON.stringify(session));
-    utimesSync(path, old / 1000, old / 1000);
-  }
-  markSessionAskStart(busy.id);
-  const busyEntry = _getRuntimeEntry(busy.id);
-  busyEntry.controller = new AbortController();
-  _runCleanupCycle();
-  assert.notEqual(JSON.parse(readFileSync(join(root, 'sessions', `${busy.id}.json`), 'utf8')).closed, true, 'unrelated busy runtime survives idle cleanup');
-  assert.equal(JSON.parse(readFileSync(join(root, 'sessions', `${terminalDuringBusy.id}.json`), 'utf8')).closed, true, 'terminal session is reaped while unrelated runtime is busy');
-
-  const postScanRaceId = 'sess_post_scan_active_veto';
-  markSessionAskStart(postScanRaceId);
-  const postScanEntry = _getRuntimeEntry(postScanRaceId);
-  postScanEntry.controller = new AbortController();
-  assert.equal(_finalizeSweptSessionRuntime({ id: postScanRaceId }), false, 'post-scan activity vetoes runtime cleanup');
-  assert.equal(postScanEntry.controller.signal.aborted, false, 'post-scan controller is not aborted');
-  assert.equal(_getRuntimeEntry(postScanRaceId), postScanEntry, 'post-scan runtime remains owned');
-  _clearSessionRuntime(busy.id);
-  _clearSessionRuntime(postScanRaceId);
-
-  const dataDir = join(root, 'worker-index');
-  mkdirSync(dataDir, { recursive: true });
-  writeFileSync(join(dataDir, 'agent-workers.json'), JSON.stringify({
-    workers: {
-      known: {
-        tag: 'known',
-        sessionId: 'sess_known_row',
-        provider: 'openai-oauth',
-        status: 'idle',
-        updatedAt: new Date(old).toISOString(),
-      },
-      unknown: {
-        tag: 'unknown',
-        sessionId: 'sess_unknown_row',
-        provider: 'unlisted',
-        status: 'idle',
-        updatedAt: new Date(old).toISOString(),
-      },
-    },
-  }));
-  const { createStandaloneAgent } = await import('../src/standalone/agent-tool.mjs');
-  const agent = createStandaloneAgent({
-    cfgMod: {
-      loadConfig: () => overrideConfig,
-      resolveRuntimeSpec: () => ({ lane: 'agent', scopeKey: 'terminal-reap', provider: 'openai-oauth', model: 'test' }),
-    },
-    reg: {},
-    mgr: { listSessions: () => [], getSession: () => null },
-    dataDir,
-    cwd: root,
-  });
-  const workers = agent.getStatus().workers;
-  assert.ok(!workers.some((worker) => worker.tag === 'known'), 'worker row expires at the provider duration');
-  assert.ok(!workers.some((worker) => worker.tag === 'unknown'), 'unlisted worker row expires at the default duration');
-  agent.closeAll('agent-terminal-reap-test');
-
-  process.stdout.write(`agent terminal reap test passed (${builtIns.length} providers)\n`);
-} finally {
-  delete process.env.MIXDOG_AGENT_TERMINAL_REAP_MS;
-  delete process.env.MIXDOG_DATA_DIR;
-  rmSync(root, { recursive: true, force: true });
-}

package/scripts/agent-trace-io-test.mjs

@@ -1,133 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import test from 'node:test';
-
-const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const traceModuleUrl = pathToFileURL(join(root, 'src/runtime/agent/orchestrator/agent-trace-io.mjs')).href;
-
-test('drainAgentTrace awaits delayed local JSONL append without a memory service', () => {
-  const dir = mkdtempSync(join(tmpdir(), 'mixdog-agent-trace-io-test-'));
-  const traceParent = join(dir, 'nested');
-  const tracePath = join(traceParent, 'history', 'agent-trace.jsonl');
-  const loaderPath = join(dir, 'loader.mjs');
-  const delayedFsPath = join(dir, 'delayed-fs-promises.mjs');
-  try {
-    writeFileSync(delayedFsPath, `
-      import { appendFile as realAppendFile } from 'node:fs/promises';
-      export async function appendFile(...args) {
-        await new Promise((resolve) => setTimeout(resolve, Number(process.env.TRACE_APPEND_DELAY_MS)));
-        return realAppendFile(...args);
-      }
-    `);
-    writeFileSync(loaderPath, `
-      export async function resolve(specifier, context, nextResolve) {
-        if (specifier === 'fs/promises' && context.parentURL === ${JSON.stringify(traceModuleUrl)}) {
-          return { url: new URL('./delayed-fs-promises.mjs', import.meta.url).href, shortCircuit: true };
-        }
-        return nextResolve(specifier, context);
-      }
-    `);
-    const child = spawnSync(process.execPath, [
-      '--experimental-loader',
-      pathToFileURL(loaderPath).href,
-      '--input-type=module',
-      '-e',
-      `
-        import { readFileSync, rmSync } from 'node:fs';
-        import { appendAgentTrace, drainAgentTrace } from ${JSON.stringify(traceModuleUrl)};
-        appendAgentTrace({ kind: 'delayed-local-test', session_id: 'sess_delayed' });
-        rmSync(process.env.TRACE_PARENT, { recursive: true, force: true });
-        const started = Date.now();
-        await drainAgentTrace();
-        const rows = readFileSync(process.env.MIXDOG_AGENT_TRACE_PATH, 'utf8').trim().split(/\\r?\\n/).map(JSON.parse);
-        process.stdout.write(JSON.stringify({ elapsed: Date.now() - started, rows }));
-      `,
-    ], {
-      encoding: 'utf8',
-      env: {
-        ...process.env,
-        MIXDOG_AGENT_TRACE_PATH: tracePath,
-        MIXDOG_AGENT_TRACE_DISABLE: '',
-        MIXDOG_AGENT_TRACE_LOCAL_DISABLE: '',
-        MIXDOG_RUNTIME_ROOT: join(dir, 'no-service'),
-        TRACE_PARENT: traceParent,
-        TRACE_APPEND_DELAY_MS: '75',
-      },
-      timeout: 5000,
-    });
-    assert.equal(child.status, 0, child.stderr || child.stdout);
-    const result = JSON.parse(child.stdout);
-    assert.ok(result.elapsed >= 60, `drain returned before delayed append (${result.elapsed}ms)`);
-    assert.equal(result.rows.length, 1);
-    assert.equal(result.rows[0].kind, 'delayed-local-test');
-    assert.equal(result.rows[0].session_id, 'sess_delayed');
-    assert.match(readFileSync(tracePath, 'utf8'), /"kind":"delayed-local-test"/);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('explicit trace path stays append-only across concurrent writers', async () => {
-  const dir = mkdtempSync(join(tmpdir(), 'mixdog-agent-trace-multiwriter-test-'));
-  const tracePath = join(dir, 'agent-trace.jsonl');
-  const writerCount = 4;
-  const rowsPerWriter = 20;
-  try {
-    // Start above the normal rotation threshold. An explicit shared sink must
-    // retain this row in the live file while every child appends to it.
-    writeFileSync(tracePath, `${JSON.stringify({
-      kind: 'multiwriter-seed',
-      session_id: 'sess_seed',
-      payload: 'x'.repeat(10 * 1024 * 1024),
-    })}\n`);
-    const childSource = `
-      import { appendAgentTrace, drainAgentTrace } from ${JSON.stringify(traceModuleUrl)};
-      for (let i = 0; i < Number(process.env.ROWS_PER_WRITER); i += 1) {
-        appendAgentTrace({
-          kind: 'multiwriter',
-          session_id: 'sess_writer_' + process.env.WRITER_ID,
-          payload: { writer: Number(process.env.WRITER_ID), index: i },
-        });
-      }
-      await drainAgentTrace();
-    `;
-    await Promise.all(Array.from({ length: writerCount }, (_, writer) => new Promise((resolveChild, rejectChild) => {
-      const child = spawn(process.execPath, ['--input-type=module', '-e', childSource], {
-        cwd: root,
-        env: {
-          ...process.env,
-          MIXDOG_AGENT_TRACE_PATH: tracePath,
-          MIXDOG_AGENT_TRACE_DISABLE: '',
-          MIXDOG_AGENT_TRACE_LOCAL_DISABLE: '',
-          MIXDOG_RUNTIME_ROOT: join(dir, `no-service-${writer}`),
-          ROWS_PER_WRITER: String(rowsPerWriter),
-          WRITER_ID: String(writer),
-        },
-        stdio: ['ignore', 'ignore', 'pipe'],
-      });
-      let stderr = '';
-      child.stderr.setEncoding('utf8');
-      child.stderr.on('data', (chunk) => { stderr += chunk; });
-      child.on('error', rejectChild);
-      child.on('exit', (code) => {
-        if (code === 0) resolveChild();
-        else rejectChild(new Error(`writer ${writer} exited ${code}: ${stderr}`));
-      });
-    })));
-    assert.equal(existsSync(`${tracePath}.1`), false);
-    const rows = readFileSync(tracePath, 'utf8').trim().split(/\r?\n/).map(JSON.parse);
-    assert.equal(rows[0].kind, 'multiwriter-seed');
-    const written = rows.filter((row) => row.kind === 'multiwriter');
-    assert.equal(written.length, writerCount * rowsPerWriter);
-    assert.deepEqual(
-      [...new Set(written.map((row) => row.session_id))].sort(),
-      Array.from({ length: writerCount }, (_, writer) => `sess_writer_${writer}`),
-    );
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});

package/scripts/ansi-color-capability-test.mjs

@@ -1,90 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import {
-  brightGreen,
-  refreshColorSupport,
-  rgb,
-  rgbBg,
-  rgbSgr,
-  rgbToAnsi256,
-  supportsTruecolor,
-} from '../src/ui/ansi.mjs';
-import {
-  remapCanonicalStatuslineTruecolor,
-  STATUSLINE_CANONICAL_TRUECOLOR,
-} from '../src/tui/statusline-ansi-bridge.mjs';
-
-const savedEnv = {
-  COLORTERM: process.env.COLORTERM,
-  FORCE_COLOR: process.env.FORCE_COLOR,
-  NO_COLOR: process.env.NO_COLOR,
-  TERM: process.env.TERM,
-  TERM_PROGRAM: process.env.TERM_PROGRAM,
-  WT_SESSION: process.env.WT_SESSION,
-};
-
-function restoreEnv() {
-  for (const [key, value] of Object.entries(savedEnv)) {
-    if (value === undefined) delete process.env[key];
-    else process.env[key] = value;
-  }
-  refreshColorSupport();
-}
-
-test.after(restoreEnv);
-
-test('truecolor capability detection preserves known positives and defaults unknown to truecolor', () => {
-  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'Apple_Terminal', COLORTERM: 'truecolor' }, 'darwin'), false);
-  assert.equal(supportsTruecolor({ COLORTERM: 'truecolor' }, 'darwin'), true);
-  assert.equal(supportsTruecolor({ COLORTERM: '24bit' }, 'linux'), true);
-  assert.equal(supportsTruecolor({ WT_SESSION: 'abc' }, 'linux'), true);
-  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'iTerm.app' }, 'darwin'), true);
-  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'WezTerm' }, 'darwin'), true);
-  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'ghostty' }, 'darwin'), true);
-  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'vscode' }, 'darwin'), true);
-  assert.equal(supportsTruecolor({ TERM: 'xterm-direct' }, 'linux'), true);
-  assert.equal(supportsTruecolor({}, 'win32'), true);
-  assert.equal(supportsTruecolor({}, 'linux'), true);
-});
-
-test('RGB helpers are byte-identical in truecolor mode and downsample foreground/background on Apple Terminal', () => {
-  process.env.FORCE_COLOR = '1';
-  delete process.env.NO_COLOR;
-  process.env.COLORTERM = 'truecolor';
-  delete process.env.TERM_PROGRAM;
-  refreshColorSupport();
-
-  assert.equal(rgb(215, 119, 87)('x'), '\x1b[38;2;215;119;87mx\x1b[0m');
-  assert.equal(rgbBg(55, 55, 55)('x'), '\x1b[48;2;55;55;55mx\x1b[0m');
-
-  process.env.TERM_PROGRAM = 'Apple_Terminal';
-  assert.equal(rgbSgr(215, 119, 87), '\x1b[38;5;173m');
-  assert.equal(rgb(215, 119, 87)('x'), '\x1b[38;5;173mx\x1b[0m');
-  assert.equal(rgbBg(55, 55, 55)('x'), '\x1b[48;5;237mx\x1b[0m');
-  assert.equal(brightGreen('x'), '\x1b[38;5;35mx\x1b[0m');
-});
-
-test('RGB to ANSI-256 conversion selects the nearest cube or grayscale entry', () => {
-  assert.equal(rgbToAnsi256(0, 170, 75), 35);
-  assert.equal(rgbToAnsi256(198, 198, 198), 251);
-  assert.equal(rgbToAnsi256(136, 136, 136), 102);
-  assert.equal(rgbToAnsi256(255, 255, 255), 231);
-});
-
-test('statusline theme remap recognizes canonical 256-color variants', () => {
-  const colors = {
-    STATUS: '<status>',
-    SUBTLE: '<subtle>',
-    SUCCESS: '<success>',
-    WARNING: '<warning>',
-    ERROR: '<error>',
-  };
-  const success256 = `\x1b[38;5;${rgbToAnsi256(...STATUSLINE_CANONICAL_TRUECOLOR.success)}m`;
-  const warning256 = `\x1b[38;5;${rgbToAnsi256(...STATUSLINE_CANONICAL_TRUECOLOR.warningBright)}m`;
-  const input = `${success256}ok ${warning256}warn`;
-  assert.equal(
-    remapCanonicalStatuslineTruecolor(input, colors),
-    '<success>ok <warning>warn',
-  );
-});

package/scripts/anthropic-admission-retry-integration-test.mjs

@@ -1,119 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { AnthropicProvider } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
-import {
-    ProviderAdmissionScheduler,
-    wrapProviderAdmission,
-} from '../src/runtime/agent/orchestrator/providers/admission-scheduler.mjs';
-
-const encoder = new TextEncoder();
-
-function sseResponse(events, headers = new Map()) {
-    const bytes = encoder.encode(events.map((event) => (
-        `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`
-    )).join(''));
-    let sent = false;
-    return {
-        ok: true,
-        status: 200,
-        headers,
-        body: { getReader: () => ({
-            async read() {
-                if (sent) return { done: true };
-                sent = true;
-                return { done: false, value: bytes };
-            },
-            async cancel() {},
-            releaseLock() {},
-        }) },
-    };
-}
-
-test('real wrapped Anthropic retries report HTTP and SSE 429 before eventual success', async () => {
-    let now = 10_000;
-    const scheduled = [];
-    const scheduler = new ProviderAdmissionScheduler({
-        concurrency: 4,
-        now: () => now,
-        setTimer(fn, delay) {
-            const timer = { fn, delay };
-            scheduled.push(timer);
-            return timer;
-        },
-        clearTimer() {},
-    });
-
-    const provider = Object.create(AnthropicProvider.prototype);
-    provider.name = 'anthropic';
-    provider.config = { apiKey: 'fixture-key' };
-    provider.fastModeBetaHeaderLatched = false;
-    let attempts = 0;
-    provider.client = { messages: { create() {
-        attempts += 1;
-        return { async asResponse() {
-            if (attempts === 1) {
-                return {
-                    ok: false,
-                    status: 429,
-                    headers: new Map([['retry-after-ms', '7']]),
-                    async text() { return 'limited'; },
-                };
-            }
-            if (attempts === 2) {
-                return sseResponse([
-                    { type: 'error', error: { type: 'rate_limit_error', message: 'rate limit' } },
-                ], new Map([['retry-after-ms', '11']]));
-            }
-            return sseResponse([
-                { type: 'message_start', message: { model: 'claude', usage: { input_tokens: 1 } } },
-                { type: 'content_block_start', index: 0, content_block: { type: 'text' } },
-                { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: 'ok' } },
-                { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: { output_tokens: 1 } },
-                { type: 'message_stop' },
-            ]);
-        } };
-    } } };
-
-    wrapProviderAdmission(provider, 'anthropic', scheduler);
-    const result = await provider.send([], 'claude-sonnet-4-5', [], {});
-    assert.equal(result.content, 'ok');
-    assert.equal(attempts, 3);
-
-    const lane = [...scheduler.lanes.values()][0];
-    assert.equal(lane.limit, 1, 'each internally recovered 429 adapts the lane');
-    assert.equal(lane.cooldownUntil, now + 11, 'full SSE Retry-After reaches admission');
-    assert.ok(scheduled.some((timer) => timer.delay === 7));
-});
-
-test('terminal Anthropic 429 is adapted once by admission, not provider retry notification', async () => {
-    const previous = process.env.CLAUDE_CODE_MAX_RETRIES;
-    process.env.CLAUDE_CODE_MAX_RETRIES = '0';
-    try {
-        const scheduler = new ProviderAdmissionScheduler({
-            concurrency: 4,
-            setTimer() { return { unref() {} }; },
-            clearTimer() {},
-        });
-        const provider = Object.create(AnthropicProvider.prototype);
-        provider.name = 'anthropic';
-        provider.config = { apiKey: 'fixture-key' };
-        provider.fastModeBetaHeaderLatched = false;
-        provider.client = { messages: { create() {
-            return { async asResponse() {
-                return {
-                    ok: false,
-                    status: 429,
-                    headers: new Map([['retry-after-ms', '20']]),
-                    async text() { return 'terminal'; },
-                };
-            } };
-        } } };
-        wrapProviderAdmission(provider, 'anthropic', scheduler);
-        await assert.rejects(provider.send([], 'claude-sonnet-4-5', [], {}), (err) => err?.status === 429);
-        assert.equal([...scheduler.lanes.values()][0]?.limit, 2);
-    } finally {
-        if (previous == null) delete process.env.CLAUDE_CODE_MAX_RETRIES;
-        else process.env.CLAUDE_CODE_MAX_RETRIES = previous;
-    }
-});