skimpyclaw 0.3.14 → 0.4.0

package/dist/__tests__/interactive-sessions.test.js

@@ -0,0 +1,96 @@
+import { describe, expect, it, beforeEach, vi } from 'vitest';
+// Mock fs before importing the module so the module never touches disk during import.
+vi.mock('fs', async () => {
+    const actual = await vi.importActual('fs');
+    return {
+        ...actual,
+        existsSync: vi.fn(() => false),
+        readFileSync: vi.fn(() => '[]'),
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+    };
+});
+import { addSession, getSession, updateStatus, enqueue, dequeue, markIdle, hasPending, listSessions, _resetForTesting, } from '../code-agents/interactive-sessions.js';
+function makeSession(threadId = 't1', cliAgent = 'claude') {
+    return {
+        discordThreadId: threadId,
+        cliSessionId: 'uuid-' + threadId,
+        cliAgent,
+        status: 'active',
+        createdAt: new Date().toISOString(),
+        lastActivityAt: new Date().toISOString(),
+        initialTask: 'test task',
+    };
+}
+describe('interactive-sessions state store', () => {
+    beforeEach(() => {
+        _resetForTesting();
+    });
+    it('stores and retrieves a session', () => {
+        const s = makeSession();
+        addSession(s);
+        expect(getSession('t1')).toEqual(s);
+        expect(listSessions()).toHaveLength(1);
+    });
+    it('updates status and activity', () => {
+        addSession(makeSession());
+        updateStatus('t1', 'errored');
+        const s = getSession('t1');
+        expect(s?.status).toBe('errored');
+    });
+    it('returns undefined for unknown thread', () => {
+        expect(getSession('nope')).toBeUndefined();
+    });
+    it('enqueue returns shouldStart=true for first message', () => {
+        addSession(makeSession());
+        const r = enqueue('t1', 'hello');
+        expect(r.shouldStart).toBe(true);
+    });
+    it('enqueue returns shouldStart=false while in-flight', () => {
+        addSession(makeSession());
+        enqueue('t1', 'first'); // marks inFlight
+        const r = enqueue('t1', 'second');
+        expect(r.shouldStart).toBe(false);
+    });
+    it('dequeue returns messages FIFO', () => {
+        addSession(makeSession());
+        enqueue('t1', 'one');
+        enqueue('t1', 'two');
+        enqueue('t1', 'three');
+        // First was taken by the "in flight" starter; caller is responsible for
+        // processing it. The remaining two should dequeue in order.
+        // Our API returns the first via shouldStart=true — the caller then calls
+        // dequeue() to consume subsequent ones.
+        const first = dequeue('t1');
+        expect(first?.content).toBe('one');
+        const second = dequeue('t1');
+        expect(second?.content).toBe('two');
+        const third = dequeue('t1');
+        expect(third?.content).toBe('three');
+        expect(dequeue('t1')).toBeUndefined();
+    });
+    it('markIdle allows shouldStart=true on next enqueue', () => {
+        addSession(makeSession());
+        enqueue('t1', 'first');
+        markIdle('t1');
+        // Queue is empty AND not in flight → next enqueue starts
+        const r = enqueue('t1', 'next');
+        expect(r.shouldStart).toBe(true);
+    });
+    it('hasPending reflects queue state', () => {
+        addSession(makeSession());
+        expect(hasPending('t1')).toBe(false);
+        enqueue('t1', 'one'); // inFlight=true, queue empty (first message is the "flight")
+        expect(hasPending('t1')).toBe(true); // we pushed to queue first
+        dequeue('t1');
+        expect(hasPending('t1')).toBe(false);
+    });
+    it('per-thread queues are isolated', () => {
+        addSession(makeSession('t1'));
+        addSession(makeSession('t2'));
+        enqueue('t1', 'to t1');
+        enqueue('t2', 'to t2');
+        expect(dequeue('t1')?.content).toBe('to t1');
+        expect(dequeue('t2')?.content).toBe('to t2');
+    });
+});

package/dist/__tests__/langfuse.test.js

@@ -1,18 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { calculateUsageCost } from '../langfuse.js';
 describe('calculateUsageCost', () => {
-    it('uses updated OpenAI pricing for gpt-4o', () => {
-        const cost = calculateUsageCost('openai/gpt-4o', 1_000_000, 1_000_000);
-        expect(cost.inputCost).toBe(2.5);
-        expect(cost.outputCost).toBe(10);
-        expect(cost.totalCost).toBe(12.5);
-    });
-    it('uses updated OpenAI pricing for gpt-4o-mini', () => {
-        const cost = calculateUsageCost('gpt-4o-mini', 1_000_000, 1_000_000);
-        expect(cost.inputCost).toBe(0.15);
-        expect(cost.outputCost).toBe(0.6);
-        expect(cost.totalCost).toBe(0.75);
-    });
     it('resolves codex provider model names', () => {
         const cost = calculateUsageCost('codex/codex-5.3', 1_000_000, 1_000_000);
         expect(cost.inputCost).toBe(1.75);
@@ -25,16 +13,16 @@ describe('calculateUsageCost', () => {
         expect(cost.outputCost).toBe(14);
         expect(cost.totalCost).toBe(15.75);
     });
+    it('resolves codex5.5 alias pricing', () => {
+        const cost = calculateUsageCost('codex5.5', 1_000_000, 1_000_000);
+        expect(cost.inputCost).toBe(5);
+        expect(cost.outputCost).toBe(30);
+        expect(cost.totalCost).toBe(35);
+    });
     it('resolves codex5.1 model pricing', () => {
         const cost = calculateUsageCost('codex/gpt-5.1-codex', 1_000_000, 1_000_000);
         expect(cost.inputCost).toBe(1.25);
         expect(cost.outputCost).toBe(10);
         expect(cost.totalCost).toBe(11.25);
     });
-    it('resolves minimax alias case correctly', () => {
-        const cost = calculateUsageCost('minimax', 1_000_000, 1_000_000);
-        expect(cost.inputCost).toBe(0.3);
-        expect(cost.outputCost).toBe(1.2);
-        expect(cost.totalCost).toBe(1.5);
-    });
 });

package/dist/__tests__/model-selection.test.js

@@ -4,7 +4,6 @@ function mockConfig() {
     return {
         models: {
             aliases: {
-                'claude-fast': 'anthropic/claude-haiku-4-5',
                 codex5: 'codex/gpt-5.3-codex',
             },
         },
@@ -12,10 +11,10 @@ function mockConfig() {
 }
 describe('model-selection', () => {
     it('lists aliases sorted', () => {
-        expect(listModelAliases(mockConfig())).toEqual(['claude-fast', 'codex5']);
+        expect(listModelAliases(mockConfig())).toEqual(['codex5']);
     });
     it('formats aliases', () => {
-        expect(formatAliases(mockConfig())).toBe('claude-fast, codex5');
+        expect(formatAliases(mockConfig())).toBe('codex5');
     });
     it('returns model selection usage string', () => {
         expect(getModelSelectionUsage()).toBe('Use alias, provider/model, or model-id.');
@@ -56,7 +55,7 @@ describe('model-selection', () => {
     it('formats model selection errors with aliases and usage', () => {
         const text = formatModelSelectionError('Unknown model alias: "x"', mockConfig());
         expect(text).toContain('Unknown model alias: "x"');
-        expect(text).toContain('Available aliases: claude-fast, codex5');
+        expect(text).toContain('Available aliases: codex5');
         expect(text).toContain('Use alias, provider/model, or model-id.');
     });
 });

package/dist/__tests__/providers-init.test.js

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest';
-import { initProviders, hasOpenAIClient, addResponsesApiProvider, isResponsesApiProvider, setUsingOAuth, isUsingOAuth, } from '../providers/index.js';
+import { initProviders, addResponsesApiProvider, isResponsesApiProvider, setUsingOAuth, isUsingOAuth, } from '../providers/index.js';
 function baseConfig(providers) {
     return {
         gateway: { port: 18790, mode: 'local' },
-        agents: { default: 'main', list: { main: { identity: { name: 'bot', emoji: 'x' }, model: 'openai/gpt-4o' } } },
+        agents: { default: 'main', list: { main: { identity: { name: 'bot', emoji: 'x' }, model: 'anthropic/claude-sonnet-4-6' } } },
         models: { providers, aliases: {} },
         channels: { telegram: { enabled: false, token: '', allowFrom: [] }, discord: { enabled: false, token: '', allowFrom: [] } },
         cron: { jobs: [] },
@@ -11,12 +11,6 @@ function baseConfig(providers) {
     };
 }
 describe('providers init reset behavior', () => {
-    it('clears stale OpenAI clients on re-init', async () => {
-        await initProviders(baseConfig({ openai: { apiKey: 'sk-test' } }));
-        expect(hasOpenAIClient('openai')).toBe(true);
-        await initProviders(baseConfig({}));
-        expect(hasOpenAIClient('openai')).toBe(false);
-    });
     it('clears stale codex provider registrations on re-init', async () => {
         addResponsesApiProvider('openai');
         expect(isResponsesApiProvider('openai')).toBe(true);

package/dist/__tests__/providers-routing.test.js

@@ -3,7 +3,7 @@ import { addResponsesApiProvider, chat, initProviders } from '../providers/index
 function baseConfig(providers) {
     return {
         gateway: { port: 18790, mode: 'local' },
-        agents: { default: 'main', list: { main: { identity: { name: 'bot', emoji: 'x' }, model: 'openai/gpt-4o' } } },
+        agents: { default: 'main', list: { main: { identity: { name: 'bot', emoji: 'x' }, model: 'anthropic/claude-sonnet-4-6' } } },
         models: { providers, aliases: {} },
         channels: { telegram: { enabled: false, token: '', allowFrom: [] }, discord: { enabled: false, token: '', allowFrom: [] } },
         cron: { jobs: [] },

package/dist/__tests__/providers-utils.test.js

@@ -1,10 +1,11 @@
 import { describe, expect, it } from 'vitest';
-import { getProvider, stripProvider, resolveModel, resolveProviderRoute, shouldUseCodexAliasProvider, } from '../providers/utils.js';
+import { getProvider, stripProvider, resolveModel, resolveProviderRoute, shouldUseCodexAliasProvider, buildThinkingConfig, } from '../providers/utils.js';
 describe('provider utils', () => {
     it('detects provider from explicit prefix', () => {
         expect(getProvider('openai/gpt-5.3-codex')).toBe('openai');
         expect(getProvider('codex/gpt-5.3-codex')).toBe('codex');
         expect(getProvider('anthropic/claude-sonnet-4-6')).toBe('anthropic');
+        expect(getProvider('gpt-5.5')).toBe('codex');
     });
     it('strips provider prefix when registries are omitted', () => {
         expect(stripProvider('openai/gpt-5.3-codex')).toBe('gpt-5.3-codex');
@@ -47,8 +48,14 @@ describe('provider utils', () => {
     });
     it('migrates deprecated claude opus 4 model ids', () => {
         const cfg = { models: { aliases: {} } };
-        expect(resolveModel('claude-opus-4', cfg)).toBe('claude-opus-4-6');
-        expect(resolveModel('anthropic/claude-opus-4', cfg)).toBe('anthropic/claude-opus-4-6');
+        expect(resolveModel('claude-opus-4', cfg)).toBe('claude-opus-4-7');
+        expect(resolveModel('anthropic/claude-opus-4', cfg)).toBe('anthropic/claude-opus-4-7');
+    });
+    it('preserves explicit claude opus 4.6 model ids', () => {
+        const cfg = { models: { aliases: {} } };
+        expect(resolveModel('claude-opus-4.6', cfg)).toBe('claude-opus-4-6');
+        expect(resolveModel('anthropic/claude-opus-4.6', cfg)).toBe('anthropic/claude-opus-4-6');
+        expect(resolveModel('anthropic/claude-opus-4-6', cfg)).toBe('anthropic/claude-opus-4-6');
     });
     it('normalizes provider route fields after deprecated model migration', () => {
         const cfg = { models: { aliases: {} } };
@@ -58,4 +65,7 @@ describe('provider utils', () => {
         expect(route.modelId).toBe('claude-sonnet-4-6');
         expect(route.isCodexModel).toBe(false);
     });
+    it('supports xhigh thinking budgets', () => {
+        expect(buildThinkingConfig('xhigh')).toEqual({ budget: 32768, maxTokens: 36864 });
+    });
 });

package/dist/__tests__/sessions.test.js

@@ -2,14 +2,17 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdirSync, rmSync, existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
-import { loadHistory, saveExchange, replaceWithSummary, clearHistory, setSessionsDir, MAX_HISTORY_PAIRS, } from '../sessions.js';
+import { loadHistory, saveExchange, replaceWithSummary, clearHistory, setSessionsDir, clearSessionKeyCacheForTests, MAX_HISTORY_PAIRS, } from '../sessions.js';
 let testSessionsDir;
 beforeEach(() => {
+    clearSessionKeyCacheForTests();
+    process.env.SKIMPYCLAW_HISTORY_KEY = 'test-history-key';
     testSessionsDir = join(tmpdir(), `sk-sessions-test-${Date.now()}`);
     mkdirSync(testSessionsDir, { recursive: true });
     setSessionsDir(testSessionsDir);
 });
 afterEach(() => {
+    delete process.env.SKIMPYCLAW_HISTORY_KEY;
     if (existsSync(testSessionsDir)) {
         rmSync(testSessionsDir, { recursive: true, force: true });
     }
@@ -30,10 +33,10 @@ describe('saveExchange', () => {
         const filePath = join(testSessionsDir, 'telegram-111.jsonl');
         expect(existsSync(filePath)).toBe(true);
         const content = readFileSync(filePath, 'utf-8');
-        const entry = JSON.parse(content.trim());
-        expect(entry.user).toBe('hello');
-        expect(entry.assistant).toBe('hi there');
-        expect(entry.ts).toBeTruthy();
+        expect(content.trim().startsWith('ENCv1:')).toBe(true);
+        const messages = await loadHistory('telegram', '111');
+        expect(messages[0].content).toBe('hello');
+        expect(messages[1].content).toBe('hi there');
     });
     it('appends multiple entries', async () => {
         await saveExchange('telegram', '222', 'msg1', 'reply1');
@@ -42,8 +45,8 @@ describe('saveExchange', () => {
         const content = readFileSync(filePath, 'utf-8');
         const lines = content.trim().split('\n').filter(Boolean);
         expect(lines).toHaveLength(2);
-        expect(JSON.parse(lines[0]).user).toBe('msg1');
-        expect(JSON.parse(lines[1]).user).toBe('msg2');
+        expect(lines[0].startsWith('ENCv1:')).toBe(true);
+        expect(lines[1].startsWith('ENCv1:')).toBe(true);
     });
 });
 describe('loadHistory round-trip', () => {
@@ -96,9 +99,10 @@ describe('replaceWithSummary', () => {
         const content = readFileSync(filePath, 'utf-8');
         const lines = content.trim().split('\n').filter(Boolean);
         expect(lines).toHaveLength(1);
-        const entry = JSON.parse(lines[0]);
-        expect(entry.summary).toBe(true);
-        expect(entry.assistant).toBe('We talked about greetings.');
+        expect(lines[0].startsWith('ENCv1:')).toBe(true);
+        const messages = await loadHistory('telegram', '777');
+        expect(messages[0].content).toBe('Summary of our previous conversation:');
+        expect(messages[1].content).toBe('We talked about greetings.');
     });
     it('loadHistory after replaceWithSummary returns the summary pair', async () => {
         await saveExchange('telegram', '888', 'hello', 'world');

package/dist/__tests__/setup.test.js

@@ -11,7 +11,7 @@ describe('setup config generation', () => {
             selectedProviders,
             providerSecrets: { anthropicKey: 'sk-ant-test' },
         });
-        expect(config.agents.list.main.model).toBe('claude-opus');
+        expect(config.agents.list.main.model).toBe('anthropic/claude-opus-4-7');
         expect(config.models.providers.anthropic.apiKey).toBe('${ANTHROPIC_API_KEY}');
         expect(config.models.providers.codex.authPath).toBe('${HOME}/.codex/auth.json');
         expect(config.channels.telegram.allowFrom).toEqual([12345]);
@@ -19,30 +19,11 @@ describe('setup config generation', () => {
         expect(config.channels.telegram.defaultAllowedPaths).toEqual(['${HOME}/.skimpyclaw']);
         expect(config.channels.discord.defaultAllowedPaths).toEqual(['${HOME}/.skimpyclaw']);
         expect(config.heartbeat.tools.allowedPaths).toEqual(['${HOME}/.skimpyclaw']);
-        expect(config.models.aliases['claude-think']).toBe('anthropic/claude-sonnet-4-6');
-        expect(config.models.aliases['claude-opus']).toBe('anthropic/claude-opus-4-6');
-        expect(config.models.aliases.codex).toBe('codex/gpt-5.3-codex');
+        expect(config.models.aliases.codex).toBe('codex/gpt-5.5');
         expect(config.models.aliases['codex5.1']).toBe('codex/gpt-5.1-codex');
         expect(config.models.aliases['codex5.2']).toBe('codex/gpt-5.2-codex');
         expect(config.models.aliases['codex5.3']).toBe('codex/gpt-5.3-codex');
-    });
-    it('builds OpenAI-only config and env content', () => {
-        const selectedProviders = new Set(['openai-api']);
-        const { configJson, envContent } = buildSetupArtifacts({
-            workspaceDir: '/tmp/workspace',
-            telegramId: 'abc-user',
-            telegramToken: 'tg-token',
-            agentName: 'Claw',
-            selectedProviders,
-            providerSecrets: { openaiKey: 'sk-openai-test' },
-        });
-        const config = JSON.parse(configJson);
-        expect(config.agents.list.main.model).toBe('openai/gpt-4o');
-        expect(config.models.providers.openai.apiKey).toBe('${OPENAI_API_KEY}');
-        expect(config.channels.telegram.allowFrom).toEqual(['abc-user']);
-        expect(envContent).toContain('OPENAI_API_KEY=sk-openai-test');
-        expect(envContent).toContain('TELEGRAM_BOT_TOKEN=tg-token');
-        expect(envContent).not.toContain('ANTHROPIC_API_KEY=');
+        expect(config.models.aliases['codex5.5']).toBe('codex/gpt-5.5');
     });
     it('includes oauth placeholders when Anthropic OAuth is selected', () => {
         const selectedProviders = new Set(['anthropic-oauth']);
@@ -71,7 +52,7 @@ describe('setup config generation', () => {
         expect(config.gateway.host).toBe('127.0.0.1');
         expect(config.gateway.port).toBe(18790);
     });
-    it('disables browser when features.browser is false', () => {
+    it('does not include browser tools in generated config', () => {
         const config = buildSetupConfig({
             workspaceDir: '/tmp/workspace',
             telegramId: '12345',
@@ -79,12 +60,14 @@ describe('setup config generation', () => {
             agentName: 'Claw',
             selectedProviders: new Set(['anthropic-api']),
             providerSecrets: { anthropicKey: 'sk-ant-test' },
-            features: { browser: false, voice: false, mcp: false, sandbox: false },
+            features: { voice: false, mcp: false },
         });
-        expect(config.heartbeat.tools.browser.enabled).toBe(false);
+        expect(config.heartbeat.tools.browser).toBeUndefined();
+        expect(config.channels.telegram.tools.browser).toBeUndefined();
+        expect(config.channels.discord.tools.browser).toBeUndefined();
         expect(config.voice).toBeUndefined();
     });
-    it('enables browser and voice when features are true', () => {
+    it('enables voice when requested', () => {
         const config = buildSetupConfig({
             workspaceDir: '/tmp/workspace',
             telegramId: '12345',
@@ -92,9 +75,9 @@ describe('setup config generation', () => {
             agentName: 'Claw',
             selectedProviders: new Set(['anthropic-api']),
             providerSecrets: { anthropicKey: 'sk-ant-test' },
-            features: { browser: true, voice: true, mcp: false, sandbox: false },
+            features: { voice: true, mcp: false },
         });
-        expect(config.heartbeat.tools.browser.enabled).toBe(true);
+        expect(config.heartbeat.tools.browser).toBeUndefined();
         expect(config.voice).toBeDefined();
         expect(config.voice.enabled).toBe(true);
         expect(config.voice.channels.telegram.sendVoice).toBe(true);
@@ -135,7 +118,7 @@ describe('setup config generation', () => {
         });
         expect(config.cron.jobs).toHaveLength(3);
         expect(config.cron.jobs[0].id).toBe('memory-trim');
-        expect(config.cron.jobs[0].model).toBe('claude-fast');
+        expect(config.cron.jobs[0].model).toBe('anthropic/claude-haiku-4-5');
         expect(config.cron.jobs[1].id).toBe('tech-digest');
         expect(config.cron.jobs[2].id).toBe('weather');
         expect(config.cron.jobs[2].schedule.tz).toBe('America/New_York');

package/dist/__tests__/skills.test.js

@@ -2,14 +2,17 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdirSync, writeFileSync, rmSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
-import { loadSkills, getSkillsForContext, formatSkillsPrompt, checkEligibility } from '../skills.js';
+import { randomUUID } from 'crypto';
+import { loadSkills, getSkillsForContext, formatSkillsPrompt, checkEligibility, clearSkillsCache } from '../skills.js';
 // Create a temp skills directory for each test
 let skillsDir;
 beforeEach(() => {
-    skillsDir = join(tmpdir(), `skimpyclaw-skills-test-${Date.now()}`);
+    clearSkillsCache();
+    skillsDir = join(tmpdir(), `skimpyclaw-skills-test-${Date.now()}-${randomUUID()}`);
     mkdirSync(skillsDir, { recursive: true });
 });
 afterEach(() => {
+    clearSkillsCache();
     rmSync(skillsDir, { recursive: true, force: true });
 });
 function writeSkill(name, content) {
@@ -198,17 +201,17 @@ describe('checkEligibility', () => {
         expect(result.reason).toContain('Missing path');
     });
     it('fails on tools requirement when tools not enabled', () => {
-        const result = checkEligibility({ name: 'test', description: 'test', requires: { tools: ['Browser'] } }, { enabled: false, allowedPaths: [] });
+        const result = checkEligibility({ name: 'test', description: 'test', requires: { tools: ['Fetch'] } }, { enabled: false, allowedPaths: [] });
         expect(result.eligible).toBe(false);
         expect(result.reason).toContain('Tools not enabled');
     });
-    it('fails on browser tool requirement when browser not enabled', () => {
+    it('fails on unsupported tool requirement', () => {
         const result = checkEligibility({ name: 'test', description: 'test', requires: { tools: ['Browser'] } }, { enabled: true, allowedPaths: ['/tmp'] });
         expect(result.eligible).toBe(false);
-        expect(result.reason).toContain('Browser');
+        expect(result.reason).toContain('Unsupported tools requested: Browser');
     });
-    it('passes on browser tool requirement when browser enabled', () => {
-        const result = checkEligibility({ name: 'test', description: 'test', requires: { tools: ['Browser'] } }, { enabled: true, allowedPaths: ['/tmp'], browser: { enabled: true } });
+    it('passes on fetch tool requirement when tools are enabled', () => {
+        const result = checkEligibility({ name: 'test', description: 'test', requires: { tools: ['Fetch'] } }, { enabled: true, allowedPaths: ['/tmp'] });
         expect(result.eligible).toBe(true);
     });
     it('passes on code_with_agent requirement when tools enabled', () => {

package/dist/__tests__/stream-formatter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/stream-formatter.test.js

@@ -0,0 +1,114 @@
+import { describe, expect, it } from 'vitest';
+import { stripAnsi, chunkForDiscord, parseCodexJsonl, formatCodexOutput, } from '../code-agents/stream-formatter.js';
+describe('stripAnsi', () => {
+    it('removes color codes', () => {
+        const input = '\x1B[31mred text\x1B[0m plain';
+        expect(stripAnsi(input)).toBe('red text plain');
+    });
+    it('removes cursor moves', () => {
+        const input = 'a\x1B[2Kb';
+        expect(stripAnsi(input)).toBe('ab');
+    });
+    it('passes through plain text unchanged', () => {
+        expect(stripAnsi('hello world')).toBe('hello world');
+    });
+});
+describe('chunkForDiscord', () => {
+    it('returns empty array for empty input', () => {
+        expect(chunkForDiscord('')).toEqual([]);
+    });
+    it('returns single chunk for short input', () => {
+        expect(chunkForDiscord('short text')).toEqual(['short text']);
+    });
+    it('splits on paragraph boundaries when possible', () => {
+        const p1 = 'a'.repeat(1000);
+        const p2 = 'b'.repeat(1000);
+        const input = p1 + '\n\n' + p2;
+        const chunks = chunkForDiscord(input, 1900);
+        // Both paragraphs fit in 1900 together (1000 + 2 + 1000 = 2002 > 1900)
+        expect(chunks).toHaveLength(2);
+        expect(chunks[0]).toBe(p1);
+        expect(chunks[1]).toBe(p2);
+    });
+    it('packs multiple small paragraphs together', () => {
+        const input = 'one\n\ntwo\n\nthree';
+        expect(chunkForDiscord(input, 1900)).toEqual(['one\n\ntwo\n\nthree']);
+    });
+    it('hard-splits a paragraph that is larger than max', () => {
+        const huge = 'x'.repeat(5000);
+        const chunks = chunkForDiscord(huge, 1900);
+        expect(chunks).toHaveLength(Math.ceil(5000 / 1900));
+        expect(chunks.every(c => c.length <= 1900)).toBe(true);
+        expect(chunks.join('')).toBe(huge);
+    });
+    it('strips ANSI before chunking', () => {
+        const input = '\x1B[31mred\x1B[0m and more';
+        expect(chunkForDiscord(input)).toEqual(['red and more']);
+    });
+    it('trims trailing whitespace but preserves internal', () => {
+        expect(chunkForDiscord('hello\n\n  \n')).toEqual(['hello']);
+    });
+});
+describe('parseCodexJsonl', () => {
+    it('captures thread_id from thread.started', () => {
+        const input = JSON.stringify({ type: 'thread.started', thread_id: 'abc-123' });
+        const r = parseCodexJsonl(input);
+        expect(r.threadId).toBe('abc-123');
+        expect(r.messages).toEqual([]);
+    });
+    it('extracts agent_message text', () => {
+        const input = [
+            JSON.stringify({ type: 'thread.started', thread_id: 't1' }),
+            JSON.stringify({ type: 'turn.started' }),
+            JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'hi there' } }),
+            JSON.stringify({ type: 'turn.completed' }),
+        ].join('\n');
+        const r = parseCodexJsonl(input);
+        expect(r.threadId).toBe('t1');
+        expect(r.messages).toEqual(['hi there']);
+    });
+    it('condenses command_execution as tool-call line', () => {
+        const input = JSON.stringify({
+            type: 'item.completed',
+            item: { type: 'command_execution', command: 'ls -la', status: 'completed' },
+        });
+        const r = parseCodexJsonl(input);
+        expect(r.messages[0]).toContain('✓');
+        expect(r.messages[0]).toContain('ls -la');
+    });
+    it('condenses file_change with paths', () => {
+        const input = JSON.stringify({
+            type: 'item.completed',
+            item: { type: 'file_change', changes: [{ path: 'src/foo.ts' }, { path: 'src/bar.ts' }] },
+        });
+        const r = parseCodexJsonl(input);
+        expect(r.messages[0]).toContain('src/foo.ts');
+        expect(r.messages[0]).toContain('src/bar.ts');
+    });
+    it('ignores turn.started/completed', () => {
+        const input = [
+            JSON.stringify({ type: 'turn.started' }),
+            JSON.stringify({ type: 'turn.completed' }),
+        ].join('\n');
+        const r = parseCodexJsonl(input);
+        expect(r.messages).toEqual([]);
+    });
+    it('tolerates invalid JSON lines', () => {
+        const input = [
+            'not json',
+            JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'hi' } }),
+            '{"broken":',
+        ].join('\n');
+        const r = parseCodexJsonl(input);
+        expect(r.messages).toEqual(['hi']);
+    });
+});
+describe('formatCodexOutput', () => {
+    it('chunks each message independently', () => {
+        const short = 'hi';
+        const long = 'y'.repeat(5000);
+        const chunks = formatCodexOutput([short, long]);
+        expect(chunks[0]).toBe('hi');
+        expect(chunks.slice(1).every(c => c.length <= 1900)).toBe(true);
+    });
+});