@supen-ai/cli 0.1.6

package/daemon/dist/index.js

@@ -0,0 +1,1582 @@
+import fs from 'fs';
+import path from 'path';
+import { CODEX_TRUSTED_DATA_HOSTS, ASSISTANT_NAME, SUPEN_HOME, POLL_INTERVAL, TRIGGER_PATTERN, DAEMON_HOSTNAME, SKILLS_CONFIG, MIND_ADMIN_USERS, configureSupenDaemon, initializeDataDirs, } from './core/config.js';
+import './channels/index.js';
+import { SkillHub } from './skills/hub.js';
+import { getChannelFactory, getRegisteredChannelNames, } from './channels/registry.js';
+import { ensureSession, getAllChats, getAllRegisteredProjects, getAllSessions, getMessagesSince, getNewMessages, getRouterState, getSessionForAgent, initStore, cleanupStaleSessions, cleanupStaleAutomationExecutions, touchAutomationRun, updateSessionStatus, setRegisteredProject, setRouterState, storeChatMetadata, storeMessage, storeSessionUiEvent, resolveFromChatJid, } from './core/store.js';
+import { logger } from './core/logger.js';
+import { readEnrollmentState, verifyEnrollmentToken, } from './core/enrollment.js';
+import { routeOutbound, routeOutboundFile, routeSetTyping, routeEditMessage, } from './router.js';
+import { completeAutomationRun, shouldSuppressAutomationReply, } from './automation-runner.js';
+import { startAutomationEventListener, stopAutomationEventListener, } from './automation-event-listener.js';
+import { AgentCortex } from './core/cortex.js';
+import { Gateway, setGatewayInstance, getGatewayInstance } from './core/gateway.js';
+import { createGatewayRoutingConfigSync } from './core/gateway-routing-config.js';
+import { broadcastToChat } from './http/stream.js';
+import { broadcastToThread } from './http/thread-stream.js';
+import { getEnabledChannelsFromConfig } from './core/env.js';
+import { acquireDaemonLock } from './core/daemon-lock.js';
+import { getMcpManager } from './mcp/index.js';
+import { executePortableBuiltinCommand } from './commands/builtin.js';
+import { listCommands, resolveCommandInput } from './commands/catalog.js';
+import { findLatestInterruptIndex, trimMessagesAfterInterrupt, } from './core/interrupts.js';
+import { isSupabaseConfigured, pullFromSupabase, scheduleSupabasePush, startPeriodicSupabasePush, } from './sync/supabase-sync.js';
+import { appendStreamChunk, createStreamState, } from './core/streaming.js';
+const DEFAULT_AUTOMATION_TASK_TIMEOUT_MS = 12 * 60 * 1000;
+function automationTaskTimeoutMs() {
+    const raw = process.env.SUPEN_AUTOMATION_TASK_TIMEOUT_MS;
+    if (!raw)
+        return DEFAULT_AUTOMATION_TASK_TIMEOUT_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return DEFAULT_AUTOMATION_TASK_TIMEOUT_MS;
+    return parsed;
+}
+import { appendThreadEvent } from './core/thread-event-log.js';
+import { parseProgressEvent, formatProgressText, progressKeyFromEvent } from './core/progress.js';
+import { buildAssistantOutputExcerpt, buildObservableToolDetail, buildProgressDetail, buildTaskContextExcerpt, canonicalAutomationLogFields, classifyObservableLogEvent, excerptText, } from './core/observable-logging.js';
+// Global state
+let registeredProjects = {};
+const sessions = {}; // folder -> sessionId
+const lastAgentTimestamp = {}; // chatJid -> iso
+const channels = [];
+const activeDaemons = new Map();
+export function captureCodexStreamPayload(input) {
+    let sequence;
+    try {
+        const event = appendThreadEvent({
+            threadId: input.threadId,
+            runtimeThreadId: input.runtimeThreadId || input.threadId,
+            source: 'codex-app-server',
+            eventType: typeof input.payload.type === 'string'
+                ? input.payload.type
+                : typeof input.payload.method === 'string'
+                    ? input.payload.method
+                    : 'codex-event',
+            rawPayload: input.payload,
+        });
+        sequence = event.sequence;
+    }
+    catch (error) {
+        logger.warn({
+            err: error,
+            agentId: input.agentId,
+            threadId: input.threadId,
+            runtimeThreadId: input.runtimeThreadId || input.threadId,
+        }, 'Failed to capture Codex stream payload');
+    }
+    broadcastToThread(input.threadId, input.payload, sequence === undefined ? {} : { id: sequence });
+}
+function appServerChunk(method, params = {}) {
+    return {
+        type: 'data-supen-event',
+        data: {
+            raw: {
+                method,
+                params,
+            },
+        },
+    };
+}
+function readTraceIdFromMetadata(metadata) {
+    const raw = typeof metadata?.trace_id === 'string' ? metadata.trace_id.trim() : '';
+    return raw || undefined;
+}
+function createDaemonTraceId() {
+    return `dtr_${Date.now()}_${Math.random().toString(16).slice(2, 10)}`;
+}
+function emitGatewayTrace(event) {
+    const traceId = event.trace_id?.trim();
+    if (!traceId)
+        return;
+    const gw = getGatewayInstance();
+    if (!gw || !gw.isConnected())
+        return;
+    gw.emitTraceEvent({
+        trace_id: traceId,
+        kind: event.kind,
+        message: event.message,
+        ...(event.level ? { level: event.level } : {}),
+        ...(event.channel ? { channel: event.channel } : {}),
+        ...(event.jid ? { jid: event.jid } : {}),
+        ...(event.agent_id ? { agent_id: event.agent_id } : {}),
+        ...(event.details ? { details: event.details } : {}),
+    });
+}
+function isAdminActor(actor) {
+    if (!actor)
+        return false;
+    return MIND_ADMIN_USERS.includes(actor);
+}
+/** Check if a registered JID still points to a live channel. */
+async function isChannelAlive(jid) {
+    for (const ch of channels) {
+        if (ch.ownsJid(jid) && ch.channelExists) {
+            return ch.channelExists(jid);
+        }
+    }
+    return false;
+}
+let messageLoopRunning = false;
+// Simple mutex per channel to prevent overlapping agent runs
+const activeAgentLocks = new Map();
+// Pending-run flags: if a second message arrives while the lock is held,
+// set the flag so the run drains immediately after the current one finishes.
+const pendingRuns = new Set();
+function requestSessionStop(agentId, sessionId, actor = 'unknown') {
+    const session = getSessionForAgent(agentId, sessionId);
+    const chatJid = session?.source_ref?.trim() || `web:${agentId}:${sessionId}`;
+    const daemon = activeDaemons.get(chatJid);
+    if (!daemon) {
+        return {
+            ok: false,
+            code: 'session_not_running',
+            message: `Task "${sessionId}" is not currently running.`,
+            chatJid,
+        };
+    }
+    logger.info({ agentId, sessionId, chatJid, actor }, 'Stop requested for active session');
+    daemon.interrupt();
+    return {
+        ok: true,
+        code: 'stop_requested',
+        message: `Stop requested for session "${sessionId}".`,
+        chatJid,
+    };
+}
+/**
+ * Schedule a processMessages run for a chatJid.
+ * - If no run is in progress, starts one immediately.
+ * - If one is already running, marks a pending flag so a drain run kicks off
+ *   as soon as the current one finishes — no message is silently dropped.
+ */
+function scheduleRun(chatJid) {
+    if (!activeAgentLocks.has(chatJid)) {
+        const agentPromise = runAndDrain(chatJid);
+        activeAgentLocks.set(chatJid, agentPromise);
+    }
+    else {
+        const sinceTimestamp = lastAgentTimestamp[chatJid] || '';
+        const pending = getMessagesSince(chatJid, sinceTimestamp, ASSISTANT_NAME);
+        if (pending.length === 0)
+            return;
+        const latestInterruptIndex = findLatestInterruptIndex(pending);
+        if (latestInterruptIndex >= 0) {
+            const interruptMsg = pending[latestInterruptIndex];
+            lastAgentTimestamp[chatJid] = interruptMsg.timestamp;
+            setRouterState(chatJid, interruptMsg.timestamp);
+            logger.info({
+                chatJid,
+                interruptTimestamp: interruptMsg.timestamp,
+                hasActiveDaemon: activeDaemons.has(chatJid),
+            }, 'Interrupt control message received while run is active');
+            activeDaemons.get(chatJid)?.interrupt();
+        }
+        const hasMessagesAfterInterrupt = latestInterruptIndex >= 0
+            ? latestInterruptIndex < pending.length - 1
+            : pending.length > 0;
+        if (hasMessagesAfterInterrupt) {
+            // Mark that we need another run after the current one finishes
+            pendingRuns.add(chatJid);
+        }
+    }
+}
+/** Run processMessages, then drain any pending message that arrived mid-run. */
+async function runAndDrain(chatJid) {
+    try {
+        await processMessages(chatJid);
+    }
+    finally {
+        activeAgentLocks.delete(chatJid);
+        if (pendingRuns.has(chatJid)) {
+            pendingRuns.delete(chatJid);
+            scheduleRun(chatJid);
+        }
+    }
+}
+export function resolveSessionChannel(chatJid, existingChannel) {
+    if (chatJid.startsWith('dc:'))
+        return 'discord';
+    if (chatJid.startsWith('web:'))
+        return 'http';
+    if (chatJid.startsWith('feishu:') || chatJid.startsWith('fs:'))
+        return 'feishu';
+    if (chatJid.startsWith('dingtalk:'))
+        return 'dingtalk';
+    if (chatJid.startsWith('gateway:')) {
+        return existingChannel && existingChannel !== 'unknown'
+            ? existingChannel
+            : 'gateway';
+    }
+    return existingChannel || chatJid.split(':')[0] || 'unknown';
+}
+export function resolveStoredSessionChannel(chatJid) {
+    const resolved = resolveFromChatJid(chatJid);
+    if (!resolved)
+        return undefined;
+    return getSessionForAgent(resolved.agentId, resolved.sessionId)?.channel;
+}
+export function resolveRoutingChannel(chatJid) {
+    return resolveSessionChannel(chatJid, resolveStoredSessionChannel(chatJid));
+}
+async function processMessages(chatJid) {
+    let group = registeredProjects[chatJid];
+    if (!group) {
+        logger.info({ chatJid }, 'Creating temporary context for unregistered chat');
+        group = {
+            name: 'unknown',
+            folder: 'unknown',
+            trigger: `@${ASSISTANT_NAME}`,
+            added_at: new Date().toISOString(),
+            requiresTrigger: true,
+            isMain: false,
+        };
+    }
+    // Resolve or create a session for this chat so directories exist.
+    // IMPORTANT: always resolve agentId + sessionId from the JID — never use
+    // chatJid itself as session_id, or the full JID gets stored and re-prefixed
+    // on every subsequent call, making the key grow indefinitely.
+    let agentId = group.agent_id || group.folder;
+    let sessionId;
+    const resolved = resolveFromChatJid(chatJid);
+    if (resolved) {
+        agentId = resolved.agentId;
+        sessionId = resolved.sessionId;
+    }
+    else {
+        // Fallback for unrecognised JID formats: split on ':' and use last segment
+        const parts = chatJid.split(':');
+        sessionId = parts.length >= 2 ? parts.slice(1).join(':') : chatJid;
+        if (agentId === 'unknown' && parts.length >= 2) {
+            agentId = parts[1];
+        }
+    }
+    const existingSession = getSessionForAgent(agentId, sessionId);
+    const channel = existingSession
+        ? resolveSessionChannel(chatJid, existingSession.channel)
+        : resolveRoutingChannel(chatJid);
+    const session = ensureSession({
+        agent_id: agentId,
+        session_id: sessionId,
+        channel,
+        agent_name: group.name,
+        source_ref: chatJid,
+    });
+    const sinceTimestamp = lastAgentTimestamp[chatJid] || '';
+    const messages = getMessagesSince(chatJid, sinceTimestamp, ASSISTANT_NAME);
+    logger.info({ chatJid, sinceTimestamp, retrievedCount: messages.length }, 'processMessages: retrieved messages');
+    if (messages.length === 0)
+        return true;
+    // Update last timestamp BEFORE handling control messages to avoid loops on failure
+    const newest = messages[messages.length - 1].timestamp;
+    lastAgentTimestamp[chatJid] = newest;
+    setRouterState(chatJid, newest);
+    // Transform messages to the format expected by daemon.run
+    let runnableMessages = trimMessagesAfterInterrupt(messages);
+    if (runnableMessages.length === 0) {
+        logger.info({ chatJid, messageCount: messages.length }, 'processMessages: consumed interrupt control message without dispatching to agent');
+        return true;
+    }
+    // Extract latest message for processing
+    const latestMsg = runnableMessages[runnableMessages.length - 1];
+    const latestText = latestMsg?.content?.trim() || '';
+    const routingChannel = resolveRoutingChannel(chatJid);
+    const activeTraceId = readTraceIdFromMetadata(latestMsg?.metadata);
+    const isAutomationEventMessage = latestMsg?.metadata?.origin === 'automation_event';
+    if (isAutomationEventMessage) {
+        runnableMessages = [latestMsg];
+    }
+    // Transform messages to the format expected by daemon.run
+    // is_from_me=true means the message is from the assistant (role: assistant)
+    // is_from_me=false means the message is from the user (role: user)
+    let aiMessages = runnableMessages.map((m) => ({
+        role: m.is_from_me ? 'assistant' : 'user',
+        content: m.content,
+        ...(Array.isArray(m.attachments) && m.attachments.length > 0 ? { attachments: m.attachments } : {}),
+    }));
+    logger.info({ chatJid, messageCount: messages.length }, 'processMessages: starting');
+    emitGatewayTrace({
+        trace_id: activeTraceId,
+        kind: 'daemon.run.starting',
+        message: 'Started processing queued message batch',
+        jid: chatJid,
+        agent_id: agentId,
+        details: {
+            message_count: runnableMessages.length,
+            latest_message_id: latestMsg?.id || null,
+        },
+    });
+    try {
+        // Show typing indicator while we process
+        routeSetTyping(channels, chatJid, true);
+        if (latestText.startsWith('/enroll')) {
+            const parts = latestText.split(/\s+/);
+            const sub = parts[1] || 'status';
+            if (sub === 'status') {
+                const e = readEnrollmentState(DAEMON_HOSTNAME || undefined);
+                await sendFn(chatJid, `🔐 Enrollment status\n- daemon: ${e.daemon_id}\n- fingerprint: ${e.daemon_fingerprint}\n- trust_state: ${e.trust_state}\n- token_expires_at: ${e.token_expires_at || 'none'}\n- failed_attempts: ${e.failed_attempts}${e.frozen_until ? `\n- frozen_until: ${e.frozen_until}` : ''}`);
+                return true;
+            }
+            if (sub === 'verify') {
+                const token = parts[2];
+                if (!token) {
+                    await sendFn(chatJid, 'Usage: /enroll verify <token>');
+                    return true;
+                }
+                const e = readEnrollmentState(DAEMON_HOSTNAME || undefined);
+                const result = verifyEnrollmentToken({
+                    token,
+                    daemonFingerprint: e.daemon_fingerprint,
+                    daemonId: DAEMON_HOSTNAME || undefined,
+                });
+                if (result.ok) {
+                    await sendFn(chatJid, `✅ Enrollment verified. trust_state=${result.state.trust_state}`);
+                }
+                else {
+                    await sendFn(chatJid, `❌ Enrollment verification failed: ${result.code} (state=${result.state.trust_state})`);
+                }
+                return true;
+            }
+        }
+        const resolvedSlashCommand = latestText.startsWith('/') && !isAutomationEventMessage
+            ? await resolveCommandInput(latestText, { channel: routingChannel, agentId })
+            : null;
+        if (resolvedSlashCommand?.kind === 'unsupported') {
+            await sendFn(chatJid, resolvedSlashCommand.reason);
+            return true;
+        }
+        if (resolvedSlashCommand?.kind === 'unknown') {
+            await sendFn(chatJid, `Unknown command: ${resolvedSlashCommand.rawInput}\nType /help for available commands.`);
+            return true;
+        }
+        if (resolvedSlashCommand?.kind === 'builtin') {
+            const portableBuiltinReply = await executePortableBuiltinCommand(resolvedSlashCommand.text, {
+                channel: routingChannel,
+                agentId,
+                sessionId,
+                actor: latestMsg?.sender || chatJid,
+                isAdmin: isAdminActor(latestMsg?.sender || chatJid),
+            });
+            if (portableBuiltinReply) {
+                await sendFn(chatJid, portableBuiltinReply);
+                return true;
+            }
+            await sendFn(chatJid, `${resolvedSlashCommand.command} is only supported in the CLI or web app.`);
+            return true;
+        }
+        const runtimePrompt = resolvedSlashCommand?.kind === 'chat'
+            ? resolvedSlashCommand.text
+            : latestMsg?.content || '';
+        if (resolvedSlashCommand?.kind === 'chat' && chatJid.startsWith('web:')) {
+            aiMessages = aiMessages.map((message, index) => index === aiMessages.length - 1
+                ? { ...message, content: runtimePrompt }
+                : message);
+        }
+        // Check if we have a valid workspace for this group
+        // (group is guaranteed to be set now because of our fallback logic at the top)
+        const workspace = session.task_workspace_folder || getFactoryPath(group);
+        const hasWorkspace = fs.existsSync(workspace);
+        logger.info({ chatJid, workspace, hasWorkspace }, 'processMessages: workspace check');
+        const automationMessage = [...runnableMessages]
+            .reverse()
+            .find((msg) => msg.automation_id ||
+            msg.schedule_id ||
+            msg.automation_run_id ||
+            msg.schedule_run_id) || null;
+        const isAutomationMessage = Boolean(automationMessage);
+        let completeAutomationIfNeeded = async () => Promise.resolve();
+        try {
+            let statusMessageId = null;
+            let lastProgressSentAt = 0;
+            let lastProgressKey = '';
+            let lastProgressEvent = null;
+            const runStartedAt = Date.now();
+            let lastRunningProgressLogAt = 0;
+            let lastAutomationProgressLogAt = 0;
+            let lastAutomationProgressKey = '';
+            let heartbeatInFlight = false;
+            let heartbeatTimer = null;
+            let automationFinalized = false;
+            const summarizeAutomationProgressTarget = (value) => {
+                return excerptText(value, 280);
+            };
+            const logAutomationProgress = (eventData) => {
+                if (!isAutomationMessage)
+                    return;
+                if (automationMessage?.automation_run_id) {
+                    touchAutomationRun(automationMessage.automation_run_id);
+                }
+                const progressInfo = parseProgressEvent(eventData);
+                const phase = typeof eventData.phase === 'string' ? eventData.phase : 'unknown';
+                const action = typeof eventData.action === 'string' ? eventData.action : 'unknown';
+                const target = summarizeAutomationProgressTarget(eventData.target);
+                const elapsedMs = typeof eventData.elapsed_ms === 'number' && Number.isFinite(eventData.elapsed_ms)
+                    ? eventData.elapsed_ms
+                    : Date.now() - runStartedAt;
+                const key = `${phase}|${action}|${target || ''}`;
+                const now = Date.now();
+                if (now - lastAutomationProgressLogAt < 2000 && key === lastAutomationProgressKey) {
+                    return;
+                }
+                lastAutomationProgressLogAt = now;
+                lastAutomationProgressKey = key;
+                logger.info({
+                    ...canonicalAutomationLogFields({
+                        chat_jid: chatJid,
+                        task_id: automationMessage?.task_id,
+                        automation_id: automationMessage?.automation_id,
+                        schedule_id: automationMessage?.schedule_id,
+                        automation_run_id: automationMessage?.automation_run_id,
+                        schedule_run_id: automationMessage?.schedule_run_id,
+                        agent_id: agentId,
+                    }),
+                    elapsed_ms: elapsedMs,
+                    phase,
+                    detail: buildProgressDetail({
+                        phase,
+                        action,
+                        target: progressInfo?.target ?? target,
+                    }),
+                    ...buildObservableToolDetail({
+                        tool: progressInfo?.tool,
+                        target: progressInfo?.target ?? target,
+                        args: progressInfo?.args,
+                    }),
+                    output_excerpt: action === 'speaking'
+                        ? buildAssistantOutputExcerpt(eventData.target)
+                        : undefined,
+                    status: eventData.status,
+                }, 'Automation progress');
+            };
+            const emitProgress = async (info) => {
+                if (chatJid.startsWith('web:')) {
+                    broadcastToChat(chatJid, {
+                        type: 'progress',
+                        category: info.category,
+                        skill: info.skill,
+                        tool: info.tool,
+                        args: info.args,
+                        target: info.target,
+                        elapsed_s: info.elapsed_s,
+                    });
+                }
+                // Non-web channels do not receive progressive UI string updates
+                // The framework strictly transmits structured data.
+            };
+            const emitProgressHeartbeat = async () => {
+                if (heartbeatInFlight)
+                    return;
+                heartbeatInFlight = true;
+                try {
+                    const elapsed = Date.now() - runStartedAt;
+                    const heartbeatNow = Date.now();
+                    if (isAutomationMessage &&
+                        heartbeatNow - lastRunningProgressLogAt >= 30_000) {
+                        if (automationMessage?.automation_run_id) {
+                            touchAutomationRun(automationMessage.automation_run_id);
+                        }
+                        lastRunningProgressLogAt = heartbeatNow;
+                        const heartbeatTarget = typeof lastProgressEvent?.target === 'string'
+                            ? lastProgressEvent.target
+                            : undefined;
+                        const heartbeatProgress = parseProgressEvent({
+                            phase: typeof lastProgressEvent?.phase === 'string'
+                                ? lastProgressEvent.phase
+                                : 'assistant',
+                            action: typeof lastProgressEvent?.action === 'string'
+                                ? lastProgressEvent?.action
+                                : 'thinking',
+                            target: heartbeatTarget,
+                            elapsed_ms: elapsed,
+                        });
+                        const heartbeatDetails = heartbeatProgress
+                            ? {
+                                phase: heartbeatProgress.category,
+                                skill: heartbeatProgress.skill,
+                                tool: heartbeatProgress.tool,
+                                target: heartbeatProgress.target,
+                                progress: formatProgressText(heartbeatProgress),
+                            }
+                            : undefined;
+                        if (heartbeatDetails) {
+                            logger.info({
+                                ...canonicalAutomationLogFields({
+                                    chat_jid: chatJid,
+                                    task_id: automationMessage?.task_id,
+                                    automation_id: automationMessage?.automation_id,
+                                    schedule_id: automationMessage?.schedule_id,
+                                    automation_run_id: automationMessage?.automation_run_id,
+                                    schedule_run_id: automationMessage?.schedule_run_id,
+                                    agent_id: agentId,
+                                }),
+                                elapsed_s: Math.floor(elapsed / 1000),
+                                phase: heartbeatDetails.phase,
+                                detail: heartbeatDetails.target ||
+                                    heartbeatDetails.progress,
+                                ...buildObservableToolDetail({
+                                    tool: heartbeatDetails.tool,
+                                    target: heartbeatDetails.target,
+                                }),
+                            }, 'Automation heartbeat');
+                        }
+                        else {
+                            logger.info({
+                                ...canonicalAutomationLogFields({
+                                    chat_jid: chatJid,
+                                    task_id: automationMessage?.task_id,
+                                    automation_id: automationMessage?.automation_id,
+                                    schedule_id: automationMessage?.schedule_id,
+                                    automation_run_id: automationMessage?.automation_run_id,
+                                    schedule_run_id: automationMessage?.schedule_run_id,
+                                    agent_id: agentId,
+                                }),
+                                elapsed_s: Math.floor(elapsed / 1000),
+                                detail: 'still running',
+                            }, 'Automation heartbeat');
+                        }
+                    }
+                    const heartbeatBase = lastProgressEvent
+                        ? {
+                            ...lastProgressEvent,
+                            elapsed_ms: elapsed,
+                        }
+                        : {
+                            phase: 'assistant',
+                            action: 'thinking',
+                            elapsed_ms: elapsed,
+                        };
+                    let heartbeatInfo = parseProgressEvent(heartbeatBase);
+                    if (!heartbeatInfo) {
+                        heartbeatInfo = parseProgressEvent({
+                            phase: 'assistant',
+                            action: 'thinking',
+                            elapsed_ms: elapsed,
+                        });
+                    }
+                    if (!heartbeatInfo)
+                        return;
+                    await emitProgress(heartbeatInfo);
+                }
+                catch (err) {
+                    logger.debug({ err, chatJid }, 'Progress heartbeat failed');
+                }
+                finally {
+                    heartbeatInFlight = false;
+                }
+            };
+            const taskId = latestMsg?.task_id || `run-${Date.now()}`;
+            const turnId = automationMessage?.automation_run_id ||
+                automationMessage?.schedule_run_id ||
+                latestMsg?.id ||
+                taskId;
+            const streamState = createStreamState(`${chatJid}:${turnId}`);
+            const shouldMirrorTaskThread = chatJid.startsWith('task:') && Boolean(taskId);
+            const mirrorTaskThreadChunk = (payload) => {
+                if (!shouldMirrorTaskThread)
+                    return;
+                captureCodexStreamPayload({
+                    agentId,
+                    threadId: taskId,
+                    runtimeThreadId: session.session_id,
+                    payload,
+                });
+            };
+            const gwChannelReplyClient = getGatewayInstance();
+            const useGatewayChannelReplyLifecycle = Boolean(gwChannelReplyClient) &&
+                chatJid.startsWith('gateway:') &&
+                !chatJid.startsWith('web:');
+            let channelReplyHandle = null;
+            let channelReplyPreviewText = '';
+            let channelReplyLastFlushAt = 0;
+            let channelReplyFlushInFlight = false;
+            const CHANNEL_REPLY_STREAM_FLUSH_MS = 800;
+            const persistOutboundLocally = (text) => {
+                const ts = new Date().toISOString();
+                lastAgentTimestamp[chatJid] = ts;
+                setRouterState(chatJid, ts);
+                if (!text.trim())
+                    return;
+                if (chatJid.startsWith('task:'))
+                    return;
+                storeMessage({
+                    id: streamState.streamId,
+                    chat_jid: chatJid,
+                    sender: ASSISTANT_NAME,
+                    sender_name: ASSISTANT_NAME,
+                    content: text,
+                    timestamp: ts,
+                    is_from_me: true,
+                    is_bot_message: true,
+                    ...(taskId ? { task_id: taskId } : {}),
+                    ...(activeTraceId ? { metadata: { trace_id: activeTraceId } } : {}),
+                });
+            };
+            const ensureChannelReplyHandle = async (initialContent) => {
+                if (!useGatewayChannelReplyLifecycle || !gwChannelReplyClient)
+                    return null;
+                if (channelReplyHandle)
+                    return channelReplyHandle;
+                try {
+                    channelReplyHandle = await gwChannelReplyClient.startChannelReplyForChat(chatJid, initialContent);
+                    emitGatewayTrace({
+                        trace_id: activeTraceId,
+                        kind: 'daemon.reply.lifecycle.started',
+                        message: 'Started gateway channel reply lifecycle',
+                        jid: chatJid,
+                        agent_id: agentId,
+                        details: { reply_handle: channelReplyHandle },
+                    });
+                    return channelReplyHandle;
+                }
+                catch (err) {
+                    logger.warn({ err, chatJid }, 'Failed to start gateway channel reply lifecycle; falling back to channel_reply');
+                    emitGatewayTrace({
+                        trace_id: activeTraceId,
+                        kind: 'daemon.reply.lifecycle.failed_to_start',
+                        message: 'Failed to start gateway channel reply lifecycle',
+                        level: 'warn',
+                        jid: chatJid,
+                        agent_id: agentId,
+                        details: {
+                            error: err?.message || String(err),
+                        },
+                    });
+                    return null;
+                }
+            };
+            const maybeFlushChannelReplyPreview = async () => {
+                if (!useGatewayChannelReplyLifecycle || !gwChannelReplyClient)
+                    return;
+                if (!channelReplyPreviewText.trim())
+                    return;
+                if (channelReplyFlushInFlight)
+                    return;
+                const now = Date.now();
+                if (now - channelReplyLastFlushAt < CHANNEL_REPLY_STREAM_FLUSH_MS)
+                    return;
+                const handle = await ensureChannelReplyHandle('Thinking...');
+                if (!handle)
+                    return;
+                channelReplyFlushInFlight = true;
+                try {
+                    await gwChannelReplyClient.updateChannelReply(handle, channelReplyPreviewText, activeTraceId);
+                    channelReplyLastFlushAt = Date.now();
+                }
+                catch (err) {
+                    logger.debug({ err, chatJid }, 'Failed to flush gateway channel reply preview chunk');
+                }
+                finally {
+                    channelReplyFlushInFlight = false;
+                }
+            };
+            completeAutomationIfNeeded = async (outcome, detail) => {
+                if (automationFinalized ||
+                    !automationMessage ||
+                    (!automationMessage?.automation_id && !automationMessage?.schedule_id) ||
+                    (!automationMessage?.automation_run_id && !automationMessage?.schedule_run_id)) {
+                    return;
+                }
+                automationFinalized = true;
+                try {
+                    await completeAutomationRun({
+                        sendMessage: (jid, notification) => sendFn(jid, notification),
+                        ensureNotificationSessionExists,
+                    }, automationMessage, chatJid, outcome, detail);
+                }
+                catch (completeError) {
+                    logger.warn({ completeError, automation_id: automationMessage?.automation_id, outcome }, 'Failed to finalize automation run in process fallback');
+                }
+            };
+            heartbeatTimer = setInterval(() => {
+                void emitProgressHeartbeat();
+            }, chatJid.startsWith('web:') ? 1000 : 15_000);
+            try {
+                if (useGatewayChannelReplyLifecycle) {
+                    await ensureChannelReplyHandle('Thinking...');
+                }
+                // Get MCP manager for this session
+                let mcpManager;
+                try {
+                    mcpManager = await getMcpManager();
+                }
+                catch (err) {
+                    logger.warn({ err }, 'Failed to get MCP manager, continuing without MCP');
+                }
+                const daemon = new AgentCortex(agentId, { ...session, task_id: taskId }.session_id, {
+                    mcpManager,
+                    onStateChange: async (state) => {
+                        const eventData = {
+                            phase: state.activity?.phase,
+                            action: state.activity?.action,
+                            target: state.activity?.target,
+                            elapsed_ms: state.activity?.elapsed_ms,
+                            status: state.status,
+                        };
+                        lastProgressEvent = { ...eventData };
+                        logAutomationProgress(eventData);
+                        if (shouldMirrorTaskThread) {
+                            const statusType = state.status === 'error'
+                                ? 'failed'
+                                : state.status === 'interrupted'
+                                    ? 'idle'
+                                    : state.status === 'idle'
+                                        ? 'idle'
+                                        : 'active';
+                            mirrorTaskThreadChunk(appServerChunk('thread/status/changed', {
+                                threadId: session.session_id,
+                                status: { type: statusType },
+                            }));
+                        }
+                        // Broadcast computer_state for all status transitions so
+                        // consumers get real-time status updates.
+                        if (chatJid.startsWith('web:')) {
+                            broadcastToChat(chatJid, {
+                                type: 'computer_state',
+                                chat_jid: chatJid,
+                                ...state,
+                            });
+                        }
+                        if (chatJid.startsWith('web:') &&
+                            (state.status === 'interrupted' || state.status === 'error')) {
+                            if (streamState.nextSeq > 1) {
+                                broadcastToChat(chatJid, {
+                                    type: 'stream_end',
+                                    stream_id: streamState.streamId,
+                                });
+                            }
+                            broadcastToChat(chatJid, { type: 'progress_end' });
+                        }
+                        // Forward streaming text deltas to SSE clients
+                        if (eventData.phase === 'stream_event' &&
+                            eventData.action === 'speaking' &&
+                            typeof eventData.target === 'string') {
+                            if (useGatewayChannelReplyLifecycle) {
+                                channelReplyPreviewText += eventData.target;
+                                await maybeFlushChannelReplyPreview();
+                            }
+                            const frame = appendStreamChunk(streamState, eventData.target);
+                            if (frame) {
+                                broadcastToChat(chatJid, {
+                                    type: 'stream_delta',
+                                    ...frame,
+                                });
+                                mirrorTaskThreadChunk({
+                                    type: 'text-delta',
+                                    id: streamState.streamId,
+                                    delta: frame.text,
+                                });
+                            }
+                        }
+                        const progressInfo = parseProgressEvent(eventData);
+                        if (!progressInfo)
+                            return;
+                        const now = Date.now();
+                        const targetKey = typeof eventData.target === 'string'
+                            ? eventData.target.slice(0, 120)
+                            : '';
+                        const progressKey = `${progressKeyFromEvent(eventData)}|${targetKey}`;
+                        const isWeb = chatJid.startsWith('web:');
+                        const throttleMs = isWeb ? 1000 : 10_000;
+                        const shouldSend = !lastProgressSentAt ||
+                            progressKey !== lastProgressKey ||
+                            now - lastProgressSentAt >= throttleMs;
+                        if (!shouldSend)
+                            return;
+                        lastProgressSentAt = now;
+                        lastProgressKey = progressKey;
+                        await emitProgress(progressInfo);
+                    },
+                    onFile: async (filePath, caption) => {
+                        try {
+                            await routeOutboundFile(channels, chatJid, filePath, caption);
+                        }
+                        catch (err) {
+                            logger.warn({ err, chatJid, filePath }, 'Failed to send file');
+                        }
+                    },
+                    onReply: async (text) => {
+                        // Stop heartbeat immediately — the run is complete and
+                        // we don't want stale progress events re-triggering the
+                        // "thinking" state on the frontend after stream_end.
+                        if (heartbeatTimer) {
+                            clearInterval(heartbeatTimer);
+                            heartbeatTimer = null;
+                        }
+                        if (shouldMirrorTaskThread) {
+                            const remainingText = text.startsWith(streamState.fullText)
+                                ? text.slice(streamState.fullText.length)
+                                : streamState.fullText.trim()
+                                    ? ''
+                                    : text;
+                            if (remainingText) {
+                                const frame = appendStreamChunk(streamState, remainingText);
+                                if (frame) {
+                                    mirrorTaskThreadChunk({
+                                        type: 'text-delta',
+                                        id: streamState.streamId,
+                                        delta: frame.text,
+                                    });
+                                }
+                            }
+                            mirrorTaskThreadChunk({
+                                type: 'text-end',
+                                id: streamState.streamId,
+                            });
+                            mirrorTaskThreadChunk(appServerChunk('turn/completed', {
+                                threadId: session.session_id,
+                                turnId,
+                                turn: { id: turnId, status: 'completed' },
+                            }));
+                            updateSessionStatus(agentId, sessionId, 'idle');
+                        }
+                        // Finalize streaming: emit stream_end so consumers
+                        // know the streaming phase is complete.
+                        if (chatJid.startsWith('web:') && streamState.nextSeq > 1) {
+                            broadcastToChat(chatJid, {
+                                type: 'stream_end',
+                                stream_id: streamState.streamId,
+                            });
+                        }
+                        // Clear progress indicators
+                        if (chatJid.startsWith('web:')) {
+                            broadcastToChat(chatJid, { type: 'progress_end' });
+                        }
+                        else if (statusMessageId) {
+                            try {
+                                await routeEditMessage(channels, chatJid, statusMessageId, 'Done, sending final reply...');
+                            }
+                            catch {
+                                // Safe to ignore; final answer will still be delivered.
+                            }
+                        }
+                        // Deliver the final message through the channel.
+                        // Pass stream_id as message_id so the frontend can correlate
+                        // the final message with the streaming placeholder.
+                        const suppressReply = shouldSuppressAutomationReply(latestMsg, 'succeeded', text);
+                        emitGatewayTrace({
+                            trace_id: activeTraceId,
+                            kind: 'daemon.reply.ready',
+                            message: suppressReply
+                                ? 'Agent produced reply but delivery is suppressed by automation policy'
+                                : 'Agent produced final reply',
+                            jid: chatJid,
+                            agent_id: agentId,
+                            details: {
+                                suppressed: suppressReply,
+                                reply_excerpt: text.slice(0, 200),
+                            },
+                        });
+                        if (suppressReply) {
+                            if (useGatewayChannelReplyLifecycle && gwChannelReplyClient) {
+                                const handle = await ensureChannelReplyHandle('Thinking...');
+                                if (handle) {
+                                    try {
+                                        await gwChannelReplyClient.finalizeChannelReply(handle, activeTraceId);
+                                        emitGatewayTrace({
+                                            trace_id: activeTraceId,
+                                            kind: 'daemon.reply.dispatched',
+                                            message: 'Reply lifecycle finalized without outbound channel message',
+                                            jid: chatJid,
+                                            agent_id: agentId,
+                                            details: {
+                                                suppressed: true,
+                                                reply_handle: handle,
+                                                mode: 'channel_reply_lifecycle',
+                                            },
+                                        });
+                                    }
+                                    catch (lifecycleErr) {
+                                        logger.warn({ lifecycleErr, chatJid }, 'Failed to finalize suppressed gateway channel reply lifecycle');
+                                    }
+                                }
+                            }
+                            await completeAutomationIfNeeded('succeeded', text);
+                            return;
+                        }
+                        if (!suppressReply) {
+                            if (useGatewayChannelReplyLifecycle && gwChannelReplyClient) {
+                                const handle = await ensureChannelReplyHandle('Thinking...');
+                                if (handle) {
+                                    try {
+                                        if (channelReplyPreviewText && channelReplyPreviewText !== text) {
+                                            channelReplyPreviewText = text;
+                                        }
+                                        await gwChannelReplyClient.updateChannelReply(handle, text, activeTraceId);
+                                        await gwChannelReplyClient.finalizeChannelReply(handle, activeTraceId);
+                                        persistOutboundLocally(text);
+                                        emitGatewayTrace({
+                                            trace_id: activeTraceId,
+                                            kind: 'daemon.reply.dispatched',
+                                            message: 'Reply dispatched via gateway channel reply lifecycle',
+                                            jid: chatJid,
+                                            agent_id: agentId,
+                                            details: {
+                                                message_id: streamState.streamId,
+                                                reply_handle: handle,
+                                                mode: 'channel_reply_lifecycle',
+                                            },
+                                        });
+                                        await completeAutomationIfNeeded('succeeded', text);
+                                        return;
+                                    }
+                                    catch (lifecycleErr) {
+                                        logger.warn({ lifecycleErr, chatJid }, 'Gateway channel reply lifecycle dispatch failed; falling back to channel_reply');
+                                    }
+                                }
+                            }
+                            await sendFn(chatJid, text, {
+                                message_id: streamState.streamId,
+                                trace_id: activeTraceId,
+                                task_id: taskId,
+                            });
+                            emitGatewayTrace({
+                                trace_id: activeTraceId,
+                                kind: 'daemon.reply.dispatched',
+                                message: 'Reply dispatched to outbound channel router',
+                                jid: chatJid,
+                                agent_id: agentId,
+                                details: {
+                                    message_id: streamState.streamId,
+                                },
+                            });
+                        }
+                        await completeAutomationIfNeeded('succeeded', text);
+                    },
+                    onError: async (text, error) => {
+                        if (heartbeatTimer) {
+                            clearInterval(heartbeatTimer);
+                            heartbeatTimer = null;
+                        }
+                        // Automation task threads mirror the underlying Codex/App Server stream.
+                        // A daemon watchdog timeout is run metadata, not a Codex chat event.
+                        // Keep it out of the mirrored thread so the chat history remains the
+                        // single source of truth from the actual runtime.
+                        const shouldMirrorSyntheticError = shouldMirrorTaskThread && !isAutomationMessage;
+                        if (shouldMirrorSyntheticError) {
+                            const errorText = text || error?.message || 'Task failed';
+                            if (!streamState.fullText.trim() && errorText) {
+                                const frame = appendStreamChunk(streamState, errorText);
+                                if (frame) {
+                                    mirrorTaskThreadChunk({
+                                        type: 'text-delta',
+                                        id: streamState.streamId,
+                                        delta: frame.text,
+                                    });
+                                }
+                            }
+                            mirrorTaskThreadChunk({
+                                type: 'text-end',
+                                id: streamState.streamId,
+                            });
+                            mirrorTaskThreadChunk(appServerChunk('turn/failed', {
+                                threadId: session.session_id,
+                                turnId,
+                                turn: { id: turnId, status: 'failed' },
+                                error: { message: error?.message || text },
+                            }));
+                            updateSessionStatus(agentId, sessionId, 'error');
+                        }
+                        if (!isAutomationMessage && chatJid.startsWith('web:') && streamState.nextSeq > 1) {
+                            broadcastToChat(chatJid, {
+                                type: 'stream_end',
+                                stream_id: streamState.streamId,
+                            });
+                        }
+                        if (!isAutomationMessage && chatJid.startsWith('web:')) {
+                            broadcastToChat(chatJid, { type: 'progress_end' });
+                        }
+                        emitGatewayTrace({
+                            trace_id: activeTraceId,
+                            kind: 'daemon.reply.error',
+                            message: 'Agent reported an error response',
+                            level: 'error',
+                            jid: chatJid,
+                            agent_id: agentId,
+                            details: {
+                                error: error?.message || text,
+                            },
+                        });
+                        if (!isAutomationMessage && useGatewayChannelReplyLifecycle && gwChannelReplyClient) {
+                            const handle = await ensureChannelReplyHandle('Thinking...');
+                            if (handle) {
+                                try {
+                                    await gwChannelReplyClient.failChannelReply(handle, text, activeTraceId);
+                                    persistOutboundLocally(text);
+                                    await completeAutomationIfNeeded('failed', error.message || text);
+                                    return;
+                                }
+                                catch (lifecycleErr) {
+                                    logger.warn({ lifecycleErr, chatJid }, 'Gateway channel reply lifecycle error-dispatch failed; falling back to channel_reply');
+                                }
+                            }
+                        }
+                        if (!isAutomationMessage) {
+                            await sendFn(chatJid, text, {
+                                message_id: streamState.streamId,
+                                trace_id: activeTraceId,
+                                task_id: taskId,
+                            });
+                        }
+                        await completeAutomationIfNeeded('failed', error.message || text);
+                    },
+                });
+                activeDaemons.set(chatJid, daemon);
+                try {
+                    if (shouldMirrorTaskThread) {
+                        updateSessionStatus(agentId, sessionId, 'running');
+                        mirrorTaskThreadChunk({
+                            type: 'start',
+                            messageId: streamState.streamId,
+                        });
+                        mirrorTaskThreadChunk(appServerChunk('turn/started', {
+                            threadId: session.session_id,
+                            turnId,
+                            turn: { id: turnId, status: 'running' },
+                        }));
+                    }
+                    // Use the latest message content as the prompt
+                    if (isAutomationMessage) {
+                        logger.info({
+                            ...canonicalAutomationLogFields({
+                                chat_jid: chatJid,
+                                task_id: taskId,
+                                automation_id: automationMessage?.automation_id,
+                                schedule_id: automationMessage?.schedule_id,
+                                automation_run_id: automationMessage?.automation_run_id,
+                                schedule_run_id: automationMessage?.schedule_run_id,
+                                agent_id: agentId,
+                            }),
+                            prompt_excerpt: excerptText(latestMsg?.content || '', 160),
+                            context_excerpt: buildTaskContextExcerpt(runnableMessages),
+                            event_style: classifyObservableLogEvent('automation.started_real_work').emphasis,
+                        }, 'Automation started');
+                    }
+                    emitGatewayTrace({
+                        trace_id: activeTraceId,
+                        kind: 'daemon.run.executing',
+                        message: 'Dispatching prompt to agent runtime',
+                        jid: chatJid,
+                        agent_id: agentId,
+                        details: {
+                            task_id: taskId,
+                            model: latestMsg?.model || null,
+                        },
+                    });
+                    const runtimeOptions = latestMsg?.metadata?.runtime_options &&
+                        typeof latestMsg.metadata.runtime_options === 'object'
+                        ? latestMsg.metadata.runtime_options
+                        : {};
+                    const permissionMode = runtimeOptions.permissionMode === 'default' ||
+                        runtimeOptions.permissionMode === 'read-only' ||
+                        runtimeOptions.permissionMode === 'workspace-write' ||
+                        runtimeOptions.permissionMode === 'full-access' ||
+                        runtimeOptions.permissionMode === 'custom'
+                        ? runtimeOptions.permissionMode
+                        : undefined;
+                    const effort = runtimeOptions.effort === 'low' ||
+                        runtimeOptions.effort === 'medium' ||
+                        runtimeOptions.effort === 'high' ||
+                        runtimeOptions.effort === 'xhigh'
+                        ? runtimeOptions.effort
+                        : undefined;
+                    const networkAccess = runtimeOptions.networkAccess === true;
+                    if (chatJid.startsWith('web:')) {
+                        const stream = await daemon.runNativeStream(taskId, aiMessages, {
+                            model: latestMsg?.model,
+                            effort,
+                            permissionMode,
+                            networkAccess,
+                            trustedDataHosts: CODEX_TRUSTED_DATA_HOSTS,
+                        });
+                        const reader = stream.getReader();
+                        const decoder = new TextDecoder();
+                        let pending = '';
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done)
+                                break;
+                            pending += decoder.decode(value, { stream: true });
+                            const lines = pending.split('\n');
+                            pending = lines.pop() || '';
+                            for (const rawLine of lines) {
+                                const line = rawLine.trim();
+                                if (!line.startsWith('data:'))
+                                    continue;
+                                const payload = line.slice(5).trim();
+                                if (!payload)
+                                    continue;
+                                try {
+                                    const parsedPayload = JSON.parse(payload);
+                                    captureCodexStreamPayload({
+                                        agentId,
+                                        threadId: sessionId,
+                                        runtimeThreadId: session.session_id,
+                                        payload: parsedPayload,
+                                    });
+                                    broadcastToChat(chatJid, parsedPayload);
+                                }
+                                catch {
+                                    // Ignore malformed chunks and keep stream processing alive.
+                                }
+                            }
+                        }
+                        const tail = pending.trim();
+                        if (tail.startsWith('data:')) {
+                            const payload = tail.slice(5).trim();
+                            if (payload) {
+                                try {
+                                    const parsedPayload = JSON.parse(payload);
+                                    captureCodexStreamPayload({
+                                        agentId,
+                                        threadId: sessionId,
+                                        runtimeThreadId: session.session_id,
+                                        payload: parsedPayload,
+                                    });
+                                    broadcastToChat(chatJid, parsedPayload);
+                                }
+                                catch {
+                                    // Ignore malformed final chunk.
+                                }
+                            }
+                        }
+                        // Mark stream dispatch completion after all chunks are broadcast to
+                        // active web clients. `/chat` waits on this marker before closing
+                        // the SSE response to avoid cutting off trailing streamed chunks.
+                        storeSessionUiEvent(agentId, sessionId, {
+                            id: `${taskId}:stream-dispatched:${Date.now()}`,
+                            timestamp: new Date().toISOString(),
+                            task_id: taskId,
+                            chunk: {
+                                type: 'stream-dispatched',
+                            },
+                        });
+                    }
+                    else {
+                        await daemon.run(taskId, runtimePrompt, {
+                            model: latestMsg?.model,
+                            effort,
+                            permissionMode,
+                            networkAccess,
+                            trustedDataHosts: CODEX_TRUSTED_DATA_HOSTS,
+                            timeoutMs: isAutomationMessage ? automationTaskTimeoutMs() : undefined,
+                            resume: isAutomationMessage ? false : undefined,
+                        });
+                    }
+                    emitGatewayTrace({
+                        trace_id: activeTraceId,
+                        kind: 'daemon.run.completed',
+                        message: 'Agent runtime completed successfully',
+                        jid: chatJid,
+                        agent_id: agentId,
+                        details: {
+                            task_id: taskId,
+                        },
+                    });
+                }
+                finally {
+                    if (activeDaemons.get(chatJid) === daemon) {
+                        activeDaemons.delete(chatJid);
+                    }
+                }
+            }
+            finally {
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = null;
+                }
+            }
+            return true;
+        }
+        catch (err) {
+            logger.error({
+                err,
+                chat_jid: chatJid,
+                automation_id: automationMessage?.automation_id,
+                schedule_id: automationMessage?.schedule_id,
+                automation_run_id: automationMessage?.automation_run_id,
+                schedule_run_id: automationMessage?.schedule_run_id,
+            }, 'Agent failed');
+            await completeAutomationIfNeeded('failed', err?.message || 'Agent failed');
+            emitGatewayTrace({
+                trace_id: activeTraceId,
+                kind: 'daemon.run.failed',
+                message: 'Agent runtime failed',
+                level: 'error',
+                jid: chatJid,
+                agent_id: agentId,
+                details: {
+                    error: err?.message || String(err),
+                },
+            });
+            await sendFn(chatJid, `❌ **Agent Error**\n\`\`\`\n${err.message}\n\`\`\``, { trace_id: activeTraceId, task_id: latestMsg?.task_id });
+            return false;
+        }
+    }
+    catch (err) {
+        logger.error({ err, chatJid }, 'processMessages: unexpected error');
+        return false;
+    }
+    finally {
+        routeSetTyping(channels, chatJid, false);
+    }
+}
+/** Resolve the workspace directory for a group. */
+function getFactoryPath(group) {
+    return path.join(SUPEN_HOME, 'factory', group.folder);
+}
+export function getAvailableProjects() {
+    const allChats = getAllChats();
+    return allChats.map((chat) => ({
+        jid: chat.jid,
+        name: chat.name || chat.jid,
+        lastActivity: chat.last_message_time,
+        isRegistered: !!registeredProjects[chat.jid],
+    }));
+}
+/** @internal - for tests only. */
+export function _setRegisteredProjects(groups) {
+    registeredProjects = groups;
+}
+function registerProject(jid, group) {
+    // Ensure a chats row exists for this JID before registering,
+    // so that subsequent message storage doesn't fail with FK constraint.
+    storeChatMetadata(jid, new Date().toISOString(), group.name);
+    setRegisteredProject(jid, group);
+    registeredProjects[jid] = group;
+    scheduleSupabasePush();
+    logger.info({ jid, folder: group.folder }, 'Group registered');
+}
+async function startMessageLoop() {
+    if (messageLoopRunning) {
+        logger.debug('Message loop already running, skipping duplicate start');
+        return;
+    }
+    messageLoopRunning = true;
+    logger.debug('Starting message loop');
+    // Track what the message loop has already SEEN (to avoid re-enqueuing).
+    // This is separate from lastAgentTimestamp which tracks what processMessages
+    // has actually PROCESSED.
+    const lastLoopTimestamp = {};
+    while (messageLoopRunning) {
+        try {
+            const jids = Object.keys(registeredProjects);
+            const lastGlobalTs = Object.values(lastLoopTimestamp).sort().reverse()[0] ||
+                Object.values(lastAgentTimestamp).sort().reverse()[0] ||
+                '';
+            const { messages } = getNewMessages(jids, lastGlobalTs, ASSISTANT_NAME);
+            for (const msg of messages) {
+                const chatJid = msg.chat_jid;
+                const group = registeredProjects[chatJid];
+                if (!group) {
+                    logger.debug({ chatJid }, 'Skipping message from unregistered group');
+                    continue;
+                }
+                // Track that the loop has seen this message (prevents re-enqueue)
+                if (!lastLoopTimestamp[chatJid] ||
+                    msg.timestamp > lastLoopTimestamp[chatJid]) {
+                    lastLoopTimestamp[chatJid] = msg.timestamp;
+                }
+                if (msg.is_from_me)
+                    continue;
+                const triggerMatch = TRIGGER_PATTERN.test(msg.content);
+                if (group.isMain || !group.requiresTrigger || triggerMatch) {
+                    logger.info({ chatJid, sender: msg.sender_name }, 'Trigger matched, checking locks');
+                    scheduleRun(chatJid);
+                }
+            }
+        }
+        catch (err) {
+            logger.error({ err }, 'Error in message loop');
+        }
+        await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+    }
+}
+function loadState() {
+    const groups = getAllRegisteredProjects();
+    for (const [jid, group] of Object.entries(groups)) {
+        registeredProjects[jid] = group;
+    }
+    logger.info({ count: Object.keys(registeredProjects).length }, 'Groups loaded');
+    const dbSessions = getAllSessions();
+    for (const sess of dbSessions) {
+        sessions[sess.agent_id] = sess.session_id;
+    }
+    logger.info({ count: Object.keys(sessions).length }, 'Sessions loaded');
+    for (const jid of Object.keys(registeredProjects)) {
+        const timestamp = getRouterState(jid);
+        if (timestamp) {
+            lastAgentTimestamp[jid] = timestamp;
+        }
+    }
+}
+function handleChatMetadata(chatJid, timestamp, name, channel, isGroup) {
+    storeChatMetadata(chatJid, timestamp, name, channel, isGroup);
+}
+function recoverPendingMessages() {
+    for (const [chatJid, group] of Object.entries(registeredProjects)) {
+        const sinceTimestamp = lastAgentTimestamp[chatJid] || '';
+        const pending = getMessagesSince(chatJid, sinceTimestamp, ASSISTANT_NAME);
+        if (pending.length > 0) {
+            logger.info({ group: group.name, pendingCount: pending.length }, 'Recovery: replaying unprocessed messages');
+            scheduleRun(chatJid);
+        }
+    }
+}
+let sendFn;
+let createChannelFn;
+function ensureNotificationSessionExists(targetJid, fallbackAgentId) {
+    const resolved = resolveFromChatJid(targetJid);
+    if (!resolved)
+        return;
+    ensureSession({
+        agent_id: resolved.agentId || fallbackAgentId || 'unknown',
+        session_id: resolved.sessionId,
+        channel: targetJid.startsWith('web:') ? 'http' : targetJid.split(':')[0] || 'unknown',
+        source_ref: targetJid,
+    });
+}
+async function main() {
+    await acquireDaemonLock({
+        interactive: process.env.SUPEN_DAEMON_LOCK_PROMPT === '1' ||
+            process.env.npm_lifecycle_event === 'dev',
+        terminateExisting: process.env.SUPEN_DAEMON_LOCK_TAKEOVER === '1' ||
+            process.env.npm_lifecycle_event === 'dev',
+    });
+    const productName = process.env.SUPEN_PRODUCT_NAME || 'Supen';
+    logger.info(`${productName} Daemon starting`);
+    initStore();
+    cleanupStaleSessions();
+    cleanupStaleAutomationExecutions();
+    logger.info('Database initialized');
+    // Ensure default agent and session exist
+    ensureSession({
+        agent_id: 'supen-agent',
+        session_id: 'supen-session',
+        channel: 'web',
+        agent_name: 'Supen Agent',
+        space_id: process.env.SUPEN_SPACE_ID || 'local',
+    });
+    logger.info('Default agent and session ensured');
+    if (isSupabaseConfigured()) {
+        await pullFromSupabase();
+        startPeriodicSupabasePush();
+    }
+    loadState();
+    const channelOpts = {
+        onMessage: (chatJid, msg) => {
+            const traceId = readTraceIdFromMetadata(msg.metadata) || createDaemonTraceId();
+            if (!msg.metadata || typeof msg.metadata !== 'object' || Array.isArray(msg.metadata)) {
+                msg.metadata = { trace_id: traceId };
+            }
+            else if (!readTraceIdFromMetadata(msg.metadata)) {
+                msg.metadata = { ...msg.metadata, trace_id: traceId };
+            }
+            emitGatewayTrace({
+                trace_id: traceId,
+                kind: 'daemon.message.received',
+                message: 'Daemon accepted inbound message from gateway',
+                channel: typeof msg.metadata?.channel === 'string' ? msg.metadata.channel : undefined,
+                jid: chatJid,
+                agent_id: msg.agent_id,
+                details: {
+                    sender: msg.sender,
+                    sender_name: msg.sender_name,
+                    content_excerpt: (msg.content || '').slice(0, 160),
+                },
+            });
+            storeMessage(msg);
+            // Event-driven: immediately process incoming messages instead of waiting for poll
+            if (!msg.is_from_me) {
+                scheduleRun(chatJid);
+                emitGatewayTrace({
+                    trace_id: traceId,
+                    kind: 'daemon.message.queued',
+                    message: 'Message queued for processing',
+                    jid: chatJid,
+                    agent_id: msg.agent_id,
+                });
+            }
+        },
+        onSessionStop: (agentId, sessionId, actor) => requestSessionStop(agentId, sessionId, actor),
+        onChatMetadata: (chatJid, timestamp, name, channel, isGroup) => handleChatMetadata(chatJid, timestamp, name, channel, isGroup),
+        registeredProjects: () => registeredProjects,
+        onGroupRegistered: (jid, group) => registerProject(jid, group),
+    };
+    // ── Gateway uplink (core infrastructure, N:1 — many nodes → one gateway) ──
+    const gateway = new Gateway({
+        onMessage: (chatJid, msg) => channelOpts.onMessage(chatJid, msg),
+        onChatMetadata: (chatJid, timestamp, name, channel, isGroup) => channelOpts.onChatMetadata(chatJid, timestamp, name, channel, isGroup),
+        onEnrollmentSuccess: async (daemonId) => {
+            // After enrollment, publish the daemon's gateway routing metadata.
+            try {
+                await gatewayRoutingConfig.sync({ force: true });
+                logger.info({ daemonId }, 'Gateway routing config sent');
+            }
+            catch (err) {
+                logger.error({ err }, 'Failed to send gateway routing config');
+            }
+        },
+    });
+    setGatewayInstance(gateway);
+    const gatewayRoutingConfig = createGatewayRoutingConfigSync({
+        gateway,
+        loadCommands: () => listCommands({ channel: 'gateway' }),
+        logger,
+    });
+    await gateway.connect();
+    setInterval(() => {
+        gatewayRoutingConfig.sync().catch((err) => {
+            logger.warn({ err }, 'Failed to refresh gateway routing config');
+        });
+    }, 5_000).unref?.();
+    // Add to channels so outbound routing (sendMessage/ownsJid) works
+    channels.push(gateway);
+    // ── Consumer channels ──
+    const CHANNEL_CONNECT_TIMEOUT = 15_000;
+    const enabledFromConfig = getEnabledChannelsFromConfig();
+    const registeredChannelNames = getRegisteredChannelNames();
+    const toConnect = enabledFromConfig.length > 0
+        ? registeredChannelNames.filter((n) => enabledFromConfig.includes(n))
+        : registeredChannelNames;
+    for (const name of toConnect) {
+        const factory = getChannelFactory(name);
+        if (factory) {
+            const channel = factory(channelOpts);
+            if (channel) {
+                try {
+                    logger.info({ channel: name }, 'Connecting channel');
+                    await Promise.race([
+                        channel.connect(),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error(`Channel ${name} connect timed out after ${CHANNEL_CONNECT_TIMEOUT / 1000}s`)), CHANNEL_CONNECT_TIMEOUT)),
+                    ]);
+                    channels.push(channel);
+                }
+                catch (err) {
+                    logger.error({ channel: name, err }, 'Failed to connect channel — skipping');
+                }
+            }
+        }
+    }
+    sendFn = async (jid, text, options) => {
+        const messageId = options?.message_id || `bot-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        if (!jid.startsWith('task:')) {
+            // Check if this is a gateway session - use gateway's routing which handles both
+            // regular gateway sessions and channel-based sessions (via sendReplyForChat)
+            const gw = getGatewayInstance();
+            if (jid.startsWith('gateway:') && gw) {
+                await gw.sendReplyForChat(jid, text, options?.message_id, options?.trace_id);
+            }
+            else {
+                await routeOutbound(channels, jid, text, {
+                    embeds: options?.embeds,
+                    message_id: messageId,
+                });
+            }
+        }
+        const ts = new Date().toISOString();
+        lastAgentTimestamp[jid] = ts;
+        setRouterState(jid, ts);
+        // Store bot response so conversation history includes assistant turns
+        if (text.trim() && !jid.startsWith('task:')) {
+            storeMessage({
+                id: messageId,
+                chat_jid: jid,
+                sender: ASSISTANT_NAME,
+                sender_name: ASSISTANT_NAME,
+                content: text,
+                timestamp: ts,
+                is_from_me: true,
+                is_bot_message: true,
+                ...(options?.task_id ? { task_id: options.task_id } : {}),
+                ...(options?.trace_id ? { metadata: { trace_id: options.trace_id } } : {}),
+            });
+        }
+    };
+    createChannelFn = async (fromJid, channelName) => {
+        for (const ch of channels) {
+            if (ch.ownsJid(fromJid) && ch.createChannel) {
+                return ch.createChannel(fromJid, channelName);
+            }
+        }
+        return null;
+    };
+    recoverPendingMessages();
+    // --- Auto-enable default skills ---
+    // SECURITY: We do NOT grant approveLevel3 here. Any skill listed in
+    // defaultEnabled that requires Level 3 will be skipped at startup with a
+    // warning. Level 3 skills require explicit operator approval via the CLI.
+    try {
+        const skillHub = new SkillHub(SKILLS_CONFIG);
+        const defaultSkills = SKILLS_CONFIG.defaultEnabled;
+        const ctx = { actor: 'system-init', isAdmin: true, approveLevel3: false };
+        for (const skillName of defaultSkills) {
+            try {
+                if (!skillHub.getInstalled(skillName)) {
+                    skillHub.installSkill(skillName, ctx);
+                }
+                const installed = skillHub.getInstalled(skillName);
+                if (!installed)
+                    continue;
+                // Issue #50: skip Level 3 skills — they must be explicitly approved
+                if (installed.permissionLevel === 3) {
+                    logger.warn({ skill: skillName }, 'Skipping auto-enable of Level 3 default skill — explicit approval required. Use `supen-node skills enable --approve` to enable it.');
+                    continue;
+                }
+                if (!installed.enabled) {
+                    skillHub.enableSkill(skillName, ctx);
+                    logger.info(`Auto-enabled default skill: ${skillName}`);
+                }
+            }
+            catch (err) {
+                logger.warn(`Failed to auto-enable skill ${skillName}: ${err.message}`);
+            }
+        }
+    }
+    catch (err) {
+        logger.warn(`Failed to initialize default skills: ${err.message}`);
+    }
+    startMessageLoop();
+    startAutomationEventListener({
+        enqueueMessage: channelOpts.onMessage,
+    });
+    const shutdown = async (signal) => {
+        logger.info({ signal }, 'Shutdown signal received');
+        // Wait for all active agents to finish (up to 10s)
+        const activePromises = Array.from(activeAgentLocks.values());
+        if (activePromises.length > 0) {
+            logger.info({ draining: activePromises.length }, 'Waiting for active agents to finish...');
+            await Promise.race([
+                Promise.allSettled(activePromises),
+                new Promise((r) => setTimeout(r, 10000)),
+            ]);
+        }
+        await stopAutomationEventListener();
+        await Promise.allSettled(channels.map((ch) => ch.disconnect()));
+        messageLoopRunning = false;
+        process.exit(0);
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    logger.info(`${productName} Daemon running (trigger: @${ASSISTANT_NAME})`);
+}
+export class SupenDaemon {
+    constructor(config = {}) {
+        if (config.productName) {
+            process.env.SUPEN_PRODUCT_NAME = config.productName;
+        }
+        configureSupenDaemon({ dataDir: config.dataDir });
+    }
+    async start() {
+        initializeDataDirs();
+        await main();
+    }
+}
+import url from 'node:url';
+if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
+    new SupenDaemon().start().catch((err) => {
+        console.error('Fatal daemon error:', err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=index.js.map