edsger 0.65.0 → 0.67.0

package/dist/api/chat.d.ts

@@ -1,6 +1,7 @@
 /**
  * MCP client wrappers for chat operations.
- * Used by the chat-worker subprocess to interact with chat channels and messages.
+ * Used by the `chat-serve` daemon and the agent workflow to interact with chat
+ * channels and messages.
  */
 import type { ChatChannel, ChatChannelType, ChatMessage, ChatMessageType, ChatMode } from '../types/index.js';
 export declare function getOrCreateChannel(channelType: ChatChannelType, channelRefId: string | null, chatMode?: ChatMode, name?: string, verbose?: boolean): Promise<{

package/dist/api/chat.js

@@ -1,6 +1,7 @@
 /**
  * MCP client wrappers for chat operations.
- * Used by the chat-worker subprocess to interact with chat channels and messages.
+ * Used by the `chat-serve` daemon and the agent workflow to interact with chat
+ * channels and messages.
  */
 import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
 import { logError, logInfo } from '../utils/logger.js';

package/dist/commands/agent-workflow/processor.d.ts

@@ -33,8 +33,6 @@ export declare class AgentWorkflowProcessor {
     private pollTimer?;
     /** Currently active worker processes, keyed by issueId */
     private activeWorkers;
-    /** Chat worker subprocess — runs in parallel, handles chat messages and phase events */
-    private chatWorker?;
     /** Realtime subscription on `issues` — wakes processNextIssues when an
      * issue flips to ready_for_ai, so the 30s poll can be relaxed. */
     private issuesRealtimeChannel;
@@ -48,9 +46,13 @@ export declare class AgentWorkflowProcessor {
      * already constrains delivery to products the user has access to.
      */
     private startIssuesRealtime;
-    private startChatWorker;
-    /** Send a message to the chat worker via IPC */
-    private notifyChatWorker;
+    /**
+     * Post a best-effort workflow status update into the issue's chat channel.
+     * Chat itself is served by the standalone `edsger chat-serve` daemon; the
+     * workflow only narrates lifecycle milestones here. Fire-and-forget — a chat
+     * failure must never affect issue processing.
+     */
+    private narrateToIssueChat;
     stop(): void;
     private processNextIssues;
     /**

package/dist/commands/agent-workflow/processor.js

@@ -10,6 +10,7 @@
 import { fork } from 'child_process';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
+import { sendIssueSystemMessage } from '../../api/chat.js';
 import { listAllReadyIssues, } from '../../api/cross-product.js';
 import { getGitHubConfig } from '../../api/github.js';
 import { claimNextIssue, getIssue } from '../../api/issues/index.js';
@@ -36,7 +37,6 @@ const __filename = fileURLToPath(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/naming-convention -- ESM __filename/__dirname polyfill
 const __dirname = dirname(__filename);
 const WORKER_SCRIPT = join(__dirname, 'issue-worker.js');
-const CHAT_WORKER_SCRIPT = join(__dirname, 'chat-worker.js');
 export class AgentWorkflowProcessor {
     options;
     config;
@@ -45,8 +45,6 @@ export class AgentWorkflowProcessor {
     pollTimer;
     /** Currently active worker processes, keyed by issueId */
     activeWorkers = new Map();
-    /** Chat worker subprocess — runs in parallel, handles chat messages and phase events */
-    chatWorker;
     /** Realtime subscription on `issues` — wakes processNextIssues when an
      * issue flips to ready_for_ai, so the 30s poll can be relaxed. */
     issuesRealtimeChannel = null;
@@ -68,8 +66,6 @@ export class AgentWorkflowProcessor {
         }
         this.isRunning = true;
         logInfo(`Concurrent processing: up to ${this.options.maxConcurrent} issue(s)`);
-        // Start chat worker subprocess
-        this.startChatWorker();
         // Initial issue check
         await this.processNextIssues();
         // Set up Realtime subscription on `issues` so a status flip to
@@ -142,77 +138,16 @@ export class AgentWorkflowProcessor {
             return false;
         }
     }
-    startChatWorker() {
-        try {
-            this.chatWorker = fork(CHAT_WORKER_SCRIPT, [], {
-                stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
-                env: { ...process.env },
-            });
-            // Forward chat worker logs to parent
-            this.chatWorker.stdout?.on('data', (data) => {
-                const lines = data.toString().trim().split('\n');
-                for (const line of lines) {
-                    if (line) {
-                        logInfo(`  [chat] ${line}`);
-                    }
-                }
-            });
-            this.chatWorker.stderr?.on('data', (data) => {
-                const lines = data.toString().trim().split('\n');
-                for (const line of lines) {
-                    if (line) {
-                        logError(`  [chat] ${line}`);
-                    }
-                }
-            });
-            this.chatWorker.on('message', (msg) => {
-                if (msg.type === 'log') {
-                    const prefix = '[chat]';
-                    switch (msg.level) {
-                        case 'info':
-                            logInfo(`  ${prefix} ${msg.message}`);
-                            break;
-                        case 'warning':
-                            logWarning(`  ${prefix} ${msg.message}`);
-                            break;
-                        case 'error':
-                            logError(`  ${prefix} ${msg.message}`);
-                            break;
-                        case 'success':
-                            logSuccess(`  ${prefix} ${msg.message}`);
-                            break;
-                        case undefined:
-                        default:
-                            break;
-                    }
-                }
-            });
-            this.chatWorker.on('exit', (code) => {
-                logWarning(`Chat worker exited with code ${code}`);
-                this.chatWorker = undefined;
-            });
-            // Initialize the chat worker with config
-            this.chatWorker.send({
-                type: 'init',
-                config: this.config,
-                verbose: this.options.verbose,
-            });
-            logInfo('Chat worker started');
-        }
-        catch (error) {
-            logError(`Failed to start chat worker: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /** Send a message to the chat worker via IPC */
-    notifyChatWorker(msg) {
-        if (this.chatWorker && this.chatWorker.connected) {
-            try {
-                this.chatWorker.send(msg);
-            }
-            catch {
-                // Chat worker may have died — non-critical
-            }
-        }
+    /**
+     * Post a best-effort workflow status update into the issue's chat channel.
+     * Chat itself is served by the standalone `edsger chat-serve` daemon; the
+     * workflow only narrates lifecycle milestones here. Fire-and-forget — a chat
+     * failure must never affect issue processing.
+     */
+    narrateToIssueChat(issueId, content, metadata) {
+        void sendIssueSystemMessage(issueId, content, metadata).catch((error) => {
+            logWarning(`Failed to post chat update for issue ${issueId}: ${error instanceof Error ? error.message : String(error)}`);
+        });
     }
     stop() {
         if (!this.isRunning) {
@@ -234,16 +169,6 @@ export class AgentWorkflowProcessor {
             }
             this.issuesRealtimeChannel = null;
         }
-        // Kill chat worker
-        if (this.chatWorker) {
-            try {
-                this.chatWorker.kill('SIGTERM');
-            }
-            catch {
-                // Ignore kill errors
-            }
-            this.chatWorker = undefined;
-        }
         // Kill all active issue workers gracefully
         for (const [issueId, worker] of this.activeWorkers) {
             logInfo(`Stopping worker for issue: ${issueId}`);
@@ -506,12 +431,6 @@ export class AgentWorkflowProcessor {
                 verbose: this.options.verbose,
                 config: this.config,
             });
-            // Notify chat worker that an issue has started processing
-            this.notifyChatWorker({
-                type: 'event:issue_started',
-                issueId,
-                repoPath,
-            });
         }
         catch (error) {
             this.activeWorkers.delete(issueId);
@@ -559,8 +478,10 @@ export class AgentWorkflowProcessor {
         if (success) {
             this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createCompletedState(issueId, currentState));
             logSuccess(`Issue completed: ${issueName}`);
-            // Notify chat worker that issue workflow is done
-            this.notifyChatWorker({ type: 'event:issue_done', issueId });
+            // Narrate completion into the issue chat (served by `edsger chat-serve`).
+            this.narrateToIssueChat(issueId, 'All workflow phases completed.', {
+                status: 'issue_done',
+            });
             // Clean up the per-issue clone now that the workflow is finished.
             // Failures intentionally leave the workspace so the user (or a retry)
             // can inspect the partial state.
@@ -578,15 +499,10 @@ export class AgentWorkflowProcessor {
             // without doing so leaves the issue at assigned_to_ai, which is a
             // separate, pre-existing orphan class outside the scope of the
             // pre-fork cleanup that releaseClaim handles.
-            // Only notify chat on first failure to avoid flooding with duplicate messages
+            // Only narrate on first failure to avoid flooding with duplicate messages.
             const failedState = this.processedIssues.get(issueId);
             if (failedState && failedState.retryCount <= 1) {
-                this.notifyChatWorker({
-                    type: 'event:phase_failed',
-                    issueId,
-                    phase: 'workflow',
-                    error: error || 'Unknown error',
-                });
+                this.narrateToIssueChat(issueId, `Phase "workflow" failed: ${error || 'Unknown error'}`, { phase: 'workflow', status: 'failed', error: error || 'Unknown error' });
             }
         }
         // Clear heartbeat issue info

package/dist/commands/chat-serve/chat-server.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Chat Server — the engine behind the standalone `edsger chat-serve` daemon.
+ *
+ * A single long-lived process that answers human messages on **issue** and
+ * **product group** chat channels (the chat surfaces in the issue- and
+ * product-detail pages). It is deliberately independent of the autonomous
+ * agent workflow: unlike the previous `chat-worker`, it is not forked by
+ * `AgentWorkflowProcessor` and needs no IPC from it — so chat keeps working
+ * whether or not the workflow is running.
+ *
+ * Two channel kinds are served here:
+ *   - `issue`   — `channel_type='issue'`
+ *   - `product` — `channel_type='product'` AND `chat_mode='group'`
+ *
+ * Session chats (`chat_mode='ai_assistant'`) are deliberately excluded — they
+ * are owned by the per-session `edsger session-serve` daemon. Letting both
+ * claim the same messages would produce duplicate replies.
+ *
+ * Message intake prefers Supabase Realtime (a `chat_messages` INSERT wakes the
+ * claim+process path immediately); when no Supabase session is available it
+ * falls back to MCP polling. Either way, messages are claimed atomically
+ * (`claimPendingMessages`) so multiple workers never process the same message.
+ *
+ * Issue chats can give the AI read access to the issue's cloned repo. The repo
+ * path is derived locally from the workspace root + issue id (the same pure
+ * mapping the workflow uses), so no IPC hand-off is required; when the clone
+ * isn't present the chat simply runs without code context.
+ *
+ * Side-effectful collaborators are injected via {@link ChatServerDeps} (with
+ * real implementations as the default) so the routing/repo logic is unit
+ * testable without a live Supabase or filesystem.
+ */
+import { claimPendingMessages, listChannels } from '../../api/chat.js';
+import { processHumanMessages, processProductHumanMessages } from '../../phases/chat-processor/index.js';
+import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
+import type { ChatChannel, EdsgerConfig } from '../../types/index.js';
+/** Channel kinds this server is responsible for. */
+export type ServedChannelKind = 'issue' | 'product';
+/**
+ * Classify a channel into the kind this server serves, or `null` to ignore it.
+ * Pure — the single source of truth for "should chat-serve touch this channel",
+ * shared by the initial refresh and the Realtime registration path.
+ *
+ * Note the precise product rule: only `chat_mode='group'` product channels are
+ * served. `ai_assistant` (session) channels belong to `edsger session-serve`;
+ * any other mode (e.g. `direct`) is not a product group chat and is ignored.
+ */
+export declare function classifyChannel(channel: Pick<ChatChannel, 'channel_type' | 'chat_mode'>): ServedChannelKind | null;
+/** Side-effectful collaborators, injectable for testing. */
+export interface ChatServerDeps {
+    listChannels: typeof listChannels;
+    claimPendingMessages: typeof claimPendingMessages;
+    processHumanMessages: typeof processHumanMessages;
+    processProductHumanMessages: typeof processProductHumanMessages;
+    issueRepoExists: (workspaceRoot: string, issueId: string) => boolean;
+    getIssueRepoPath: (workspaceRoot: string, issueId: string) => string;
+    hasSupabaseSession: typeof hasSupabaseSession;
+    getSupabase: typeof getSupabase;
+}
+export interface ChatServerOptions {
+    config: EdsgerConfig;
+    /** Workspace root used to locate issue repo clones for code context. */
+    workspaceRoot: string;
+    verbose?: boolean;
+}
+export declare class ChatServer {
+    private readonly deps;
+    private readonly config;
+    private readonly workspaceRoot;
+    private readonly verbose;
+    /** Unique id for atomic message claiming across competing workers. */
+    private readonly workerId;
+    /** issueId -> channelId */
+    private readonly issueChannels;
+    /** productId -> channelId */
+    private readonly productChannels;
+    /** channelId -> { kind, refId } */
+    private readonly metaByChannel;
+    /** In-flight message processing, awaited on shutdown so we drain cleanly. */
+    private readonly inflight;
+    private realtimeChannel;
+    private pollTimer;
+    private refreshTimer;
+    private running;
+    constructor(options: ChatServerOptions, deps?: ChatServerDeps);
+    /** Bring the server up: seed channels, drain backlog, start intake. */
+    start(): Promise<void>;
+    /**
+     * Stop accepting new work, tear down timers/subscriptions, then wait for any
+     * in-flight message processing to finish (bounded by DRAIN_TIMEOUT_MS) so a
+     * mid-flight reply isn't abandoned. Idempotent.
+     */
+    stop(): Promise<void>;
+    private refreshChannels;
+    /**
+     * Register a channel into the routing maps. Returns true if it was newly
+     * added. Ignores channels this server doesn't serve (e.g. session chats).
+     */
+    private registerChannel;
+    /** Fire-and-forget a claim+process while tracking it for graceful drain. */
+    private dispatch;
+    /** Claim and process pending human messages on a single known channel. */
+    private claimAndProcess;
+    /**
+     * Locate the issue's cloned repo so the chat AI can read code. Derived from
+     * the workspace root with the same pure mapping the workflow uses; returns
+     * undefined when the clone isn't present (chat then runs without code).
+     */
+    private resolveRepoPath;
+    private startRealtime;
+    private stopRealtime;
+    private startPolling;
+    private pollOnce;
+}

package/dist/commands/chat-serve/chat-server.js

@@ -0,0 +1,339 @@
+/**
+ * Chat Server — the engine behind the standalone `edsger chat-serve` daemon.
+ *
+ * A single long-lived process that answers human messages on **issue** and
+ * **product group** chat channels (the chat surfaces in the issue- and
+ * product-detail pages). It is deliberately independent of the autonomous
+ * agent workflow: unlike the previous `chat-worker`, it is not forked by
+ * `AgentWorkflowProcessor` and needs no IPC from it — so chat keeps working
+ * whether or not the workflow is running.
+ *
+ * Two channel kinds are served here:
+ *   - `issue`   — `channel_type='issue'`
+ *   - `product` — `channel_type='product'` AND `chat_mode='group'`
+ *
+ * Session chats (`chat_mode='ai_assistant'`) are deliberately excluded — they
+ * are owned by the per-session `edsger session-serve` daemon. Letting both
+ * claim the same messages would produce duplicate replies.
+ *
+ * Message intake prefers Supabase Realtime (a `chat_messages` INSERT wakes the
+ * claim+process path immediately); when no Supabase session is available it
+ * falls back to MCP polling. Either way, messages are claimed atomically
+ * (`claimPendingMessages`) so multiple workers never process the same message.
+ *
+ * Issue chats can give the AI read access to the issue's cloned repo. The repo
+ * path is derived locally from the workspace root + issue id (the same pure
+ * mapping the workflow uses), so no IPC hand-off is required; when the clone
+ * isn't present the chat simply runs without code context.
+ *
+ * Side-effectful collaborators are injected via {@link ChatServerDeps} (with
+ * real implementations as the default) so the routing/repo logic is unit
+ * testable without a live Supabase or filesystem.
+ */
+import { randomUUID } from 'node:crypto';
+import { claimPendingMessages, listChannels } from '../../api/chat.js';
+import { processHumanMessages, processProductHumanMessages, } from '../../phases/chat-processor/index.js';
+import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
+import { logError, logInfo, logWarning } from '../../utils/logger.js';
+import { getIssueRepoPath, issueRepoExists, } from '../../workspace/workspace-manager.js';
+/**
+ * Classify a channel into the kind this server serves, or `null` to ignore it.
+ * Pure — the single source of truth for "should chat-serve touch this channel",
+ * shared by the initial refresh and the Realtime registration path.
+ *
+ * Note the precise product rule: only `chat_mode='group'` product channels are
+ * served. `ai_assistant` (session) channels belong to `edsger session-serve`;
+ * any other mode (e.g. `direct`) is not a product group chat and is ignored.
+ */
+export function classifyChannel(channel) {
+    if (channel.channel_type === 'issue') {
+        return 'issue';
+    }
+    if (channel.channel_type === 'product' && channel.chat_mode === 'group') {
+        return 'product';
+    }
+    return null;
+}
+const POLL_INTERVAL_MS = 5_000;
+/** Periodic channel re-discovery (also a Realtime-mode safety net + keepalive). */
+const REFRESH_INTERVAL_MS = 60_000;
+/** Max time `stop()` waits for in-flight message processing before exiting. */
+const DRAIN_TIMEOUT_MS = 15_000;
+const defaultDeps = {
+    listChannels,
+    claimPendingMessages,
+    processHumanMessages,
+    processProductHumanMessages,
+    issueRepoExists,
+    getIssueRepoPath,
+    hasSupabaseSession,
+    getSupabase,
+};
+export class ChatServer {
+    deps;
+    config;
+    workspaceRoot;
+    verbose;
+    /** Unique id for atomic message claiming across competing workers. */
+    workerId = `chat-serve-${process.pid}-${randomUUID().slice(0, 8)}`;
+    /** issueId -> channelId */
+    issueChannels = new Map();
+    /** productId -> channelId */
+    productChannels = new Map();
+    /** channelId -> { kind, refId } */
+    metaByChannel = new Map();
+    /** In-flight message processing, awaited on shutdown so we drain cleanly. */
+    inflight = new Set();
+    realtimeChannel = null;
+    pollTimer = null;
+    refreshTimer = null;
+    running = false;
+    constructor(options, deps = defaultDeps) {
+        this.config = options.config;
+        this.workspaceRoot = options.workspaceRoot;
+        this.verbose = options.verbose ?? false;
+        this.deps = deps;
+    }
+    /** Bring the server up: seed channels, drain backlog, start intake. */
+    async start() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        logInfo(`Chat server starting (id: ${this.workerId})`);
+        // Seed the channel cache before subscriptions so Realtime events can be
+        // routed by channel id without an extra round-trip.
+        await this.refreshChannels();
+        // Drain anything that arrived while we were offline.
+        for (const channelId of this.metaByChannel.keys()) {
+            this.dispatch(channelId);
+        }
+        if (this.startRealtime()) {
+            logInfo('Chat server running in Realtime mode');
+            // Low-frequency refresh as a safety net for missed channel INSERTs and
+            // to keep the event loop alive even if the Realtime socket drops.
+            this.refreshTimer = setInterval(() => {
+                void this.refreshChannels();
+            }, REFRESH_INTERVAL_MS);
+            return;
+        }
+        logWarning('No Supabase session — chat server using MCP polling mode');
+        this.startPolling();
+    }
+    /**
+     * Stop accepting new work, tear down timers/subscriptions, then wait for any
+     * in-flight message processing to finish (bounded by DRAIN_TIMEOUT_MS) so a
+     * mid-flight reply isn't abandoned. Idempotent.
+     */
+    async stop() {
+        this.running = false;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        if (this.refreshTimer) {
+            clearInterval(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        this.stopRealtime();
+        if (this.inflight.size > 0) {
+            logInfo(`Draining ${this.inflight.size} in-flight message turn(s)…`);
+            await Promise.race([
+                Promise.allSettled([...this.inflight]),
+                delay(DRAIN_TIMEOUT_MS),
+            ]);
+        }
+        logInfo('Chat server stopped');
+    }
+    // ── Channel discovery ──────────────────────────────────────────────────
+    async refreshChannels() {
+        try {
+            const [issueChannels, productChannels] = await Promise.all([
+                this.deps.listChannels('issue'),
+                this.deps.listChannels('product'),
+            ]);
+            let added = 0;
+            for (const channel of [...issueChannels, ...productChannels]) {
+                if (this.registerChannel(channel)) {
+                    added++;
+                }
+            }
+            if (added > 0) {
+                logInfo(`Discovered ${added} new channel(s) (issues: ${this.issueChannels.size}, products: ${this.productChannels.size})`);
+            }
+        }
+        catch (error) {
+            logError(`Failed to refresh channels: ${describe(error)}`);
+        }
+    }
+    /**
+     * Register a channel into the routing maps. Returns true if it was newly
+     * added. Ignores channels this server doesn't serve (e.g. session chats).
+     */
+    registerChannel(channel) {
+        if (!channel.channel_ref_id) {
+            return false;
+        }
+        const kind = classifyChannel(channel);
+        if (!kind) {
+            return false; // session / general channel — not ours
+        }
+        const refMap = kind === 'issue' ? this.issueChannels : this.productChannels;
+        const isNew = !refMap.has(channel.channel_ref_id);
+        refMap.set(channel.channel_ref_id, channel.id);
+        this.metaByChannel.set(channel.id, { kind, refId: channel.channel_ref_id });
+        if (isNew) {
+            logInfo(`New ${kind} channel: ${channel.channel_ref_id} (${channel.id})`);
+        }
+        return isNew;
+    }
+    // ── Message processing ─────────────────────────────────────────────────
+    /** Fire-and-forget a claim+process while tracking it for graceful drain. */
+    dispatch(channelId) {
+        const task = this.claimAndProcess(channelId);
+        this.inflight.add(task);
+        void task.finally(() => this.inflight.delete(task));
+    }
+    /** Claim and process pending human messages on a single known channel. */
+    async claimAndProcess(channelId) {
+        if (!this.running) {
+            return;
+        }
+        const meta = this.metaByChannel.get(channelId);
+        if (!meta) {
+            // Unknown channel — the chat_channels subscription / next refresh will
+            // seed it, and the following message event will pick it up.
+            return;
+        }
+        try {
+            const claimed = await this.deps.claimPendingMessages(channelId, this.workerId);
+            if (claimed.length === 0) {
+                return;
+            }
+            logInfo(`Claimed ${claimed.length} message(s) for ${meta.kind} ${meta.refId}`);
+            if (meta.kind === 'issue') {
+                await this.deps.processHumanMessages(claimed, meta.refId, this.config, this.verbose, this.resolveRepoPath(meta.refId));
+            }
+            else {
+                await this.deps.processProductHumanMessages(claimed, meta.refId, this.config, this.verbose);
+            }
+        }
+        catch (error) {
+            logError(`Error processing channel ${channelId}: ${describe(error)}`);
+        }
+    }
+    /**
+     * Locate the issue's cloned repo so the chat AI can read code. Derived from
+     * the workspace root with the same pure mapping the workflow uses; returns
+     * undefined when the clone isn't present (chat then runs without code).
+     */
+    resolveRepoPath(issueId) {
+        if (this.deps.issueRepoExists(this.workspaceRoot, issueId)) {
+            return this.deps.getIssueRepoPath(this.workspaceRoot, issueId);
+        }
+        if (this.verbose) {
+            logInfo(`No local clone for issue ${issueId} — chat runs without code context`);
+        }
+        return undefined;
+    }
+    // ── Realtime intake ────────────────────────────────────────────────────
+    startRealtime() {
+        if (this.realtimeChannel) {
+            return true;
+        }
+        if (!this.deps.hasSupabaseSession()) {
+            return false;
+        }
+        try {
+            this.realtimeChannel = this.deps
+                .getSupabase()
+                .channel('chat-serve', { config: { broadcast: { ack: false } } })
+                .on('postgres_changes', {
+                event: 'INSERT',
+                schema: 'public',
+                table: 'chat_messages',
+                filter: 'sender_type=eq.human',
+            }, (payload) => {
+                const row = payload.new;
+                if (!row.channel_id || row.is_processed) {
+                    return;
+                }
+                this.dispatch(row.channel_id);
+            })
+                .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'chat_channels' }, (payload) => {
+                const channel = payload.new;
+                this.registerChannel(channel);
+                if (channel.id) {
+                    this.dispatch(channel.id);
+                }
+            })
+                .subscribe((status) => {
+                if (status === 'SUBSCRIBED') {
+                    logInfo('Realtime subscription active (chat_messages, chat_channels)');
+                }
+                else if (status === 'CHANNEL_ERROR' ||
+                    status === 'TIMED_OUT' ||
+                    status === 'CLOSED') {
+                    logWarning(`Realtime channel status: ${status}`);
+                    // supabase-js auto-reconnects; the refresh timer covers the gap.
+                }
+            });
+            return true;
+        }
+        catch (error) {
+            logError(`Failed to start Realtime subscription: ${describe(error)}`);
+            return false;
+        }
+    }
+    stopRealtime() {
+        if (!this.realtimeChannel) {
+            return;
+        }
+        try {
+            void this.deps.getSupabase().removeChannel(this.realtimeChannel);
+        }
+        catch {
+            // Best-effort; supabase may already be torn down.
+        }
+        this.realtimeChannel = null;
+    }
+    // ── Polling fallback (no Supabase session) ─────────────────────────────
+    startPolling() {
+        if (this.pollTimer) {
+            return;
+        }
+        void this.pollOnce();
+        this.pollTimer = setInterval(() => void this.pollOnce(), POLL_INTERVAL_MS);
+        // Periodically re-discover channels in the polling path too.
+        this.refreshTimer = setInterval(() => {
+            void this.refreshChannels();
+        }, REFRESH_INTERVAL_MS);
+    }
+    async pollOnce() {
+        if (!this.running) {
+            return;
+        }
+        for (const channelId of this.metaByChannel.keys()) {
+            const task = this.claimAndProcess(channelId);
+            this.inflight.add(task);
+            try {
+                await task;
+            }
+            finally {
+                this.inflight.delete(task);
+            }
+        }
+    }
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        // Don't keep the event loop alive solely for the drain timeout.
+        if (typeof timer.unref === 'function') {
+            timer.unref();
+        }
+    });
+}