@nordbyte/nordrelay 0.8.0 → 0.8.2

package/dist/{slack-bot.js → channels/slack/slack-bot.js}

@@ -1,47 +1,48 @@
 import { randomUUID } from "node:crypto";
 import { App } from "@slack/bolt";
-import { ADMIN_GROUP_ID } from "./access-control.js";
-import { agentLabel, agentReasoningLabel, agentReasoningOptions } from "./agent.js";
-import { getAgentActivityLog, getExternalSnapshotForSession } from "./agent-activity.js";
-import { listAgentAdapterDescriptors } from "./agent-adapter.js";
-import { AgentUpdateManager } from "./agent-updates.js";
-import { enabledAgents } from "./agent-factory.js";
-import { collectRecentWorkspaceArtifacts, ensureOutDir, formatArtifactSummary, persistWorkspaceArtifactReport } from "./artifacts.js";
-import { buildFileInstructions, outboxPath, stageFile } from "./attachments.js";
-import { AuditLogStore } from "./audit-log.js";
-import { BotPreferencesStore } from "./bot-preferences.js";
-import { capabilitiesOf, filterActivityEvents, parseActivityOptions, renderExternalMirrorEvent, renderExternalMirrorStatus, renderPromptFailure, trimLine } from "./bot-rendering.js";
-import { parseAgentUpdateId, renderAgentUpdateJobAction, renderAgentUpdateJobsAction, renderAgentUpdateLogAction, renderAgentUpdatePickerAction, renderQueueListAction } from "./channel-actions.js";
-import { createSharedChannelCommandDispatcher } from "./channel-command-core.js";
-import { slackHelpCommandList } from "./channel-command-catalog.js";
-import { ChannelCommandService } from "./channel-command-service.js";
-import { createChannelPromptEngine } from "./channel-prompt-engine.js";
-import { runChannelPeerPrompt } from "./channel-peer-prompt.js";
-import { deliverChannelAction } from "./channel-runtime.js";
-import { checkAuthStatus, startLogin as startCodexLogin, startLogout as startCodexLogout } from "./codex-auth.js";
-import { checkClaudeCodeAuthStatus, startClaudeCodeLogin, startClaudeCodeLogout } from "./claude-code-auth.js";
-import { isSlackContextKey, parseSlackContextKey, slackContextKey } from "./context-key.js";
-import { friendlyErrorText } from "./error-messages.js";
-import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
-import { spawnConnectorRestart, spawnSelfUpdate } from "./operations.js";
-import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
-import { RemoteRelayClient } from "./peer-client.js";
-import { checkPiAuthStatus } from "./pi-auth.js";
-import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
-import { RelayArtifactService } from "./relay-artifact-service.js";
-import { configureRedaction, redactText } from "./redaction.js";
-import { renderSessionInfoPlain } from "./session-format.js";
-import { canWriteWithLock, SessionLockStore } from "./session-locks.js";
-import { SessionRegistry } from "./session-registry.js";
+import { ADMIN_GROUP_ID } from "../../access/access-control.js";
+import { agentLabel, agentReasoningLabel, agentReasoningOptions } from "../../agents/shared/agent.js";
+import { getAgentActivityLog, getExternalSnapshotForSession } from "../../agents/shared/agent-activity.js";
+import { hostAgentLoginCommand, hostAgentLogoutCommand } from "../../agents/shared/agent-auth-commands.js";
+import { listAgentAdapterDescriptors } from "../../agents/shared/agent-adapter.js";
+import { AgentUpdateManager } from "../../agents/shared/agent-updates.js";
+import { enabledAgents } from "../../agents/shared/agent-factory.js";
+import { ensureOutDir } from "../../artifacts/artifacts.js";
+import { buildFileInstructions, outboxPath, stageFile } from "../../artifacts/attachments.js";
+import { AuditLogStore } from "../../access/audit-log.js";
+import { BotPreferencesStore } from "../../state/bot-preferences.js";
+import { capabilitiesOf, filterActivityEvents, parseActivityOptions, renderPromptFailure, trimLine } from "../shared/bot-rendering.js";
+import { parseAgentUpdateId, renderAgentUpdateJobAction, renderAgentUpdateJobsAction, renderAgentUpdateLogAction, renderAgentUpdatePickerAction, renderQueueListAction } from "../shared/channel-actions.js";
+import { createChannelActivityRecorder, createChannelAuditRecorder, createChannelBusyStore, createChannelPermissionChecker, createChannelQueueStatusController, } from "../shared/channel-bridge-controller.js";
+import { createSharedChannelCommandDispatcher } from "../shared/channel-command-core.js";
+import { slackHelpCommandList } from "../shared/channel-command-catalog.js";
+import { ChannelCommandService } from "../shared/channel-command-service.js";
+import { createChannelPromptEngine } from "../shared/channel-prompt-engine.js";
+import { runChannelPeerPrompt } from "../shared/channel-peer-prompt.js";
+import { deliverChannelAction } from "../shared/channel-runtime.js";
+import { deliverChannelCliArtifacts } from "../shared/channel-cli-artifacts.js";
+import { createChannelExternalMirrorController } from "../shared/channel-external-mirror-controller.js";
+import { monitorChannelExternalContexts } from "../shared/channel-external-monitor.js";
+import { isSlackContextKey, parseSlackContextKey, slackContextKey } from "../shared/context-key.js";
+import { friendlyErrorText } from "../../core/error-messages.js";
+import { spawnConnectorRestart, spawnSelfUpdate } from "../../support/operations.js";
+import { RemoteRelayClient } from "../../peers/peer-client.js";
+import { PromptStore, toPromptEnvelope } from "../../state/prompt-store.js";
+import { RelayArtifactService } from "../../runtime/relay-artifact-service.js";
+import { RelayAuthService } from "../../runtime/relay-auth-service.js";
+import { configureRedaction, redactText } from "../../core/redaction.js";
+import { renderSessionInfoPlain } from "../shared/session-format.js";
+import { canWriteWithLock, SessionLockStore } from "../../access/session-locks.js";
+import { SessionRegistry } from "../../state/session-registry.js";
 import { createSlackArtifactCommandHandler, sendRecentSlackArtifacts } from "./slack-artifacts.js";
 import { SlackBotChannelRuntime, actionFromSlackActionId, splitSlackMessage, trimSlackMessage } from "./slack-channel-runtime.js";
 import { isUnauthenticatedSlackCommandAllowed, parseSlackMessageCommand, parseSlackSlashCommand, permissionForSlackAction, requiredPermissionForSlackCommand } from "./slack-command-surface.js";
 import { collectSlackDiagnostics } from "./slack-diagnostics.js";
 import { getSlackRateLimitMetrics } from "./slack-rate-limit.js";
-import { transcribeAudio } from "./voice.js";
-import { UserStore } from "./user-management.js";
-import { WebActivityStore } from "./web-state.js";
-import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "./workspace-policy.js";
+import { transcribeAudio } from "../../artifacts/voice.js";
+import { UserStore } from "../../access/user-management.js";
+import { WebActivityStore } from "../../web/web-state.js";
+import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "../../core/workspace-policy.js";
 export { isUnauthenticatedSlackCommandAllowed, permissionForSlackAction, requiredPermissionForSlackCommand } from "./slack-command-surface.js";
 const EDIT_DEBOUNCE_MS = 1500;
 const TYPING_INTERVAL_MS = 4500;
@@ -70,24 +71,23 @@ export function createSlackBridge(config, registry) {
     const lockStore = new SessionLockStore(config.workspace, config.stateBackend);
     const userStore = new UserStore();
     const artifactService = new RelayArtifactService(config);
+    const authService = new RelayAuthService(config);
     const agentUpdates = new AgentUpdateManager();
     const commandService = new ChannelCommandService(config);
-    const busyStates = new Map();
+    const busyStates = createChannelBusyStore();
     const turnProgress = new Map();
     const draining = new Set();
     const picks = new Map();
     const externalMirrors = new Map();
-    const queueStatusMessages = new Map();
+    const queueStatusMessages = createChannelQueueStatusController({
+        send: async (_contextKey, context, text) => (await runtime.sendMessage(context, { text, fallbackText: text })).messageId,
+        edit: async (_contextKey, context, messageId, text) => {
+            await runtime.editMessage(context, messageId, { text, fallbackText: text });
+        },
+    });
     const remoteClient = new RemoteRelayClient();
     let externalMonitor;
-    const getBusyState = (contextKey) => {
-        let state = busyStates.get(contextKey);
-        if (!state) {
-            state = { processing: false, switching: false };
-            busyStates.set(contextKey, state);
-        }
-        return state;
-    };
+    const getBusyState = (contextKey) => busyStates.get(contextKey);
     const actorFor = (request) => ({
         channel: "slack",
         id: request.authUser?.user.id ?? `slack:${request.userId}`,
@@ -95,27 +95,19 @@ export function createSlackBridge(config, registry) {
         username: request.authUser?.user.email ?? request.username,
         channelUserId: request.userId,
     });
-    const appendActivity = (request, input) => {
-        activityStore.append({
-            source: "slack",
-            contextKey: request.contextKey,
-            actor: input.actor ?? actorFor(request),
-            workspace: input.workspace ?? config.workspace,
-            threadId: input.threadId ?? null,
-            ...input,
-        });
-    };
-    const audit = (request, input) => {
-        auditLog.append({
-            channelId: "slack",
-            contextKey: input.contextKey ?? request.contextKey,
-            actor: input.actor ?? actorFor(request),
-            actorId: request.authUser?.user.id ?? request.userId,
-            actorRole: request.authUser?.groups.map((group) => group.name).join(", ") ?? "unauthenticated",
-            ...input,
-        });
-    };
-    const hasPermission = (request, permission) => userStore.hasPermission(request.authUser, permission);
+    const appendActivity = createChannelActivityRecorder({
+        source: "slack",
+        workspace: config.workspace,
+        activityStore,
+        actorFor,
+    });
+    const audit = createChannelAuditRecorder({
+        channelId: "slack",
+        auditLog,
+        actorFor,
+        actorIdFor: (request) => request.userId,
+    });
+    const hasPermission = createChannelPermissionChecker(userStore);
     const reply = async (request, content, options = {}) => {
         if (options.ephemeral && request.respond) {
             await request.respond({
@@ -213,7 +205,7 @@ export function createSlackBridge(config, registry) {
     };
     const commandArtifacts = createSlackArtifactCommandHandler(artifactDeps);
     const getBusyReason = (contextKey) => {
-        const state = busyStates.get(contextKey);
+        const state = busyStates.peek(contextKey);
         const session = registry.get(contextKey);
         if (state?.processing || state?.switching || session?.isProcessing()) {
             return { busy: true, kind: "connector", state: state ?? getBusyState(contextKey) };
@@ -225,111 +217,7 @@ export function createSlackBridge(config, registry) {
         return { busy: false, kind: "idle" };
     };
     const updateQueueStatusMessage = async (contextKey, context, text) => {
-        const state = queueStatusMessages.get(contextKey) ?? {};
-        if (state.lastText === text && state.messageId) {
-            return;
-        }
-        if (!state.messageId) {
-            const sent = await runtime.sendMessage(context, { text, fallbackText: text });
-            state.messageId = sent.messageId;
-            state.lastText = text;
-            queueStatusMessages.set(contextKey, state);
-            return;
-        }
-        await runtime.editMessage(context, state.messageId, { text, fallbackText: text });
-        state.lastText = text;
-        queueStatusMessages.set(contextKey, state);
-    };
-    const sendExternalWorkingNotice = async (context, state, snapshot) => {
-        const turnKey = snapshot.activity.turnId ?? snapshot.activity.startedAt?.toISOString() ?? "unknown";
-        if (state.workingNoticeTurnKey === turnKey) {
-            return;
-        }
-        const prompt = trimLine(snapshot.latestUserMessage ?? "", 250);
-        const text = prompt ? `*Working on* ${prompt}` : `*Working on* external ${snapshot.agentLabel} task...`;
-        await runtime.sendMessage(context, {
-            text,
-            fallbackText: prompt ? `Working on ${prompt}` : `Working on external ${snapshot.agentLabel} task...`,
-        });
-        state.workingNoticeTurnKey = turnKey;
-    };
-    const mirrorExternalSnapshot = async (contextKey, context, session, snapshot) => {
-        let state = externalMirrors.get(contextKey);
-        if (!state || state.threadId !== snapshot.threadId || state.rolloutPath !== snapshot.sourcePath) {
-            state = {
-                threadId: snapshot.threadId,
-                rolloutPath: snapshot.sourcePath,
-                lastLine: snapshot.lineCount,
-                turnId: snapshot.activity.turnId,
-                startedAt: snapshot.activity.startedAt,
-            };
-            externalMirrors.set(contextKey, state);
-        }
-        const mirrorMode = preferencesStore.get(contextKey).mirrorMode ?? config.slackMirrorMode;
-        if (snapshot.activity.active) {
-            state.turnId = snapshot.activity.turnId;
-            state.startedAt = snapshot.activity.startedAt;
-            if (mirrorMode !== "off") {
-                const now = Date.now();
-                if (!state.lastTypingAt || now - state.lastTypingAt >= TYPING_INTERVAL_MS) {
-                    state.lastTypingAt = now;
-                    await runtime.sendTyping(context).catch(() => { });
-                }
-            }
-            if (mirrorMode === "final") {
-                await sendExternalWorkingNotice(context, state, snapshot);
-                state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
-                return;
-            }
-            if (mirrorMode === "off") {
-                state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
-                return;
-            }
-            const status = renderExternalMirrorStatus(snapshot, promptStore.list(contextKey).length);
-            const now = Date.now();
-            const canUpdateStatus = !state.latestStatusAt || now - state.latestStatusAt >= config.slackMirrorMinUpdateMs;
-            if (!state.statusMessageId) {
-                const sent = await runtime.sendMessage(context, { text: status.plain, fallbackText: status.plain });
-                state.statusMessageId = sent.messageId;
-                state.latestStatusAt = now;
-            }
-            else if (state.latestStatus !== status.plain && canUpdateStatus) {
-                await runtime.editMessage(context, state.statusMessageId, { text: status.plain, fallbackText: status.plain });
-                state.latestStatusAt = now;
-            }
-            state.latestStatus = status.plain;
-            if (mirrorMode === "full") {
-                const newEvents = snapshot.events
-                    .filter((event) => event.lineNumber > (state.latestMirroredEventLine ?? state.lastLine))
-                    .slice(-6);
-                for (const event of newEvents) {
-                    const rendered = renderExternalMirrorEvent(event);
-                    if (rendered) {
-                        await runtime.sendMessage(context, { text: rendered.plain, fallbackText: rendered.plain });
-                        state.latestMirroredEventLine = event.lineNumber;
-                    }
-                }
-            }
-            state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
-            return;
-        }
-        const terminalEvent = [...snapshot.events].reverse().find((event) => event.kind === "task" && event.status && event.status !== "started");
-        if (terminalEvent) {
-            const finalAgent = snapshot.events.filter((event) => event.kind === "agent" && event.text).at(-1);
-            if (mirrorMode !== "off" && mirrorMode !== "status" && finalAgent?.text && finalAgent.lineNumber !== state.latestAgentLine) {
-                await runtime.sendMessage(context, {
-                    text: `*${snapshot.agentLabel} CLI final answer:*`,
-                    fallbackText: `${snapshot.agentLabel} CLI final answer:`,
-                });
-                for (const chunk of splitSlackMessage(finalAgent.text)) {
-                    await runtime.sendMessage(context, { text: chunk, fallbackText: chunk });
-                }
-                state.latestAgentLine = finalAgent.lineNumber;
-            }
-            await deliverCliGeneratedArtifacts(contextKey, context, session, state.startedAt, terminalEvent.turnId);
-        }
-        state.workingNoticeTurnKey = undefined;
-        state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
+        await queueStatusMessages.update(contextKey, context, text);
     };
     const ensureActiveThread = async (request, session) => {
         if (!session.hasActiveThread()) {
@@ -337,63 +225,15 @@ export function createSlackBridge(config, registry) {
             updateSession(request, session);
         }
     };
-    const checkAgentAuthStatus = async (info) => {
-        if (info.agentId === "pi")
-            return checkPiAuthStatus(info.model);
-        if (info.agentId === "hermes")
-            return checkHermesAuthStatus({ baseUrl: config.hermesApiBaseUrl, apiKey: config.hermesApiKey });
-        if (info.agentId === "openclaw")
-            return checkOpenClawAuthStatus({ gatewayUrl: config.openClawGatewayUrl, token: config.openClawGatewayToken, password: config.openClawGatewayPassword });
-        if (info.agentId === "claude-code")
-            return checkClaudeCodeAuthStatus(config.claudeCodeCliPath);
-        return checkAuthStatus(config.codexApiKey);
-    };
-    const checkLoginAuthStatus = async (info) => {
-        if (info.agentId === "hermes")
-            return checkHermesAuthStatus({ baseUrl: config.hermesApiBaseUrl, apiKey: config.hermesApiKey });
-        if (info.agentId === "claude-code")
-            return checkClaudeCodeAuthStatus(config.claudeCodeCliPath);
-        return checkAuthStatus(config.codexApiKey);
-    };
-    const startAgentLogin = (info) => {
-        if (info.agentId === "hermes")
-            return startHermesLogin(config.hermesCliPath);
-        if (info.agentId === "claude-code")
-            return startClaudeCodeLogin(config.claudeCodeCliPath);
-        if (info.agentId === "codex")
-            return startCodexLogin();
-        return Promise.resolve({ success: false, message: `${info.agentLabel} login is not managed by NordRelay. Run the agent login flow on the host.` });
-    };
-    const startAgentLogout = (info) => {
-        if (info.agentId === "hermes")
-            return startHermesLogout(config.hermesCliPath);
-        if (info.agentId === "claude-code")
-            return startClaudeCodeLogout(config.claudeCodeCliPath);
-        if (info.agentId === "codex")
-            return startCodexLogout();
-        return Promise.resolve({ success: false, message: `${info.agentLabel} logout is not managed by NordRelay. Run the agent logout flow on the host.` });
-    };
+    const checkAgentAuthStatus = (info) => authService.check(info);
+    const checkLoginAuthStatus = (info) => authService.check(info);
+    const startAgentLogin = (info) => authService.startLogin(info);
+    const startAgentLogout = (info) => authService.startLogout(info);
     const hostLoginCommand = (info) => {
-        if (info.agentId === "hermes")
-            return `${config.hermesCliPath ?? "hermes"} login --no-browser`;
-        if (info.agentId === "claude-code")
-            return `${config.claudeCodeCliPath ?? "claude"} auth login`;
-        if (info.agentId === "pi")
-            return `${config.piCliPath ?? "pi"} auth login`;
-        if (info.agentId === "openclaw")
-            return `${config.openClawCliPath ?? "openclaw"} login`;
-        return "codex login --device-auth";
+        return hostAgentLoginCommand(config, info);
     };
     const hostLogoutCommand = (info) => {
-        if (info.agentId === "hermes")
-            return `${config.hermesCliPath ?? "hermes"} logout`;
-        if (info.agentId === "claude-code")
-            return `${config.claudeCodeCliPath ?? "claude"} auth logout`;
-        if (info.agentId === "pi")
-            return `${config.piCliPath ?? "pi"} auth logout`;
-        if (info.agentId === "openclaw")
-            return `${config.openClawCliPath ?? "openclaw"} logout`;
-        return "codex logout";
+        return hostAgentLogoutCommand(config, info);
     };
     const denyIfLocked = async (request) => {
         const lock = lockStore.get(request.contextKey);
@@ -545,45 +385,76 @@ export function createSlackBridge(config, registry) {
         }
     };
     const deliverCliGeneratedArtifacts = async (contextKey, context, session, startedAt, turnId) => {
-        if (!startedAt || !turnId)
-            return;
-        const state = externalMirrors.get(contextKey);
-        if (state?.artifactsDeliveredForTurnId === turnId)
-            return;
-        const workspace = session.getInfo().workspace;
-        const report = await collectRecentWorkspaceArtifacts(workspace, {
-            since: startedAt,
-            until: new Date(),
-            maxFileSize: config.maxFileSize,
-            limit: 5,
-            ignoreDirs: config.artifactIgnoreDirs,
-            ignoreGlobs: config.artifactIgnoreGlobs,
-        });
-        if (report.artifacts.length === 0 && report.skippedCount === 0 && !report.omittedCount) {
-            if (state)
-                state.artifactsDeliveredForTurnId = turnId;
-            return;
-        }
-        const persisted = await persistWorkspaceArtifactReport(workspace, turnId, report).catch((error) => {
-            console.error("Failed to persist Slack CLI artifact report:", error);
-            return null;
+        await deliverChannelCliArtifacts({
+            config,
+            contextKey,
+            session,
+            startedAt,
+            turnId,
+            state: externalMirrors.get(contextKey),
+            autoSend: config.slackAutoSendArtifacts,
+            sendSummaryWhenAutoSendDisabled: true,
+            logPrefix: "Slack",
+            sendSummary: (summary) => runtime.sendMessage(context, { text: summary, fallbackText: summary }).then(() => { }),
+            sendArtifact: (artifact) => runtime.sendFile(context, { localPath: artifact.localPath, name: artifact.name }).then(() => { }).catch((error) => {
+                console.error(`Failed to send Slack CLI artifact ${artifact.name}:`, error);
+            }),
+            appendActivity: (input) => {
+                activityStore.append(input);
+            },
         });
-        const summary = formatArtifactSummary(report.artifacts, report.skippedCount, report.omittedCount);
-        if (summary) {
-            await runtime.sendMessage(context, { text: summary, fallbackText: summary });
-        }
-        if (config.slackAutoSendArtifacts) {
-            for (const artifact of (persisted?.artifacts ?? report.artifacts).slice(0, 5)) {
-                await runtime.sendFile(context, { localPath: artifact.localPath, name: artifact.name }).catch((error) => {
-                    console.error(`Failed to send Slack CLI artifact ${artifact.name}:`, error);
-                });
-            }
-        }
-        const info = session.getInfo();
-        activityStore.append({ source: "cli", status: "info", type: config.slackAutoSendArtifacts ? "artifacts_sent" : "artifacts_detected", contextKey, threadId: info.threadId, workspace: info.workspace, agentId: info.agentId, actor: { channel: "cli", label: `${info.agentLabel} CLI` }, detail: summary });
-        if (state)
-            state.artifactsDeliveredForTurnId = turnId;
     };
+    const externalMirrorController = createChannelExternalMirrorController({
+        config,
+        states: externalMirrors,
+        typingIntervalMs: TYPING_INTERVAL_MS,
+        minUpdateMs: () => config.slackMirrorMinUpdateMs,
+        mirrorMode: (contextKey) => preferencesStore.get(contextKey).mirrorMode ?? config.slackMirrorMode,
+        queueLength: (contextKey) => promptStore.list(contextKey).length,
+        activityActor: (snapshot) => ({ channel: "cli", label: `${snapshot.agentLabel} CLI` }),
+        appendActivity: (input) => {
+            activityStore.append(input);
+        },
+        sendTyping: (_contextKey, context) => runtime.sendTyping(context).catch(() => { }),
+        sendWorkingNotice: async (_contextKey, context, state, snapshot, prompt) => {
+            const turnKey = snapshot.activity.turnId ?? snapshot.activity.startedAt?.toISOString() ?? "unknown";
+            if (state.workingNoticeTurnKey === turnKey) {
+                return;
+            }
+            const text = prompt ? `*Working on* ${prompt}` : `*Working on* external ${snapshot.agentLabel} task...`;
+            await runtime.sendMessage(context, {
+                text,
+                fallbackText: prompt ? `Working on ${prompt}` : `Working on external ${snapshot.agentLabel} task...`,
+            });
+            state.workingNoticeTurnKey = turnKey;
+        },
+        sendStatus: async (_contextKey, context, _state, rendered) => {
+            const sent = await runtime.sendMessage(context, { text: rendered.plain, fallbackText: rendered.plain });
+            return sent.messageId;
+        },
+        editStatus: (_contextKey, context, _state, messageId, rendered) => runtime.editMessage(context, messageId, { text: rendered.plain, fallbackText: rendered.plain }),
+        sendEvent: (_contextKey, context, _state, rendered) => runtime.sendMessage(context, { text: rendered.plain, fallbackText: rendered.plain }).then(() => { }),
+        sendDone: (_contextKey, context, state, text) => {
+            if (state.statusMessageId) {
+                return runtime.editMessage(context, state.statusMessageId, { text, fallbackText: text });
+            }
+            return runtime.sendMessage(context, { text, fallbackText: text }).then(() => { });
+        },
+        sendFinalAnswer: async (_contextKey, context, _state, snapshot, text) => {
+            await runtime.sendMessage(context, {
+                text: `*${snapshot.agentLabel} CLI final answer:*`,
+                fallbackText: `${snapshot.agentLabel} CLI final answer:`,
+            });
+            for (const chunk of splitSlackMessage(text)) {
+                await runtime.sendMessage(context, { text: chunk, fallbackText: chunk });
+            }
+        },
+        deliverArtifacts: (contextKey, context, session, state, turnId) => deliverCliGeneratedArtifacts(contextKey, context, session, state.startedAt, turnId),
+        fullEventFilter: () => true,
+        fullEventLimit: 6,
+        requirePreviousForTerminal: false,
+    });
+    const mirrorExternalSnapshot = externalMirrorController.mirror;
     const commandDispatcher = createSharedChannelCommandDispatcher({
         transport: "slack",
         bindings: [
@@ -1285,36 +1156,30 @@ export function createSlackBridge(config, registry) {
         return id;
     };
     const monitorExternalContexts = async () => {
-        const keys = new Set([...registry.listContexts().map((context) => context.contextKey), ...promptStore.listContextKeys()].filter(isSlackContextKey));
-        for (const contextKey of keys) {
-            const parsed = parseSlackContextKey(contextKey);
-            if (!parsed)
-                continue;
-            if (!canSendSystemMessagesToSlackContext(userStore, contextKey))
-                continue;
-            if (!isSlackTeamAllowed(parsed.teamId) || !isSlackChannelAllowedByEnv(parsed.channelId))
-                continue;
-            const session = await registry.getOrCreate(contextKey, { deferThreadStart: true }).catch(() => null);
-            if (!session)
-                continue;
-            const context = { channelId: "slack", chatId: parsed.channelId, topicId: parsed.threadTs };
-            const previous = externalMirrors.get(contextKey);
-            const snapshot = getExternalSnapshotForSession(session, config, { afterLine: previous?.lastLine ?? Number.MAX_SAFE_INTEGER }) ??
-                getExternalSnapshotForSession(session, config, { maxEvents: 1 });
-            if (snapshot && !session.isProcessing()) {
-                await mirrorExternalSnapshot(contextKey, context, session, snapshot);
-            }
-            if (snapshot?.activity.active) {
-                if (promptStore.list(contextKey).length > 0) {
-                    await updateQueueStatusMessage(contextKey, context, `Waiting for ${snapshot.agentLabel} CLI task... ${promptStore.list(contextKey).length} queued${promptStore.isPaused(contextKey) ? " (paused)" : ""}.`).catch(() => { });
-                }
-                continue;
-            }
-            if (promptStore.list(contextKey).length > 0 && !promptStore.isPaused(contextKey) && !session.isProcessing()) {
-                await updateQueueStatusMessage(contextKey, context, `CLI task finished, running queued prompt 1/${promptStore.list(contextKey).length}.`).catch(() => { });
+        await monitorChannelExternalContexts({
+            config,
+            registry,
+            promptStore,
+            isContextKey: isSlackContextKey,
+            canSendSystemMessages: (contextKey) => canSendSystemMessagesToSlackContext(userStore, contextKey),
+            isAllowed: (contextKey) => {
+                const parsed = parseSlackContextKey(contextKey);
+                return Boolean(parsed && isSlackTeamAllowed(parsed.teamId) && isSlackChannelAllowedByEnv(parsed.channelId));
+            },
+            contextForKey: (contextKey) => {
+                const parsed = parseSlackContextKey(contextKey);
+                return parsed ? { channelId: "slack", chatId: parsed.channelId, ...(parsed.threadTs ? { topicId: parsed.threadTs } : {}) } : null;
+            },
+            previousLastLine: (contextKey) => externalMirrors.get(contextKey)?.lastLine,
+            mirrorSnapshot: mirrorExternalSnapshot,
+            updateQueueStatus: updateQueueStatusMessage,
+            drainQueue: async (contextKey, context) => {
+                const parsed = parseSlackContextKey(contextKey);
+                if (!parsed)
+                    return;
                 await drainQueue({ contextKey, context, userId: "system", channelId: parsed.channelId, teamId: parsed.teamId, isDirectMessage: false, source: "system" });
-            }
-        }
+            },
+        });
     };
     app.event("message", async ({ event }) => {
         await handleMessage(event);

package/dist/{slack-channel-runtime.js → channels/slack/slack-channel-runtime.js}

@@ -1,6 +1,6 @@
 import { createReadStream } from "node:fs";
-import { SlackChannelAdapter, } from "./channel-adapter.js";
-import { redactText } from "./redaction.js";
+import { SlackChannelAdapter, } from "../shared/channel-adapter.js";
+import { redactText } from "../../core/redaction.js";
 import { slackRateLimiter } from "./slack-rate-limit.js";
 const SLACK_TEXT_LIMIT = 40000;
 const SLACK_SAFE_TEXT_LIMIT = 3500;

package/dist/{slack-command-surface.js → channels/slack/slack-command-surface.js}

@@ -1,5 +1,5 @@
-import { permissionForCommand } from "./access-control.js";
-import { normalizeChannelCommandName, parseChannelCommand } from "./channel-runtime.js";
+import { permissionForCommand } from "../../access/access-control.js";
+import { normalizeChannelCommandName, parseChannelCommand } from "../shared/channel-runtime.js";
 export function parseSlackMessageCommand(text) {
     return parseChannelCommand(text, { allowBotMention: false });
 }

package/dist/{slack-diagnostics.js → channels/slack/slack-diagnostics.js}

@@ -1,6 +1,6 @@
 import { WebClient } from "@slack/web-api";
-import { friendlyErrorText } from "./error-messages.js";
-import { UserStore } from "./user-management.js";
+import { friendlyErrorText } from "../../core/error-messages.js";
+import { UserStore } from "../../access/user-management.js";
 export async function collectSlackDiagnostics(input) {
     const { config } = input;
     const checks = [];

package/dist/{bot-ui.js → channels/telegram/bot-ui.js}

@@ -1,4 +1,4 @@
-import { escapeHTML } from "./format.js";
+import { escapeHTML } from "../../core/format.js";
 /**
  * Grouped command reference for /help.
  */