edsger 0.66.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();
+        }
+    });
+}

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

@@ -0,0 +1,20 @@
+/**
+ * `edsger chat-serve` — long-lived daemon that answers human messages on issue
+ * and product group chat channels.
+ *
+ * This is the standalone replacement for the old `chat-worker` that
+ * `AgentWorkflowProcessor` used to fork. Running it as its own top-level
+ * process (spawned by the desktop app, sibling to `edsger --verbose` and
+ * `edsger session-serve`) decouples chat from the autonomous workflow: chat
+ * works whether or not the workflow is running, and the two never both claim
+ * the same messages.
+ *
+ * Like the agent workflow, it requires `edsger login` first and exits promptly
+ * if no auth is found. The actual chat-serving logic lives in {@link ChatServer}.
+ */
+export interface ChatServeCliOptions {
+    verbose?: boolean;
+    /** Optional path to an edsger config file (forwarded to validateConfiguration). */
+    config?: string;
+}
+export declare function runChatServeCommand(options?: ChatServeCliOptions): Promise<void>;

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

@@ -0,0 +1,58 @@
+/**
+ * `edsger chat-serve` — long-lived daemon that answers human messages on issue
+ * and product group chat channels.
+ *
+ * This is the standalone replacement for the old `chat-worker` that
+ * `AgentWorkflowProcessor` used to fork. Running it as its own top-level
+ * process (spawned by the desktop app, sibling to `edsger --verbose` and
+ * `edsger session-serve`) decouples chat from the autonomous workflow: chat
+ * works whether or not the workflow is running, and the two never both claim
+ * the same messages.
+ *
+ * Like the agent workflow, it requires `edsger login` first and exits promptly
+ * if no auth is found. The actual chat-serving logic lives in {@link ChatServer}.
+ */
+import { isLoggedIn } from '../../auth/auth-store.js';
+import { logError, logInfo } from '../../utils/logger.js';
+import { validateConfiguration } from '../../utils/validation.js';
+import { ensureWorkspaceDir } from '../../workspace/workspace-manager.js';
+import { ChatServer } from './chat-server.js';
+export async function runChatServeCommand(options = {}) {
+    // Mirror the agent workflow: auth is required, and we exit fast when absent
+    // so the desktop supervisor can surface a "run `edsger login`" hint.
+    if (!isLoggedIn()) {
+        logError('Not authenticated. Please run `edsger login` first.');
+        process.exit(1);
+    }
+    const cliOptions = {
+        verbose: options.verbose,
+        config: options.config,
+    };
+    const config = validateConfiguration(cliOptions);
+    const workspaceRoot = ensureWorkspaceDir();
+    logInfo(`Workspace: ${workspaceRoot}`);
+    const server = new ChatServer({
+        config,
+        workspaceRoot,
+        verbose: options.verbose,
+    });
+    await server.start();
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        logInfo(`Received ${signal} — shutting down chat server.`);
+        await server.stop();
+        process.exit(0);
+    };
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+    process.on('uncaughtException', (error) => {
+        logError(`Uncaught exception: ${error instanceof Error ? error.message : String(error)}`);
+        void server.stop().finally(() => process.exit(1));
+    });
+    // The Realtime socket / poll timer keep the event loop alive; nothing else
+    // to do on the main path. The process lives until a signal arrives.
+}

package/dist/index.js

@@ -10,6 +10,7 @@ import { runAgentWorkflow } from './commands/agent-workflow/index.js';
 import { runAnalyzeLogs } from './commands/analyze-logs/index.js';
 import { runAppStoreGeneration } from './commands/app-store/index.js';
 import { runBuild } from './commands/build/index.js';
+import { runChatServeCommand } from './commands/chat-serve/index.js';
 import { runChecklists } from './commands/checklists/index.js';
 import { runCodeReview } from './commands/code-review/index.js';
 import { runConfigGet, runConfigList, runConfigSet, runConfigUnset, } from './commands/config/index.js';
@@ -495,6 +496,22 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger chat-serve
+// ============================================================
+program
+    .command('chat-serve')
+    .description('Run a long-lived daemon that answers human messages on issue and product group chat channels')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (opts) => {
+    try {
+        await runChatServeCommand({ verbose: opts.verbose });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
 // Subcommand: edsger user-stories-analysis <issueId>
 // ============================================================
 program

package/dist/phases/sync-org-repos/index.d.ts

@@ -1,13 +1,16 @@
 /**
  * Phase: sync-org-repos
  *
- * Fetches all repositories from a GitHub organization using the local `gh` CLI,
- * then upserts a row into the team-scoped `repositories` table for each repo.
- * Products are NOT created here — a product is a higher-level grouping that a
- * user links one or more repositories to afterwards.
+ * Fetches all repositories from a GitHub organization via the Edsger GitHub
+ * App (server-side, through the MCP `github/org_repos` endpoint), then upserts
+ * a row into the team-scoped `repositories` table for each repo. Products are
+ * NOT created here — a product is a higher-level grouping that a user links one
+ * or more repositories to afterwards.
  *
- * Uses `gh api --paginate` for truly unlimited pagination (no hardcoded cap).
- * Forks and archived repos are filtered out client-side.
+ * Repos are listed with a short-lived GitHub App installation token minted on
+ * the server, so this no longer depends on the user's machine having the `gh`
+ * CLI installed, authenticated, and on PATH. Forks and archived repos are
+ * filtered out server-side.
  */
 export interface SyncOrgReposResult {
     status: 'success' | 'error';

package/dist/phases/sync-org-repos/index.js

@@ -1,44 +1,32 @@
 /**
  * Phase: sync-org-repos
  *
- * Fetches all repositories from a GitHub organization using the local `gh` CLI,
- * then upserts a row into the team-scoped `repositories` table for each repo.
- * Products are NOT created here — a product is a higher-level grouping that a
- * user links one or more repositories to afterwards.
+ * Fetches all repositories from a GitHub organization via the Edsger GitHub
+ * App (server-side, through the MCP `github/org_repos` endpoint), then upserts
+ * a row into the team-scoped `repositories` table for each repo. Products are
+ * NOT created here — a product is a higher-level grouping that a user links one
+ * or more repositories to afterwards.
  *
- * Uses `gh api --paginate` for truly unlimited pagination (no hardcoded cap).
- * Forks and archived repos are filtered out client-side.
+ * Repos are listed with a short-lived GitHub App installation token minted on
+ * the server, so this no longer depends on the user's machine having the `gh`
+ * CLI installed, authenticated, and on PATH. Forks and archived repos are
+ * filtered out server-side.
  */
-import { execFile } from 'child_process';
-import { promisify } from 'util';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
 import { logDebug, logError, logInfo, logWarning } from '../../utils/logger.js';
-const execFileAsync = promisify(execFile);
 const ORG_NAME_RE = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/;
-async function fetchOrgRepos(orgLogin, verbose) {
-    logInfo(`Fetching repos for org "${orgLogin}" via gh CLI...`);
-    const { stdout } = await execFileAsync('gh', [
-        'api',
-        `--paginate`,
-        `/orgs/${encodeURIComponent(orgLogin)}/repos?per_page=100&type=sources&sort=updated`,
-        '--jq',
-        '.[] | select(.archived == false) | {id, name, full_name, description, html_url, default_branch, private, language}',
-    ], { timeout: 120_000 });
-    if (!stdout.trim()) {
-        return [];
-    }
-    const repos = [];
-    for (const line of stdout.trim().split('\n')) {
-        if (!line) {
-            continue;
-        }
-        try {
-            repos.push(JSON.parse(line));
-        }
-        catch {
-            // skip malformed lines
-        }
+async function fetchOrgRepos(teamId, orgLogin, verbose) {
+    logInfo(`Fetching repos for org "${orgLogin}" via Edsger GitHub App...`);
+    const result = (await callMcpEndpoint('github/org_repos', {
+        team_id: teamId,
+        org: orgLogin,
+    }));
+    if (!result.configured) {
+        throw new Error(result.message ||
+            `The Edsger GitHub App is not configured for "${orgLogin}".`);
     }
+    const repos = result.repos ?? [];
     if (verbose) {
         logDebug(`Fetched ${repos.length} source repos from ${orgLogin}`);
     }
@@ -67,14 +55,14 @@ export async function syncOrgRepos(opts) {
     const supabase = getSupabase();
     let orgRepos;
     try {
-        orgRepos = await fetchOrgRepos(orgLogin, verbose);
+        orgRepos = await fetchOrgRepos(teamId, orgLogin, verbose);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         logError(`Failed to fetch repos: ${msg}`);
         return {
             status: 'error',
-            message: `Failed to fetch repos from GitHub CLI: ${msg}`,
+            message: `Failed to fetch repos from GitHub: ${msg}`,
             total: 0,
             created: 0,
             skipped: 0,

package/dist/types/index.d.ts

@@ -204,34 +204,3 @@ export interface ChatReadStatus {
     last_read_message_id: string | null;
     last_read_at: string;
 }
-export interface ChatWorkerInitMessage {
-    type: 'init';
-    config: EdsgerConfig;
-    verbose?: boolean;
-}
-export interface ChatWorkerPhaseEvent {
-    type: 'event:phase_completed' | 'event:phase_failed' | 'event:issue_done' | 'event:issue_started';
-    issueId: string;
-    phase?: string;
-    summary?: string;
-    phaseOutput?: unknown;
-    error?: string;
-    repoPath?: string;
-}
-export interface ChatWorkerCommand {
-    type: 'command:pause_issue' | 'command:resume_issue';
-    issueId: string;
-}
-export interface ChatWorkerQuery {
-    type: 'query:active_issues';
-}
-export interface ChatWorkerReply {
-    type: 'reply:active_issues';
-    issues: {
-        id: string;
-        name: string;
-        phase: string;
-    }[];
-}
-export type ChatWorkerParentMessage = ChatWorkerInitMessage | ChatWorkerPhaseEvent;
-export type ChatWorkerChildMessage = ChatWorkerCommand | ChatWorkerQuery;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.66.0",
+  "version": "0.67.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"
@@ -51,7 +51,7 @@
     "cosmiconfig": "^9.0.0",
     "dotenv": "^16.4.5",
     "edsger-contract": "0.7.0",
-    "edsger-tools": "0.8.0",
+    "edsger-tools": "0.9.0",
     "gray-matter": "^4.0.3",
     "zod": "^4.0.0"
   },