cyrus-edge-worker 0.0.39 → 0.2.0-rc

package/dist/EdgeWorker.js

@@ -5,9 +5,9 @@ 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 { isAgentSessionCreatedWebhook, isAgentSessionPromptedWebhook, isIssueAssignedWebhook, isIssueCommentMentionWebhook, isIssueNewCommentWebhook, isIssueUnassignedWebhook, PersistenceManager, } from "cyrus-core";
-import { LinearWebhookClient } from "cyrus-linear-webhook-client";
-import { NdjsonClient } from "cyrus-ndjson-client";
+import { ConfigUpdater } from "cyrus-config-updater";
+import { DEFAULT_PROXY_URL, isAgentSessionCreatedWebhook, isAgentSessionPromptedWebhook, isIssueAssignedWebhook, isIssueCommentMentionWebhook, isIssueNewCommentWebhook, isIssueUnassignedWebhook, PersistenceManager, resolvePath, } from "cyrus-core";
+import { LinearEventTransport } from "cyrus-linear-event-transport";
 import { fileTypeFromBuffer } from "file-type";
 import { AgentSessionManager } from "./AgentSessionManager.js";
 import { ProcedureRouter, } from "./procedures/index.js";
@@ -23,7 +23,8 @@ export class EdgeWorker extends EventEmitter {
     repositories = new Map(); // repository 'id' (internal, stored in config.json) mapped to the full repo config
     agentSessionManagers = new Map(); // Maps repository ID to AgentSessionManager, which manages ClaudeRunners for a repo
     linearClients = new Map(); // one linear client per 'repository'
-    ndjsonClients = new Map(); // listeners for webhook events, one per linear token
+    linearEventTransport = null; // Single event transport for webhook delivery
+    configUpdater = null; // Single config updater for configuration updates
     persistenceManager;
     sharedApplicationServer;
     cyrusHome;
@@ -31,7 +32,6 @@ export class EdgeWorker extends EventEmitter {
     procedureRouter; // Intelligent workflow routing
     configWatcher; // File watcher for config.json
     configPath; // Path to config.json file
-    tokenToRepoIds = new Map(); // Maps Linear token to repository IDs using that token
     constructor(config) {
         super();
         this.config = config;
@@ -48,15 +48,28 @@ export class EdgeWorker extends EventEmitter {
         // Initialize shared application server
         const serverPort = config.serverPort || config.webhookPort || 3456;
         const serverHost = config.serverHost || "localhost";
-        this.sharedApplicationServer = new SharedApplicationServer(serverPort, serverHost, config.ngrokAuthToken, config.proxyUrl);
-        // Register OAuth callback handler if provided
-        if (config.handlers?.onOAuthCallback) {
-            this.sharedApplicationServer.registerOAuthCallbackHandler(config.handlers.onOAuthCallback);
-        }
-        // Initialize repositories
+        this.sharedApplicationServer = new SharedApplicationServer(serverPort, serverHost);
+        // Initialize repositories with path resolution
         for (const repo of config.repositories) {
             if (repo.isActive !== false) {
-                this.repositories.set(repo.id, repo);
+                // Resolve paths that may contain tilde (~) prefix
+                const resolvedRepo = {
+                    ...repo,
+                    repositoryPath: resolvePath(repo.repositoryPath),
+                    workspaceBaseDir: resolvePath(repo.workspaceBaseDir),
+                    mcpConfigPath: Array.isArray(repo.mcpConfigPath)
+                        ? repo.mcpConfigPath.map(resolvePath)
+                        : repo.mcpConfigPath
+                            ? resolvePath(repo.mcpConfigPath)
+                            : undefined,
+                    promptTemplatePath: repo.promptTemplatePath
+                        ? resolvePath(repo.promptTemplatePath)
+                        : undefined,
+                    openaiOutputDirectory: repo.openaiOutputDirectory
+                        ? resolvePath(repo.openaiOutputDirectory)
+                        : undefined,
+                };
+                this.repositories.set(repo.id, resolvedRepo);
                 // Create Linear client for this repository's workspace
                 const linearClient = new LinearClient({
                     accessToken: repo.linearToken,
@@ -123,77 +136,7 @@ export class EdgeWorker extends EventEmitter {
                 this.agentSessionManagers.set(repo.id, agentSessionManager);
             }
         }
-        // Group repositories by token to minimize NDJSON connections
-        const tokenToRepos = new Map();
-        for (const repo of this.repositories.values()) {
-            const repos = tokenToRepos.get(repo.linearToken) || [];
-            repos.push(repo);
-            tokenToRepos.set(repo.linearToken, repos);
-            // Track token-to-repo-id mapping for dynamic config updates
-            const repoIds = this.tokenToRepoIds.get(repo.linearToken) || [];
-            if (!repoIds.includes(repo.id)) {
-                repoIds.push(repo.id);
-            }
-            this.tokenToRepoIds.set(repo.linearToken, repoIds);
-        }
-        // Create one NDJSON client per unique token using shared application server
-        for (const [token, repos] of tokenToRepos) {
-            if (!repos || repos.length === 0)
-                continue;
-            const firstRepo = repos[0];
-            if (!firstRepo)
-                continue;
-            const primaryRepoId = firstRepo.id;
-            // Determine which client to use based on environment variable
-            const useLinearDirectWebhooks = process.env.LINEAR_DIRECT_WEBHOOKS?.toLowerCase().trim() === "true";
-            const clientConfig = {
-                proxyUrl: config.proxyUrl,
-                token: token,
-                name: repos.map((r) => r.name).join(", "), // Pass repository names
-                transport: "webhook",
-                // Use shared application server instead of individual servers
-                useExternalWebhookServer: true,
-                externalWebhookServer: this.sharedApplicationServer,
-                webhookPort: serverPort, // All clients use same port
-                webhookPath: "/webhook",
-                webhookHost: serverHost,
-                ...(config.baseUrl && { webhookBaseUrl: config.baseUrl }),
-                // Legacy fallback support
-                ...(!config.baseUrl &&
-                    config.webhookBaseUrl && { webhookBaseUrl: config.webhookBaseUrl }),
-                onConnect: () => this.handleConnect(primaryRepoId, repos),
-                onDisconnect: (reason) => this.handleDisconnect(primaryRepoId, repos, reason),
-                onError: (error) => this.handleError(error),
-            };
-            // Create the appropriate client based on configuration
-            const ndjsonClient = useLinearDirectWebhooks
-                ? new LinearWebhookClient({
-                    ...clientConfig,
-                    onWebhook: (payload) => {
-                        // Get fresh repositories for this token to avoid stale closures
-                        const freshRepos = this.getRepositoriesForToken(token);
-                        this.handleWebhook(payload, freshRepos);
-                    },
-                })
-                : new NdjsonClient(clientConfig);
-            // Set up webhook handler for NdjsonClient (LinearWebhookClient uses onWebhook in constructor)
-            if (!useLinearDirectWebhooks) {
-                ndjsonClient.on("webhook", (data) => {
-                    // Get fresh repositories for this token to avoid stale closures
-                    const freshRepos = this.getRepositoriesForToken(token);
-                    this.handleWebhook(data, freshRepos);
-                });
-            }
-            // Optional heartbeat logging (only for NdjsonClient)
-            if (process.env.DEBUG_EDGE === "true" && !useLinearDirectWebhooks) {
-                ndjsonClient.on("heartbeat", () => {
-                    console.log(`❤️ Heartbeat received for token ending in ...${token.slice(-4)}`);
-                });
-            }
-            // Store with the first repo's ID as the key (for error messages)
-            // But also store the token mapping for lookup
-            this.ndjsonClients.set(primaryRepoId, ndjsonClient);
-        }
+        // Components will be initialized and registered in start() method before server starts
     }
     /**
      * Start the edge worker
@@ -205,52 +148,53 @@ export class EdgeWorker extends EventEmitter {
         if (this.configPath) {
             this.startConfigWatcher();
         }
-        // Start shared application server first
+        // Initialize and register components BEFORE starting server (routes must be registered before listen())
+        await this.initializeComponents();
+        // Start shared application server (this also starts Cloudflare tunnel if CLOUDFLARE_TOKEN is set)
         await this.sharedApplicationServer.start();
-        // Connect all NDJSON clients
-        const connections = Array.from(this.ndjsonClients.entries()).map(async ([repoId, client]) => {
-            try {
-                await client.connect();
-            }
-            catch (error) {
-                const repoConfig = this.config.repositories.find((r) => r.id === repoId);
-                const repoName = repoConfig?.name || repoId;
-                // Check if it's an authentication error
-                if (error.isAuthError || error.code === "LINEAR_AUTH_FAILED") {
-                    console.error(`\n❌ Linear authentication failed for repository: ${repoName}`);
-                    console.error(`   Workspace: ${repoConfig?.linearWorkspaceName || repoConfig?.linearWorkspaceId || "Unknown"}`);
-                    console.error(`   Error: ${error.message}`);
-                    console.error(`\n   To fix this issue:`);
-                    console.error(`   1. Run: cyrus refresh-token`);
-                    console.error(`   2. Complete the OAuth flow in your browser`);
-                    console.error(`   3. The configuration will be automatically updated\n`);
-                    console.error(`   You can also check all tokens with: cyrus check-tokens\n`);
-                    // Continue with other repositories instead of failing completely
-                    return { repoId, success: false, error };
-                }
-                // For other errors, still log but with less guidance
-                console.error(`\n❌ Failed to connect repository: ${repoName}`);
-                console.error(`   Error: ${error.message}\n`);
-                return { repoId, success: false, error };
-            }
-            return { repoId, success: true };
+    }
+    /**
+     * Initialize and register components (routes) before server starts
+     */
+    async initializeComponents() {
+        // Get the first active repository for configuration
+        const firstRepo = Array.from(this.repositories.values())[0];
+        if (!firstRepo) {
+            throw new Error("No active repositories configured");
+        }
+        // 1. Create and register LinearEventTransport
+        const useDirectWebhooks = process.env.LINEAR_DIRECT_WEBHOOKS?.toLowerCase() === "true";
+        const verificationMode = useDirectWebhooks ? "direct" : "proxy";
+        // Get appropriate secret based on mode
+        const secret = useDirectWebhooks
+            ? process.env.LINEAR_WEBHOOK_SECRET || ""
+            : process.env.CYRUS_API_KEY || "";
+        this.linearEventTransport = new LinearEventTransport({
+            fastifyServer: this.sharedApplicationServer.getFastifyInstance(),
+            verificationMode,
+            secret,
         });
-        const results = await Promise.all(connections);
-        const failures = results.filter((r) => !r.success);
-        if (failures.length === this.ndjsonClients.size) {
-            // All connections failed
-            throw new Error("Failed to connect any repositories. Please check your configuration and Linear tokens.");
-        }
-        else if (failures.length > 0) {
-            // Some connections failed
-            console.warn(`\n⚠️  Connected ${results.length - failures.length} out of ${results.length} repositories`);
-            console.warn(`   The following repositories could not be connected:`);
-            failures.forEach((f) => {
-                const repoConfig = this.config.repositories.find((r) => r.id === f.repoId);
-                console.warn(`   - ${repoConfig?.name || f.repoId}`);
-            });
-            console.warn(`\n   Cyrus will continue running with the available repositories.\n`);
-        }
+        // Listen for webhook events
+        this.linearEventTransport.on("webhook", (payload) => {
+            // Get all active repositories for webhook handling
+            const repos = Array.from(this.repositories.values());
+            this.handleWebhook(payload, repos);
+        });
+        // Listen for errors
+        this.linearEventTransport.on("error", (error) => {
+            this.handleError(error);
+        });
+        // Register the /webhook endpoint
+        this.linearEventTransport.register();
+        console.log(`✅ Linear event transport registered (${verificationMode} mode)`);
+        console.log(`   Webhook endpoint: ${this.sharedApplicationServer.getWebhookUrl()}`);
+        // 2. Create and register ConfigUpdater
+        this.configUpdater = new ConfigUpdater(this.sharedApplicationServer.getFastifyInstance(), this.cyrusHome, process.env.CYRUS_API_KEY || "");
+        // Register config update routes
+        this.configUpdater.register();
+        console.log("✅ Config updater registered");
+        console.log("   Routes: /api/update/cyrus-config, /api/update/cyrus-env,");
+        console.log("           /api/update/repository, /api/test-mcp, /api/configure-mcp");
     }
     /**
      * Stop the edge worker
@@ -285,11 +229,10 @@ export class EdgeWorker extends EventEmitter {
                 }
             }
         }
-        // Disconnect all NDJSON clients
-        for (const client of this.ndjsonClients.values()) {
-            client.disconnect();
-        }
-        // Stop shared application server
+        // Clear event transport (no explicit cleanup needed, routes are removed when server stops)
+        this.linearEventTransport = null;
+        this.configUpdater = null;
+        // Stop shared application server (this also stops Cloudflare tunnel if running)
         await this.sharedApplicationServer.stop();
     }
     /**
@@ -298,21 +241,6 @@ export class EdgeWorker extends EventEmitter {
     setConfigPath(configPath) {
         this.configPath = configPath;
     }
-    /**
-     * Get fresh list of repositories for a given Linear token
-     * This ensures webhook handlers always work with current repository state
-     */
-    getRepositoriesForToken(token) {
-        const repoIds = this.tokenToRepoIds.get(token) || [];
-        const repos = [];
-        for (const repoId of repoIds) {
-            const repo = this.repositories.get(repoId);
-            if (repo) {
-                repos.push(repo);
-            }
-        }
-        return repos;
-    }
     /**
      * Handle resuming a parent session when a child session completes
      * This is the core logic used by the resume parent session callback
@@ -339,13 +267,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);
@@ -496,8 +449,25 @@ export class EdgeWorker extends EventEmitter {
             }
             try {
                 console.log(`➕ Adding repository: ${repo.name} (${repo.id})`);
+                // Resolve paths that may contain tilde (~) prefix
+                const resolvedRepo = {
+                    ...repo,
+                    repositoryPath: resolvePath(repo.repositoryPath),
+                    workspaceBaseDir: resolvePath(repo.workspaceBaseDir),
+                    mcpConfigPath: Array.isArray(repo.mcpConfigPath)
+                        ? repo.mcpConfigPath.map(resolvePath)
+                        : repo.mcpConfigPath
+                            ? resolvePath(repo.mcpConfigPath)
+                            : undefined,
+                    promptTemplatePath: repo.promptTemplatePath
+                        ? resolvePath(repo.promptTemplatePath)
+                        : undefined,
+                    openaiOutputDirectory: repo.openaiOutputDirectory
+                        ? resolvePath(repo.openaiOutputDirectory)
+                        : undefined,
+                };
                 // Add to internal map
-                this.repositories.set(repo.id, repo);
+                this.repositories.set(repo.id, resolvedRepo);
                 // Create Linear client
                 const linearClient = new LinearClient({
                     accessToken: repo.linearToken,
@@ -511,14 +481,6 @@ export class EdgeWorker extends EventEmitter {
                 }, undefined, // No resumeNextSubroutine callback for dynamically added repos
                 this.procedureRouter, this.sharedApplicationServer);
                 this.agentSessionManagers.set(repo.id, agentSessionManager);
-                // Update token-to-repo mapping
-                const repoIds = this.tokenToRepoIds.get(repo.linearToken) || [];
-                if (!repoIds.includes(repo.id)) {
-                    repoIds.push(repo.id);
-                }
-                this.tokenToRepoIds.set(repo.linearToken, repoIds);
-                // Set up webhook listener
-                await this.setupWebhookListener(repo);
                 console.log(`✅ Repository added successfully: ${repo.name}`);
             }
             catch (error) {
@@ -538,8 +500,25 @@ export class EdgeWorker extends EventEmitter {
                     continue;
                 }
                 console.log(`🔄 Updating repository: ${repo.name} (${repo.id})`);
+                // Resolve paths that may contain tilde (~) prefix
+                const resolvedRepo = {
+                    ...repo,
+                    repositoryPath: resolvePath(repo.repositoryPath),
+                    workspaceBaseDir: resolvePath(repo.workspaceBaseDir),
+                    mcpConfigPath: Array.isArray(repo.mcpConfigPath)
+                        ? repo.mcpConfigPath.map(resolvePath)
+                        : repo.mcpConfigPath
+                            ? resolvePath(repo.mcpConfigPath)
+                            : undefined,
+                    promptTemplatePath: repo.promptTemplatePath
+                        ? resolvePath(repo.promptTemplatePath)
+                        : undefined,
+                    openaiOutputDirectory: repo.openaiOutputDirectory
+                        ? resolvePath(repo.openaiOutputDirectory)
+                        : undefined,
+                };
                 // Update stored config
-                this.repositories.set(repo.id, repo);
+                this.repositories.set(repo.id, resolvedRepo);
                 // If token changed, recreate Linear client
                 if (oldRepo.linearToken !== repo.linearToken) {
                     console.log(`  🔑 Token changed, recreating Linear client`);
@@ -547,22 +526,6 @@ export class EdgeWorker extends EventEmitter {
                         accessToken: repo.linearToken,
                     });
                     this.linearClients.set(repo.id, linearClient);
-                    // Update token mapping
-                    const oldRepoIds = this.tokenToRepoIds.get(oldRepo.linearToken) || [];
-                    const filteredOldIds = oldRepoIds.filter((id) => id !== repo.id);
-                    if (filteredOldIds.length > 0) {
-                        this.tokenToRepoIds.set(oldRepo.linearToken, filteredOldIds);
-                    }
-                    else {
-                        this.tokenToRepoIds.delete(oldRepo.linearToken);
-                    }
-                    const newRepoIds = this.tokenToRepoIds.get(repo.linearToken) || [];
-                    if (!newRepoIds.includes(repo.id)) {
-                        newRepoIds.push(repo.id);
-                    }
-                    this.tokenToRepoIds.set(repo.linearToken, newRepoIds);
-                    // Reconnect webhook if needed
-                    await this.reconnectWebhook(oldRepo, repo);
                 }
                 // If active status changed
                 if (oldRepo.isActive !== repo.isActive) {
@@ -571,7 +534,6 @@ export class EdgeWorker extends EventEmitter {
                     }
                     else {
                         console.log(`  ▶️  Repository reactivated`);
-                        await this.setupWebhookListener(repo);
                     }
                 }
                 console.log(`✅ Repository updated successfully: ${repo.name}`);
@@ -626,17 +588,6 @@ export class EdgeWorker extends EventEmitter {
                 this.repositories.delete(repo.id);
                 this.linearClients.delete(repo.id);
                 this.agentSessionManagers.delete(repo.id);
-                // Update token mapping
-                const repoIds = this.tokenToRepoIds.get(repo.linearToken) || [];
-                const filteredIds = repoIds.filter((id) => id !== repo.id);
-                if (filteredIds.length > 0) {
-                    this.tokenToRepoIds.set(repo.linearToken, filteredIds);
-                }
-                else {
-                    this.tokenToRepoIds.delete(repo.linearToken);
-                }
-                // Clean up webhook listener if no other repos use the same token
-                await this.cleanupWebhookIfUnused(repo);
                 console.log(`✅ Repository removed successfully: ${repo.name}`);
             }
             catch (error) {
@@ -644,115 +595,6 @@ export class EdgeWorker extends EventEmitter {
             }
         }
     }
-    /**
-     * Set up webhook listener for a repository
-     */
-    async setupWebhookListener(repo) {
-        // Check if we already have a client for this token
-        const existingRepoIds = this.tokenToRepoIds.get(repo.linearToken) || [];
-        const existingClient = existingRepoIds.length > 0
-            ? this.ndjsonClients.get(existingRepoIds[0] || "")
-            : null;
-        if (existingClient) {
-            console.log(`  ℹ️  Reusing existing webhook connection for token ...${repo.linearToken.slice(-4)}`);
-            return;
-        }
-        // Create new NDJSON client for this token
-        const serverPort = this.config.serverPort || this.config.webhookPort || 3456;
-        const serverHost = this.config.serverHost || "localhost";
-        const useLinearDirectWebhooks = process.env.LINEAR_DIRECT_WEBHOOKS?.toLowerCase().trim() === "true";
-        const clientConfig = {
-            proxyUrl: this.config.proxyUrl,
-            token: repo.linearToken,
-            name: repo.name,
-            transport: "webhook",
-            useExternalWebhookServer: true,
-            externalWebhookServer: this.sharedApplicationServer,
-            webhookPort: serverPort,
-            webhookPath: "/webhook",
-            webhookHost: serverHost,
-            ...(this.config.baseUrl && { webhookBaseUrl: this.config.baseUrl }),
-            ...(!this.config.baseUrl &&
-                this.config.webhookBaseUrl && {
-                webhookBaseUrl: this.config.webhookBaseUrl,
-            }),
-            onConnect: () => this.handleConnect(repo.id, [repo]),
-            onDisconnect: (reason) => this.handleDisconnect(repo.id, [repo], reason),
-            onError: (error) => this.handleError(error),
-        };
-        const ndjsonClient = useLinearDirectWebhooks
-            ? new LinearWebhookClient({
-                ...clientConfig,
-                onWebhook: (payload) => {
-                    // Get fresh repositories for this token to avoid stale closures
-                    const freshRepos = this.getRepositoriesForToken(repo.linearToken);
-                    this.handleWebhook(payload, freshRepos);
-                },
-            })
-            : new NdjsonClient(clientConfig);
-        if (!useLinearDirectWebhooks) {
-            ndjsonClient.on("webhook", (data) => {
-                // Get fresh repositories for this token to avoid stale closures
-                const freshRepos = this.getRepositoriesForToken(repo.linearToken);
-                this.handleWebhook(data, freshRepos);
-            });
-        }
-        this.ndjsonClients.set(repo.id, ndjsonClient);
-        // Connect the client
-        try {
-            await ndjsonClient.connect();
-            console.log(`  ✅ Webhook listener connected for ${repo.name}`);
-        }
-        catch (error) {
-            console.error(`  ❌ Failed to connect webhook listener:`, error);
-        }
-    }
-    /**
-     * Reconnect webhook when token changes
-     */
-    async reconnectWebhook(oldRepo, newRepo) {
-        console.log(`  🔌 Reconnecting webhook due to token change`);
-        // Disconnect old client if no other repos use it
-        await this.cleanupWebhookIfUnused(oldRepo);
-        // Set up new connection
-        await this.setupWebhookListener(newRepo);
-    }
-    /**
-     * Clean up webhook listener if no other repositories use the token
-     */
-    async cleanupWebhookIfUnused(repo) {
-        const repoIds = this.tokenToRepoIds.get(repo.linearToken) || [];
-        const otherRepos = repoIds.filter((id) => id !== repo.id);
-        if (otherRepos.length === 0) {
-            // No other repos use this token, safe to disconnect
-            const client = this.ndjsonClients.get(repo.id);
-            if (client) {
-                console.log(`  🔌 Disconnecting webhook for token ...${repo.linearToken.slice(-4)}`);
-                client.disconnect();
-                this.ndjsonClients.delete(repo.id);
-            }
-        }
-        else {
-            console.log(`  ℹ️  Token still used by ${otherRepos.length} other repository(ies), keeping connection`);
-        }
-    }
-    /**
-     * Handle connection established
-     */
-    handleConnect(clientId, repos) {
-        // Get the token for backward compatibility with events
-        const token = repos[0]?.linearToken || clientId;
-        this.emit("connected", token);
-        // Connection logged by CLI app event handler
-    }
-    /**
-     * Handle disconnection
-     */
-    handleDisconnect(clientId, repos, reason) {
-        // Get the token for backward compatibility with events
-        const token = repos[0]?.linearToken || clientId;
-        this.emit("disconnected", token, reason);
-    }
     /**
      * Handle errors
      */
@@ -1106,71 +948,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 +1072,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 +1092,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 +1104,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 +1138,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 +1148,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);
         }
     }
     /**
@@ -1585,10 +1385,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 +1399,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 +1623,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 +1719,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);
@@ -1960,29 +1766,28 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
      */
     getConnectionStatus() {
         const status = new Map();
-        for (const [repoId, client] of this.ndjsonClients) {
-            status.set(repoId, client.isConnected());
+        // Single event transport is "connected" if it exists
+        if (this.linearEventTransport) {
+            // Mark all repositories as connected since they share the single transport
+            for (const repoId of this.repositories.keys()) {
+                status.set(repoId, true);
+            }
         }
         return status;
     }
     /**
-     * Get NDJSON client by token (for testing purposes)
+     * Get event transport (for testing purposes)
      * @internal
      */
-    _getClientByToken(token) {
-        for (const [repoId, client] of this.ndjsonClients) {
-            const repo = this.repositories.get(repoId);
-            if (repo?.linearToken === token) {
-                return client;
-            }
-        }
-        return undefined;
+    _getClientByToken(_token) {
+        // Return the single shared event transport
+        return this.linearEventTransport;
     }
     /**
      * Start OAuth flow using the shared application server
      */
     async startOAuthFlow(proxyUrl) {
-        const oauthProxyUrl = proxyUrl || this.config.proxyUrl;
+        const oauthProxyUrl = proxyUrl || this.config.proxyUrl || DEFAULT_PROXY_URL;
         return this.sharedApplicationServer.startOAuthFlow(oauthProxyUrl);
     }
     /**
@@ -2481,6 +2286,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 +2310,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 +2409,264 @@ ${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, 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 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 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) {
+        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 +2968,78 @@ ${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) {
+        // Initialize procedure metadata using intelligent routing
+        if (!session.metadata) {
+            session.metadata = {};
+        }
+        // Post ephemeral "Routing..." thought
+        await agentSessionManager.postRoutingThought(linearAgentActivitySessionId);
+        // Route based on the prompt content
+        const routingDecision = await this.procedureRouter.determineRoutine(promptBody.trim());
+        const selectedProcedure = routingDecision.procedure;
+        // 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, routingDecision.classification);
+        // Log routing decision
+        console.log(`[EdgeWorker] Routing decision for ${linearAgentActivitySessionId}:`);
+        console.log(`  Classification: ${routingDecision.classification}`);
+        console.log(`  Procedure: ${selectedProcedure.name}`);
+        console.log(`  Reasoning: ${routingDecision.reasoning}`);
+    }
+    /**
+     * 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);
+            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 +3136,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 +3188,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);