cyrus-edge-worker 0.0.39 → 0.0.41

package/dist/EdgeWorker.js

@@ -4,7 +4,7 @@ import { basename, dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { LinearClient, } from "@linear/sdk";
 import { watch as chokidarWatch } from "chokidar";
-import { ClaudeRunner, createCyrusToolsServer, createImageToolsServer, createSoraToolsServer, getAllTools, getCoordinatorTools, getReadOnlyTools, getSafeTools, } from "cyrus-claude-runner";
+import { AbortError, ClaudeRunner, createCyrusToolsServer, createImageToolsServer, createSoraToolsServer, getAllTools, getCoordinatorTools, getReadOnlyTools, getSafeTools, } from "cyrus-claude-runner";
 import { isAgentSessionCreatedWebhook, isAgentSessionPromptedWebhook, isIssueAssignedWebhook, isIssueCommentMentionWebhook, isIssueNewCommentWebhook, isIssueUnassignedWebhook, PersistenceManager, } from "cyrus-core";
 import { LinearWebhookClient } from "cyrus-linear-webhook-client";
 import { NdjsonClient } from "cyrus-ndjson-client";
@@ -339,13 +339,38 @@ export class EdgeWorker extends EventEmitter {
             console.warn(`[Parent Session Resume] Could not find child session ${childSessionId} to add workspace to parent allowed directories`);
         }
         await this.postParentResumeAcknowledgment(parentSessionId, repo.id);
-        // Resume the parent session with the child's result
-        console.log(`[Parent Session Resume] Resuming parent Claude session with child results`);
+        // Post thought to Linear showing child result receipt
+        const linearClient = this.linearClients.get(repo.id);
+        if (linearClient && childSession) {
+            const childIssueIdentifier = childSession.issue?.identifier || childSession.issueId;
+            const resultThought = `Received result from sub-issue ${childIssueIdentifier}:\n\n---\n\n${prompt}\n\n---`;
+            try {
+                const result = await linearClient.createAgentActivity({
+                    agentSessionId: parentSessionId,
+                    content: {
+                        type: "thought",
+                        body: resultThought,
+                    },
+                });
+                if (result.success) {
+                    console.log(`[Parent Session Resume] Posted child result receipt thought for parent session ${parentSessionId}`);
+                }
+                else {
+                    console.error(`[Parent Session Resume] Failed to post child result receipt thought:`, result);
+                }
+            }
+            catch (error) {
+                console.error(`[Parent Session Resume] Error posting child result receipt thought:`, error);
+            }
+        }
+        // Use centralized streaming check and routing logic
+        console.log(`[Parent Session Resume] Handling child result for parent session ${parentSessionId}`);
         try {
-            await this.resumeClaudeSession(parentSession, repo, parentSessionId, agentSessionManager, prompt, "", // No attachment manifest for child results
+            await this.handlePromptWithStreamingCheck(parentSession, repo, parentSessionId, agentSessionManager, prompt, "", // No attachment manifest for child results
             false, // Not a new session
-            childWorkspaceDirs);
-            console.log(`[Parent Session Resume] Successfully resumed parent session ${parentSessionId} with child results`);
+            childWorkspaceDirs, // Add child workspace directories to parent's allowed directories
+            "parent resume from child");
+            console.log(`[Parent Session Resume] Successfully handled child result for parent session ${parentSessionId}`);
         }
         catch (error) {
             console.error(`[Parent Session Resume] Failed to resume parent session ${parentSessionId}:`, error);
@@ -1106,71 +1131,66 @@ export class EdgeWorker extends EventEmitter {
         this.procedureRouter.initializeProcedureMetadata(session, finalProcedure);
         // Post single procedure selection result (replaces ephemeral routing thought)
         await agentSessionManager.postProcedureSelectionThought(linearAgentActivitySessionId, finalProcedure.name, finalClassification);
-        // Only determine system prompt for delegation (not mentions) or when /label-based-prompt is requested
-        let systemPrompt;
-        let systemPromptVersion;
-        let promptType;
-        if (!isMentionTriggered || isLabelBasedPromptRequested) {
-            // Determine system prompt based on labels (delegation case or /label-based-prompt command)
-            const systemPromptResult = await this.determineSystemPromptFromLabels(labels, repository);
-            systemPrompt = systemPromptResult?.prompt;
-            systemPromptVersion = systemPromptResult?.version;
-            promptType = systemPromptResult?.type;
-            // Post thought about system prompt selection
-            if (systemPrompt) {
-                await this.postSystemPromptSelectionThought(linearAgentActivitySessionId, labels, repository.id);
-            }
-        }
-        else {
-            console.log(`[EdgeWorker] Skipping system prompt for mention-triggered session ${linearAgentActivitySessionId}`);
-        }
-        // Build allowed tools list with Linear MCP tools (now with prompt type context)
-        const allowedTools = this.buildAllowedTools(repository, promptType);
-        const disallowedTools = this.buildDisallowedTools(repository, promptType);
-        console.log(`[EdgeWorker] Configured allowed tools for ${fullIssue.identifier}:`, allowedTools);
-        if (disallowedTools.length > 0) {
-            console.log(`[EdgeWorker] Configured disallowed tools for ${fullIssue.identifier}:`, disallowedTools);
-        }
-        // Create Claude runner with attachment directory access and optional system prompt
-        const runnerConfig = this.buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, systemPrompt, allowedTools, allowedDirectories, disallowedTools, undefined, // resumeSessionId
-        labels);
-        const runner = new ClaudeRunner(runnerConfig);
-        // Store runner by comment ID
-        agentSessionManager.addClaudeRunner(linearAgentActivitySessionId, runner);
-        // Save state after mapping changes
-        await this.savePersistedState();
-        // Emit events using full Linear issue
-        this.emit("session:started", fullIssue.id, fullIssue, repository.id);
-        this.config.handlers?.onSessionStart?.(fullIssue.id, fullIssue, repository.id);
         // Build and start Claude with initial prompt using full issue (streaming mode)
         console.log(`[EdgeWorker] Building initial prompt for issue ${fullIssue.identifier}`);
         try {
-            // Choose the appropriate prompt builder based on trigger type and system prompt
-            const promptResult = isMentionTriggered && isLabelBasedPromptRequested
-                ? await this.buildLabelBasedPrompt(fullIssue, repository, attachmentResult.manifest, guidance)
-                : isMentionTriggered
-                    ? await this.buildMentionPrompt(fullIssue, agentSession, attachmentResult.manifest, guidance)
-                    : systemPrompt
-                        ? await this.buildLabelBasedPrompt(fullIssue, repository, attachmentResult.manifest, guidance)
-                        : await this.buildPromptV2(fullIssue, repository, undefined, attachmentResult.manifest, guidance);
-            const { prompt, version: userPromptVersion } = promptResult;
-            // Update runner with version information
-            if (userPromptVersion || systemPromptVersion) {
+            // Create input for unified prompt assembly
+            const input = {
+                session,
+                fullIssue,
+                repository,
+                userComment: commentBody || "", // Empty for delegation, present for mentions
+                attachmentManifest: attachmentResult.manifest,
+                guidance,
+                agentSession,
+                labels,
+                isNewSession: true,
+                isStreaming: false, // Not yet streaming
+                isMentionTriggered: isMentionTriggered || false,
+                isLabelBasedPromptRequested: isLabelBasedPromptRequested || false,
+            };
+            // Use unified prompt assembly
+            const assembly = await this.assemblePrompt(input);
+            // Get systemPromptVersion for tracking (TODO: add to PromptAssembly metadata)
+            let systemPromptVersion;
+            let promptType;
+            if (!isMentionTriggered || isLabelBasedPromptRequested) {
+                const systemPromptResult = await this.determineSystemPromptFromLabels(labels, repository);
+                systemPromptVersion = systemPromptResult?.version;
+                promptType = systemPromptResult?.type;
+                // Post thought about system prompt selection
+                if (assembly.systemPrompt) {
+                    await this.postSystemPromptSelectionThought(linearAgentActivitySessionId, labels, repository.id);
+                }
+            }
+            // Build allowed tools list with Linear MCP tools (now with prompt type context)
+            const allowedTools = this.buildAllowedTools(repository, promptType);
+            const disallowedTools = this.buildDisallowedTools(repository, promptType);
+            console.log(`[EdgeWorker] Configured allowed tools for ${fullIssue.identifier}:`, allowedTools);
+            if (disallowedTools.length > 0) {
+                console.log(`[EdgeWorker] Configured disallowed tools for ${fullIssue.identifier}:`, disallowedTools);
+            }
+            // Create Claude runner with system prompt from assembly
+            const runnerConfig = this.buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, assembly.systemPrompt, allowedTools, allowedDirectories, disallowedTools, undefined, // resumeSessionId
+            labels);
+            const runner = new ClaudeRunner(runnerConfig);
+            // Store runner by comment ID
+            agentSessionManager.addClaudeRunner(linearAgentActivitySessionId, runner);
+            // Save state after mapping changes
+            await this.savePersistedState();
+            // Emit events using full Linear issue
+            this.emit("session:started", fullIssue.id, fullIssue, repository.id);
+            this.config.handlers?.onSessionStart?.(fullIssue.id, fullIssue, repository.id);
+            // Update runner with version information (if available)
+            if (systemPromptVersion) {
                 runner.updatePromptVersions({
-                    userPromptVersion,
                     systemPromptVersion,
                 });
             }
-            const promptType = isMentionTriggered && isLabelBasedPromptRequested
-                ? "label-based-prompt-command"
-                : isMentionTriggered
-                    ? "mention"
-                    : systemPrompt
-                        ? "label-based"
-                        : "fallback";
-            console.log(`[EdgeWorker] Initial prompt built successfully using ${promptType} workflow, length: ${prompt.length} characters`);
+            // Log metadata for debugging
+            console.log(`[EdgeWorker] Initial prompt built successfully - components: ${assembly.metadata.components.join(", ")}, type: ${assembly.metadata.promptType}, length: ${assembly.userPrompt.length} characters`);
             console.log(`[EdgeWorker] Starting Claude streaming session`);
-            const sessionInfo = await runner.startStreaming(prompt);
+            const sessionInfo = await runner.startStreaming(assembly.userPrompt);
             console.log(`[EdgeWorker] Claude streaming session started: ${sessionInfo.sessionId}`);
             // Note: AgentSessionManager will be initialized automatically when the first system message
             // is received via handleClaudeMessage() callback
@@ -1235,38 +1255,8 @@ export class EdgeWorker extends EventEmitter {
                 }
             }
         }
-        // Check if runner is actively streaming before routing
-        const existingRunner = session?.claudeRunner;
-        const isStreaming = existingRunner?.isStreaming() || false;
-        // Always route procedure for new comments, UNLESS actively streaming
-        if (!isStreaming) {
-            // Initialize procedure metadata using intelligent routing
-            if (!session.metadata) {
-                session.metadata = {};
-            }
-            // Post ephemeral "Routing..." thought
-            await agentSessionManager.postRoutingThought(linearAgentActivitySessionId);
-            // For prompted events, use the actual prompt content from the user
-            // Combine with issue context for better routing
-            if (!fullIssue) {
-                console.warn(`[EdgeWorker] Routing without full issue details for ${linearAgentActivitySessionId}`);
-            }
-            const promptBody = webhook.agentActivity.content.body;
-            const routingDecision = await this.procedureRouter.determineRoutine(promptBody.trim());
-            const selectedProcedure = routingDecision.procedure;
-            // Initialize procedure metadata in session (resets for each new comment)
-            this.procedureRouter.initializeProcedureMetadata(session, selectedProcedure);
-            // Post procedure selection result (replaces ephemeral routing thought)
-            await agentSessionManager.postProcedureSelectionThought(linearAgentActivitySessionId, selectedProcedure.name, routingDecision.classification);
-            // Log routing decision
-            console.log(`[EdgeWorker] Routing decision for ${linearAgentActivitySessionId} (prompted webhook, ${isNewSession ? "new" : "existing"} session):`);
-            console.log(`  Classification: ${routingDecision.classification}`);
-            console.log(`  Procedure: ${selectedProcedure.name}`);
-            console.log(`  Reasoning: ${routingDecision.reasoning}`);
-        }
-        else {
-            console.log(`[EdgeWorker] Skipping routing for ${linearAgentActivitySessionId} - runner is actively streaming`);
-        }
+        // Note: Routing and streaming check happens later in handlePromptWithStreamingCheck
+        // after attachments are processed
         // Ensure session is not null after creation/retrieval
         if (!session) {
             throw new Error(`Failed to get or create session for agent activity session ${linearAgentActivitySessionId}`);
@@ -1285,6 +1275,8 @@ export class EdgeWorker extends EventEmitter {
         // Ensure directory exists
         await mkdir(attachmentsDir, { recursive: true });
         let attachmentManifest = "";
+        let commentAuthor;
+        let commentTimestamp;
         try {
             const result = await linearClient.client.rawRequest(`
           query GetComment($id: String!) {
@@ -1295,16 +1287,27 @@ export class EdgeWorker extends EventEmitter {
               updatedAt
               user {
                 name
+                displayName
+                email
                 id
               }
             }
           }
         `, { id: commentId });
+            // Extract comment data
+            const comment = result.data.comment;
+            // Extract comment metadata for multi-player context
+            if (comment) {
+                const user = comment.user;
+                commentAuthor =
+                    user?.displayName || user?.name || user?.email || "Unknown";
+                commentTimestamp = comment.createdAt || new Date().toISOString();
+            }
             // Count existing attachments
             const existingFiles = await readdir(attachmentsDir).catch(() => []);
             const existingAttachmentCount = existingFiles.filter((file) => file.startsWith("attachment_") || file.startsWith("image_")).length;
             // Download new attachments from the comment
-            const downloadResult = await this.downloadCommentAttachments(result.data.comment.body, attachmentsDir, repository.linearToken, existingAttachmentCount);
+            const downloadResult = await this.downloadCommentAttachments(comment.body, attachmentsDir, repository.linearToken, existingAttachmentCount);
             if (downloadResult.totalNewAttachments > 0) {
                 attachmentManifest = this.generateNewAttachmentManifest(downloadResult);
             }
@@ -1318,6 +1321,7 @@ export class EdgeWorker extends EventEmitter {
         if (stopSignal) {
             console.log(`[EdgeWorker] Received stop signal for agent activity session ${linearAgentActivitySessionId}`);
             // Stop the existing runner if it's active
+            const existingRunner = session.claudeRunner;
             if (existingRunner) {
                 existingRunner.stop();
                 console.log(`[EdgeWorker] Stopped Claude session for agent activity session ${linearAgentActivitySessionId}`);
@@ -1327,34 +1331,13 @@ export class EdgeWorker extends EventEmitter {
             await agentSessionManager.createResponseActivity(linearAgentActivitySessionId, stopConfirmation);
             return; // Exit early - stop signal handled
         }
-        // Check if there's an existing runner for this comment thread
-        if (existingRunner?.isStreaming()) {
-            // Add comment with attachment manifest to existing stream
-            console.log(`[EdgeWorker] Adding comment to existing stream for agent activity session ${linearAgentActivitySessionId}`);
-            // Append attachment manifest to the prompt if we have one
-            let fullPrompt = promptBody;
-            if (attachmentManifest) {
-                fullPrompt = `${promptBody}\n\n${attachmentManifest}`;
-            }
-            existingRunner.addStreamMessage(fullPrompt);
-            return; // Exit early - comment has been added to stream
-        }
-        // Use the new resumeClaudeSession function
+        // Use centralized streaming check and routing logic
         try {
-            await this.resumeClaudeSession(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest, isNewSession, []);
+            await this.handlePromptWithStreamingCheck(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest, isNewSession, [], // No additional allowed directories for regular continuation
+            `prompted webhook (${isNewSession ? "new" : "existing"} session)`, commentAuthor, commentTimestamp);
         }
         catch (error) {
-            console.error("Failed to continue conversation:", error);
-            // Remove any partially created session
-            // this.sessionManager.removeSession(threadRootCommentId)
-            // this.commentToRepo.delete(threadRootCommentId)
-            // this.commentToIssue.delete(threadRootCommentId)
-            // // Start fresh for root comments, or fall back to issue assignment
-            // if (isRootComment) {
-            //   await this.handleNewRootComment(issue, comment, repository)
-            // } else {
-            //   await this.handleIssueAssigned(issue, repository)
-            // }
+            console.error("Failed to handle prompted webhook:", error);
         }
     }
     /**
@@ -1395,9 +1378,13 @@ export class EdgeWorker extends EventEmitter {
     }
     /**
      * Handle Claude session error
-     * TODO: improve this
+     * Silently ignores AbortError (user-initiated stop), logs other errors
      */
     async handleClaudeError(error) {
+        // AbortError is expected when user stops Claude process, don't log it
+        if (error instanceof AbortError) {
+            return;
+        }
         console.error("Unhandled claude error:", error);
     }
     /**
@@ -1585,10 +1572,12 @@ export class EdgeWorker extends EventEmitter {
     async buildMentionPrompt(issue, agentSession, attachmentManifest = "", guidance) {
         try {
             console.log(`[EdgeWorker] Building mention prompt for issue ${issue.identifier}`);
-            // Get the mention comment body
+            // Get the mention comment metadata
             const mentionContent = agentSession.comment?.body || "";
-            // Build a simple prompt focused on the mention
-            let prompt = `You were mentioned in a Linear comment. Please help with the following request.
+            const authorName = agentSession.creator?.name || agentSession.creator?.id || "Unknown";
+            const timestamp = agentSession.createdAt || new Date().toISOString();
+            // Build a focused prompt with comment metadata
+            let prompt = `You were mentioned in a Linear comment on this issue:
 
 <linear_issue>
   <id>${issue.id}</id>
@@ -1597,11 +1586,15 @@ export class EdgeWorker extends EventEmitter {
   <url>${issue.url}</url>
 </linear_issue>
 
-<mention_request>
+<mention_comment>
+  <author>${authorName}</author>
+  <timestamp>${timestamp}</timestamp>
+  <content>
 ${mentionContent}
-</mention_request>
+  </content>
+</mention_comment>
 
-IMPORTANT: You were specifically mentioned in the comment above. Focus on addressing the specific question or request in the mention. You can use the Linear MCP tools to fetch additional context about the issue if needed.`;
+Focus on addressing the specific request in the mention. You can use the Linear MCP tools to fetch additional context if needed.`;
             // Append agent guidance if present
             prompt += this.formatAgentGuidance(guidance);
             // Append attachment manifest if any
@@ -1817,17 +1810,17 @@ ${reply.body}
      * @param guidance Optional agent guidance rules from Linear
      * @returns Formatted prompt string
      */
-    async buildPromptV2(issue, repository, newComment, attachmentManifest = "", guidance) {
-        console.log(`[EdgeWorker] buildPromptV2 called for issue ${issue.identifier}${newComment ? " with new comment" : ""}`);
+    async buildIssueContextPrompt(issue, repository, newComment, attachmentManifest = "", guidance) {
+        console.log(`[EdgeWorker] buildIssueContextPrompt called for issue ${issue.identifier}${newComment ? " with new comment" : ""}`);
         try {
             // Use custom template if provided (repository-specific takes precedence)
             let templatePath = repository.promptTemplatePath ||
                 this.config.features?.promptTemplatePath;
-            // If no custom template, use the v2 template
+            // If no custom template, use the standard issue assigned user prompt template
             if (!templatePath) {
                 const __filename = fileURLToPath(import.meta.url);
                 const __dirname = dirname(__filename);
-                templatePath = resolve(__dirname, "../prompt-template-v2.md");
+                templatePath = resolve(__dirname, "../prompts/standard-issue-assigned-user-prompt.md");
             }
             // Load the template
             console.log(`[EdgeWorker] Loading prompt template from: ${templatePath}`);
@@ -1913,8 +1906,8 @@ IMPORTANT: Focus specifically on addressing the new comment above. This is a new
                     .replace(/{{new_comment_content}}/g, newComment.body || "");
             }
             else {
-                // Remove the new comment section entirely
-                prompt = prompt.replace(/{{#if new_comment}}[\s\S]*?{{\/if}}/g, "");
+                // Remove the new comment section entirely (including preceding newlines)
+                prompt = prompt.replace(/\n*{{#if new_comment}}[\s\S]*?{{\/if}}/g, "");
             }
             // Append agent guidance if present
             prompt += this.formatAgentGuidance(guidance);
@@ -2481,6 +2474,8 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
                 },
                 onFeedbackDelivery: async (childSessionId, message) => {
                     console.log(`[EdgeWorker] Processing feedback delivery to child session ${childSessionId}`);
+                    // Find the parent session ID for context
+                    const parentSessionId = this.childToParentAgentSession.get(childSessionId);
                     // Find the repository containing the child session
                     // We need to search all repositories for this child session
                     let childRepo;
@@ -2503,22 +2498,62 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
                         return false;
                     }
                     console.log(`[EdgeWorker] Found child session - Issue: ${childSession.issueId}`);
+                    // Get parent session info for better context in the thought
+                    let parentIssueId;
+                    if (parentSessionId) {
+                        // Find parent session across all repositories
+                        for (const manager of this.agentSessionManagers.values()) {
+                            const parentSession = manager.getSession(parentSessionId);
+                            if (parentSession) {
+                                parentIssueId =
+                                    parentSession.issue?.identifier || parentSession.issueId;
+                                break;
+                            }
+                        }
+                    }
+                    // Post thought to Linear showing feedback receipt
+                    const linearClient = this.linearClients.get(childRepo.id);
+                    if (linearClient) {
+                        const feedbackThought = parentIssueId
+                            ? `Received feedback from orchestrator (${parentIssueId}):\n\n---\n\n${message}\n\n---`
+                            : `Received feedback from orchestrator:\n\n---\n\n${message}\n\n---`;
+                        try {
+                            const result = await linearClient.createAgentActivity({
+                                agentSessionId: childSessionId,
+                                content: {
+                                    type: "thought",
+                                    body: feedbackThought,
+                                },
+                            });
+                            if (result.success) {
+                                console.log(`[EdgeWorker] Posted feedback receipt thought for child session ${childSessionId}`);
+                            }
+                            else {
+                                console.error(`[EdgeWorker] Failed to post feedback receipt thought:`, result);
+                            }
+                        }
+                        catch (error) {
+                            console.error(`[EdgeWorker] Error posting feedback receipt thought:`, error);
+                        }
+                    }
                     // Format the feedback as a prompt for the child session with enhanced markdown formatting
                     const feedbackPrompt = `## Received feedback from orchestrator\n\n---\n\n${message}\n\n---`;
-                    // Resume the CHILD session with the feedback from the parent
+                    // Use centralized streaming check and routing logic
                     // Important: We don't await the full session completion to avoid timeouts.
                     // The feedback is delivered immediately when the session starts, so we can
                     // return success right away while the session continues in the background.
-                    this.resumeClaudeSession(childSession, childRepo, childSessionId, childAgentSessionManager, feedbackPrompt, "", // No attachment manifest for feedback
+                    console.log(`[EdgeWorker] Handling feedback delivery to child session ${childSessionId}`);
+                    this.handlePromptWithStreamingCheck(childSession, childRepo, childSessionId, childAgentSessionManager, feedbackPrompt, "", // No attachment manifest for feedback
                     false, // Not a new session
-                    [])
+                    [], // No additional allowed directories for feedback
+                    "give feedback to child")
                         .then(() => {
                         console.log(`[EdgeWorker] Child session ${childSessionId} completed processing feedback`);
                     })
                         .catch((error) => {
-                        console.error(`[EdgeWorker] Failed to complete child session with feedback:`, error);
+                        console.error(`[EdgeWorker] Failed to process feedback in child session:`, error);
                     });
-                    // Return success immediately after initiating the session
+                    // Return success immediately after initiating the handling
                     console.log(`[EdgeWorker] Feedback delivered successfully to child session ${childSessionId}`);
                     return true;
                 },
@@ -2562,22 +2597,268 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
         }
     }
     /**
-     * Build prompt for a session - handles both new and existing sessions
+     * Build the complete prompt for a session - shows full prompt assembly in one place
+     *
+     * New session prompt structure:
+     * 1. Issue context (from buildIssueContextPrompt)
+     * 2. Initial subroutine prompt (if procedure initialized)
+     * 3. User comment
+     *
+     * Existing session prompt structure:
+     * 1. User comment
+     * 2. Attachment manifest (if present)
+     */
+    async buildSessionPrompt(isNewSession, session, fullIssue, repository, promptBody, attachmentManifest, commentAuthor, commentTimestamp) {
+        // Fetch labels for system prompt determination
+        const labels = await this.fetchIssueLabels(fullIssue);
+        // Create input for unified prompt assembly
+        const input = {
+            session,
+            fullIssue,
+            repository,
+            userComment: promptBody,
+            commentAuthor,
+            commentTimestamp,
+            attachmentManifest,
+            isNewSession,
+            isStreaming: false, // This path is only for non-streaming prompts
+            labels,
+        };
+        // Use unified prompt assembly
+        const assembly = await this.assemblePrompt(input);
+        // Log metadata for debugging
+        console.log(`[EdgeWorker] Built prompt - components: ${assembly.metadata.components.join(", ")}, type: ${assembly.metadata.promptType}`);
+        return assembly.userPrompt;
+    }
+    /**
+     * Assemble a complete prompt - unified entry point for all prompt building
+     * This method contains all prompt assembly logic in one place
+     */
+    async assemblePrompt(input) {
+        // If actively streaming, just pass through the comment
+        if (input.isStreaming) {
+            return this.buildStreamingPrompt(input);
+        }
+        // If new session, build full prompt with all components
+        if (input.isNewSession) {
+            return this.buildNewSessionPrompt(input);
+        }
+        // Existing session continuation - just user comment + attachments
+        return this.buildContinuationPrompt(input);
+    }
+    /**
+     * Build prompt for actively streaming session - pass through user comment as-is
+     */
+    buildStreamingPrompt(input) {
+        const components = ["user-comment"];
+        if (input.attachmentManifest) {
+            components.push("attachment-manifest");
+        }
+        const parts = [input.userComment];
+        if (input.attachmentManifest) {
+            parts.push(input.attachmentManifest);
+        }
+        return {
+            systemPrompt: undefined,
+            userPrompt: parts.join("\n\n"),
+            metadata: {
+                components,
+                promptType: "continuation",
+                isNewSession: false,
+                isStreaming: true,
+            },
+        };
+    }
+    /**
+     * Build prompt for new session - includes issue context, subroutine prompt, and user comment
      */
-    async buildSessionPrompt(isNewSession, fullIssue, repository, promptBody, attachmentManifest) {
-        if (isNewSession) {
-            // For completely new sessions, create a complete initial prompt
-            const promptResult = await this.buildPromptV2(fullIssue, repository, undefined, attachmentManifest);
-            // Add the user's comment to the initial prompt
-            return `${promptResult.prompt}\n\nUser comment: ${promptBody}`;
+    async buildNewSessionPrompt(input) {
+        const components = [];
+        const parts = [];
+        // 1. Determine system prompt from labels
+        // Only for delegation (not mentions) or when /label-based-prompt is requested
+        let labelBasedSystemPrompt;
+        if (!input.isMentionTriggered || input.isLabelBasedPromptRequested) {
+            labelBasedSystemPrompt = await this.determineSystemPromptForAssembly(input.labels || [], input.repository);
+        }
+        // 2. Determine system prompt based on prompt type
+        // Label-based: Use only the label-based system prompt
+        // Fallback: Use scenarios system prompt (shared instructions)
+        let systemPrompt;
+        if (labelBasedSystemPrompt) {
+            // Use label-based system prompt as-is (no shared instructions)
+            systemPrompt = labelBasedSystemPrompt;
         }
         else {
-            // For existing sessions, just use the comment with attachment manifest
-            const manifestSuffix = attachmentManifest
-                ? `\n\n${attachmentManifest}`
-                : "";
-            return `${promptBody}${manifestSuffix}`;
+            // Use scenarios system prompt for fallback cases
+            const sharedInstructions = await this.loadSharedInstructions();
+            systemPrompt = sharedInstructions;
+        }
+        // 3. Build issue context using appropriate builder
+        // Use label-based prompt ONLY if we have a label-based system prompt
+        const promptType = this.determinePromptType(input, !!labelBasedSystemPrompt);
+        const issueContext = await this.buildIssueContextForPromptAssembly(input.fullIssue, input.repository, promptType, input.attachmentManifest, input.guidance, input.agentSession);
+        parts.push(issueContext.prompt);
+        components.push("issue-context");
+        // 4. Load and append initial subroutine prompt
+        const currentSubroutine = this.procedureRouter.getCurrentSubroutine(input.session);
+        let subroutineName;
+        if (currentSubroutine) {
+            const subroutinePrompt = await this.loadSubroutinePrompt(currentSubroutine);
+            if (subroutinePrompt) {
+                parts.push(subroutinePrompt);
+                components.push("subroutine-prompt");
+                subroutineName = currentSubroutine.name;
+            }
+        }
+        // 5. Add user comment (if present)
+        // Skip for mention-triggered prompts since the comment is already in the mention block
+        if (input.userComment.trim() && !input.isMentionTriggered) {
+            // If we have author/timestamp metadata, include it for multi-player context
+            if (input.commentAuthor || input.commentTimestamp) {
+                const author = input.commentAuthor || "Unknown";
+                const timestamp = input.commentTimestamp || new Date().toISOString();
+                parts.push(`<user_comment>
+  <author>${author}</author>
+  <timestamp>${timestamp}</timestamp>
+  <content>
+${input.userComment}
+  </content>
+</user_comment>`);
+            }
+            else {
+                // Legacy format without metadata
+                parts.push(`<user_comment>\n${input.userComment}\n</user_comment>`);
+            }
+            components.push("user-comment");
+        }
+        // 6. Add guidance rules (if present)
+        if (input.guidance && input.guidance.length > 0) {
+            components.push("guidance-rules");
         }
+        return {
+            systemPrompt,
+            userPrompt: parts.join("\n\n"),
+            metadata: {
+                components,
+                subroutineName,
+                promptType,
+                isNewSession: true,
+                isStreaming: false,
+            },
+        };
+    }
+    /**
+     * Build prompt for existing session continuation - user comment and attachments only
+     */
+    buildContinuationPrompt(input) {
+        const components = ["user-comment"];
+        if (input.attachmentManifest) {
+            components.push("attachment-manifest");
+        }
+        // Wrap comment in XML with author and timestamp for multi-player context
+        const author = input.commentAuthor || "Unknown";
+        const timestamp = input.commentTimestamp || new Date().toISOString();
+        const commentXml = `<new_comment>
+  <author>${author}</author>
+  <timestamp>${timestamp}</timestamp>
+  <content>
+${input.userComment}
+  </content>
+</new_comment>`;
+        const parts = [commentXml];
+        if (input.attachmentManifest) {
+            parts.push(input.attachmentManifest);
+        }
+        return {
+            systemPrompt: undefined,
+            userPrompt: parts.join("\n\n"),
+            metadata: {
+                components,
+                promptType: "continuation",
+                isNewSession: false,
+                isStreaming: false,
+            },
+        };
+    }
+    /**
+     * Determine the prompt type based on input flags and system prompt availability
+     */
+    determinePromptType(input, hasSystemPrompt) {
+        if (input.isMentionTriggered && input.isLabelBasedPromptRequested) {
+            return "label-based-prompt-command";
+        }
+        if (input.isMentionTriggered) {
+            return "mention";
+        }
+        if (hasSystemPrompt) {
+            return "label-based";
+        }
+        return "fallback";
+    }
+    /**
+     * Load a subroutine prompt file
+     * Extracted helper to make prompt assembly more readable
+     */
+    async loadSubroutinePrompt(subroutine) {
+        // Skip loading for "primary" - it's a placeholder that doesn't have a file
+        if (subroutine.promptPath === "primary") {
+            return null;
+        }
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const subroutinePromptPath = join(__dirname, "prompts", subroutine.promptPath);
+        try {
+            const prompt = await readFile(subroutinePromptPath, "utf-8");
+            console.log(`[EdgeWorker] Loaded ${subroutine.name} subroutine prompt (${prompt.length} characters)`);
+            return prompt;
+        }
+        catch (error) {
+            console.warn(`[EdgeWorker] Failed to load subroutine prompt from ${subroutinePromptPath}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Load shared instructions that get appended to all system prompts
+     */
+    async loadSharedInstructions() {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const instructionsPath = join(__dirname, "..", "prompts", "todolist-system-prompt-extension.md");
+        try {
+            const instructions = await readFile(instructionsPath, "utf-8");
+            return instructions;
+        }
+        catch (error) {
+            console.error(`[EdgeWorker] Failed to load shared instructions from ${instructionsPath}:`, error);
+            return ""; // Return empty string if file can't be loaded
+        }
+    }
+    /**
+     * Adapter method for prompt assembly - extracts just the prompt string
+     */
+    async determineSystemPromptForAssembly(labels, repository) {
+        const result = await this.determineSystemPromptFromLabels(labels, repository);
+        return result?.prompt;
+    }
+    /**
+     * Adapter method for prompt assembly - routes to appropriate issue context builder
+     */
+    async buildIssueContextForPromptAssembly(issue, repository, promptType, attachmentManifest, guidance, agentSession) {
+        // Delegate to appropriate builder based on promptType
+        if (promptType === "mention") {
+            if (!agentSession) {
+                throw new Error("agentSession is required for mention-triggered prompts");
+            }
+            return this.buildMentionPrompt(issue, agentSession, attachmentManifest, guidance);
+        }
+        if (promptType === "label-based" ||
+            promptType === "label-based-prompt-command") {
+            return this.buildLabelBasedPrompt(issue, repository, attachmentManifest, guidance);
+        }
+        // Fallback to standard issue context
+        return this.buildIssueContextPrompt(issue, repository, undefined, // No new comment for initial prompt assembly
+        attachmentManifest, guidance);
     }
     /**
      * Build Claude runner configuration with common settings
@@ -2879,6 +3160,113 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
             console.error(`[EdgeWorker] Error posting parent resumption acknowledgment:`, error);
         }
     }
+    /**
+     * Re-route procedure for a session (used when resuming from child or give feedback)
+     * This ensures the currentSubroutine is reset to avoid suppression issues
+     */
+    async rerouteProcedureForSession(session, linearAgentActivitySessionId, agentSessionManager, promptBody, repository) {
+        // Initialize procedure metadata using intelligent routing
+        if (!session.metadata) {
+            session.metadata = {};
+        }
+        // Post ephemeral "Routing..." thought
+        await agentSessionManager.postRoutingThought(linearAgentActivitySessionId);
+        // Fetch full issue and labels to check for Orchestrator label override
+        const linearClient = this.linearClients.get(repository.id);
+        let hasOrchestratorLabel = false;
+        if (linearClient) {
+            try {
+                const fullIssue = await linearClient.issue(session.issueId);
+                const labels = await this.fetchIssueLabels(fullIssue);
+                // Check for Orchestrator label (same logic as initial routing)
+                const orchestratorConfig = repository.labelPrompts?.orchestrator;
+                const orchestratorLabels = Array.isArray(orchestratorConfig)
+                    ? orchestratorConfig
+                    : orchestratorConfig?.labels;
+                hasOrchestratorLabel =
+                    orchestratorLabels?.some((label) => labels.includes(label)) || false;
+            }
+            catch (error) {
+                console.error(`[EdgeWorker] Failed to fetch issue labels for routing:`, error);
+                // Continue with AI routing if label fetch fails
+            }
+        }
+        let selectedProcedure;
+        let finalClassification;
+        // If Orchestrator label is present, ALWAYS use orchestrator-full procedure
+        if (hasOrchestratorLabel) {
+            const orchestratorProcedure = this.procedureRouter.getProcedure("orchestrator-full");
+            if (!orchestratorProcedure) {
+                throw new Error("orchestrator-full procedure not found in registry");
+            }
+            selectedProcedure = orchestratorProcedure;
+            finalClassification = "orchestrator";
+            console.log(`[EdgeWorker] Using orchestrator-full procedure due to Orchestrator label (skipping AI routing)`);
+        }
+        else {
+            // No Orchestrator label - use AI routing based on prompt content
+            const routingDecision = await this.procedureRouter.determineRoutine(promptBody.trim());
+            selectedProcedure = routingDecision.procedure;
+            finalClassification = routingDecision.classification;
+            // Log AI routing decision
+            console.log(`[EdgeWorker] AI routing decision for ${linearAgentActivitySessionId}:`);
+            console.log(`  Classification: ${routingDecision.classification}`);
+            console.log(`  Procedure: ${selectedProcedure.name}`);
+            console.log(`  Reasoning: ${routingDecision.reasoning}`);
+        }
+        // Initialize procedure metadata in session (resets currentSubroutine)
+        this.procedureRouter.initializeProcedureMetadata(session, selectedProcedure);
+        // Post procedure selection result (replaces ephemeral routing thought)
+        await agentSessionManager.postProcedureSelectionThought(linearAgentActivitySessionId, selectedProcedure.name, finalClassification);
+    }
+    /**
+     * Handle prompt with streaming check - centralized logic for all input types
+     *
+     * This method implements the unified pattern for handling prompts:
+     * 1. Check if runner is actively streaming
+     * 2. Route procedure if NOT streaming (resets currentSubroutine)
+     * 3. Add to stream if streaming, OR resume session if not
+     *
+     * @param session The Cyrus agent session
+     * @param repository Repository configuration
+     * @param linearAgentActivitySessionId Linear agent activity session ID
+     * @param agentSessionManager Agent session manager instance
+     * @param promptBody The prompt text to send
+     * @param attachmentManifest Optional attachment manifest to append
+     * @param isNewSession Whether this is a new session
+     * @param additionalAllowedDirs Additional directories to allow access to
+     * @param logContext Context string for logging (e.g., "prompted webhook", "parent resume")
+     * @returns true if message was added to stream, false if session was resumed
+     */
+    async handlePromptWithStreamingCheck(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest, isNewSession, additionalAllowedDirs, logContext, commentAuthor, commentTimestamp) {
+        // Check if runner is actively streaming before routing
+        const existingRunner = session.claudeRunner;
+        const isStreaming = existingRunner?.isStreaming() || false;
+        // Always route procedure for new input, UNLESS actively streaming
+        if (!isStreaming) {
+            await this.rerouteProcedureForSession(session, linearAgentActivitySessionId, agentSessionManager, promptBody, repository);
+            console.log(`[EdgeWorker] Routed procedure for ${logContext}`);
+        }
+        else {
+            console.log(`[EdgeWorker] Skipping routing for ${linearAgentActivitySessionId} (${logContext}) - runner is actively streaming`);
+        }
+        // Handle streaming case - add message to existing stream
+        if (existingRunner?.isStreaming()) {
+            console.log(`[EdgeWorker] Adding prompt to existing stream for ${linearAgentActivitySessionId} (${logContext})`);
+            // Append attachment manifest to the prompt if we have one
+            let fullPrompt = promptBody;
+            if (attachmentManifest) {
+                fullPrompt = `${promptBody}\n\n${attachmentManifest}`;
+            }
+            existingRunner.addStreamMessage(fullPrompt);
+            return true; // Message added to stream
+        }
+        // Not streaming - resume/start session
+        console.log(`[EdgeWorker] Resuming Claude session for ${linearAgentActivitySessionId} (${logContext})`);
+        await this.resumeClaudeSession(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest, isNewSession, additionalAllowedDirs, undefined, // maxTurns
+        commentAuthor, commentTimestamp);
+        return false; // Session was resumed
+    }
     /**
      * Post thought about system prompt selection based on labels
      */
@@ -2975,7 +3363,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
      * @param attachmentManifest Optional attachment manifest
      * @param isNewSession Whether this is a new session
      */
-    async resumeClaudeSession(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest = "", isNewSession = false, additionalAllowedDirectories = [], maxTurns) {
+    async resumeClaudeSession(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest = "", isNewSession = false, additionalAllowedDirectories = [], maxTurns, commentAuthor, commentTimestamp) {
         // Check for existing runner
         const existingRunner = session.claudeRunner;
         // If there's an existing streaming runner, add to it
@@ -3027,7 +3415,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
         // Save state
         await this.savePersistedState();
         // Prepare the full prompt
-        const fullPrompt = await this.buildSessionPrompt(isNewSession, fullIssue, repository, promptBody, attachmentManifest);
+        const fullPrompt = await this.buildSessionPrompt(isNewSession, session, fullIssue, repository, promptBody, attachmentManifest, commentAuthor, commentTimestamp);
         // Start streaming session
         try {
             await runner.startStreaming(fullPrompt);