clementine-agent 1.0.0

package/dist/channels/slack-agent-bot.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Clementine TypeScript — Slack agent bot client.
+ *
+ * A @slack/bolt App wrapper for a single agent.
+ * Handles: DMs + channel messages → gateway → stream response.
+ * Uses Socket Mode (requires both bot token + app token).
+ *
+ * Channel discovery (in priority order):
+ *   1. Explicit `slackChannelId` from agent config
+ *   2. Auto-discover by matching `channelName` via conversations.list
+ *   3. Falls back to listening in ALL channels the bot is in
+ *
+ * DMs are always enabled for the owner.
+ */
+import type { AgentProfile } from '../types.js';
+import type { Gateway } from '../gateway/router.js';
+export interface SlackAgentBotConfig {
+    slug: string;
+    botToken: string;
+    appToken: string;
+    ownerId: string;
+    profile: AgentProfile;
+    /** Explicit channel IDs to listen in. If empty, auto-discovered on connect. */
+    channelIds?: string[];
+}
+export type SlackAgentBotStatus = 'offline' | 'connecting' | 'online' | 'error';
+export declare class SlackAgentBotClient {
+    private app;
+    private config;
+    private gateway;
+    private status;
+    private errorMessage?;
+    /** Bot's own user ID (set after auth.test). */
+    private botUserId?;
+    /** Resolved channel IDs (set on connect, after auto-discovery). */
+    private resolvedChannelIds;
+    constructor(config: SlackAgentBotConfig, gateway: Gateway);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): {
+        status: SlackAgentBotStatus;
+        botUserId?: string;
+        error?: string;
+    };
+    getChannelIds(): string[];
+    /**
+     * Discover which channels this bot should listen in.
+     *
+     * Priority:
+     * 1. Explicit channelIds from config (e.g. slackChannelId in agent.md)
+     * 2. Match by channelName via conversations.list
+     * 3. All channels the bot is a member of (fallback)
+     */
+    private discoverChannels;
+    /** Check if this bot participates in a shared team chat channel. */
+    isTeamChat(): boolean;
+    /**
+     * Check if this agent is being addressed in a team chat message.
+     * Matches: @mention (Slack format <@UXXXXXX>), agent name, agent slug, or broadcast keywords.
+     */
+    private isAddressedInTeamChat;
+    /**
+     * Collect recent messages from the channel for team chat context.
+     */
+    private gatherTeamChatContext;
+    /**
+     * Receive an inter-agent team message. Posts a formatted message showing
+     * the incoming content, then triggers the agent to process and respond.
+     */
+    receiveTeamMessage(fromName: string, fromSlug: string, content: string): Promise<string>;
+    private handleMessage;
+}
+//# sourceMappingURL=slack-agent-bot.d.ts.map

package/dist/channels/slack-agent-bot.js

@@ -0,0 +1,320 @@
+/**
+ * Clementine TypeScript — Slack agent bot client.
+ *
+ * A @slack/bolt App wrapper for a single agent.
+ * Handles: DMs + channel messages → gateway → stream response.
+ * Uses Socket Mode (requires both bot token + app token).
+ *
+ * Channel discovery (in priority order):
+ *   1. Explicit `slackChannelId` from agent config
+ *   2. Auto-discover by matching `channelName` via conversations.list
+ *   3. Falls back to listening in ALL channels the bot is in
+ *
+ * DMs are always enabled for the owner.
+ */
+import { App } from '@slack/bolt';
+import pino from 'pino';
+import { SlackStreamingMessage } from './slack-utils.js';
+import { friendlyToolName } from './discord-utils.js';
+const logger = pino({ name: 'clementine.slack-agent-bot' });
+export class SlackAgentBotClient {
+    app;
+    config;
+    gateway;
+    status = 'offline';
+    errorMessage;
+    /** Bot's own user ID (set after auth.test). */
+    botUserId;
+    /** Resolved channel IDs (set on connect, after auto-discovery). */
+    resolvedChannelIds = [];
+    constructor(config, gateway) {
+        this.config = config;
+        this.gateway = gateway;
+        this.app = new App({
+            token: config.botToken,
+            appToken: config.appToken,
+            socketMode: true,
+        });
+        // Catch Socket Mode errors so they don't crash the daemon
+        this.app.error(async (error) => {
+            this.status = 'error';
+            this.errorMessage = String(error);
+            logger.error({ err: error, slug: config.slug }, 'Slack agent bot error — continuing');
+        });
+    }
+    async start() {
+        this.status = 'connecting';
+        try {
+            // Get bot identity
+            const authResult = await this.app.client.auth.test({ token: this.config.botToken });
+            this.botUserId = authResult.user_id;
+            // Discover channels
+            this.resolvedChannelIds = await this.discoverChannels();
+            // Register message handler
+            this.app.message(async ({ message, client }) => {
+                try {
+                    await this.handleMessage(message, client);
+                }
+                catch (err) {
+                    logger.error({ err, slug: this.config.slug }, 'Unhandled error in Slack agent bot message handler');
+                }
+            });
+            await this.app.start();
+            this.status = 'online';
+            this.errorMessage = undefined;
+            logger.info({ slug: this.config.slug, botUserId: this.botUserId, channels: this.resolvedChannelIds }, `Slack agent bot online: ${this.config.profile.name}`);
+        }
+        catch (err) {
+            this.status = 'error';
+            this.errorMessage = String(err);
+            logger.error({ err, slug: this.config.slug }, 'Slack agent bot start failed');
+            throw err;
+        }
+    }
+    async stop() {
+        try {
+            await this.app.stop();
+        }
+        catch {
+            // ignore
+        }
+        this.status = 'offline';
+        logger.info({ slug: this.config.slug }, 'Slack agent bot stopped');
+    }
+    getStatus() {
+        return {
+            status: this.status,
+            botUserId: this.botUserId,
+            error: this.errorMessage,
+        };
+    }
+    getChannelIds() {
+        return this.resolvedChannelIds;
+    }
+    /**
+     * Discover which channels this bot should listen in.
+     *
+     * Priority:
+     * 1. Explicit channelIds from config (e.g. slackChannelId in agent.md)
+     * 2. Match by channelName via conversations.list
+     * 3. All channels the bot is a member of (fallback)
+     */
+    async discoverChannels() {
+        // 1. Explicit IDs
+        if (this.config.channelIds && this.config.channelIds.length > 0) {
+            logger.info({ slug: this.config.slug, channelIds: this.config.channelIds }, 'Using explicit channel IDs');
+            return this.config.channelIds;
+        }
+        // Fetch all channels the bot is a member of (paginate fully)
+        const allBotChannels = [];
+        let cursor;
+        do {
+            const result = await this.app.client.conversations.list({
+                token: this.config.botToken,
+                types: 'public_channel,private_channel',
+                exclude_archived: true,
+                limit: 200,
+                cursor,
+            });
+            for (const ch of result.channels ?? []) {
+                if (ch.is_member && ch.id && ch.name) {
+                    allBotChannels.push({ id: ch.id, name: ch.name });
+                }
+            }
+            cursor = result.response_metadata?.next_cursor || undefined;
+        } while (cursor);
+        // 2. Match by channelName
+        const channelNameConfig = this.config.profile.team?.channelName;
+        if (channelNameConfig) {
+            const channelNames = Array.isArray(channelNameConfig) ? channelNameConfig : [channelNameConfig];
+            const matched = allBotChannels
+                .filter(ch => channelNames.includes(ch.name))
+                .map(ch => ch.id);
+            if (matched.length > 0) {
+                logger.info({ slug: this.config.slug, channelNames, matched }, 'Auto-discovered Slack channels by name');
+                return matched;
+            }
+            logger.warn({ slug: this.config.slug, channelNames }, 'No Slack channels found matching channelName(s) — falling back to all bot channels');
+        }
+        // 3. Fallback: all channels the bot is a member of
+        const all = allBotChannels.map(ch => ch.id);
+        logger.info({ slug: this.config.slug, count: all.length }, 'Fallback: listening in all Slack channels bot is a member of');
+        return all;
+    }
+    /** Check if this bot participates in a shared team chat channel. */
+    isTeamChat() {
+        return this.config.profile.team?.teamChat === true;
+    }
+    /**
+     * Check if this agent is being addressed in a team chat message.
+     * Matches: @mention (Slack format <@UXXXXXX>), agent name, agent slug, or broadcast keywords.
+     */
+    isAddressedInTeamChat(text) {
+        // Direct @mention of this bot
+        if (this.botUserId && text.includes(`<@${this.botUserId}>`)) {
+            return true;
+        }
+        const lower = text.toLowerCase();
+        // Broadcast keywords
+        const broadcastPatterns = [
+            /\b@?team\b/,
+            /\beveryone\b/,
+            /\ball\s+agents?\b/,
+            /\bthe\s+team\b/,
+        ];
+        if (broadcastPatterns.some(p => p.test(lower))) {
+            return true;
+        }
+        // Individual agent name or slug at word boundaries
+        const name = this.config.profile.name.toLowerCase();
+        const slug = this.config.slug.toLowerCase();
+        const namePattern = new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+        const slugPattern = new RegExp(`\\b${slug.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+        return namePattern.test(lower) || slugPattern.test(lower);
+    }
+    /**
+     * Collect recent messages from the channel for team chat context.
+     */
+    async gatherTeamChatContext(channel, beforeTs, limit = 10) {
+        try {
+            const result = await this.app.client.conversations.history({
+                token: this.config.botToken,
+                channel,
+                latest: beforeTs,
+                limit: limit + 1,
+                inclusive: false,
+            });
+            const contextLines = [];
+            for (const msg of (result.messages ?? []).reverse()) {
+                const authorName = msg.bot_id ? (msg.username ?? 'Bot') : 'Owner';
+                const preview = (msg.text ?? '').slice(0, 300);
+                if (preview) {
+                    contextLines.push(`[${authorName}]: ${preview}`);
+                }
+            }
+            if (contextLines.length === 0)
+                return '';
+            return `\n\n[Recent team chat context]\n${contextLines.join('\n')}\n[End context]`;
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * Receive an inter-agent team message. Posts a formatted message showing
+     * the incoming content, then triggers the agent to process and respond.
+     */
+    async receiveTeamMessage(fromName, fromSlug, content) {
+        if (this.resolvedChannelIds.length === 0) {
+            logger.warn({ slug: this.config.slug }, 'No Slack channels to deliver team message to');
+            return '(no channels available)';
+        }
+        const channelId = this.resolvedChannelIds[0];
+        // Post the incoming message so it's visible in the channel
+        await this.app.client.chat.postMessage({
+            token: this.config.botToken,
+            channel: channelId,
+            text: `*${fromName}* via team message:\n${content.slice(0, 3000)}`,
+        });
+        // Run the task through the unleashed pipeline — gives the agent full
+        // multi-phase autonomous execution instead of the 5-minute chat timeout.
+        const streamer = new SlackStreamingMessage(this.app.client, channelId);
+        await streamer.start();
+        try {
+            const response = await this.gateway.handleTeamTask(fromName, fromSlug, content, this.config.profile, async (token) => {
+                await streamer.update(token);
+            });
+            await streamer.finalize(response);
+            logger.info({ slug: this.config.slug, from: fromSlug }, 'Processed Slack team message');
+            return response;
+        }
+        catch (err) {
+            logger.error({ err, slug: this.config.slug }, 'Failed to process Slack team message');
+            const errMsg = `Something went wrong processing a team message: ${err}`;
+            await streamer.finalize(errMsg);
+            return errMsg;
+        }
+    }
+    async handleMessage(message, client) {
+        // Ignore own messages
+        if (message.user === this.botUserId)
+            return;
+        // Ignore bot messages
+        if (message.bot_id)
+            return;
+        // Ignore subtypes (joins, leaves, etc.)
+        if (message.subtype)
+            return;
+        const channel = message.channel;
+        const isDm = message.channel_type === 'im';
+        const isWatchedChannel = !isDm && this.resolvedChannelIds.includes(channel);
+        // Respond in DMs or watched channels
+        if (!isDm && !isWatchedChannel)
+            return;
+        const isTeamChatChannel = isWatchedChannel && this.isTeamChat();
+        // Owner-only check
+        if (this.config.ownerId && message.user !== this.config.ownerId) {
+            logger.warn({ slug: this.config.slug, author: message.user }, 'Ignored Slack message from non-owner');
+            return;
+        }
+        // In team chat: respond to all if respondToAll is set, otherwise only when addressed
+        const respondToAll = this.config.profile.team?.respondToAll === true;
+        if (isTeamChatChannel && !respondToAll && !this.isAddressedInTeamChat(message.text ?? '')) {
+            return;
+        }
+        let text = message.text ?? '';
+        // Extract file attachments
+        if (message.files && Array.isArray(message.files) && message.files.length > 0) {
+            const fileLines = message.files.map((file) => {
+                if (file.mimetype?.startsWith('image/')) {
+                    return `[Image attached: ${file.name} (${file.url_private})]`;
+                }
+                return `[File attached: ${file.name}, ${file.mimetype || 'unknown type'}, ${file.url_private}]`;
+            });
+            text = fileLines.join('\n') + (text ? '\n' + text : '');
+        }
+        if (!text)
+            return;
+        // !clear command
+        if (text === '!clear') {
+            const sessionKey = isDm
+                ? `slack:agent:${this.config.slug}:${message.user}`
+                : `slack:channel:${channel}:${this.config.slug}:${message.user}`;
+            this.gateway.clearSession(sessionKey);
+            await client.chat.postMessage({ channel, text: 'Session cleared.', thread_ts: message.ts });
+            return;
+        }
+        // In team chat, use agent-scoped session key
+        const sessionKey = isDm
+            ? `slack:agent:${this.config.slug}:${message.user}`
+            : isTeamChatChannel
+                ? `slack:channel:${channel}:${this.config.slug}:${message.user}`
+                : `slack:channel:${channel}:${message.user}`;
+        // Set the agent profile for this session
+        this.gateway.setSessionProfile(sessionKey, this.config.slug);
+        // In team chat, gather recent messages for context
+        if (isTeamChatChannel) {
+            const teamContext = await this.gatherTeamChatContext(channel, message.ts, 10);
+            if (teamContext) {
+                text += teamContext;
+            }
+        }
+        // Stream response
+        const threadTs = message.thread_ts ?? message.ts;
+        const streamer = new SlackStreamingMessage(client, channel, threadTs);
+        await streamer.start();
+        try {
+            const response = await this.gateway.handleMessage(sessionKey, text, async (token) => {
+                await streamer.update(token);
+            }, undefined, // model
+            undefined, // maxTurns
+            async (toolName, toolInput) => { streamer.setToolStatus(friendlyToolName(toolName, toolInput)); });
+            await streamer.finalize(response);
+        }
+        catch (err) {
+            logger.error({ err, slug: this.config.slug }, 'Slack agent bot message handling error');
+            await streamer.finalize(`Something went wrong: ${err}`);
+        }
+    }
+}
+//# sourceMappingURL=slack-agent-bot.js.map

package/dist/channels/slack-bot-manager.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Clementine TypeScript — Slack bot manager.
+ *
+ * Orchestrates the lifecycle of Slack agent bot clients. Agents with both
+ * `slackBotToken` AND `slackAppToken` in their profile get their own
+ * dedicated @slack/bolt App.
+ */
+import type { Gateway } from '../gateway/router.js';
+import { type SlackAgentBotStatus } from './slack-agent-bot.js';
+export interface SlackBotManagerConfig {
+    gateway: Gateway;
+    ownerId: string;
+    statusFilePath?: string;
+}
+export interface SlackBotStatus {
+    slug: string;
+    status: SlackAgentBotStatus;
+    botUserId?: string;
+    channelIds: string[];
+    error?: string;
+}
+export declare class SlackBotManager {
+    private bots;
+    private gateway;
+    private ownerId;
+    private statusFilePath;
+    private pollInterval?;
+    private statusInterval?;
+    constructor(config: SlackBotManagerConfig);
+    /**
+     * Scan all agents for slackBotToken + slackAppToken, start bots, return owned channel IDs.
+     */
+    startAll(): Promise<string[]>;
+    startBot(slug: string): Promise<void>;
+    stopBot(slug: string): Promise<void>;
+    stopAll(): Promise<void>;
+    getStatuses(): Map<string, SlackBotStatus>;
+    /**
+     * Get all channel IDs managed by Slack agent bots.
+     * Main Slack bot should NOT watch these.
+     */
+    getOwnedChannelIds(): string[];
+    /** Get channel IDs that are shared team chat channels. */
+    getTeamChatChannelIds(): string[];
+    /** Get the primary channel ID for a specific agent bot. */
+    getChannelForAgent(slug: string): string | null;
+    /** Reverse lookup: which agent slug owns a given Slack channel ID? */
+    getAgentForChannel(channelId: string): string | null;
+    /** Get the owner ID. */
+    getOwnerId(): string;
+    /** Check if an agent has a running Slack bot. */
+    hasBot(slug: string): boolean;
+    /**
+     * Deliver a team message to an agent's Slack bot.
+     * Returns the agent's response text, or null if delivery failed.
+     */
+    deliverTeamMessage(toSlug: string, fromName: string, fromSlug: string, content: string): Promise<string | null>;
+    /**
+     * Poll for new/removed agents with Slack tokens at the given interval.
+     */
+    startPolling(intervalMs: number): void;
+    private pollForChanges;
+    /** Write status to disk so the dashboard can read it. */
+    private startStatusWriter;
+}
+//# sourceMappingURL=slack-bot-manager.d.ts.map

package/dist/channels/slack-bot-manager.js

@@ -0,0 +1,236 @@
+/**
+ * Clementine TypeScript — Slack bot manager.
+ *
+ * Orchestrates the lifecycle of Slack agent bot clients. Agents with both
+ * `slackBotToken` AND `slackAppToken` in their profile get their own
+ * dedicated @slack/bolt App.
+ */
+import { writeFileSync } from 'node:fs';
+import path from 'node:path';
+import pino from 'pino';
+import { SlackAgentBotClient } from './slack-agent-bot.js';
+const logger = pino({ name: 'clementine.slack-bot-manager' });
+export class SlackBotManager {
+    bots = new Map();
+    gateway;
+    ownerId;
+    statusFilePath;
+    pollInterval;
+    statusInterval;
+    constructor(config) {
+        this.gateway = config.gateway;
+        this.ownerId = config.ownerId;
+        this.statusFilePath = config.statusFilePath ??
+            path.join(process.env.CLEMENTINE_HOME || path.join(process.env.HOME || '', '.clementine'), '.slack-bot-status.json');
+    }
+    /**
+     * Scan all agents for slackBotToken + slackAppToken, start bots, return owned channel IDs.
+     */
+    async startAll() {
+        const mgr = this.gateway.getAgentManager();
+        const allAgents = mgr.listAll();
+        logger.info({ agentCount: allAgents.length }, 'Scanning agents for Slack tokens');
+        for (const agent of allAgents) {
+            if (!agent.slackBotToken || !agent.slackAppToken)
+                continue;
+            try {
+                await this.startBot(agent.slug);
+            }
+            catch (err) {
+                logger.error({ err, slug: agent.slug }, 'Failed to start Slack agent bot');
+            }
+        }
+        // Start status file writer
+        this.startStatusWriter();
+        return this.getOwnedChannelIds();
+    }
+    async startBot(slug) {
+        // If already running, stop first
+        if (this.bots.has(slug)) {
+            await this.stopBot(slug);
+        }
+        const mgr = this.gateway.getAgentManager();
+        const profile = mgr.get(slug);
+        if (!profile) {
+            throw new Error(`Agent '${slug}' not found`);
+        }
+        if (!profile.slackBotToken || !profile.slackAppToken) {
+            throw new Error(`Agent '${slug}' missing slackBotToken or slackAppToken`);
+        }
+        // Build channel IDs from explicit config
+        const explicitChannelIds = profile.slackChannelId
+            ? [profile.slackChannelId]
+            : undefined;
+        const bot = new SlackAgentBotClient({
+            slug,
+            botToken: profile.slackBotToken,
+            appToken: profile.slackAppToken,
+            ownerId: this.ownerId,
+            profile,
+            channelIds: explicitChannelIds,
+        }, this.gateway);
+        await bot.start();
+        this.bots.set(slug, bot);
+        logger.info({ slug }, 'Slack agent bot started');
+    }
+    async stopBot(slug) {
+        const bot = this.bots.get(slug);
+        if (!bot)
+            return;
+        await bot.stop();
+        this.bots.delete(slug);
+    }
+    async stopAll() {
+        const slugs = [...this.bots.keys()];
+        await Promise.all(slugs.map(slug => this.stopBot(slug)));
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = undefined;
+        }
+        if (this.statusInterval) {
+            clearInterval(this.statusInterval);
+            this.statusInterval = undefined;
+        }
+    }
+    getStatuses() {
+        const result = new Map();
+        for (const [slug, bot] of this.bots) {
+            const s = bot.getStatus();
+            result.set(slug, {
+                slug,
+                status: s.status,
+                botUserId: s.botUserId,
+                channelIds: bot.getChannelIds(),
+                error: s.error,
+            });
+        }
+        return result;
+    }
+    /**
+     * Get all channel IDs managed by Slack agent bots.
+     * Main Slack bot should NOT watch these.
+     */
+    getOwnedChannelIds() {
+        const ids = [];
+        for (const bot of this.bots.values()) {
+            ids.push(...bot.getChannelIds());
+        }
+        return ids;
+    }
+    /** Get channel IDs that are shared team chat channels. */
+    getTeamChatChannelIds() {
+        const ids = [];
+        for (const bot of this.bots.values()) {
+            if (bot.isTeamChat()) {
+                ids.push(...bot.getChannelIds());
+            }
+        }
+        return [...new Set(ids)];
+    }
+    /** Get the primary channel ID for a specific agent bot. */
+    getChannelForAgent(slug) {
+        const bot = this.bots.get(slug);
+        if (!bot)
+            return null;
+        const channels = bot.getChannelIds();
+        return channels[0] ?? null;
+    }
+    /** Reverse lookup: which agent slug owns a given Slack channel ID? */
+    getAgentForChannel(channelId) {
+        for (const [slug, bot] of this.bots) {
+            if (bot.getChannelIds().includes(channelId))
+                return slug;
+        }
+        return null;
+    }
+    /** Get the owner ID. */
+    getOwnerId() {
+        return this.ownerId;
+    }
+    /** Check if an agent has a running Slack bot. */
+    hasBot(slug) {
+        return this.bots.has(slug);
+    }
+    /**
+     * Deliver a team message to an agent's Slack bot.
+     * Returns the agent's response text, or null if delivery failed.
+     */
+    async deliverTeamMessage(toSlug, fromName, fromSlug, content) {
+        const bot = this.bots.get(toSlug);
+        if (!bot)
+            return null;
+        try {
+            return await bot.receiveTeamMessage(fromName, fromSlug, content);
+        }
+        catch (err) {
+            logger.error({ err, toSlug, fromSlug }, 'Failed to deliver Slack team message via bot');
+            return null;
+        }
+    }
+    /**
+     * Poll for new/removed agents with Slack tokens at the given interval.
+     */
+    startPolling(intervalMs) {
+        if (this.pollInterval)
+            clearInterval(this.pollInterval);
+        this.pollInterval = setInterval(async () => {
+            try {
+                await this.pollForChanges();
+            }
+            catch (err) {
+                logger.error({ err }, 'Slack bot polling error');
+            }
+        }, intervalMs);
+    }
+    async pollForChanges() {
+        const mgr = this.gateway.getAgentManager();
+        mgr.invalidateCache();
+        const allAgents = mgr.listAll();
+        // Find agents that should have Slack bots (need both tokens)
+        const shouldHaveBot = new Set();
+        for (const agent of allAgents) {
+            if (agent.slackBotToken && agent.slackAppToken) {
+                shouldHaveBot.add(agent.slug);
+            }
+        }
+        // Start new bots
+        for (const slug of shouldHaveBot) {
+            if (!this.bots.has(slug)) {
+                logger.info({ slug }, 'Detected new agent with Slack tokens — starting bot');
+                try {
+                    await this.startBot(slug);
+                }
+                catch (err) {
+                    logger.error({ err, slug }, 'Failed to start new Slack agent bot');
+                }
+            }
+        }
+        // Stop removed bots
+        for (const slug of this.bots.keys()) {
+            if (!shouldHaveBot.has(slug)) {
+                logger.info({ slug }, 'Agent no longer has Slack tokens — stopping bot');
+                await this.stopBot(slug);
+            }
+        }
+    }
+    /** Write status to disk so the dashboard can read it. */
+    startStatusWriter() {
+        if (this.statusInterval)
+            clearInterval(this.statusInterval);
+        const writeStatus = () => {
+            try {
+                const statuses = {};
+                for (const [slug, status] of this.getStatuses()) {
+                    statuses[slug] = status;
+                }
+                writeFileSync(this.statusFilePath, JSON.stringify(statuses, null, 2));
+            }
+            catch {
+                // Non-fatal
+            }
+        };
+        writeStatus();
+        this.statusInterval = setInterval(writeStatus, 10_000);
+    }
+}
+//# sourceMappingURL=slack-bot-manager.js.map