skimpyclaw 0.3.10 → 0.3.14

package/dist/__tests__/channels.test.js

@@ -18,7 +18,7 @@ const discordMock = vi.hoisted(() => ({
     getDiscordDefaultTarget: vi.fn(() => '999'),
 }));
 vi.mock('../channels/telegram/index.js', () => telegramMock);
-vi.mock('../discord.js', () => discordMock);
+vi.mock('../channels/discord/index.js', () => discordMock);
 import { getActiveChannelId, initActiveChannel, sendActiveChannelProactiveMessage, } from '../channels.js';
 function makeConfig(overrides = {}) {
     return {

package/dist/__tests__/context-manager.test.js

@@ -1,5 +1,22 @@
-import { describe, it, expect } from 'vitest';
-import { estimateTokens, compactAnthropicMessages, compactOpenAIMessages, compactCodexMessages, } from '../providers/context-manager.js';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { estimateTokens, compactAnthropicMessages, compactOpenAIMessages, compactCodexMessages, serializeAnthropicMessages, serializeOpenAIMessages, serializeCodexMessages, } from '../providers/context-manager.js';
+// Mock the chat function used for LLM summarization
+vi.mock('../providers/index.js', () => ({
+    chat: vi.fn().mockResolvedValue('Summary of the conversation: the user asked to list files and the assistant ran ls.'),
+}));
+import { chat } from '../providers/index.js';
+const mockChat = vi.mocked(chat);
+// Minimal config for LLM compaction
+const fullConfig = {
+    models: {
+        providers: { anthropic: { apiKey: 'test' } },
+        aliases: {},
+    },
+};
+beforeEach(() => {
+    mockChat.mockClear();
+    mockChat.mockResolvedValue('Summary of the conversation: the user asked to list files and the assistant ran ls.');
+});
 // Helper: build an Anthropic-style tool exchange (assistant + user pair)
 function anthropicExchange(toolResult) {
     return [
@@ -23,6 +40,17 @@ function codexExchange(output) {
         { type: 'function_call_output', call_id: 'fc_1', output },
     ];
 }
+// Helper: build an OpenAI-style tool exchange (assistant + tool result)
+function openaiExchange(toolResult) {
+    return [
+        {
+            role: 'assistant',
+            content: null,
+            tool_calls: [{ id: 'tc_1', type: 'function', function: { name: 'Bash', arguments: '{}' } }],
+        },
+        { role: 'tool', tool_call_id: 'tc_1', content: toolResult },
+    ];
+}
 describe('estimateTokens', () => {
     it('returns a positive number for non-empty data', () => {
         expect(estimateTokens([{ role: 'user', content: 'hello' }])).toBeGreaterThan(0);
@@ -37,200 +65,315 @@ describe('estimateTokens', () => {
     });
 });
 describe('compactAnthropicMessages', () => {
-    it('passes through unchanged when under threshold', () => {
+    it('passes through unchanged when under threshold', async () => {
         const messages = anthropicExchange('short result');
-        const result = compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
-        expect(result).toEqual(messages);
+        const result = await compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
+        expect(result.messages).toEqual(messages);
+        expect(result.compacted).toBe(false);
     });
-    it('returns same reference when no compaction needed', () => {
+    it('returns same reference when no compaction needed', async () => {
         const messages = anthropicExchange('short result');
-        const result = compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
-        expect(result).toBe(messages);
+        const result = await compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
+        expect(result.messages).toBe(messages);
+    });
+    it('uses LLM summarization when fullConfig is provided', async () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...anthropicExchange(longResult));
+        }
+        const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('llm');
+        expect(result.summary).toBeTruthy();
+        expect(result.tokensBefore).toBeGreaterThan(0);
+        expect(result.tokensAfter).toBeGreaterThan(0);
+        expect(result.tokensAfter).toBeLessThan(result.tokensBefore);
+        expect(mockChat).toHaveBeenCalledOnce();
+        // First message should be the summary
+        expect(result.messages[0].role).toBe('user');
+        expect(result.messages[0].content[0].text).toContain('[Conversation Summary]');
+        // Last 8 should be preserved
+        expect(result.messages.slice(-8)).toEqual(messages.slice(-8));
     });
-    it('truncates old tool_result content when over threshold', () => {
+    it('falls back to truncation when LLM fails', async () => {
+        mockChat.mockRejectedValueOnce(new Error('API error'));
         const longResult = 'x'.repeat(10_000);
-        // Build many exchanges to exceed threshold
         const messages = [];
         for (let i = 0; i < 30; i++) {
             messages.push(...anthropicExchange(longResult));
         }
-        const result = compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
+        const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('truncation');
         // Head messages should have truncated tool results
-        const headMessages = result.slice(0, -8);
-        const toolResultMessages = headMessages.filter(m => Array.isArray(m.content) && m.content.some((b) => b.type === 'tool_result'));
+        const headMessages = result.messages.slice(0, -8);
+        const toolResultMessages = headMessages.filter((m) => Array.isArray(m.content) && m.content.some((b) => b.type === 'tool_result'));
         for (const msg of toolResultMessages) {
             const block = msg.content.find((b) => b.type === 'tool_result');
             expect(block.content).toContain('[truncated]');
             expect(block.content.length).toBeLessThan(longResult.length);
         }
     });
-    it('keeps last 8 messages intact when compacting', () => {
+    it('falls back to truncation without fullConfig', async () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...anthropicExchange(longResult));
+        }
+        const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('truncation');
+        expect(mockChat).not.toHaveBeenCalled();
+    });
+    it('keeps last 8 messages intact when compacting', async () => {
         const longResult = 'x'.repeat(10_000);
         const messages = [];
         for (let i = 0; i < 30; i++) {
             messages.push(...anthropicExchange(longResult));
         }
-        const result = compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
+        const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
         // Last 8 messages should be untouched
-        const tail = result.slice(-8);
+        const tail = result.messages.slice(-8);
         const originalTail = messages.slice(-8);
         expect(tail).toEqual(originalTail);
     });
-    it('does not mutate the input array', () => {
+    it('does not mutate the input array', async () => {
         const longResult = 'x'.repeat(10_000);
         const messages = [];
         for (let i = 0; i < 30; i++) {
             messages.push(...anthropicExchange(longResult));
         }
         const originalJson = JSON.stringify(messages);
-        compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
+        await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
         expect(JSON.stringify(messages)).toBe(originalJson);
     });
-    it('preserves non-tool_result blocks unchanged', () => {
+    it('passes through unchanged when disabled', async () => {
         const longResult = 'x'.repeat(10_000);
         const messages = [];
         for (let i = 0; i < 30; i++) {
             messages.push(...anthropicExchange(longResult));
         }
-        const result = compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
-        // Assistant messages (tool_use blocks) should be untouched
-        const assistantMessages = result.filter(m => m.role === 'assistant');
-        for (const msg of assistantMessages) {
-            const toolUse = msg.content.find((b) => b.type === 'tool_use');
-            expect(toolUse).toBeDefined();
-            expect(toolUse.name).toBe('Bash');
-        }
+        const result = await compactAnthropicMessages(messages, { enabled: false, maxContextTokens: 1 });
+        expect(result.messages).toBe(messages);
+        expect(result.compacted).toBe(false);
     });
-    it('passes through unchanged when disabled', () => {
+    it('includes token counts in result', async () => {
         const longResult = 'x'.repeat(10_000);
         const messages = [];
         for (let i = 0; i < 30; i++) {
             messages.push(...anthropicExchange(longResult));
         }
-        const result = compactAnthropicMessages(messages, { enabled: false, maxContextTokens: 1 });
-        expect(result).toBe(messages);
+        const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.tokensBefore).toBeGreaterThan(1_000);
+        expect(result.tokensAfter).toBeDefined();
     });
 });
-// Helper: build an OpenAI-style tool exchange (assistant + tool result)
-function openaiExchange(toolResult) {
-    return [
-        {
-            role: 'assistant',
-            content: null,
-            tool_calls: [{ id: 'tc_1', type: 'function', function: { name: 'Bash', arguments: '{}' } }],
-        },
-        { role: 'tool', tool_call_id: 'tc_1', content: toolResult },
-    ];
-}
 describe('compactOpenAIMessages', () => {
-    it('passes through unchanged when under threshold', () => {
+    it('passes through unchanged when under threshold', async () => {
         const messages = openaiExchange('short result');
-        const result = compactOpenAIMessages(messages, { maxContextTokens: 100_000 });
-        expect(result).toBe(messages);
+        const result = await compactOpenAIMessages(messages, { maxContextTokens: 100_000 });
+        expect(result.messages).toBe(messages);
+        expect(result.compacted).toBe(false);
+    });
+    it('uses LLM summarization when fullConfig is provided', async () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...openaiExchange(longResult));
+        }
+        const result = await compactOpenAIMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('llm');
+        expect(result.messages[0].role).toBe('user');
+        expect(result.messages[0].content).toContain('[Conversation Summary]');
     });
-    it('truncates old tool content when over threshold', () => {
+    it('falls back to truncation when LLM fails', async () => {
+        mockChat.mockRejectedValueOnce(new Error('API error'));
         const longResult = 'x'.repeat(10_000);
         const messages = [];
         for (let i = 0; i < 30; i++) {
             messages.push(...openaiExchange(longResult));
         }
-        const result = compactOpenAIMessages(messages, { maxContextTokens: 1_000 });
-        const headItems = result.slice(0, -8);
+        const result = await compactOpenAIMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.method).toBe('truncation');
+        const headItems = result.messages.slice(0, -8);
         const toolMessages = headItems.filter((m) => m.role === 'tool');
         for (const msg of toolMessages) {
             expect(msg.content).toContain('[truncated]');
-            expect(msg.content.length).toBeLessThan(longResult.length);
         }
     });
-    it('keeps last 8 messages intact', () => {
+    it('keeps last 8 messages intact', async () => {
         const longResult = 'x'.repeat(10_000);
         const messages = [];
         for (let i = 0; i < 30; i++) {
             messages.push(...openaiExchange(longResult));
         }
-        const result = compactOpenAIMessages(messages, { maxContextTokens: 1_000 });
-        expect(result.slice(-8)).toEqual(messages.slice(-8));
+        const result = await compactOpenAIMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.messages.slice(-8)).toEqual(messages.slice(-8));
     });
-    it('does not mutate the input array', () => {
+    it('does not mutate the input array', async () => {
         const longResult = 'x'.repeat(10_000);
         const messages = [];
         for (let i = 0; i < 30; i++) {
             messages.push(...openaiExchange(longResult));
         }
         const original = JSON.stringify(messages);
-        compactOpenAIMessages(messages, { maxContextTokens: 1_000 });
+        await compactOpenAIMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
         expect(JSON.stringify(messages)).toBe(original);
     });
-    it('passes through unchanged when disabled', () => {
+    it('passes through unchanged when disabled', async () => {
         const longResult = 'x'.repeat(10_000);
         const messages = [];
         for (let i = 0; i < 30; i++) {
             messages.push(...openaiExchange(longResult));
         }
-        const result = compactOpenAIMessages(messages, { enabled: false, maxContextTokens: 1 });
-        expect(result).toBe(messages);
+        const result = await compactOpenAIMessages(messages, { enabled: false, maxContextTokens: 1 });
+        expect(result.messages).toBe(messages);
+        expect(result.compacted).toBe(false);
     });
 });
 describe('compactCodexMessages', () => {
-    it('passes through unchanged when under threshold', () => {
+    it('passes through unchanged when under threshold', async () => {
         const items = codexExchange('short result');
-        const result = compactCodexMessages(items, { maxContextTokens: 100_000 });
-        expect(result).toEqual(items);
+        const result = await compactCodexMessages(items, { maxContextTokens: 100_000 });
+        expect(result.messages).toEqual(items);
+        expect(result.compacted).toBe(false);
     });
-    it('truncates old function_call_output when over threshold', () => {
+    it('uses LLM summarization when fullConfig is provided', async () => {
         const longOutput = 'x'.repeat(10_000);
         const items = [];
         for (let i = 0; i < 30; i++) {
             items.push(...codexExchange(longOutput));
         }
-        const result = compactCodexMessages(items, { maxContextTokens: 1_000 });
-        const headItems = result.slice(0, -8);
+        const result = await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('llm');
+        expect(result.messages[0].type).toBe('message');
+        expect(result.messages[0].content).toContain('[Conversation Summary]');
+    });
+    it('falls back to truncation when LLM fails', async () => {
+        mockChat.mockRejectedValueOnce(new Error('API error'));
+        const longOutput = 'x'.repeat(10_000);
+        const items = [];
+        for (let i = 0; i < 30; i++) {
+            items.push(...codexExchange(longOutput));
+        }
+        const result = await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.method).toBe('truncation');
+        const headItems = result.messages.slice(0, -8);
         const outputItems = headItems.filter((item) => item.type === 'function_call_output');
         for (const item of outputItems) {
             expect(item.output).toContain('[truncated]');
-            expect(item.output.length).toBeLessThan(longOutput.length);
         }
     });
-    it('keeps last 8 items intact when compacting', () => {
+    it('keeps last 8 items intact when compacting', async () => {
         const longOutput = 'x'.repeat(10_000);
         const items = [];
         for (let i = 0; i < 30; i++) {
             items.push(...codexExchange(longOutput));
         }
-        const result = compactCodexMessages(items, { maxContextTokens: 1_000 });
-        const tail = result.slice(-8);
-        const originalTail = items.slice(-8);
-        expect(tail).toEqual(originalTail);
+        const result = await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.messages.slice(-8)).toEqual(items.slice(-8));
     });
-    it('does not mutate the input array', () => {
+    it('does not mutate the input array', async () => {
         const longOutput = 'x'.repeat(10_000);
         const items = [];
         for (let i = 0; i < 30; i++) {
             items.push(...codexExchange(longOutput));
         }
         const originalJson = JSON.stringify(items);
-        compactCodexMessages(items, { maxContextTokens: 1_000 });
+        await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
         expect(JSON.stringify(items)).toBe(originalJson);
     });
-    it('preserves function_call items (not just outputs) unchanged', () => {
+    it('preserves function_call items unchanged', async () => {
+        mockChat.mockRejectedValueOnce(new Error('fail')); // force truncation
         const longOutput = 'x'.repeat(10_000);
         const items = [];
         for (let i = 0; i < 30; i++) {
             items.push(...codexExchange(longOutput));
         }
-        const result = compactCodexMessages(items, { maxContextTokens: 1_000 });
-        const callItems = result.filter((item) => item.type === 'function_call');
+        const result = await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
+        const callItems = result.messages.filter((item) => item.type === 'function_call');
         for (const item of callItems) {
             expect(item.name).toBe('Bash');
         }
     });
-    it('passes through unchanged when disabled', () => {
+    it('passes through unchanged when disabled', async () => {
         const longOutput = 'x'.repeat(10_000);
         const items = [];
         for (let i = 0; i < 30; i++) {
             items.push(...codexExchange(longOutput));
         }
-        const result = compactCodexMessages(items, { enabled: false, maxContextTokens: 1 });
-        expect(result).toBe(items);
+        const result = await compactCodexMessages(items, { enabled: false, maxContextTokens: 1 });
+        expect(result.messages).toBe(items);
+        expect(result.compacted).toBe(false);
+    });
+});
+describe('serializers', () => {
+    it('serializeAnthropicMessages produces readable transcript', () => {
+        const messages = [
+            { role: 'user', content: [{ type: 'text', text: 'List files' }] },
+            {
+                role: 'assistant',
+                content: [
+                    { type: 'text', text: 'Let me check.' },
+                    { type: 'tool_use', id: 'tu_1', name: 'Bash', input: { command: 'ls' } },
+                ],
+            },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'file1.ts\nfile2.ts' }] },
+        ];
+        const transcript = serializeAnthropicMessages(messages);
+        expect(transcript).toContain('[User]: List files');
+        expect(transcript).toContain('[Assistant]: Let me check.');
+        expect(transcript).toContain('[Assistant Tool Call: Bash]');
+        expect(transcript).toContain('[Tool Result]: file1.ts');
+    });
+    it('serializeOpenAIMessages produces readable transcript', () => {
+        const messages = [
+            { role: 'user', content: 'List files' },
+            {
+                role: 'assistant',
+                content: 'Let me check.',
+                tool_calls: [{ id: 'tc_1', type: 'function', function: { name: 'Bash', arguments: '{"command":"ls"}' } }],
+            },
+            { role: 'tool', tool_call_id: 'tc_1', content: 'file1.ts\nfile2.ts' },
+        ];
+        const transcript = serializeOpenAIMessages(messages);
+        expect(transcript).toContain('[User]: List files');
+        expect(transcript).toContain('[Assistant]: Let me check.');
+        expect(transcript).toContain('[Assistant Tool Call: Bash]');
+        expect(transcript).toContain('[Tool Result (tc_1)]: file1.ts');
+    });
+    it('serializeCodexMessages produces readable transcript', () => {
+        const items = [
+            { type: 'message', role: 'user', content: 'List files' },
+            { type: 'function_call', call_id: 'fc_1', name: 'Bash', arguments: '{"command":"ls"}' },
+            { type: 'function_call_output', call_id: 'fc_1', output: 'file1.ts\nfile2.ts' },
+        ];
+        const transcript = serializeCodexMessages(items);
+        expect(transcript).toContain('[User]: List files');
+        expect(transcript).toContain('[Assistant Tool Call: Bash]');
+        expect(transcript).toContain('[Tool Result]: file1.ts');
+    });
+    it('truncates long tool inputs and results in serialization', () => {
+        const longContent = 'x'.repeat(2000);
+        const messages = [
+            {
+                role: 'assistant',
+                content: [
+                    { type: 'tool_use', id: 'tu_1', name: 'ReadFile', input: longContent },
+                ],
+            },
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: longContent }] },
+        ];
+        const transcript = serializeAnthropicMessages(messages);
+        // Tool input should be truncated to ~500 + ...
+        expect(transcript).toContain('...');
+        // Tool result should be truncated to ~1000 + ...
+        const lines = transcript.split('\n');
+        for (const line of lines) {
+            expect(line.length).toBeLessThan(2500);
+        }
     });
 });

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

@@ -42,6 +42,8 @@ describe('provider utils', () => {
         expect(resolveModel('claude-3-5-haiku-20241022', cfg)).toBe('claude-haiku-4-5');
         expect(resolveModel('anthropic/claude-3-5-haiku-20241022', cfg)).toBe('anthropic/claude-haiku-4-5');
         expect(resolveModel('claude-3.5-haiku', cfg)).toBe('claude-haiku-4-5');
+        expect(resolveModel('claude-haiku', cfg)).toBe('claude-haiku-4-5');
+        expect(resolveModel('anthropic/claude-haiku', cfg)).toBe('anthropic/claude-haiku-4-5');
     });
     it('migrates deprecated claude opus 4 model ids', () => {
         const cfg = { models: { aliases: {} } };

package/dist/__tests__/sandbox-manager.test.js

@@ -61,6 +61,31 @@ describe('sandbox/manager', () => {
             expect(mockRemoveContainer).toHaveBeenCalledWith('skimpyclaw-sbx-default');
             expect(mockCreateContainer).toHaveBeenCalledTimes(1);
         });
+        it('expands ${VAR} references in env from process.env', async () => {
+            process.env.MY_SECRET = 'hunter2';
+            try {
+                const configWithEnv = {
+                    ...testConfig,
+                    env: { TOKEN: '${MY_SECRET}', PLAIN: 'literal' },
+                };
+                await ensureContainer('env-test', configWithEnv, ['/p']);
+                const opts = mockCreateContainer.mock.calls[0][1];
+                expect(opts.env).toEqual({ TOKEN: 'hunter2', PLAIN: 'literal' });
+            }
+            finally {
+                delete process.env.MY_SECRET;
+            }
+        });
+        it('expands unset ${VAR} to empty string', async () => {
+            delete process.env.NONEXISTENT_VAR_XYZ;
+            const configWithEnv = {
+                ...testConfig,
+                env: { VAL: '${NONEXISTENT_VAR_XYZ}' },
+            };
+            await ensureContainer('env-test2', configWithEnv, ['/p']);
+            const opts = mockCreateContainer.mock.calls[0][1];
+            expect(opts.env).toEqual({ VAL: '' });
+        });
     });
     describe('releaseContainer', () => {
         it('removes container and clears from map', async () => {

package/dist/__tests__/sandbox-mount-security.test.js

@@ -119,6 +119,14 @@ describe('sandbox/mount-security', () => {
         it('returns original path if no mount matches', () => {
             expect(translatePath('/tmp/random/file', mounts)).toBe('/tmp/random/file');
         });
+        it('expands ~ to home directory before matching', () => {
+            const home = process.env.HOME || '/Users/katre';
+            const homeMounts = [
+                { host: `${home}/.skimpyclaw`, container: '/workspace/config', readOnly: false },
+            ];
+            expect(translatePath('~/.skimpyclaw/agents/main/HEARTBEAT.md', homeMounts))
+                .toBe('/workspace/config/agents/main/HEARTBEAT.md');
+        });
         it('matches most specific mount first', () => {
             const nestedMounts = [
                 { host: '/Users/katre', container: '/workspace/home', readOnly: false },

package/dist/__tests__/setup.test.js

@@ -135,7 +135,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-haiku');
+        expect(config.cron.jobs[0].model).toBe('claude-fast');
         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__/tools.test.js

@@ -60,11 +60,11 @@ describe('getToolDefinitions', () => {
         expect(tools.map(t => t.name)).not.toContain('Browser');
     });
     describe('tool profiles', () => {
-        it('minimal returns exactly 4 built-in tools', async () => {
+        it('minimal returns built-in tools plus Fetch', async () => {
             const config = { ...toolConfig, toolProfile: 'minimal' };
             const tools = await getToolDefinitions(config, { includeAgentTools: true, includeMcp: true });
-            expect(tools).toHaveLength(4);
-            expect(tools.map(t => t.name)).toEqual(['Read', 'Write', 'Glob', 'Bash']);
+            expect(tools).toHaveLength(5);
+            expect(tools.map(t => t.name)).toEqual(['Read', 'Write', 'Glob', 'Bash', 'Fetch']);
         });
         it('minimal excludes Browser even when browser.enabled is true', async () => {
             const config = { ...toolConfig, toolProfile: 'minimal', browser: { enabled: true } };
@@ -199,13 +199,15 @@ describe('bash', () => {
         const result = await executeTool('Bash', { command: 'echo hello' }, toolConfig);
         expect(result.trim()).toBe('hello');
     });
-    it('blocks dangerous commands', async () => {
-        const result = await executeTool('Bash', { command: 'rm -rf /' }, toolConfig);
-        expect(result).toContain('Error: Command blocked');
+    it('blocks dangerous commands via exec approval', async () => {
+        const result = await executeTool('Bash', { command: `rm -rf ${TEST_DIR}` }, toolConfig);
+        expect(result).toContain('⛔');
+        expect(result).toContain('tier 3');
     });
-    it('blocks sudo', async () => {
-        const result = await executeTool('Bash', { command: 'sudo cat /etc/passwd' }, toolConfig);
-        expect(result).toContain('Error: Command blocked');
+    it('blocks sudo via exec approval', async () => {
+        const result = await executeTool('Bash', { command: `sudo ls ${TEST_DIR}` }, toolConfig);
+        expect(result).toContain('⛔');
+        expect(result).toContain('tier 2');
     });
     it('respects cwd when in allowed paths', async () => {
         const result = await executeTool('Bash', { command: 'ls', cwd: TEST_DIR }, toolConfig);

package/dist/agent.js

@@ -159,7 +159,7 @@ export async function runAgentTurn(agentId, userMessage, config, modelOverride,
     const runTurn = async () => {
         if (toolConfig?.enabled) {
             // Provider-specific routing is centralized in providers/chatWithTools.
-            console.log(`[agent] Running with tools (provider: ${provider}, model: ${modelId}, paths: ${toolConfig.allowedPaths.join(', ')})`);
+            console.log(`[agent] Running with tools (provider: ${provider}, model: ${modelId}, paths: ${(toolConfig.allowedPaths ?? []).join(', ')})`);
             const result = await chatWithTools(messages, chatOptions, config, toolConfig, toolCtx);
             response = result.response;
             toolCalls = result.toolCalls;

package/dist/api.js

@@ -619,6 +619,11 @@ export function registerDashboardAPI(fastify, config) {
             return reply.code(500).send({ error: `Reload failed: ${msg}` });
         }
     });
+    fastify.post('/api/dashboard/mcp/reconnect', async () => {
+        const { reconnectMcp } = await import('./tools.js');
+        await reconnectMcp();
+        return { reconnected: true, timestamp: new Date().toISOString() };
+    });
     // --- Audit Log ---
     // Reads from ~/.skimpyclaw/logs/audit/YYYY-MM-DD.jsonl files
     fastify.get('/api/dashboard/audit', async (request) => {

package/dist/channels/discord/handlers.d.ts

@@ -0,0 +1,7 @@
+import { type Client, type Message, type Interaction } from 'discord.js';
+import type { Config } from '../../types.js';
+import { type PendingApproval } from '../../exec-approval.js';
+export declare function handleCommand(message: Message, command: string, args: string[], config: Config, silenceUntil: Date | null, setSilenceUntil: (d: Date | null) => void): Promise<void>;
+export declare function handleIncomingMessage(message: Message, config: Config): Promise<void>;
+export declare function sendApprovalCard(client: Client, channelId: string, approval: PendingApproval): Promise<void>;
+export declare function handleInteraction(interaction: Interaction): Promise<void>;