cyrus-edge-worker 0.0.18 → 0.0.19

package/dist/EdgeWorker.js

@@ -2,38 +2,33 @@ import { EventEmitter } from 'events';
 import { LinearClient } from '@linear/sdk';
 import { NdjsonClient } from 'cyrus-ndjson-client';
 import { ClaudeRunner, getSafeTools } from 'cyrus-claude-runner';
-import { SessionManager, Session, PersistenceManager } from 'cyrus-core';
+import { PersistenceManager } from 'cyrus-core';
 import { SharedApplicationServer } from './SharedApplicationServer.js';
-import { isIssueAssignedWebhook, isIssueCommentMentionWebhook, isIssueNewCommentWebhook, isIssueUnassignedWebhook } from 'cyrus-core';
-import { readFile, writeFile, mkdir, rename, readdir } from 'fs/promises';
+import { AgentSessionManager } from './AgentSessionManager.js';
+import { isIssueAssignedWebhook, isIssueCommentMentionWebhook, isIssueNewCommentWebhook, isIssueUnassignedWebhook, isAgentSessionCreatedWebhook, isAgentSessionPromptedWebhook } from 'cyrus-core';
+import { readFile, writeFile, mkdir, rename } from 'fs/promises';
 import { resolve, dirname, join, basename, extname } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
 import { fileTypeFromBuffer } from 'file-type';
-import { existsSync } from 'fs';
 /**
- * Unified edge worker that orchestrates NDJSON streaming, Claude processing, and Linear integration
+ * Unified edge worker that **orchestrates**
+ *   capturing Linear webhooks,
+ *   managing Claude Code processes, and
+ *   processes results through to Linear Agent Activity Sessions
  */
 export class EdgeWorker extends EventEmitter {
     config;
-    repositories = new Map();
-    linearClients = new Map();
-    ndjsonClients = new Map();
-    sessionManager;
+    repositories = new Map(); // repository 'id' (internal, stored in config.json) mapped to the full repo config
+    agentSessionManagers = new Map(); // Maps repository ID to AgentSessionManager, which manages ClaudeRunners for a repo
+    linearClients = new Map(); // one linear client per 'repository'
+    ndjsonClients = new Map(); // listeners for webhook events, one per linear token
     persistenceManager;
-    claudeRunners = new Map(); // Maps comment ID to ClaudeRunner
-    commentToRepo = new Map(); // Maps comment ID to repository ID
-    commentToIssue = new Map(); // Maps comment ID to issue ID
-    commentToLatestAgentReply = new Map(); // Maps thread root comment ID to latest agent comment
-    issueToCommentThreads = new Map(); // Maps issue ID to all comment thread IDs
-    tokenToClientId = new Map(); // Maps token to NDJSON client ID
-    issueToReplyContext = new Map(); // Maps issue ID to reply context
     sharedApplicationServer;
     constructor(config) {
         super();
         this.config = config;
         this.persistenceManager = new PersistenceManager();
-        this.sessionManager = new SessionManager(this.persistenceManager);
         // Initialize shared application server
         const serverPort = config.serverPort || config.webhookPort || 3456;
         const serverHost = config.serverHost || 'localhost';
@@ -47,9 +42,12 @@ export class EdgeWorker extends EventEmitter {
             if (repo.isActive !== false) {
                 this.repositories.set(repo.id, repo);
                 // Create Linear client for this repository's workspace
-                this.linearClients.set(repo.id, new LinearClient({
+                const linearClient = new LinearClient({
                     accessToken: repo.linearToken
-                }));
+                });
+                this.linearClients.set(repo.id, linearClient);
+                // Create AgentSessionManager for this repository
+                this.agentSessionManagers.set(repo.id, new AgentSessionManager(linearClient));
             }
         }
         // Group repositories by token to minimize NDJSON connections
@@ -96,8 +94,6 @@ export class EdgeWorker extends EventEmitter {
             // Store with the first repo's ID as the key (for error messages)
             // But also store the token mapping for lookup
             this.ndjsonClients.set(primaryRepoId, ndjsonClient);
-            // Store token to client mapping for other lookups if needed
-            this.tokenToClientId.set(token, primaryRepoId);
         }
     }
     /**
@@ -157,9 +153,21 @@ export class EdgeWorker extends EventEmitter {
      * Stop the edge worker
      */
     async stop() {
+        try {
+            await this.savePersistedState();
+            console.log('✅ EdgeWorker state saved successfully');
+        }
+        catch (error) {
+            console.error('❌ Failed to save EdgeWorker state during shutdown:', error);
+        }
+        // get all claudeRunners
+        const claudeRunners = [];
+        for (const agentSessionManager of this.agentSessionManagers.values()) {
+            claudeRunners.push(...agentSessionManager.getAllClaudeRunners());
+        }
         // Kill all Claude processes with null checking
-        for (const [, runner] of this.claudeRunners) {
-            if (runner && typeof runner.stop === 'function') {
+        for (const runner of claudeRunners) {
+            if (runner) {
                 try {
                     runner.stop();
                 }
@@ -168,15 +176,6 @@ export class EdgeWorker extends EventEmitter {
                 }
             }
         }
-        this.claudeRunners.clear();
-        // Clear all sessions
-        for (const [commentId] of this.sessionManager.getAllSessions()) {
-            this.sessionManager.removeSession(commentId);
-        }
-        this.commentToRepo.clear();
-        this.commentToIssue.clear();
-        this.commentToLatestAgentReply.clear();
-        this.issueToCommentThreads.clear();
         // Disconnect all NDJSON clients
         for (const client of this.ndjsonClients.values()) {
             client.disconnect();
@@ -208,25 +207,6 @@ export class EdgeWorker extends EventEmitter {
         this.emit('error', error);
         this.config.handlers?.onError?.(error);
     }
-    /**
-     * Check if Claude logs exist for a workspace
-     */
-    async hasExistingLogs(workspaceName) {
-        try {
-            const logsDir = join(homedir(), '.cyrus', 'logs', workspaceName);
-            // Check if directory exists
-            if (!existsSync(logsDir)) {
-                return false;
-            }
-            // Check if directory has any log files
-            const files = await readdir(logsDir);
-            return files.some(file => file.endsWith('.jsonl'));
-        }
-        catch (error) {
-            console.error(`Failed to check logs for workspace ${workspaceName}:`, error);
-            return false;
-        }
-    }
     /**
      * Handle webhook events from proxy - now accepts native webhook payloads
      */
@@ -252,18 +232,29 @@ export class EdgeWorker extends EventEmitter {
         console.log(`[EdgeWorker] Webhook matched to repository: ${repository.name}`);
         try {
             // Handle specific webhook types with proper typing
+            // NOTE: Traditional webhooks (assigned, comment) are disabled in favor of agent session events
             if (isIssueAssignedWebhook(webhook)) {
-                await this.handleIssueAssignedWebhook(webhook, repository);
+                console.log(`[EdgeWorker] Ignoring traditional issue assigned webhook - using agent session events instead`);
+                return;
             }
             else if (isIssueCommentMentionWebhook(webhook)) {
-                await this.handleIssueCommentMentionWebhook(webhook, repository);
+                console.log(`[EdgeWorker] Ignoring traditional comment mention webhook - using agent session events instead`);
+                return;
             }
             else if (isIssueNewCommentWebhook(webhook)) {
-                await this.handleIssueNewCommentWebhook(webhook, repository);
+                console.log(`[EdgeWorker] Ignoring traditional new comment webhook - using agent session events instead`);
+                return;
             }
             else if (isIssueUnassignedWebhook(webhook)) {
+                // Keep unassigned webhook active
                 await this.handleIssueUnassignedWebhook(webhook, repository);
             }
+            else if (isAgentSessionCreatedWebhook(webhook)) {
+                await this.handleAgentSessionCreatedWebhook(webhook, repository);
+            }
+            else if (isAgentSessionPromptedWebhook(webhook)) {
+                await this.handleUserPostedAgentActivity(webhook, repository);
+            }
             else {
                 console.log(`Unhandled webhook type: ${webhook.action}`);
             }
@@ -274,32 +265,6 @@ export class EdgeWorker extends EventEmitter {
             // The error has been logged and individual webhook failures shouldn't crash the entire system
         }
     }
-    /**
-     * Handle issue assignment webhook
-     */
-    async handleIssueAssignedWebhook(webhook, repository) {
-        console.log(`[EdgeWorker] Handling issue assignment: ${webhook.notification.issue.identifier}`);
-        await this.handleIssueAssigned(webhook.notification.issue, repository);
-    }
-    /**
-     * Handle issue comment mention webhook
-     */
-    async handleIssueCommentMentionWebhook(webhook, repository) {
-        console.log(`[EdgeWorker] Handling comment mention: ${webhook.notification.issue.identifier}`);
-        await this.handleNewComment(webhook.notification.issue, webhook.notification.comment, repository);
-    }
-    /**
-     * Handle issue new comment webhook
-     */
-    async handleIssueNewCommentWebhook(webhook, repository) {
-        console.log(`[EdgeWorker] Handling new comment: ${webhook.notification.issue.identifier}`);
-        // Check if the comment mentions the agent (Cyrus) before proceeding
-        if (!(await this.isAgentMentionedInComment(webhook.notification.comment, repository))) {
-            console.log(`[EdgeWorker] Comment does not mention agent, ignoring: ${webhook.notification.issue.identifier}`);
-            return;
-        }
-        await this.handleNewComment(webhook.notification.issue, webhook.notification.comment, repository);
-    }
     /**
      * Handle issue unassignment webhook
      */
@@ -318,50 +283,73 @@ export class EdgeWorker extends EventEmitter {
         const workspaceId = webhook.organizationId;
         if (!workspaceId)
             return repos[0] || null; // Fallback to first repo if no workspace ID
-        // Try team-based routing first
-        const teamKey = webhook.notification?.issue?.team?.key;
-        if (teamKey) {
-            const repo = repos.find(r => r.teamKeys && r.teamKeys.includes(teamKey));
-            if (repo)
-                return repo;
-        }
-        // Try parsing issue identifier as fallback
-        const issueId = webhook.notification?.issue?.identifier;
-        if (issueId && issueId.includes('-')) {
-            const prefix = issueId.split('-')[0];
-            if (prefix) {
-                const repo = repos.find(r => r.teamKeys && r.teamKeys.includes(prefix));
+        // Handle agent session webhooks which have different structure
+        if (isAgentSessionCreatedWebhook(webhook) || isAgentSessionPromptedWebhook(webhook)) {
+            const teamKey = webhook.agentSession?.issue?.team?.key;
+            if (teamKey) {
+                const repo = repos.find(r => r.teamKeys && r.teamKeys.includes(teamKey));
                 if (repo)
                     return repo;
             }
+            // Try parsing issue identifier as fallback
+            const issueId = webhook.agentSession?.issue?.identifier;
+            if (issueId && issueId.includes('-')) {
+                const prefix = issueId.split('-')[0];
+                if (prefix) {
+                    const repo = repos.find(r => r.teamKeys && r.teamKeys.includes(prefix));
+                    if (repo)
+                        return repo;
+                }
+            }
+        }
+        else {
+            // Original logic for other webhook types
+            const teamKey = webhook.notification?.issue?.team?.key;
+            if (teamKey) {
+                const repo = repos.find(r => r.teamKeys && r.teamKeys.includes(teamKey));
+                if (repo)
+                    return repo;
+            }
+            // Try parsing issue identifier as fallback
+            const issueId = webhook.notification?.issue?.identifier;
+            if (issueId && issueId.includes('-')) {
+                const prefix = issueId.split('-')[0];
+                if (prefix) {
+                    const repo = repos.find(r => r.teamKeys && r.teamKeys.includes(prefix));
+                    if (repo)
+                        return repo;
+                }
+            }
         }
         // Original workspace fallback - find first repo without teamKeys or matching workspace
         return repos.find(repo => repo.linearWorkspaceId === workspaceId && (!repo.teamKeys || repo.teamKeys.length === 0)) || repos.find(repo => repo.linearWorkspaceId === workspaceId) || null;
     }
     /**
-     * Handle issue assignment
-     * @param issue Linear issue object from webhook data (contains full Linear SDK properties)
+     * Handle agent session created webhook
+     * . Can happen due to being 'delegated' or @ mentioned in a new thread
+     * @param webhook
      * @param repository Repository configuration
      */
-    async handleIssueAssigned(issue, repository) {
-        console.log(`[EdgeWorker] handleIssueAssigned started for issue ${issue.identifier} (${issue.id})`);
+    async handleAgentSessionCreatedWebhook(webhook, repository) {
+        console.log(`[EdgeWorker] Handling agent session created: ${webhook.agentSession.issue.identifier}`);
+        const { agentSession } = webhook;
+        const linearAgentActivitySessionId = agentSession.id;
+        const { issue } = agentSession;
+        // Initialize the agent session in AgentSessionManager
+        const agentSessionManager = this.agentSessionManagers.get(repository.id);
+        if (!agentSessionManager) {
+            console.error('There was no agentSessionManage for the repository with id', repository.id);
+            return;
+        }
+        // Post instant acknowledgment thought
+        await this.postInstantAcknowledgment(linearAgentActivitySessionId, repository.id);
         // Fetch full Linear issue details immediately
         const fullIssue = await this.fetchFullIssueDetails(issue.id, repository.id);
         if (!fullIssue) {
             throw new Error(`Failed to fetch full issue details for ${issue.id}`);
         }
-        console.log(`[EdgeWorker] Fetched full issue details for ${issue.identifier}`);
-        await this.handleIssueAssignedWithFullIssue(fullIssue, repository);
-    }
-    async handleIssueAssignedWithFullIssue(fullIssue, repository) {
-        console.log(`[EdgeWorker] handleIssueAssignedWithFullIssue started for issue ${fullIssue.identifier} (${fullIssue.id})`);
-        // Move issue to started state automatically
+        // Move issue to started state automatically, in case it's not already
         await this.moveIssueToStartedState(fullIssue, repository.id);
-        // Post initial comment immediately
-        const initialComment = await this.postInitialComment(fullIssue.id, repository.id);
-        if (!initialComment?.id) {
-            throw new Error(`Failed to create initial comment for issue ${fullIssue.identifier}`);
-        }
         // Create workspace using full issue data
         const workspace = this.config.handlers?.createWorkspace
             ? await this.config.handlers.createWorkspace(fullIssue, repository)
@@ -370,6 +358,8 @@ export class EdgeWorker extends EventEmitter {
                 isGitWorktree: false
             };
         console.log(`[EdgeWorker] Workspace created at: ${workspace.path}`);
+        const issueMinimal = this.convertLinearIssueToCore(fullIssue);
+        agentSessionManager.createLinearAgentSession(linearAgentActivitySessionId, issue.id, issueMinimal, workspace);
         // Download attachments before creating Claude runner
         const attachmentResult = await this.downloadIssueAttachments(fullIssue, repository, workspace.path);
         // Build allowed directories list
@@ -379,7 +369,18 @@ export class EdgeWorker extends EventEmitter {
         }
         // Build allowed tools list with Linear MCP tools
         const allowedTools = this.buildAllowedTools(repository);
-        // Create Claude runner with attachment directory access
+        // Fetch issue labels and determine system prompt
+        const labels = await this.fetchIssueLabels(fullIssue);
+        const systemPromptResult = await this.determineSystemPromptFromLabels(labels, repository);
+        const systemPrompt = systemPromptResult?.prompt;
+        const systemPromptVersion = systemPromptResult?.version;
+        // Post thought about system prompt selection
+        if (systemPrompt) {
+            await this.postSystemPromptSelectionThought(linearAgentActivitySessionId, labels, repository.id);
+        }
+        // Create Claude runner with attachment directory access and optional system prompt
+        // Always append the last message marker to prevent duplication
+        const lastMessageMarker = '\n\n___LAST_MESSAGE_MARKER___\nIMPORTANT: When providing your final summary response, include the special marker ___LAST_MESSAGE_MARKER___ at the very beginning of your message. This marker will be automatically removed before posting.';
         const runner = new ClaudeRunner({
             workingDirectory: workspace.path,
             allowedTools,
@@ -387,27 +388,13 @@ export class EdgeWorker extends EventEmitter {
             workspaceName: fullIssue.identifier,
             mcpConfigPath: repository.mcpConfigPath,
             mcpConfig: this.buildMcpConfig(repository),
-            onMessage: (message) => this.handleClaudeMessage(initialComment.id, message, repository.id),
-            onComplete: (messages) => this.handleClaudeComplete(initialComment.id, messages, repository.id),
-            onError: (error) => this.handleClaudeError(initialComment.id, error, repository.id)
+            appendSystemPrompt: (systemPrompt || '') + lastMessageMarker,
+            onMessage: (message) => this.handleClaudeMessage(linearAgentActivitySessionId, message, repository.id),
+            // onComplete: (messages) => this.handleClaudeComplete(initialComment.id, messages, repository.id),
+            onError: (error) => this.handleClaudeError(error)
         });
         // Store runner by comment ID
-        this.claudeRunners.set(initialComment.id, runner);
-        this.commentToRepo.set(initialComment.id, repository.id);
-        this.commentToIssue.set(initialComment.id, fullIssue.id);
-        // Create session using full Linear issue (convert LinearIssue to CoreIssue)
-        const session = new Session({
-            issue: this.convertLinearIssueToCore(fullIssue),
-            workspace,
-            startedAt: new Date(),
-            agentRootCommentId: initialComment.id
-        });
-        // Store session by comment ID
-        this.sessionManager.addSession(initialComment.id, session);
-        // Track this thread for the issue
-        const threads = this.issueToCommentThreads.get(fullIssue.id) || new Set();
-        threads.add(initialComment.id);
-        this.issueToCommentThreads.set(fullIssue.id, threads);
+        agentSessionManager.addClaudeRunner(linearAgentActivitySessionId, runner);
         // Save state after mapping changes
         await this.savePersistedState();
         // Emit events using full Linear issue
@@ -416,105 +403,24 @@ export class EdgeWorker extends EventEmitter {
         // Build and start Claude with initial prompt using full issue (streaming mode)
         console.log(`[EdgeWorker] Building initial prompt for issue ${fullIssue.identifier}`);
         try {
-            // Use buildPromptV2 without a new comment for issue assignment
-            const prompt = await this.buildPromptV2(fullIssue, repository, undefined, attachmentResult.manifest);
-            console.log(`[EdgeWorker] Initial prompt built successfully, length: ${prompt.length} characters`);
+            // Choose the appropriate prompt builder based on system prompt availability
+            const promptResult = systemPrompt
+                ? await this.buildLabelBasedPrompt(fullIssue, repository, attachmentResult.manifest)
+                : await this.buildPromptV2(fullIssue, repository, undefined, attachmentResult.manifest);
+            const { prompt, version: userPromptVersion } = promptResult;
+            // Update runner with version information
+            if (userPromptVersion || systemPromptVersion) {
+                runner.updatePromptVersions({
+                    userPromptVersion,
+                    systemPromptVersion
+                });
+            }
+            console.log(`[EdgeWorker] Initial prompt built successfully using ${systemPrompt ? 'label-based' : 'fallback'} workflow, length: ${prompt.length} characters`);
             console.log(`[EdgeWorker] Starting Claude streaming session`);
             const sessionInfo = await runner.startStreaming(prompt);
             console.log(`[EdgeWorker] Claude streaming session started: ${sessionInfo.sessionId}`);
-        }
-        catch (error) {
-            console.error(`[EdgeWorker] Error in prompt building/starting:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Find the root comment of a comment thread by traversing parent relationships
-     */
-    /**
-     * Handle new root comment - creates a new Claude session for a new comment thread
-     * @param issue Linear issue object from webhook data
-     * @param comment Linear comment object from webhook data
-     * @param repository Repository configuration
-     */
-    async handleNewRootComment(issue, comment, repository) {
-        console.log(`[EdgeWorker] Handling new root comment ${comment.id} on issue ${issue.identifier}`);
-        // Fetch full Linear issue details
-        const fullIssue = await this.fetchFullIssueDetails(issue.id, repository.id);
-        if (!fullIssue) {
-            throw new Error(`Failed to fetch full issue details for ${issue.id}`);
-        }
-        // Post immediate acknowledgment
-        const acknowledgment = await this.postComment(issue.id, "I'm getting started on that right away. I'll update this comment with my plan as I work through it.", repository.id, comment.id // Reply to the new root comment
-        );
-        if (!acknowledgment?.id) {
-            throw new Error(`Failed to create acknowledgment for root comment ${comment.id}`);
-        }
-        // Create or get workspace
-        const workspace = this.config.handlers?.createWorkspace
-            ? await this.config.handlers.createWorkspace(fullIssue, repository)
-            : {
-                path: `${repository.workspaceBaseDir}/${fullIssue.identifier}`,
-                isGitWorktree: false
-            };
-        console.log(`[EdgeWorker] Using workspace at: ${workspace.path}`);
-        // Download attachments if any
-        const attachmentResult = await this.downloadIssueAttachments(fullIssue, repository, workspace.path);
-        // Build allowed directories and tools
-        const allowedDirectories = [];
-        if (attachmentResult.attachmentsDir) {
-            allowedDirectories.push(attachmentResult.attachmentsDir);
-        }
-        const allowedTools = this.buildAllowedTools(repository);
-        // Create Claude runner for this new comment thread
-        const runner = new ClaudeRunner({
-            workingDirectory: workspace.path,
-            allowedTools,
-            allowedDirectories,
-            workspaceName: fullIssue.identifier,
-            mcpConfigPath: repository.mcpConfigPath,
-            mcpConfig: this.buildMcpConfig(repository),
-            onMessage: (message) => {
-                // Update session with Claude session ID when first received
-                if (!session.claudeSessionId && message.session_id) {
-                    session.claudeSessionId = message.session_id;
-                    console.log(`[EdgeWorker] Claude session ID assigned: ${message.session_id}`);
-                }
-                this.handleClaudeMessage(acknowledgment.id, message, repository.id);
-            },
-            onComplete: (messages) => this.handleClaudeComplete(acknowledgment.id, messages, repository.id),
-            onError: (error) => this.handleClaudeError(acknowledgment.id, error, repository.id)
-        });
-        // Store runner and mappings
-        this.claudeRunners.set(comment.id, runner);
-        this.commentToRepo.set(comment.id, repository.id);
-        this.commentToIssue.set(comment.id, fullIssue.id);
-        // Create session for this new comment thread
-        const session = new Session({
-            issue: this.convertLinearIssueToCore(fullIssue),
-            workspace,
-            startedAt: new Date(),
-            agentRootCommentId: comment.id
-        });
-        this.sessionManager.addSession(comment.id, session);
-        // Track this new thread for the issue
-        const threads = this.issueToCommentThreads.get(issue.id) || new Set();
-        threads.add(comment.id);
-        this.issueToCommentThreads.set(issue.id, threads);
-        // Track latest reply
-        this.commentToLatestAgentReply.set(comment.id, acknowledgment.id);
-        // Save state after mapping changes
-        await this.savePersistedState();
-        // Emit session start event
-        this.config.handlers?.onSessionStart?.(fullIssue.id, fullIssue, repository.id);
-        // Build prompt with new comment focus using V2 template
-        console.log(`[EdgeWorker] Building prompt for new root comment`);
-        try {
-            const prompt = await this.buildPromptV2(fullIssue, repository, comment, attachmentResult.manifest);
-            console.log(`[EdgeWorker] Prompt built successfully, length: ${prompt.length} characters`);
-            console.log(`[EdgeWorker] Starting Claude streaming session for new comment thread`);
-            const sessionInfo = await runner.startStreaming(prompt);
-            console.log(`[EdgeWorker] Claude streaming session started: ${sessionInfo.sessionId}`);
+            // Note: AgentSessionManager will be initialized automatically when the first system message 
+            // is received via handleClaudeMessage() callback
         }
         catch (error) {
             console.error(`[EdgeWorker] Error in prompt building/starting:`, error);
@@ -527,191 +433,93 @@ export class EdgeWorker extends EventEmitter {
      * @param comment Linear comment object from webhook data
      * @param repository Repository configuration
      */
-    async handleNewComment(issue, comment, repository) {
-        // Check if continuation is enabled
-        if (!this.config.features?.enableContinuation) {
-            console.log('Continuation not enabled, ignoring comment');
+    async handleUserPostedAgentActivity(webhook, repository) {
+        // Look for existing session for this comment thread
+        const { agentSession } = webhook;
+        const linearAgentActivitySessionId = agentSession.id;
+        const { issue } = agentSession;
+        const promptBody = webhook.agentActivity.content.body;
+        // Initialize the agent session in AgentSessionManager
+        const agentSessionManager = this.agentSessionManagers.get(repository.id);
+        if (!agentSessionManager) {
+            console.error('Unexpected: There was no agentSessionManage for the repository with id', repository.id);
             return;
         }
-        // Fetch full Linear issue details
-        const fullIssue = await this.fetchFullIssueDetails(issue.id, repository.id);
-        if (!fullIssue) {
-            throw new Error(`Failed to fetch full issue details for ${issue.id}`);
-        }
-        // IMPORTANT: Linear has exactly ONE level of comment nesting:
-        // - Root comments (no parent)
-        // - Reply comments (have a parent, which must be a root comment)
-        // There is NO recursion - a reply cannot have replies
-        // Fetch full comment to determine if this is a root or reply
-        let parentCommentId = null;
-        let rootCommentId = comment.id; // Default to this comment being the root
-        try {
-            const linearClient = this.linearClients.get(repository.id);
-            if (linearClient && comment.id) {
-                const fullComment = await linearClient.comment({ id: comment.id });
-                // Check if comment has a parent (making it a reply)
-                if (fullComment.parent) {
-                    const parent = await fullComment.parent;
-                    if (parent?.id) {
-                        parentCommentId = parent.id;
-                        // In Linear's 2-level structure, the parent IS always the root
-                        // No need for recursion - replies can't have replies
-                        rootCommentId = parent.id;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error('Failed to fetch full comment data:', error);
-        }
-        // Determine comment type based on whether it has a parent
-        const isRootComment = parentCommentId === null;
-        const threadRootCommentId = rootCommentId;
-        console.log(`[EdgeWorker] Comment ${comment.id} - isRoot: ${isRootComment}, threadRoot: ${threadRootCommentId}, parent: ${parentCommentId}`);
-        // Store reply context for Linear commenting
-        // parentId will be: the parent comment ID (if this is a reply) OR this comment's ID (if root)
-        // This ensures our bot's replies appear at the correct nesting level
-        this.issueToReplyContext.set(issue.id, {
-            commentId: comment.id,
-            parentId: parentCommentId || comment.id
-        });
-        // Look for existing session for this comment thread
-        let session = this.sessionManager.getSession(threadRootCommentId);
-        // If no session exists, we need to create one
+        const session = agentSessionManager.getSession(linearAgentActivitySessionId);
         if (!session) {
-            console.log(`No active session for issue ${issue.identifier}, checking for existing logs...`);
-            // Check if we have existing logs for this issue
-            const hasLogs = await this.hasExistingLogs(issue.identifier);
-            if (!hasLogs) {
-                console.log(`No existing logs found for ${issue.identifier}, treating as new assignment`);
-                // Start fresh - treat it like a new assignment
-                await this.handleIssueAssigned(issue, repository);
-                return;
-            }
-            console.log(`Found existing logs for ${issue.identifier}, creating session for continuation`);
-            // Create workspace (or get existing one)
-            const workspace = this.config.handlers?.createWorkspace
-                ? await this.config.handlers.createWorkspace(fullIssue, repository)
-                : {
-                    path: `${repository.workspaceBaseDir}/${fullIssue.identifier}`,
-                    isGitWorktree: false
-                };
-            // Create session for this comment thread
-            session = new Session({
-                issue: this.convertLinearIssueToCore(fullIssue),
-                workspace,
-                process: null,
-                startedAt: new Date(),
-                agentRootCommentId: threadRootCommentId
-            });
-            this.sessionManager.addSession(threadRootCommentId, session);
-            this.commentToRepo.set(threadRootCommentId, repository.id);
-            this.commentToIssue.set(threadRootCommentId, issue.id);
-            // Track this thread for the issue
-            const threads = this.issueToCommentThreads.get(issue.id) || new Set();
-            threads.add(threadRootCommentId);
-            this.issueToCommentThreads.set(issue.id, threads);
-            // Save state after mapping changes
-            await this.savePersistedState();
+            console.error(`Unexpected: could not find Cyrus Agent Session for agent activity session: ${linearAgentActivitySessionId}`);
+            return;
         }
         // Check if there's an existing runner for this comment thread
-        const existingRunner = this.claudeRunners.get(threadRootCommentId);
+        const existingRunner = session.claudeRunner;
         if (existingRunner && existingRunner.isStreaming()) {
-            // Post immediate reply for streaming case
-            // parentId ensures correct nesting: replies to parent if this is a reply, or to comment itself if root
-            await this.postComment(issue.id, "I've queued up your message to address it right after I resolve my current focus.", repository.id, parentCommentId || comment.id // Same nesting level as the triggering comment
-            );
+            // Post instant acknowledgment for streaming case
+            await this.postInstantPromptedAcknowledgment(linearAgentActivitySessionId, repository.id, true);
             // Add comment to existing stream instead of restarting
-            console.log(`[EdgeWorker] Adding comment to existing stream for thread ${threadRootCommentId}`);
-            try {
-                existingRunner.addStreamMessage(comment.body || '');
-                return; // Exit early - comment has been added to stream
-            }
-            catch (error) {
-                console.error(`[EdgeWorker] Failed to add comment to stream, will stop the existing session and start a new one: ${error}`);
-                // Fall through to restart logic below
-            }
-        }
-        // For root comments without existing sessions, call placeholder handler
-        if (isRootComment && !session) {
-            console.log(`[EdgeWorker] Detected new root comment ${comment.id}, delegating to handleNewRootComment`);
-            await this.handleNewRootComment(issue, comment, repository);
-            return;
+            console.log(`[EdgeWorker] Adding comment to existing stream for agent activity session ${linearAgentActivitySessionId}`);
+            existingRunner.addStreamMessage(promptBody);
+            return; // Exit early - comment has been added to stream
         }
-        // Post immediate reply for continuing existing thread
-        // parentId ensures correct nesting: replies to parent if this is a reply, or to comment itself if root
-        await this.postComment(issue.id, "I'm getting started on that right away. I'll update this comment with my plan as I work through it.", repository.id, parentCommentId || comment.id // Same nesting level as the triggering comment
-        );
+        // Post instant acknowledgment for non-streaming case
+        await this.postInstantPromptedAcknowledgment(linearAgentActivitySessionId, repository.id, false);
         // Stop existing runner if it's not streaming or stream addition failed
         if (existingRunner) {
             existingRunner.stop();
         }
+        if (!session.claudeSessionId) {
+            console.error(`Unexpected: Handling a 'prompted' webhook but did not find an existing claudeSessionId for the linearAgentActivitySessionId ${linearAgentActivitySessionId}. Not continuing.`);
+            return;
+        }
         try {
             // Build allowed tools list with Linear MCP tools
             const allowedTools = this.buildAllowedTools(repository);
+            // Fetch full issue details to get labels
+            const fullIssue = await this.fetchFullIssueDetails(issue.id, repository.id);
+            if (!fullIssue) {
+                throw new Error(`Failed to fetch full issue details for ${issue.id}`);
+            }
+            // Fetch issue labels and determine system prompt (same as in handleAgentSessionCreatedWebhook)
+            const labels = await this.fetchIssueLabels(fullIssue);
+            const systemPromptResult = await this.determineSystemPromptFromLabels(labels, repository);
+            const systemPrompt = systemPromptResult?.prompt;
             // Create new runner with resume mode if we have a Claude session ID
+            // Always append the last message marker to prevent duplication
+            const lastMessageMarker = '\n\n___LAST_MESSAGE_MARKER___\nIMPORTANT: When providing your final summary response, include the special marker ___LAST_MESSAGE_MARKER___ at the very beginning of your message. This marker will be automatically removed before posting.';
             const runner = new ClaudeRunner({
                 workingDirectory: session.workspace.path,
                 allowedTools,
-                resumeSessionId: session.claudeSessionId || undefined,
+                resumeSessionId: session.claudeSessionId,
                 workspaceName: issue.identifier,
                 mcpConfigPath: repository.mcpConfigPath,
                 mcpConfig: this.buildMcpConfig(repository),
+                appendSystemPrompt: (systemPrompt || '') + lastMessageMarker,
                 onMessage: (message) => {
-                    // Update session with Claude session ID when first received
-                    if (!session.claudeSessionId && message.session_id) {
-                        session.claudeSessionId = message.session_id;
-                        console.log(`[EdgeWorker] Stored Claude session ID ${message.session_id} for comment thread ${threadRootCommentId}`);
-                    }
-                    // Check for continuation errors
-                    if (message.type === 'assistant' && 'message' in message && message.message?.content) {
-                        const content = Array.isArray(message.message.content) ? message.message.content : [message.message.content];
-                        for (const item of content) {
-                            if (item?.type === 'text' && item.text?.includes('tool_use` ids were found without `tool_result` blocks')) {
-                                console.log('Detected corrupted conversation history, will restart fresh');
-                                // Kill this runner
-                                runner.stop();
-                                // Remove from map
-                                this.claudeRunners.delete(threadRootCommentId);
-                                // Start fresh by calling root comment handler
-                                this.handleNewRootComment(issue, comment, repository).catch(error => {
-                                    console.error(`[EdgeWorker] Failed to restart fresh session for comment thread ${threadRootCommentId}:`, error);
-                                    // Clean up any partial state
-                                    this.claudeRunners.delete(threadRootCommentId);
-                                    this.commentToRepo.delete(threadRootCommentId);
-                                    this.commentToIssue.delete(threadRootCommentId);
-                                    // Emit error event to notify handlers
-                                    this.emit('session:ended', threadRootCommentId, 1, repository.id);
-                                    this.config.handlers?.onSessionEnd?.(threadRootCommentId, 1, repository.id);
-                                });
-                                return;
-                            }
-                        }
-                    }
-                    this.handleClaudeMessage(threadRootCommentId, message, repository.id);
+                    this.handleClaudeMessage(linearAgentActivitySessionId, message, repository.id);
                 },
-                onComplete: (messages) => this.handleClaudeComplete(threadRootCommentId, messages, repository.id),
-                onError: (error) => this.handleClaudeError(threadRootCommentId, error, repository.id)
+                // onComplete: (messages) => this.handleClaudeComplete(threadRootCommentId, messages, repository.id),
+                onError: (error) => this.handleClaudeError(error)
             });
             // Store new runner by comment thread root
-            this.claudeRunners.set(threadRootCommentId, runner);
+            // Store runner by comment ID
+            agentSessionManager.addClaudeRunner(linearAgentActivitySessionId, runner);
+            // Save state after mapping changes
+            await this.savePersistedState();
             // Start streaming session with the comment as initial prompt
             console.log(`[EdgeWorker] Starting new streaming session for issue ${issue.identifier}`);
-            await runner.startStreaming(comment.body || '');
+            await runner.startStreaming(promptBody);
         }
         catch (error) {
-            console.error('Failed to continue conversation, starting fresh:', error);
+            console.error('Failed to continue conversation:', error);
             // Remove any partially created session
-            this.sessionManager.removeSession(threadRootCommentId);
-            this.commentToRepo.delete(threadRootCommentId);
-            this.commentToIssue.delete(threadRootCommentId);
-            // Start fresh for root comments, or fall back to issue assignment
-            if (isRootComment) {
-                await this.handleNewRootComment(issue, comment, repository);
-            }
-            else {
-                await this.handleIssueAssigned(issue, repository);
-            }
+            // this.sessionManager.removeSession(threadRootCommentId)
+            // this.commentToRepo.delete(threadRootCommentId)
+            // this.commentToIssue.delete(threadRootCommentId)
+            // // Start fresh for root comments, or fall back to issue assignment
+            // if (isRootComment) {
+            //   await this.handleNewRootComment(issue, comment, repository)
+            // } else {
+            //   await this.handleIssueAssigned(issue, repository)
+            // }
         }
     }
     /**
@@ -720,17 +528,18 @@ export class EdgeWorker extends EventEmitter {
      * @param repository Repository configuration
      */
     async handleIssueUnassigned(issue, repository) {
-        // Get all comment threads for this issue
-        const threadRootCommentIds = this.issueToCommentThreads.get(issue.id) || new Set();
+        const agentSessionManager = this.agentSessionManagers.get(repository.id);
+        if (!agentSessionManager) {
+            console.log('No agentSessionManager for unassigned issue, so no sessions to stop');
+            return;
+        }
+        // Get all Claude runners for this specific issue
+        const claudeRunners = agentSessionManager.getClaudeRunnersForIssue(issue.id);
         // Stop all Claude runners for this issue
-        let activeThreadCount = 0;
-        for (const threadRootCommentId of threadRootCommentIds) {
-            const runner = this.claudeRunners.get(threadRootCommentId);
-            if (runner) {
-                console.log(`[EdgeWorker] Stopping Claude runner for thread ${threadRootCommentId}`);
-                await runner.stop();
-                activeThreadCount++;
-            }
+        const activeThreadCount = claudeRunners.length;
+        for (const runner of claudeRunners) {
+            console.log(`[EdgeWorker] Stopping Claude runner for issue ${issue.identifier}`);
+            runner.stop();
         }
         // Post ONE farewell comment on the issue (not in any thread) if there were active sessions
         if (activeThreadCount > 0) {
@@ -738,135 +547,25 @@ export class EdgeWorker extends EventEmitter {
             // No parentId - post as a new comment on the issue
             );
         }
-        // Clean up thread mappings for each stopped thread
-        for (const threadRootCommentId of threadRootCommentIds) {
-            // Remove from runners map
-            this.claudeRunners.delete(threadRootCommentId);
-            // Clean up comment mappings
-            this.commentToRepo.delete(threadRootCommentId);
-            this.commentToIssue.delete(threadRootCommentId);
-            this.commentToLatestAgentReply.delete(threadRootCommentId);
-            // Remove session
-            this.sessionManager.removeSession(threadRootCommentId);
-        }
-        // Clean up issue-level mappings
-        this.issueToCommentThreads.delete(issue.id);
-        this.issueToReplyContext.delete(issue.id);
-        // Save state after mapping changes
-        await this.savePersistedState();
         // Emit events
         console.log(`[EdgeWorker] Stopped ${activeThreadCount} sessions for unassigned issue ${issue.identifier}`);
-        this.emit('session:ended', issue.id, null, repository.id);
-        this.config.handlers?.onSessionEnd?.(issue.id, null, repository.id);
     }
     /**
      * Handle Claude messages
      */
-    async handleClaudeMessage(commentId, message, repositoryId) {
-        // Get issue ID from comment mapping
-        const issueId = this.commentToIssue.get(commentId);
-        if (!issueId) {
-            console.error(`[EdgeWorker] No issue mapping found for comment ${commentId}`);
-            return;
-        }
-        // Emit generic message event
-        this.emit('claude:message', issueId, message, repositoryId);
-        this.config.handlers?.onClaudeMessage?.(issueId, message, repositoryId);
-        // Handle specific messages
-        if (message.type === 'assistant') {
-            const content = this.extractTextContent(message);
-            if (content) {
-                this.emit('claude:response', issueId, content, repositoryId);
-                // Don't post assistant messages anymore - wait for result
-            }
-            // Also check for tool use in assistant messages
-            if ('message' in message && message.message && 'content' in message.message) {
-                const messageContent = Array.isArray(message.message.content) ? message.message.content : [message.message.content];
-                for (const item of messageContent) {
-                    if (item && typeof item === 'object' && 'type' in item && item.type === 'tool_use') {
-                        this.emit('claude:tool-use', issueId, item.name, item.input, repositoryId);
-                        // Handle TodoWrite tool specifically
-                        if ('name' in item && item.name === 'TodoWrite' && 'input' in item && item.input?.todos) {
-                            console.log(`[EdgeWorker] Detected TodoWrite tool use with ${item.input.todos.length} todos`);
-                            await this.updateCommentWithTodos(item.input.todos, repositoryId, commentId);
-                        }
-                    }
-                }
-            }
-        }
-        else if (message.type === 'result') {
-            if (message.subtype === 'success' && 'result' in message && message.result) {
-                // Post the successful result to Linear
-                // For comment-based sessions, reply to the root comment of this thread
-                await this.postComment(issueId, message.result, repositoryId, commentId);
-            }
-            else if (message.subtype === 'error_max_turns' || message.subtype === 'error_during_execution') {
-                // Handle error results
-                const errorMessage = message.subtype === 'error_max_turns'
-                    ? 'Maximum turns reached'
-                    : 'Error during execution';
-                this.handleError(new Error(`Claude error: ${errorMessage}`));
-                // Handle token limit specifically for max turns error
-                if (this.config.features?.enableTokenLimitHandling && message.subtype === 'error_max_turns') {
-                    await this.handleTokenLimit(commentId, repositoryId);
-                }
-            }
-        }
-    }
-    /**
-     * Handle Claude session completion (successful)
-     */
-    async handleClaudeComplete(commentId, messages, repositoryId) {
-        const issueId = this.commentToIssue.get(commentId);
-        console.log(`[EdgeWorker] Claude session completed for comment thread ${commentId} (issue ${issueId}) with ${messages.length} messages`);
-        this.claudeRunners.delete(commentId);
-        if (issueId) {
-            this.emit('session:ended', issueId, 0, repositoryId); // 0 indicates success
-            this.config.handlers?.onSessionEnd?.(issueId, 0, repositoryId);
+    async handleClaudeMessage(linearAgentActivitySessionId, message, repositoryId) {
+        const agentSessionManager = this.agentSessionManagers.get(repositoryId);
+        // Integrate with AgentSessionManager to capture streaming messages
+        if (agentSessionManager) {
+            await agentSessionManager.handleClaudeMessage(linearAgentActivitySessionId, message);
         }
     }
     /**
      * Handle Claude session error
+     * TODO: improve this
      */
-    async handleClaudeError(commentId, error, repositoryId) {
-        const issueId = this.commentToIssue.get(commentId);
-        console.error(`[EdgeWorker] Claude session error for comment thread ${commentId} (issue ${issueId}):`, error.message);
-        console.error(`[EdgeWorker] Error type: ${error.constructor.name}`);
-        if (error.stack) {
-            console.error(`[EdgeWorker] Stack trace:`, error.stack);
-        }
-        // Clean up resources
-        this.claudeRunners.delete(commentId);
-        if (issueId) {
-            // Emit events for external handlers
-            this.emit('session:ended', issueId, 1, repositoryId); // 1 indicates error
-            this.config.handlers?.onSessionEnd?.(issueId, 1, repositoryId);
-        }
-        console.log(`[EdgeWorker] Cleaned up resources for failed session ${commentId}`);
-    }
-    /**
-     * Handle token limit by restarting session
-     */
-    async handleTokenLimit(commentId, repositoryId) {
-        const session = this.sessionManager.getSession(commentId);
-        if (!session)
-            return;
-        const repository = this.repositories.get(repositoryId);
-        if (!repository)
-            return;
-        const issueId = this.commentToIssue.get(commentId);
-        if (!issueId)
-            return;
-        // Post warning to Linear
-        await this.postComment(issueId, '[System] Token limit reached. Starting fresh session with issue context.', repositoryId, commentId);
-        // Fetch fresh LinearIssue data and restart session for this comment thread
-        const linearIssue = await this.fetchFullIssueDetails(issueId, repositoryId);
-        if (!linearIssue) {
-            throw new Error(`Failed to fetch full issue details for ${issueId}`);
-        }
-        // For now, fall back to creating a new root comment handler
-        // TODO: Implement proper comment thread restart
-        await this.handleIssueAssignedWithFullIssue(linearIssue, repository);
+    async handleClaudeError(error) {
+        console.error('Unhandled claude error:', error);
     }
     /**
      * Fetch complete issue details from Linear API
@@ -881,6 +580,16 @@ export class EdgeWorker extends EventEmitter {
             console.log(`[EdgeWorker] Fetching full issue details for ${issueId}`);
             const fullIssue = await linearClient.issue(issueId);
             console.log(`[EdgeWorker] Successfully fetched issue details for ${issueId}`);
+            // Check if issue has a parent
+            try {
+                const parent = await fullIssue.parent;
+                if (parent) {
+                    console.log(`[EdgeWorker] Issue ${issueId} has parent: ${parent.identifier}`);
+                }
+            }
+            catch (error) {
+                // Parent field might not exist, ignore error
+            }
             return fullIssue;
         }
         catch (error) {
@@ -888,6 +597,107 @@ export class EdgeWorker extends EventEmitter {
             return null;
         }
     }
+    /**
+     * Fetch issue labels for a given issue
+     */
+    async fetchIssueLabels(issue) {
+        try {
+            const labels = await issue.labels();
+            return labels.nodes.map(label => label.name);
+        }
+        catch (error) {
+            console.error(`[EdgeWorker] Failed to fetch labels for issue ${issue.id}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Determine system prompt based on issue labels and repository configuration
+     */
+    async determineSystemPromptFromLabels(labels, repository) {
+        if (!repository.labelPrompts || labels.length === 0) {
+            return undefined;
+        }
+        // Check each prompt type for matching labels
+        const promptTypes = ['debugger', 'builder', 'scoper'];
+        for (const promptType of promptTypes) {
+            const configuredLabels = repository.labelPrompts[promptType];
+            if (configuredLabels && configuredLabels.some(label => labels.includes(label))) {
+                try {
+                    // Load the prompt template from file
+                    const __filename = fileURLToPath(import.meta.url);
+                    const __dirname = dirname(__filename);
+                    const promptPath = join(__dirname, '..', 'prompts', `${promptType}.md`);
+                    const promptContent = await readFile(promptPath, 'utf-8');
+                    console.log(`[EdgeWorker] Using ${promptType} system prompt for labels: ${labels.join(', ')}`);
+                    // Extract and log version tag if present
+                    const promptVersion = this.extractVersionTag(promptContent);
+                    if (promptVersion) {
+                        console.log(`[EdgeWorker] ${promptType} system prompt version: ${promptVersion}`);
+                    }
+                    return { prompt: promptContent, version: promptVersion };
+                }
+                catch (error) {
+                    console.error(`[EdgeWorker] Failed to load ${promptType} prompt template:`, error);
+                    return undefined;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Build simplified prompt for label-based workflows
+     * @param issue Full Linear issue
+     * @param repository Repository configuration
+     * @returns Formatted prompt string
+     */
+    async buildLabelBasedPrompt(issue, repository, attachmentManifest = '') {
+        console.log(`[EdgeWorker] buildLabelBasedPrompt called for issue ${issue.identifier}`);
+        try {
+            // Load the label-based prompt template
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            const templatePath = resolve(__dirname, '../label-prompt-template.md');
+            console.log(`[EdgeWorker] Loading label prompt template from: ${templatePath}`);
+            const template = await readFile(templatePath, 'utf-8');
+            console.log(`[EdgeWorker] Template loaded, length: ${template.length} characters`);
+            // Extract and log version tag if present
+            const templateVersion = this.extractVersionTag(template);
+            if (templateVersion) {
+                console.log(`[EdgeWorker] Label prompt template version: ${templateVersion}`);
+            }
+            // Build the simplified prompt with only essential variables
+            let prompt = template
+                .replace(/{{repository_name}}/g, repository.name)
+                .replace(/{{base_branch}}/g, repository.baseBranch)
+                .replace(/{{issue_id}}/g, issue.id || '')
+                .replace(/{{issue_identifier}}/g, issue.identifier || '')
+                .replace(/{{issue_title}}/g, issue.title || '')
+                .replace(/{{issue_description}}/g, issue.description || 'No description provided')
+                .replace(/{{issue_url}}/g, issue.url || '');
+            if (attachmentManifest) {
+                console.log(`[EdgeWorker] Adding attachment manifest to label-based prompt, length: ${attachmentManifest.length} characters`);
+                prompt = prompt + '\n\n' + attachmentManifest;
+            }
+            console.log(`[EdgeWorker] Label-based prompt built successfully, length: ${prompt.length} characters`);
+            return { prompt, version: templateVersion };
+        }
+        catch (error) {
+            console.error(`[EdgeWorker] Error building label-based prompt:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Extract version tag from template content
+     * @param templateContent The template content to parse
+     * @returns The version value if found, undefined otherwise
+     */
+    extractVersionTag(templateContent) {
+        // Match the version tag pattern: <version-tag value="..." />
+        const versionTagMatch = templateContent.match(/<version-tag\s+value="([^"]*)"\s*\/>/i);
+        const version = versionTagMatch ? versionTagMatch[1] : undefined;
+        // Return undefined for empty strings
+        return version && version.trim() ? version : undefined;
+    }
     /**
      * Convert full Linear SDK issue to CoreIssue interface for Session creation
      */
@@ -897,9 +707,7 @@ export class EdgeWorker extends EventEmitter {
             identifier: issue.identifier,
             title: issue.title || '',
             description: issue.description || undefined,
-            getBranchName() {
-                return issue.branchName; // Use the real branchName property!
-            }
+            branchName: issue.branchName // Use the real branchName property!
         };
     }
     /**
@@ -1003,6 +811,11 @@ ${reply.body}
             console.log(`[EdgeWorker] Loading prompt template from: ${templatePath}`);
             const template = await readFile(templatePath, 'utf-8');
             console.log(`[EdgeWorker] Template loaded, length: ${template.length} characters`);
+            // Extract and log version tag if present
+            const templateVersion = this.extractVersionTag(template);
+            if (templateVersion) {
+                console.log(`[EdgeWorker] Prompt template version: ${templateVersion}`);
+            }
             // Get state name from Linear API
             const state = await issue.state;
             const stateName = state?.name || 'Unknown';
@@ -1015,7 +828,7 @@ ${reply.body}
                     const comments = await linearClient.comments({
                         filter: { issue: { id: { eq: issue.id } } }
                     });
-                    const commentNodes = await comments.nodes;
+                    const commentNodes = comments.nodes;
                     if (commentNodes.length > 0) {
                         commentThreads = await this.formatCommentThreads(commentNodes);
                         console.log(`[EdgeWorker] Formatted ${commentNodes.length} comments into threads`);
@@ -1080,15 +893,20 @@ IMPORTANT: Focus specifically on addressing the new comment above. This is a new
                 console.log(`[EdgeWorker] Adding attachment manifest, length: ${attachmentManifest.length} characters`);
                 prompt = prompt + '\n\n' + attachmentManifest;
             }
+            // Append repository-specific instruction if provided
+            if (repository.appendInstruction) {
+                console.log(`[EdgeWorker] Adding repository-specific instruction`);
+                prompt = prompt + '\n\n<repository-specific-instruction>\n' + repository.appendInstruction + '\n</repository-specific-instruction>';
+            }
             console.log(`[EdgeWorker] Final prompt length: ${prompt.length} characters`);
-            return prompt;
+            return { prompt, version: templateVersion };
         }
         catch (error) {
             console.error('[EdgeWorker] Failed to load prompt template:', error);
             // Fallback to simple prompt
             const state = await issue.state;
             const stateName = state?.name || 'Unknown';
-            return `Please help me with the following Linear issue:
+            const fallbackPrompt = `Please help me with the following Linear issue:
 
 Repository: ${repository.name}
 Issue: ${issue.identifier}
@@ -1102,31 +920,9 @@ Working directory: ${repository.repositoryPath}
 Base branch: ${repository.baseBranch}
 
 ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please analyze this issue and help implement a solution.`;
+            return { prompt: fallbackPrompt, version: undefined };
         }
     }
-    /**
-     * Extract text content from Claude message
-     */
-    extractTextContent(sdkMessage) {
-        if (sdkMessage.type !== 'assistant')
-            return null;
-        const message = sdkMessage.message;
-        if (!message?.content)
-            return null;
-        if (typeof message.content === 'string') {
-            return message.content;
-        }
-        if (Array.isArray(message.content)) {
-            const textBlocks = [];
-            for (const block of message.content) {
-                if (typeof block === 'object' && block !== null && 'type' in block && block.type === 'text' && 'text' in block) {
-                    textBlocks.push(block.text);
-                }
-            }
-            return textBlocks.join('');
-        }
-        return null;
-    }
     /**
      * Get connection status by repository ID
      */
@@ -1137,12 +933,6 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
         }
         return status;
     }
-    /**
-     * Get active sessions
-     */
-    getActiveSessions() {
-        return Array.from(this.sessionManager.getAllSessions().keys());
-    }
     /**
      * Get NDJSON client by token (for testing purposes)
      * @internal
@@ -1231,125 +1021,48 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
     /**
      * Post initial comment when assigned to issue
      */
-    async postInitialComment(issueId, repositoryId) {
-        try {
-            const body = "I've been assigned to this issue and am getting started right away. I'll update this comment with my plan shortly.";
-            // Get the Linear client for this repository
-            const linearClient = this.linearClients.get(repositoryId);
-            if (!linearClient) {
-                throw new Error(`No Linear client found for repository ${repositoryId}`);
-            }
-            const commentData = {
-                issueId,
-                body
-            };
-            const response = await linearClient.createComment(commentData);
-            // Linear SDK returns CommentPayload with structure: { comment, success, lastSyncId }
-            if (response && response.comment) {
-                const comment = await response.comment;
-                console.log(`✅ Posted initial comment on issue ${issueId} (ID: ${comment.id})`);
-                // Track this as the latest agent reply for the thread (initial comment is its own root)
-                if (comment.id) {
-                    this.commentToLatestAgentReply.set(comment.id, comment.id);
-                    // Save state after successful comment creation and mapping update
-                    await this.savePersistedState();
-                }
-                return comment;
-            }
-            else {
-                throw new Error('Initial comment creation failed');
-            }
-        }
-        catch (error) {
-            console.error(`Failed to create initial comment on issue ${issueId}:`, error);
-            return null;
-        }
-    }
+    // private async postInitialComment(issueId: string, repositoryId: string): Promise<void> {
+    //   const body = "I'm getting started right away."
+    //   // Get the Linear client for this repository
+    //   const linearClient = this.linearClients.get(repositoryId)
+    //   if (!linearClient) {
+    //     throw new Error(`No Linear client found for repository ${repositoryId}`)
+    //   }
+    //   const commentData = {
+    //     issueId,
+    //     body
+    //   }
+    //   await linearClient.createComment(commentData)
+    // }
     /**
      * Post a comment to Linear
      */
     async postComment(issueId, body, repositoryId, parentId) {
-        try {
-            // Get the Linear client for this repository
-            const linearClient = this.linearClients.get(repositoryId);
-            if (!linearClient) {
-                throw new Error(`No Linear client found for repository ${repositoryId}`);
-            }
-            const commentData = {
-                issueId,
-                body
-            };
-            // Add parent ID if provided (for reply)
-            if (parentId) {
-                commentData.parentId = parentId;
-            }
-            const response = await linearClient.createComment(commentData);
-            // Linear SDK returns CommentPayload with structure: { comment, success, lastSyncId }
-            if (response && response.comment) {
-                console.log(`✅ Successfully created comment on issue ${issueId}`);
-                const comment = await response.comment;
-                if (comment?.id) {
-                    console.log(`Comment ID: ${comment.id}`);
-                    // Track this as the latest agent reply for the thread
-                    // If parentId exists, that's the thread root; otherwise this comment IS the root
-                    const threadRootCommentId = parentId || comment.id;
-                    this.commentToLatestAgentReply.set(threadRootCommentId, comment.id);
-                    // Save state after successful comment creation and mapping update
-                    await this.savePersistedState();
-                    return comment;
-                }
-                return null;
-            }
-            else {
-                throw new Error('Comment creation failed');
-            }
-        }
-        catch (error) {
-            console.error(`Failed to create comment on issue ${issueId}:`, error);
-            // Don't re-throw - just log the error so the edge worker doesn't crash
-            // TODO: Implement retry logic or token refresh
-            return null;
-        }
-    }
-    /**
-     * Update initial comment with TODO checklist
-     */
-    async updateCommentWithTodos(todos, repositoryId, threadRootCommentId) {
-        try {
-            // Get the latest agent comment in this thread
-            const commentId = this.commentToLatestAgentReply.get(threadRootCommentId) || threadRootCommentId;
-            if (!commentId) {
-                console.log('No comment ID found for thread, cannot update with todos');
-                return;
-            }
-            // Convert todos to Linear checklist format
-            const checklist = this.formatTodosAsChecklist(todos);
-            const body = `I've been assigned to this issue and am getting started right away. Here's my plan:\n\n${checklist}`;
-            // Get the Linear client
-            const linearClient = this.linearClients.get(repositoryId);
-            if (!linearClient) {
-                throw new Error(`No Linear client found for repository ${repositoryId}`);
-            }
-            // Update the comment
-            const response = await linearClient.updateComment(commentId, { body });
-            if (response) {
-                console.log(`✅ Updated comment ${commentId} with ${todos.length} todos`);
-            }
+        // Get the Linear client for this repository
+        const linearClient = this.linearClients.get(repositoryId);
+        if (!linearClient) {
+            throw new Error(`No Linear client found for repository ${repositoryId}`);
         }
-        catch (error) {
-            console.error(`Failed to update comment with todos:`, error);
+        const commentData = {
+            issueId,
+            body
+        };
+        // Add parent ID if provided (for reply)
+        if (parentId) {
+            commentData.parentId = parentId;
         }
+        await linearClient.createComment(commentData);
     }
     /**
      * Format todos as Linear checklist markdown
      */
-    formatTodosAsChecklist(todos) {
-        return todos.map(todo => {
-            const checkbox = todo.status === 'completed' ? '[x]' : '[ ]';
-            const statusEmoji = todo.status === 'in_progress' ? ' 🔄' : '';
-            return `- ${checkbox} ${todo.content}${statusEmoji}`;
-        }).join('\n');
-    }
+    // private formatTodosAsChecklist(todos: Array<{id: string, content: string, status: string, priority: string}>): string {
+    //   return todos.map(todo => {
+    //     const checkbox = todo.status === 'completed' ? '[x]' : '[ ]'
+    //     const statusEmoji = todo.status === 'in_progress' ? ' 🔄' : ''
+    //     return `- ${checkbox} ${todo.content}${statusEmoji}`
+    //   }).join('\n')
+    // }
     /**
      * Extract attachment URLs from text (issue description or comment)
      */
@@ -1392,7 +1105,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
                     const comments = await linearClient.comments({
                         filter: { issue: { id: { eq: issue.id } } }
                     });
-                    const commentNodes = await comments.nodes;
+                    const commentNodes = comments.nodes;
                     for (const comment of commentNodes) {
                         const urls = this.extractAttachmentUrls(comment.body);
                         commentUrls.push(...urls);
@@ -1557,62 +1270,61 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
         }
         return manifest;
     }
-    /**
-     * Check if the agent (Cyrus) is mentioned in a comment
-     * @param comment Linear comment object from webhook data
-     * @param repository Repository configuration
-     * @returns true if the agent is mentioned, false otherwise
-     */
-    async isAgentMentionedInComment(comment, repository) {
-        try {
-            const linearClient = this.linearClients.get(repository.id);
-            if (!linearClient) {
-                console.warn(`No Linear client found for repository ${repository.id}`);
-                return false;
-            }
-            // Get the current user (agent) information
-            const viewer = await linearClient.viewer;
-            if (!viewer) {
-                console.warn('Unable to fetch viewer information');
-                return false;
-            }
-            // Check for mentions in the comment body
-            // Linear mentions can be in formats like:
-            // @username, @"Display Name", or @userId
-            const commentBody = comment.body;
-            // Check for mention by user ID (most reliable)
-            if (commentBody.includes(`@${viewer.id}`)) {
-                return true;
-            }
-            // Check for mention by name (case-insensitive)
-            if (viewer.name) {
-                const namePattern = new RegExp(`@"?${viewer.name}"?`, 'i');
-                if (namePattern.test(commentBody)) {
-                    return true;
-                }
-            }
-            // Check for mention by display name (case-insensitive)
-            if (viewer.displayName && viewer.displayName !== viewer.name) {
-                const displayNamePattern = new RegExp(`@"?${viewer.displayName}"?`, 'i');
-                if (displayNamePattern.test(commentBody)) {
-                    return true;
-                }
-            }
-            // Check for mention by email (less common but possible)
-            if (viewer.email) {
-                const emailPattern = new RegExp(`@"?${viewer.email}"?`, 'i');
-                if (emailPattern.test(commentBody)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        catch (error) {
-            console.error('Failed to check if agent is mentioned in comment:', error);
-            // If we can't determine, err on the side of caution and allow the trigger
-            return true;
-        }
-    }
+    // /**
+    //  * Check if the agent (Cyrus) is mentioned in a comment
+    //  * @param comment Linear comment object from webhook data
+    //  * @param repository Repository configuration
+    //  * @returns true if the agent is mentioned, false otherwise
+    //  */
+    // private async isAgentMentionedInComment(comment: LinearWebhookComment, repository: RepositoryConfig): Promise<boolean> {
+    //   try {
+    //     const linearClient = this.linearClients.get(repository.id)
+    //     if (!linearClient) {
+    //       console.warn(`No Linear client found for repository ${repository.id}`)
+    //       return false
+    //     }
+    //     // Get the current user (agent) information
+    //     const viewer = await linearClient.viewer
+    //     if (!viewer) {
+    //       console.warn('Unable to fetch viewer information')
+    //       return false
+    //     }
+    //     // Check for mentions in the comment body
+    //     // Linear mentions can be in formats like:
+    //     // @username, @"Display Name", or @userId
+    //     const commentBody = comment.body
+    //     // Check for mention by user ID (most reliable)
+    //     if (commentBody.includes(`@${viewer.id}`)) {
+    //       return true
+    //     }
+    //     // Check for mention by name (case-insensitive)
+    //     if (viewer.name) {
+    //       const namePattern = new RegExp(`@"?${viewer.name}"?`, 'i')
+    //       if (namePattern.test(commentBody)) {
+    //         return true
+    //       }
+    //     }
+    //     // Check for mention by display name (case-insensitive)
+    //     if (viewer.displayName && viewer.displayName !== viewer.name) {
+    //       const displayNamePattern = new RegExp(`@"?${viewer.displayName}"?`, 'i')
+    //       if (displayNamePattern.test(commentBody)) {
+    //         return true
+    //       }
+    //     }
+    //     // Check for mention by email (less common but possible)
+    //     if (viewer.email) {
+    //       const emailPattern = new RegExp(`@"?${viewer.email}"?`, 'i')
+    //       if (emailPattern.test(commentBody)) {
+    //         return true
+    //       }
+    //     }
+    //     return false
+    //   } catch (error) {
+    //     console.error('Failed to check if agent is mentioned in comment:', error)
+    //     // If we can't determine, err on the side of caution and allow the trigger
+    //     return true
+    //   }
+    // }
     /**
      * Build MCP configuration with automatic Linear server injection
      */
@@ -1647,104 +1359,197 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
         const allTools = [...new Set([...baseToolsArray, ...linearMcpTools])];
         return allTools;
     }
+    /**
+     * Get Agent Sessions for an issue
+     */
+    getAgentSessionsForIssue(issueId, repositoryId) {
+        const agentSessionManager = this.agentSessionManagers.get(repositoryId);
+        if (!agentSessionManager) {
+            return [];
+        }
+        return agentSessionManager.getSessionsByIssueId(issueId);
+    }
     /**
      * Load persisted EdgeWorker state for all repositories
      */
     async loadPersistedState() {
-        for (const repo of this.repositories.values()) {
-            try {
-                const state = await this.persistenceManager.loadEdgeWorkerState(repo.id);
-                if (state) {
-                    this.restoreMappings(state);
-                    console.log(`✅ Loaded persisted state for repository: ${repo.name}`);
-                }
-            }
-            catch (error) {
-                console.error(`Failed to load persisted state for repository ${repo.name}:`, error);
+        try {
+            const state = await this.persistenceManager.loadEdgeWorkerState();
+            if (state) {
+                this.restoreMappings(state);
+                console.log(`✅ Loaded persisted EdgeWorker state with ${Object.keys(state.agentSessions || {}).length} repositories`);
             }
         }
+        catch (error) {
+            console.error(`Failed to load persisted EdgeWorker state:`, error);
+        }
     }
     /**
      * Save current EdgeWorker state for all repositories
      */
     async savePersistedState() {
-        for (const repo of this.repositories.values()) {
-            try {
-                const state = this.serializeMappings();
-                await this.persistenceManager.saveEdgeWorkerState(repo.id, state);
-            }
-            catch (error) {
-                console.error(`Failed to save persisted state for repository ${repo.name}:`, error);
-            }
+        try {
+            const state = this.serializeMappings();
+            await this.persistenceManager.saveEdgeWorkerState(state);
+            console.log(`✅ Saved EdgeWorker state for ${Object.keys(state.agentSessions || {}).length} repositories`);
+        }
+        catch (error) {
+            console.error(`Failed to save persisted EdgeWorker state:`, error);
         }
     }
     /**
      * Serialize EdgeWorker mappings to a serializable format
      */
     serializeMappings() {
-        // Convert issueToCommentThreads Map<string, Set<string>> to Record<string, string[]>
-        const issueToCommentThreads = {};
-        for (const [issueId, threadSet] of this.issueToCommentThreads.entries()) {
-            issueToCommentThreads[issueId] = Array.from(threadSet);
+        // Serialize Agent Session state for all repositories
+        const agentSessions = {};
+        const agentSessionEntries = {};
+        for (const [repositoryId, agentSessionManager] of this.agentSessionManagers.entries()) {
+            const serializedState = agentSessionManager.serializeState();
+            agentSessions[repositoryId] = serializedState.sessions;
+            agentSessionEntries[repositoryId] = serializedState.entries;
         }
-        // Serialize session manager state
-        const sessionManagerState = this.sessionManager.serializeSessions();
         return {
-            commentToRepo: PersistenceManager.mapToRecord(this.commentToRepo),
-            commentToIssue: PersistenceManager.mapToRecord(this.commentToIssue),
-            commentToLatestAgentReply: PersistenceManager.mapToRecord(this.commentToLatestAgentReply),
-            issueToCommentThreads,
-            issueToReplyContext: PersistenceManager.mapToRecord(this.issueToReplyContext),
-            sessionsByCommentId: sessionManagerState.sessionsByCommentId,
-            sessionsByIssueId: sessionManagerState.sessionsByIssueId
+            agentSessions,
+            agentSessionEntries,
         };
     }
     /**
      * Restore EdgeWorker mappings from serialized state
      */
     restoreMappings(state) {
-        // Restore basic mappings
-        this.commentToRepo = PersistenceManager.recordToMap(state.commentToRepo);
-        this.commentToIssue = PersistenceManager.recordToMap(state.commentToIssue);
-        this.commentToLatestAgentReply = PersistenceManager.recordToMap(state.commentToLatestAgentReply);
-        this.issueToReplyContext = PersistenceManager.recordToMap(state.issueToReplyContext);
-        // Restore issueToCommentThreads Record<string, string[]> to Map<string, Set<string>>
-        this.issueToCommentThreads.clear();
-        for (const [issueId, threadArray] of Object.entries(state.issueToCommentThreads)) {
-            this.issueToCommentThreads.set(issueId, new Set(threadArray));
-        }
-        // Restore session manager state
-        this.sessionManager.deserializeSessions({
-            sessionsByCommentId: state.sessionsByCommentId,
-            sessionsByIssueId: state.sessionsByIssueId
-        });
+        // Restore Agent Session state for all repositories
+        if (state.agentSessions && state.agentSessionEntries) {
+            for (const [repositoryId, agentSessionManager] of this.agentSessionManagers.entries()) {
+                const repositorySessions = state.agentSessions[repositoryId] || {};
+                const repositoryEntries = state.agentSessionEntries[repositoryId] || {};
+                if (Object.keys(repositorySessions).length > 0 || Object.keys(repositoryEntries).length > 0) {
+                    agentSessionManager.restoreState(repositorySessions, repositoryEntries);
+                    console.log(`[EdgeWorker] Restored Agent Session state for repository ${repositoryId}`);
+                }
+            }
+        }
     }
     /**
-     * Save state and cleanup on shutdown
+     * Post instant acknowledgment thought when agent session is created
      */
-    async shutdown() {
+    async postInstantAcknowledgment(linearAgentActivitySessionId, repositoryId) {
         try {
-            await this.savePersistedState();
-            console.log('✅ EdgeWorker state saved successfully');
+            const linearClient = this.linearClients.get(repositoryId);
+            if (!linearClient) {
+                console.warn(`[EdgeWorker] No Linear client found for repository ${repositoryId}`);
+                return;
+            }
+            const activityInput = {
+                agentSessionId: linearAgentActivitySessionId,
+                content: {
+                    type: 'thought',
+                    body: 'I\'ve received your request and I\'m starting to work on it. Let me analyze the issue and prepare my approach.'
+                }
+            };
+            const result = await linearClient.createAgentActivity(activityInput);
+            if (result.success) {
+                console.log(`[EdgeWorker] Posted instant acknowledgment thought for session ${linearAgentActivitySessionId}`);
+            }
+            else {
+                console.error(`[EdgeWorker] Failed to post instant acknowledgment:`, result);
+            }
         }
         catch (error) {
-            console.error('❌ Failed to save EdgeWorker state during shutdown:', error);
+            console.error(`[EdgeWorker] Error posting instant acknowledgment:`, error);
         }
-        // Stop all Claude runners
-        for (const [commentId, runner] of this.claudeRunners.entries()) {
-            try {
-                await runner.stop();
+    }
+    /**
+     * Post thought about system prompt selection based on labels
+     */
+    async postSystemPromptSelectionThought(linearAgentActivitySessionId, labels, repositoryId) {
+        try {
+            const linearClient = this.linearClients.get(repositoryId);
+            if (!linearClient) {
+                console.warn(`[EdgeWorker] No Linear client found for repository ${repositoryId}`);
+                return;
             }
-            catch (error) {
-                console.error(`Failed to stop Claude runner for comment ${commentId}:`, error);
+            // Determine which prompt type was selected and which label triggered it
+            let selectedPromptType = null;
+            let triggerLabel = null;
+            const repository = Array.from(this.repositories.values()).find(r => r.id === repositoryId);
+            if (repository?.labelPrompts) {
+                // Check debugger labels
+                const debuggerLabel = repository.labelPrompts.debugger?.find(label => labels.includes(label));
+                if (debuggerLabel) {
+                    selectedPromptType = 'debugger';
+                    triggerLabel = debuggerLabel;
+                }
+                else {
+                    // Check builder labels
+                    const builderLabel = repository.labelPrompts.builder?.find(label => labels.includes(label));
+                    if (builderLabel) {
+                        selectedPromptType = 'builder';
+                        triggerLabel = builderLabel;
+                    }
+                    else {
+                        // Check scoper labels
+                        const scoperLabel = repository.labelPrompts.scoper?.find(label => labels.includes(label));
+                        if (scoperLabel) {
+                            selectedPromptType = 'scoper';
+                            triggerLabel = scoperLabel;
+                        }
+                    }
+                }
+            }
+            // Only post if a role was actually triggered
+            if (!selectedPromptType || !triggerLabel) {
+                return;
+            }
+            const activityInput = {
+                agentSessionId: linearAgentActivitySessionId,
+                content: {
+                    type: 'thought',
+                    body: `Entering '${selectedPromptType}' mode because of the '${triggerLabel}' label. I'll follow the ${selectedPromptType} process...`
+                }
+            };
+            const result = await linearClient.createAgentActivity(activityInput);
+            if (result.success) {
+                console.log(`[EdgeWorker] Posted system prompt selection thought for session ${linearAgentActivitySessionId} (${selectedPromptType} mode)`);
+            }
+            else {
+                console.error(`[EdgeWorker] Failed to post system prompt selection thought:`, result);
             }
         }
-        // Stop shared application server
+        catch (error) {
+            console.error(`[EdgeWorker] Error posting system prompt selection thought:`, error);
+        }
+    }
+    /**
+     * Post instant acknowledgment thought when receiving prompted webhook
+     */
+    async postInstantPromptedAcknowledgment(linearAgentActivitySessionId, repositoryId, isStreaming) {
         try {
-            await this.sharedApplicationServer.stop();
+            const linearClient = this.linearClients.get(repositoryId);
+            if (!linearClient) {
+                console.warn(`[EdgeWorker] No Linear client found for repository ${repositoryId}`);
+                return;
+            }
+            const message = isStreaming
+                ? "I've queued up your message as guidance"
+                : "Getting started on that...";
+            const activityInput = {
+                agentSessionId: linearAgentActivitySessionId,
+                content: {
+                    type: 'thought',
+                    body: message
+                }
+            };
+            const result = await linearClient.createAgentActivity(activityInput);
+            if (result.success) {
+                console.log(`[EdgeWorker] Posted instant prompted acknowledgment thought for session ${linearAgentActivitySessionId} (streaming: ${isStreaming})`);
+            }
+            else {
+                console.error(`[EdgeWorker] Failed to post instant prompted acknowledgment:`, result);
+            }
         }
         catch (error) {
-            console.error('Failed to stop shared application server:', error);
+            console.error(`[EdgeWorker] Error posting instant prompted acknowledgment:`, error);
         }
     }
 }