pikiloop 0.4.0

package/dist/channels/health.js

@@ -0,0 +1,109 @@
+/**
+ * Shared transport health tracker for IM channel listen / connect loops.
+ *
+ * Solves three problems each channel was reinventing:
+ *
+ *  1. **Exponential backoff** — initial → max with doubling between attempts,
+ *     reset on success.
+ *  2. **Log throttling** — continuous failures emit a log line only when the
+ *     retry-delay bucket changes (1s → 2s → 4s → …), so identical failures
+ *     don't flood the journal once per attempt.
+ *  3. **Sustained-failure notice** — after a configurable threshold (5 min
+ *     by default) of uninterrupted failures, emit a one-shot warn-level
+ *     line pointing the operator at the relevant config. Retries continue
+ *     indefinitely — the notice is informational, not a stop signal.
+ *
+ * Usage (long-poll style):
+ *
+ * ```ts
+ * const health = new ChannelHealth({ label: 'Weixin', opAction: 'polling',
+ *   initialDelayMs: 1_000, maxDelayMs: 60_000,
+ *   sustainedFailureHint: 'verify baseUrl / token / accountId',
+ *   log: (msg, level) => this.log(msg, level) });
+ *
+ * while (!stopping) {
+ *   try {
+ *     await poll();
+ *     health.recordSuccess();
+ *     // …process result…
+ *   } catch (err) {
+ *     if (stopping || isAbort(err)) break;
+ *     await sleep(health.recordFailure(err));
+ *   }
+ * }
+ * ```
+ */
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error ?? 'unknown error');
+}
+export class ChannelHealth {
+    label;
+    opAction;
+    initialDelayMs;
+    maxDelayMs;
+    log;
+    sustainedThresholdMs;
+    sustainedFailureHint;
+    transientFailureLevel;
+    delayMs;
+    consecutiveFailures = 0;
+    firstFailureAt = null;
+    lastLoggedDelayMs = 0;
+    sustainedNoticeFired = false;
+    constructor(opts) {
+        this.label = opts.label;
+        this.opAction = opts.opAction;
+        this.initialDelayMs = opts.initialDelayMs;
+        this.maxDelayMs = opts.maxDelayMs;
+        this.log = opts.log;
+        this.sustainedThresholdMs = opts.sustainedThresholdMs ?? 5 * 60_000;
+        this.sustainedFailureHint = opts.sustainedFailureHint ?? '';
+        this.transientFailureLevel = opts.transientFailureLevel ?? 'warn';
+        this.delayMs = opts.initialDelayMs;
+    }
+    /**
+     * Mark the operation as currently succeeding. Resets backoff state and,
+     * if there were prior failures, emits an info-level recovery line.
+     */
+    recordSuccess() {
+        if (this.consecutiveFailures > 0 && this.firstFailureAt !== null) {
+            const downtimeMs = Date.now() - this.firstFailureAt;
+            this.log(`${this.label}: connection recovered after ${Math.round(downtimeMs / 1000)}s `
+                + `(${this.consecutiveFailures} failed attempts)`, 'info');
+        }
+        this.delayMs = this.initialDelayMs;
+        this.consecutiveFailures = 0;
+        this.firstFailureAt = null;
+        this.lastLoggedDelayMs = 0;
+        this.sustainedNoticeFired = false;
+    }
+    /**
+     * Record a failure. Emits the per-bucket failure log (throttled) and the
+     * one-shot sustained-failure notice when applicable, then advances the
+     * backoff for the *next* failure. Returns the delay (ms) the caller
+     * should sleep before its next attempt.
+     */
+    recordFailure(error) {
+        this.consecutiveFailures += 1;
+        if (this.firstFailureAt === null)
+            this.firstFailureAt = Date.now();
+        const elapsedMs = Date.now() - this.firstFailureAt;
+        const delayMs = this.delayMs;
+        if (delayMs !== this.lastLoggedDelayMs) {
+            this.log(`${this.label} ${this.opAction} failed (retrying in ${Math.ceil(delayMs / 1000)}s): ${describeError(error)}`, this.transientFailureLevel);
+            this.lastLoggedDelayMs = delayMs;
+        }
+        if (!this.sustainedNoticeFired && elapsedMs >= this.sustainedThresholdMs) {
+            this.sustainedNoticeFired = true;
+            const hint = this.sustainedFailureHint ? ` — ${this.sustainedFailureHint}` : '';
+            this.log(`⚠ ${this.label}: connection has been failing for ${Math.round(elapsedMs / 60_000)}+ min `
+                + `(${this.consecutiveFailures} attempts)${hint}. Retries continue at ${Math.ceil(delayMs / 1000)}s intervals.`, 'warn');
+        }
+        this.delayMs = Math.min(this.delayMs * 2, this.maxDelayMs);
+        return delayMs;
+    }
+    /** Current consecutive failure count. */
+    get failureCount() {
+        return this.consecutiveFailures;
+    }
+}

package/dist/channels/slack/bot.js

@@ -0,0 +1,554 @@
+/**
+ * Slack bot orchestration.
+ *
+ * Mirrors WeixinBot's command surface (/help, /status, /agent, /models, …)
+ * over Slack channels and DMs. Each Slack channel id is a chat key, threads
+ * are reused so the bot's reply lands in the same conversation as the trigger.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Bot, buildPrompt, fmtUptime, fmtBytes, formatGitStatusLine, normalizeAgent, parseAllowedChatIds, } from '../../bot/bot.js';
+import { BOT_SHUTDOWN_FORCE_EXIT_MS, buildSessionTaskId } from '../../bot/orchestration.js';
+import { shutdownAllDrivers } from '../../agent/driver.js';
+import { expandTilde } from '../../core/platform.js';
+import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
+import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getStartData, getWorkspacesData, } from '../../bot/commands.js';
+import { SlackChannel } from './channel.js';
+import { getActiveUserConfig } from '../../core/config/user-config.js';
+const SHUTDOWN_EXIT_CODE = {
+    SIGINT: 130,
+    SIGTERM: 143,
+};
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error ?? 'unknown error');
+}
+export class SlackBot extends Bot {
+    botToken;
+    appToken;
+    channel;
+    nextTaskId = 1;
+    shutdownInFlight = false;
+    shutdownExitCode = null;
+    shutdownForceExitTimer = null;
+    signalHandlers = {};
+    processRuntimeCleanup = null;
+    constructor() {
+        super();
+        const config = getActiveUserConfig();
+        if (process.env.SLACK_ALLOWED_CHANNEL_IDS) {
+            for (const id of parseAllowedChatIds(process.env.SLACK_ALLOWED_CHANNEL_IDS))
+                this.allowedChatIds.add(id);
+        }
+        this.botToken = String(config.slackBotToken || process.env.SLACK_BOT_TOKEN || '').trim();
+        this.appToken = String(config.slackAppToken || process.env.SLACK_APP_TOKEN || '').trim();
+        if (!this.botToken || !this.appToken) {
+            throw new Error('Missing Slack credentials. Configure slackBotToken and slackAppToken.');
+        }
+    }
+    requestStop() {
+        super.requestStop();
+        try {
+            this.channel?.disconnect();
+        }
+        catch { }
+    }
+    onManagedConfigChange(config, opts = {}) {
+        const nextBotToken = String(config.slackBotToken || process.env.SLACK_BOT_TOKEN || '').trim();
+        const nextAppToken = String(config.slackAppToken || process.env.SLACK_APP_TOKEN || '').trim();
+        if (nextBotToken && nextBotToken !== this.botToken) {
+            this.botToken = nextBotToken;
+            if (!opts.initial)
+                this.log('slack botToken reloaded from setting.json');
+        }
+        if (nextAppToken && nextAppToken !== this.appToken) {
+            this.appToken = nextAppToken;
+            if (!opts.initial)
+                this.log('slack appToken reloaded from setting.json');
+        }
+    }
+    installSignalHandlers() {
+        this.removeSignalHandlers();
+        const onSigint = () => this.beginShutdown('SIGINT');
+        const onSigterm = () => this.beginShutdown('SIGTERM');
+        this.signalHandlers = { SIGINT: onSigint, SIGTERM: onSigterm };
+        process.once('SIGINT', onSigint);
+        process.once('SIGTERM', onSigterm);
+    }
+    removeSignalHandlers() {
+        for (const signal of Object.keys(this.signalHandlers)) {
+            const handler = this.signalHandlers[signal];
+            if (handler)
+                process.off(signal, handler);
+        }
+        this.signalHandlers = {};
+    }
+    clearShutdownForceExitTimer() {
+        if (!this.shutdownForceExitTimer)
+            return;
+        clearTimeout(this.shutdownForceExitTimer);
+        this.shutdownForceExitTimer = null;
+    }
+    cleanupRuntimeForExit() {
+        try {
+            this.channel.disconnect();
+        }
+        catch { }
+        this.stopKeepAlive();
+        shutdownAllDrivers();
+    }
+    beginShutdown(signal) {
+        if (this.shutdownInFlight)
+            return;
+        this.shutdownInFlight = true;
+        this.shutdownExitCode = SHUTDOWN_EXIT_CODE[signal];
+        this.log(`${signal}, shutting down...`);
+        this.cleanupRuntimeForExit();
+        this.clearShutdownForceExitTimer();
+        this.shutdownForceExitTimer = setTimeout(() => {
+            this.log(`shutdown still pending after ${Math.floor(BOT_SHUTDOWN_FORCE_EXIT_MS / 1000)}s, forcing exit`);
+            process.exit(this.shutdownExitCode ?? 1);
+        }, BOT_SHUTDOWN_FORCE_EXIT_MS);
+        this.shutdownForceExitTimer.unref?.();
+    }
+    resolveSession(chatId, title, files) {
+        return this.ensureSessionForChat(chatId, title, files);
+    }
+    async handleCommand(text, ctx) {
+        const [rawCommand, ...rest] = text.trim().slice(1).split(/\s+/);
+        const command = rawCommand?.toLowerCase() || '';
+        const args = rest.join(' ').trim();
+        switch (command) {
+            case 'help':
+                await ctx.reply([
+                    '/help - Show commands',
+                    '/new - New session',
+                    '/status - Session status',
+                    '/host - Host system info',
+                    '/agent [codex|claude|gemini] - Switch agent',
+                    '/models [name|#] - Switch model',
+                    '/mode [plan|code] - Toggle plan mode (claude only)',
+                    '/switch [path] - Change workdir',
+                    '/workspaces [#] - Pick saved workspace',
+                    '/sessions [new|#] - List/switch sessions',
+                    '/skills - List project skills',
+                    '/stop - Stop current task',
+                    '/restart - Restart pikiloop',
+                ].join('\n'));
+                return true;
+            case 'new': {
+                this.resetConversationForChat(ctx.chatId);
+                await ctx.reply('Started a new session.');
+                return true;
+            }
+            case 'status':
+                await this.cmdStatus(ctx);
+                return true;
+            case 'host':
+                await this.cmdHost(ctx);
+                return true;
+            case 'agent':
+                await this.cmdAgent(ctx, args);
+                return true;
+            case 'models':
+                await this.cmdModels(ctx, args);
+                return true;
+            case 'mode':
+                await this.cmdMode(ctx, args);
+                return true;
+            case 'switch':
+                await this.cmdSwitch(ctx, args);
+                return true;
+            case 'workspaces':
+                await this.cmdWorkspaces(ctx, args);
+                return true;
+            case 'sessions':
+                await this.cmdSessions(ctx, args);
+                return true;
+            case 'skills':
+                await this.cmdSkills(ctx);
+                return true;
+            case 'stop':
+                await this.cmdStop(ctx);
+                return true;
+            case 'restart':
+                await this.cmdRestart(ctx);
+                return true;
+            case 'start':
+                await this.cmdStart(ctx);
+                return true;
+            default: return false;
+        }
+    }
+    async cmdStart(ctx) {
+        const d = getStartData(this, ctx.chatId);
+        const lines = [`pikiloop v${d.version}`, `Workdir: ${d.workdir}`, '', `Agent: ${d.agent}`];
+        for (const a of d.agentDetails) {
+            const parts = [`  ${a.agent}: ${a.model}`];
+            if (a.effort)
+                parts[0] += ` (effort: ${a.effort})`;
+            lines.push(parts[0]);
+        }
+        lines.push('', 'Ready. Send a message to start.');
+        await ctx.reply(lines.join('\n'));
+    }
+    async cmdStatus(ctx) {
+        const d = await getStatusDataAsync(this, ctx.chatId);
+        const gitLine = formatGitStatusLine(d.git);
+        const lines = [
+            `pikiloop v${d.version}`,
+            `Uptime: ${fmtUptime(d.uptime)}`,
+            `PID: ${d.pid} | RSS: ${fmtBytes(d.memRss)} | Heap: ${fmtBytes(d.memHeap)}`,
+            `Workdir: ${d.workdir}`,
+            ...(gitLine ? [`Git: ${gitLine}`] : []),
+            '',
+            `Agent: ${d.agent}`,
+            `Model: ${d.model || '-'}`,
+            `Session: ${d.sessionId ? d.sessionId.slice(0, 16) : '(new)'}`,
+            `Tasks: ${d.activeTasksCount}`,
+        ];
+        if (d.running)
+            lines.push(`Running: ${fmtUptime(Date.now() - d.running.startedAt)}`);
+        await ctx.reply(lines.join('\n'));
+    }
+    async cmdHost(ctx) {
+        const d = getHostDataSync(this);
+        const lines = [`Host: ${d.hostName}`, `CPU: ${d.cpuModel} x${d.cpuCount}`];
+        if (d.cpuUsage) {
+            lines.push(`CPU Usage: ${d.cpuUsage.usedPercent.toFixed(1)}% (user ${d.cpuUsage.userPercent.toFixed(1)}%, sys ${d.cpuUsage.sysPercent.toFixed(1)}%)`);
+        }
+        lines.push(`Memory: ${fmtBytes(d.memoryUsed)} / ${fmtBytes(d.totalMem)} (${d.memoryPercent.toFixed(0)}%)`, `Available: ${fmtBytes(d.memoryAvailable)}`);
+        if (d.battery)
+            lines.push(`Battery: ${d.battery.percent} (${d.battery.state})`);
+        if (d.disk)
+            lines.push(`Disk: ${d.disk.used} / ${d.disk.total} (${d.disk.percent})`);
+        lines.push(`Process: PID ${d.selfPid} | RSS ${fmtBytes(d.selfRss)} | Heap ${fmtBytes(d.selfHeap)}`);
+        if (d.topProcs.length > 1) {
+            lines.push('', 'Top Processes:');
+            lines.push(...d.topProcs);
+        }
+        await ctx.reply(lines.join('\n'));
+    }
+    async cmdAgent(ctx, args) {
+        if (!args) {
+            const d = getAgentsListData(this, ctx.chatId);
+            const current = d.agents.find(a => a.isCurrent);
+            const lines = [];
+            lines.push(`Current: ${current ? current.label : d.currentAgent}`, '');
+            for (const a of d.agents) {
+                const tick = a.installed ? '✓' : '✗';
+                const head = a.versionShort ? `${tick} ${a.label} · v${a.versionShort}` : `${tick} ${a.label}`;
+                lines.push(a.isCurrent ? `${head}  ← current` : head);
+                if (a.boundProvider && a.boundModel)
+                    lines.push(`   └ ${a.boundProvider} / ${a.boundModel}`);
+            }
+            const ids = d.agents.filter(a => a.installed).map(a => a.agent).join('|');
+            lines.push('', `Switch: /agent ${ids || 'codex|claude|gemini|hermes'}`);
+            await ctx.reply(lines.join('\n'));
+            return;
+        }
+        try {
+            const agent = normalizeAgent(args);
+            this.switchAgentForChat(ctx.chatId, agent);
+            await ctx.reply(`Agent switched to ${agent}.`);
+        }
+        catch {
+            await ctx.reply('Unknown agent. Use: /agent codex|claude|gemini');
+        }
+    }
+    async cmdModels(ctx, args) {
+        const d = await getModelsListData(this, ctx.chatId);
+        if (args) {
+            const idx = parseInt(args, 10);
+            let modelId = null;
+            if (!isNaN(idx) && idx >= 1 && idx <= d.models.length)
+                modelId = d.models[idx - 1].id;
+            else {
+                const match = d.models.find(m => m.id === args || m.alias === args);
+                if (match)
+                    modelId = match.id;
+            }
+            if (modelId) {
+                this.switchModelForChat(ctx.chatId, modelId);
+                await ctx.reply(`Model switched to ${modelId}.`);
+                return;
+            }
+            await ctx.reply(`Unknown model: ${args}`);
+            return;
+        }
+        const lines = [`Current: ${d.currentModel}`, ''];
+        d.models.forEach((m, i) => {
+            const alias = m.alias ? ` (${m.alias})` : '';
+            const mark = m.isCurrent ? ' ←' : '';
+            lines.push(`${i + 1}. ${m.id}${alias}${mark}`);
+        });
+        if (d.effort) {
+            lines.push('', `Effort: ${d.effort.current}`);
+            for (const lv of d.effort.levels) {
+                const mark = lv.isCurrent ? ' ←' : '';
+                lines.push(`  ${lv.id} - ${lv.label}${mark}`);
+            }
+        }
+        lines.push('', 'Usage: /models <name|number>');
+        await ctx.reply(lines.join('\n'));
+    }
+    async cmdMode(ctx, args) {
+        if (this.chat(ctx.chatId).agent !== 'claude') {
+            await ctx.reply('Mode toggle is only available for Claude agent.');
+            return;
+        }
+        const isPlan = this.agentConfigs.claude.permissionMode === 'plan';
+        if (args === 'plan') {
+            this.switchPermissionModeForChat(ctx.chatId, 'plan');
+            await ctx.reply('Mode: Plan (read-only)');
+        }
+        else if (args === 'code') {
+            this.switchPermissionModeForChat(ctx.chatId, 'bypassPermissions');
+            await ctx.reply('Mode: Code (full access)');
+        }
+        else {
+            await ctx.reply(`Current: ${isPlan ? 'Plan (read-only)' : 'Code (full access)'}\n\nUsage: /mode plan|code`);
+        }
+    }
+    async cmdSwitch(ctx, args) {
+        const wd = this.chatWorkdir(ctx.chatId);
+        if (args) {
+            const resolvedPath = path.resolve(expandTilde(args));
+            if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) {
+                await ctx.reply(`Not a valid directory: ${resolvedPath}`);
+                return;
+            }
+            const oldPath = this.switchWorkdir(resolvedPath);
+            await ctx.reply(`Workdir switched:\n${oldPath}\n→ ${resolvedPath}`);
+            return;
+        }
+        const savedCount = getWorkspacesData(this, ctx.chatId).workspaces.length;
+        const hint = savedCount > 0
+            ? `\n\nTip: ${savedCount} saved workspace${savedCount === 1 ? '' : 's'} — use /workspaces to pick one.`
+            : '';
+        await ctx.reply(`Current workdir: ${wd}\n\nUsage: /switch <path>${hint}`);
+    }
+    async cmdWorkspaces(ctx, args) {
+        const data = getWorkspacesData(this, ctx.chatId);
+        if (data.workspaces.length === 0) {
+            await ctx.reply('No saved workspaces yet. Add them from the dashboard, or use /switch <path>.');
+            return;
+        }
+        const trimmed = args.trim();
+        if (trimmed) {
+            const idx = parseInt(trimmed, 10);
+            if (Number.isNaN(idx) || idx < 1 || idx > data.workspaces.length) {
+                await ctx.reply(`Workspace #${trimmed} not found. Use /workspaces to list.`);
+                return;
+            }
+            const ws = data.workspaces[idx - 1];
+            if (!ws.exists) {
+                await ctx.reply(`Workspace path is missing on disk:\n${ws.path}`);
+                return;
+            }
+            const oldPath = this.switchWorkdir(ws.path);
+            await ctx.reply(`Workdir switched:\n${oldPath}\n→ ${ws.path}`);
+            return;
+        }
+        const lines = ['Saved workspaces:', `Current: ${data.currentWorkdir}`, ''];
+        data.workspaces.forEach((ws, i) => {
+            const marker = ws.isCurrent ? '✓' : ws.exists ? ' ' : '⚠';
+            lines.push(`${marker} ${i + 1}. ${ws.name}`);
+            lines.push(`     ${ws.path}`);
+        });
+        lines.push('', 'Usage: /workspaces <number> to switch.');
+        await ctx.reply(lines.join('\n'));
+    }
+    async cmdSessions(ctx, args) {
+        const arg = args.trim().toLowerCase();
+        if (arg === 'new') {
+            this.resetConversationForChat(ctx.chatId);
+            await ctx.reply('Started a new session.');
+            return;
+        }
+        const idx = parseInt(arg, 10);
+        if (!isNaN(idx) && idx >= 1) {
+            const d = await getSessionsPageData(this, ctx.chatId, 0, 100);
+            const target = d.sessions[idx - 1];
+            if (target) {
+                const result = await this.fetchSessions(undefined, this.chatWorkdir(ctx.chatId));
+                const session = result.sessions.find(s => s.sessionId === target.key);
+                if (session) {
+                    this.resumeSessionForChat(ctx.chatId, session);
+                    await ctx.reply(`Switched to [${session.agent}] ${target.title}`);
+                }
+                else {
+                    await ctx.reply('Session not found.');
+                }
+                return;
+            }
+            await ctx.reply(`Session #${idx} not found.`);
+            return;
+        }
+        const d = await getSessionsPageData(this, ctx.chatId, 0, 10);
+        if (!d.sessions.length) {
+            await ctx.reply('No sessions found.');
+            return;
+        }
+        const lines = [`Sessions (${d.total}):`, ''];
+        d.sessions.forEach((s, i) => {
+            const mark = s.isCurrent ? ' ←' : '';
+            const running = s.isRunning ? ' [running]' : '';
+            lines.push(`${i + 1}. [${s.agent}] ${s.title} · ${s.time}${mark}${running}`);
+        });
+        lines.push('', 'Usage: /sessions new | /sessions <#>');
+        await ctx.reply(lines.join('\n'));
+    }
+    async cmdSkills(ctx) {
+        const d = getSkillsListData(this, ctx.chatId);
+        if (!d.skills.length) {
+            await ctx.reply('No project skills found.');
+            return;
+        }
+        const lines = [`Skills (${d.agent}):`, ''];
+        for (const s of d.skills) {
+            const desc = s.description ? ` - ${s.description}` : '';
+            lines.push(`/${s.command} (${s.label})${desc}`);
+        }
+        await ctx.reply(lines.join('\n'));
+    }
+    async cmdStop(ctx) {
+        const session = this.selectedSession(ctx.chatId);
+        if (!session) {
+            await ctx.reply('No active session to stop.');
+            return;
+        }
+        const { interrupted, cancelledQueued } = this.stopTasksForSession(session.key);
+        if (!interrupted && cancelledQueued === 0) {
+            await ctx.reply('No running or queued work for the current session.');
+            return;
+        }
+        const parts = [];
+        if (interrupted)
+            parts.push('interrupted current run');
+        if (cancelledQueued > 0)
+            parts.push(`cancelled ${cancelledQueued} queued task(s)`);
+        await ctx.reply(`Stopped: ${parts.join(', ')}.`);
+    }
+    async cmdRestart(ctx) {
+        await ctx.reply('Restarting pikiloop...');
+        void requestProcessRestart({ log: msg => this.log(msg) });
+    }
+    createMcpSendFile(chatId) {
+        return async (filePath) => {
+            try {
+                await this.channel.send(chatId, `Artifact ready: ${path.basename(filePath)}\n${filePath}`);
+                return { ok: true };
+            }
+            catch (error) {
+                return { ok: false, error: describeError(error) };
+            }
+        };
+    }
+    async sendResult(chatId, result) {
+        const text = result.ok
+            ? (result.message.trim() || 'Task finished.')
+            : ['Task failed.', result.error || result.message || 'Unknown error.'].filter(Boolean).join('\n');
+        await this.channel.send(chatId, text);
+    }
+    async handleMessage(msg, ctx) {
+        const text = msg.text.trim();
+        if (text.startsWith('/') && await this.handleCommand(text, ctx))
+            return;
+        if (!text && !msg.files.length) {
+            await ctx.reply('Send some text — file uploads are not yet supported on the Slack channel.');
+            return;
+        }
+        const session = this.resolveSession(ctx.chatId, text, msg.files);
+        const prompt = buildPrompt(text, msg.files);
+        const taskId = buildSessionTaskId(session, this.nextTaskId++);
+        this.beginTask({
+            taskId,
+            chatId: ctx.chatId,
+            agent: session.agent,
+            sessionKey: session.key,
+            prompt,
+            startedAt: Date.now(),
+            sourceMessageId: ctx.messageId,
+        });
+        this.emitStreamQueued(session.key, taskId);
+        void this.queueSessionTask(session, async () => {
+            const abortController = new AbortController();
+            const task = this.markTaskRunning(taskId, () => abortController.abort());
+            if (task?.cancelled) {
+                this.emitStreamCancelled(taskId, session.key);
+                this.finishTask(taskId);
+                return;
+            }
+            this.emitStreamStart(taskId, session);
+            try {
+                const result = await this.runStream(prompt, session, msg.files, (text, thinking, activity, meta, plan) => {
+                    this.emitStreamText(taskId, session.key, text, thinking, activity, meta, plan);
+                }, undefined, this.createMcpSendFile(ctx.chatId), abortController.signal, this.createInteractionHandler(ctx.chatId, taskId));
+                this.emitStreamDone(taskId, session.key, {
+                    sessionId: result.sessionId || session.sessionId,
+                    incomplete: !!result.incomplete,
+                    ...(result.ok ? {} : { error: result.error || result.message }),
+                });
+                await this.sendResult(ctx.chatId, result);
+            }
+            catch (error) {
+                this.emitStreamDone(taskId, session.key, {
+                    sessionId: session.sessionId,
+                    incomplete: true,
+                    error: describeError(error),
+                });
+                await ctx.reply(`Error: ${describeError(error)}`);
+            }
+            finally {
+                this.finishTask(taskId);
+                this.syncSelectedChats(session);
+            }
+        }, taskId).catch(error => {
+            this.finishTask(taskId);
+            this.log(`slack queue execution failed: ${describeError(error)}`);
+        });
+    }
+    async run() {
+        const tmpDir = path.join(os.tmpdir(), 'pikiloop');
+        fs.mkdirSync(tmpDir, { recursive: true });
+        this.channel = new SlackChannel({
+            botToken: this.botToken,
+            appToken: this.appToken,
+            workdir: tmpDir,
+            allowedChatIds: this.allowedChatIds.size ? new Set([...this.allowedChatIds].map(value => String(value))) : undefined,
+        });
+        this.processRuntimeCleanup?.();
+        this.processRuntimeCleanup = registerProcessRuntime({
+            label: 'slack',
+            getActiveTaskCount: () => this.activeTasks.size,
+            prepareForRestart: () => this.cleanupRuntimeForExit(),
+        });
+        this.installSignalHandlers();
+        try {
+            const bot = await this.channel.connect();
+            this.connected = true;
+            this.log(`bot: ${bot.displayName} (id=${bot.id})`);
+            for (const agent of this.fetchAgents().agents) {
+                this.log(`agent ${agent.agent}: ${agent.path || 'NOT FOUND'}`);
+            }
+            this.log(`config: agent=${this.defaultAgent} workdir=${this.workdir} timeout=${this.runTimeout}s`);
+            this.channel.onMessage((msg, ctx) => this.handleMessage(msg, ctx));
+            this.channel.onError(error => this.log(`error: ${describeError(error)}`));
+            this.startKeepAlive();
+            this.log('✓ Slack connected, Socket Mode listening — ready to receive messages');
+            await this.channel.listen();
+            this.stopKeepAlive();
+            this.log('stopped');
+        }
+        finally {
+            this.stopKeepAlive();
+            this.clearShutdownForceExitTimer();
+            this.removeSignalHandlers();
+            this.processRuntimeCleanup?.();
+            this.processRuntimeCleanup = null;
+            if (this.shutdownInFlight)
+                process.exit(this.shutdownExitCode ?? 1);
+        }
+    }
+}