skimpyclaw 0.3.15 → 0.4.0

package/README.md

@@ -1,17 +1,17 @@
 # SkimpyClaw 👙🦞
 
-Lightweight personal AI assistant (~23k LOC). Runs locally. Telegram/Discord chat, scheduled routines, a web dashboard, and a tool-enabled agent — all in one tiny service.
+Lightweight personal AI assistant (~21k LOC). Runs locally. Telegram/Discord chat, scheduled routines, a web dashboard, and a tool-enabled agent — all in one tiny service.
 
 ## Why SkimpyClaw vs OpenClaw
 
 Both are personal AI assistants you run yourself. The difference is scope.
 
-|                     | SkimpyClaw (~23k LOC)                   | OpenClaw (~700k LOC)                                     |
+|                     | SkimpyClaw (~21k LOC)                   | OpenClaw (~700k LOC)                                     |
 | ------------------- | --------------------------------------- | -------------------------------------------------------- |
 | **Channels**        | Telegram, Discord                       | WhatsApp, Signal, iMessage, Slack, Teams, Matrix, + more |
 | **Setup**           | `skimpyclaw onboard` → done             | Daemon + wizard + per-channel pairing                    |
 | **Codebase**        | Read it in an afternoon                 | Full platform with extensions, packages, native UI       |
-| **Model support**   | Anthropic, OpenAI, Kimi, MiniMax, Codex | Same + more                                              |
+| **Model support**   | Anthropic, Codex                        | Same + more                                              |
 | **Release cadence** | Move fast, no stability guarantees      | Stable / beta / dev channels                             |
 
 Use SkimpyClaw if you live in Telegram or Discord, want to read and own every line, and don't need 13 channels. Use OpenClaw if you need to support multiple channels like WhatsApp, Signal, iMessage, or Slack — or want a more polished, maintained platform.
@@ -19,10 +19,10 @@ Use SkimpyClaw if you live in Telegram or Discord, want to read and own every li
 ## Features
 
 - **Chat interface** — Telegram and Discord bots with persistent conversation history
-- **Tool-enabled agent** — file read/write, bash, browser (Playwright), MCP tools via mcporter
+- **Tool-enabled agent** — file read/write, bash, fetch, MCP tools via mcporter
 - **Multi-modal support** — voice messages (STT/TTS), image analysis
-- **Coding agents** — delegate to Claude Code / Codex CLI; `code_with_team` for parallel multi-agent work
-- **Code agents** — delegate coding tasks to Claude Code, Codex, or Kimi CLI with `code_with_agent` and `code_with_team`
+- **Agents** — configure multiple local agents with their own identity, prompts, model, effort, and memory; Discord adds reusable `/agent` profiles and `@alias <message>` shortcuts
+- **Coding agents** — delegate coding tasks to Claude Code or Codex with `code_with_agent`; Discord threads can also run bidirectional interactive Claude sessions that `--resume` the same process
 - **Cron scheduler** — run agent prompts or shell scripts on a schedule
 - **Web dashboard** — Preact/Vite SPA with status, cron, audit log, memory, templates, config editor, skills, approvals
 - **Heartbeat** — periodic keep-alive with Telegram/Discord alerts
@@ -31,15 +31,21 @@ Use SkimpyClaw if you live in Telegram or Discord, want to read and own every li
 - **Voice** — optional TTS/STT support (ElevenLabs, OpenAI, macOS `say`, local Whisper)
 - **Observability** — optional Langfuse tracing per agent turn
 - **Audit logging** — JSONL-based audit traces for all agent interactions
-- **Multiple model providers** — Anthropic, OpenAI, Kimi, MiniMax, Codex (ChatGPT backend), any OpenAI-compatible API
+- **Model providers** — Anthropic and Codex (ChatGPT backend)
 
 ## Architecture
 
+SkimpyClaw routes all model calls through a provider adapter registry in `src/providers/index.ts`.
+
+- `chat()` and `chatWithTools()` both resolve provider/model and dispatch to a `ProviderAdapter`.
+- Adapters implement `isAvailable()`, `chat()`, and `chatWithTools()` behavior via a shared interface.
+- Tool-enabled turns use one common execution path: `runToolLoop()` in `src/providers/tool-loop.ts`.
+- Context compaction is unified through shared context-management utilities used by all adapters.
+
 ```mermaid
 flowchart LR
   subgraph Channels
     user["Telegram / Discord"]
-    browser["Browser"]
   end
 
   subgraph Gateway["Fastify :18790"]
@@ -49,6 +55,9 @@ flowchart LR
 
   subgraph Core
     agent["Agent Runtime"]
+    registry["Provider Registry"]
+    adapters["Provider Adapters"]
+    loop["runToolLoop()"]
     codeAgents["Coding Agents"]
     cron["Cron"]
     hb["Heartbeat"]
@@ -58,19 +67,21 @@ flowchart LR
   end
 
   user --> agent
-  browser --> dash --> api --> agent
+  dash --> api --> agent
   cron --> agent
   hb --> agent
   agent --> codeAgents
   agent --> audit
   agent --> skills
   agent --> approvals
-  agent --> models["Anthropic / OpenAI / Codex"]
+  agent --> registry --> adapters
+  adapters --> loop
+  adapters --> models["Anthropic / Codex"]
   agent --> mcp["MCP Servers"]
   agent --> fs["~/.skimpyclaw"]
 ```
 
-See [docs/architecture.md](docs/architecture.md) for runtime flow and startup sequence diagrams.
+See [docs/guide/architecture.md](docs/guide/architecture.md) for runtime flow and startup sequence diagrams.
 
 ## Quick Start
 
@@ -85,16 +96,6 @@ Onboarding validates your Telegram token, provider auth, and creates:
 - `~/.skimpyclaw/config.json`
 - `~/.skimpyclaw/agents/main/*.md` (from templates)
 
-**Sandbox setup (optional — isolates Bash commands in a container):**
-
-```bash
-skimpyclaw sandbox init              # detect runtime, build image, update config
-skimpyclaw sandbox doctor            # verify everything works
-skimpyclaw restart                   # pick up sandbox config
-```
-
-Requires Apple Containers (macOS 26+) or Docker. See [docs/guide/sandbox.md](docs/guide/sandbox.md) for options.
-
 **Stop/Restart daemon (macOS):**
 
 ```bash
@@ -124,13 +125,18 @@ http://127.0.0.1:18790/dashboard
 
 Bearer token is shown in startup logs.
 
+## Security
+
+SkimpyClaw uses defense-in-depth for local execution: strict config/secrets handling, bearer-authenticated control endpoints, constrained tool paths, SSRF protections, and safer command execution defaults.
+
+For the full security model and controls, see [docs/guide/security.md](docs/guide/security.md).
+
 ## Tech Stack
 
 - **Backend:** TypeScript (ESM), Fastify, Vitest
 - **Frontend:** Preact, Vite, TypeScript
 - **Chat:** grammy (Telegram), discord.js (Discord)
 - **Scheduling:** Croner
-- **Browser:** Playwright
 - **AI SDKs:** Anthropic SDK, OpenAI SDK
 - **Observability:** Langfuse (optional)
 
@@ -140,12 +146,12 @@ Bearer token is shown in startup logs.
 src/
   index.ts              # App entrypoint with logging setup
   gateway.ts            # Fastify server + top-level routes
-  agent.ts              # Prompt assembly, model routing, tool loop, memory writes
+  agent.ts              # Prompt assembly, runAgentTurn orchestration, memory writes
   tools.ts              # Tool registry + dispatch
-  tools/                # Tool executors (bash, browser, file tools, path utils, execute context)
-  providers/            # Provider routing + provider implementations (anthropic/openai/codex)
-  code-agents/          # Background coding-agent runtime (executor/parser/orchestrator/registry)
-  channels/             # Channel adapters/utilities (telegram/discord)
+  tools/                # Tool executors (bash, fetch, file tools, path utils, execute context)
+  providers/            # Provider registry, adapters, unified tool loop, provider implementations
+  code-agents/          # Background coding-agent runtime (executor/parser/registry + interactive sessions)
+  channels/             # Channel adapters/utilities (telegram/discord, Discord agent profile routing)
   file-lock.ts          # In-memory file lock for concurrent writes
   audit.ts              # Append-only audit log (trace/event model, JSONL storage)
   cron.ts               # Job scheduling + execution + cron logging
@@ -202,17 +208,21 @@ dist/                   # Compiled output + built dashboard assets
 
 | Doc                                            | Contents                                                         |
 | ---------------------------------------------- | ---------------------------------------------------------------- |
-| [docs/architecture.md](docs/architecture.md)   | Component diagram, runtime flow, startup sequence, source layout |
-| [docs/configuration.md](docs/configuration.md) | Full config reference, all sections with examples                |
-| [docs/tools.md](docs/tools.md)                 | Built-in tools, browser tool, MCP integration, code agents       |
-| [docs/dashboard.md](docs/dashboard.md)         | Web dashboard, all HTTP endpoints + API routes                   |
-| [docs/coding-agents.md](docs/coding-agents.md) | Coding-agent execution model and CLI backends                    |
-| [docs/cli.md](docs/cli.md)                     | CLI commands, service management                                 |
-| [docs/chat-commands.md](docs/chat-commands.md) | Telegram/Discord bot commands                                    |
-| [docs/skills.md](docs/skills.md)               | Skills system, built-in skills, creating custom skills           |
-| [docs/data-storage.md](docs/data-storage.md)   | File layout, audit log format, security notes                    |
+| [docs/guide/architecture.md](docs/guide/architecture.md)   | Component diagram, runtime flow, startup sequence, source layout |
+| [docs/guide/configuration.md](docs/guide/configuration.md) | Full config reference, all sections with examples                |
+| [docs/guide/security.md](docs/guide/security.md)           | Security model and runtime safeguards                             |
+| [docs/guide/tools.md](docs/guide/tools.md)                 | Built-in tools, fetch, MCP integration, code agents             |
+| [docs/guide/dashboard.md](docs/guide/dashboard.md)         | Web dashboard, all HTTP endpoints + API routes                   |
+| [docs/guide/agents.md](docs/guide/agents.md)               | Core agents, prompt directories, Discord profile aliases         |
+| [docs/guide/coding-agents.md](docs/guide/coding-agents.md) | Coding-agent execution model and CLI backends                    |
+| [docs/guide/cli.md](docs/guide/cli.md)                     | CLI commands, service management                                 |
+| [docs/guide/chat-commands.md](docs/guide/chat-commands.md) | Telegram/Discord bot commands                                    |
+| [docs/guide/discord-updates.md](docs/guide/discord-updates.md) | Discord workflow documentation maintenance process            |
+| [docs/guide/changelog.md](docs/guide/changelog.md)         | Documentation and behavior changelog                              |
+| [docs/guide/skills.md](docs/guide/skills.md)               | Skills system, built-in skills, creating custom skills           |
+| [docs/guide/data-storage.md](docs/guide/data-storage.md)   | File layout, audit log format, security notes                    |
 | [Setup Guide](https://docs.skimpyclaw.xyz/guide/setup-guide.html) | Step-by-step installation and setup guide                        |
-| [docs/troubleshooting.md](docs/troubleshooting.md) | Common issues and solutions                                  |
+| [docs/guide/troubleshooting.md](docs/guide/troubleshooting.md) | Common issues and solutions                                  |
 
 ## Development
 

package/dist/__tests__/adapter-types.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Compile-time validation tests for adapter interfaces.
+ */
+export {};

package/dist/__tests__/adapter-types.test.js

@@ -0,0 +1,63 @@
+/**
+ * Compile-time validation tests for adapter interfaces.
+ */
+import { describe, it, expect } from 'vitest';
+import { buildToolLogEntry, logIteration } from '../providers/loop-utils.js';
+describe('ProviderAdapter interface', () => {
+    it('should define correct structure for NormalizedResponse', () => {
+        const response = {
+            hasToolCalls: false,
+            toolCalls: [],
+            textContent: 'test response',
+            usage: { inputTokens: 100, outputTokens: 50 },
+            rawResponse: {},
+        };
+        expect(response.hasToolCalls).toBe(false);
+        expect(response.textContent).toBe('test response');
+    });
+    it('should define correct structure for NormalizedToolCall', () => {
+        const toolCall = {
+            id: 'call_123',
+            name: 'testTool',
+            args: { param: 'value' },
+            rawArgs: '{"param":"value"}',
+        };
+        expect(toolCall.name).toBe('testTool');
+        expect(toolCall.args.param).toBe('value');
+    });
+    it('should define correct structure for ProviderMessages', () => {
+        const messages = {
+            messages: [{ role: 'user', content: 'test' }],
+            systemParam: 'system prompt',
+        };
+        expect(messages.messages).toHaveLength(1);
+        expect(messages.systemParam).toBe('system prompt');
+    });
+    it('should define correct structure for CompactionResult', () => {
+        const result = {
+            messages: [],
+            compacted: true,
+            method: 'llm',
+        };
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('llm');
+    });
+});
+describe('loop-utils', () => {
+    it('buildToolLogEntry should format tool calls correctly', () => {
+        const log = buildToolLogEntry('Read', 'file.txt', 'file contents here');
+        expect(log).toContain('Read');
+        expect(log).toContain('file.txt');
+        expect(log).toContain('file contents here');
+    });
+    it('buildToolLogEntry should truncate long inputs and outputs', () => {
+        const longInput = 'a'.repeat(200);
+        const longOutput = 'b'.repeat(300);
+        const log = buildToolLogEntry('Write', longInput, longOutput);
+        expect(log.length).toBeLessThan(320);
+        expect(log).toContain('...');
+    });
+    it('logIteration should not throw', () => {
+        expect(() => logIteration('test', 0, 10, 'model-id')).not.toThrow();
+    });
+});

package/dist/__tests__/anthropic-adapter.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for the Anthropic provider adapter.
+ */
+export {};

package/dist/__tests__/anthropic-adapter.test.js

@@ -0,0 +1,264 @@
+/**
+ * Tests for the Anthropic provider adapter.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AnthropicAdapter } from '../providers/adapters/anthropic-adapter.js';
+// Mock the Anthropic client - create a single shared mock
+const mockMessagesCreate = vi.fn();
+const mockMessagesStream = vi.fn();
+vi.mock('../providers/anthropic.js', () => ({
+    getAnthropicClient: vi.fn(() => ({
+        messages: {
+            create: mockMessagesCreate,
+            stream: mockMessagesStream,
+        },
+    })),
+}));
+// Mock utils
+vi.mock('../providers/utils.js', () => ({
+    buildSystemParam: vi.fn((content, cache) => ({ content, cache })),
+    addToolCacheBreakpoint: vi.fn((defs) => defs),
+    contentToText: vi.fn((content) => String(content)),
+    stripProvider: vi.fn((model) => model.replace(/^[^/]+\//, '')),
+    buildThinkingConfig: vi.fn(() => null),
+}));
+// Mock context manager
+vi.mock('../providers/context-manager.js', () => ({
+    compactMessages: vi.fn(async (messages) => ({
+        messages,
+        compacted: false,
+    })),
+    anthropicFormatHelper: {
+        isToolResult: () => false,
+        truncateToolResult: (item) => item,
+        serialize: () => '',
+        buildSummaryMessage: (s) => ({ role: 'user', content: [{ type: 'text', text: s }] }),
+    },
+}));
+// Mock observability
+vi.mock('../providers/observability.js', () => ({
+    toCostDetails: vi.fn(() => ({ input: 0.001, output: 0.002, total: 0.003 })),
+}));
+// Mock usage tracking
+vi.mock('../usage.js', () => ({
+    buildUsageRecord: vi.fn((opts) => opts),
+    recordUsage: vi.fn(),
+}));
+describe('AnthropicAdapter', () => {
+    let adapter;
+    let config;
+    let options;
+    beforeEach(async () => {
+        adapter = new AnthropicAdapter();
+        config = {
+            gateway: { port: 18790, mode: 'local' },
+            agents: { default: 'main', list: {} },
+            models: { providers: {}, aliases: {}, promptCaching: true },
+            channels: {
+                telegram: {
+                    enabled: false,
+                    token: 'test-token',
+                    allowFrom: [],
+                }
+            },
+            cron: { jobs: [] },
+            heartbeat: { intervalMs: 300000, prompt: 'HEARTBEAT' },
+        };
+        options = {
+            model: 'anthropic/claude-opus-4',
+            maxTokens: 1000,
+        };
+        // Clear mock call history
+        mockMessagesCreate.mockClear();
+        mockMessagesStream.mockClear();
+        const { recordUsage } = await import('../usage.js');
+        vi.mocked(recordUsage).mockClear();
+    });
+    describe('buildMessages', () => {
+        it('should extract system message and build API messages', () => {
+            const messages = [
+                { role: 'system', content: 'You are helpful' },
+                { role: 'user', content: 'Hello' },
+                { role: 'assistant', content: 'Hi!' },
+            ];
+            const result = adapter.buildMessages(messages, options, config);
+            expect(result.messages).toHaveLength(2); // system excluded
+            expect(result.messages[0].role).toBe('user');
+            expect(result.messages[1].role).toBe('assistant');
+            expect(result.systemParam).toBeDefined();
+        });
+        it('should handle missing system message', () => {
+            const messages = [
+                { role: 'user', content: 'Hello' },
+            ];
+            const result = adapter.buildMessages(messages, options, config);
+            expect(result.messages).toHaveLength(1);
+        });
+    });
+    describe('buildToolDefs', () => {
+        it('should return tool definitions with cache breakpoints when caching enabled', async () => {
+            const { addToolCacheBreakpoint } = await import('../providers/utils.js');
+            vi.mocked(addToolCacheBreakpoint).mockClear();
+            const toolDefs = [
+                { name: 'Read', description: 'Read file' },
+                { name: 'Write', description: 'Write file' },
+            ];
+            const result = adapter.buildToolDefs(toolDefs, config);
+            expect(result).toHaveLength(2);
+            expect(result[0].name).toBe('Read');
+            expect(addToolCacheBreakpoint).toHaveBeenCalled();
+        });
+        it('should skip cache breakpoints when promptCaching is false', async () => {
+            const { addToolCacheBreakpoint } = await import('../providers/utils.js');
+            vi.mocked(addToolCacheBreakpoint).mockClear();
+            const noCacheConfig = {
+                ...config,
+                models: { ...config.models, promptCaching: false },
+            };
+            const toolDefs = [{ name: 'Read', description: 'Read file' }];
+            adapter.buildToolDefs(toolDefs, noCacheConfig);
+            expect(addToolCacheBreakpoint).not.toHaveBeenCalled();
+        });
+    });
+    describe('call', () => {
+        it('should normalize Anthropic response without tool calls', async () => {
+            mockMessagesCreate.mockResolvedValue({
+                content: [{ type: 'text', text: 'Hello!' }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 100, output_tokens: 50 },
+            });
+            const providerMessages = {
+                messages: [{ role: 'user', content: 'Hi' }],
+                systemParam: { content: 'system' },
+            };
+            const result = await adapter.call(providerMessages, [], options, config);
+            expect(result.hasToolCalls).toBe(false);
+            expect(result.textContent).toBe('Hello!');
+            expect(result.usage?.inputTokens).toBe(100);
+            expect(result.usage?.outputTokens).toBe(50);
+        });
+        it('should normalize Anthropic response with tool calls', async () => {
+            mockMessagesCreate.mockResolvedValue({
+                content: [
+                    { type: 'text', text: 'Let me read that file' },
+                    {
+                        type: 'tool_use',
+                        id: 'tool_123',
+                        name: 'Read',
+                        input: { file_path: 'test.txt' },
+                    },
+                ],
+                stop_reason: 'tool_use',
+                usage: { input_tokens: 150, output_tokens: 80 },
+            });
+            const providerMessages = {
+                messages: [{ role: 'user', content: 'Read test.txt' }],
+                systemParam: { content: 'system' },
+            };
+            const result = await adapter.call(providerMessages, [], options, config);
+            expect(result.hasToolCalls).toBe(true);
+            expect(result.toolCalls).toHaveLength(1);
+            expect(result.toolCalls[0].id).toBe('tool_123');
+            expect(result.toolCalls[0].name).toBe('Read');
+            expect(result.toolCalls[0].args).toEqual({ file_path: 'test.txt' });
+            expect(result.textContent).toBe('Let me read that file');
+        });
+        it('should handle cache metrics logging', async () => {
+            const consoleSpy = vi.spyOn(console, 'log');
+            mockMessagesCreate.mockResolvedValue({
+                content: [{ type: 'text', text: 'Cached response' }],
+                stop_reason: 'end_turn',
+                usage: {
+                    input_tokens: 100,
+                    output_tokens: 50,
+                    cache_read_input_tokens: 500,
+                    cache_creation_input_tokens: 100,
+                },
+            });
+            const providerMessages = {
+                messages: [{ role: 'user', content: 'Hi' }],
+            };
+            await adapter.call(providerMessages, [], options, config);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[cache]'));
+        });
+        it('should use streaming for large xhigh thinking requests', async () => {
+            const { buildThinkingConfig } = await import('../providers/utils.js');
+            vi.mocked(buildThinkingConfig).mockReturnValueOnce({ budget: 32768, maxTokens: 36864 });
+            const finalMessage = vi.fn().mockResolvedValue({
+                content: [{ type: 'text', text: 'Streamed response' }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 100, output_tokens: 50 },
+            });
+            mockMessagesStream.mockReturnValue({ finalMessage });
+            const providerMessages = {
+                messages: [{ role: 'user', content: 'Hi' }],
+            };
+            const result = await adapter.call(providerMessages, [], { ...options, thinking: 'xhigh' }, config);
+            expect(mockMessagesCreate).not.toHaveBeenCalled();
+            expect(mockMessagesStream).toHaveBeenCalledWith(expect.objectContaining({
+                max_tokens: 36864,
+                thinking: { type: 'enabled', budget_tokens: 32768 },
+            }));
+            expect(result.textContent).toBe('Streamed response');
+        });
+    });
+    describe('appendAssistantResponse', () => {
+        it('should append raw response to messages', () => {
+            const providerMessages = {
+                messages: [{ role: 'user', content: 'Hi' }],
+            };
+            const rawResponse = {
+                content: [{ type: 'text', text: 'Hello' }],
+            };
+            adapter.appendAssistantResponse(providerMessages, rawResponse);
+            expect(providerMessages.messages).toHaveLength(2);
+            expect(providerMessages.messages[1].role).toBe('assistant');
+            expect(providerMessages.messages[1].content).toBe(rawResponse.content);
+        });
+    });
+    describe('appendToolResult', () => {
+        it('should append tool result as user message', () => {
+            const providerMessages = {
+                messages: [{ role: 'user', content: 'Hi' }],
+            };
+            adapter.appendToolResult(providerMessages, 'tool_123', 'file contents', false);
+            expect(providerMessages.messages).toHaveLength(2);
+            expect(providerMessages.messages[1].role).toBe('user');
+            expect(providerMessages.messages[1].content).toHaveLength(1);
+            expect(providerMessages.messages[1].content[0].type).toBe('tool_result');
+            expect(providerMessages.messages[1].content[0].tool_use_id).toBe('tool_123');
+        });
+        it('should mark error results', () => {
+            const providerMessages = {
+                messages: [],
+            };
+            adapter.appendToolResult(providerMessages, 'tool_123', 'error!', true);
+            expect(providerMessages.messages[0].content[0].is_error).toBe(true);
+        });
+    });
+    describe('compactMessages', () => {
+        it('should delegate to generic compactMessages with anthropicFormatHelper', async () => {
+            const { compactMessages } = await import('../providers/context-manager.js');
+            const providerMessages = {
+                messages: [{ role: 'user', content: 'Hi' }],
+            };
+            const result = await adapter.compactMessages(providerMessages, {}, 1, config);
+            expect(compactMessages).toHaveBeenCalled();
+            expect(result.compacted).toBe(false);
+        });
+    });
+    describe('recordUsage', () => {
+        it('should record usage with costs', async () => {
+            const { recordUsage } = await import('../usage.js');
+            adapter.recordUsage('claude-opus-4', { inputTokens: 100, outputTokens: 50 }, 'api', 'agent-1');
+            expect(recordUsage).toHaveBeenCalled();
+        });
+        it('should skip recording when tokens are zero', async () => {
+            const { recordUsage } = await import('../usage.js');
+            vi.mocked(recordUsage).mockClear();
+            adapter.recordUsage('claude-opus-4', { inputTokens: 0, outputTokens: 0 }, 'api');
+            // recordUsage should not be called when tokens are zero
+            expect(recordUsage).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/__tests__/api.test.js

@@ -889,7 +889,6 @@ describe('Health endpoint', () => {
         expect(body).toHaveProperty('features');
         expect(body.features).toHaveProperty('telegram');
         expect(body.features).toHaveProperty('discord');
-        expect(body.features).toHaveProperty('browser');
         expect(body.features).toHaveProperty('voice');
     });
     it('GET /api/dashboard/health returns env var status', async () => {

package/dist/__tests__/cli.integration.test.js

@@ -1,10 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { spawnSync } from 'child_process';
-import { join } from 'path';
 describe('cli integration', () => {
-    it('onboard --dry-run exits successfully without prompting', () => {
-        const tsxCli = join(process.cwd(), 'node_modules', 'tsx', 'dist', 'cli.mjs');
-        const result = spawnSync(process.execPath, [tsxCli, 'src/cli.ts', 'onboard', '--dry-run'], {
+    it('onboard --dry-run exits successfully without prompting', { timeout: 30000 }, () => {
+        const result = spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', 'onboard', '--dry-run'], {
             cwd: process.cwd(),
             encoding: 'utf-8',
         });

package/dist/__tests__/cli.test.js

@@ -175,7 +175,6 @@ describe('runCli', () => {
                     codex: { authPath: '~/.codex/auth.json' },
                 },
                 aliases: {
-                    'claude-fast': 'anthropic/claude-haiku-4-5',
                     'codex5.1': 'codex/gpt-5.1-codex',
                     'codex5.3': 'codex/gpt-5.3-codex',
                 },