edsger 0.29.3 → 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);
@@ -35,6 +35,8 @@ let pollTimer = null;
 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
@@ -53,20 +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
                 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}`);
         }
     }
 }
@@ -161,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) {

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

@@ -27,6 +27,12 @@ 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, 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.

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
 // ============================================================
@@ -153,6 +156,109 @@ 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.
@@ -309,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;