edsger 0.29.2 → 0.30.0

package/dist/api/chat.d.ts

@@ -33,6 +33,24 @@ export declare function claimPendingMessages(channelId: string, workerId: string
 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 product.
+ * Every product has one group channel.
+ */
+export declare function getProductChannel(productId: string, verbose?: boolean): Promise<ChatChannel>;
+/**
+ * Send a system message to a product's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export declare function sendProductSystemMessage(productId: string, content: string, metadata?: Record<string, unknown>, verbose?: boolean): Promise<ChatMessage>;
+/**
+ * Send an AI message to a product's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export declare function sendProductAiMessage(productId: string, content: string, metadata?: Record<string, unknown>, options?: {
+    messageType?: ChatMessageType;
+    parentMessageId?: string;
+}, verbose?: boolean): Promise<ChatMessage>;
 /**
  * Get or create the group chat channel for a feature.
  * This is the most common operation — every feature has one group channel.

package/dist/api/chat.js

@@ -135,6 +135,47 @@ export async function getUnreadCount(channelId, verbose) {
     return result.unread_count;
 }
 // ============================================================
+// Convenience: Product Channel
+// ============================================================
+/**
+ * Get or create the group chat channel for a product.
+ * Every product has one group channel.
+ */
+export async function getProductChannel(productId, verbose) {
+    const { channel } = await getOrCreateChannel('product', productId, 'group', undefined, verbose);
+    return channel;
+}
+/**
+ * Send a system message to a product's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export async function sendProductSystemMessage(productId, content, metadata = {}, verbose) {
+    try {
+        const channel = await getProductChannel(productId, 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 product ${productId}: ${msg}`);
+        throw error;
+    }
+}
+/**
+ * Send an AI message to a product's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export async function sendProductAiMessage(productId, content, metadata = {}, options = {}, verbose) {
+    try {
+        const channel = await getProductChannel(productId, 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 product ${productId}: ${msg}`);
+        throw error;
+    }
+}
+// ============================================================
 // Convenience: Feature Channel
 // ============================================================
 /**

package/dist/api/features/status-updater.d.ts

@@ -10,6 +10,10 @@ interface StatusUpdateOptions {
 }
 /**
  * Check if moving from currentStatus to newStatus is forward progression
+ *
+ * Special cases for archived status:
+ * - Any status → archived: Always allowed (archiving from any state)
+ * - Archived → backlog: Always allowed (unarchiving restores to backlog)
  */
 export declare function isForwardProgression(currentStatus: FeatureStatus, newStatus: FeatureStatus): boolean;
 /**

package/dist/api/features/status-updater.js

@@ -8,8 +8,18 @@ import { getFeature } from './get-feature.js';
 import { STATUS_PROGRESSION_ORDER, PHASE_STATUS_MAP, } from '../../config/feature-status.js';
 /**
  * Check if moving from currentStatus to newStatus is forward progression
+ *
+ * Special cases for archived status:
+ * - Any status → archived: Always allowed (archiving from any state)
+ * - Archived → backlog: Always allowed (unarchiving restores to backlog)
  */
 export function isForwardProgression(currentStatus, newStatus) {
+    // Any status can transition to archived
+    if (newStatus === 'archived')
+        return true;
+    // Archived can only transition back to backlog (unarchive)
+    if (currentStatus === 'archived')
+        return newStatus === 'backlog';
     const currentIndex = STATUS_PROGRESSION_ORDER.indexOf(currentStatus);
     const newIndex = STATUS_PROGRESSION_ORDER.indexOf(newStatus);
     // Allow moving forward or staying at same level (for retries, etc.)

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

@@ -15,7 +15,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { getFeatureChannel, claimPendingMessages, listChannels, sendSystemMessage, } from '../../api/chat.js';
-import { processHumanMessages, processPhaseCompletion, } from '../../phases/chat-processor/index.js';
+import { processHumanMessages, processProductHumanMessages, processPhaseCompletion, } from '../../phases/chat-processor/index.js';
 function sendMessage(msg) {
     if (process.send) {
         process.send(msg);
@@ -28,12 +28,17 @@ function log(level, message) {
 // State
 // ============================================================
 let config = null;
+let verbose = false;
 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();
+// Track active product channels (productId -> channelId)
+const activeProductChannels = new Map();
+// Track feature repo paths (featureId -> repoPath) for setting cwd on AI agent
+const featureRepoPaths = new Map();
 // Poll interval in ms
 const POLL_INTERVAL = 5000;
 // Refresh channel list every N polls (~30s at 5s intervals)
@@ -50,19 +55,33 @@ async function pollForMessages() {
     if (pollCount % CHANNEL_REFRESH_INTERVAL === 0) {
         await refreshChannels();
     }
+    // Poll feature channels
     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);
+                const repoPath = featureRepoPaths.get(featureId);
+                await processHumanMessages(claimed, featureId, config, verbose, repoPath);
             }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            log('error', `Error polling channel ${channelId}: ${msg}`);
+            log('error', `Error polling feature channel ${channelId}: ${msg}`);
+        }
+    }
+    // Poll product channels
+    for (const [productId, channelId] of activeProductChannels) {
+        try {
+            const claimed = await claimPendingMessages(channelId, WORKER_ID);
+            if (claimed.length > 0) {
+                log('info', `Claimed ${claimed.length} message(s) for product ${productId} (worker: ${WORKER_ID})`);
+                await processProductHumanMessages(claimed, productId, config, verbose);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            log('error', `Error polling product channel ${channelId}: ${msg}`);
         }
     }
 }
@@ -95,6 +114,7 @@ function stopPolling() {
 // ============================================================
 async function handleInit(msg) {
     config = msg.config;
+    verbose = msg.verbose ?? false;
     log('info', `Chat worker initialized (id: ${WORKER_ID})`);
     // Load existing channels before starting the poll loop
     await refreshChannels();
@@ -109,7 +129,8 @@ async function handlePhaseCompleted(msg) {
         // Ensure we have the channel registered
         await ensureFeatureChannel(featureId);
         // Process with AI for next-step suggestions
-        await processPhaseCompletion(featureId, phase, summary, phaseOutput, config);
+        const repoPath = featureRepoPaths.get(featureId);
+        await processPhaseCompletion(featureId, phase, summary, phaseOutput, config, verbose, repoPath);
     }
     catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
@@ -155,16 +176,26 @@ async function handleFeatureDone(msg) {
  */
 async function refreshChannels() {
     try {
-        const channels = await listChannels('feature');
+        // Fetch feature and product channels in parallel
+        const [featureChannels, productChannels] = await Promise.all([
+            listChannels('feature'),
+            listChannels('product'),
+        ]);
         let added = 0;
-        for (const channel of channels) {
+        for (const channel of featureChannels) {
             if (channel.channel_ref_id && !activeChannels.has(channel.channel_ref_id)) {
                 activeChannels.set(channel.channel_ref_id, channel.id);
                 added++;
             }
         }
+        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 (added > 0) {
-            log('info', `Discovered ${added} new channel(s) (total: ${activeChannels.size})`);
+            log('info', `Discovered ${added} new channel(s) (features: ${activeChannels.size}, products: ${activeProductChannels.size})`);
         }
     }
     catch (error) {
@@ -216,6 +247,9 @@ process.on('message', (msg) => {
         // Register a feature channel for polling when a worker starts
         case 'event:feature_started': {
             const startMsg = msg;
+            if (startMsg.repoPath) {
+                featureRepoPaths.set(startMsg.featureId, startMsg.repoPath);
+            }
             ensureFeatureChannel(startMsg.featureId).catch((error) => {
                 log('error', `Channel registration error: ${error instanceof Error ? error.message : String(error)}`);
             });

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

@@ -113,7 +113,7 @@ export class AgentWorkflowProcessor {
                 this.chatWorker = undefined;
             });
             // Initialize the chat worker with config
-            this.chatWorker.send({ type: 'init', config: this.config });
+            this.chatWorker.send({ type: 'init', config: this.config, verbose: this.options.verbose });
             logInfo('Chat worker started');
         }
         catch (error) {
@@ -336,7 +336,7 @@ export class AgentWorkflowProcessor {
                 config: this.config,
             });
             // Notify chat worker that a feature has started processing
-            this.notifyChatWorker({ type: 'event:feature_started', featureId });
+            this.notifyChatWorker({ type: 'event:feature_started', featureId, repoPath });
         }
         catch (error) {
             this.activeWorkers.delete(featureId);

package/dist/config/__tests__/feature-status.test.js

@@ -6,9 +6,9 @@ import assert from 'node:assert';
 import { STATUS_PROGRESSION_ORDER, PHASE_STATUS_MAP, } from '../feature-status.js';
 describe('Feature Status Configuration', () => {
     describe('STATUS_PROGRESSION_ORDER', () => {
-        it('should start with backlog and end with shipped', () => {
+        it('should start with backlog and end with archived', () => {
             assert.strictEqual(STATUS_PROGRESSION_ORDER[0], 'backlog', 'First status should be backlog');
-            assert.strictEqual(STATUS_PROGRESSION_ORDER[STATUS_PROGRESSION_ORDER.length - 1], 'shipped', 'Last status should be shipped');
+            assert.strictEqual(STATUS_PROGRESSION_ORDER[STATUS_PROGRESSION_ORDER.length - 1], 'archived', 'Last status should be archived');
         });
         it('should be readonly', () => {
             // This test ensures the configuration is properly typed as readonly

package/dist/config/feature-status.js

@@ -49,6 +49,7 @@ export const STATUS_PROGRESSION_ORDER = [
     'testing_failed',
     'ready_for_review',
     'shipped',
+    'archived',
 ];
 /**
  * Phase to status mapping
@@ -119,6 +120,7 @@ export const HUMAN_SELECTABLE_STATUSES = [
     'functional_testing',
     'ready_for_review',
     'shipped',
+    'archived',
 ];
 /**
  * Check if a status can be manually selected by a human user

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

@@ -26,9 +26,15 @@ export declare function clearChannelSession(channelId: string): void;
  *
  * Returns the session ID (callers should track this if needed).
  */
-export declare function processHumanMessages(messages: ChatMessage[], featureId: string, config: EdsgerConfig, verbose?: boolean): Promise<string | undefined>;
+export declare function processHumanMessages(messages: ChatMessage[], featureId: string, config: EdsgerConfig, verbose?: boolean, repoPath?: string): Promise<string | undefined>;
+/**
+ * Process one or more human messages from a product channel.
+ * Same session resumption pattern as feature chat, but uses
+ * product context, product prompt, and product tools.
+ */
+export declare function processProductHumanMessages(messages: ChatMessage[], productId: string, config: EdsgerConfig, verbose?: boolean): Promise<string | undefined>;
 /**
  * Process a phase completion event: analyze output and suggest next steps.
  * Resumes the same channel session so AI has full conversation context.
  */
-export declare function processPhaseCompletion(featureId: string, phase: string, summary: string, phaseOutput: unknown, config: EdsgerConfig, verbose?: boolean): Promise<void>;
+export declare function processPhaseCompletion(featureId: string, phase: string, summary: string, phaseOutput: unknown, config: EdsgerConfig, verbose?: boolean, repoPath?: string): Promise<void>;

package/dist/phases/chat-processor/index.js

@@ -15,8 +15,11 @@ import { DEFAULT_MODEL } from '../../constants.js';
 import { logInfo, logError } from '../../utils/logger.js';
 import { sendAiMessage, markMessageProcessed, sendSystemMessage, getFeatureChannel, listChatMessages, } from '../../api/chat.js';
 import { buildChatContext, formatContextForAI } from './context.js';
+import { buildProductChatContext, formatProductContextForAI, } from './product-context.js';
 import { CHAT_RESPONSE_PROMPT, NEXT_STEP_ADVISOR_PROMPT, buildNextStepAdvisorMessage, } from './prompts.js';
+import { PRODUCT_CHAT_RESPONSE_PROMPT } from './product-prompts.js';
 import { createChatMcpServer } from './tools.js';
+import { createProductChatMcpServer } from './product-tools.js';
 // ============================================================
 // Session Management
 // ============================================================
@@ -44,7 +47,7 @@ export function clearChannelSession(channelId) {
  *
  * Returns the session ID (callers should track this if needed).
  */
-export async function processHumanMessages(messages, featureId, config, verbose) {
+export async function processHumanMessages(messages, featureId, config, verbose, repoPath) {
     if (messages.length === 0)
         return undefined;
     const channelId = messages[0].channel_id;
@@ -107,7 +110,7 @@ export async function processHumanMessages(messages, featureId, config, verbose)
             fullPrompt = userPrompt;
         }
         // Run the agent (with resume if we have a session)
-        const result = await runChatAgent(CHAT_RESPONSE_PROMPT, fullPrompt, config, existingSessionId, verbose);
+        const result = await runChatAgent(CHAT_RESPONSE_PROMPT, fullPrompt, config, existingSessionId, verbose, repoPath);
         // Store the session ID for future resumption
         if (result.sessionId) {
             channelSessions.set(channelId, result.sessionId);
@@ -135,7 +138,7 @@ export async function processHumanMessages(messages, featureId, config, verbose)
         if (existingSessionId) {
             logInfo(`Clearing session ${existingSessionId} and retrying without resume`);
             channelSessions.delete(channelId);
-            return processHumanMessages(messages, featureId, config, verbose);
+            return processHumanMessages(messages, featureId, config, verbose, repoPath);
         }
         // Send error message to chat
         try {
@@ -153,11 +156,114 @@ export async function processHumanMessages(messages, featureId, config, verbose)
         return undefined;
     }
 }
+/**
+ * Process one or more human messages from a product channel.
+ * Same session resumption pattern as feature chat, but uses
+ * product context, product prompt, and product tools.
+ */
+export async function processProductHumanMessages(messages, productId, config, verbose) {
+    if (messages.length === 0)
+        return undefined;
+    const channelId = messages[0].channel_id;
+    const existingSessionId = channelSessions.get(channelId);
+    if (verbose) {
+        logInfo(`Processing ${messages.length} product message(s) for channel ${channelId}` +
+            (existingSessionId ? ` (resuming session ${existingSessionId})` : ' (new session)'));
+    }
+    try {
+        // Build the user prompt
+        const messageParts = messages.map((m, i) => {
+            if (messages.length === 1) {
+                return m.content;
+            }
+            return `[Message ${i + 1} from ${m.sender_name}]: ${m.content}`;
+        });
+        const userPrompt = messageParts.join('\n\n');
+        let fullPrompt;
+        if (!existingSessionId) {
+            const context = await buildProductChatContext(productId, channelId, verbose);
+            const contextStr = formatProductContextForAI(context);
+            // Load recent chat history
+            const recentMessages = await listChatMessages(channelId, { limit: 30 }, verbose);
+            const currentIds = new Set(messages.map((m) => m.id));
+            const historyMessages = recentMessages.filter((m) => !currentIds.has(m.id));
+            let historySection = '';
+            if (historyMessages.length > 0) {
+                const historyLines = historyMessages.map((m) => {
+                    const role = m.sender_type === 'ai' ? 'AI' : m.sender_type === 'system' ? 'System' : (m.sender_name || 'User');
+                    return `[${role}]: ${m.content}`;
+                });
+                historySection = [
+                    `## Previous Chat History`,
+                    `The following is the recent conversation history in this channel. Continue the conversation naturally.`,
+                    '',
+                    ...historyLines,
+                    '',
+                ].join('\n');
+            }
+            fullPrompt = [
+                `## Current Product Context`,
+                contextStr,
+                '',
+                `## Channel ID: ${channelId}`,
+                `## Product ID: ${productId}`,
+                '',
+                historySection,
+                `## Human Message`,
+                userPrompt,
+                '',
+                `Respond to this message. Use tools if you need to take actions. Always respond in the chat using the send_chat_message tool.`,
+            ].join('\n');
+        }
+        else {
+            fullPrompt = userPrompt;
+        }
+        // Run the agent with product tools (no cwd — product chat doesn't operate on a repo)
+        const result = await runProductChatAgent(PRODUCT_CHAT_RESPONSE_PROMPT, fullPrompt, config, existingSessionId, verbose);
+        if (result.sessionId) {
+            channelSessions.set(channelId, result.sessionId);
+        }
+        const sentViaTool = result.toolsUsed.has('mcp__edsger-product-chat__send_chat_message');
+        if (result.text && !sentViaTool) {
+            await sendAiMessage(channelId, result.text, {
+                in_response_to: messages[messages.length - 1].id,
+            });
+        }
+        for (const message of messages) {
+            await markMessageProcessed(message.id, verbose);
+        }
+        if (verbose) {
+            logInfo(`All ${messages.length} product message(s) processed successfully`);
+        }
+        return result.sessionId;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logError(`Failed to process product messages: ${msg}`);
+        if (existingSessionId) {
+            logInfo(`Clearing session ${existingSessionId} and retrying without resume`);
+            channelSessions.delete(channelId);
+            return processProductHumanMessages(messages, productId, config, verbose);
+        }
+        try {
+            await sendAiMessage(channelId, `Sorry, I encountered an error processing your message: ${msg}`, {
+                error: true,
+            });
+        }
+        catch {
+            // Ignore error sending error message
+        }
+        for (const message of messages) {
+            await markMessageProcessed(message.id, verbose);
+        }
+        return undefined;
+    }
+}
 /**
  * Process a phase completion event: analyze output and suggest next steps.
  * Resumes the same channel session so AI has full conversation context.
  */
-export async function processPhaseCompletion(featureId, phase, summary, phaseOutput, config, verbose) {
+export async function processPhaseCompletion(featureId, phase, summary, phaseOutput, config, verbose, repoPath) {
     if (verbose) {
         logInfo(`Processing phase completion: ${phase} for feature ${featureId}`);
     }
@@ -215,7 +321,7 @@ export async function processPhaseCompletion(featureId, phase, summary, phaseOut
         // but on resume the system prompt from the original session persists.
         // We still pass the advisor prompt — the SDK will use it for new sessions
         // and ignore it for resumed ones (system prompt is fixed at session creation).
-        const result = await runChatAgent(existingSessionId ? CHAT_RESPONSE_PROMPT : NEXT_STEP_ADVISOR_PROMPT, fullPrompt, config, existingSessionId, verbose);
+        const result = await runChatAgent(existingSessionId ? CHAT_RESPONSE_PROMPT : NEXT_STEP_ADVISOR_PROMPT, fullPrompt, config, existingSessionId, verbose, repoPath);
         // Store session ID
         if (result.sessionId) {
             channelSessions.set(channelId, result.sessionId);
@@ -253,7 +359,7 @@ async function* prompt(userContent) {
  * Claude Code's built-in tools (Read, Write, Bash, Grep, Glob) are also available.
  * Supports session resumption via the `resumeSessionId` parameter.
  */
-async function runChatAgent(systemPrompt, userPrompt, config, resumeSessionId, verbose) {
+async function runChatAgent(systemPrompt, userPrompt, config, resumeSessionId, verbose, cwd) {
     let lastAssistantResponse = '';
     const toolUsed = new Set();
     let sessionId;
@@ -273,6 +379,7 @@ async function runChatAgent(systemPrompt, userPrompt, config, resumeSessionId, v
             mcpServers: {
                 'edsger-chat': chatMcpServer,
             },
+            ...(cwd ? { cwd } : {}),
             ...(resumeSessionId ? { resume: resumeSessionId } : {}),
         },
     })) {
@@ -308,3 +415,61 @@ async function runChatAgent(systemPrompt, userPrompt, config, resumeSessionId, v
         toolsUsed: toolUsed,
     };
 }
+/**
+ * Run the Claude Agent SDK with product chat MCP tools.
+ * Same as runChatAgent but uses product-level tools instead of feature-level tools.
+ * No cwd parameter since product chat doesn't operate on a specific repo.
+ */
+async function runProductChatAgent(systemPrompt, userPrompt, config, resumeSessionId, verbose) {
+    let lastAssistantResponse = '';
+    const toolUsed = new Set();
+    let sessionId;
+    const productChatMcpServer = createProductChatMcpServer();
+    for await (const message of query({
+        prompt: prompt(userPrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 20,
+            permissionMode: 'bypassPermissions',
+            mcpServers: {
+                'edsger-product-chat': productChatMcpServer,
+            },
+            ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+        },
+    })) {
+        if (message.session_id && !sessionId) {
+            sessionId = message.session_id;
+        }
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistantResponse += content.text + '\n';
+                    if (verbose) {
+                        console.log(`🤖 ${content.text}`);
+                    }
+                }
+                else if (content.type === 'tool_use') {
+                    toolUsed.add(content.name);
+                    if (verbose) {
+                        console.log(`🔧 Tool: ${content.name}`);
+                    }
+                }
+            }
+        }
+        if (message.type === 'result') {
+            if (verbose) {
+                logInfo(`Product chat agent completed: ${message.subtype}`);
+            }
+        }
+    }
+    return {
+        text: lastAssistantResponse.trim(),
+        sessionId,
+        toolsUsed: toolUsed,
+    };
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Build context for the product chat AI processor.
+ * Fetches product state, features summary, and recent chat history.
+ */
+import type { ChatMessage } from '../../types/index.js';
+export interface ProductChatContext {
+    productId: string;
+    productName: string;
+    productDescription: string;
+    featuresSummary: {
+        total: number;
+        byStatus: Record<string, number>;
+        features: Array<{
+            id: string;
+            name: string;
+            status: string;
+            description: string;
+        }>;
+    };
+    teamMembers: Array<{
+        id: string;
+        name: string;
+        email: string;
+        role: string;
+    }>;
+    recentChatMessages: ChatMessage[];
+    channelId: string;
+}
+/**
+ * Build the full context for the product chat AI to process a message.
+ */
+export declare function buildProductChatContext(productId: string, channelId: string, verbose?: boolean): Promise<ProductChatContext>;
+/**
+ * Format product context into a string for the AI system prompt.
+ */
+export declare function formatProductContextForAI(context: ProductChatContext): string;

package/dist/phases/chat-processor/product-context.js

@@ -0,0 +1,104 @@
+/**
+ * Build context for the product chat AI processor.
+ * Fetches product state, features summary, and recent chat history.
+ */
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+import { listChatMessages } from '../../api/chat.js';
+/**
+ * Build the full context for the product chat AI to process a message.
+ */
+export async function buildProductChatContext(productId, channelId, verbose) {
+    // Fetch product, features, and team members in parallel
+    const [productResult, featuresResult, membersResult, recentMessages] = await Promise.all([
+        callMcpEndpoint('products/list', {
+            product_id: productId,
+        }),
+        callMcpEndpoint('features/list', {
+            product_id: productId,
+        }),
+        callMcpEndpoint('tasks/product_members', {
+            product_id: productId,
+        }),
+        listChatMessages(channelId, { limit: 20 }, verbose),
+    ]);
+    const products = productResult?.products || productResult?.content?.[0]?.text
+        ? (() => {
+            try {
+                const text = productResult?.content?.[0]?.text;
+                return text ? JSON.parse(text) : productResult?.products || [];
+            }
+            catch {
+                return productResult?.products || [];
+            }
+        })()
+        : [];
+    const product = Array.isArray(products) ? products.find((p) => p.id === productId) || products[0] || {} : products || {};
+    const allFeatures = (featuresResult?.features || []).map((f) => ({
+        id: f.id,
+        name: f.name,
+        status: f.status,
+        description: f.description || '',
+    }));
+    // Count features by status
+    const byStatus = {};
+    for (const f of allFeatures) {
+        byStatus[f.status] = (byStatus[f.status] || 0) + 1;
+    }
+    // Parse members
+    let members = [];
+    try {
+        const membersData = membersResult?.content?.[0]?.text
+            ? JSON.parse(membersResult.content[0].text)
+            : membersResult?.members || membersResult || [];
+        members = Array.isArray(membersData) ? membersData : [];
+    }
+    catch {
+        members = [];
+    }
+    return {
+        productId,
+        productName: product.name || 'Unknown',
+        productDescription: product.description || 'No description',
+        featuresSummary: {
+            total: allFeatures.length,
+            byStatus,
+            features: allFeatures,
+        },
+        teamMembers: members,
+        recentChatMessages: recentMessages,
+        channelId,
+    };
+}
+/**
+ * Format product context into a string for the AI system prompt.
+ */
+export function formatProductContextForAI(context) {
+    const parts = [
+        `## Product: ${context.productName}`,
+        context.productDescription,
+        '',
+        `## Features Summary (${context.featuresSummary.total} total)`,
+        '### By Status:',
+        ...Object.entries(context.featuresSummary.byStatus).map(([status, count]) => `- ${status}: ${count}`),
+        '',
+        '### Features:',
+    ];
+    if (context.featuresSummary.features.length > 0) {
+        for (const f of context.featuresSummary.features) {
+            parts.push(`- [${f.status}] ${f.name}: ${f.description.slice(0, 100)}`);
+        }
+    }
+    else {
+        parts.push('- (no features yet)');
+    }
+    parts.push('', `## Team Members (${context.teamMembers.length})`);
+    if (context.teamMembers.length > 0) {
+        for (const m of context.teamMembers) {
+            parts.push(`- ${m.name || m.email} (${m.role})`);
+        }
+    }
+    else {
+        parts.push('- (no team members)');
+    }
+    return parts.join('\n');
+}

package/dist/phases/chat-processor/product-prompts.d.ts

@@ -0,0 +1,4 @@
+/**
+ * System prompts for the product chat AI processor.
+ */
+export declare const PRODUCT_CHAT_RESPONSE_PROMPT = "You are an AI assistant embedded in Edsger, a software development platform. You are helping a team manage a product at the product level.\n\n## Your Capabilities\nYou can see the product's current state, all features (with statuses), and team members. You have tools to:\n- List features with status filtering\n- Create new features for the product\n- Get detailed feature information (drill down into any feature)\n- Create tasks for team members (human) or AI\n- Look up product team members by name\n- Send follow-up messages and present options to the user\n\n## How to Respond\n1. **Understand the intent** \u2014 Is this a question about product state, a request to create something, or coordination work?\n2. **Take action if needed** \u2014 Use the appropriate tools to make changes\n3. **Respond concisely** \u2014 Summarize what you understood and what you did\n4. **Ask for clarification** \u2014 If the message is ambiguous, use provide_options to present choices\n\n## Communication Style\n- Respond in the same language the user writes in\n- Be concise but thorough \u2014 no filler text\n- Reference specific features, statuses, and team members by name\n- When making changes, always explain what you changed and why\n\n## Product-Level Scope\nUnlike feature chat (which focuses on a single feature's lifecycle), you operate at the product level:\n- Answer cross-feature questions (e.g., \"which features are blocked?\", \"what's our progress?\")\n- Help with product planning and prioritization\n- Create new features when the user describes new work\n- Coordinate team work by creating and assigning tasks\n- Provide product-wide insights and summaries\n\n## Task Creation\nWhen the user asks to notify someone, assign a review, or request action from a team member:\n1. Use list_product_members to find the person by name\n2. Use create_task with executor=\"human\", the resolved user ID, and the correct action_url\n3. Confirm in chat what you created and who it's assigned to\n\nWhen the user describes work for AI to do:\n1. Use create_task with executor=\"ai\" \u2014 the task worker will pick it up automatically\n\n### Action URL Patterns\nAlways set action_url to link to the most relevant page:\n- Product page: `/products/{product_id}`\n- Feature details: `/products/{product_id}/features/{feature_id}`\n- Feature tab: `/products/{product_id}/features/{feature_id}?tab={tab}`\n\n## Important Rules\n- Never make destructive changes without confirmation\n- For ambiguous requests, present options rather than guessing\n- If you can't do something, explain why clearly\n- When creating tasks for people, always confirm the person's identity if the name is ambiguous\n";

package/dist/phases/chat-processor/product-prompts.js

@@ -0,0 +1,55 @@
+/**
+ * System prompts for the product chat AI processor.
+ */
+export const PRODUCT_CHAT_RESPONSE_PROMPT = `You are an AI assistant embedded in Edsger, a software development platform. You are helping a team manage a product at the product level.
+
+## Your Capabilities
+You can see the product's current state, all features (with statuses), and team members. You have tools to:
+- List features with status filtering
+- Create new features for the product
+- Get detailed feature information (drill down into any feature)
+- Create tasks for team members (human) or AI
+- Look up product team members by name
+- Send follow-up messages and present options to the user
+
+## How to Respond
+1. **Understand the intent** — Is this a question about product state, a request to create something, or coordination work?
+2. **Take action if needed** — Use the appropriate tools to make changes
+3. **Respond concisely** — Summarize what you understood and what you did
+4. **Ask for clarification** — If the message is ambiguous, use provide_options to present choices
+
+## Communication Style
+- Respond in the same language the user writes in
+- Be concise but thorough — no filler text
+- Reference specific features, statuses, and team members by name
+- When making changes, always explain what you changed and why
+
+## Product-Level Scope
+Unlike feature chat (which focuses on a single feature's lifecycle), you operate at the product level:
+- Answer cross-feature questions (e.g., "which features are blocked?", "what's our progress?")
+- Help with product planning and prioritization
+- Create new features when the user describes new work
+- Coordinate team work by creating and assigning tasks
+- Provide product-wide insights and summaries
+
+## Task Creation
+When the user asks to notify someone, assign a review, or request action from a team member:
+1. Use list_product_members to find the person by name
+2. Use create_task with executor="human", the resolved user ID, and the correct action_url
+3. Confirm in chat what you created and who it's assigned to
+
+When the user describes work for AI to do:
+1. Use create_task with executor="ai" — the task worker will pick it up automatically
+
+### Action URL Patterns
+Always set action_url to link to the most relevant page:
+- Product page: \`/products/{product_id}\`
+- Feature details: \`/products/{product_id}/features/{feature_id}\`
+- Feature tab: \`/products/{product_id}/features/{feature_id}?tab={tab}\`
+
+## Important Rules
+- Never make destructive changes without confirmation
+- For ambiguous requests, present options rather than guessing
+- If you can't do something, explain why clearly
+- When creating tasks for people, always confirm the person's identity if the name is ambiguous
+`;

package/dist/phases/chat-processor/product-tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Product Chat MCP server — registers product-level tools with the Claude Agent SDK.
+ *
+ * Unlike the feature chat tools which operate on a single feature's lifecycle
+ * (stories, tests, workflow), these tools operate at the product level:
+ * listing features, creating features, managing tasks, and team coordination.
+ */
+/**
+ * Create an in-process MCP server with product-level chat tools.
+ */
+export declare function createProductChatMcpServer(): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;

package/dist/phases/chat-processor/product-tools.js

@@ -0,0 +1,236 @@
+/**
+ * Product Chat MCP server — registers product-level tools with the Claude Agent SDK.
+ *
+ * Unlike the feature chat tools which operate on a single feature's lifecycle
+ * (stories, tests, workflow), these tools operate at the product level:
+ * listing features, creating features, managing tasks, and team coordination.
+ */
+import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+import { sendAiMessage, listChatMessages } from '../../api/chat.js';
+/**
+ * Create an in-process MCP server with product-level chat tools.
+ */
+export function createProductChatMcpServer() {
+    return createSdkMcpServer({
+        name: 'edsger-product-chat',
+        version: '1.0.0',
+        tools: [
+            tool('list_features', 'List all features for the product, optionally filtered by status. Use this to answer questions about product progress, blocked features, etc.', {
+                product_id: z.string().describe('Product ID'),
+                status: z
+                    .string()
+                    .optional()
+                    .describe('Filter by status (e.g., backlog, ready_for_ai, in_progress, shipped)'),
+            }, async (args) => {
+                const params = { product_id: args.product_id };
+                if (args.status) {
+                    params.status = args.status;
+                }
+                const result = await callMcpEndpoint('features/list', params);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }),
+            tool('create_feature', 'Create a new feature for the product. Use when the user describes new work to be added.', {
+                product_id: z.string().describe('Product ID'),
+                name: z.string().describe('Feature name'),
+                description: z.string().describe('Feature description'),
+            }, async (args) => {
+                const result = await callMcpEndpoint('features/create', {
+                    product_id: args.product_id,
+                    name: args.name,
+                    description: args.description,
+                });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }),
+            tool('get_feature_details', 'Get detailed information about a specific feature, including its status, workflow, user stories, and test cases.', {
+                feature_id: z.string().describe('Feature ID'),
+            }, async (args) => {
+                const [featureResult, storiesResult, testCasesResult] = await Promise.all([
+                    callMcpEndpoint('features/get', {
+                        feature_id: args.feature_id,
+                    }),
+                    callMcpEndpoint('user_stories/list', {
+                        feature_id: args.feature_id,
+                    }),
+                    callMcpEndpoint('test_cases/list', {
+                        feature_id: args.feature_id,
+                    }),
+                ]);
+                const feature = featureResult?.features?.[0] || {};
+                const result = {
+                    feature,
+                    user_stories: storiesResult?.user_stories || [],
+                    test_cases: testCasesResult?.test_cases || [],
+                    summary: {
+                        status: feature.status,
+                        execution_mode: feature.execution_mode,
+                        workflow_phases: (feature.workflow || []).map((p) => `${p.phase}: ${p.status}`),
+                    },
+                };
+                return {
+                    content: [
+                        { type: 'text', text: JSON.stringify(result, null, 2) },
+                    ],
+                };
+            }),
+            tool('get_product_overview', 'Get a full product overview: features by status, task counts, team size. Use this for summary questions.', {
+                product_id: z.string().describe('Product ID'),
+            }, async (args) => {
+                const [featuresResult, membersResult] = await Promise.all([
+                    callMcpEndpoint('features/list', {
+                        product_id: args.product_id,
+                    }),
+                    callMcpEndpoint('tasks/product_members', {
+                        product_id: args.product_id,
+                    }),
+                ]);
+                const features = featuresResult?.features || [];
+                const byStatus = {};
+                for (const f of features) {
+                    byStatus[f.status] = (byStatus[f.status] || 0) + 1;
+                }
+                let members = [];
+                try {
+                    const membersData = membersResult?.content?.[0]?.text
+                        ? JSON.parse(membersResult.content[0].text)
+                        : membersResult?.members || membersResult || [];
+                    members = Array.isArray(membersData) ? membersData : [];
+                }
+                catch {
+                    members = [];
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                total_features: features.length,
+                                features_by_status: byStatus,
+                                team_size: members.length,
+                                features: features.map((f) => ({
+                                    id: f.id,
+                                    name: f.name,
+                                    status: f.status,
+                                })),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }),
+            tool('send_chat_message', 'Send a follow-up message to the chat. Use for explanations, summaries, or asking clarifying questions.', {
+                channel_id: z.string().describe('Chat channel ID'),
+                content: z.string().describe('Message content (markdown)'),
+                message_type: z
+                    .enum(['text', 'question', 'answer'])
+                    .optional()
+                    .describe('Type of message'),
+            }, async (args) => {
+                await sendAiMessage(args.channel_id, args.content, {}, {
+                    messageType: args.message_type || 'text',
+                });
+                return {
+                    content: [{ type: 'text', text: 'Message sent successfully.' }],
+                };
+            }),
+            tool('provide_options', 'Present 2-4 actionable options to the user. Each option has a label and description. The user will click one to respond.', {
+                channel_id: z.string().describe('Chat channel ID'),
+                prompt: z
+                    .string()
+                    .describe('Question or context for the options'),
+                options: z.array(z.object({
+                    label: z.string().describe('Short option label'),
+                    description: z.string().describe('What this option does'),
+                    action_key: z
+                        .string()
+                        .describe('Machine-readable key (e.g. "create_feature", "list_blocked")'),
+                })),
+            }, async (args) => {
+                await sendAiMessage(args.channel_id, args.prompt, { options: args.options }, { messageType: 'options' });
+                return {
+                    content: [
+                        { type: 'text', text: 'Options presented to the user.' },
+                    ],
+                };
+            }),
+            tool('get_chat_history', 'Retrieve older chat messages from the channel. Use when you need more context about earlier discussions.', {
+                channel_id: z.string().describe('Chat channel ID'),
+                limit: z
+                    .number()
+                    .optional()
+                    .describe('Number of messages to retrieve (default 50, max 100)'),
+                before: z
+                    .string()
+                    .optional()
+                    .describe('Fetch messages before this ISO timestamp for pagination'),
+            }, async (args) => {
+                const limit = Math.min(args.limit || 50, 100);
+                const messages = await listChatMessages(args.channel_id, { limit, ...(args.before ? { since: args.before } : {}) });
+                const formatted = messages.map((m) => ({
+                    id: m.id,
+                    sender: m.sender_type === 'ai' ? 'AI' : m.sender_type === 'system' ? 'System' : (m.sender_name || 'User'),
+                    sender_type: m.sender_type,
+                    content: m.content,
+                    message_type: m.message_type,
+                    created_at: m.created_at,
+                }));
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ messages: formatted, count: formatted.length }, null, 2),
+                        },
+                    ],
+                };
+            }),
+            tool('create_task', 'Create a task for a team member (human) or for AI to execute.', {
+                product_id: z.string().describe('Product ID'),
+                name: z.string().describe('Short task name'),
+                description: z.string().optional().describe('Detailed description'),
+                executor: z.enum(['ai', 'human']).describe('Who should do this'),
+                assigned_to: z.string().optional().describe('User ID to assign to'),
+                feature_id: z.string().optional().describe('Related feature ID'),
+                action_url: z.string().optional().describe('URL where the assignee should take action'),
+                priority: z.number().optional().describe('1=low, 2=medium, 3=high, 4=urgent'),
+            }, async (args) => {
+                const listResult = (await callMcpEndpoint('tasks/list_for_product', {
+                    product_id: args.product_id,
+                }));
+                const text = listResult?.content?.[0]?.text || '[]';
+                const existingTasks = JSON.parse(text);
+                const nextSequence = existingTasks.length + 1;
+                const actionUrl = args.action_url
+                    || (args.feature_id ? `/products/${args.product_id}/features/${args.feature_id}` : `/products/${args.product_id}`);
+                const result = await callMcpEndpoint('tasks/create', {
+                    product_id: args.product_id,
+                    sequence: nextSequence,
+                    name: args.name,
+                    description: args.description || null,
+                    executor: args.executor,
+                    source: 'system',
+                    assigned_to: args.assigned_to || null,
+                    feature_id: args.feature_id || null,
+                    action_url: actionUrl,
+                    priority: args.priority || (args.executor === 'human' ? 3 : 2),
+                });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }),
+            tool('list_product_members', 'List all members of a product (owner + developers) with their names, emails, and IDs.', {
+                product_id: z.string().describe('Product ID'),
+            }, async (args) => {
+                const result = await callMcpEndpoint('tasks/product_members', {
+                    product_id: args.product_id,
+                });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }),
+        ],
+    });
+}

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

@@ -5,7 +5,7 @@
  * 1. CHAT_RESPONSE_PROMPT — responding to human messages
  * 2. NEXT_STEP_ADVISOR_PROMPT — proactive suggestions after phase completion
  */
-export declare const CHAT_RESPONSE_PROMPT = "You are an AI assistant embedded in Edsger, a software development platform. You are helping a team develop a feature.\n\n## Your Capabilities\nYou can see the feature's current state, user stories, test cases, workflow phases, and code. You have tools to:\n- Modify feature status, execution mode, and workflow phases\n- Create/update user stories and test cases\n- Read and search source code files\n- Send follow-up messages and present options to the user\n- Trigger phase reruns\n- Create tasks for team members (human) or AI\n- Look up product team members by name\n\n## How to Respond\n1. **Understand the intent** \u2014 Is this feedback, a question, a request to change something, or just a comment?\n2. **Take action if needed** \u2014 Use the appropriate tools to make changes\n3. **Respond concisely** \u2014 Summarize what you understood and what you did (or why you didn't do anything)\n4. **Ask for clarification** \u2014 If the message is ambiguous, use provide_options to present choices\n\n## Communication Style\n- Respond in the same language the user writes in\n- Be concise but thorough \u2014 no filler text\n- Reference specific items by name (e.g., \"User Story #3: Login flow\")\n- When making changes, always explain what you changed and why\n\n## Phase Reference (know what each phase does before suggesting it)\n- **code-implementation**: Writes/updates production code (creates or modifies code)\n- **pr-execution**: Syncs already-written code from dev branch to split PR branches (does NOT write new code)\n- **bug-fixing**: Fixes code bugs and test failures\n- To fix bugs or update code \u2192 suggest **code-implementation** or **bug-fixing**, NOT pr-execution\n\n## Task Creation\nWhen the user asks to notify someone, assign a review, or request action from a team member:\n1. Use list_product_members to find the person by name\n2. Use create_task with executor=\"human\", the resolved user ID, and the correct action_url\n3. Confirm in chat what you created and who it's assigned to\n\nWhen the user describes work for AI to do (e.g., \"implement X\", \"fix Y\"):\n1. Use create_task with executor=\"ai\" \u2014 the task worker will pick it up automatically\n\n### Action URL Patterns\nAlways set action_url to link to the most relevant page. Available patterns:\n- Product page: `/products/{product_id}`\n- Feature details: `/products/{product_id}/features/{feature_id}`\n- Feature tab (append ?tab=): `/products/{product_id}/features/{feature_id}?tab={tab}`\n\nAvailable feature tabs:\n- `stories` \u2014 User Stories (use for: review user stories, update stories)\n- `test-cases` \u2014 Test Cases (use for: review test cases, verify tests)\n- `technical-design` \u2014 Technical Design (use for: review design, architecture review)\n- `checklists` \u2014 Checklists (use for: review checklists, quality checks)\n- `branches` \u2014 Branches (use for: code review, branch management)\n- `pull-requests` \u2014 Pull Requests (use for: review PRs, merge requests)\n- `test-reports` \u2014 Test Reports (use for: review test results)\n- `feedbacks` \u2014 Feedbacks (use for: provide feedback)\n- `chat` \u2014 Chat (use for: discussion)\n- `details` \u2014 Feature Details (default)\n\nChoose the tab that best matches the task content. For example:\n- \"review user stories\" \u2192 `?tab=stories`\n- \"review technical design\" \u2192 `?tab=technical-design`\n- \"check test results\" \u2192 `?tab=test-reports`\n\n## Important Rules\n- Never make destructive changes without confirmation (deleting stories, resetting phases)\n- For ambiguous feedback, present options rather than guessing\n- If you can't do something, explain why clearly\n- When creating tasks for people, always confirm the person's identity if the name is ambiguous\n";
+export declare const CHAT_RESPONSE_PROMPT = "You are an AI assistant embedded in Edsger, a software development platform. You are helping a team develop a feature.\n\n## Your Capabilities\nYou can see the feature's current state, user stories, test cases, workflow phases, and code. You have tools to:\n- Modify feature status, execution mode, and workflow phases\n- Create/update user stories and test cases\n- Read, search, edit, and write source code files (Bash, Glob, Grep, Read, Edit, Write)\n- Send follow-up messages and present options to the user\n- Trigger phase reruns\n- Create tasks for team members (human) or AI\n- Look up product team members by name\n\n## How to Respond\n1. **Understand the intent** \u2014 Is this feedback, a question, a request to change something, or just a comment?\n2. **Take action if needed** \u2014 Use the appropriate tools to make changes\n3. **Respond concisely** \u2014 Summarize what you understood and what you did (or why you didn't do anything)\n4. **Ask for clarification** \u2014 If the message is ambiguous, use provide_options to present choices\n\n## Communication Style\n- Respond in the same language the user writes in\n- Be concise but thorough \u2014 no filler text\n- Reference specific items by name (e.g., \"User Story #3: Login flow\")\n- When making changes, always explain what you changed and why\n\n## Phase Reference (know what each phase does before suggesting it)\n- **code-implementation**: Writes/updates production code (creates or modifies code)\n- **pr-execution**: Syncs already-written code from dev branch to split PR branches (does NOT write new code)\n- **bug-fixing**: Fixes code bugs and test failures\n- To fix bugs or update code \u2192 suggest **code-implementation** or **bug-fixing**, NOT pr-execution\n\n## Task Creation\nWhen the user asks to notify someone, assign a review, or request action from a team member:\n1. Use list_product_members to find the person by name\n2. Use create_task with executor=\"human\", the resolved user ID, and the correct action_url\n3. Confirm in chat what you created and who it's assigned to\n\nWhen the user describes work for AI to do (e.g., \"implement X\", \"fix Y\"):\n1. Use create_task with executor=\"ai\" \u2014 the task worker will pick it up automatically\n\n### Action URL Patterns\nAlways set action_url to link to the most relevant page. Available patterns:\n- Product page: `/products/{product_id}`\n- Feature details: `/products/{product_id}/features/{feature_id}`\n- Feature tab (append ?tab=): `/products/{product_id}/features/{feature_id}?tab={tab}`\n\nAvailable feature tabs:\n- `stories` \u2014 User Stories (use for: review user stories, update stories)\n- `test-cases` \u2014 Test Cases (use for: review test cases, verify tests)\n- `technical-design` \u2014 Technical Design (use for: review design, architecture review)\n- `checklists` \u2014 Checklists (use for: review checklists, quality checks)\n- `branches` \u2014 Branches (use for: code review, branch management)\n- `pull-requests` \u2014 Pull Requests (use for: review PRs, merge requests)\n- `test-reports` \u2014 Test Reports (use for: review test results)\n- `feedbacks` \u2014 Feedbacks (use for: provide feedback)\n- `chat` \u2014 Chat (use for: discussion)\n- `details` \u2014 Feature Details (default)\n\nChoose the tab that best matches the task content. For example:\n- \"review user stories\" \u2192 `?tab=stories`\n- \"review technical design\" \u2192 `?tab=technical-design`\n- \"check test results\" \u2192 `?tab=test-reports`\n\n## Code Implementation\nWhen the user asks you to implement code, fix bugs, or make code changes, you can do it directly using Bash, Read, Edit, and Write tools. Follow this workflow:\n\n### Git Workflow\n1. **Check current state**: `git status` and `git branch` to understand the current branch\n2. **Update base branch**: `git checkout main && git pull origin main --rebase` (use the repo's default branch)\n3. **Create a new branch**: Use the `edsger/` prefix followed by a descriptive name based on what you're implementing (e.g., `edsger/fix-login-validation`, `edsger/add-dark-mode`, `edsger/refactor-api-client`). Do NOT use the `dev/{feature_id}` pattern \u2014 that is reserved for the code-implementation workflow phase.\n4. **Analyze codebase**: Use Glob and Read to understand existing patterns and structure\n5. **Implement changes**: Use Edit/Write to modify or create files\n6. **Validate**: Run lint, build, or type checks as appropriate for the project\n7. **Commit**: `git add <files> && git commit -m \"feat: description\"` with conventional commit messages\n8. **Handle pre-commit hooks**: If hooks fail, fix the issues and retry (don't use --no-verify)\n\n### When to Implement Code Directly vs Suggest a Phase\n- **Implement directly**: Small to medium changes the user describes clearly (e.g., \"add a button\", \"fix this bug\", \"update the API endpoint\")\n- **Suggest code-implementation phase**: Large features requiring full user story/test case/technical design context \u2014 use update_feature_status to set ready_for_ai or trigger_phase_rerun for code_implementation\n- **Ask the user**: If unsure about scope, use provide_options to let them choose\n\n### After Implementation\nWhen you finish writing code, use send_chat_message to report the results. Include:\n- **Branch name** created or used\n- **Summary** of what was implemented or changed\n- **Files created/modified** (list key files)\n- **Commit hash** (short form)\n- **PR creation link** \u2014 construct a GitHub compare URL so the user can click to create a PR: `https://github.com/{owner}/{repo}/compare/{base}...{branch}?expand=1`. Get owner/repo from `git remote get-url origin`.\n- **Next steps** \u2014 e.g., review the changes, run tests, or merge the PR\n\n### Implementation Standards\n- Follow existing code patterns and conventions in the repository\n- Use proper TypeScript types and interfaces\n- Handle error cases appropriately\n- Write clean, maintainable code\n- Reference user stories and test cases from the feature context when implementing\n\n## Important Rules\n- Never make destructive changes without confirmation (deleting stories, resetting phases)\n- For ambiguous feedback, present options rather than guessing\n- If you can't do something, explain why clearly\n- When creating tasks for people, always confirm the person's identity if the name is ambiguous\n";
 export declare const NEXT_STEP_ADVISOR_PROMPT = "You are an AI advisor in Edsger, a software development platform. A workflow phase just completed for a feature you're helping develop.\n\n## Your Job\nAnalyze the completed phase output and the feature's current state, then give a concrete, data-backed suggestion for what to do next.\n\n## Critical Rules\n1. **Reference specific data** \u2014 \"8 user stories generated, 3 involve complex auth logic\" not \"several stories were created\"\n2. **Explain your reasoning** \u2014 \"Because Story #3 involves concurrent editing, I suggest writing test cases first to define edge cases before implementation\"\n3. **Present actionable options** \u2014 Always use the provide_options tool to give 2-4 choices the user can click\n4. **Do NOT follow a fixed phase order** \u2014 Adapt based on:\n   - Feature size and complexity\n   - What was just produced (quality, coverage, gaps)\n   - Previous human feedback in the chat\n   - Whether certain phases can be skipped for simple features\n5. **Flag issues proactively** \u2014 If the phase output has gaps, incomplete coverage, or potential problems, call them out\n\n## Phase Reference (know what each phase does before suggesting it)\n- **code-implementation**: Writes/updates production code (the phase that creates or modifies code)\n- **pr-splitting**: Plans how to split code changes into reviewable PRs\n- **pr-execution**: Syncs already-written code from the dev branch to split PR branches (does NOT write new code)\n- **code-testing**: Writes automated tests for implemented code\n- **functional-testing**: Runs end-to-end tests with Playwright\n- **bug-fixing**: Fixes code bugs and test failures\n- **code-review**: Reviews PR code for issues\n- **code-refine**: Updates code based on PR review feedback\n\n**Important distinctions:**\n- To fix bugs or update code \u2192 use **code-implementation** or **bug-fixing**, NOT pr-execution\n- pr-execution only moves existing code to PR branches \u2014 it never creates or modifies implementation code\n\n## Context You Receive\n- Feature description, size, and current state\n- The completed phase name and its full output\n- Remaining workflow phases (with descriptions)\n- User story and test case counts\n- Code change scope (if applicable)\n- Recent chat history (human feedback)\n\n## Communication Style\n- Respond in the same language as recent chat messages (default to the feature's language context)\n- Be specific and data-driven\n- Structure: brief summary \u2192 reasoning \u2192 options\n";
 /**
  * Phase descriptions so the AI advisor understands what each phase does.

package/dist/phases/chat-processor/prompts.js

@@ -11,7 +11,7 @@ export const CHAT_RESPONSE_PROMPT = `You are an AI assistant embedded in Edsger,
 You can see the feature's current state, user stories, test cases, workflow phases, and code. You have tools to:
 - Modify feature status, execution mode, and workflow phases
 - Create/update user stories and test cases
-- Read and search source code files
+- Read, search, edit, and write source code files (Bash, Glob, Grep, Read, Edit, Write)
 - Send follow-up messages and present options to the user
 - Trigger phase reruns
 - Create tasks for team members (human) or AI
@@ -67,6 +67,40 @@ Choose the tab that best matches the task content. For example:
 - "review technical design" → \`?tab=technical-design\`
 - "check test results" → \`?tab=test-reports\`
 
+## Code Implementation
+When the user asks you to implement code, fix bugs, or make code changes, you can do it directly using Bash, Read, Edit, and Write tools. Follow this workflow:
+
+### Git Workflow
+1. **Check current state**: \`git status\` and \`git branch\` to understand the current branch
+2. **Update base branch**: \`git checkout main && git pull origin main --rebase\` (use the repo's default branch)
+3. **Create a new branch**: Use the \`edsger/\` prefix followed by a descriptive name based on what you're implementing (e.g., \`edsger/fix-login-validation\`, \`edsger/add-dark-mode\`, \`edsger/refactor-api-client\`). Do NOT use the \`dev/{feature_id}\` pattern — that is reserved for the code-implementation workflow phase.
+4. **Analyze codebase**: Use Glob and Read to understand existing patterns and structure
+5. **Implement changes**: Use Edit/Write to modify or create files
+6. **Validate**: Run lint, build, or type checks as appropriate for the project
+7. **Commit**: \`git add <files> && git commit -m "feat: description"\` with conventional commit messages
+8. **Handle pre-commit hooks**: If hooks fail, fix the issues and retry (don't use --no-verify)
+
+### When to Implement Code Directly vs Suggest a Phase
+- **Implement directly**: Small to medium changes the user describes clearly (e.g., "add a button", "fix this bug", "update the API endpoint")
+- **Suggest code-implementation phase**: Large features requiring full user story/test case/technical design context — use update_feature_status to set ready_for_ai or trigger_phase_rerun for code_implementation
+- **Ask the user**: If unsure about scope, use provide_options to let them choose
+
+### After Implementation
+When you finish writing code, use send_chat_message to report the results. Include:
+- **Branch name** created or used
+- **Summary** of what was implemented or changed
+- **Files created/modified** (list key files)
+- **Commit hash** (short form)
+- **PR creation link** — construct a GitHub compare URL so the user can click to create a PR: \`https://github.com/{owner}/{repo}/compare/{base}...{branch}?expand=1\`. Get owner/repo from \`git remote get-url origin\`.
+- **Next steps** — e.g., review the changes, run tests, or merge the PR
+
+### Implementation Standards
+- Follow existing code patterns and conventions in the repository
+- Use proper TypeScript types and interfaces
+- Handle error cases appropriately
+- Write clean, maintainable code
+- Reference user stories and test cases from the feature context when implementing
+
 ## Important Rules
 - Never make destructive changes without confirmation (deleting stories, resetting phases)
 - For ambiguous feedback, present options rather than guessing

package/dist/types/index.d.ts

@@ -133,7 +133,7 @@ export interface FeatureAnalysisDisplayResult {
     createdUserStories?: DisplayUserStory[];
     createdTestCases?: DisplayTestCase[];
 }
-export type FeatureStatus = 'backlog' | 'ready_for_ai' | 'assigned_to_ai' | 'feature_analysis' | 'feature_analysis_verification' | 'user_stories_analysis' | 'user_stories_analysis_verification' | 'test_cases_analysis' | 'test_cases_analysis_verification' | 'technical_design' | 'technical_design_verification' | 'branch_planning' | 'branch_planning_verification' | 'code_implementation' | 'code_implementation_verification' | 'pr_splitting' | 'pr_splitting_verification' | 'pr_execution' | 'code_refine' | 'code_refine_verification' | 'bug_fixing' | 'code_review' | 'functional_testing' | 'ready_for_review' | 'shipped' | 'testing_in_progress' | 'testing_passed' | 'testing_failed';
+export type FeatureStatus = 'backlog' | 'ready_for_ai' | 'assigned_to_ai' | 'feature_analysis' | 'feature_analysis_verification' | 'user_stories_analysis' | 'user_stories_analysis_verification' | 'test_cases_analysis' | 'test_cases_analysis_verification' | 'technical_design' | 'technical_design_verification' | 'branch_planning' | 'branch_planning_verification' | 'code_implementation' | 'code_implementation_verification' | 'pr_splitting' | 'pr_splitting_verification' | 'pr_execution' | 'code_refine' | 'code_refine_verification' | 'bug_fixing' | 'code_review' | 'functional_testing' | 'ready_for_review' | 'shipped' | 'testing_in_progress' | 'testing_passed' | 'testing_failed' | 'archived';
 export type ChatChannelType = 'feature' | 'product' | 'general';
 export type ChatMode = 'group' | 'direct' | 'ai_assistant';
 export type ChatSenderType = 'human' | 'ai' | 'system';
@@ -180,6 +180,7 @@ export interface ChatReadStatus {
 export interface ChatWorkerInitMessage {
     type: 'init';
     config: EdsgerConfig;
+    verbose?: boolean;
 }
 export interface ChatWorkerPhaseEvent {
     type: 'event:phase_completed' | 'event:phase_failed' | 'event:feature_done' | 'event:feature_started';
@@ -188,6 +189,7 @@ export interface ChatWorkerPhaseEvent {
     summary?: string;
     phaseOutput?: unknown;
     error?: string;
+    repoPath?: string;
 }
 export interface ChatWorkerCommand {
     type: 'command:pause_feature' | 'command:resume_feature';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.29.2",
+  "version": "0.30.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"