cyrus-edge-worker 0.2.0 → 0.2.2

package/dist/EdgeWorker.js

@@ -11,6 +11,7 @@ import { LinearEventTransport } from "cyrus-linear-event-transport";
 import { fileTypeFromBuffer } from "file-type";
 import { AgentSessionManager } from "./AgentSessionManager.js";
 import { ProcedureRouter, } from "./procedures/index.js";
+import { RepositoryRouter, } from "./RepositoryRouter.js";
 import { SharedApplicationServer } from "./SharedApplicationServer.js";
 /**
  * Unified edge worker that **orchestrates**
@@ -32,6 +33,8 @@ export class EdgeWorker extends EventEmitter {
     procedureRouter; // 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
     constructor(config) {
         super();
         this.config = config;
@@ -43,6 +46,36 @@ export class EdgeWorker extends EventEmitter {
             model: "haiku",
             timeoutMs: 10000,
         });
+        // Initialize repository router with dependencies
+        const repositoryRouterDeps = {
+            fetchIssueLabels: async (issueId, workspaceId) => {
+                // Get Linear client for this workspace
+                const linearClient = this.getLinearClientForWorkspace(workspaceId);
+                if (!linearClient) {
+                    console.warn(`[EdgeWorker] No Linear client found for workspace ${workspaceId}`);
+                    return [];
+                }
+                try {
+                    const issue = await linearClient.issue(issueId);
+                    return await this.fetchIssueLabels(issue);
+                }
+                catch (error) {
+                    console.error(`[EdgeWorker] Failed to fetch issue labels for ${issueId}:`, error);
+                    return [];
+                }
+            },
+            hasActiveSession: (issueId, repositoryId) => {
+                const sessionManager = this.agentSessionManagers.get(repositoryId);
+                if (!sessionManager)
+                    return false;
+                const activeSessions = sessionManager.getActiveSessionsByIssueId(issueId);
+                return activeSessions.length > 0;
+            },
+            getLinearClient: (workspaceId) => {
+                return this.getLinearClientForWorkspace(workspaceId);
+            },
+        };
+        this.repositoryRouter = new RepositoryRouter(repositoryRouterDeps);
         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
@@ -108,16 +141,16 @@ export class EdgeWorker extends EventEmitter {
                     }
                     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)`);
+                        subroutinePrompt = await this.loadSubroutinePrompt(nextSubroutine, this.config.linearWorkspaceSlug);
+                        if (!subroutinePrompt) {
+                            // Fallback if loadSubroutinePrompt returns null
+                            subroutinePrompt = `Continue with: ${nextSubroutine.description}`;
+                        }
                     }
                     catch (error) {
-                        console.error(`[Subroutine Transition] Failed to load subroutine prompt from ${subroutinePromptPath}:`, error);
+                        console.error(`[Subroutine Transition] Failed to load subroutine prompt:`, error);
                         // Fallback to simple prompt
                         subroutinePrompt = `Continue with: ${nextSubroutine.description}`;
                     }
@@ -375,6 +408,7 @@ export class EdgeWorker extends EventEmitter {
                 ...this.config,
                 repositories: parsedConfig.repositories || [],
                 ngrokAuthToken: parsedConfig.ngrokAuthToken || this.config.ngrokAuthToken,
+                linearWorkspaceSlug: parsedConfig.linearWorkspaceSlug || this.config.linearWorkspaceSlug,
                 defaultModel: parsedConfig.defaultModel || this.config.defaultModel,
                 defaultFallbackModel: parsedConfig.defaultFallbackModel || this.config.defaultFallbackModel,
                 defaultAllowedTools: parsedConfig.defaultAllowedTools || this.config.defaultAllowedTools,
@@ -603,29 +637,21 @@ export class EdgeWorker extends EventEmitter {
         this.config.handlers?.onError?.(error);
     }
     /**
-     * Handle webhook events from proxy - now accepts native webhook payloads
+     * Get cached repository for an issue (used by agentSessionPrompted Branch 3)
+     */
+    getCachedRepository(issueId) {
+        return this.repositoryRouter.getCachedRepository(issueId, this.repositories);
+    }
+    /**
+     * Handle webhook events from proxy - main router for all webhooks
      */
     async handleWebhook(webhook, repos) {
         // Log verbose webhook info if enabled
         if (process.env.CYRUS_WEBHOOK_DEBUG === "true") {
             console.log(`[handleWebhook] Full webhook payload:`, JSON.stringify(webhook, null, 2));
         }
-        // Find the appropriate repository for this webhook
-        const repository = await this.findRepositoryForWebhook(webhook, repos);
-        if (!repository) {
-            if (process.env.CYRUS_WEBHOOK_DEBUG === "true") {
-                console.log(`[handleWebhook] No repository configured for webhook from workspace ${webhook.organizationId}`);
-                console.log(`[handleWebhook] Available repositories:`, repos.map((r) => ({
-                    name: r.name,
-                    workspaceId: r.linearWorkspaceId,
-                    teamKeys: r.teamKeys,
-                    routingLabels: r.routingLabels,
-                })));
-            }
-            return;
-        }
         try {
-            // Handle specific webhook types with proper typing
+            // Route to specific webhook handlers based on webhook type
             // NOTE: Traditional webhooks (assigned, comment) are disabled in favor of agent session events
             if (isIssueAssignedWebhook(webhook)) {
                 return;
@@ -638,22 +664,22 @@ export class EdgeWorker extends EventEmitter {
             }
             else if (isIssueUnassignedWebhook(webhook)) {
                 // Keep unassigned webhook active
-                await this.handleIssueUnassignedWebhook(webhook, repository);
+                await this.handleIssueUnassignedWebhook(webhook);
             }
             else if (isAgentSessionCreatedWebhook(webhook)) {
-                await this.handleAgentSessionCreatedWebhook(webhook, repository);
+                await this.handleAgentSessionCreatedWebhook(webhook, repos);
             }
             else if (isAgentSessionPromptedWebhook(webhook)) {
-                await this.handleUserPostedAgentActivity(webhook, repository);
+                await this.handleUserPromptedAgentActivity(webhook);
             }
             else {
                 if (process.env.CYRUS_WEBHOOK_DEBUG === "true") {
-                    console.log(`[handleWebhook] Unhandled webhook type: ${webhook.action} for repository ${repository.name}`);
+                    console.log(`[handleWebhook] Unhandled webhook type: ${webhook.action}`);
                 }
             }
         }
         catch (error) {
-            console.error(`[handleWebhook] Failed to process webhook: ${webhook.action} for repository ${repository.name}`, error);
+            console.error(`[handleWebhook] Failed to process webhook: ${webhook.action}`, error);
             // 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
         }
@@ -661,7 +687,14 @@ export class EdgeWorker extends EventEmitter {
     /**
      * Handle issue unassignment webhook
      */
-    async handleIssueUnassignedWebhook(webhook, repository) {
+    async handleIssueUnassignedWebhook(webhook) {
+        const issueId = webhook.notification.issue.id;
+        // Get cached repository (unassignment should only happen on issues with active sessions)
+        const repository = this.getCachedRepository(issueId);
+        if (!repository) {
+            console.log(`[EdgeWorker] No cached repository for issue unassignment webhook ${webhook.notification.issue.identifier} (no active sessions to stop)`);
+            return;
+        }
         console.log(`[EdgeWorker] Handling issue unassignment: ${webhook.notification.issue.identifier}`);
         // Log the complete webhook payload for TypeScript type definition
         // console.log('=== ISSUE UNASSIGNMENT WEBHOOK PAYLOAD ===')
@@ -670,128 +703,15 @@ export class EdgeWorker extends EventEmitter {
         await this.handleIssueUnassigned(webhook.notification.issue, repository);
     }
     /**
-     * Find the repository configuration for a webhook
-     * Now supports async operations for label-based and project-based routing
-     * Priority: routingLabels > projectKeys > teamKeys
-     */
-    async findRepositoryForWebhook(webhook, repos) {
-        const workspaceId = webhook.organizationId;
-        if (!workspaceId)
-            return repos[0] || null; // Fallback to first repo if no workspace ID
-        // Get issue information from webhook
-        let issueId;
-        let teamKey;
-        let issueIdentifier;
-        // Handle agent session webhooks which have different structure
-        if (isAgentSessionCreatedWebhook(webhook) ||
-            isAgentSessionPromptedWebhook(webhook)) {
-            issueId = webhook.agentSession?.issue?.id;
-            teamKey = webhook.agentSession?.issue?.team?.key;
-            issueIdentifier = webhook.agentSession?.issue?.identifier;
-        }
-        else {
-            issueId = webhook.notification?.issue?.id;
-            teamKey = webhook.notification?.issue?.team?.key;
-            issueIdentifier = webhook.notification?.issue?.identifier;
-        }
-        // Filter repos by workspace first
-        const workspaceRepos = repos.filter((repo) => repo.linearWorkspaceId === workspaceId);
-        if (workspaceRepos.length === 0)
-            return null;
-        // Priority 1: Check routing labels (highest priority)
-        const reposWithRoutingLabels = workspaceRepos.filter((repo) => repo.routingLabels && repo.routingLabels.length > 0);
-        if (reposWithRoutingLabels.length > 0 && issueId && workspaceRepos[0]) {
-            // We need a Linear client to fetch labels
-            // Use the first workspace repo's client temporarily
-            const linearClient = this.linearClients.get(workspaceRepos[0].id);
-            if (linearClient) {
-                try {
-                    // Fetch the issue to get labels
-                    const issue = await linearClient.issue(issueId);
-                    const labels = await this.fetchIssueLabels(issue);
-                    // Check each repo with routing labels
-                    for (const repo of reposWithRoutingLabels) {
-                        if (repo.routingLabels?.some((routingLabel) => labels.includes(routingLabel))) {
-                            console.log(`[EdgeWorker] Repository selected: ${repo.name} (label-based routing)`);
-                            return repo;
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(`[EdgeWorker] Failed to fetch labels for routing:`, error);
-                    // Continue to project-based routing
-                }
-            }
-        }
-        // Priority 2: Check project-based routing
-        if (issueId) {
-            const projectBasedRepo = await this.findRepositoryByProject(issueId, workspaceRepos);
-            if (projectBasedRepo) {
-                console.log(`[EdgeWorker] Repository selected: ${projectBasedRepo.name} (project-based routing)`);
-                return projectBasedRepo;
-            }
-        }
-        // Priority 3: Check team-based routing
-        if (teamKey) {
-            const repo = workspaceRepos.find((r) => r.teamKeys?.includes(teamKey));
-            if (repo) {
-                console.log(`[EdgeWorker] Repository selected: ${repo.name} (team-based routing)`);
-                return repo;
-            }
-        }
-        // Try parsing issue identifier as fallback for team routing
-        if (issueIdentifier?.includes("-")) {
-            const prefix = issueIdentifier.split("-")[0];
-            if (prefix) {
-                const repo = workspaceRepos.find((r) => r.teamKeys?.includes(prefix));
-                if (repo) {
-                    console.log(`[EdgeWorker] Repository selected: ${repo.name} (team prefix routing)`);
-                    return repo;
-                }
-            }
-        }
-        // Workspace fallback - find first repo without routing configuration
-        const catchAllRepo = workspaceRepos.find((repo) => (!repo.teamKeys || repo.teamKeys.length === 0) &&
-            (!repo.routingLabels || repo.routingLabels.length === 0) &&
-            (!repo.projectKeys || repo.projectKeys.length === 0));
-        if (catchAllRepo) {
-            console.log(`[EdgeWorker] Repository selected: ${catchAllRepo.name} (workspace catch-all)`);
-            return catchAllRepo;
-        }
-        // Final fallback to first workspace repo
-        const fallbackRepo = workspaceRepos[0] || null;
-        if (fallbackRepo) {
-            console.log(`[EdgeWorker] Repository selected: ${fallbackRepo.name} (workspace fallback)`);
-        }
-        return fallbackRepo;
-    }
-    /**
-     * Helper method to find repository by project name
+     * Get Linear client for a workspace by finding first repository with that workspace ID
      */
-    async findRepositoryByProject(issueId, repos) {
-        // Try each repository that has projectKeys configured
-        for (const repo of repos) {
-            if (!repo.projectKeys || repo.projectKeys.length === 0)
-                continue;
-            try {
-                const fullIssue = await this.fetchFullIssueDetails(issueId, repo.id);
-                const project = await fullIssue?.project;
-                if (!project || !project.name) {
-                    console.warn(`[EdgeWorker] No project name found for issue ${issueId} in repository ${repo.name}`);
-                    continue;
-                }
-                const projectName = project.name;
-                if (repo.projectKeys.includes(projectName)) {
-                    console.log(`[EdgeWorker] Matched issue ${issueId} to repository ${repo.name} via project: ${projectName}`);
-                    return repo;
-                }
-            }
-            catch (error) {
-                // Continue to next repository if this one fails
-                console.debug(`[EdgeWorker] Failed to fetch project for issue ${issueId} from repository ${repo.name}:`, error);
+    getLinearClientForWorkspace(workspaceId) {
+        for (const [repoId, repo] of this.repositories) {
+            if (repo.linearWorkspaceId === workspaceId) {
+                return this.linearClients.get(repoId);
             }
         }
-        return null;
+        return undefined;
     }
     /**
      * Create a new Linear agent session with all necessary setup
@@ -849,13 +769,67 @@ export class EdgeWorker extends EventEmitter {
     }
     /**
      * Handle agent session created webhook
-     * . Can happen due to being 'delegated' or @ mentioned in a new thread
-     * @param webhook
-     * @param repository Repository configuration
-     */
-    async handleAgentSessionCreatedWebhook(webhook, repository) {
+     * Can happen due to being 'delegated' or @ mentioned in a new thread
+     * @param webhook The agent session created webhook
+     * @param repos All available repositories for routing
+     */
+    async handleAgentSessionCreatedWebhook(webhook, repos) {
+        const issueId = webhook.agentSession?.issue?.id;
+        // Check the cache first, as the agentSessionCreated webhook may have been triggered by an @mention
+        // on an issue that already has an agentSession and an associated repository.
+        let repository = null;
+        if (issueId) {
+            repository = this.getCachedRepository(issueId);
+            if (repository) {
+                console.log(`[EdgeWorker] Using cached repository ${repository.name} for issue ${issueId}`);
+            }
+        }
+        // If not cached, perform routing logic
+        if (!repository) {
+            const routingResult = await this.repositoryRouter.determineRepositoryForWebhook(webhook, repos);
+            if (routingResult.type === "none") {
+                if (process.env.CYRUS_WEBHOOK_DEBUG === "true") {
+                    console.log(`[EdgeWorker] No repository configured for webhook from workspace ${webhook.organizationId}`);
+                }
+                return;
+            }
+            // Handle needs_selection case
+            if (routingResult.type === "needs_selection") {
+                await this.repositoryRouter.elicitUserRepositorySelection(webhook, routingResult.workspaceRepos);
+                // Selection in progress - will be handled by handleRepositorySelectionResponse
+                return;
+            }
+            // At this point, routingResult.type === "selected"
+            repository = routingResult.repository;
+            const routingMethod = routingResult.routingMethod;
+            // Cache the repository for this issue
+            if (issueId) {
+                this.repositoryRouter
+                    .getIssueRepositoryCache()
+                    .set(issueId, repository.id);
+            }
+            // Post agent activity showing auto-matched routing
+            await this.postRepositorySelectionActivity(webhook.agentSession.id, repository.id, repository.name, routingMethod);
+        }
         console.log(`[EdgeWorker] Handling agent session created: ${webhook.agentSession.issue.identifier}`);
         const { agentSession, guidance } = webhook;
+        const commentBody = agentSession.comment?.body;
+        // Initialize Claude runner using shared logic
+        await this.initializeClaudeRunner(agentSession, repository, guidance, commentBody);
+    }
+    /**
+
+    /**
+     * Initialize and start Claude runner for an agent session
+     * This method contains the shared logic for creating a Claude runner that both
+     * handleAgentSessionCreatedWebhook and handleUserPromptedAgentActivity use.
+     *
+     * @param agentSession The Linear agent session
+     * @param repository The repository configuration
+     * @param guidance Optional guidance rules from Linear
+     * @param commentBody Optional comment body (for mentions)
+     */
+    async initializeClaudeRunner(agentSession, repository, guidance, commentBody) {
         const linearAgentActivitySessionId = agentSession.id;
         const { issue } = agentSession;
         // Log guidance if present
@@ -874,7 +848,6 @@ export class EdgeWorker extends EventEmitter {
                 console.log(`[EdgeWorker]   - ${origin}: ${rule.body.substring(0, 100)}...`);
             }
         }
-        const commentBody = agentSession.comment?.body;
         // HACK: This is required since the comment body is always populated, thus there is no other way to differentiate between the two trigger events
         const AGENT_SESSION_MARKER = "This thread is for an agent session";
         const isMentionTriggered = commentBody && !commentBody.includes(AGENT_SESSION_MARKER);
@@ -982,7 +955,9 @@ export class EdgeWorker extends EventEmitter {
             }
             // Build allowed tools list with Linear MCP tools (now with prompt type context)
             const allowedTools = this.buildAllowedTools(repository, promptType);
-            const disallowedTools = this.buildDisallowedTools(repository, promptType);
+            const baseDisallowedTools = this.buildDisallowedTools(repository, promptType);
+            // Merge subroutine-level disallowedTools if applicable
+            const disallowedTools = this.mergeSubroutineDisallowedTools(session, baseDisallowedTools, "EdgeWorker");
             console.log(`[EdgeWorker] Configured allowed tools for ${fullIssue.identifier}:`, allowedTools);
             if (disallowedTools.length > 0) {
                 console.log(`[EdgeWorker] Configured disallowed tools for ${fullIssue.identifier}:`, disallowedTools);
@@ -1018,13 +993,78 @@ export class EdgeWorker extends EventEmitter {
         }
     }
     /**
-     * Handle new comment on issue (updated for comment-based sessions)
-     * @param issue Linear issue object from webhook data
-     * @param comment Linear comment object from webhook data
-     * @param repository Repository configuration
+     * Handle stop signal from prompted webhook
+     * Branch 1 of agentSessionPrompted (see packages/CLAUDE.md)
+     *
+     * IMPORTANT: Stop signals do NOT require repository lookup.
+     * The session must already exist (per CLAUDE.md), so we search
+     * all agent session managers to find it.
+     */
+    async handleStopSignal(webhook) {
+        const agentSessionId = webhook.agentSession.id;
+        const { issue } = webhook.agentSession;
+        console.log(`[EdgeWorker] Received stop signal for agent activity session ${agentSessionId}`);
+        // Find the agent session manager that contains this session
+        // We don't need repository lookup - just search all managers
+        let foundManager = null;
+        let foundSession = null;
+        for (const manager of this.agentSessionManagers.values()) {
+            const session = manager.getSession(agentSessionId);
+            if (session) {
+                foundManager = manager;
+                foundSession = session;
+                break;
+            }
+        }
+        if (!foundManager || !foundSession) {
+            console.warn(`[EdgeWorker] No session found for stop signal: ${agentSessionId}`);
+            return;
+        }
+        // Stop the existing runner if it's active
+        const existingRunner = foundSession.claudeRunner;
+        if (existingRunner) {
+            existingRunner.stop();
+            console.log(`[EdgeWorker] Stopped Claude session for agent activity session ${agentSessionId}`);
+        }
+        // Post confirmation
+        const issueTitle = issue.title || "this issue";
+        const stopConfirmation = `I've stopped working on ${issueTitle} as requested.\n\n**Stop Signal:** Received from ${webhook.agentSession.creator?.name || "user"}\n**Action Taken:** All ongoing work has been halted`;
+        await foundManager.createResponseActivity(agentSessionId, stopConfirmation);
+    }
+    /**
+     * Handle repository selection response from prompted webhook
+     * Branch 2 of agentSessionPrompted (see packages/CLAUDE.md)
+     *
+     * This method extracts the user's repository selection from their response,
+     * or uses the fallback repository if their message doesn't match any option.
+     * In both cases, the selected repository is cached for future use.
      */
-    async handleUserPostedAgentActivity(webhook, repository) {
-        // Look for existing session for this comment thread
+    async handleRepositorySelectionResponse(webhook) {
+        const { agentSession, agentActivity, guidance } = webhook;
+        const commentBody = agentSession.comment?.body;
+        const agentSessionId = agentSession.id;
+        const userMessage = agentActivity.content.body;
+        console.log(`[EdgeWorker] Processing repository selection response: "${userMessage}"`);
+        // Get the selected repository (or fallback)
+        const repository = await this.repositoryRouter.selectRepositoryFromResponse(agentSessionId, userMessage);
+        if (!repository) {
+            console.error(`[EdgeWorker] Failed to select repository for agent session ${agentSessionId}`);
+            return;
+        }
+        // Cache the selected repository for this issue
+        const issueId = agentSession.issue.id;
+        this.repositoryRouter.getIssueRepositoryCache().set(issueId, repository.id);
+        // Post agent activity showing user-selected repository
+        await this.postRepositorySelectionActivity(agentSessionId, repository.id, repository.name, "user-selected");
+        console.log(`[EdgeWorker] Initializing Claude runner after repository selection: ${agentSession.issue.identifier} -> ${repository.name}`);
+        // Initialize Claude runner with the selected repository
+        await this.initializeClaudeRunner(agentSession, repository, guidance, commentBody);
+    }
+    /**
+     * Handle normal prompted activity (existing session continuation)
+     * Branch 3 of agentSessionPrompted (see packages/CLAUDE.md)
+     */
+    async handleNormalPromptedActivity(webhook, repository) {
         const { agentSession } = webhook;
         const linearAgentActivitySessionId = agentSession.id;
         const { issue } = agentSession;
@@ -1133,21 +1173,6 @@ export class EdgeWorker extends EventEmitter {
             console.error("Failed to fetch comments for attachments:", error);
         }
         const promptBody = webhook.agentActivity.content.body;
-        const stopSignal = webhook.agentActivity.signal === "stop";
-        // Handle stop signal
-        if (stopSignal) {
-            console.log(`[EdgeWorker] Received stop signal for agent activity session ${linearAgentActivitySessionId}`);
-            // Stop the existing runner if it's active
-            const existingRunner = session.claudeRunner;
-            if (existingRunner) {
-                existingRunner.stop();
-                console.log(`[EdgeWorker] Stopped Claude session for agent activity session ${linearAgentActivitySessionId}`);
-            }
-            const issueTitle = issue.title || "this issue";
-            const stopConfirmation = `I've stopped working on ${issueTitle} as requested.\n\n**Stop Signal:** Received from ${webhook.agentSession.creator?.name || "user"}\n**Action Taken:** All ongoing work has been halted`;
-            await agentSessionManager.createResponseActivity(linearAgentActivitySessionId, stopConfirmation);
-            return; // Exit early - stop signal handled
-        }
         // Use centralized streaming check and routing logic
         try {
             await this.handlePromptWithStreamingCheck(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest, isNewSession, [], // No additional allowed directories for regular continuation
@@ -1157,6 +1182,48 @@ export class EdgeWorker extends EventEmitter {
             console.error("Failed to handle prompted webhook:", error);
         }
     }
+    /**
+     * Handle user-prompted agent activity webhook
+     * Implements three-branch architecture from packages/CLAUDE.md:
+     *   1. Stop signal - terminate existing runner
+     *   2. Repository selection response - initialize Claude runner for first time
+     *   3. Normal prompted activity - continue existing session or create new one
+     *
+     * @param webhook The prompted webhook containing user's message
+     */
+    async handleUserPromptedAgentActivity(webhook) {
+        const agentSessionId = webhook.agentSession.id;
+        // Branch 1: Handle stop signal (checked FIRST, before any routing work)
+        // Per CLAUDE.md: "an agentSession MUST already exist" for stop signals
+        // IMPORTANT: Stop signals do NOT require repository lookup
+        if (webhook.agentActivity.signal === "stop") {
+            await this.handleStopSignal(webhook);
+            return;
+        }
+        // Branch 2: Handle repository selection response
+        // This is the first Claude runner initialization after user selects a repository.
+        // The selection handler extracts the choice from the response (or uses fallback)
+        // and caches the repository for future use.
+        if (this.repositoryRouter.hasPendingSelection(agentSessionId)) {
+            await this.handleRepositorySelectionResponse(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
+        // the issue-to-repository cache - no new routing logic is performed."
+        const issueId = webhook.agentSession?.issue?.id;
+        if (!issueId) {
+            console.error(`[EdgeWorker] No issue ID found in prompted webhook ${agentSessionId}`);
+            return;
+        }
+        const repository = this.getCachedRepository(issueId);
+        if (!repository) {
+            console.warn(`[EdgeWorker] No cached repository found for prompted webhook ${agentSessionId}`);
+            return;
+        }
+        await this.handleNormalPromptedActivity(webhook, repository);
+    }
     /**
      * Handle issue unassignment
      * @param issue Linear issue object from webhook data
@@ -2520,7 +2587,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
         const currentSubroutine = this.procedureRouter.getCurrentSubroutine(input.session);
         let subroutineName;
         if (currentSubroutine) {
-            const subroutinePrompt = await this.loadSubroutinePrompt(currentSubroutine);
+            const subroutinePrompt = await this.loadSubroutinePrompt(currentSubroutine, this.config.linearWorkspaceSlug);
             if (subroutinePrompt) {
                 parts.push(subroutinePrompt);
                 components.push("subroutine-prompt");
@@ -2616,7 +2683,7 @@ ${input.userComment}
      * Load a subroutine prompt file
      * Extracted helper to make prompt assembly more readable
      */
-    async loadSubroutinePrompt(subroutine) {
+    async loadSubroutinePrompt(subroutine, workspaceSlug) {
         // Skip loading for "primary" - it's a placeholder that doesn't have a file
         if (subroutine.promptPath === "primary") {
             return null;
@@ -2625,8 +2692,12 @@ ${input.userComment}
         const __dirname = dirname(__filename);
         const subroutinePromptPath = join(__dirname, "prompts", subroutine.promptPath);
         try {
-            const prompt = await readFile(subroutinePromptPath, "utf-8");
+            let prompt = await readFile(subroutinePromptPath, "utf-8");
             console.log(`[EdgeWorker] Loaded ${subroutine.name} subroutine prompt (${prompt.length} characters)`);
+            // Perform template substitution if workspace slug is provided
+            if (workspaceSlug) {
+                prompt = prompt.replace(/https:\/\/linear\.app\/linear\/profiles\//g, `https://linear.app/${workspaceSlug}/profiles/`);
+            }
             return prompt;
         }
         catch (error) {
@@ -2797,6 +2868,27 @@ ${input.userComment}
         }
         return disallowedTools;
     }
+    /**
+     * Merge subroutine-level disallowedTools with base disallowedTools
+     * @param session Current agent session
+     * @param baseDisallowedTools Base disallowed tools from repository/global config
+     * @param logContext Context string for logging (e.g., "EdgeWorker", "resumeClaudeSession")
+     * @returns Merged disallowed tools list
+     */
+    mergeSubroutineDisallowedTools(session, baseDisallowedTools, logContext) {
+        const currentSubroutine = this.procedureRouter.getCurrentSubroutine(session);
+        if (currentSubroutine?.disallowedTools) {
+            const mergedTools = [
+                ...new Set([
+                    ...baseDisallowedTools,
+                    ...currentSubroutine.disallowedTools,
+                ]),
+            ];
+            console.log(`[${logContext}] Merged subroutine-level disallowedTools for ${currentSubroutine.name}:`, currentSubroutine.disallowedTools);
+            return mergedTools;
+        }
+        return baseDisallowedTools;
+    }
     /**
      * Build allowed tools list with Linear MCP tools automatically included
      */
@@ -2890,10 +2982,13 @@ ${input.userComment}
         }
         // Serialize child to parent agent session mapping
         const childToParentAgentSession = Object.fromEntries(this.childToParentAgentSession.entries());
+        // Serialize issue to repository cache from RepositoryRouter
+        const issueRepositoryCache = Object.fromEntries(this.repositoryRouter.getIssueRepositoryCache().entries());
         return {
             agentSessions,
             agentSessionEntries,
             childToParentAgentSession,
+            issueRepositoryCache,
         };
     }
     /**
@@ -2917,6 +3012,12 @@ ${input.userComment}
             this.childToParentAgentSession = new Map(Object.entries(state.childToParentAgentSession));
             console.log(`[EdgeWorker] Restored ${this.childToParentAgentSession.size} child-to-parent agent session mappings`);
         }
+        // Restore issue to repository cache in RepositoryRouter
+        if (state.issueRepositoryCache) {
+            const cache = new Map(Object.entries(state.issueRepositoryCache));
+            this.repositoryRouter.restoreIssueRepositoryCache(cache);
+            console.log(`[EdgeWorker] Restored ${cache.size} issue-to-repository cache mappings`);
+        }
     }
     /**
      * Post instant acknowledgment thought when agent session is created
@@ -2976,6 +3077,58 @@ ${input.userComment}
             console.error(`[EdgeWorker] Error posting parent resumption acknowledgment:`, error);
         }
     }
+    /**
+     * Post repository selection activity to Linear
+     * Shows which method was used to select the repository (auto-routing or user selection)
+     */
+    async postRepositorySelectionActivity(linearAgentActivitySessionId, repositoryId, repositoryName, selectionMethod) {
+        try {
+            const linearClient = this.linearClients.get(repositoryId);
+            if (!linearClient) {
+                console.warn(`[EdgeWorker] No Linear client found for repository ${repositoryId}`);
+                return;
+            }
+            let methodDisplay;
+            if (selectionMethod === "user-selected") {
+                methodDisplay = "selected by user";
+            }
+            else if (selectionMethod === "label-based") {
+                methodDisplay = "matched via label-based routing";
+            }
+            else if (selectionMethod === "project-based") {
+                methodDisplay = "matched via project-based routing";
+            }
+            else if (selectionMethod === "team-based") {
+                methodDisplay = "matched via team-based routing";
+            }
+            else if (selectionMethod === "team-prefix") {
+                methodDisplay = "matched via team prefix routing";
+            }
+            else if (selectionMethod === "catch-all") {
+                methodDisplay = "matched via catch-all routing";
+            }
+            else {
+                methodDisplay = "matched via workspace fallback";
+            }
+            const activityInput = {
+                agentSessionId: linearAgentActivitySessionId,
+                content: {
+                    type: "thought",
+                    body: `Repository "${repositoryName}" has been ${methodDisplay}.`,
+                },
+            };
+            const result = await linearClient.createAgentActivity(activityInput);
+            if (result.success) {
+                console.log(`[EdgeWorker] Posted repository selection activity for session ${linearAgentActivitySessionId} (${selectionMethod})`);
+            }
+            else {
+                console.error(`[EdgeWorker] Failed to post repository selection activity:`, result);
+            }
+        }
+        catch (error) {
+            console.error(`[EdgeWorker] Error posting repository selection activity:`, error);
+        }
+    }
     /**
      * Re-route procedure for a session (used when resuming from child or give feedback)
      * This ensures the currentSubroutine is reset to avoid suppression issues
@@ -3210,7 +3363,9 @@ ${input.userComment}
         const promptType = systemPromptResult?.type;
         // Build allowed tools list
         const allowedTools = this.buildAllowedTools(repository, promptType);
-        const disallowedTools = this.buildDisallowedTools(repository, promptType);
+        const baseDisallowedTools = this.buildDisallowedTools(repository, promptType);
+        // Merge subroutine-level disallowedTools if applicable
+        const disallowedTools = this.mergeSubroutineDisallowedTools(session, baseDisallowedTools, "resumeClaudeSession");
         // Set up attachments directory
         const workspaceFolderName = basename(session.workspace.path);
         const attachmentsDir = join(this.cyrusHome, workspaceFolderName, "attachments");