cyrus-edge-worker 0.0.36 → 0.0.38

package/dist/EdgeWorker.js

@@ -3,14 +3,15 @@ import { mkdir, readdir, readFile, rename, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { LinearClient, } from "@linear/sdk";
-import { ClaudeRunner, createCyrusToolsServer, getAllTools, getCoordinatorTools, getReadOnlyTools, getSafeTools, } from "cyrus-claude-runner";
+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 { fileTypeFromBuffer } from "file-type";
 import { AgentSessionManager } from "./AgentSessionManager.js";
+import { ProcedureRouter, } from "./procedures/index.js";
 import { SharedApplicationServer } from "./SharedApplicationServer.js";
-const LAST_MESSAGE_MARKER = "\n\nIMPORTANT: When providing your final summary response, include the special marker ___LAST_MESSAGE_MARKER___ at the very beginning of your message. This marker will be automatically removed before posting.";
 /**
  * Unified edge worker that **orchestrates**
  *   capturing Linear webhooks,
@@ -27,11 +28,21 @@ export class EdgeWorker extends EventEmitter {
     sharedApplicationServer;
     cyrusHome;
     childToParentAgentSession = new Map(); // Maps child agentSessionId to parent agentSessionId
+    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;
         this.cyrusHome = config.cyrusHome;
         this.persistenceManager = new PersistenceManager(join(this.cyrusHome, "state"));
+        // Initialize procedure router with haiku model for fast classification
+        this.procedureRouter = new ProcedureRouter({
+            cyrusHome: this.cyrusHome,
+            model: "haiku",
+            timeoutMs: 10000,
+        });
         console.log(`[EdgeWorker Constructor] Initializing parent-child session mapping system`);
         console.log(`[EdgeWorker Constructor] Parent-child mapping initialized with 0 entries`);
         // Initialize shared application server
@@ -67,40 +78,48 @@ export class EdgeWorker extends EventEmitter {
                     console.log(`[Parent-Child Lookup] Child ${childSessionId} -> Parent ${parentId || "not found"}`);
                     return parentId;
                 }, async (parentSessionId, prompt, childSessionId) => {
-                    console.log(`[Parent Session Resume] Child session completed, resuming parent session ${parentSessionId}`);
-                    // Get the parent session and repository
-                    // This works because by the time this callback runs, agentSessionManager is fully initialized
-                    console.log(`[Parent Session Resume] Retrieving parent session ${parentSessionId} from agent session manager`);
-                    const parentSession = agentSessionManager.getSession(parentSessionId);
-                    if (!parentSession) {
-                        console.error(`[Parent Session Resume] Parent session ${parentSessionId} not found in agent session manager`);
+                    await this.handleResumeParentSession(parentSessionId, prompt, childSessionId, repo, agentSessionManager);
+                }, async (linearAgentActivitySessionId) => {
+                    console.log(`[Subroutine Transition] Advancing to next subroutine for session ${linearAgentActivitySessionId}`);
+                    // Get the session
+                    const session = agentSessionManager.getSession(linearAgentActivitySessionId);
+                    if (!session) {
+                        console.error(`[Subroutine Transition] Session ${linearAgentActivitySessionId} not found`);
                         return;
                     }
-                    console.log(`[Parent Session Resume] Found parent session - Issue: ${parentSession.issueId}, Workspace: ${parentSession.workspace.path}`);
-                    // Get the child session to access its workspace path
-                    const childSession = agentSessionManager.getSession(childSessionId);
-                    const childWorkspaceDirs = [];
-                    if (childSession) {
-                        childWorkspaceDirs.push(childSession.workspace.path);
-                        console.log(`[Parent Session Resume] Adding child workspace to parent allowed directories: ${childSession.workspace.path}`);
+                    // Get next subroutine (advancement already handled by AgentSessionManager)
+                    const nextSubroutine = this.procedureRouter.getCurrentSubroutine(session);
+                    if (!nextSubroutine) {
+                        console.log(`[Subroutine Transition] Procedure complete for session ${linearAgentActivitySessionId}`);
+                        return;
                     }
-                    else {
-                        console.warn(`[Parent Session Resume] Could not find child session ${childSessionId} to add workspace to parent allowed directories`);
+                    console.log(`[Subroutine Transition] Next subroutine: ${nextSubroutine.name}`);
+                    // Load subroutine prompt
+                    const __filename = fileURLToPath(import.meta.url);
+                    const __dirname = dirname(__filename);
+                    const subroutinePromptPath = join(__dirname, "prompts", nextSubroutine.promptPath);
+                    let subroutinePrompt;
+                    try {
+                        subroutinePrompt = await readFile(subroutinePromptPath, "utf-8");
+                        console.log(`[Subroutine Transition] Loaded ${nextSubroutine.name} subroutine prompt (${subroutinePrompt.length} characters)`);
+                    }
+                    catch (error) {
+                        console.error(`[Subroutine Transition] Failed to load subroutine prompt from ${subroutinePromptPath}:`, error);
+                        // Fallback to simple prompt
+                        subroutinePrompt = `Continue with: ${nextSubroutine.description}`;
                     }
-                    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`);
+                    // Resume Claude session with subroutine prompt
                     try {
-                        await this.resumeClaudeSession(parentSession, repo, parentSessionId, agentSessionManager, prompt, "", // No attachment manifest for child results
+                        await this.resumeClaudeSession(session, repo, linearAgentActivitySessionId, agentSessionManager, subroutinePrompt, "", // No attachment manifest
                         false, // Not a new session
-                        childWorkspaceDirs);
-                        console.log(`[Parent Session Resume] Successfully resumed parent session ${parentSessionId} with child results`);
+                        [], // No additional allowed directories
+                        nextSubroutine.maxTurns);
+                        console.log(`[Subroutine Transition] Successfully resumed session for ${nextSubroutine.name} subroutine${nextSubroutine.maxTurns ? ` (maxTurns=${nextSubroutine.maxTurns})` : ""}`);
                     }
                     catch (error) {
-                        console.error(`[Parent Session Resume] Failed to resume parent session ${parentSessionId}:`, error);
-                        console.error(`[Parent Session Resume] Error context - Parent issue: ${parentSession.issueId}, Repository: ${repo.name}`);
+                        console.error(`[Subroutine Transition] Failed to resume session for ${nextSubroutine.name} subroutine:`, error);
                     }
-                });
+                }, this.procedureRouter, this.sharedApplicationServer);
                 this.agentSessionManagers.set(repo.id, agentSessionManager);
             }
         }
@@ -110,6 +129,12 @@ export class EdgeWorker extends EventEmitter {
             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) {
@@ -144,12 +169,20 @@ export class EdgeWorker extends EventEmitter {
             const ndjsonClient = useLinearDirectWebhooks
                 ? new LinearWebhookClient({
                     ...clientConfig,
-                    onWebhook: (payload) => this.handleWebhook(payload, repos),
+                    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) => this.handleWebhook(data, repos));
+                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) {
@@ -168,6 +201,10 @@ export class EdgeWorker extends EventEmitter {
     async start() {
         // Load persisted state for each repository
         await this.loadPersistedState();
+        // Start config file watcher if configPath is provided
+        if (this.configPath) {
+            this.startConfigWatcher();
+        }
         // Start shared application server first
         await this.sharedApplicationServer.start();
         // Connect all NDJSON clients
@@ -219,6 +256,12 @@ export class EdgeWorker extends EventEmitter {
      * Stop the edge worker
      */
     async stop() {
+        // Stop config file watcher
+        if (this.configWatcher) {
+            await this.configWatcher.close();
+            this.configWatcher = undefined;
+            console.log("✅ Config file watcher stopped");
+        }
         try {
             await this.savePersistedState();
             console.log("✅ EdgeWorker state saved successfully");
@@ -249,6 +292,450 @@ export class EdgeWorker extends EventEmitter {
         // Stop shared application server
         await this.sharedApplicationServer.stop();
     }
+    /**
+     * Set the config file path for dynamic reloading
+     */
+    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
+     * Extracted to reduce duplication between constructor and addNewRepositories
+     */
+    async handleResumeParentSession(parentSessionId, prompt, childSessionId, repo, agentSessionManager) {
+        console.log(`[Parent Session Resume] Child session completed, resuming parent session ${parentSessionId}`);
+        // Get the parent session and repository
+        console.log(`[Parent Session Resume] Retrieving parent session ${parentSessionId} from agent session manager`);
+        const parentSession = agentSessionManager.getSession(parentSessionId);
+        if (!parentSession) {
+            console.error(`[Parent Session Resume] Parent session ${parentSessionId} not found in agent session manager`);
+            return;
+        }
+        console.log(`[Parent Session Resume] Found parent session - Issue: ${parentSession.issueId}, Workspace: ${parentSession.workspace.path}`);
+        // Get the child session to access its workspace path
+        const childSession = agentSessionManager.getSession(childSessionId);
+        const childWorkspaceDirs = [];
+        if (childSession) {
+            childWorkspaceDirs.push(childSession.workspace.path);
+            console.log(`[Parent Session Resume] Adding child workspace to parent allowed directories: ${childSession.workspace.path}`);
+        }
+        else {
+            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`);
+        try {
+            await this.resumeClaudeSession(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`);
+        }
+        catch (error) {
+            console.error(`[Parent Session Resume] Failed to resume parent session ${parentSessionId}:`, error);
+            console.error(`[Parent Session Resume] Error context - Parent issue: ${parentSession.issueId}, Repository: ${repo.name}`);
+        }
+    }
+    /**
+     * Start watching config file for changes
+     */
+    startConfigWatcher() {
+        if (!this.configPath) {
+            console.warn("⚠️  No config path set, skipping config file watcher");
+            return;
+        }
+        console.log(`👀 Watching config file for changes: ${this.configPath}`);
+        this.configWatcher = chokidarWatch(this.configPath, {
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 500,
+                pollInterval: 100,
+            },
+        });
+        this.configWatcher.on("change", async () => {
+            console.log("🔄 Config file changed, reloading...");
+            await this.handleConfigChange();
+        });
+        this.configWatcher.on("error", (error) => {
+            console.error("❌ Config watcher error:", error);
+        });
+    }
+    /**
+     * Handle configuration file changes
+     */
+    async handleConfigChange() {
+        try {
+            const newConfig = await this.loadConfigSafely();
+            if (!newConfig) {
+                return;
+            }
+            const changes = this.detectRepositoryChanges(newConfig);
+            if (changes.added.length === 0 &&
+                changes.modified.length === 0 &&
+                changes.removed.length === 0) {
+                console.log("ℹ️  No repository changes detected");
+                return;
+            }
+            console.log(`📊 Repository changes detected: ${changes.added.length} added, ${changes.modified.length} modified, ${changes.removed.length} removed`);
+            // Apply changes incrementally
+            await this.removeDeletedRepositories(changes.removed);
+            await this.updateModifiedRepositories(changes.modified);
+            await this.addNewRepositories(changes.added);
+            // Update config reference
+            this.config = newConfig;
+            console.log("✅ Configuration reloaded successfully");
+        }
+        catch (error) {
+            console.error("❌ Failed to reload configuration:", error);
+        }
+    }
+    /**
+     * Safely load configuration from file with validation
+     */
+    async loadConfigSafely() {
+        try {
+            if (!this.configPath) {
+                console.error("❌ No config path set");
+                return null;
+            }
+            const configContent = await readFile(this.configPath, "utf-8");
+            const parsedConfig = JSON.parse(configContent);
+            // Merge with current EdgeWorker config structure
+            const newConfig = {
+                ...this.config,
+                repositories: parsedConfig.repositories || [],
+                ngrokAuthToken: parsedConfig.ngrokAuthToken || this.config.ngrokAuthToken,
+                defaultModel: parsedConfig.defaultModel || this.config.defaultModel,
+                defaultFallbackModel: parsedConfig.defaultFallbackModel || this.config.defaultFallbackModel,
+                defaultAllowedTools: parsedConfig.defaultAllowedTools || this.config.defaultAllowedTools,
+                defaultDisallowedTools: parsedConfig.defaultDisallowedTools ||
+                    this.config.defaultDisallowedTools,
+            };
+            // Basic validation
+            if (!Array.isArray(newConfig.repositories)) {
+                console.error("❌ Invalid config: repositories must be an array");
+                return null;
+            }
+            // Validate each repository has required fields
+            for (const repo of newConfig.repositories) {
+                if (!repo.id ||
+                    !repo.name ||
+                    !repo.repositoryPath ||
+                    !repo.baseBranch) {
+                    console.error(`❌ Invalid repository config: missing required fields (id, name, repositoryPath, baseBranch)`, repo);
+                    return null;
+                }
+            }
+            return newConfig;
+        }
+        catch (error) {
+            console.error("❌ Failed to load config file:", error);
+            return null;
+        }
+    }
+    /**
+     * Detect changes between current and new repository configurations
+     */
+    detectRepositoryChanges(newConfig) {
+        const currentRepos = new Map(this.repositories);
+        const newRepos = new Map(newConfig.repositories.map((r) => [r.id, r]));
+        const added = [];
+        const modified = [];
+        const removed = [];
+        // Find added and modified repositories
+        for (const [id, repo] of newRepos) {
+            if (!currentRepos.has(id)) {
+                added.push(repo);
+            }
+            else {
+                const currentRepo = currentRepos.get(id);
+                if (currentRepo && !this.deepEqual(currentRepo, repo)) {
+                    modified.push(repo);
+                }
+            }
+        }
+        // Find removed repositories
+        for (const [id, repo] of currentRepos) {
+            if (!newRepos.has(id)) {
+                removed.push(repo);
+            }
+        }
+        return { added, modified, removed };
+    }
+    /**
+     * Deep equality check for repository configs
+     */
+    deepEqual(obj1, obj2) {
+        return JSON.stringify(obj1) === JSON.stringify(obj2);
+    }
+    /**
+     * Add new repositories to the running EdgeWorker
+     */
+    async addNewRepositories(repos) {
+        for (const repo of repos) {
+            if (repo.isActive === false) {
+                console.log(`⏭️  Skipping inactive repository: ${repo.name}`);
+                continue;
+            }
+            try {
+                console.log(`➕ Adding repository: ${repo.name} (${repo.id})`);
+                // Add to internal map
+                this.repositories.set(repo.id, repo);
+                // Create Linear client
+                const linearClient = new LinearClient({
+                    accessToken: repo.linearToken,
+                });
+                this.linearClients.set(repo.id, linearClient);
+                // Create AgentSessionManager with same pattern as constructor
+                const agentSessionManager = new AgentSessionManager(linearClient, (childSessionId) => {
+                    return this.childToParentAgentSession.get(childSessionId);
+                }, async (parentSessionId, prompt, childSessionId) => {
+                    await this.handleResumeParentSession(parentSessionId, prompt, childSessionId, repo, agentSessionManager);
+                }, 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) {
+                console.error(`❌ Failed to add repository ${repo.name}:`, error);
+            }
+        }
+    }
+    /**
+     * Update existing repositories
+     */
+    async updateModifiedRepositories(repos) {
+        for (const repo of repos) {
+            try {
+                const oldRepo = this.repositories.get(repo.id);
+                if (!oldRepo) {
+                    console.warn(`⚠️  Repository ${repo.id} not found for update, skipping`);
+                    continue;
+                }
+                console.log(`🔄 Updating repository: ${repo.name} (${repo.id})`);
+                // Update stored config
+                this.repositories.set(repo.id, repo);
+                // If token changed, recreate Linear client
+                if (oldRepo.linearToken !== repo.linearToken) {
+                    console.log(`  🔑 Token changed, recreating Linear client`);
+                    const linearClient = new LinearClient({
+                        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) {
+                    if (repo.isActive === false) {
+                        console.log(`  ⏸️  Repository set to inactive - existing sessions will continue`);
+                    }
+                    else {
+                        console.log(`  ▶️  Repository reactivated`);
+                        await this.setupWebhookListener(repo);
+                    }
+                }
+                console.log(`✅ Repository updated successfully: ${repo.name}`);
+            }
+            catch (error) {
+                console.error(`❌ Failed to update repository ${repo.name}:`, error);
+            }
+        }
+    }
+    /**
+     * Remove deleted repositories
+     */
+    async removeDeletedRepositories(repos) {
+        for (const repo of repos) {
+            try {
+                console.log(`🗑️  Removing repository: ${repo.name} (${repo.id})`);
+                // Check for active sessions
+                const manager = this.agentSessionManagers.get(repo.id);
+                const activeSessions = manager?.getActiveSessions() || [];
+                if (activeSessions.length > 0) {
+                    console.warn(`  ⚠️  Repository has ${activeSessions.length} active sessions - stopping them`);
+                    // Stop all active sessions and notify Linear
+                    for (const session of activeSessions) {
+                        try {
+                            console.log(`  🛑 Stopping session for issue ${session.issueId}`);
+                            // Get the Claude runner for this session
+                            const runner = manager?.getClaudeRunner(session.linearAgentActivitySessionId);
+                            if (runner) {
+                                // Stop the Claude process
+                                runner.stop();
+                                console.log(`  ✅ Stopped Claude runner for session ${session.linearAgentActivitySessionId}`);
+                            }
+                            // Post cancellation message to Linear
+                            const linearClient = this.linearClients.get(repo.id);
+                            if (linearClient) {
+                                await linearClient.createAgentActivity({
+                                    agentSessionId: session.linearAgentActivitySessionId,
+                                    content: {
+                                        type: "response",
+                                        body: `**Repository Removed from Configuration**\n\nThis repository (\`${repo.name}\`) has been removed from the Cyrus configuration. All active sessions for this repository have been stopped.\n\nIf you need to continue working on this issue, please contact your administrator to restore the repository configuration.`,
+                                    },
+                                });
+                                console.log(`  📤 Posted cancellation message to Linear for issue ${session.issueId}`);
+                            }
+                        }
+                        catch (error) {
+                            console.error(`  ❌ Failed to stop session ${session.linearAgentActivitySessionId}:`, error);
+                        }
+                    }
+                }
+                // Remove repository from all maps
+                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) {
+                console.error(`❌ Failed to remove repository ${repo.name}:`, error);
+            }
+        }
+    }
+    /**
+     * 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
      */
@@ -563,8 +1050,62 @@ export class EdgeWorker extends EventEmitter {
         const sessionData = await this.createLinearAgentSession(linearAgentActivitySessionId, issue, repository, agentSessionManager);
         // Destructure the session data (excluding allowedTools which we'll build with promptType)
         const { session, fullIssue, workspace: _workspace, attachmentResult, attachmentsDir: _attachmentsDir, allowedDirectories, } = sessionData;
-        // Fetch labels (needed for both model selection and system prompt determination)
+        // Initialize procedure metadata using intelligent routing
+        if (!session.metadata) {
+            session.metadata = {};
+        }
+        // Post ephemeral "Routing..." thought
+        await agentSessionManager.postRoutingThought(linearAgentActivitySessionId);
+        // Fetch labels early (needed for label override check)
         const labels = await this.fetchIssueLabels(fullIssue);
+        // Check for label overrides BEFORE AI routing
+        const debuggerConfig = repository.labelPrompts?.debugger;
+        const debuggerLabels = Array.isArray(debuggerConfig)
+            ? debuggerConfig
+            : debuggerConfig?.labels;
+        const hasDebuggerLabel = debuggerLabels?.some((label) => labels.includes(label));
+        const orchestratorConfig = repository.labelPrompts?.orchestrator;
+        const orchestratorLabels = Array.isArray(orchestratorConfig)
+            ? orchestratorConfig
+            : orchestratorConfig?.labels;
+        const hasOrchestratorLabel = orchestratorLabels?.some((label) => labels.includes(label));
+        let finalProcedure;
+        let finalClassification;
+        // If labels indicate a specific procedure, use that instead of AI routing
+        if (hasDebuggerLabel) {
+            const debuggerProcedure = this.procedureRouter.getProcedure("debugger-full");
+            if (!debuggerProcedure) {
+                throw new Error("debugger-full procedure not found in registry");
+            }
+            finalProcedure = debuggerProcedure;
+            finalClassification = "debugger";
+            console.log(`[EdgeWorker] Using debugger-full procedure due to debugger label (skipping AI routing)`);
+        }
+        else if (hasOrchestratorLabel) {
+            const orchestratorProcedure = this.procedureRouter.getProcedure("orchestrator-full");
+            if (!orchestratorProcedure) {
+                throw new Error("orchestrator-full procedure not found in registry");
+            }
+            finalProcedure = orchestratorProcedure;
+            finalClassification = "orchestrator";
+            console.log(`[EdgeWorker] Using orchestrator-full procedure due to orchestrator label (skipping AI routing)`);
+        }
+        else {
+            // No label override - use AI routing
+            const issueDescription = `${issue.title}\n\n${fullIssue.description || ""}`.trim();
+            const routingDecision = await this.procedureRouter.determineRoutine(issueDescription);
+            finalProcedure = 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: ${finalProcedure.name}`);
+            console.log(`  Reasoning: ${routingDecision.reasoning}`);
+        }
+        // Initialize procedure metadata in session with final decision
+        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;
@@ -659,6 +1200,7 @@ export class EdgeWorker extends EventEmitter {
         }
         let session = agentSessionManager.getSession(linearAgentActivitySessionId);
         let isNewSession = false;
+        let fullIssue = null;
         if (!session) {
             console.log(`[EdgeWorker] No existing session found for agent activity session ${linearAgentActivitySessionId}, creating new session`);
             isNewSession = true;
@@ -667,23 +1209,70 @@ export class EdgeWorker extends EventEmitter {
             // Create the session using the shared method
             const sessionData = await this.createLinearAgentSession(linearAgentActivitySessionId, issue, repository, agentSessionManager);
             // Destructure session data for new session
-            const { fullIssue: newFullIssue } = sessionData;
+            fullIssue = sessionData.fullIssue;
             session = sessionData.session;
+            console.log(`[EdgeWorker] Created new session ${linearAgentActivitySessionId} (prompted webhook)`);
             // Save state and emit events for new session
             await this.savePersistedState();
-            this.emit("session:started", newFullIssue.id, newFullIssue, repository.id);
-            this.config.handlers?.onSessionStart?.(newFullIssue.id, newFullIssue, repository.id);
+            this.emit("session:started", fullIssue.id, fullIssue, repository.id);
+            this.config.handlers?.onSessionStart?.(fullIssue.id, fullIssue, repository.id);
+        }
+        else {
+            console.log(`[EdgeWorker] Found existing session ${linearAgentActivitySessionId} for new user prompt`);
+            // Post instant acknowledgment for existing session BEFORE any async work
+            // Check streaming status first to determine the message
+            const isCurrentlyStreaming = session?.claudeRunner?.isStreaming() || false;
+            await this.postInstantPromptedAcknowledgment(linearAgentActivitySessionId, repository.id, isCurrentlyStreaming);
+            // Need to fetch full issue for routing context
+            const linearClient = this.linearClients.get(repository.id);
+            if (linearClient) {
+                try {
+                    fullIssue = await linearClient.issue(issue.id);
+                }
+                catch (error) {
+                    console.warn(`[EdgeWorker] Failed to fetch full issue for routing: ${issue.id}`, error);
+                    // Continue with degraded routing context
+                }
+            }
+        }
+        // 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`);
         }
         // Ensure session is not null after creation/retrieval
         if (!session) {
             throw new Error(`Failed to get or create session for agent activity session ${linearAgentActivitySessionId}`);
         }
-        // Nothing before this should create latency or be async, so that these remain instant and low-latency for user experience
-        const existingRunner = session.claudeRunner;
-        if (!isNewSession) {
-            // Only post acknowledgment for existing sessions (new sessions already handled it above)
-            await this.postInstantPromptedAcknowledgment(linearAgentActivitySessionId, repository.id, existingRunner?.isStreaming() || false);
-        }
+        // Acknowledgment already posted above for both new and existing sessions
+        // (before any async routing work to ensure instant user feedback)
         // Get Linear client for this repository
         const linearClient = this.linearClients.get(repository.id);
         if (!linearClient) {
@@ -747,7 +1336,6 @@ export class EdgeWorker extends EventEmitter {
             if (attachmentManifest) {
                 fullPrompt = `${promptBody}\n\n${attachmentManifest}`;
             }
-            fullPrompt = `${fullPrompt}${LAST_MESSAGE_MARKER}`;
             existingRunner.addStreamMessage(fullPrompt);
             return; // Exit early - comment has been added to stream
         }
@@ -977,7 +1565,6 @@ export class EdgeWorker extends EventEmitter {
                 console.log(`[EdgeWorker] Adding attachment manifest to label-based prompt, length: ${attachmentManifest.length} characters`);
                 prompt = `${prompt}\n\n${attachmentManifest}`;
             }
-            prompt = `${prompt}${LAST_MESSAGE_MARKER}`;
             console.log(`[EdgeWorker] Label-based prompt built successfully, length: ${prompt.length} characters`);
             return { prompt, version: templateVersion };
         }
@@ -1021,7 +1608,6 @@ IMPORTANT: You were specifically mentioned in the comment above. Focus on addres
             if (attachmentManifest) {
                 prompt = `${prompt}\n\n${attachmentManifest}`;
             }
-            prompt = `${prompt}${LAST_MESSAGE_MARKER}`;
             return { prompt };
         }
         catch (error) {
@@ -1342,7 +1928,6 @@ IMPORTANT: Focus specifically on addressing the new comment above. This is a new
                 console.log(`[EdgeWorker] Adding repository-specific instruction`);
                 prompt = `${prompt}\n\n<repository-specific-instruction>\n${repository.appendInstruction}\n</repository-specific-instruction>`;
             }
-            prompt = `${prompt}${LAST_MESSAGE_MARKER}`;
             console.log(`[EdgeWorker] Final prompt length: ${prompt.length} characters`);
             return { prompt, version: templateVersion };
         }
@@ -1366,7 +1951,7 @@ Branch: ${issue.branchName}
 Working directory: ${repository.repositoryPath}
 Base branch: ${baseBranch}
 
-${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please analyze this issue and help implement a solution. ${LAST_MESSAGE_MARKER}`;
+${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please analyze this issue and help implement a solution.`;
             return { prompt: fallbackPrompt, version: undefined };
         }
     }
@@ -1877,13 +2462,13 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
      */
     buildMcpConfig(repository, parentSessionId) {
         // Always inject the Linear MCP servers with the repository's token
+        // https://linear.app/docs/mcp
         const mcpConfig = {
             linear: {
-                type: "stdio",
-                command: "npx",
-                args: ["-y", "@tacticlaunch/mcp-linear"],
-                env: {
-                    LINEAR_API_TOKEN: repository.linearToken,
+                type: "http",
+                url: "https://mcp.linear.app/mcp",
+                headers: {
+                    Authorization: `Bearer ${repository.linearToken}`,
                 },
             },
             "cyrus-tools": createCyrusToolsServer(repository.linearToken, {
@@ -1939,6 +2524,20 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
                 },
             }),
         };
+        // Add OpenAI-based MCP servers if API key is configured
+        if (repository.openaiApiKey) {
+            // Sora video generation tools
+            mcpConfig["sora-tools"] = createSoraToolsServer({
+                apiKey: repository.openaiApiKey,
+                outputDirectory: repository.openaiOutputDirectory,
+            });
+            // GPT Image generation tools
+            mcpConfig["image-tools"] = createImageToolsServer({
+                apiKey: repository.openaiApiKey,
+                outputDirectory: repository.openaiOutputDirectory,
+            });
+            console.log(`[EdgeWorker] Configured OpenAI MCP servers (Sora + GPT Image) for repository: ${repository.name}`);
+        }
         return mcpConfig;
     }
     /**
@@ -1977,13 +2576,13 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
             const manifestSuffix = attachmentManifest
                 ? `\n\n${attachmentManifest}`
                 : "";
-            return `${promptBody}${manifestSuffix}${LAST_MESSAGE_MARKER}`;
+            return `${promptBody}${manifestSuffix}`;
         }
     }
     /**
      * Build Claude runner configuration with common settings
      */
-    buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, systemPrompt, allowedTools, allowedDirectories, disallowedTools, resumeSessionId, labels) {
+    buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, systemPrompt, allowedTools, allowedDirectories, disallowedTools, resumeSessionId, labels, maxTurns) {
         // Configure PostToolUse hook for playwright screenshots
         const hooks = {
             PostToolUse: [
@@ -2043,7 +2642,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
             cyrusHome: this.cyrusHome,
             mcpConfigPath: repository.mcpConfigPath,
             mcpConfig: this.buildMcpConfig(repository, linearAgentActivitySessionId),
-            appendSystemPrompt: (systemPrompt || "") + LAST_MESSAGE_MARKER,
+            appendSystemPrompt: systemPrompt || "",
             // Priority order: label override > repository config > global default
             model: modelOverride || repository.model || this.config.defaultModel,
             fallbackModel: fallbackModelOverride ||
@@ -2058,6 +2657,9 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
         if (resumeSessionId) {
             config.resumeSessionId = resumeSessionId;
         }
+        if (maxTurns !== undefined) {
+            config.maxTurns = maxTurns;
+        }
         return config;
     }
     /**
@@ -2373,7 +2975,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 = []) {
+    async resumeClaudeSession(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest = "", isNewSession = false, additionalAllowedDirectories = [], maxTurns) {
         // Check for existing runner
         const existingRunner = session.claudeRunner;
         // If there's an existing streaming runner, add to it
@@ -2382,7 +2984,6 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
             if (attachmentManifest) {
                 fullPrompt = `${promptBody}\n\n${attachmentManifest}`;
             }
-            fullPrompt = `${fullPrompt}${LAST_MESSAGE_MARKER}`;
             existingRunner.addStreamMessage(fullPrompt);
             return;
         }
@@ -2415,7 +3016,11 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
             ...additionalAllowedDirectories,
         ];
         // Create runner configuration
-        const runnerConfig = this.buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, systemPrompt, allowedTools, allowedDirectories, disallowedTools, needsNewClaudeSession ? undefined : session.claudeSessionId, labels);
+        const resumeSessionId = needsNewClaudeSession
+            ? undefined
+            : session.claudeSessionId;
+        const runnerConfig = this.buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, systemPrompt, allowedTools, allowedDirectories, disallowedTools, resumeSessionId, labels, // Pass labels for model override
+        maxTurns);
         const runner = new ClaudeRunner(runnerConfig);
         // Store runner
         agentSessionManager.addClaudeRunner(linearAgentActivitySessionId, runner);