onkol 0.3.0 → 0.5.0

package/dist/cli/index.js

@@ -8,7 +8,7 @@ import { mkdirSync, writeFileSync, readFileSync, copyFileSync, existsSync } from
 import { resolve } from 'path';
 import { execSync } from 'child_process';
 import { runSetupPrompts } from './prompts.js';
-import { createCategory, createChannel } from './discord-api.js';
+import { createCategory, createChannel, validateBotToken, checkGatewayIntents } from './discord-api.js';
 import { discoverServices, formatServicesMarkdown } from './auto-discover.js';
 import { renderOrchestratorClaude, renderSettings } from './templates.js';
 import { generateSystemdUnit, generateCrontab } from './systemd.js';
@@ -152,6 +152,25 @@ program
     if (answers.discordUserId.trim()) {
         allowedUsers.push(answers.discordUserId.trim());
     }
+    // --- Validate Discord bot token and intents ---
+    if (!skip('discord')) {
+        console.log(chalk.gray('Validating Discord bot token...'));
+        const tokenCheck = await validateBotToken(answers.botToken);
+        if (!tokenCheck.ok) {
+            console.error(chalk.red(`\nFATAL: ${tokenCheck.error}`));
+            console.error(chalk.yellow('\nYour answers have been saved. Fix the issue and run `npx onkol setup` again to resume.'));
+            process.exit(1);
+        }
+        console.log(chalk.green('✓ Bot token is valid'));
+        console.log(chalk.gray('Checking gateway intents...'));
+        const intentWarning = await checkGatewayIntents(answers.botToken);
+        if (intentWarning) {
+            console.error(chalk.red(`\nFATAL: ${intentWarning}`));
+            console.error(chalk.yellow('\nEnable the required intent and run `npx onkol setup` again to resume.'));
+            process.exit(1);
+        }
+        console.log(chalk.green('✓ Message Content intent is enabled'));
+    }
     // --- CRITICAL: Create Discord category and orchestrator channel ---
     let categoryId = checkpoint.categoryId || '';
     let orchChannelId = checkpoint.orchChannelId || '';
@@ -193,6 +212,14 @@ program
             maxWorkers: 3,
             installDir: dir,
             plugins: answers.plugins,
+            ...(answers.watchdogProvider !== 'skip' ? {
+                watchdog: {
+                    provider: answers.watchdogProvider,
+                    model: answers.watchdogModel,
+                    apiKey: answers.watchdogApiKey,
+                    ...(answers.watchdogApiUrl ? { apiUrl: answers.watchdogApiUrl } : {}),
+                },
+            } : {}),
         };
         writeFileSync(resolve(dir, 'config.json'), JSON.stringify(config, null, 2), { mode: 0o600 });
         markStep(homeDir, checkpoint, 'config');
@@ -233,6 +260,7 @@ program
                         DISCORD_BOT_TOKEN: answers.botToken,
                         DISCORD_CHANNEL_ID: orchChannelId,
                         DISCORD_ALLOWED_USERS: JSON.stringify(allowedUsers),
+                        TMUX_TARGET: `onkol-${answers.nodeName}`,
                     },
                 },
             },
@@ -275,7 +303,7 @@ program
         console.log(chalk.gray('  Config files already written, skipping'));
     }
     // --- CRITICAL: Copy scripts ---
-    const requiredScripts = ['spawn-worker.sh', 'dissolve-worker.sh', 'list-workers.sh', 'check-worker.sh', 'healthcheck.sh', 'start-orchestrator.sh'];
+    const requiredScripts = ['spawn-worker.sh', 'dissolve-worker.sh', 'list-workers.sh', 'check-worker.sh', 'healthcheck.sh', 'worker-watchdog.sh', 'start-orchestrator.sh'];
     const scriptsSource = resolve(__dirname, '../../scripts');
     if (skip('scripts')) {
         console.log(chalk.gray('  Scripts already installed, skipping'));
@@ -405,12 +433,16 @@ program
                 const timerDir = resolve(homeDir, '.config/systemd/user');
                 mkdirSync(timerDir, { recursive: true });
                 const healthcheckPath = resolve(dir, 'scripts/healthcheck.sh');
+                const watchdogPath = resolve(dir, 'scripts/worker-watchdog.sh');
                 writeFileSync(resolve(timerDir, 'onkol-healthcheck.service'), `[Unit]\nDescription=Onkol healthcheck\n[Service]\nType=oneshot\nExecStart=${healthcheckPath}\n`);
                 writeFileSync(resolve(timerDir, 'onkol-healthcheck.timer'), `[Unit]\nDescription=Onkol healthcheck every 5min\n[Timer]\nOnBootSec=2min\nOnUnitActiveSec=5min\n[Install]\nWantedBy=timers.target\n`);
+                writeFileSync(resolve(timerDir, 'onkol-worker-watchdog.service'), `[Unit]\nDescription=Onkol worker watchdog\n[Service]\nType=oneshot\nExecStart=${watchdogPath}\n`);
+                writeFileSync(resolve(timerDir, 'onkol-worker-watchdog.timer'), `[Unit]\nDescription=Onkol worker watchdog every 3min\n[Timer]\nOnBootSec=3min\nOnUnitActiveSec=3min\n[Install]\nWantedBy=timers.target\n`);
                 writeFileSync(resolve(timerDir, 'onkol-cleanup.service'), `[Unit]\nDescription=Onkol archive cleanup\n[Service]\nType=oneshot\nExecStart=/usr/bin/find ${resolve(dir, 'workers/.archive')} -maxdepth 1 -mtime +30 -exec rm -rf {} \\;\n`);
                 writeFileSync(resolve(timerDir, 'onkol-cleanup.timer'), `[Unit]\nDescription=Onkol archive cleanup daily\n[Timer]\nOnCalendar=*-*-* 04:00:00\n[Install]\nWantedBy=timers.target\n`);
                 execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
                 execSync('systemctl --user enable --now onkol-healthcheck.timer', { stdio: 'pipe' });
+                execSync('systemctl --user enable --now onkol-worker-watchdog.timer', { stdio: 'pipe' });
                 execSync('systemctl --user enable --now onkol-cleanup.timer', { stdio: 'pipe' });
             }
             console.log(chalk.green(`✓ Systemd user timers installed (healthcheck every 5min, cleanup daily)`));
@@ -441,30 +473,49 @@ program
     console.log(chalk.gray('\nStarting orchestrator...'));
     let started = false;
     try {
-        execSync(`sudo systemctl start onkol-${answers.nodeName}`, { stdio: 'pipe' });
-        // Wait for tmux session to appear
-        for (let i = 0; i < 10; i++) {
+        execSync(`sudo systemctl start onkol-${answers.nodeName}`, { stdio: 'pipe', timeout: 60000 });
+        // Wait for tmux session to appear (the start script itself verifies, but double-check)
+        for (let i = 0; i < 5; i++) {
             try {
                 execSync(`tmux has-session -t onkol-${answers.nodeName}`, { stdio: 'pipe' });
                 started = true;
                 break;
             }
             catch { /* not ready yet */ }
-            execSync('sleep 1', { stdio: 'pipe' });
+            execSync('sleep 2', { stdio: 'pipe' });
         }
         if (started) {
             console.log(chalk.green(`✓ Orchestrator started via systemd (tmux session "onkol-${answers.nodeName}")`));
         }
+        else {
+            // systemctl succeeded but tmux session not visible — likely PATH or env issue
+            console.log(chalk.yellow(`⚠ systemctl started but tmux session not found. Trying direct start...`));
+            try {
+                const logs = execSync(`sudo journalctl -u onkol-${answers.nodeName} --no-pager -n 10 2>&1`, { encoding: 'utf-8' });
+                if (logs.trim())
+                    console.log(chalk.gray(`  Journal: ${logs.trim().split('\n').slice(-3).join('\n  ')}`));
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(chalk.yellow(`⚠ systemctl start failed: ${msg.split('\n')[0]}`));
     }
-    catch { /* systemctl start failed, try direct */ }
     if (!started) {
         try {
-            execSync(`bash "${resolve(dir, 'scripts/start-orchestrator.sh')}"`, { stdio: 'pipe' });
+            execSync(`bash "${resolve(dir, 'scripts/start-orchestrator.sh')}"`, { stdio: 'pipe', timeout: 60000 });
+            // Verify the session is actually running
+            execSync(`tmux has-session -t onkol-${answers.nodeName}`, { stdio: 'pipe' });
+            started = true;
             console.log(chalk.green(`✓ Orchestrator started in tmux session "onkol-${answers.nodeName}"`));
         }
         catch {
-            console.log(chalk.yellow(`⚠ Could not start orchestrator automatically.`));
-            console.log(chalk.yellow(`  Start manually: ${dir}/scripts/start-orchestrator.sh`));
+            console.log(chalk.red(`✗ Could not start orchestrator. The tmux session failed to stay alive.`));
+            console.log(chalk.yellow(`  Debug steps:`));
+            console.log(chalk.yellow(`    1. Run manually: bash ${dir}/scripts/start-orchestrator.sh`));
+            console.log(chalk.yellow(`    2. Check: tmux attach -t onkol-${answers.nodeName}`));
+            console.log(chalk.yellow(`    3. Verify claude works: claude --version`));
         }
     }
     // Setup complete — clear checkpoint
@@ -481,4 +532,148 @@ program
     console.log(chalk.gray(`\n  To attach to the session: tmux attach -t onkol-${answers.nodeName}`));
     console.log(chalk.gray(`  To check status: systemctl status onkol-${answers.nodeName}`));
 });
+program
+    .command('update')
+    .description('Update plugin + scripts and restart workers with conversation history preserved')
+    .option('--skip-update', 'Skip pulling latest npm package, just restart workers')
+    .option('--dir <path>', 'Onkol install directory', '')
+    .action(async (opts) => {
+    // Find install directory
+    let dir = opts.dir;
+    if (!dir) {
+        // Try common locations
+        const homeDir = process.env.HOME || '';
+        const candidates = [
+            resolve(homeDir, 'onkol'),
+            resolve(homeDir, '.onkol'),
+            '/opt/onkol',
+        ];
+        for (const c of candidates) {
+            if (existsSync(resolve(c, 'config.json'))) {
+                dir = c;
+                break;
+            }
+        }
+    }
+    if (!dir || !existsSync(resolve(dir, 'config.json'))) {
+        console.log(chalk.red('Could not find Onkol install. Use --dir <path> to specify.'));
+        process.exit(1);
+    }
+    const config = JSON.parse(readFileSync(resolve(dir, 'config.json'), 'utf-8'));
+    const nodeName = config.nodeName;
+    console.log(chalk.bold('=== Onkol Update & Restart ==='));
+    console.log(chalk.gray(`Node: ${nodeName}`));
+    console.log(chalk.gray(`Install dir: ${dir}`));
+    console.log('');
+    // Step 1: Update files
+    if (!opts.skipUpdate) {
+        console.log(chalk.cyan('[1/3] Updating files from npm package...'));
+        try {
+            // Find where this CLI is running from — that's the latest package
+            const pkgRoot = resolve(__dirname, '..');
+            const pluginSrc = existsSync(resolve(pkgRoot, 'src/plugin'))
+                ? resolve(pkgRoot, 'src/plugin')
+                : resolve(pkgRoot, 'dist/plugin');
+            const scriptsSrc = resolve(pkgRoot, 'scripts');
+            // Copy plugin files
+            if (existsSync(pluginSrc)) {
+                const pluginDest = resolve(dir, 'plugins/discord-filtered');
+                const { readdirSync } = await import('fs');
+                for (const f of readdirSync(pluginSrc)) {
+                    if (f.endsWith('.ts') || f.endsWith('.js')) {
+                        copyFileSync(resolve(pluginSrc, f), resolve(pluginDest, f));
+                    }
+                }
+                console.log(chalk.green('  ✓ Plugin files updated'));
+            }
+            // Copy scripts
+            if (existsSync(scriptsSrc)) {
+                const { readdirSync, chmodSync } = await import('fs');
+                for (const f of readdirSync(scriptsSrc)) {
+                    if (f.endsWith('.sh')) {
+                        copyFileSync(resolve(scriptsSrc, f), resolve(dir, 'scripts', f));
+                        chmodSync(resolve(dir, 'scripts', f), 0o755);
+                    }
+                }
+                console.log(chalk.green('  ✓ Scripts updated'));
+            }
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  ⚠ Update failed: ${err instanceof Error ? err.message : err}`));
+            console.log(chalk.yellow('  Continuing with restart...'));
+        }
+    }
+    else {
+        console.log(chalk.gray('[1/3] Skipping update (--skip-update)'));
+    }
+    console.log('');
+    // Step 2: Find active workers and their session IDs
+    console.log(chalk.cyan('[2/3] Dissolving active workers...'));
+    const trackingPath = resolve(dir, 'workers/tracking.json');
+    if (!existsSync(trackingPath)) {
+        console.log(chalk.gray('  No active workers.'));
+        console.log(chalk.green.bold('\n✓ Update complete. No workers to restart.'));
+        return;
+    }
+    const tracking = JSON.parse(readFileSync(trackingPath, 'utf-8'));
+    const active = tracking.filter((w) => w.status === 'active');
+    if (active.length === 0) {
+        console.log(chalk.gray('  No active workers.'));
+        console.log(chalk.green.bold('\n✓ Update complete. No workers to restart.'));
+        return;
+    }
+    const workers = [];
+    for (const w of active) {
+        // Find session ID: look in ~/.claude/projects/<encoded-path>/
+        const encoded = '-' + w.workDir.replace(/^\//, '').replace(/\//g, '-');
+        const sessionDir = resolve(process.env.HOME || '', '.claude/projects', encoded);
+        let sessionId = '';
+        try {
+            const { readdirSync, statSync } = await import('fs');
+            const jsonls = readdirSync(sessionDir)
+                .filter((f) => f.endsWith('.jsonl'))
+                .map((f) => ({ name: f, mtime: statSync(resolve(sessionDir, f)).mtimeMs }))
+                .sort((a, b) => a.mtime - b.mtime);
+            if (jsonls.length > 0) {
+                sessionId = jsonls[jsonls.length - 1].name.replace('.jsonl', '');
+            }
+        }
+        catch { /* session dir may not exist */ }
+        workers.push({ name: w.name, workDir: w.workDir, intent: w.intent, sessionId });
+        console.log(chalk.gray(`  ${w.name} → session: ${sessionId || 'none'}`));
+    }
+    console.log('');
+    // Dissolve
+    for (const w of workers) {
+        try {
+            execSync(`bash "${resolve(dir, 'scripts/dissolve-worker.sh')}" --name "${w.name}"`, { stdio: 'pipe' });
+            console.log(chalk.gray(`  ✓ ${w.name} dissolved`));
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  ⚠ Failed to dissolve ${w.name}: ${err instanceof Error ? err.message : err}`));
+        }
+    }
+    console.log('');
+    // Step 3: Respawn with --resume
+    console.log(chalk.cyan('[3/3] Respawning workers with --resume...'));
+    for (const w of workers) {
+        const resumeArg = w.sessionId ? `--resume ${w.sessionId}` : '';
+        const cmd = `bash "${resolve(dir, 'scripts/spawn-worker.sh')}" \
+        --name "${w.name}" \
+        --dir "${w.workDir}" \
+        --task "Continue the previous work. Check your conversation history for context." \
+        --intent "${w.intent}" \
+        ${resumeArg}`;
+        try {
+            execSync(cmd, { stdio: 'pipe' });
+            console.log(chalk.green(`  ✓ ${w.name} respawned${w.sessionId ? ' (resumed)' : ''}`));
+        }
+        catch (err) {
+            console.log(chalk.red(`  ✗ Failed to spawn ${w.name}: ${err instanceof Error ? err.message : err}`));
+        }
+        // Small delay to avoid Discord rate limits
+        await new Promise(r => setTimeout(r, 2000));
+    }
+    console.log(chalk.green.bold(`\n✓ Update complete. ${workers.length} worker(s) restarted.`));
+});
 program.parse();

package/dist/cli/prompts.d.ts

@@ -13,5 +13,9 @@ export interface SetupAnswers {
     claudeMdMode: 'prompt' | 'skip';
     claudeMdPrompt: string | null;
     plugins: string[];
+    watchdogProvider: 'openrouter' | 'gemini' | 'custom' | 'skip';
+    watchdogModel: string | null;
+    watchdogApiKey: string | null;
+    watchdogApiUrl: string | null;
 }
 export declare function runSetupPrompts(homeDir: string): Promise<SetupAnswers>;

package/dist/cli/prompts.js

@@ -165,8 +165,70 @@ export async function runSetupPrompts(homeDir) {
                 { name: 'frontend-design', value: 'frontend-design', checked: false },
             ],
         },
+        {
+            type: 'list',
+            name: 'watchdogProvider',
+            message: 'Worker watchdog LLM (monitors workers, nudges if stuck/silent):',
+            choices: [
+                { name: 'OpenRouter (recommended — use any model via openrouter.ai)', value: 'openrouter' },
+                { name: 'Google Gemini (direct API)', value: 'gemini' },
+                { name: 'Custom OpenAI-compatible endpoint', value: 'custom' },
+                { name: 'Skip (disable LLM watchdog)', value: 'skip' },
+            ],
+        },
+        {
+            type: 'list',
+            name: 'watchdogModel',
+            message: 'Watchdog model:',
+            choices: (a) => {
+                const base = [
+                    { name: 'google/gemini-2.5-flash (fast, cheap)', value: 'google/gemini-2.5-flash' },
+                    { name: 'google/gemini-2.0-flash-001 (fast, cheap)', value: 'google/gemini-2.0-flash-001' },
+                    { name: 'anthropic/claude-haiku (fast)', value: 'anthropic/claude-3-5-haiku-20241022' },
+                    { name: 'Custom — enter model ID', value: '__custom__' },
+                ];
+                if (a.watchdogProvider === 'gemini') {
+                    return [
+                        { name: 'gemini-2.5-flash-preview-05-20 (recommended)', value: 'gemini-2.5-flash-preview-05-20' },
+                        { name: 'gemini-2.0-flash', value: 'gemini-2.0-flash' },
+                        { name: 'Custom — enter model ID', value: '__custom__' },
+                    ];
+                }
+                return base;
+            },
+            when: (a) => a.watchdogProvider !== 'skip',
+        },
+        {
+            type: 'input',
+            name: 'watchdogModelCustom',
+            message: 'Enter model ID:',
+            when: (a) => a.watchdogProvider !== 'skip' && a.watchdogModel === '__custom__',
+        },
+        {
+            type: 'password',
+            name: 'watchdogApiKey',
+            message: (a) => {
+                if (a.watchdogProvider === 'openrouter')
+                    return 'OpenRouter API key (sk-or-...):';
+                if (a.watchdogProvider === 'gemini')
+                    return 'Google Gemini API key:';
+                return 'API key:';
+            },
+            mask: '*',
+            when: (a) => a.watchdogProvider !== 'skip',
+        },
+        {
+            type: 'input',
+            name: 'watchdogApiUrl',
+            message: 'API base URL (OpenAI-compatible, e.g. https://api.example.com/v1/chat/completions):',
+            when: (a) => a.watchdogProvider === 'custom',
+        },
     ]);
     const answers = { ...preDiscordAnswers, ...discordAndRestAnswers };
+    // Resolve custom model selection
+    const watchdogModel = answers.watchdogModel === '__custom__'
+        ? (answers.watchdogModelCustom || null)
+        : (answers.watchdogModel || null);
     return {
         ...answers,
         registryPath: answers.registryPath || null,
@@ -174,5 +236,8 @@ export async function runSetupPrompts(homeDir) {
         serviceSummaryPath: answers.serviceSummaryPath || null,
         servicesPrompt: answers.servicesPrompt || null,
         claudeMdPrompt: answers.claudeMdPrompt || null,
+        watchdogModel,
+        watchdogApiKey: answers.watchdogApiKey || null,
+        watchdogApiUrl: answers.watchdogApiUrl || null,
     };
 }

package/dist/cli/systemd.js

@@ -1,15 +1,33 @@
 export function generateSystemdUnit(nodeName, user, onkolDir) {
+    // Resolve PATH additions for claude and bun at generation time
+    const homeDir = process.env.HOME || `/home/${user}`;
+    const extraPaths = [
+        `${homeDir}/.local/bin`,
+        `${homeDir}/.bun/bin`,
+    ].filter(p => {
+        try {
+            return require('fs').existsSync(p);
+        }
+        catch {
+            return false;
+        }
+    });
+    const pathEnv = extraPaths.length > 0
+        ? `Environment=PATH=${extraPaths.join(':')}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin`
+        : '';
     return `[Unit]
 Description=Onkol Node: ${nodeName}
 After=network.target
 
 [Service]
-Type=forking
+Type=oneshot
+RemainAfterExit=yes
 User=${user}
+${pathEnv}
+Environment=HOME=${homeDir}
 ExecStart=${onkolDir}/scripts/start-orchestrator.sh
 ExecStop=/usr/bin/tmux kill-session -t onkol-${nodeName}
-Restart=on-failure
-RestartSec=10
+TimeoutStartSec=60
 
 [Install]
 WantedBy=multi-user.target
@@ -17,6 +35,7 @@ WantedBy=multi-user.target
 }
 export function generateCrontab(onkolDir) {
     return `*/5 * * * * ${onkolDir}/scripts/healthcheck.sh
+*/3 * * * * ${onkolDir}/scripts/worker-watchdog.sh
 0 4 * * * find ${onkolDir}/workers/.archive -maxdepth 1 -mtime +30 -exec rm -rf {} \\;
 `;
 }

package/dist/plugin/discord-client.d.ts

@@ -5,7 +5,7 @@ export interface DiscordClientConfig {
     allowedUsers: string[];
 }
 export declare function shouldForwardMessage(messageChannelId: string, authorId: string, isBot: boolean, targetChannelId: string, allowedUsers: string[]): boolean;
-export declare function createDiscordClient(config: DiscordClientConfig, onMessage: (message: Message) => void): {
+export declare function createDiscordClient(config: DiscordClientConfig, onMessage: (content: string, message: Message) => void): {
     login: () => Promise<string>;
     client: Client<boolean>;
     sendMessage(channelId: string, text: string): Promise<void>;

package/dist/plugin/discord-client.js

@@ -8,6 +8,25 @@ export function shouldForwardMessage(messageChannelId, authorId, isBot, targetCh
         return false;
     return true;
 }
+// When a message is too long, Discord auto-converts it to a .txt file attachment
+// with empty message content. This fetches the text from those attachments.
+async function resolveTextAttachments(message) {
+    let content = message.content;
+    const textAttachments = message.attachments.filter((a) => a.contentType?.startsWith('text/') || a.name?.endsWith('.txt'));
+    for (const attachment of textAttachments.values()) {
+        try {
+            const res = await fetch(attachment.url);
+            if (res.ok) {
+                const text = await res.text();
+                content = content ? `${content}\n\n${text}` : text;
+            }
+        }
+        catch (err) {
+            console.error(`[discord-filtered] Failed to fetch attachment ${attachment.name}: ${err}`);
+        }
+    }
+    return content;
+}
 export function createDiscordClient(config, onMessage) {
     const client = new Client({
         intents: [
@@ -16,9 +35,12 @@ export function createDiscordClient(config, onMessage) {
             GatewayIntentBits.MessageContent,
         ],
     });
-    client.on('messageCreate', (message) => {
+    client.on('messageCreate', async (message) => {
         if (shouldForwardMessage(message.channel.id, message.author.id, message.author.bot, config.channelId, config.allowedUsers)) {
-            onMessage(message);
+            const content = await resolveTextAttachments(message);
+            if (content) {
+                onMessage(content, message);
+            }
         }
     });
     client.on('ready', () => {

package/dist/plugin/index.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env bun
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { execSync } from 'child_process';
 import { createMcpServer } from './mcp-server.js';
 import { createDiscordClient } from './discord-client.js';
 import { MessageBatcher } from './message-batcher.js';
 const BOT_TOKEN = process.env.DISCORD_BOT_TOKEN;
 const CHANNEL_ID = process.env.DISCORD_CHANNEL_ID;
 const ALLOWED_USERS = JSON.parse(process.env.DISCORD_ALLOWED_USERS || '[]');
+const TMUX_TARGET = process.env.TMUX_TARGET || '';
 if (!BOT_TOKEN) {
     console.error('[discord-filtered] DISCORD_BOT_TOKEN is required');
     process.exit(1);
@@ -14,11 +16,60 @@ if (!CHANNEL_ID) {
     console.error('[discord-filtered] DISCORD_CHANNEL_ID is required');
     process.exit(1);
 }
-const discord = createDiscordClient({ botToken: BOT_TOKEN, channelId: CHANNEL_ID, allowedUsers: ALLOWED_USERS }, async (message) => {
+function sendInterrupt() {
+    if (!TMUX_TARGET) {
+        console.error('[discord-filtered] !stop received but TMUX_TARGET not set — cannot interrupt');
+        return false;
+    }
+    try {
+        // Escape is Claude Code's interrupt key
+        execSync(`tmux send-keys -t ${JSON.stringify(TMUX_TARGET)} Escape`, { stdio: 'pipe' });
+        console.error(`[discord-filtered] Sent interrupt (Escape) to ${TMUX_TARGET}`);
+        return true;
+    }
+    catch (err) {
+        console.error(`[discord-filtered] Failed to send interrupt: ${err}`);
+        return false;
+    }
+}
+const discord = createDiscordClient({ botToken: BOT_TOKEN, channelId: CHANNEL_ID, allowedUsers: ALLOWED_USERS }, async (content, message) => {
+    // Instant acknowledgment — user knows the message reached the session
+    try {
+        await message.react('👀');
+    }
+    catch { /* ignore */ }
+    const isInterrupt = /^!stop\b/i.test(content);
+    if (isInterrupt) {
+        sendInterrupt();
+        // Strip the !stop prefix and forward the rest as a normal message
+        const rest = content.replace(/^!stop\s*/i, '').trim();
+        // React to confirm the interrupt was received
+        try {
+            await message.react('🛑');
+        }
+        catch { /* ignore */ }
+        // Small delay to let Claude Code process the Escape before the new message arrives
+        await new Promise(r => setTimeout(r, 1500));
+        // Forward the message (with or without remaining text)
+        await mcpServer.notification({
+            method: 'notifications/claude/channel',
+            params: {
+                content: rest || '[interrupted by user]',
+                meta: {
+                    channel_id: message.channel.id,
+                    sender: message.author.username,
+                    sender_id: message.author.id,
+                    message_id: message.id,
+                    interrupt: true,
+                },
+            },
+        });
+        return;
+    }
     await mcpServer.notification({
         method: 'notifications/claude/channel',
         params: {
-            content: message.content,
+            content: content,
             meta: {
                 channel_id: message.channel.id,
                 sender: message.author.username,

package/dist/plugin/message-batcher.js

@@ -1,5 +1,4 @@
 const DISCORD_MAX_LENGTH = 2000;
-const TRUNCATION_SUFFIX = '\n... (truncated)';
 export class MessageBatcher {
     buffer = [];
     timer = null;
@@ -18,12 +17,55 @@ export class MessageBatcher {
     async flush() {
         if (this.buffer.length === 0)
             return;
-        let combined = this.buffer.join('\n');
+        const combined = this.buffer.join('\n');
         this.buffer = [];
         this.timer = null;
-        if (combined.length > DISCORD_MAX_LENGTH) {
-            combined = combined.slice(0, DISCORD_MAX_LENGTH - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
+        // Split into multiple messages instead of truncating
+        const chunks = splitMessage(combined);
+        for (const chunk of chunks) {
+            await this.sendFn(chunk);
         }
-        await this.sendFn(combined);
     }
 }
+// Split long text into Discord-safe chunks, preferring line breaks as split points
+function splitMessage(text) {
+    if (text.length <= DISCORD_MAX_LENGTH)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= DISCORD_MAX_LENGTH) {
+            chunks.push(remaining);
+            break;
+        }
+        // Find a good split point: prefer double newline, then single newline, then space
+        let splitAt = -1;
+        const searchWindow = remaining.slice(0, DISCORD_MAX_LENGTH);
+        // Try splitting at last paragraph break
+        const lastParagraph = searchWindow.lastIndexOf('\n\n');
+        if (lastParagraph > DISCORD_MAX_LENGTH * 0.3) {
+            splitAt = lastParagraph;
+        }
+        // Fall back to last line break
+        if (splitAt === -1) {
+            const lastNewline = searchWindow.lastIndexOf('\n');
+            if (lastNewline > DISCORD_MAX_LENGTH * 0.3) {
+                splitAt = lastNewline;
+            }
+        }
+        // Fall back to last space
+        if (splitAt === -1) {
+            const lastSpace = searchWindow.lastIndexOf(' ');
+            if (lastSpace > DISCORD_MAX_LENGTH * 0.3) {
+                splitAt = lastSpace;
+            }
+        }
+        // Hard split as last resort
+        if (splitAt === -1) {
+            splitAt = DISCORD_MAX_LENGTH;
+        }
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).replace(/^\n+/, '');
+    }
+    return chunks;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onkol",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Decentralized on-call agent system powered by Claude Code",
   "type": "module",
   "bin": {
@@ -19,16 +19,18 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "chalk": "^5.0.0",
+    "commander": "^13.0.0",
     "discord.js": "^14.0.0",
     "handlebars": "^4.7.0",
     "inquirer": "^12.0.0",
-    "chalk": "^5.0.0",
-    "commander": "^13.0.0"
+    "ws": "^8.20.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "typescript": "^5.7.0",
-    "bun-types": "^1.2.0"
+    "@types/ws": "^8.18.1",
+    "bun-types": "^1.2.0",
+    "typescript": "^5.7.0"
   },
   "engines": {
     "node": ">=18.0.0"