testronaut 1.1.2 → 1.2.0

package/tests/llmTests/geminiProvider.test.js

@@ -0,0 +1,191 @@
+// tests/llmTests/geminiProvider.test.js
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Hoisted shared so the mock factory can access/record state
+const { shared } = vi.hoisted(() => ({
+  shared: {
+    apiKey: null,
+    getModelOpts: null,
+    lastContents: null,
+    // default response generator; tests can override
+    generateResponse: () => ({
+      response: {
+        candidates: [
+          { content: { parts: [{ text: 'hello' }] } }
+        ],
+        usageMetadata: { totalTokenCount: 123 },
+      },
+    }),
+  },
+}));
+
+// Mock the Google SDK
+vi.mock('@google/generative-ai', () => {
+  class FakeModel {
+    constructor(opts) { shared.getModelOpts = opts; }
+    async generateContent({ contents }) {
+      shared.lastContents = contents;
+      return shared.generateResponse();
+    }
+  }
+  class GoogleGenerativeAI {
+    constructor(key) { shared.apiKey = key; }
+    getGenerativeModel(opts) { shared.getModelOpts = opts; return new FakeModel(opts); }
+  }
+  return { GoogleGenerativeAI };
+});
+
+// Import SUT after mocks
+import { GeminiProvider } from '../../llm/gemini/geminiProvider.js';
+
+describe('GeminiProvider', () => {
+  beforeEach(() => {
+    shared.apiKey = null;
+    shared.getModelOpts = null;
+    shared.lastContents = null;
+    // reset default response
+    shared.generateResponse = () => ({
+      response: {
+        candidates: [{ content: { parts: [{ text: 'hello' }] } }],
+        usageMetadata: { totalTokenCount: 123 },
+      },
+    });
+  });
+
+  it('throws if constructed without apiKey', () => {
+    expect(() => new GeminiProvider({})).toThrow(/GEMINI_API_KEY/i);
+  });
+
+  it('passes apiKey and model/tools into the SDK correctly', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-123' });
+
+    const tools = [
+      { type: 'function', function: { name: 'foo', description: 'Foo', parameters: { type: 'object' } } },
+      { type: 'function', function: { name: 'bar', parameters: { type: 'object', properties: { x: { type: 'string' } } } } },
+    ];
+
+    await prov.chat({
+      model: 'gemini-2.5-flash',
+      messages: [{ role: 'user', content: 'hi' }],
+      tools,
+    });
+
+    expect(shared.apiKey).toBe('gk-123');
+    expect(shared.getModelOpts?.model).toBe('gemini-2.5-flash');
+    // Tools converted to Gemini functionDeclarations wrapper
+    expect(Array.isArray(shared.getModelOpts?.tools)).toBe(true);
+    expect(shared.getModelOpts.tools[0].functionDeclarations.map(d => d.name)).toEqual(['foo', 'bar']);
+  });
+
+  it('converts OpenAI-like messages → Gemini contents (system prefix + tool calls + tool results)', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+
+    // Build a conversation:
+    // - system
+    // - user (should get system prefix injected)
+    // - assistant with tool_calls
+    // - tool result
+    // - assistant normal text
+    const messages = [
+      { role: 'system', content: 'You are helpful.' },
+      { role: 'user', content: 'search for x' },
+      {
+        role: 'assistant',
+        tool_calls: [
+          { id: '1', type: 'function', function: { name: 'search', arguments: JSON.stringify({ q: 'x' }) } },
+        ],
+      },
+      {
+        role: 'tool',
+        tool_call_id: '1',
+        name: 'search',
+        type: 'function',
+        content: JSON.stringify({ results: [1, 2, 3] }),
+      },
+      { role: 'assistant', content: 'Here are results.' },
+    ];
+
+    await prov.chat({ model: 'gemini-2.5-pro', messages });
+
+    const c = shared.lastContents;
+    expect(Array.isArray(c)).toBe(true);
+
+    // 1) First item: user with injected system prefix
+    expect(c[0].role).toBe('user');
+    expect(c[0].parts[0].text).toMatch(/^\[system]\nYou are helpful\./);
+    expect(c[0].parts[1].text).toBe('search for x');
+
+    // 2) Assistant tool call → model role with functionCall
+    expect(c[1].role).toBe('model');
+    expect(c[1].parts[0].functionCall).toEqual({ name: 'search', args: { q: 'x' } });
+
+    // 3) Tool result → user role with JSON marker
+    expect(c[2].role).toBe('user');
+    const toolJson = JSON.parse(c[2].parts[0].text);
+    expect(toolJson._tool_result).toBe(true);
+    expect(toolJson.tool_call_id).toBe('1');
+    expect(toolJson.name).toBe('search');
+
+    // 4) Final assistant text → model role with text
+    expect(c[3].role).toBe('model');
+    expect(c[3].parts[0].text).toBe('Here are results.');
+  });
+
+  it('maps Gemini candidate parts → OpenAI-like assistant message and usage', async () => {
+    // Make the fake SDK return a functionCall + text
+    shared.generateResponse = () => ({
+      response: {
+        candidates: [
+          {
+            content: {
+              parts: [
+                { functionCall: { name: 'open', args: { url: 'https://example.com' } } },
+                { text: 'Ok!' },
+              ],
+            },
+          },
+        ],
+        usageMetadata: { totalTokenCount: 999, other: 'meta' },
+      },
+    });
+
+    const prov = new GeminiProvider({ apiKey: 'gk-abc' });
+    const { message, usage } = await prov.chat({
+      model: 'gemini-2.5-flash',
+      messages: [{ role: 'user', content: 'go' }],
+    });
+
+    expect(message.role).toBe('assistant');
+    expect(message.content).toBe('Ok!');
+    expect(Array.isArray(message.tool_calls)).toBe(true);
+    expect(message.tool_calls[0].function.name).toBe('open');
+    expect(JSON.parse(message.tool_calls[0].function.arguments)).toEqual({ url: 'https://example.com' });
+
+    expect(usage.total_tokens).toBe(999);
+    expect(usage.providerRaw).toEqual({ totalTokenCount: 999, other: 'meta' });
+  });
+
+  it('supports image parts (encoded to inlineData)', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+
+    const imageBytes = Buffer.from([1, 2, 3, 4]);
+    await prov.chat({
+      model: 'gemini-2.5-flash',
+      messages: [
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'see image' },
+            { type: 'image', mimeType: 'image/png', data: imageBytes },
+          ],
+        },
+      ],
+    });
+
+    const c = shared.lastContents;
+    expect(c[0].role).toBe('user');
+    expect(c[0].parts[0].text).toBe('see image');
+    expect(c[0].parts[1].inlineData.mimeType).toBe('image/png');
+    expect(typeof c[0].parts[1].inlineData.data).toBe('string'); // base64
+  });
+});

package/tests/llmTests/llmFactory.test.js

@@ -0,0 +1,78 @@
+// tests/llmTests/llmFactory.test.js
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+// Hoisted shared spies so mock factories can access them
+const { shared } = vi.hoisted(() => ({
+  shared: {
+    openAICtor: vi.fn(),
+    geminiCtor: vi.fn(),
+  },
+}));
+
+// Mock provider classes; constructors record received options
+vi.mock('../../llm/openAI/openaiProvider.js', () => ({
+  OpenAIProvider: function (opts) {
+    shared.openAICtor(opts);
+    // minimal adapter surface used by callers
+    this.chat = vi.fn(async () => ({ message: { role: 'assistant', content: 'ok' }, usage: {} }));
+  },
+}));
+
+vi.mock('../../llm/gemini/geminiProvider.js', () => ({
+  GeminiProvider: function (opts) {
+    shared.geminiCtor(opts);
+    this.chat = vi.fn(async () => ({ message: { role: 'assistant', content: 'ok' }, usage: {} }));
+  },
+}));
+
+// Import SUT after mocks
+import { getLLM } from '../../llm/llmFactory.js';
+
+const ORIGINAL_ENV = { ...process.env };
+
+describe('getLLM', () => {
+  beforeEach(() => {
+    process.env = { ...ORIGINAL_ENV };
+    shared.openAICtor.mockClear();
+    shared.geminiCtor.mockClear();
+  });
+
+  afterEach(() => {
+    process.env = { ...ORIGINAL_ENV };
+  });
+
+  it('creates OpenAI provider (case-insensitive) and passes env key', () => {
+    process.env.OPENAI_API_KEY = 'sk-openai-123';
+    const llm = getLLM('OpEnAi');
+    expect(typeof llm.chat).toBe('function');
+    expect(shared.openAICtor).toHaveBeenCalledTimes(1);
+    expect(shared.openAICtor).toHaveBeenCalledWith(
+      expect.objectContaining({ apiKey: 'sk-openai-123' })
+    );
+    expect(shared.geminiCtor).not.toHaveBeenCalled();
+  });
+
+  it('creates Gemini provider and passes env key', () => {
+    process.env.GEMINI_API_KEY = 'gk-gemini-abc';
+    const llm = getLLM('gemini');
+    expect(typeof llm.chat).toBe('function');
+    expect(shared.geminiCtor).toHaveBeenCalledTimes(1);
+    expect(shared.geminiCtor).toHaveBeenCalledWith(
+      expect.objectContaining({ apiKey: 'gk-gemini-abc' })
+    );
+    expect(shared.openAICtor).not.toHaveBeenCalled();
+  });
+
+  it('merges opts after env so explicit opts.apiKey overrides env', () => {
+    process.env.OPENAI_API_KEY = 'sk-env-will-be-overridden';
+    const llm = getLLM('openai', { apiKey: 'sk-passed-in' });
+    expect(shared.openAICtor).toHaveBeenCalledWith(
+      expect.objectContaining({ apiKey: 'sk-passed-in' })
+    );
+    expect(typeof llm.chat).toBe('function');
+  });
+
+  it('throws on unsupported provider', () => {
+    expect(() => getLLM('anthropic')).toThrow(/Unsupported LLM provider/i);
+  });
+});

package/tests/llmTests/modelResolver.test.js

@@ -0,0 +1,119 @@
+// tests/llmTests/modelResolver.test.js
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { resolveProviderModel } from '../../llm/modelResolver.js';
+
+const ORIGINAL_ENV = { ...process.env };
+const originalCwd = process.cwd();
+
+function makeTempProject() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-'));
+}
+function writeConfig(dir, obj) {
+  fs.writeFileSync(path.join(dir, 'testronaut-config.json'), JSON.stringify(obj, null, 2), 'utf8');
+}
+function clearResolverEnv() {
+  delete process.env.TESTRONAUT_PROVIDER;
+  delete process.env.TESTRONAUT_MODEL;
+}
+
+beforeEach(() => {
+  process.env = { ...ORIGINAL_ENV };
+  clearResolverEnv();
+});
+
+afterEach(() => {
+  process.env = { ...ORIGINAL_ENV };
+  process.chdir(originalCwd);
+});
+
+describe('resolveProviderModel', () => {
+  it('returns env provider/model when both set', () => {
+    process.env.TESTRONAUT_PROVIDER = 'gemini';
+    process.env.TESTRONAUT_MODEL = 'gemini-2.5-flash';
+    const res = resolveProviderModel();
+    expect(res).toEqual({ provider: 'gemini', model: 'gemini-2.5-flash' });
+  });
+
+  it('reads provider/model from config file when present', () => {
+    const temp = makeTempProject();
+    writeConfig(temp, { provider: 'openai', model: 'gpt-5' });
+
+    const res = resolveProviderModel({ cwd: temp }); // 👈 pass cwd
+    expect(res.provider).toBe('openai');
+    expect(res.model).toBe('gpt-5');
+  });
+
+  it('applies env override for only one value (env model overrides config model)', () => {
+    const temp = makeTempProject();
+    writeConfig(temp, { provider: 'openai', model: 'gpt-4o' });
+    process.env.TESTRONAUT_MODEL = 'gpt-5-mini';
+
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res.provider).toBe('openai');
+    expect(res.model).toBe('gpt-5-mini');
+  });
+
+  it('handles legacy config with model="openai"', () => {
+    const temp = makeTempProject();
+    writeConfig(temp, { model: 'openai' });
+
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-4o' });
+  });
+
+  it('returns defaults when config missing', () => {
+    const temp = makeTempProject();
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-4o' });
+  });
+
+  it('returns defaults when JSON parsing fails', () => {
+    const temp = makeTempProject();
+    fs.writeFileSync(path.join(temp, 'testronaut-config.json'), '{bad json', 'utf8');
+
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res.provider).toBe('openai');
+    expect(res.model).toBe('gpt-4o');
+  });
+
+  it('trims env vars and treats empty strings as absent', () => {
+    process.env.TESTRONAUT_PROVIDER = '  openai  ';
+    process.env.TESTRONAUT_MODEL = '   gpt-5   ';
+    let res = resolveProviderModel();
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-5' });
+
+    process.env.TESTRONAUT_PROVIDER = '   ';
+    process.env.TESTRONAUT_MODEL = '   ';
+    res = resolveProviderModel();
+    // falls back to defaults when env vars are just whitespace
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-4o' });
+  });
+
+  it('prefers config when only provider is in env and model only in config', () => {
+    process.env.TESTRONAUT_PROVIDER = 'gemini';
+    const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-'));
+    fs.writeFileSync(
+      path.join(temp, 'testronaut-config.json'),
+      JSON.stringify({ provider: 'openai', model: 'gemini-2.5-flash' }),
+      'utf8'
+    );
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res).toEqual({ provider: 'gemini', model: 'gemini-2.5-flash' });
+  });
+
+  it('ignores unrelated keys in config and still resolves', () => {
+    const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-'));
+    fs.writeFileSync(
+      path.join(temp, 'testronaut-config.json'),
+      JSON.stringify({ provider: 'openai', model: 'gpt-4o', extra: { foo: 1 } }),
+      'utf8'
+    );
+    const res = resolveProviderModel({ cwd: temp });
+    expect(res).toEqual({ provider: 'openai', model: 'gpt-4o' });
+  });
+
+});

package/tests/llmTests/openAIProvider.test.js

@@ -0,0 +1,117 @@
+// tests/llmTests/openAIProvider.test.js
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Hoisted shared so the mock factory can access/record state
+const { shared } = vi.hoisted(() => ({
+  shared: {
+    ctorOpts: null,
+    lastCreateArgs: null,
+    // default response; tests can override
+    responseFactory: () => ({
+      choices: [{ message: { role: 'assistant', content: 'hello' } }],
+      usage: { total_tokens: 321, prompt_tokens: 100, completion_tokens: 221 },
+      headers: { 'x-ratelimit-limit-tokens': '90000' },
+    }),
+  },
+}));
+
+// Mock the OpenAI SDK surface we use
+vi.mock('openai', () => {
+  class FakeChatCompletions {
+    async create(args) {
+      shared.lastCreateArgs = args;
+      return shared.responseFactory();
+    }
+  }
+  class FakeChat {
+    constructor() {
+      this.completions = new FakeChatCompletions();
+    }
+  }
+  class OpenAI {
+    constructor(opts) {
+      shared.ctorOpts = opts;
+      this.chat = new FakeChat();
+    }
+  }
+  return { default: OpenAI };
+});
+
+// Import SUT after mocks
+import { OpenAIProvider } from '../../llm/openAI/openaiProvider.js';
+
+describe('OpenAIProvider', () => {
+  beforeEach(() => {
+    shared.ctorOpts = null;
+    shared.lastCreateArgs = null;
+    shared.responseFactory = () => ({
+      choices: [{ message: { role: 'assistant', content: 'hello' } }],
+      usage: { total_tokens: 321, prompt_tokens: 100, completion_tokens: 221 },
+      headers: { 'x-ratelimit-limit-tokens': '90000' },
+    });
+  });
+
+  it('throws without apiKey', () => {
+    expect(() => new OpenAIProvider({})).toThrow(/OPENAI_API_KEY/i);
+  });
+
+  it('passes apiKey to OpenAI constructor', () => {
+    const p = new OpenAIProvider({ apiKey: 'sk-test-123' });
+    expect(shared.ctorOpts).toEqual({ apiKey: 'sk-test-123' });
+    expect(typeof p.chat).toBe('function');
+  });
+
+  it('calls chat.completions.create with model/messages/tools', async () => {
+    const prov = new OpenAIProvider({ apiKey: 'sk-abc' });
+    const tools = [{ type: 'function', function: { name: 'doThing', parameters: { type: 'object' } } }];
+
+    await prov.chat({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'hi' }],
+      tools,
+    });
+
+    expect(shared.lastCreateArgs).toEqual({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'hi' }],
+      tools,
+    });
+  });
+
+  it('returns normalized message, usage, and headers', async () => {
+    const prov = new OpenAIProvider({ apiKey: 'sk-abc' });
+    const { message, usage, headers } = await prov.chat({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'go' }],
+    });
+
+    expect(message).toEqual({ role: 'assistant', content: 'hello' });
+    expect(usage.total_tokens).toBe(321);
+    expect(usage.providerRaw).toEqual({ total_tokens: 321, prompt_tokens: 100, completion_tokens: 221 });
+    expect(headers).toEqual({ 'x-ratelimit-limit-tokens': '90000' });
+  });
+
+  it('handles SDK variants with headers on response.response.headers', async () => {
+    shared.responseFactory = () => ({
+      choices: [{ message: { role: 'assistant', content: 'ok' } }],
+      usage: { total_tokens: 11 },
+      response: { headers: { 'x-ratelimit-limit-tokens': '12345' } },
+    });
+
+    const prov = new OpenAIProvider({ apiKey: 'sk-abc' });
+    const { headers } = await prov.chat({ model: 'gpt-4o', messages: [] });
+    expect(headers).toEqual({ 'x-ratelimit-limit-tokens': '12345' });
+  });
+
+  it('provides a default assistant message when choices are empty', async () => {
+    shared.responseFactory = () => ({
+      choices: [],
+      usage: {},
+      headers: {},
+    });
+
+    const prov = new OpenAIProvider({ apiKey: 'sk-abc' });
+    const { message } = await prov.chat({ model: 'gpt-4o', messages: [] });
+    expect(message).toEqual({ role: 'assistant', content: '' });
+  });
+});

package/tests/toolsTests/tokenControl.test.js

@@ -0,0 +1,150 @@
+// tests/tokenControlTests/tokenControl.test.js
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+// Hoist env so we can safely mutate per test
+const ORIGINAL_ENV = { ...process.env };
+
+// Mock wait so tests are instant
+vi.mock('../../tools/turnLoopUtils.js', () => ({
+  wait: vi.fn(async () => {}),
+}));
+
+// Mock tiktoken in a controllable way
+const encMock = {
+  encode: vi.fn((s) => Array.from(String(s)).map(() => 1)), // 1 token per char
+  free: vi.fn(() => {}),
+};
+
+const tiktokenMocks = vi.hoisted(() => ({
+  encoding_for_model_impl: vi.fn(),
+  get_encoding_impl: vi.fn(() => encMock),
+}));
+
+vi.mock('@dqbd/tiktoken', () => ({
+  encoding_for_model: (model) => tiktokenMocks.encoding_for_model_impl(model),
+  get_encoding: (name) => tiktokenMocks.get_encoding_impl(name),
+}));
+
+// Import after mocks
+import {
+  tokenEstimate,
+  getCurrentTokenLimit,
+  updateLimitsFromHeaders,
+  tokenUseCoolOff,
+  recordTokenUsage,
+  pruneOldTokenUsage,
+  __resetTokenControlForTests,
+} from '../../tools/tokenControl.js';
+
+describe('tokenControl', () => {
+  beforeEach(() => {
+    // reset env and mocks
+    process.env = { ...ORIGINAL_ENV };
+    __resetTokenControlForTests(); 
+    tiktokenMocks.encoding_for_model_impl.mockReset();
+    tiktokenMocks.get_encoding_impl.mockReset().mockReturnValue(encMock);
+    encMock.encode.mockClear();
+    encMock.free.mockClear();
+  });
+
+  afterEach(() => {
+    process.env = { ...ORIGINAL_ENV };
+  });
+
+  describe('tokenEstimate', () => {
+    it('uses encoding_for_model when available', async () => {
+      tiktokenMocks.encoding_for_model_impl.mockReturnValue(encMock);
+
+      const n = await tokenEstimate('gpt-4o', 'abcd'); // 4 chars → 4 tokens via mock
+      expect(n).toBe(4);
+      expect(encMock.encode).toHaveBeenCalledOnce();
+      expect(encMock.free).toHaveBeenCalledOnce();
+    });
+
+    it('falls back to get_encoding when encoding_for_model throws', async () => {
+      tiktokenMocks.encoding_for_model_impl.mockImplementation(() => { throw new Error('no direct encoding'); });
+      tiktokenMocks.get_encoding_impl.mockReturnValue(encMock);
+
+      const n = await tokenEstimate('gemini-2.5-flash', 'abc'); // 3
+      expect(n).toBe(3);
+      expect(encMock.encode).toHaveBeenCalledOnce();
+    });
+
+    it('falls back to bytes/4 when both tokenizers fail', async () => {
+      tiktokenMocks.encoding_for_model_impl.mockImplementation(() => { throw new Error('no direct encoding'); });
+      tiktokenMocks.get_encoding_impl.mockImplementation(() => { throw new Error('no base encoding'); });
+
+      const n = await tokenEstimate('unknown-model', 'abcdefgh'); // 8 bytes → 8/4 = 2
+      expect(n).toBe(2);
+    });
+
+    it('stringifies non-string input', async () => {
+      tiktokenMocks.encoding_for_model_impl.mockReturnValue(encMock);
+      const n = await tokenEstimate('gpt-4o', { a: 1, b: 2 });
+      expect(encMock.encode).toHaveBeenCalled();
+      expect(typeof n).toBe('number');
+    });
+  });
+
+  describe('getCurrentTokenLimit / updateLimitsFromHeaders', () => {
+    it('uses defaults by model pattern', () => {
+      const openai = getCurrentTokenLimit('gpt-4o');
+      const gemini = getCurrentTokenLimit('gemini-2.5-flash');
+      expect(openai.tpm).toBeGreaterThan(0);
+      expect(gemini.tpm).toBeGreaterThan(0);
+      expect(['default', 'env', 'header']).toContain(openai.source);
+    });
+
+    it('honors ENV override TESTRONAUT_TOKENS_PER_MIN', () => {
+      process.env.TESTRONAUT_TOKENS_PER_MIN = '999';
+      const anyModel = getCurrentTokenLimit('what-ever-model');
+      expect(anyModel.tpm).toBe(999);
+      expect(anyModel.source).toBe('env');
+    });
+
+    it('updates limits from headers (header wins)', () => {
+      const before = getCurrentTokenLimit('gpt-4o');
+      updateLimitsFromHeaders('gpt-4o', { 'x-ratelimit-limit-tokens': '1234' });
+      const after = getCurrentTokenLimit('gpt-4o');
+      expect(after.tpm).toBe(1234);
+      expect(after.source).toBe('header');
+      // sanity check it actually changed (unless defaults already 1234)
+      if (before.tpm !== 1234) expect(after.tpm).not.toBe(before.tpm);
+    });
+  });
+
+  describe('rolling window + cooldown', () => {
+    it('prunes old entries outside the window', () => {
+      const now = Date.now();
+      const entries = [
+        [now - 70000, 100], // old → pruned
+        [now - 10000, 50],  // kept
+        [now - 5000, 30],   // kept
+      ];
+      const { turnTimestamps, totalTokensUsed } = pruneOldTokenUsage(entries, 60000);
+      expect(turnTimestamps.length).toBe(2);
+      expect(totalTokensUsed).toBe(80);
+    });
+
+    it('triggers backoff when usage exceeds TPM', async () => {
+      // small ENV cap to force backoff
+      process.env.TESTRONAUT_TOKENS_PER_MIN = '50';
+      const entries = [];
+      recordTokenUsage(entries, 60);
+
+      const result = await tokenUseCoolOff(60, entries, 'any-model');
+      expect(result.shouldBackoff).toBe(true);
+      expect(result.totalTokensUsed).toBe(0);
+      expect(Array.isArray(result.turnTimestamps)).toBe(true);
+    });
+
+    it('does not backoff when under TPM', async () => {
+      process.env.TESTRONAUT_TOKENS_PER_MIN = '100';
+      const entries = [];
+      recordTokenUsage(entries, 60);
+      const result = await tokenUseCoolOff(60, entries, 'any-model');
+      expect(result.shouldBackoff).toBe(false);
+      expect(result.totalTokensUsed).toBe(60);
+    });
+  });
+});