edsger 0.56.2 → 0.57.0

package/dist/api/user-psychology.js

@@ -0,0 +1,143 @@
+import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
+import { logError, logInfo } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+/**
+ * Update an existing psychology analysis row with the AI-produced result.
+ * The CLI always reserves the row via the desktop UI first (status='pending')
+ * and then fills it in here — so this path expects a real analysisId.
+ */
+export async function updateUserPsychologyAnalysis(analysisId, updates, verbose) {
+    if (!hasSupabaseSession()) {
+        logError('Cannot save psychology analysis: no Supabase session. Sign in to the desktop app.');
+        return null;
+    }
+    if (verbose) {
+        logInfo(`Updating user psychology analysis: ${analysisId}`);
+    }
+    try {
+        const { data, error } = await getSupabase()
+            .from('user_psychology_analyses')
+            .update(updates)
+            .eq('id', analysisId)
+            .select()
+            .single();
+        if (error) {
+            throw new Error(error.message);
+        }
+        return data;
+    }
+    catch (error) {
+        logError(`Failed to update user psychology analysis: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Fetch the most recent completed psychology profile for a product.
+ * Used by the growth-analysis phase to ground content in real personas.
+ * Tries direct Supabase first; falls back to the MCP endpoint when the
+ * CLI is running without a synced session.
+ */
+export async function getLatestUserPsychologyAnalysis(productId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching latest psychology profile for product: ${productId}`);
+    }
+    if (hasSupabaseSession()) {
+        try {
+            const { data, error } = await getSupabase()
+                .from('user_psychology_analyses')
+                .select('*')
+                .eq('product_id', productId)
+                .eq('status', 'completed')
+                .order('created_at', { ascending: false })
+                .limit(1)
+                .maybeSingle();
+            if (error) {
+                throw new Error(error.message);
+            }
+            return data ?? null;
+        }
+        catch (error) {
+            if (verbose) {
+                logError(`Direct Supabase fetch failed, falling back to MCP: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    try {
+        const result = (await callMcpEndpoint('user_psychology/latest', {
+            product_id: productId,
+        }));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            const parsed = JSON.parse(text);
+            return parsed ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch latest psychology via MCP: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return null;
+    }
+}
+export function classifyPsychologyFailure(reason) {
+    const r = reason.toLowerCase();
+    if (r.includes('parse') || r.includes('json')) {
+        return 'parse';
+    }
+    if (r.includes('no analysis results') || r.includes('no result')) {
+        return 'no_result';
+    }
+    if (r.includes('quota') ||
+        r.includes('rate limit') ||
+        r.includes('insufficient_quota')) {
+        return 'ai_quota';
+    }
+    if (r.includes('unauthorized') ||
+        r.includes('401') ||
+        r.includes('api key')) {
+        return 'ai_auth';
+    }
+    if (r.includes('econn') ||
+        r.includes('etimedout') ||
+        r.includes('network') ||
+        r.includes('fetch')) {
+        return 'network';
+    }
+    if (r.includes('clone') || r.includes('git')) {
+        return 'repo_clone';
+    }
+    if (r.includes('context fetch')) {
+        return 'context_fetch';
+    }
+    return 'unknown';
+}
+/**
+ * Mark an analysis as failed. Lets the desktop UI surface the error state
+ * instead of leaving a stuck "pending" row. The failure code is embedded
+ * as a leading tag in analysis_content so the UI can render it without a
+ * schema migration.
+ */
+export async function markUserPsychologyAnalysisFailed(analysisId, reason, verbose) {
+    if (!hasSupabaseSession()) {
+        return;
+    }
+    const code = classifyPsychologyFailure(reason);
+    const body = `[${code}] ${reason}`.slice(0, 4000);
+    try {
+        await getSupabase()
+            .from('user_psychology_analyses')
+            .update({
+            status: 'failed',
+            analysis_content: body,
+        })
+            .eq('id', analysisId);
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to mark psychology analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/auth/auth-store.d.ts

@@ -13,6 +13,18 @@ export interface AuthConfig {
     loggedInAt: string;
     /** Edsger.ai base URL */
     edsgerBaseUrl?: string;
+    /** Supabase project URL (e.g. https://xxx.supabase.co). Written by the
+     * desktop app so the CLI can talk to Supabase directly (RLS-gated) for
+     * endpoints that have been migrated off the MCP edge function. */
+    supabaseUrl?: string;
+    /** Supabase anon (publishable) key for the same project. */
+    supabaseAnonKey?: string;
+    /** Supabase user JWT. Rotated by desktop-app on TOKEN_REFRESHED. */
+    accessToken?: string;
+    /** Supabase refresh token paired with accessToken. */
+    refreshToken?: string;
+    /** Supabase auth user ID. */
+    userId?: string;
 }
 /**
  * Save auth configuration to ~/.edsger/auth.json
@@ -24,6 +36,13 @@ export declare function saveAuth(config: AuthConfig): void;
  * Results are cached in memory to avoid repeated disk reads.
  */
 export declare function loadAuth(): AuthConfig | null;
+/**
+ * Invalidate the in-memory auth cache so the next loadAuth() re-reads from
+ * disk. Useful when an external process (typically the desktop-app) has
+ * rotated tokens in auth.json and we want subsequent getters to see the
+ * fresh values.
+ */
+export declare function invalidateAuthCache(): void;
 /**
  * Clear stored auth (logout)
  */
@@ -42,6 +61,20 @@ export declare function getMcpServerUrl(): string | undefined;
  * Environment variable takes precedence
  */
 export declare function getMcpToken(): string | undefined;
+/**
+ * Get the Supabase project URL. Returns undefined when the desktop-app has
+ * not synced a session — callers MUST handle the missing case (typically by
+ * falling back to the MCP edge function path).
+ */
+export declare function getSupabaseUrl(): string | undefined;
+/** Get the Supabase anon (publishable) key. */
+export declare function getSupabaseAnonKey(): string | undefined;
+/** Get the Supabase user JWT (access token). */
+export declare function getAccessToken(): string | undefined;
+/** Get the Supabase refresh token. */
+export declare function getRefreshToken(): string | undefined;
+/** Get the Supabase auth user ID. */
+export declare function getUserId(): string | undefined;
 /**
  * Get the Edsger base URL (defaults to https://edsger.ai)
  */

package/dist/auth/auth-store.js

@@ -58,6 +58,15 @@ export function loadAuth() {
         return null;
     }
 }
+/**
+ * Invalidate the in-memory auth cache so the next loadAuth() re-reads from
+ * disk. Useful when an external process (typically the desktop-app) has
+ * rotated tokens in auth.json and we want subsequent getters to see the
+ * fresh values.
+ */
+export function invalidateAuthCache() {
+    _authCache = undefined;
+}
 /**
  * Clear stored auth (logout)
  */
@@ -102,6 +111,36 @@ export function getMcpToken() {
     const auth = loadAuth();
     return auth?.mcpToken;
 }
+/**
+ * Get the Supabase project URL. Returns undefined when the desktop-app has
+ * not synced a session — callers MUST handle the missing case (typically by
+ * falling back to the MCP edge function path).
+ */
+export function getSupabaseUrl() {
+    if (process.env.EDSGER_SUPABASE_URL) {
+        return process.env.EDSGER_SUPABASE_URL;
+    }
+    return loadAuth()?.supabaseUrl;
+}
+/** Get the Supabase anon (publishable) key. */
+export function getSupabaseAnonKey() {
+    if (process.env.EDSGER_SUPABASE_ANON_KEY) {
+        return process.env.EDSGER_SUPABASE_ANON_KEY;
+    }
+    return loadAuth()?.supabaseAnonKey;
+}
+/** Get the Supabase user JWT (access token). */
+export function getAccessToken() {
+    return loadAuth()?.accessToken;
+}
+/** Get the Supabase refresh token. */
+export function getRefreshToken() {
+    return loadAuth()?.refreshToken;
+}
+/** Get the Supabase auth user ID. */
+export function getUserId() {
+    return loadAuth()?.userId;
+}
 /**
  * Get the Edsger base URL (defaults to https://edsger.ai)
  */

package/dist/commands/agent-workflow/chat-worker.js

@@ -16,6 +16,7 @@
 import { randomUUID } from 'node:crypto';
 import { claimPendingMessages, getIssueChannel, listChannels, sendSystemMessage, } from '../../api/chat.js';
 import { processHumanMessages, processPhaseCompletion, processProductHumanMessages, } from '../../phases/chat-processor/index.js';
+import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
 function sendMessage(msg) {
     if (process.send) {
         process.send(msg);
@@ -37,11 +38,17 @@ const WORKER_ID = `chat-worker-${process.pid}-${randomUUID().slice(0, 8)}`;
 const activeChannels = new Map();
 // Track active product channels (productId -> channelId)
 const activeProductChannels = new Map();
+const channelMetaById = new Map();
 // Track issue repo paths (issueId -> repoPath) for setting cwd on AI agent
 const issueRepoPaths = new Map();
-// Poll interval in ms
+// Active Realtime channel — set when the Supabase session is available.
+let realtimeChannel = null;
+// Fallback poll interval (legacy path when no Supabase session — desktop-app
+// not yet rolled out / standalone CLI). Realtime path needs no timer.
 const POLL_INTERVAL = 5000;
-// Refresh channel list every N polls (~30s at 5s intervals)
+// In the legacy poll path: refresh the channel list every N polls (~30s).
+// The Realtime path discovers new channels via the chat_channels
+// subscription, so this constant is unused there.
 const CHANNEL_REFRESH_INTERVAL = 6;
 let pollCount = 0;
 // ============================================================
@@ -91,7 +98,7 @@ function startPolling() {
         return;
     }
     isRunning = true;
-    log('info', 'Chat worker started polling');
+    log('info', 'Chat worker started polling (MCP fallback path)');
     // Initial poll
     pollForMessages().catch((error) => {
         log('error', `Initial poll error: ${error instanceof Error ? error.message : String(error)}`);
@@ -109,7 +116,8 @@ function stopPolling() {
         clearInterval(pollTimer);
         pollTimer = null;
     }
-    log('info', 'Chat worker stopped polling');
+    stopRealtime();
+    log('info', 'Chat worker stopped');
 }
 // ============================================================
 // Event Handlers
@@ -119,8 +127,21 @@ async function handleInit(msg) {
     ({ config } = msg);
     verbose = msg.verbose ?? false;
     log('info', `Chat worker initialized (id: ${WORKER_ID})`);
-    // Load existing channels before starting the poll loop
+    // Seed the channel cache before subscriptions/polling so dispatch knows
+    // which kind (issue vs product) a chat_messages event belongs to.
     await refreshChannels();
+    // Drain any messages that landed while we were offline.
+    isRunning = true;
+    for (const channelId of channelMetaById.keys()) {
+        void claimAndProcess(channelId);
+    }
+    // Prefer Realtime over polling when the Supabase session is available —
+    // eliminates the 5s/N-channel polling load entirely.
+    if (startRealtime()) {
+        log('info', 'Chat worker running in Realtime mode');
+        return;
+    }
+    log('info', 'No Supabase session — chat worker falling back to MCP polling mode');
     startPolling();
 }
 async function handlePhaseCompleted(msg) {
@@ -185,8 +206,10 @@ async function handleIssueDone(msg) {
 // ============================================================
 /**
  * Refresh the active channels list from the server.
- * Called on init and periodically during polling to discover
- * newly created channels (e.g., when a user opens an issue chat on the web).
+ * Called on init (and, in the legacy poll path, periodically) to discover
+ * newly created channels. In the Realtime path the chat_channels INSERT
+ * subscription keeps the map fresh; refreshChannels is still called once at
+ * startup to seed it.
  */
 async function refreshChannels() {
     try {
@@ -197,17 +220,27 @@ async function refreshChannels() {
         ]);
         let added = 0;
         for (const channel of issueChannels) {
-            if (channel.channel_ref_id &&
-                !activeChannels.has(channel.channel_ref_id)) {
-                activeChannels.set(channel.channel_ref_id, channel.id);
-                added++;
+            if (channel.channel_ref_id) {
+                if (!activeChannels.has(channel.channel_ref_id)) {
+                    activeChannels.set(channel.channel_ref_id, channel.id);
+                    added++;
+                }
+                channelMetaById.set(channel.id, {
+                    kind: 'issue',
+                    refId: channel.channel_ref_id,
+                });
             }
         }
         for (const channel of productChannels) {
-            if (channel.channel_ref_id &&
-                !activeProductChannels.has(channel.channel_ref_id)) {
-                activeProductChannels.set(channel.channel_ref_id, channel.id);
-                added++;
+            if (channel.channel_ref_id) {
+                if (!activeProductChannels.has(channel.channel_ref_id)) {
+                    activeProductChannels.set(channel.channel_ref_id, channel.id);
+                    added++;
+                }
+                channelMetaById.set(channel.id, {
+                    kind: 'product',
+                    refId: channel.channel_ref_id,
+                });
             }
         }
         if (added > 0) {
@@ -219,6 +252,144 @@ async function refreshChannels() {
         log('error', `Failed to refresh channels: ${msg}`);
     }
 }
+/** Register a newly-discovered channel (typically from a Realtime event). */
+function registerChannel(channel) {
+    if (!channel.channel_ref_id) {
+        return;
+    }
+    if (channel.channel_type === 'issue') {
+        if (!activeChannels.has(channel.channel_ref_id)) {
+            activeChannels.set(channel.channel_ref_id, channel.id);
+            log('info', `New issue channel discovered: ${channel.channel_ref_id} (${channel.id})`);
+        }
+        channelMetaById.set(channel.id, {
+            kind: 'issue',
+            refId: channel.channel_ref_id,
+        });
+    }
+    else if (channel.channel_type === 'product') {
+        if (!activeProductChannels.has(channel.channel_ref_id)) {
+            activeProductChannels.set(channel.channel_ref_id, channel.id);
+            log('info', `New product channel discovered: ${channel.channel_ref_id} (${channel.id})`);
+        }
+        channelMetaById.set(channel.id, {
+            kind: 'product',
+            refId: channel.channel_ref_id,
+        });
+    }
+}
+/**
+ * Dispatch claim+process for a single channel. Called both from Realtime
+ * INSERT events on chat_messages and (in the legacy path) from the poll loop.
+ */
+async function claimAndProcess(channelId) {
+    if (!config) {
+        return;
+    }
+    const meta = channelMetaById.get(channelId);
+    if (!meta) {
+        // Unknown channel — could be a fresh channel we haven't seeded yet.
+        // Skip rather than fetch synchronously; the chat_channels INSERT
+        // subscription will populate it momentarily and the next message event
+        // will pick it up.
+        return;
+    }
+    try {
+        const claimed = await claimPendingMessages(channelId, WORKER_ID);
+        if (claimed.length === 0) {
+            return;
+        }
+        if (meta.kind === 'issue') {
+            log('info', `Claimed ${claimed.length} message(s) for issue ${meta.refId} (worker: ${WORKER_ID})`);
+            const repoPath = issueRepoPaths.get(meta.refId);
+            await processHumanMessages(claimed, meta.refId, config, verbose, repoPath);
+        }
+        else {
+            log('info', `Claimed ${claimed.length} message(s) for product ${meta.refId} (worker: ${WORKER_ID})`);
+            await processProductHumanMessages(claimed, meta.refId, config, verbose);
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log('error', `Error processing channel ${channelId}: ${msg}`);
+    }
+}
+/**
+ * Bring up the Realtime subscription. Listens for:
+ *   - chat_messages INSERT (sender_type=human) → claim+process on that channel
+ *   - chat_channels INSERT → register newly-created channels
+ *
+ * Returns true if the subscription was successfully started.
+ */
+function startRealtime() {
+    if (realtimeChannel) {
+        return true;
+    }
+    if (!hasSupabaseSession()) {
+        return false;
+    }
+    try {
+        const supabase = getSupabase();
+        realtimeChannel = supabase
+            .channel('chat-worker', { config: { broadcast: { ack: false } } })
+            .on('postgres_changes', {
+            event: 'INSERT',
+            schema: 'public',
+            table: 'chat_messages',
+            filter: 'sender_type=eq.human',
+        }, (payload) => {
+            // RLS filters out events from channels the user isn't in, so any
+            // event reaching us belongs to a channel we have access to.
+            const row = payload.new;
+            if (!row.channel_id || row.is_processed) {
+                return;
+            }
+            void claimAndProcess(row.channel_id);
+        })
+            .on('postgres_changes', {
+            event: 'INSERT',
+            schema: 'public',
+            table: 'chat_channels',
+        }, (payload) => {
+            registerChannel(payload.new);
+            // A channel created with messages already in it (unlikely but
+            // possible if INSERTs race) deserves an immediate sweep.
+            const id = payload.new.id;
+            if (id) {
+                void claimAndProcess(id);
+            }
+        })
+            .subscribe((status) => {
+            if (status === 'SUBSCRIBED') {
+                log('info', 'Realtime subscription active (chat_messages, chat_channels)');
+            }
+            else if (status === 'CHANNEL_ERROR' ||
+                status === 'TIMED_OUT' ||
+                status === 'CLOSED') {
+                log('warning', `Realtime channel status: ${status}`);
+                // supabase-js auto-reconnects; no manual reschedule needed here.
+            }
+        });
+        return true;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log('error', `Failed to start Realtime subscription: ${msg}`);
+        return false;
+    }
+}
+function stopRealtime() {
+    if (!realtimeChannel) {
+        return;
+    }
+    try {
+        void getSupabase().removeChannel(realtimeChannel);
+    }
+    catch {
+        // Best-effort; supabase may already be torn down.
+    }
+    realtimeChannel = null;
+}
 async function ensureIssueChannel(issueId) {
     const cachedChannel = activeChannels.get(issueId);
     if (cachedChannel) {
@@ -227,6 +398,7 @@ async function ensureIssueChannel(issueId) {
     try {
         const channel = await getIssueChannel(issueId);
         activeChannels.set(issueId, channel.id);
+        channelMetaById.set(channel.id, { kind: 'issue', refId: issueId });
         log('info', `Registered channel ${channel.id} for issue ${issueId}`);
         return channel.id;
     }

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

@@ -35,8 +35,19 @@ export declare class AgentWorkflowProcessor {
     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;
     constructor(options: AgentWorkflowOptions, config: EdsgerConfig);
     start(): Promise<void>;
+    /**
+     * Subscribe to `issues` UPDATE/INSERT events and trigger processNextIssues
+     * when a row arrives with `status='ready_for_ai'` assigned to this user.
+     *
+     * Returns true if the subscription was successfully started. RLS on `issues`
+     * 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;

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

@@ -14,7 +14,9 @@ import { listAllReadyIssues, } from '../../api/cross-product.js';
 import { getGitHubConfig } from '../../api/github.js';
 import { claimNextIssue, getIssue } from '../../api/issues/index.js';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
+import { getUserId } from '../../auth/auth-store.js';
 import { WorkerTimeoutError } from '../../errors/index.js';
+import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
 import { sendHeartbeat, shouldProcess } from '../../system/session-manager.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
 import { cleanupIssueRepo, cloneIssueRepo, getIssueRepoPath, } from '../../workspace/workspace-manager.js';
@@ -45,6 +47,9 @@ export class AgentWorkflowProcessor {
     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;
     constructor(options, config) {
         const wf = config.workflow;
         this.options = {
@@ -67,12 +72,75 @@ export class AgentWorkflowProcessor {
         this.startChatWorker();
         // Initial issue check
         await this.processNextIssues();
-        // Set up polling
+        // Set up Realtime subscription on `issues` so a status flip to
+        // 'ready_for_ai' triggers an immediate processing pass instead of
+        // waiting for the next poll tick. Falls back to the timer-only path
+        // when the Supabase session isn't available yet.
+        const realtimeOk = this.startIssuesRealtime();
+        // Keep the timer as a safety net (Realtime can drop events on
+        // reconnect / publication lag). When Realtime is active we stretch the
+        // interval substantially — the timer is purely a backstop now.
+        const safetyNetInterval = realtimeOk
+            ? Math.max(this.options.pollInterval, 5 * 60_000)
+            : this.options.pollInterval;
         this.pollTimer = setInterval(() => {
             this.processNextIssues().catch((error) => {
                 logError(`Polling error: ${error instanceof Error ? error.message : String(error)}`);
             });
-        }, this.options.pollInterval);
+        }, safetyNetInterval);
+    }
+    /**
+     * Subscribe to `issues` UPDATE/INSERT events and trigger processNextIssues
+     * when a row arrives with `status='ready_for_ai'` assigned to this user.
+     *
+     * Returns true if the subscription was successfully started. RLS on `issues`
+     * already constrains delivery to products the user has access to.
+     */
+    startIssuesRealtime() {
+        if (this.issuesRealtimeChannel) {
+            return true;
+        }
+        const userId = getUserId();
+        if (!hasSupabaseSession() || !userId) {
+            return false;
+        }
+        try {
+            const supabase = getSupabase();
+            const onChange = (payload) => {
+                const row = payload.new;
+                if (!row) {
+                    return;
+                }
+                // Realtime postgres_changes filter syntax only supports a single
+                // predicate, so filter the rest in-process.
+                if (row.status !== 'ready_for_ai' ||
+                    (row.developer_id && row.developer_id !== userId)) {
+                    return;
+                }
+                this.processNextIssues().catch((error) => {
+                    logError(`Realtime-triggered processNextIssues failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            };
+            this.issuesRealtimeChannel = supabase
+                .channel('agent-workflow-issues')
+                .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'issues' }, onChange)
+                .on('postgres_changes', { event: 'UPDATE', schema: 'public', table: 'issues' }, onChange)
+                .subscribe((status) => {
+                if (status === 'SUBSCRIBED') {
+                    logInfo('Realtime subscription on issues active');
+                }
+                else if (status === 'CHANNEL_ERROR' ||
+                    status === 'TIMED_OUT' ||
+                    status === 'CLOSED') {
+                    logWarning(`Issues Realtime channel status: ${status}`);
+                }
+            });
+            return true;
+        }
+        catch (error) {
+            logWarning(`Failed to start issues Realtime subscription: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
     }
     startChatWorker() {
         try {
@@ -155,6 +223,17 @@ export class AgentWorkflowProcessor {
             clearInterval(this.pollTimer);
             this.pollTimer = undefined;
         }
+        // Tear down Realtime first so a late event doesn't kick off new work
+        // while we're shutting down workers.
+        if (this.issuesRealtimeChannel) {
+            try {
+                void getSupabase().removeChannel(this.issuesRealtimeChannel);
+            }
+            catch {
+                // Best-effort
+            }
+            this.issuesRealtimeChannel = null;
+        }
         // Kill chat worker
         if (this.chatWorker) {
             try {

package/dist/commands/product-test-cases/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CLI command: edsger product-test-cases <productId>
+ *
+ * Clones the product's repo, asks Claude to draft a product-level regression
+ * suite (deduped against existing approved + unapproved cases), saves the new
+ * ones as drafts, and cleans up the workspace.
+ */
+export interface ProductTestCasesCliOptions {
+    branch?: string;
+    verbose?: boolean;
+}
+export declare function runProductTestCases(productId: string, options: ProductTestCasesCliOptions): Promise<void>;