skimpyclaw 0.3.9 → 0.3.14

package/dist/channels/discord/index.js

@@ -0,0 +1,149 @@
+import { Client, GatewayIntentBits, Partials, AttachmentBuilder, } from 'discord.js';
+import { onApprovalEvent } from '../../exec-approval.js';
+import { KNOWN_COMMANDS } from './types.js';
+import { handleCommand, handleIncomingMessage, handleInteraction, sendApprovalCard } from './handlers.js';
+import { splitToChunks } from './utils.js';
+let client = null;
+let config;
+let silenceUntil = null;
+export async function initDiscord(cfg) {
+    const discord = cfg.channels.discord;
+    if (!discord?.enabled || !discord.token) {
+        console.log('[discord] Disabled or no token configured');
+        return false;
+    }
+    config = cfg;
+    client = new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.DirectMessages,
+            GatewayIntentBits.MessageContent,
+        ],
+        partials: [Partials.Channel],
+    });
+    client.on('messageCreate', (message) => {
+        if (message.author.bot)
+            return;
+        void (async () => {
+            const text = message.content.trim();
+            const isPrefixedCommand = text.startsWith('/') || text.startsWith('!');
+            const isDm = message.channel.isDMBased();
+            // Route commands through handleCommand with silenceUntil access
+            if (isPrefixedCommand || isDm) {
+                const commandText = isPrefixedCommand ? text.slice(1).trim() : text;
+                const [commandPart, ...args] = commandText.split(/\s+/);
+                const command = (commandPart || '').toLowerCase();
+                if (KNOWN_COMMANDS.has(command)) {
+                    await handleCommand(message, command, args, config, silenceUntil, (d) => { silenceUntil = d; });
+                    return;
+                }
+                if (isPrefixedCommand) {
+                    await message.reply(`Unknown command: /${command}\n\nType /help to see available commands.`);
+                    return;
+                }
+            }
+            // Non-command messages
+            await handleIncomingMessage(message, config);
+        })();
+    });
+    client.on('interactionCreate', (interaction) => {
+        void handleInteraction(interaction);
+    });
+    client.once('clientReady', () => {
+        console.log(`[discord] Bot started as ${client?.user?.tag ?? 'unknown'}`);
+    });
+    client.on('error', (error) => {
+        console.error('[discord] Client error:', error);
+    });
+    // Subscribe to approval-created events
+    onApprovalEvent('created', (event) => {
+        if (!client)
+            return;
+        const { approval } = event;
+        const meta = approval.channelMeta;
+        if (meta?.channel && meta.channel !== 'discord')
+            return;
+        let targetChannelId;
+        if (meta?.chatId) {
+            targetChannelId = String(meta.chatId);
+        }
+        if (!targetChannelId) {
+            targetChannelId = getDiscordDefaultTarget(cfg) ?? undefined;
+        }
+        if (!targetChannelId)
+            return;
+        void sendApprovalCard(client, targetChannelId, approval).catch((err) => {
+            console.error('[discord] Failed to send approval notification:', err);
+        });
+    });
+    return true;
+}
+export async function startDiscord() {
+    if (!client || !config.channels.discord?.token)
+        return;
+    console.log('[discord] Starting bot...');
+    await client.login(config.channels.discord.token);
+}
+export async function stopDiscord() {
+    if (!client)
+        return;
+    client.destroy();
+    console.log('[discord] Bot stopped');
+}
+export function isDiscordSilenced() {
+    if (!silenceUntil)
+        return false;
+    return new Date() < silenceUntil;
+}
+export function getDiscordDefaultTarget(cfg) {
+    const discord = cfg.channels.discord;
+    if (!discord)
+        return null;
+    if (discord.defaultChannelId?.trim())
+        return discord.defaultChannelId.trim();
+    for (const entry of discord.allowFrom) {
+        const value = String(entry).trim();
+        if (value)
+            return value;
+    }
+    return null;
+}
+async function sendChunked(target, text) {
+    const chunks = splitToChunks(text, 1900);
+    for (const chunk of chunks) {
+        await target.send(chunk);
+    }
+}
+export async function sendDiscordProactiveMessage(target, message) {
+    if (!client || isDiscordSilenced())
+        return;
+    const targetId = String(target);
+    const channel = await client.channels.fetch(targetId).catch(() => null);
+    if (channel && 'send' in channel && typeof channel.send === 'function') {
+        await sendChunked(channel, message);
+        return;
+    }
+    const user = await client.users.fetch(targetId).catch(() => null);
+    if (user) {
+        await sendChunked(user, message);
+    }
+}
+export async function sendDiscordProactiveVoice(target, buffer, format) {
+    if (!client || isDiscordSilenced())
+        return;
+    const targetId = String(target);
+    const attachment = new AttachmentBuilder(buffer, {
+        name: `voice.${format}`,
+        description: 'Voice message',
+    });
+    const channel = await client.channels.fetch(targetId).catch(() => null);
+    if (channel && 'send' in channel && typeof channel.send === 'function') {
+        await channel.send({ files: [attachment] });
+        return;
+    }
+    const user = await client.users.fetch(targetId).catch(() => null);
+    if (user) {
+        await user.send({ files: [attachment] });
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare const BOT_COMMANDS: {
+    command: string;
+    description: string;
+}[];
+export declare const KNOWN_COMMANDS: Set<string>;
+export declare const MAX_HISTORY_PAIRS = 5;

package/dist/channels/discord/types.js

@@ -0,0 +1,17 @@
+export const BOT_COMMANDS = [
+    { command: 'help', description: 'Show available commands' },
+    { command: 'model', description: 'Switch model (fast/smart/opus)' },
+    { command: 'status', description: 'Show bot status' },
+    { command: 'clear', description: 'Clear conversation history' },
+    { command: 'compact', description: 'Compress conversation history' },
+    { command: 'silence', description: 'Pause proactive messages' },
+    { command: 'cron', description: 'List or run scheduled jobs' },
+    { command: 'tasks', description: 'List active coding agents and cron jobs' },
+    { command: 'cancel', description: 'Cancel a coding agent (use dashboard) or cron job' },
+    { command: 'approvals', description: 'List pending exec approvals' },
+    { command: 'approve', description: 'Approve an exec request by ID' },
+    { command: 'deny', description: 'Deny an exec request by ID' },
+    { command: 'heartbeat', description: 'Trigger heartbeat check' },
+];
+export const KNOWN_COMMANDS = new Set(BOT_COMMANDS.map(c => c.command));
+export const MAX_HISTORY_PAIRS = 5;

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

@@ -0,0 +1,14 @@
+import type { Message } from 'discord.js';
+import type { AgentRunContext, ChatMessage, Config, ToolConfig } from '../../types.js';
+export declare function getHistory(key: string): Promise<ChatMessage[]>;
+export declare function addToHistory(key: string, userMsg: string, assistantMsg: string): Promise<void>;
+export declare function clearHistory(key: string): Promise<void>;
+/** Replace history with a compact summary (used by /compact). */
+export declare function replaceHistory(key: string, summary: string): void;
+export declare function getDiscordToolConfig(cfg: Config): ToolConfig;
+export declare function conversationKey(message: Message): string;
+export declare function getDiscordRunContext(message: Message): AgentRunContext;
+export declare function buildHelpText(cfg: Config): string;
+export declare function splitToChunks(text: string, maxLength: number): string[];
+export declare function sendLongText(message: Message, text: string): Promise<void>;
+export declare function startTypingIndicator(message: Message): () => void;

package/dist/channels/discord/utils.js

@@ -0,0 +1,161 @@
+import { resolveAllowedPaths } from '../../config.js';
+import * as sessions from '../../sessions.js';
+import { BOT_COMMANDS, MAX_HISTORY_PAIRS } from './types.js';
+// ── State ───────────────────────────────────────────────────────────
+const chatHistory = new Map();
+const loadedFromDisk = new Set();
+// ── History ─────────────────────────────────────────────────────────
+export async function getHistory(key) {
+    if (!loadedFromDisk.has(key)) {
+        loadedFromDisk.add(key);
+        const diskHistory = await sessions.loadHistory('discord', key).catch(() => []);
+        if (diskHistory.length > 0 && !chatHistory.has(key)) {
+            chatHistory.set(key, diskHistory);
+        }
+    }
+    return chatHistory.get(key) || [];
+}
+export async function addToHistory(key, userMsg, assistantMsg) {
+    const history = await getHistory(key);
+    history.push({ role: 'user', content: userMsg });
+    history.push({ role: 'assistant', content: assistantMsg });
+    while (history.length > MAX_HISTORY_PAIRS * 2) {
+        history.shift();
+        history.shift();
+    }
+    chatHistory.set(key, history);
+    sessions.saveExchange('discord', key, userMsg, assistantMsg).catch(() => { });
+}
+export async function clearHistory(key) {
+    chatHistory.delete(key);
+    loadedFromDisk.delete(key);
+    await sessions.clearHistory('discord', key).catch(() => { });
+}
+/** Replace history with a compact summary (used by /compact). */
+export function replaceHistory(key, summary) {
+    chatHistory.set(key, [
+        { role: 'user', content: 'Summary of our previous conversation:' },
+        { role: 'assistant', content: summary },
+    ]);
+    loadedFromDisk.add(key);
+}
+// ── Tool config ─────────────────────────────────────────────────────
+export function getDiscordToolConfig(cfg) {
+    const discord = cfg.channels.discord;
+    if (discord?.tools) {
+        return {
+            ...discord.tools,
+            allowedPaths: discord.tools.allowedPaths?.length
+                ? discord.tools.allowedPaths
+                : resolveAllowedPaths(cfg),
+        };
+    }
+    return {
+        enabled: true,
+        allowedPaths: resolveAllowedPaths(cfg),
+        maxIterations: 100,
+        bashTimeout: 15000,
+    };
+}
+// ── Helpers ─────────────────────────────────────────────────────────
+export function conversationKey(message) {
+    if (message.channel.isDMBased()) {
+        return `dm:${message.author.id}`;
+    }
+    return `channel:${message.channelId}`;
+}
+export function getDiscordRunContext(message) {
+    return {
+        userId: message.author.id,
+        sessionId: message.channel.id,
+        channel: 'discord',
+        trigger: 'discord',
+        metadata: {
+            username: message.author.username,
+        },
+    };
+}
+export function buildHelpText(cfg) {
+    const agentConfig = cfg.agents.list[cfg.agents.default];
+    const emoji = agentConfig?.identity?.emoji || '🦞';
+    const name = agentConfig?.identity?.name || 'SkimpyClaw';
+    const commandList = BOT_COMMANDS.map(c => `/${c.command} - ${c.description}`).join('\n');
+    return `${emoji} ${name} online.\n\nSend a message to chat, or use a command:\n\n${commandList}`;
+}
+export function splitToChunks(text, maxLength) {
+    if (text.length <= maxLength)
+        return [text];
+    const chunks = [];
+    let current = '';
+    for (const paragraph of text.split('\n\n')) {
+        if (current.length + paragraph.length + 2 > maxLength) {
+            if (current)
+                chunks.push(current.trim());
+            if (paragraph.length > maxLength) {
+                const lines = paragraph.split('\n');
+                let lineBuf = '';
+                for (const line of lines) {
+                    if (lineBuf.length + line.length + 1 > maxLength) {
+                        if (lineBuf)
+                            chunks.push(lineBuf.trim());
+                        if (line.length > maxLength) {
+                            for (let i = 0; i < line.length; i += maxLength) {
+                                chunks.push(line.slice(i, i + maxLength));
+                            }
+                            lineBuf = '';
+                        }
+                        else {
+                            lineBuf = line;
+                        }
+                    }
+                    else {
+                        lineBuf += (lineBuf ? '\n' : '') + line;
+                    }
+                }
+                current = lineBuf;
+            }
+            else {
+                current = paragraph;
+            }
+        }
+        else {
+            current += (current ? '\n\n' : '') + paragraph;
+        }
+    }
+    if (current)
+        chunks.push(current.trim());
+    return chunks.filter(c => c.length > 0);
+}
+export async function sendLongText(message, text) {
+    const chunks = splitToChunks(text, 1900);
+    for (const chunk of chunks) {
+        await message.reply(chunk);
+    }
+}
+export function startTypingIndicator(message) {
+    const maxDurationMs = 90_000;
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        clearInterval(interval);
+        clearTimeout(watchdog);
+    };
+    const channel = message.channel;
+    if (typeof channel.sendTyping === 'function') {
+        void channel.sendTyping().catch(() => { });
+    }
+    const interval = setInterval(() => {
+        if (stopped)
+            return;
+        if (typeof channel.sendTyping === 'function') {
+            void channel.sendTyping().catch(() => { });
+        }
+    }, 4000);
+    const watchdog = setTimeout(() => {
+        console.warn('[discord] Typing indicator watchdog reached; auto-stopping.');
+        stop();
+    }, maxDurationMs);
+    return stop;
+}

package/dist/channels/telegram/utils.d.ts

@@ -12,7 +12,7 @@ export declare function getHistory(chatId: number): Promise<ChatMessage[]>;
 export declare function addToHistory(chatId: number, userMsg: string, assistantMsg: string): Promise<void>;
 export declare function clearHistory(chatId: number): Promise<void>;
 export declare function getRunContext(ctx: Context): AgentRunContext;
-export declare function getDefaultTelegramToolConfig(cfg: Config): ToolConfig | undefined;
+export declare function getDefaultTelegramToolConfig(cfg: Config): ToolConfig;
 /** Get Telegram default chat ID from config */
 export declare function getTelegramDefaultChatId(cfg: Config): number | null;
 /** Send a long message by splitting it into chunks */

package/dist/channels/telegram/utils.js

@@ -2,6 +2,7 @@
 import { existsSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { resolveAllowedPaths } from '../../config.js';
 import { state, MAX_HISTORY_PAIRS, BOT_COMMANDS } from './types.js';
 import * as sessions from '../../sessions.js';
 /** Keep sending "typing..." every 4s until the returned stop function is called. */
@@ -102,20 +103,17 @@ export function getRunContext(ctx) {
 // Default tool config for Telegram — gives the agent file/bash access
 export function getDefaultTelegramToolConfig(cfg) {
     if (cfg.channels.telegram.tools) {
-        return cfg.channels.telegram.tools;
-    }
-    if (cfg.channels.telegram.defaultAllowedPaths?.length) {
         return {
-            enabled: true,
-            allowedPaths: cfg.channels.telegram.defaultAllowedPaths,
-            maxIterations: 100,
-            bashTimeout: 15000,
+            ...cfg.channels.telegram.tools,
+            allowedPaths: cfg.channels.telegram.tools.allowedPaths?.length
+                ? cfg.channels.telegram.tools.allowedPaths
+                : resolveAllowedPaths(cfg),
         };
     }
     return {
         enabled: true,
-        allowedPaths: [join(homedir(), '.skimpyclaw')],
-        maxIterations: 30,
+        allowedPaths: resolveAllowedPaths(cfg),
+        maxIterations: 100,
         bashTimeout: 15000,
     };
 }

package/dist/channels.js

@@ -38,7 +38,7 @@ async function loadAdapter(channel) {
             resolveDefaultTarget: telegram.getTelegramDefaultChatId,
         };
     }
-    const discord = await import('./discord.js');
+    const discord = await import('./channels/discord/index.js');
     return {
         init: discord.initDiscord,
         start: discord.startDiscord,

package/dist/cli.js

@@ -4,12 +4,13 @@ import { join } from 'path';
 import { homedir } from 'os';
 import { spawn, spawnSync } from 'child_process';
 import { fileURLToPath } from 'url';
-import { loadConfig, loadRawConfig, getConfigPath, saveConfig } from './config.js';
+import { loadConfig, loadRawConfig, getConfigPath, saveConfig, resolveAllowedPaths } from './config.js';
 import { startRuntime } from './service.js';
 import { runSetup, renderGatewayPlist } from './setup.js';
 import { runDoctor as runDoctorCommand } from './doctor/index.js';
 import { executeTool, getToolDefinitions, BUILTIN_TOOL_DEFINITIONS, BROWSER_TOOL_DEFINITION } from './tools.js';
 import { formatModelSelectionError, getModelSelectionUsage, resolveModelSelection } from './model-selection.js';
+import { detectSandboxRuntime, isSandboxRuntimeRunning, sandboxNetworkExists, defaultSandboxNetwork, sandboxImageExists, } from './sandbox-utils.js';
 const APP_NAME = 'skimpyclaw';
 const DEFAULT_PORT = 18790;
 const LAUNCHD_LABEL = 'com.skimpyclaw.gateway';
@@ -102,19 +103,17 @@ function hasFlag(args, flag) {
     return args.includes(flag);
 }
 function getCliToolConfig(config) {
-    if (config.channels.telegram.tools)
-        return config.channels.telegram.tools;
-    if (config.channels.telegram.defaultAllowedPaths?.length) {
+    if (config.channels.telegram.tools) {
         return {
-            enabled: true,
-            allowedPaths: config.channels.telegram.defaultAllowedPaths,
-            maxIterations: 100,
-            bashTimeout: 15000,
+            ...config.channels.telegram.tools,
+            allowedPaths: config.channels.telegram.tools.allowedPaths?.length
+                ? config.channels.telegram.tools.allowedPaths
+                : resolveAllowedPaths(config),
         };
     }
     return {
         enabled: true,
-        allowedPaths: [join(homedir(), '.skimpyclaw')],
+        allowedPaths: resolveAllowedPaths(config),
         maxIterations: 100,
         bashTimeout: 15000,
     };
@@ -771,40 +770,6 @@ const SANDBOX_CLI_BY_PROFILE = {
     dev: ['bash', 'curl', 'git', 'gh', 'jq', 'python3', 'rg', 'pnpm', 'gcc', 'g++', 'make'],
     full: ['bash', 'curl', 'git', 'gh', 'jq', 'python3', 'rg', 'pnpm', 'gcc', 'g++', 'make', 'pip3', 'sqlite3'],
 };
-function defaultSandboxNetwork(runtime) {
-    return runtime === 'container' ? 'default' : 'bridge';
-}
-function detectSandboxRuntime(preferred) {
-    if (preferred === 'container' || preferred === 'docker') {
-        return spawnSync(preferred, ['--version'], { encoding: 'utf-8' }).status === 0 ? preferred : null;
-    }
-    if (spawnSync('container', ['--version'], { encoding: 'utf-8' }).status === 0) {
-        return 'container';
-    }
-    if (spawnSync('docker', ['--version'], { encoding: 'utf-8' }).status === 0) {
-        return 'docker';
-    }
-    return null;
-}
-function isSandboxRuntimeRunning(runtime) {
-    if (runtime === 'container') {
-        return spawnSync('container', ['system', 'status'], { encoding: 'utf-8' }).status === 0;
-    }
-    return spawnSync('docker', ['info'], { encoding: 'utf-8' }).status === 0;
-}
-function sandboxNetworkExists(runtime, network) {
-    if (runtime === 'container') {
-        const result = spawnSync('container', ['network', 'ls'], { encoding: 'utf-8' });
-        if (result.status !== 0)
-            return false;
-        return result.stdout.split('\n').some((line) => line.trim().split(/\s+/)[0] === network);
-    }
-    const result = spawnSync('docker', ['network', 'inspect', network], { encoding: 'utf-8' });
-    return result.status === 0;
-}
-function sandboxImageExists(runtime, image) {
-    return spawnSync(runtime, ['image', 'inspect', image], { encoding: 'utf-8' }).status === 0;
-}
 function resolveSandboxDir() {
     // 1. Check CWD (user is in repo root)
     const cwdSandbox = join(process.cwd(), 'sandbox');

package/dist/code-agents/parser.js

@@ -184,9 +184,14 @@ export function parseCodexOutput(stdout) {
     for (const line of lines) {
         try {
             const obj = JSON.parse(line);
+            // Standard output_text events
             if (obj.type === 'output_text' || obj.output_text) {
                 outputs.push(obj.output_text || obj.text || '');
             }
+            // Codex stream-json: item.completed with agent_message
+            else if (obj.type === 'item.completed' && obj.item?.type === 'agent_message' && obj.item?.text) {
+                outputs.push(obj.item.text);
+            }
         }
         catch {
             if (line.trim())

package/dist/config.d.ts

@@ -17,4 +17,11 @@ export declare function listMemoryFiles(agentId: string): {
     date: string;
     size: number;
 }[];
+/**
+ * Resolve allowed paths for a given context. Priority:
+ * 1. Explicit toolConfig.allowedPaths (if provided)
+ * 2. Config top-level allowedPaths
+ * 3. Fallback: ~/.skimpyclaw only
+ */
+export declare function resolveAllowedPaths(config: Config, overridePaths?: string[]): string[];
 export declare function readMemoryFile(agentId: string, filename: string): string;

package/dist/config.js

@@ -109,6 +109,19 @@ export function listMemoryFiles(agentId) {
         };
     }).sort((a, b) => b.date.localeCompare(a.date));
 }
+/**
+ * Resolve allowed paths for a given context. Priority:
+ * 1. Explicit toolConfig.allowedPaths (if provided)
+ * 2. Config top-level allowedPaths
+ * 3. Fallback: ~/.skimpyclaw only
+ */
+export function resolveAllowedPaths(config, overridePaths) {
+    if (overridePaths?.length)
+        return overridePaths;
+    if (config.allowedPaths?.length)
+        return config.allowedPaths;
+    return [join(homedir(), '.skimpyclaw')];
+}
 export function readMemoryFile(agentId, filename) {
     if (!isValidAgentId(agentId)) {
         throw new Error('Invalid agent ID');

package/dist/cron.js

@@ -3,7 +3,7 @@ import { Cron } from 'croner';
 import { exec } from 'child_process';
 import { existsSync, mkdirSync, appendFileSync, readFileSync, watch } from 'fs';
 import { join } from 'path';
-import { getLogsDir, getConfigPath, loadConfig } from './config.js';
+import { getLogsDir, getConfigPath, loadConfig, resolveAllowedPaths } from './config.js';
 import { homedir } from 'node:os';
 import { runAgentTurn } from './agent.js';
 import { startTrace, addEvent, endTrace } from './audit.js';
@@ -152,11 +152,14 @@ async function executeJobPayload(jobDef, config) {
             appendCronLogLine(jobDef.id, `Agent turn started (prompt: ${message.slice(0, 100)}...)`);
             const defaultTools = {
                 enabled: true,
-                allowedPaths: [`${homedir()}/.skimpyclaw`],
+                allowedPaths: resolveAllowedPaths(config),
                 maxIterations: 30,
                 bashTimeout: 15000,
             };
-            const response = await runAgentTurn(config.agents.default, message, config, jobDef.model, jobDef.payload.tools || defaultTools, undefined, {
+            const tools = jobDef.payload.tools
+                ? { ...jobDef.payload.tools, allowedPaths: jobDef.payload.tools.allowedPaths?.length ? jobDef.payload.tools.allowedPaths : resolveAllowedPaths(config) }
+                : defaultTools;
+            const response = await runAgentTurn(config.agents.default, message, config, jobDef.model, tools, undefined, {
                 channel: getActiveChannelId() || 'telegram',
                 trigger: 'cron',
                 sessionId: jobDef.id,

package/dist/heartbeat.js

@@ -6,30 +6,26 @@
 import { join } from 'path';
 import { homedir } from 'os';
 import { runAgentTurn } from './agent.js';
+import { resolveAllowedPaths } from './config.js';
 import { pruneIdle, SANDBOX_DEFAULTS } from './sandbox/index.js';
 import { getActiveChannelId, isActiveChannelSilenced, sendActiveChannelProactiveMessage, } from './channels.js';
 let heartbeatTimer = null;
 let running = false;
-const DEFAULT_HEARTBEAT_TOOLS = {
-    enabled: true,
-    allowedPaths: [join(homedir(), '.skimpyclaw')],
-    maxIterations: 100,
-    bashTimeout: 15000,
-};
 function getHeartbeatTools(config) {
     if (config.heartbeat.tools) {
-        return config.heartbeat.tools;
-    }
-    const defaultAllowedPaths = config.channels.active === 'discord'
-        ? config.channels.discord?.defaultAllowedPaths
-        : config.channels.telegram.defaultAllowedPaths || config.channels.discord?.defaultAllowedPaths;
-    if (defaultAllowedPaths?.length) {
         return {
-            ...DEFAULT_HEARTBEAT_TOOLS,
-            allowedPaths: defaultAllowedPaths,
+            ...config.heartbeat.tools,
+            allowedPaths: config.heartbeat.tools.allowedPaths?.length
+                ? config.heartbeat.tools.allowedPaths
+                : resolveAllowedPaths(config),
         };
     }
-    return DEFAULT_HEARTBEAT_TOOLS;
+    return {
+        enabled: true,
+        allowedPaths: resolveAllowedPaths(config),
+        maxIterations: 100,
+        bashTimeout: 15000,
+    };
 }
 function getHeartbeatFilePath(config) {
     return join(homedir(), '.skimpyclaw', 'agents', config.agents.default, 'HEARTBEAT.md');

package/dist/providers/anthropic.js

@@ -152,7 +152,13 @@ export async function chatWithToolsAnthropic(params) {
             };
         }
         // Compact old tool results if context is growing large
-        const messagesForApi = compactAnthropicMessages(apiMessages, toolConfig.contextManagement, i + 1);
+        const compactionResult = await compactAnthropicMessages(apiMessages, toolConfig.contextManagement, i + 1, config);
+        const messagesForApi = compactionResult.messages;
+        if (compactionResult.compacted) {
+            const method = compactionResult.method === 'llm' ? 'LLM summary' : 'truncation';
+            const detail = `~${Math.round((compactionResult.tokensBefore || 0) / 1000)}k → ~${Math.round((compactionResult.tokensAfter || 0) / 1000)}k tokens`;
+            toolLog.push(`[context compacted via ${method}: ${detail}]`);
+        }
         const anthropicParams = {
             model: modelId,
             max_tokens: options.maxTokens || 16384,

package/dist/providers/codex.js

@@ -265,7 +265,7 @@ export async function chatCodex(params) {
     }
 }
 export async function chatWithToolsCodex(params) {
-    const { messages, options, toolConfig, toolContext } = params;
+    const { messages, options, config, toolConfig, toolContext } = params;
     const modelId = stripProvider(options.model);
     const maxIterations = toolConfig.maxIterations || 100;
     // Build input — system messages go to `instructions`, rest to `input`
@@ -308,7 +308,13 @@ export async function chatWithToolsCodex(params) {
             };
         }
         // Compact old tool results if context is growing large
-        const inputForApi = compactCodexMessages(input, toolConfig.contextManagement, i + 1);
+        const compactionResult = await compactCodexMessages(input, toolConfig.contextManagement, i + 1, config);
+        const inputForApi = compactionResult.messages;
+        if (compactionResult.compacted) {
+            const method = compactionResult.method === 'llm' ? 'LLM summary' : 'truncation';
+            const detail = `~${Math.round((compactionResult.tokensBefore || 0) / 1000)}k → ~${Math.round((compactionResult.tokensAfter || 0) / 1000)}k tokens`;
+            toolLog.push(`[context compacted via ${method}: ${detail}]`);
+        }
         const body = {
             model: modelId,
             instructions,