cyrus-edge-worker 0.2.5 → 0.2.7

package/dist/EdgeWorker.js

@@ -4,14 +4,16 @@ import { basename, dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { LinearClient } from "@linear/sdk";
 import { watch as chokidarWatch } from "chokidar";
-import { AbortError, ClaudeRunner, createCyrusToolsServer, createImageToolsServer, createSoraToolsServer, getAllTools, getCoordinatorTools, getReadOnlyTools, getSafeTools, } from "cyrus-claude-runner";
+import { ClaudeRunner, createCyrusToolsServer, createImageToolsServer, createSoraToolsServer, getAllTools, getCoordinatorTools, getReadOnlyTools, getSafeTools, } from "cyrus-claude-runner";
 import { ConfigUpdater } from "cyrus-config-updater";
-import { DEFAULT_PROXY_URL, isAgentSessionCreatedWebhook, isAgentSessionPromptedWebhook, isIssueAssignedWebhook, isIssueCommentMentionWebhook, isIssueNewCommentWebhook, isIssueUnassignedWebhook, PersistenceManager, resolvePath, } from "cyrus-core";
+import { CLIIssueTrackerService, CLIRPCServer, DEFAULT_PROXY_URL, isAgentSessionCreatedWebhook, isAgentSessionPromptedWebhook, isIssueAssignedWebhook, isIssueCommentMentionWebhook, isIssueNewCommentWebhook, isIssueUnassignedWebhook, PersistenceManager, resolvePath, } from "cyrus-core";
 import { GeminiRunner } from "cyrus-gemini-runner";
 import { LinearEventTransport, LinearIssueTrackerService, } from "cyrus-linear-event-transport";
 import { fileTypeFromBuffer } from "file-type";
 import { AgentSessionManager } from "./AgentSessionManager.js";
-import { ProcedureRouter, } from "./procedures/index.js";
+import { AskUserQuestionHandler } from "./AskUserQuestionHandler.js";
+import { GitService } from "./GitService.js";
+import { ProcedureAnalyzer, } from "./procedures/index.js";
 import { RepositoryRouter, } from "./RepositoryRouter.js";
 import { SharedApplicationServer } from "./SharedApplicationServer.js";
 /**
@@ -26,16 +28,21 @@ export class EdgeWorker extends EventEmitter {
     agentSessionManagers = new Map(); // Maps repository ID to AgentSessionManager, which manages agent runners for a repo
     issueTrackers = new Map(); // one issue tracker per 'repository'
     linearEventTransport = null; // Single event transport for webhook delivery
+    cliRPCServer = null; // CLI RPC server for CLI platform mode
     configUpdater = null; // Single config updater for configuration updates
     persistenceManager;
     sharedApplicationServer;
     cyrusHome;
     childToParentAgentSession = new Map(); // Maps child agentSessionId to parent agentSessionId
-    procedureRouter; // Intelligent workflow routing
+    procedureAnalyzer; // Intelligent workflow routing
     configWatcher; // File watcher for config.json
     configPath; // Path to config.json file
     /** @internal - Exposed for testing only */
     repositoryRouter; // Repository routing and selection
+    gitService;
+    activeWebhookCount = 0; // Track number of webhooks currently being processed
+    /** Handler for AskUserQuestion tool invocations via Linear select signal */
+    askUserQuestionHandler;
     constructor(config) {
         super();
         this.config = config;
@@ -43,7 +50,7 @@ export class EdgeWorker extends EventEmitter {
         this.persistenceManager = new PersistenceManager(join(this.cyrusHome, "state"));
         // Initialize procedure router with haiku for fast classification
         // Default to claude runner
-        this.procedureRouter = new ProcedureRouter({
+        this.procedureAnalyzer = new ProcedureAnalyzer({
             cyrusHome: this.cyrusHome,
             model: "haiku",
             timeoutMs: 100000,
@@ -75,12 +82,20 @@ export class EdgeWorker extends EventEmitter {
             },
         };
         this.repositoryRouter = new RepositoryRouter(repositoryRouterDeps);
+        this.gitService = new GitService();
+        // Initialize AskUserQuestion handler for elicitation via Linear select signal
+        this.askUserQuestionHandler = new AskUserQuestionHandler({
+            getIssueTracker: (workspaceId) => {
+                return this.getIssueTrackerForWorkspace(workspaceId) ?? null;
+            },
+        });
         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
         const serverPort = config.serverPort || config.webhookPort || 3456;
         const serverHost = config.serverHost || "localhost";
-        this.sharedApplicationServer = new SharedApplicationServer(serverPort, serverHost);
+        const skipTunnel = config.platform === "cli"; // Skip Cloudflare tunnel in CLI mode
+        this.sharedApplicationServer = new SharedApplicationServer(serverPort, serverHost, skipTunnel);
         // Initialize repositories with path resolution
         for (const repo of config.repositories) {
             if (repo.isActive !== false) {
@@ -103,10 +118,15 @@ export class EdgeWorker extends EventEmitter {
                 };
                 this.repositories.set(repo.id, resolvedRepo);
                 // Create issue tracker for this repository's workspace
-                const linearClient = new LinearClient({
-                    accessToken: repo.linearToken,
-                });
-                const issueTracker = new LinearIssueTrackerService(linearClient);
+                const issueTracker = this.config.platform === "cli"
+                    ? (() => {
+                        const service = new CLIIssueTrackerService();
+                        service.seedDefaultData();
+                        return service;
+                    })()
+                    : new LinearIssueTrackerService(new LinearClient({
+                        accessToken: repo.linearToken,
+                    }));
                 this.issueTrackers.set(repo.id, issueTracker);
                 // Create AgentSessionManager for this repository with parent session lookup and resume callback
                 //
@@ -125,11 +145,20 @@ export class EdgeWorker extends EventEmitter {
                     return parentId;
                 }, async (parentSessionId, prompt, childSessionId) => {
                     await this.handleResumeParentSession(parentSessionId, prompt, childSessionId, repo, agentSessionManager);
-                }, this.procedureRouter, this.sharedApplicationServer);
+                }, this.procedureAnalyzer, this.sharedApplicationServer);
                 // Subscribe to subroutine completion events
                 agentSessionManager.on("subroutineComplete", async ({ linearAgentActivitySessionId, session }) => {
                     await this.handleSubroutineTransition(linearAgentActivitySessionId, session, repo, agentSessionManager);
                 });
+                // Subscribe to validation loop events
+                agentSessionManager.on("validationLoopIteration", async ({ linearAgentActivitySessionId, session, fixerPrompt, iteration, maxIterations, }) => {
+                    console.log(`[EdgeWorker] Validation loop iteration ${iteration}/${maxIterations}, running fixer`);
+                    await this.handleValidationLoopFixer(linearAgentActivitySessionId, session, repo, agentSessionManager, fixerPrompt, iteration);
+                });
+                agentSessionManager.on("validationLoopRerun", async ({ linearAgentActivitySessionId, session, iteration }) => {
+                    console.log(`[EdgeWorker] Validation loop re-running verifications (iteration ${iteration})`);
+                    await this.handleValidationLoopRerun(linearAgentActivitySessionId, session, repo, agentSessionManager);
+                });
                 this.agentSessionManagers.set(repo.id, agentSessionManager);
             }
         }
@@ -159,39 +188,116 @@ export class EdgeWorker extends EventEmitter {
         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,
-        });
-        // Listen for webhook events
-        this.linearEventTransport.on("event", (event) => {
-            // Get all active repositories for webhook handling
-            const repos = Array.from(this.repositories.values());
-            this.handleWebhook(event, 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
+        // Platform-specific initialization
+        if (this.config.platform === "cli") {
+            // CLI mode: Create and register CLIRPCServer
+            const firstIssueTracker = this.issueTrackers.get(firstRepo.id);
+            if (!firstIssueTracker) {
+                throw new Error("Issue tracker not found for first repository");
+            }
+            // Type guard to ensure it's a CLIIssueTrackerService
+            if (!(firstIssueTracker instanceof CLIIssueTrackerService)) {
+                throw new Error("CLI platform requires CLIIssueTrackerService but found different implementation");
+            }
+            this.cliRPCServer = new CLIRPCServer({
+                fastifyServer: this.sharedApplicationServer.getFastifyInstance(),
+                issueTracker: firstIssueTracker,
+                version: "1.0.0",
+            });
+            // Register the /cli/rpc endpoint
+            this.cliRPCServer.register();
+            console.log("✅ CLI RPC server registered");
+            console.log("   RPC endpoint: /cli/rpc");
+            // Create CLI event transport and register listener
+            const cliEventTransport = firstIssueTracker.createEventTransport({
+                platform: "cli",
+                fastifyServer: this.sharedApplicationServer.getFastifyInstance(),
+            });
+            // Listen for webhook events (same pattern as Linear mode)
+            cliEventTransport.on("event", (event) => {
+                // Get all active repositories for webhook handling
+                const repos = Array.from(this.repositories.values());
+                this.handleWebhook(event, repos);
+            });
+            // Listen for errors
+            cliEventTransport.on("error", (error) => {
+                this.handleError(error);
+            });
+            // Register the CLI event transport endpoints
+            cliEventTransport.register();
+            console.log("✅ CLI event transport registered");
+            console.log("   Event listener: listening for AgentSessionCreated events");
+        }
+        else {
+            // Linear mode: 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,
+            });
+            // Listen for webhook events
+            this.linearEventTransport.on("event", (event) => {
+                // Get all active repositories for webhook handling
+                const repos = Array.from(this.repositories.values());
+                this.handleWebhook(event, 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 (both platforms)
         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");
+        // 3. Register /status endpoint for process activity monitoring
+        this.registerStatusEndpoint();
+    }
+    /**
+     * Register the /status endpoint for checking if the process is busy or idle
+     * This endpoint is used to determine if the process can be safely restarted
+     */
+    registerStatusEndpoint() {
+        const fastify = this.sharedApplicationServer.getFastifyInstance();
+        fastify.get("/status", async (_request, reply) => {
+            const status = this.computeStatus();
+            return reply.status(200).send({ status });
+        });
+        console.log("✅ Status endpoint registered");
+        console.log("   Route: GET /status");
+    }
+    /**
+     * Compute the current status of the Cyrus process
+     * @returns "idle" if the process can be safely restarted, "busy" if work is in progress
+     */
+    computeStatus() {
+        // Busy if any webhooks are currently being processed
+        if (this.activeWebhookCount > 0) {
+            return "busy";
+        }
+        // Busy if any runner is actively running
+        for (const manager of this.agentSessionManagers.values()) {
+            const runners = manager.getAllAgentRunners();
+            for (const runner of runners) {
+                if (runner.isRunning()) {
+                    return "busy";
+                }
+            }
+        }
+        return "idle";
     }
     /**
      * Stop the edge worker
@@ -309,7 +415,7 @@ export class EdgeWorker extends EventEmitter {
     async handleSubroutineTransition(linearAgentActivitySessionId, session, repo, agentSessionManager) {
         console.log(`[Subroutine Transition] Handling subroutine completion for session ${linearAgentActivitySessionId}`);
         // Get next subroutine (advancement already handled by AgentSessionManager)
-        const nextSubroutine = this.procedureRouter.getCurrentSubroutine(session);
+        const nextSubroutine = this.procedureAnalyzer.getCurrentSubroutine(session);
         if (!nextSubroutine) {
             console.log(`[Subroutine Transition] Procedure complete for session ${linearAgentActivitySessionId}`);
             return;
@@ -341,6 +447,51 @@ export class EdgeWorker extends EventEmitter {
             console.error(`[Subroutine Transition] Failed to resume session for ${nextSubroutine.name} subroutine:`, error);
         }
     }
+    /**
+     * Handle validation loop fixer - run the fixer prompt
+     */
+    async handleValidationLoopFixer(linearAgentActivitySessionId, session, repo, agentSessionManager, fixerPrompt, iteration) {
+        console.log(`[Validation Loop] Running fixer for session ${linearAgentActivitySessionId}, iteration ${iteration}`);
+        try {
+            await this.resumeAgentSession(session, repo, linearAgentActivitySessionId, agentSessionManager, fixerPrompt, "", // No attachment manifest
+            false, // Not a new session
+            [], // No additional allowed directories
+            undefined);
+            console.log(`[Validation Loop] Successfully started fixer for iteration ${iteration}`);
+        }
+        catch (error) {
+            console.error(`[Validation Loop] Failed to run fixer for iteration ${iteration}:`, error);
+        }
+    }
+    /**
+     * Handle validation loop rerun - re-run the verifications subroutine
+     */
+    async handleValidationLoopRerun(linearAgentActivitySessionId, session, repo, agentSessionManager) {
+        console.log(`[Validation Loop] Re-running verifications for session ${linearAgentActivitySessionId}`);
+        // Get the verifications subroutine definition
+        const verificationsSubroutine = this.procedureAnalyzer.getCurrentSubroutine(session);
+        if (!verificationsSubroutine ||
+            verificationsSubroutine.name !== "verifications") {
+            console.error(`[Validation Loop] Expected verifications subroutine, got: ${verificationsSubroutine?.name}`);
+            return;
+        }
+        try {
+            // Load the verifications prompt
+            const subroutinePrompt = await this.loadSubroutinePrompt(verificationsSubroutine, this.config.linearWorkspaceSlug);
+            if (!subroutinePrompt) {
+                console.error(`[Validation Loop] Failed to load verifications prompt`);
+                return;
+            }
+            await this.resumeAgentSession(session, repo, linearAgentActivitySessionId, agentSessionManager, subroutinePrompt, "", // No attachment manifest
+            false, // Not a new session
+            [], // No additional allowed directories
+            undefined);
+            console.log(`[Validation Loop] Successfully re-started verifications`);
+        }
+        catch (error) {
+            console.error(`[Validation Loop] Failed to re-run verifications:`, error);
+        }
+    }
     /**
      * Start watching config file for changes
      */
@@ -506,21 +657,35 @@ export class EdgeWorker extends EventEmitter {
                 // Add to internal map
                 this.repositories.set(repo.id, resolvedRepo);
                 // Create issue tracker
-                const linearClient = new LinearClient({
-                    accessToken: repo.linearToken,
-                });
-                const issueTracker = new LinearIssueTrackerService(linearClient);
+                const issueTracker = this.config.platform === "cli"
+                    ? (() => {
+                        const service = new CLIIssueTrackerService();
+                        service.seedDefaultData();
+                        return service;
+                    })()
+                    : new LinearIssueTrackerService(new LinearClient({
+                        accessToken: repo.linearToken,
+                    }));
                 this.issueTrackers.set(repo.id, issueTracker);
                 // Create AgentSessionManager with same pattern as constructor
                 const agentSessionManager = new AgentSessionManager(issueTracker, (childSessionId) => {
                     return this.childToParentAgentSession.get(childSessionId);
                 }, async (parentSessionId, prompt, childSessionId) => {
                     await this.handleResumeParentSession(parentSessionId, prompt, childSessionId, repo, agentSessionManager);
-                }, this.procedureRouter, this.sharedApplicationServer);
+                }, this.procedureAnalyzer, this.sharedApplicationServer);
                 // Subscribe to subroutine completion events
                 agentSessionManager.on("subroutineComplete", async ({ linearAgentActivitySessionId, session }) => {
                     await this.handleSubroutineTransition(linearAgentActivitySessionId, session, repo, agentSessionManager);
                 });
+                // Subscribe to validation loop events
+                agentSessionManager.on("validationLoopIteration", async ({ linearAgentActivitySessionId, session, fixerPrompt, iteration, maxIterations, }) => {
+                    console.log(`[EdgeWorker] Validation loop iteration ${iteration}/${maxIterations}, running fixer`);
+                    await this.handleValidationLoopFixer(linearAgentActivitySessionId, session, repo, agentSessionManager, fixerPrompt, iteration);
+                });
+                agentSessionManager.on("validationLoopRerun", async ({ linearAgentActivitySessionId, session, iteration }) => {
+                    console.log(`[EdgeWorker] Validation loop re-running verifications (iteration ${iteration})`);
+                    await this.handleValidationLoopRerun(linearAgentActivitySessionId, session, repo, agentSessionManager);
+                });
                 this.agentSessionManagers.set(repo.id, agentSessionManager);
                 console.log(`✅ Repository added successfully: ${repo.name}`);
             }
@@ -563,10 +728,15 @@ export class EdgeWorker extends EventEmitter {
                 // If token changed, recreate issue tracker
                 if (oldRepo.linearToken !== repo.linearToken) {
                     console.log(`  🔑 Token changed, recreating issue tracker`);
-                    const linearClient = new LinearClient({
-                        accessToken: repo.linearToken,
-                    });
-                    const issueTracker = new LinearIssueTrackerService(linearClient);
+                    const issueTracker = this.config.platform === "cli"
+                        ? (() => {
+                            const service = new CLIIssueTrackerService();
+                            service.seedDefaultData();
+                            return service;
+                        })()
+                        : new LinearIssueTrackerService(new LinearClient({
+                            accessToken: repo.linearToken,
+                        }));
                     this.issueTrackers.set(repo.id, issueTracker);
                 }
                 // If active status changed
@@ -654,6 +824,8 @@ export class EdgeWorker extends EventEmitter {
      * Handle webhook events from proxy - main router for all webhooks
      */
     async handleWebhook(webhook, repos) {
+        // Track active webhook processing for status endpoint
+        this.activeWebhookCount++;
         // Log verbose webhook info if enabled
         if (process.env.CYRUS_WEBHOOK_DEBUG === "true") {
             console.log(`[handleWebhook] Full webhook payload:`, JSON.stringify(webhook, null, 2));
@@ -691,6 +863,10 @@ export class EdgeWorker extends EventEmitter {
             // Don't re-throw webhook processing errors to prevent application crashes
             // The error has been logged and individual webhook failures shouldn't crash the entire system
         }
+        finally {
+            // Always decrement counter when webhook processing completes
+            this.activeWebhookCount--;
+        }
     }
     /**
      * Handle issue unassignment webhook
@@ -742,12 +918,10 @@ export class EdgeWorker extends EventEmitter {
         // Move issue to started state automatically, in case it's not already
         await this.moveIssueToStartedState(fullIssue, repository.id);
         // Create workspace using full issue data
+        // Use custom handler if provided, otherwise create a git worktree by default
         const workspace = this.config.handlers?.createWorkspace
             ? await this.config.handlers.createWorkspace(fullIssue, repository)
-            : {
-                path: `${repository.workspaceBaseDir}/${fullIssue.identifier}`,
-                isGitWorktree: false,
-            };
+            : await this.gitService.createGitWorktree(fullIssue, repository);
         console.log(`[EdgeWorker] Workspace created at: ${workspace.path}`);
         const issueMinimal = this.convertLinearIssueToCore(fullIssue);
         agentSessionManager.createLinearAgentSession(linearAgentActivitySessionId, issue.id, issueMinimal, workspace);
@@ -893,7 +1067,7 @@ export class EdgeWorker extends EventEmitter {
             session.metadata = {};
         }
         // Post ephemeral "Routing..." thought
-        await agentSessionManager.postRoutingThought(linearAgentActivitySessionId);
+        await agentSessionManager.postAnalyzingThought(linearAgentActivitySessionId);
         // Fetch labels early (needed for label override check)
         const labels = await this.fetchIssueLabels(fullIssue);
         // Check for label overrides BEFORE AI routing
@@ -905,13 +1079,19 @@ export class EdgeWorker extends EventEmitter {
         const orchestratorConfig = repository.labelPrompts?.orchestrator;
         const orchestratorLabels = Array.isArray(orchestratorConfig)
             ? orchestratorConfig
-            : orchestratorConfig?.labels;
+            : (orchestratorConfig?.labels ?? ["orchestrator"]);
         const hasOrchestratorLabel = orchestratorLabels?.some((label) => labels.includes(label));
+        // Check for graphite label (for graphite-orchestrator combination)
+        const graphiteConfig = repository.labelPrompts?.graphite;
+        const graphiteLabels = graphiteConfig?.labels ?? ["graphite"];
+        const hasGraphiteLabel = graphiteLabels?.some((label) => labels.includes(label));
+        // Graphite-orchestrator requires BOTH graphite AND orchestrator labels
+        const hasGraphiteOrchestratorLabels = hasGraphiteLabel && hasOrchestratorLabel;
         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");
+            const debuggerProcedure = this.procedureAnalyzer.getProcedure("debugger-full");
             if (!debuggerProcedure) {
                 throw new Error("debugger-full procedure not found in registry");
             }
@@ -919,8 +1099,19 @@ export class EdgeWorker extends EventEmitter {
             finalClassification = "debugger";
             console.log(`[EdgeWorker] Using debugger-full procedure due to debugger label (skipping AI routing)`);
         }
+        else if (hasGraphiteOrchestratorLabels) {
+            // Graphite-orchestrator takes precedence over regular orchestrator when both labels present
+            const orchestratorProcedure = this.procedureAnalyzer.getProcedure("orchestrator-full");
+            if (!orchestratorProcedure) {
+                throw new Error("orchestrator-full procedure not found in registry");
+            }
+            finalProcedure = orchestratorProcedure;
+            // Use orchestrator classification but the system prompt will be graphite-orchestrator
+            finalClassification = "orchestrator";
+            console.log(`[EdgeWorker] Using orchestrator-full procedure with graphite-orchestrator prompt (graphite + orchestrator labels)`);
+        }
         else if (hasOrchestratorLabel) {
-            const orchestratorProcedure = this.procedureRouter.getProcedure("orchestrator-full");
+            const orchestratorProcedure = this.procedureAnalyzer.getProcedure("orchestrator-full");
             if (!orchestratorProcedure) {
                 throw new Error("orchestrator-full procedure not found in registry");
             }
@@ -931,7 +1122,7 @@ export class EdgeWorker extends EventEmitter {
         else {
             // No label override - use AI routing
             const issueDescription = `${issue.title}\n\n${fullIssue.description || ""}`.trim();
-            const routingDecision = await this.procedureRouter.determineRoutine(issueDescription);
+            const routingDecision = await this.procedureAnalyzer.determineRoutine(issueDescription);
             finalProcedure = routingDecision.procedure;
             finalClassification = routingDecision.classification;
             // Log AI routing decision
@@ -941,7 +1132,7 @@ export class EdgeWorker extends EventEmitter {
             console.log(`  Reasoning: ${routingDecision.reasoning}`);
         }
         // Initialize procedure metadata in session with final decision
-        this.procedureRouter.initializeProcedureMetadata(session, finalProcedure);
+        this.procedureAnalyzer.initializeProcedureMetadata(session, finalProcedure);
         // Post single procedure selection result (replaces ephemeral routing thought)
         await agentSessionManager.postProcedureSelectionThought(linearAgentActivitySessionId, finalProcedure.name, finalClassification);
         // Build and start Claude with initial prompt using full issue (streaming mode)
@@ -986,7 +1177,7 @@ export class EdgeWorker extends EventEmitter {
                 console.log(`[EdgeWorker] Configured disallowed tools for ${fullIssue.identifier}:`, disallowedTools);
             }
             // Get current subroutine to check for singleTurn mode
-            const currentSubroutine = this.procedureRouter.getCurrentSubroutine(session);
+            const currentSubroutine = this.procedureAnalyzer.getCurrentSubroutine(session);
             // Create agent runner with system prompt from assembly
             // buildAgentRunnerConfig now determines runner type from labels internally
             const { config: runnerConfig, runnerType } = this.buildAgentRunnerConfig(session, repository, linearAgentActivitySessionId, assembly.systemPrompt, allowedTools, allowedDirectories, disallowedTools, undefined, // resumeSessionId
@@ -1001,7 +1192,7 @@ export class EdgeWorker extends EventEmitter {
             agentSessionManager.addAgentRunner(linearAgentActivitySessionId, runner);
             // Save state after mapping changes
             await this.savePersistedState();
-            // Emit events using full Linear issue
+            // Emit events using full issue (core Issue type)
             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)
@@ -1110,6 +1301,33 @@ export class EdgeWorker extends EventEmitter {
         // Initialize agent runner with the selected repository
         await this.initializeAgentRunner(agentSession, repository, guidance, commentBody);
     }
+    /**
+     * Handle AskUserQuestion response from prompted webhook
+     * Branch 2.5: User response to a question posed via AskUserQuestion tool
+     *
+     * @param webhook The prompted webhook containing user's response
+     */
+    async handleAskUserQuestionResponse(webhook) {
+        const { agentSession, agentActivity } = webhook;
+        const agentSessionId = agentSession.id;
+        if (!agentActivity) {
+            console.warn("[EdgeWorker] Cannot handle AskUserQuestion response without agentActivity");
+            // Resolve with a denial to unblock the waiting promise
+            this.askUserQuestionHandler.cancelPendingQuestion(agentSessionId, "No agent activity in webhook");
+            return;
+        }
+        // Extract the user's response from the activity body
+        const userResponse = agentActivity.content?.body || "";
+        console.log(`[EdgeWorker] Processing AskUserQuestion response for session ${agentSessionId}: "${userResponse}"`);
+        // Pass the response to the handler to resolve the waiting promise
+        const handled = this.askUserQuestionHandler.handleUserResponse(agentSessionId, userResponse);
+        if (!handled) {
+            console.warn(`[EdgeWorker] AskUserQuestion response not handled for session ${agentSessionId} (no pending question)`);
+        }
+        else {
+            console.log(`[EdgeWorker] AskUserQuestion response handled for session ${agentSessionId}`);
+        }
+    }
     /**
      * Handle normal prompted activity (existing session continuation)
      * Branch 3 of agentSessionPrompted (see packages/CLAUDE.md)
@@ -1149,6 +1367,7 @@ export class EdgeWorker extends EventEmitter {
             console.log(`[EdgeWorker] Created new session ${linearAgentActivitySessionId} (prompted webhook)`);
             // Save state and emit events for new session
             await this.savePersistedState();
+            // Emit events using full issue (core Issue type)
             this.emit("session:started", fullIssue.id, fullIssue, repository.id);
             this.config.handlers?.onSessionStart?.(fullIssue.id, fullIssue, repository.id);
         }
@@ -1263,6 +1482,13 @@ export class EdgeWorker extends EventEmitter {
             await this.handleRepositorySelectionResponse(webhook);
             return;
         }
+        // Branch 2.5: Handle AskUserQuestion response
+        // This handles responses to questions posed via the AskUserQuestion tool.
+        // The response is passed to the pending promise resolver.
+        if (this.askUserQuestionHandler.hasPendingQuestion(agentSessionId)) {
+            await this.handleAskUserQuestionResponse(webhook);
+            return;
+        }
         // Branch 3: Handle normal prompted activity (existing session continuation)
         // Per CLAUDE.md: "an agentSession MUST exist and a repository MUST already
         // be associated with the Linear issue. The repository will be retrieved from
@@ -1321,7 +1547,11 @@ export class EdgeWorker extends EventEmitter {
      */
     async handleClaudeError(error) {
         // AbortError is expected when user stops Claude process, don't log it
-        if (error instanceof AbortError) {
+        // Check by name since the SDK's AbortError class may not match our imported definition
+        const isAbortError = error.name === "AbortError" || error.message.includes("aborted by user");
+        // Also check for SIGTERM (exit code 143), which indicates graceful termination
+        const isSigterm = error.message.includes("Claude Code process exited with code 143");
+        if (isAbortError || isSigterm) {
             return;
         }
         console.error("Unhandled claude error:", error);
@@ -1353,8 +1583,8 @@ export class EdgeWorker extends EventEmitter {
         if (!labels || labels.length === 0) {
             return {
                 runnerType: "claude",
-                modelOverride: "sonnet",
-                fallbackModelOverride: "haiku",
+                modelOverride: "opus",
+                fallbackModelOverride: "sonnet",
             };
         }
         const lowercaseLabels = labels.map((label) => label.toLowerCase());
@@ -1415,8 +1645,8 @@ export class EdgeWorker extends EventEmitter {
         // Default to claude if no runner labels found
         return {
             runnerType: "claude",
-            modelOverride: "sonnet",
-            fallbackModelOverride: "haiku",
+            modelOverride: "opus",
+            fallbackModelOverride: "sonnet",
         };
     }
     /**
@@ -1426,6 +1656,38 @@ export class EdgeWorker extends EventEmitter {
         if (!repository.labelPrompts || labels.length === 0) {
             return undefined;
         }
+        // Check for graphite-orchestrator first (requires BOTH graphite AND orchestrator labels)
+        const graphiteConfig = repository.labelPrompts.graphite;
+        const graphiteLabels = graphiteConfig?.labels ?? ["graphite"];
+        const hasGraphiteLabel = graphiteLabels?.some((label) => labels.includes(label));
+        const orchestratorConfig = repository.labelPrompts.orchestrator;
+        const orchestratorLabels = Array.isArray(orchestratorConfig)
+            ? orchestratorConfig
+            : (orchestratorConfig?.labels ?? ["orchestrator"]);
+        const hasOrchestratorLabel = orchestratorLabels?.some((label) => labels.includes(label));
+        // If both graphite AND orchestrator labels are present, use graphite-orchestrator prompt
+        if (hasGraphiteLabel && hasOrchestratorLabel) {
+            try {
+                const __filename = fileURLToPath(import.meta.url);
+                const __dirname = dirname(__filename);
+                const promptPath = join(__dirname, "..", "prompts", "graphite-orchestrator.md");
+                const promptContent = await readFile(promptPath, "utf-8");
+                console.log(`[EdgeWorker] Using graphite-orchestrator system prompt for labels: ${labels.join(", ")}`);
+                const promptVersion = this.extractVersionTag(promptContent);
+                if (promptVersion) {
+                    console.log(`[EdgeWorker] graphite-orchestrator system prompt version: ${promptVersion}`);
+                }
+                return {
+                    prompt: promptContent,
+                    version: promptVersion,
+                    type: "graphite-orchestrator",
+                };
+            }
+            catch (error) {
+                console.error(`[EdgeWorker] Failed to load graphite-orchestrator prompt template:`, error);
+                // Fall through to regular orchestrator if graphite-orchestrator prompt fails
+            }
+        }
         // Check each prompt type for matching labels
         const promptTypes = [
             "debugger",
@@ -1665,40 +1927,44 @@ Focus on addressing the specific request in the mention. You can use the Linear
         return formatted;
     }
     /**
-     * Check if a branch exists locally or remotely
-     */
-    async branchExists(branchName, repoPath) {
-        const { execSync } = await import("node:child_process");
-        try {
-            // Check if branch exists locally
-            execSync(`git rev-parse --verify "${branchName}"`, {
-                cwd: repoPath,
-                stdio: "pipe",
-            });
-            return true;
-        }
-        catch {
-            // Branch doesn't exist locally, check remote
-            try {
-                execSync(`git ls-remote --heads origin "${branchName}"`, {
-                    cwd: repoPath,
-                    stdio: "pipe",
-                });
-                return true;
-            }
-            catch {
-                // Branch doesn't exist remotely either
-                return false;
-            }
-        }
-    }
-    /**
-     * Determine the base branch for an issue, considering parent issues
+     * Determine the base branch for an issue, considering parent issues and blocked-by relationships
+     *
+     * Priority order:
+     * 1. If issue has graphite label AND has a "blocked by" relationship, use the blocking issue's branch
+     *    (This enables Graphite stacking where each sub-issue branches off the previous)
+     * 2. If issue has a parent, use the parent's branch
+     * 3. Fall back to repository's default base branch
      */
     async determineBaseBranch(issue, repository) {
         // Start with the repository's default base branch
         let baseBranch = repository.baseBranch;
-        // Check if issue has a parent
+        // Check if this issue has the graphite label - if so, blocked-by relationship takes priority
+        const isGraphiteIssue = await this.hasGraphiteLabel(issue, repository);
+        if (isGraphiteIssue) {
+            // For Graphite stacking: use the blocking issue's branch as base
+            const blockingIssues = await this.fetchBlockingIssues(issue);
+            if (blockingIssues.length > 0) {
+                // Use the first blocking issue's branch (typically there's only one in a stack)
+                const blockingIssue = blockingIssues[0];
+                console.log(`[EdgeWorker] Issue ${issue.identifier} has graphite label and is blocked by ${blockingIssue.identifier}`);
+                // Get blocking issue's branch name
+                const blockingRawBranchName = blockingIssue.branchName ||
+                    `${blockingIssue.identifier}-${(blockingIssue.title ?? "")
+                        .toLowerCase()
+                        .replace(/\s+/g, "-")
+                        .substring(0, 30)}`;
+                const blockingBranchName = this.gitService.sanitizeBranchName(blockingRawBranchName);
+                // Check if blocking issue's branch exists
+                const blockingBranchExists = await this.gitService.branchExists(blockingBranchName, repository.repositoryPath);
+                if (blockingBranchExists) {
+                    baseBranch = blockingBranchName;
+                    console.log(`[EdgeWorker] Using blocking issue branch '${blockingBranchName}' as base for Graphite-stacked issue ${issue.identifier}`);
+                    return baseBranch;
+                }
+                console.log(`[EdgeWorker] Blocking issue branch '${blockingBranchName}' not found, falling back to parent/default`);
+            }
+        }
+        // Check if issue has a parent (standard sub-issue behavior)
         try {
             const parent = await issue.parent;
             if (parent) {
@@ -1709,9 +1975,9 @@ Focus on addressing the specific request in the mention. You can use the Linear
                         ?.toLowerCase()
                         .replace(/\s+/g, "-")
                         .substring(0, 30)}`;
-                const parentBranchName = this.sanitizeBranchName(parentRawBranchName);
+                const parentBranchName = this.gitService.sanitizeBranchName(parentRawBranchName);
                 // Check if parent branch exists
-                const parentBranchExists = await this.branchExists(parentBranchName, repository.repositoryPath);
+                const parentBranchExists = await this.gitService.branchExists(parentBranchName, repository.repositoryPath);
                 if (parentBranchExists) {
                     baseBranch = parentBranchName;
                     console.log(`[EdgeWorker] Using parent issue branch '${parentBranchName}' as base for sub-issue ${issue.identifier}`);
@@ -1740,10 +2006,60 @@ Focus on addressing the specific request in the mention. You can use the Linear
         };
     }
     /**
-     * Sanitize branch name by removing backticks to prevent command injection
+     * Fetch issues that block this issue (i.e., issues this one is "blocked by")
+     * Uses the inverseRelations field with type "blocks"
+     *
+     * Linear relations work like this:
+     * - When Issue A "blocks" Issue B, a relation is created with:
+     *   - issue = A (the blocker)
+     *   - relatedIssue = B (the blocked one)
+     *   - type = "blocks"
+     *
+     * So to find "who blocks Issue B", we need inverseRelations (where B is the relatedIssue)
+     * and look for type === "blocks", then get the `issue` field (the blocker).
+     *
+     * @param issue The issue to fetch blocking issues for
+     * @returns Array of issues that block this one, or empty array if none
+     */
+    async fetchBlockingIssues(issue) {
+        try {
+            // inverseRelations contains relations where THIS issue is the relatedIssue
+            // When type is "blocks", it means the `issue` field blocks THIS issue
+            const inverseRelations = await issue.inverseRelations();
+            if (!inverseRelations?.nodes) {
+                return [];
+            }
+            const blockingIssues = [];
+            for (const relation of inverseRelations.nodes) {
+                // "blocks" type in inverseRelations means the `issue` blocks this one
+                if (relation.type === "blocks") {
+                    // The `issue` field is the one that blocks THIS issue
+                    const blockingIssue = await relation.issue;
+                    if (blockingIssue) {
+                        blockingIssues.push(blockingIssue);
+                    }
+                }
+            }
+            console.log(`[EdgeWorker] Issue ${issue.identifier} is blocked by ${blockingIssues.length} issue(s): ${blockingIssues.map((i) => i.identifier).join(", ") || "none"}`);
+            return blockingIssues;
+        }
+        catch (error) {
+            console.error(`[EdgeWorker] Failed to fetch blocking issues for ${issue.identifier}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Check if an issue has the graphite label
+     *
+     * @param issue The issue to check
+     * @param repository The repository configuration
+     * @returns True if the issue has the graphite label
      */
-    sanitizeBranchName(name) {
-        return name ? name.replace(/`/g, "") : name;
+    async hasGraphiteLabel(issue, repository) {
+        const graphiteConfig = repository.labelPrompts?.graphite;
+        const graphiteLabels = graphiteConfig?.labels ?? ["graphite"];
+        const issueLabels = await this.fetchIssueLabels(issue);
+        return graphiteLabels.some((label) => issueLabels.includes(label));
     }
     /**
      * Format Linear comments into a threaded structure that mirrors the Linear UI
@@ -1887,7 +2203,7 @@ ${reply.body}
                 ? "Will be created based on issue"
                 : repository.repositoryPath)
                 .replace(/{{base_branch}}/g, baseBranch)
-                .replace(/{{branch_name}}/g, this.sanitizeBranchName(issue.branchName));
+                .replace(/{{branch_name}}/g, this.gitService.sanitizeBranchName(issue.branchName));
             // Handle the optional new comment section
             if (newComment) {
                 // Replace the conditional block
@@ -2709,7 +3025,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
         parts.push(issueContext.prompt);
         components.push("issue-context");
         // 4. Load and append initial subroutine prompt
-        const currentSubroutine = this.procedureRouter.getCurrentSubroutine(input.session);
+        const currentSubroutine = this.procedureAnalyzer.getCurrentSubroutine(input.session);
         let subroutineName;
         if (currentSubroutine) {
             const subroutinePrompt = await this.loadSubroutinePrompt(currentSubroutine, this.config.linearWorkspaceSlug);
@@ -2936,6 +3252,12 @@ ${input.userComment}
                 repository.fallbackModel ||
                 this.config.defaultFallbackModel,
             hooks,
+            // Enable Chrome integration for Claude runner (disabled for other runners)
+            ...(runnerType === "claude" && { extraArgs: { chrome: null } }),
+            // AskUserQuestion callback - only for Claude runner
+            ...(runnerType === "claude" && {
+                onAskUserQuestion: this.createAskUserQuestionCallback(linearAgentActivitySessionId, repository.linearWorkspaceId),
+            }),
             onMessage: (message) => {
                 this.handleClaudeMessage(linearAgentActivitySessionId, message, repository.id);
             },
@@ -2952,23 +3274,43 @@ ${input.userComment}
         }
         return { config, runnerType };
     }
+    /**
+     * Create an onAskUserQuestion callback for the ClaudeRunner.
+     * This callback delegates to the AskUserQuestionHandler which posts
+     * elicitations to Linear and waits for user responses.
+     *
+     * @param linearAgentSessionId - Linear agent session ID for tracking
+     * @param organizationId - Linear organization/workspace ID
+     */
+    createAskUserQuestionCallback(linearAgentSessionId, organizationId) {
+        return async (input, _sessionId, signal) => {
+            // Note: We use linearAgentSessionId (from closure) instead of the passed sessionId
+            // because the passed sessionId is the Claude session ID, not the Linear agent session ID
+            return this.askUserQuestionHandler.handleAskUserQuestion(input, linearAgentSessionId, organizationId, signal);
+        };
+    }
     /**
      * Build disallowed tools list following the same hierarchy as allowed tools
      */
     buildDisallowedTools(repository, promptType) {
+        // graphite-orchestrator uses the same tool config as orchestrator
+        const effectivePromptType = promptType === "graphite-orchestrator" ? "orchestrator" : promptType;
         let disallowedTools = [];
         let toolSource = "";
         // Priority order (same as allowedTools):
         // 1. Repository-specific prompt type configuration
-        if (promptType && repository.labelPrompts?.[promptType]?.disallowedTools) {
-            disallowedTools = repository.labelPrompts[promptType].disallowedTools;
-            toolSource = `repository label prompt (${promptType})`;
+        if (effectivePromptType &&
+            repository.labelPrompts?.[effectivePromptType]?.disallowedTools) {
+            disallowedTools =
+                repository.labelPrompts[effectivePromptType].disallowedTools;
+            toolSource = `repository label prompt (${effectivePromptType})`;
         }
         // 2. Global prompt type defaults
-        else if (promptType &&
-            this.config.promptDefaults?.[promptType]?.disallowedTools) {
-            disallowedTools = this.config.promptDefaults[promptType].disallowedTools;
-            toolSource = `global prompt defaults (${promptType})`;
+        else if (effectivePromptType &&
+            this.config.promptDefaults?.[effectivePromptType]?.disallowedTools) {
+            disallowedTools =
+                this.config.promptDefaults[effectivePromptType].disallowedTools;
+            toolSource = `global prompt defaults (${effectivePromptType})`;
         }
         // 3. Repository-level disallowed tools
         else if (repository.disallowedTools) {
@@ -2998,7 +3340,7 @@ ${input.userComment}
      * @returns Merged disallowed tools list
      */
     mergeSubroutineDisallowedTools(session, baseDisallowedTools, logContext) {
-        const currentSubroutine = this.procedureRouter.getCurrentSubroutine(session);
+        const currentSubroutine = this.procedureAnalyzer.getCurrentSubroutine(session);
         if (currentSubroutine?.disallowedTools) {
             const mergedTools = [
                 ...new Set([
@@ -3015,19 +3357,22 @@ ${input.userComment}
      * Build allowed tools list with Linear MCP tools automatically included
      */
     buildAllowedTools(repository, promptType) {
+        // graphite-orchestrator uses the same tool config as orchestrator
+        const effectivePromptType = promptType === "graphite-orchestrator" ? "orchestrator" : promptType;
         let baseTools = [];
         let toolSource = "";
         // Priority order:
         // 1. Repository-specific prompt type configuration
-        if (promptType && repository.labelPrompts?.[promptType]?.allowedTools) {
-            baseTools = this.resolveToolPreset(repository.labelPrompts[promptType].allowedTools);
-            toolSource = `repository label prompt (${promptType})`;
+        if (effectivePromptType &&
+            repository.labelPrompts?.[effectivePromptType]?.allowedTools) {
+            baseTools = this.resolveToolPreset(repository.labelPrompts[effectivePromptType].allowedTools);
+            toolSource = `repository label prompt (${effectivePromptType})`;
         }
         // 2. Global prompt type defaults
-        else if (promptType &&
-            this.config.promptDefaults?.[promptType]?.allowedTools) {
-            baseTools = this.resolveToolPreset(this.config.promptDefaults[promptType].allowedTools);
-            toolSource = `global prompt defaults (${promptType})`;
+        else if (effectivePromptType &&
+            this.config.promptDefaults?.[effectivePromptType]?.allowedTools) {
+            baseTools = this.resolveToolPreset(this.config.promptDefaults[effectivePromptType].allowedTools);
+            toolSource = `global prompt defaults (${effectivePromptType})`;
         }
         // 3. Repository-level allowed tools
         else if (repository.allowedTools) {
@@ -3261,7 +3606,7 @@ ${input.userComment}
             session.metadata = {};
         }
         // Post ephemeral "Routing..." thought
-        await agentSessionManager.postRoutingThought(linearAgentActivitySessionId);
+        await agentSessionManager.postAnalyzingThought(linearAgentActivitySessionId);
         // Fetch full issue and labels to check for Orchestrator label override
         const issueTracker = this.issueTrackers.get(repository.id);
         let hasOrchestratorLabel = false;
@@ -3273,7 +3618,7 @@ ${input.userComment}
                 const orchestratorConfig = repository.labelPrompts?.orchestrator;
                 const orchestratorLabels = Array.isArray(orchestratorConfig)
                     ? orchestratorConfig
-                    : orchestratorConfig?.labels;
+                    : (orchestratorConfig?.labels ?? ["orchestrator"]);
                 hasOrchestratorLabel =
                     orchestratorLabels?.some((label) => labels.includes(label)) || false;
             }
@@ -3286,7 +3631,7 @@ ${input.userComment}
         let finalClassification;
         // If Orchestrator label is present, ALWAYS use orchestrator-full procedure
         if (hasOrchestratorLabel) {
-            const orchestratorProcedure = this.procedureRouter.getProcedure("orchestrator-full");
+            const orchestratorProcedure = this.procedureAnalyzer.getProcedure("orchestrator-full");
             if (!orchestratorProcedure) {
                 throw new Error("orchestrator-full procedure not found in registry");
             }
@@ -3296,7 +3641,7 @@ ${input.userComment}
         }
         else {
             // No Orchestrator label - use AI routing based on prompt content
-            const routingDecision = await this.procedureRouter.determineRoutine(promptBody.trim());
+            const routingDecision = await this.procedureAnalyzer.determineRoutine(promptBody.trim());
             selectedProcedure = routingDecision.procedure;
             finalClassification = routingDecision.classification;
             // Log AI routing decision
@@ -3306,7 +3651,7 @@ ${input.userComment}
             console.log(`  Reasoning: ${routingDecision.reasoning}`);
         }
         // Initialize procedure metadata in session (resets currentSubroutine)
-        this.procedureRouter.initializeProcedureMetadata(session, selectedProcedure);
+        this.procedureAnalyzer.initializeProcedureMetadata(session, selectedProcedure);
         // Post procedure selection result (replaces ephemeral routing thought)
         await agentSessionManager.postProcedureSelectionThought(linearAgentActivitySessionId, selectedProcedure.name, finalClassification);
     }
@@ -3412,7 +3757,7 @@ ${input.userComment}
                             const orchestratorConfig = repository.labelPrompts.orchestrator;
                             const orchestratorLabels = Array.isArray(orchestratorConfig)
                                 ? orchestratorConfig
-                                : orchestratorConfig?.labels;
+                                : (orchestratorConfig?.labels ?? ["orchestrator"]);
                             const orchestratorLabel = orchestratorLabels?.find((label) => labels.includes(label));
                             if (orchestratorLabel) {
                                 selectedPromptType = "orchestrator";
@@ -3505,7 +3850,7 @@ ${input.userComment}
             ...additionalAllowedDirectories,
         ];
         // Get current subroutine to check for singleTurn mode
-        const currentSubroutine = this.procedureRouter.getCurrentSubroutine(session);
+        const currentSubroutine = this.procedureAnalyzer.getCurrentSubroutine(session);
         const resumeSessionId = needsNewSession
             ? undefined
             : session.claudeSessionId