edsger 0.27.11 → 0.28.1

package/dist/api/chat.d.ts

@@ -0,0 +1,53 @@
+/**
+ * MCP client wrappers for chat operations.
+ * Used by the chat-worker subprocess to interact with chat channels and messages.
+ */
+import type { ChatChannel, ChatChannelType, ChatMode, ChatMessage, ChatMessageType } from '../types/index.js';
+export declare function getOrCreateChannel(channelType: ChatChannelType, channelRefId: string | null, chatMode?: ChatMode, name?: string, verbose?: boolean): Promise<{
+    channel: ChatChannel;
+    created: boolean;
+}>;
+export declare function listChannels(channelType?: ChatChannelType, channelRefId?: string, verbose?: boolean): Promise<ChatChannel[]>;
+export declare function addChannelMember(channelId: string, userId: string, role?: 'owner' | 'admin' | 'member', verbose?: boolean): Promise<void>;
+export declare function removeChannelMember(channelId: string, userId: string, verbose?: boolean): Promise<void>;
+export declare function listChatMessages(channelId: string, options?: {
+    since?: string;
+    limit?: number;
+    offset?: number;
+}, verbose?: boolean): Promise<ChatMessage[]>;
+export declare function sendAiMessage(channelId: string, content: string, metadata?: Record<string, unknown>, options?: {
+    messageType?: ChatMessageType;
+    parentMessageId?: string;
+}, verbose?: boolean): Promise<ChatMessage>;
+export declare function sendSystemMessage(channelId: string, content: string, metadata?: Record<string, unknown>, verbose?: boolean): Promise<ChatMessage>;
+export declare function getPendingMessages(channelId: string, verbose?: boolean): Promise<ChatMessage[]>;
+/**
+ * Atomically claim pending messages for a channel.
+ * Uses FOR UPDATE SKIP LOCKED at the database level so multiple CLI workers
+ * never process the same message. Stale claims are automatically released.
+ */
+export declare function claimPendingMessages(channelId: string, workerId: string, options?: {
+    limit?: number;
+    staleTimeoutSeconds?: number;
+}, verbose?: boolean): Promise<ChatMessage[]>;
+export declare function markMessageProcessed(messageId: string, verbose?: boolean): Promise<void>;
+export declare function markChannelRead(channelId: string, lastReadMessageId?: string, verbose?: boolean): Promise<void>;
+export declare function getUnreadCount(channelId: string, verbose?: boolean): Promise<number>;
+/**
+ * Get or create the group chat channel for a feature.
+ * This is the most common operation — every feature has one group channel.
+ */
+export declare function getFeatureChannel(featureId: string, verbose?: boolean): Promise<ChatChannel>;
+/**
+ * Send a system message to a feature's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export declare function sendFeatureSystemMessage(featureId: string, content: string, metadata?: Record<string, unknown>, verbose?: boolean): Promise<ChatMessage>;
+/**
+ * Send an AI message to a feature's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export declare function sendFeatureAiMessage(featureId: string, content: string, metadata?: Record<string, unknown>, options?: {
+    messageType?: ChatMessageType;
+    parentMessageId?: string;
+}, verbose?: boolean): Promise<ChatMessage>;

package/dist/api/chat.js

@@ -0,0 +1,177 @@
+/**
+ * MCP client wrappers for chat operations.
+ * Used by the chat-worker subprocess to interact with chat channels and messages.
+ */
+import { callMcpEndpoint } from './mcp-client.js';
+import { logInfo, logError } from '../utils/logger.js';
+// ============================================================
+// Channels
+// ============================================================
+export async function getOrCreateChannel(channelType, channelRefId, chatMode = 'group', name, verbose) {
+    if (verbose) {
+        logInfo(`Getting/creating channel: ${channelType}/${channelRefId}/${chatMode}`);
+    }
+    const result = (await callMcpEndpoint('chat/channels/get_or_create', {
+        channel_type: channelType,
+        channel_ref_id: channelRefId,
+        chat_mode: chatMode,
+        name,
+    }));
+    return result;
+}
+export async function listChannels(channelType, channelRefId, verbose) {
+    if (verbose) {
+        logInfo(`Listing channels: type=${channelType || 'all'}`);
+    }
+    const result = (await callMcpEndpoint('chat/channels/list', {
+        channel_type: channelType,
+        channel_ref_id: channelRefId,
+    }));
+    return result.channels || [];
+}
+// ============================================================
+// Members
+// ============================================================
+export async function addChannelMember(channelId, userId, role = 'member', verbose) {
+    if (verbose) {
+        logInfo(`Adding member ${userId} to channel ${channelId}`);
+    }
+    await callMcpEndpoint('chat/members/add', {
+        channel_id: channelId,
+        user_id: userId,
+        role,
+    });
+}
+export async function removeChannelMember(channelId, userId, verbose) {
+    if (verbose) {
+        logInfo(`Removing member ${userId} from channel ${channelId}`);
+    }
+    await callMcpEndpoint('chat/members/remove', {
+        channel_id: channelId,
+        user_id: userId,
+    });
+}
+// ============================================================
+// Messages
+// ============================================================
+export async function listChatMessages(channelId, options = {}, verbose) {
+    if (verbose) {
+        logInfo(`Listing messages for channel ${channelId}`);
+    }
+    const result = (await callMcpEndpoint('chat/messages/list', {
+        channel_id: channelId,
+        ...options,
+    }));
+    return result.messages || [];
+}
+export async function sendAiMessage(channelId, content, metadata = {}, options = {}, verbose) {
+    if (verbose) {
+        logInfo(`Sending AI message to channel ${channelId}`);
+    }
+    const result = (await callMcpEndpoint('chat/messages/send_ai', {
+        channel_id: channelId,
+        content,
+        message_type: options.messageType || 'text',
+        metadata,
+        parent_message_id: options.parentMessageId,
+    }));
+    return result.message;
+}
+export async function sendSystemMessage(channelId, content, metadata = {}, verbose) {
+    if (verbose) {
+        logInfo(`Sending system message to channel ${channelId}`);
+    }
+    const result = (await callMcpEndpoint('chat/messages/send_system', {
+        channel_id: channelId,
+        content,
+        metadata,
+    }));
+    return result.message;
+}
+export async function getPendingMessages(channelId, verbose) {
+    const result = (await callMcpEndpoint('chat/messages/pending', {
+        channel_id: channelId,
+    }));
+    return result.messages || [];
+}
+/**
+ * Atomically claim pending messages for a channel.
+ * Uses FOR UPDATE SKIP LOCKED at the database level so multiple CLI workers
+ * never process the same message. Stale claims are automatically released.
+ */
+export async function claimPendingMessages(channelId, workerId, options = {}, verbose) {
+    if (verbose) {
+        logInfo(`Claiming pending messages for channel ${channelId} (worker: ${workerId})`);
+    }
+    const result = (await callMcpEndpoint('chat/messages/claim', {
+        channel_id: channelId,
+        worker_id: workerId,
+        limit: options.limit || 10,
+        stale_timeout_seconds: options.staleTimeoutSeconds || 300,
+    }));
+    return result.messages || [];
+}
+export async function markMessageProcessed(messageId, verbose) {
+    if (verbose) {
+        logInfo(`Marking message ${messageId} as processed`);
+    }
+    await callMcpEndpoint('chat/messages/mark_processed', {
+        message_id: messageId,
+    });
+}
+// ============================================================
+// Read Status
+// ============================================================
+export async function markChannelRead(channelId, lastReadMessageId, verbose) {
+    await callMcpEndpoint('chat/read_status/mark_read', {
+        channel_id: channelId,
+        last_read_message_id: lastReadMessageId,
+    });
+}
+export async function getUnreadCount(channelId, verbose) {
+    const result = (await callMcpEndpoint('chat/read_status/unread_count', {
+        channel_id: channelId,
+    }));
+    return result.unread_count;
+}
+// ============================================================
+// Convenience: Feature Channel
+// ============================================================
+/**
+ * Get or create the group chat channel for a feature.
+ * This is the most common operation — every feature has one group channel.
+ */
+export async function getFeatureChannel(featureId, verbose) {
+    const { channel } = await getOrCreateChannel('feature', featureId, 'group', undefined, verbose);
+    return channel;
+}
+/**
+ * Send a system message to a feature's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export async function sendFeatureSystemMessage(featureId, content, metadata = {}, verbose) {
+    try {
+        const channel = await getFeatureChannel(featureId, verbose);
+        return await sendSystemMessage(channel.id, content, metadata, verbose);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logError(`Failed to send system message for feature ${featureId}: ${msg}`);
+        throw error;
+    }
+}
+/**
+ * Send an AI message to a feature's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export async function sendFeatureAiMessage(featureId, content, metadata = {}, options = {}, verbose) {
+    try {
+        const channel = await getFeatureChannel(featureId, verbose);
+        return await sendAiMessage(channel.id, content, metadata, options, verbose);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logError(`Failed to send AI message for feature ${featureId}: ${msg}`);
+        throw error;
+    }
+}

package/dist/commands/agent-workflow/chat-worker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Chat Worker — Child process entry point for processing chat messages.
+ *
+ * Spawned by AgentWorkflowProcessor as a parallel subprocess alongside feature workers.
+ * Runs continuously, polling for unprocessed human messages across all active feature channels.
+ *
+ * Communication with parent via IPC:
+ * - Parent sends: { type: 'init', config }
+ * - Parent sends: { type: 'event:phase_completed', featureId, phase, summary, phaseOutput }
+ * - Parent sends: { type: 'event:phase_failed', featureId, phase, error }
+ * - Parent sends: { type: 'event:feature_done', featureId }
+ * - Worker sends: { type: 'log', level, message }
+ * - Worker sends: { type: 'command:pause_feature', featureId }
+ * - Worker sends: { type: 'command:resume_feature', featureId }
+ */
+export {};

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

@@ -0,0 +1,242 @@
+/**
+ * Chat Worker — Child process entry point for processing chat messages.
+ *
+ * Spawned by AgentWorkflowProcessor as a parallel subprocess alongside feature workers.
+ * Runs continuously, polling for unprocessed human messages across all active feature channels.
+ *
+ * Communication with parent via IPC:
+ * - Parent sends: { type: 'init', config }
+ * - Parent sends: { type: 'event:phase_completed', featureId, phase, summary, phaseOutput }
+ * - Parent sends: { type: 'event:phase_failed', featureId, phase, error }
+ * - Parent sends: { type: 'event:feature_done', featureId }
+ * - Worker sends: { type: 'log', level, message }
+ * - Worker sends: { type: 'command:pause_feature', featureId }
+ * - Worker sends: { type: 'command:resume_feature', featureId }
+ */
+import { randomUUID } from 'node:crypto';
+import { getFeatureChannel, claimPendingMessages, listChannels, sendSystemMessage, } from '../../api/chat.js';
+import { processHumanMessages, processPhaseCompletion, } from '../../phases/chat-processor/index.js';
+function sendMessage(msg) {
+    if (process.send) {
+        process.send(msg);
+    }
+}
+function log(level, message) {
+    sendMessage({ type: 'log', level, message });
+}
+// ============================================================
+// State
+// ============================================================
+let config = null;
+let isRunning = false;
+let pollTimer = null;
+// Unique worker ID for this process instance — used for atomic message claiming
+const WORKER_ID = `chat-worker-${process.pid}-${randomUUID().slice(0, 8)}`;
+// Track active feature channels (featureId -> channelId)
+const activeChannels = new Map();
+// Poll interval in ms
+const POLL_INTERVAL = 5000;
+// Refresh channel list every N polls (~30s at 5s intervals)
+const CHANNEL_REFRESH_INTERVAL = 6;
+let pollCount = 0;
+// ============================================================
+// Message Polling Loop
+// ============================================================
+async function pollForMessages() {
+    if (!config || !isRunning)
+        return;
+    // Periodically refresh the channel list to pick up newly created channels
+    pollCount++;
+    if (pollCount % CHANNEL_REFRESH_INTERVAL === 0) {
+        await refreshChannels();
+    }
+    for (const [featureId, channelId] of activeChannels) {
+        try {
+            // Atomically claim messages — other workers won't see these
+            const claimed = await claimPendingMessages(channelId, WORKER_ID);
+            if (claimed.length > 0) {
+                log('info', `Claimed ${claimed.length} message(s) for feature ${featureId} (worker: ${WORKER_ID})`);
+                // Batch all claimed messages into a single AI session
+                await processHumanMessages(claimed, featureId, config);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            log('error', `Error polling channel ${channelId}: ${msg}`);
+        }
+    }
+}
+function startPolling() {
+    if (pollTimer)
+        return;
+    isRunning = true;
+    log('info', 'Chat worker started polling');
+    // Initial poll
+    pollForMessages().catch((error) => {
+        log('error', `Initial poll error: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    // Set up interval
+    pollTimer = setInterval(() => {
+        pollForMessages().catch((error) => {
+            log('error', `Poll error: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }, POLL_INTERVAL);
+}
+function stopPolling() {
+    isRunning = false;
+    if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+    }
+    log('info', 'Chat worker stopped polling');
+}
+// ============================================================
+// Event Handlers
+// ============================================================
+async function handleInit(msg) {
+    config = msg.config;
+    log('info', `Chat worker initialized (id: ${WORKER_ID})`);
+    // Load existing channels before starting the poll loop
+    await refreshChannels();
+    startPolling();
+}
+async function handlePhaseCompleted(msg) {
+    if (!config)
+        return;
+    const { featureId, phase, summary, phaseOutput } = msg;
+    log('info', `Phase completed: ${phase} for feature ${featureId}`);
+    try {
+        // Ensure we have the channel registered
+        await ensureFeatureChannel(featureId);
+        // Process with AI for next-step suggestions
+        await processPhaseCompletion(featureId, phase, summary, phaseOutput, config);
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        log('error', `Failed to process phase completion: ${errorMsg}`);
+    }
+}
+async function handlePhaseFailed(msg) {
+    const { featureId, phase, error: errorStr } = msg;
+    log('warning', `Phase failed: ${phase} for feature ${featureId}`);
+    try {
+        await ensureFeatureChannel(featureId);
+        const channelId = activeChannels.get(featureId);
+        if (channelId) {
+            await sendSystemMessage(channelId, `Phase "${phase}" failed: ${errorStr}`, { phase, status: 'failed', error: errorStr });
+        }
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        log('error', `Failed to send phase failure message: ${errorMsg}`);
+    }
+}
+async function handleFeatureDone(msg) {
+    const { featureId } = msg;
+    log('info', `Feature done: ${featureId}`);
+    try {
+        const channelId = activeChannels.get(featureId);
+        if (channelId) {
+            await sendSystemMessage(channelId, 'All workflow phases completed.', { status: 'feature_done' });
+        }
+    }
+    catch (error) {
+        // Non-critical
+    }
+    // Keep the channel in activeChannels so we can still process messages
+}
+// ============================================================
+// Channel Management
+// ============================================================
+/**
+ * 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 a feature chat on the web).
+ */
+async function refreshChannels() {
+    try {
+        const channels = await listChannels('feature');
+        let added = 0;
+        for (const channel of channels) {
+            if (channel.channel_ref_id && !activeChannels.has(channel.channel_ref_id)) {
+                activeChannels.set(channel.channel_ref_id, channel.id);
+                added++;
+            }
+        }
+        if (added > 0) {
+            log('info', `Discovered ${added} new channel(s) (total: ${activeChannels.size})`);
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log('error', `Failed to refresh channels: ${msg}`);
+    }
+}
+async function ensureFeatureChannel(featureId) {
+    if (activeChannels.has(featureId)) {
+        return activeChannels.get(featureId);
+    }
+    try {
+        const channel = await getFeatureChannel(featureId);
+        activeChannels.set(featureId, channel.id);
+        log('info', `Registered channel ${channel.id} for feature ${featureId}`);
+        return channel.id;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log('error', `Failed to get channel for feature ${featureId}: ${msg}`);
+        throw error;
+    }
+}
+// ============================================================
+// Main IPC Listener
+// ============================================================
+process.on('message', (msg) => {
+    switch (msg.type) {
+        case 'init':
+            handleInit(msg).catch((error) => {
+                log('error', `Init error: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            break;
+        case 'event:phase_completed':
+            handlePhaseCompleted(msg).catch((error) => {
+                log('error', `Phase event error: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            break;
+        case 'event:phase_failed':
+            handlePhaseFailed(msg).catch((error) => {
+                log('error', `Phase fail event error: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            break;
+        case 'event:feature_done':
+            handleFeatureDone(msg).catch((error) => {
+                log('error', `Feature done event error: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            break;
+        // Register a feature channel for polling when a worker starts
+        case 'event:feature_started': {
+            const startMsg = msg;
+            ensureFeatureChannel(startMsg.featureId).catch((error) => {
+                log('error', `Channel registration error: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            break;
+        }
+        default:
+            log('warning', `Unknown message type: ${msg.type}`);
+    }
+});
+// Handle graceful shutdown
+process.on('SIGTERM', () => {
+    stopPolling();
+    process.exit(0);
+});
+process.on('SIGINT', () => {
+    stopPolling();
+    process.exit(0);
+});
+// Handle uncaught errors
+process.on('uncaughtException', (error) => {
+    log('error', `Uncaught exception: ${error.message}`);
+    stopPolling();
+    process.exit(1);
+});

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

@@ -33,8 +33,13 @@ export declare class AgentWorkflowProcessor {
     private pollTimer?;
     /** Currently active worker processes, keyed by featureId */
     private activeWorkers;
+    /** Chat worker subprocess — runs in parallel, handles chat messages and phase events */
+    private chatWorker?;
     constructor(options: AgentWorkflowOptions, config: EdsgerConfig);
     start(): Promise<void>;
+    private startChatWorker;
+    /** Send a message to the chat worker via IPC */
+    private notifyChatWorker;
     stop(): void;
     private processNextFeatures;
     /**

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

@@ -25,10 +25,11 @@ import { createInitialState, updateFeatureState, createProcessingState, createCo
  * - Memory: each fork() creates ~50-80MB Node.js process
  */
 export const MAX_CONCURRENCY = 10;
-/** Path to the compiled feature-worker.js entry point */
+/** Path to the compiled worker entry points */
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const WORKER_SCRIPT = join(__dirname, 'feature-worker.js');
+const CHAT_WORKER_SCRIPT = join(__dirname, 'chat-worker.js');
 export class AgentWorkflowProcessor {
     options;
     config;
@@ -37,6 +38,8 @@ export class AgentWorkflowProcessor {
     pollTimer;
     /** Currently active worker processes, keyed by featureId */
     activeWorkers = new Map();
+    /** Chat worker subprocess — runs in parallel, handles chat messages and phase events */
+    chatWorker;
     constructor(options, config) {
         this.options = {
             pollInterval: 30_000,
@@ -54,6 +57,8 @@ export class AgentWorkflowProcessor {
         }
         this.isRunning = true;
         logInfo(`Concurrent processing: up to ${this.options.maxConcurrent} feature(s)`);
+        // Start chat worker subprocess
+        this.startChatWorker();
         // Initial feature check
         await this.processNextFeatures();
         // Set up polling
@@ -63,6 +68,69 @@ export class AgentWorkflowProcessor {
             });
         }, this.options.pollInterval);
     }
+    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;
+                    }
+                }
+            });
+            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 });
+            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
+            }
+        }
+    }
     stop() {
         if (!this.isRunning)
             return;
@@ -71,7 +139,17 @@ export class AgentWorkflowProcessor {
             clearInterval(this.pollTimer);
             this.pollTimer = undefined;
         }
-        // Kill all active workers gracefully
+        // Kill chat worker
+        if (this.chatWorker) {
+            try {
+                this.chatWorker.kill('SIGTERM');
+            }
+            catch {
+                // Ignore kill errors
+            }
+            this.chatWorker = undefined;
+        }
+        // Kill all active feature workers gracefully
         for (const [featureId, worker] of this.activeWorkers) {
             logInfo(`Stopping worker for feature: ${featureId}`);
             try {
@@ -232,6 +310,8 @@ export class AgentWorkflowProcessor {
                 verbose: this.options.verbose,
                 config: this.config,
             });
+            // Notify chat worker that a feature has started processing
+            this.notifyChatWorker({ type: 'event:feature_started', featureId });
         }
         catch (error) {
             this.activeWorkers.delete(featureId);
@@ -243,10 +323,19 @@ export class AgentWorkflowProcessor {
         if (success) {
             this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createCompletedState(featureId, currentState));
             logSuccess(`Feature completed: ${featureName}`);
+            // Notify chat worker that feature workflow is done
+            this.notifyChatWorker({ type: 'event:feature_done', featureId });
         }
         else {
             this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
             logError(`Feature failed: ${featureName}${error ? ` - ${error}` : ''}`);
+            // Notify chat worker about the failure
+            this.notifyChatWorker({
+                type: 'event:phase_failed',
+                featureId,
+                phase: 'workflow',
+                error: error || 'Unknown error',
+            });
         }
         // Clear heartbeat feature info
         sendHeartbeat().catch(() => { });

package/dist/phases/chat-processor/context.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Build context for the chat AI processor.
+ * Fetches feature state, user stories, test cases, and recent chat history.
+ */
+import type { ChatMessage } from '../../types/index.js';
+export interface ChatProcessorContext {
+    featureId: string;
+    featureDescription: string;
+    featureStatus: string;
+    executionMode: string;
+    workflow: Array<{
+        phase: string;
+        status: string;
+    }>;
+    userStories: Array<{
+        id: string;
+        title: string;
+        description: string;
+        status: string;
+    }>;
+    testCases: Array<{
+        id: string;
+        name: string;
+        description: string;
+        is_critical: boolean;
+    }>;
+    recentChatMessages: ChatMessage[];
+    channelId: string;
+}
+/**
+ * Build the full context for the chat AI to process a message.
+ */
+export declare function buildChatContext(featureId: string, channelId: string, verbose?: boolean): Promise<ChatProcessorContext>;
+/**
+ * Format context into a string for the AI system prompt.
+ */
+export declare function formatContextForAI(context: ChatProcessorContext): string;