cyrus-edge-worker 0.0.18 → 0.0.20

package/dist/EdgeWorker.js

@@ -1,42 +1,36 @@
-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 { SharedApplicationServer } from './SharedApplicationServer.js';
-import { isIssueAssignedWebhook, isIssueCommentMentionWebhook, isIssueNewCommentWebhook, isIssueUnassignedWebhook } from 'cyrus-core';
-import { readFile, writeFile, mkdir, rename, readdir } 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';
+import { EventEmitter } from "node:events";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { LinearClient, } from "@linear/sdk";
+import { ClaudeRunner, getSafeTools } from "cyrus-claude-runner";
+import { isAgentSessionCreatedWebhook, isAgentSessionPromptedWebhook, isIssueAssignedWebhook, isIssueCommentMentionWebhook, isIssueNewCommentWebhook, isIssueUnassignedWebhook, PersistenceManager, } from "cyrus-core";
+import { NdjsonClient } from "cyrus-ndjson-client";
+import { fileTypeFromBuffer } from "file-type";
+import { AgentSessionManager } from "./AgentSessionManager.js";
+import { SharedApplicationServer } from "./SharedApplicationServer.js";
 /**
- * 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';
+        const serverHost = config.serverHost || "localhost";
         this.sharedApplicationServer = new SharedApplicationServer(serverPort, serverHost, config.ngrokAuthToken, config.proxyUrl);
         // Register OAuth callback handler if provided
         if (config.handlers?.onOAuthCallback) {
@@ -47,9 +41,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({
-                    accessToken: repo.linearToken
-                }));
+                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
@@ -70,34 +67,33 @@ export class EdgeWorker extends EventEmitter {
             const ndjsonClient = new NdjsonClient({
                 proxyUrl: config.proxyUrl,
                 token: token,
-                name: repos.map(r => r.name).join(', '), // Pass repository names
-                transport: 'webhook',
+                name: repos.map((r) => r.name).join(", "), // Pass repository names
+                transport: "webhook",
                 // Use shared application server instead of individual servers
                 useExternalWebhookServer: true,
                 externalWebhookServer: this.sharedApplicationServer,
                 webhookPort: serverPort, // All clients use same port
-                webhookPath: '/webhook',
+                webhookPath: "/webhook",
                 webhookHost: serverHost,
                 ...(config.baseUrl && { webhookBaseUrl: config.baseUrl }),
                 // Legacy fallback support
-                ...(!config.baseUrl && config.webhookBaseUrl && { webhookBaseUrl: config.webhookBaseUrl }),
+                ...(!config.baseUrl &&
+                    config.webhookBaseUrl && { webhookBaseUrl: config.webhookBaseUrl }),
                 onConnect: () => this.handleConnect(primaryRepoId, repos),
                 onDisconnect: (reason) => this.handleDisconnect(primaryRepoId, repos, reason),
-                onError: (error) => this.handleError(error)
+                onError: (error) => this.handleError(error),
             });
             // Set up webhook handler - data should be the native webhook payload
-            ndjsonClient.on('webhook', (data) => this.handleWebhook(data, repos));
+            ndjsonClient.on("webhook", (data) => this.handleWebhook(data, repos));
             // Optional heartbeat logging
-            if (process.env.DEBUG_EDGE === 'true') {
-                ndjsonClient.on('heartbeat', () => {
+            if (process.env.DEBUG_EDGE === "true") {
+                ndjsonClient.on("heartbeat", () => {
                     console.log(`❤️ Heartbeat received for token ending in ...${token.slice(-4)}`);
                 });
             }
             // Store with the first repo's ID as the key (for error messages)
             // But also store the token mapping for lookup
             this.ndjsonClients.set(primaryRepoId, ndjsonClient);
-            // Store token to client mapping for other lookups if needed
-            this.tokenToClientId.set(token, primaryRepoId);
         }
     }
     /**
@@ -114,12 +110,12 @@ export class EdgeWorker extends EventEmitter {
                 await client.connect();
             }
             catch (error) {
-                const repoConfig = this.config.repositories.find(r => r.id === repoId);
+                const repoConfig = this.config.repositories.find((r) => r.id === repoId);
                 const repoName = repoConfig?.name || repoId;
                 // Check if it's an authentication error
-                if (error.isAuthError || error.code === 'LINEAR_AUTH_FAILED') {
+                if (error.isAuthError || error.code === "LINEAR_AUTH_FAILED") {
                     console.error(`\n❌ Linear authentication failed for repository: ${repoName}`);
-                    console.error(`   Workspace: ${repoConfig?.linearWorkspaceName || repoConfig?.linearWorkspaceId || 'Unknown'}`);
+                    console.error(`   Workspace: ${repoConfig?.linearWorkspaceName || repoConfig?.linearWorkspaceId || "Unknown"}`);
                     console.error(`   Error: ${error.message}`);
                     console.error(`\n   To fix this issue:`);
                     console.error(`   1. Run: cyrus refresh-token`);
@@ -137,17 +133,17 @@ export class EdgeWorker extends EventEmitter {
             return { repoId, success: true };
         });
         const results = await Promise.all(connections);
-        const failures = results.filter(r => !r.success);
+        const failures = results.filter((r) => !r.success);
         if (failures.length === this.ndjsonClients.size) {
             // All connections failed
-            throw new Error('Failed to connect any repositories. Please check your configuration and Linear tokens.');
+            throw new Error("Failed to connect any repositories. Please check your configuration and Linear tokens.");
         }
         else if (failures.length > 0) {
             // Some connections failed
             console.warn(`\n⚠️  Connected ${results.length - failures.length} out of ${results.length} repositories`);
             console.warn(`   The following repositories could not be connected:`);
-            failures.forEach(f => {
-                const repoConfig = this.config.repositories.find(r => r.id === f.repoId);
+            failures.forEach((f) => {
+                const repoConfig = this.config.repositories.find((r) => r.id === f.repoId);
                 console.warn(`   - ${repoConfig?.name || f.repoId}`);
             });
             console.warn(`\n   Cyrus will continue running with the available repositories.\n`);
@@ -157,26 +153,29 @@ 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();
                 }
                 catch (error) {
-                    console.error('Error stopping Claude runner:', error);
+                    console.error("Error stopping Claude runner:", error);
                 }
             }
         }
-        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();
@@ -190,7 +189,7 @@ export class EdgeWorker extends EventEmitter {
     handleConnect(clientId, repos) {
         // Get the token for backward compatibility with events
         const token = repos[0]?.linearToken || clientId;
-        this.emit('connected', token);
+        this.emit("connected", token);
         // Connection logged by CLI app event handler
     }
     /**
@@ -199,52 +198,33 @@ export class EdgeWorker extends EventEmitter {
     handleDisconnect(clientId, repos, reason) {
         // Get the token for backward compatibility with events
         const token = repos[0]?.linearToken || clientId;
-        this.emit('disconnected', token, reason);
+        this.emit("disconnected", token, reason);
     }
     /**
      * Handle errors
      */
     handleError(error) {
-        this.emit('error', error);
+        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
      */
     async handleWebhook(webhook, repos) {
         console.log(`[EdgeWorker] Processing webhook: ${webhook.type}`);
         // Log verbose webhook info if enabled
-        if (process.env.CYRUS_WEBHOOK_DEBUG === 'true') {
+        if (process.env.CYRUS_WEBHOOK_DEBUG === "true") {
             console.log(`[EdgeWorker] Webhook payload:`, JSON.stringify(webhook, null, 2));
         }
         // Find the appropriate repository for this webhook
         const repository = this.findRepositoryForWebhook(webhook, repos);
         if (!repository) {
-            console.log('No repository configured for webhook from workspace', webhook.organizationId);
-            if (process.env.CYRUS_WEBHOOK_DEBUG === 'true') {
-                console.log('Available repositories:', repos.map(r => ({
+            console.log("No repository configured for webhook from workspace", webhook.organizationId);
+            if (process.env.CYRUS_WEBHOOK_DEBUG === "true") {
+                console.log("Available repositories:", repos.map((r) => ({
                     name: r.name,
                     workspaceId: r.linearWorkspaceId,
-                    teamKeys: r.teamKeys
+                    teamKeys: r.teamKeys,
                 })));
             }
             return;
@@ -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,58 +283,87 @@ 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?.includes(teamKey));
+                if (repo)
+                    return repo;
+            }
+            // Try parsing issue identifier as fallback
+            const issueId = webhook.agentSession?.issue?.identifier;
+            if (issueId?.includes("-")) {
+                const prefix = issueId.split("-")[0];
+                if (prefix) {
+                    const repo = repos.find((r) => 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?.includes(teamKey));
                 if (repo)
                     return repo;
             }
+            // Try parsing issue identifier as fallback
+            const issueId = webhook.notification?.issue?.identifier;
+            if (issueId?.includes("-")) {
+                const prefix = issueId.split("-")[0];
+                if (prefix) {
+                    const repo = repos.find((r) => 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;
+        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)
             : {
                 path: `${repository.workspaceBaseDir}/${fullIssue.identifier}`,
-                isGitWorktree: false
+                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 +373,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,134 +392,39 @@ 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
-        this.emit('session:started', fullIssue.id, fullIssue, repository.id);
+        this.emit("session:started", fullIssue.id, fullIssue, repository.id);
         this.config.handlers?.onSessionStart?.(fullIssue.id, fullIssue, repository.id);
         // Build and start Claude with initial prompt using full issue (streaming mode)
         console.log(`[EdgeWorker] Building initial prompt for issue ${fullIssue.identifier}`);
         try {
-            // 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 +437,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);
-        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
-            );
+        const existingRunner = session.claudeRunner;
+        if (existingRunner?.isStreaming()) {
+            // 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
-            }
+            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
         }
-        // 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;
-        }
-        // 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,153 +532,42 @@ 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) {
-            await this.postComment(issue.id, "I've been unassigned and am stopping work now.", repository.id
-            // 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();
+            await this.postComment(issue.id, "I've been unassigned and am stopping work now.", repository.id);
+        }
         // 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 +582,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 +599,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?.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?.trim() ? version : undefined;
+    }
     /**
      * Convert full Linear SDK issue to CoreIssue interface for Session creation
      */
@@ -895,18 +707,16 @@ export class EdgeWorker extends EventEmitter {
         return {
             id: issue.id,
             identifier: issue.identifier,
-            title: issue.title || '',
+            title: issue.title || "",
             description: issue.description || undefined,
-            getBranchName() {
-                return issue.branchName; // Use the real branchName property!
-            }
+            branchName: issue.branchName, // Use the real branchName property!
         };
     }
     /**
      * Sanitize branch name by removing backticks to prevent command injection
      */
     sanitizeBranchName(name) {
-        return name ? name.replace(/`/g, '') : name;
+        return name ? name.replace(/`/g, "") : name;
     }
     /**
      * Format Linear comments into a threaded structure that mirrors the Linear UI
@@ -915,7 +725,7 @@ export class EdgeWorker extends EventEmitter {
      */
     async formatCommentThreads(comments) {
         if (comments.length === 0) {
-            return 'No comments yet.';
+            return "No comments yet.";
         }
         // Group comments by thread (root comments and their replies)
         const threads = new Map();
@@ -947,7 +757,7 @@ export class EdgeWorker extends EventEmitter {
                 continue;
             // Format root comment
             const rootUser = await rootComment.user;
-            const rootAuthor = rootUser?.displayName || rootUser?.name || rootUser?.email || 'Unknown';
+            const rootAuthor = rootUser?.displayName || rootUser?.name || rootUser?.email || "Unknown";
             const rootTime = new Date(rootComment.createdAt).toLocaleString();
             let threadText = `<comment_thread>
   <root_comment>
@@ -959,10 +769,13 @@ ${rootComment.body}
   </root_comment>`;
             // Format replies if any
             if (thread.replies.length > 0) {
-                threadText += '\n  <replies>';
+                threadText += "\n  <replies>";
                 for (const reply of thread.replies) {
                     const replyUser = await reply.user;
-                    const replyAuthor = replyUser?.displayName || replyUser?.name || replyUser?.email || 'Unknown';
+                    const replyAuthor = replyUser?.displayName ||
+                        replyUser?.name ||
+                        replyUser?.email ||
+                        "Unknown";
                     const replyTime = new Date(reply.createdAt).toLocaleString();
                     threadText += `
     <reply>
@@ -973,12 +786,12 @@ ${reply.body}
       </content>
     </reply>`;
                 }
-                threadText += '\n  </replies>';
+                threadText += "\n  </replies>";
             }
-            threadText += '\n</comment_thread>';
+            threadText += "\n</comment_thread>";
             formattedThreads.push(threadText);
         }
-        return formattedThreads.join('\n\n');
+        return formattedThreads.join("\n\n");
     }
     /**
      * Build a prompt for Claude using the improved XML-style template
@@ -988,56 +801,63 @@ ${reply.body}
      * @param attachmentManifest Optional attachment manifest
      * @returns Formatted prompt string
      */
-    async buildPromptV2(issue, repository, newComment, attachmentManifest = '') {
-        console.log(`[EdgeWorker] buildPromptV2 called for issue ${issue.identifier}${newComment ? ' with new comment' : ''}`);
+    async buildPromptV2(issue, repository, newComment, attachmentManifest = "") {
+        console.log(`[EdgeWorker] buildPromptV2 called for issue ${issue.identifier}${newComment ? " with new comment" : ""}`);
         try {
             // Use custom template if provided (repository-specific takes precedence)
-            let templatePath = repository.promptTemplatePath || this.config.features?.promptTemplatePath;
+            let templatePath = repository.promptTemplatePath ||
+                this.config.features?.promptTemplatePath;
             // If no custom template, use the v2 template
             if (!templatePath) {
                 const __filename = fileURLToPath(import.meta.url);
                 const __dirname = dirname(__filename);
-                templatePath = resolve(__dirname, '../prompt-template-v2.md');
+                templatePath = resolve(__dirname, "../prompt-template-v2.md");
             }
             // Load the template
             console.log(`[EdgeWorker] Loading prompt template from: ${templatePath}`);
-            const template = await readFile(templatePath, 'utf-8');
+            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';
+            const stateName = state?.name || "Unknown";
             // Get formatted comment threads
             const linearClient = this.linearClients.get(repository.id);
-            let commentThreads = 'No comments yet.';
+            let commentThreads = "No comments yet.";
             if (linearClient && issue.id) {
                 try {
                     console.log(`[EdgeWorker] Fetching comments for issue ${issue.identifier}`);
                     const comments = await linearClient.comments({
-                        filter: { issue: { id: { eq: issue.id } } }
+                        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`);
                     }
                 }
                 catch (error) {
-                    console.error('Failed to fetch comments:', error);
+                    console.error("Failed to fetch comments:", error);
                 }
             }
             // Build the prompt with all variables
             let prompt = template
                 .replace(/{{repository_name}}/g, repository.name)
-                .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_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_state}}/g, stateName)
-                .replace(/{{issue_priority}}/g, issue.priority?.toString() || 'None')
-                .replace(/{{issue_url}}/g, issue.url || '')
+                .replace(/{{issue_priority}}/g, issue.priority?.toString() || "None")
+                .replace(/{{issue_url}}/g, issue.url || "")
                 .replace(/{{comment_threads}}/g, commentThreads)
-                .replace(/{{working_directory}}/g, this.config.handlers?.createWorkspace ?
-                'Will be created based on issue' : repository.repositoryPath)
+                .replace(/{{working_directory}}/g, this.config.handlers?.createWorkspace
+                ? "Will be created based on issue"
+                : repository.repositoryPath)
                 .replace(/{{base_branch}}/g, repository.baseBranch)
                 .replace(/{{branch_name}}/g, this.sanitizeBranchName(issue.branchName));
             // Handle the optional new comment section
@@ -1055,77 +875,63 @@ IMPORTANT: Focus specifically on addressing the new comment above. This is a new
                 prompt = prompt.replace(/{{#if new_comment}}[\s\S]*?{{\/if}}/g, newCommentSection);
                 // Now replace the new comment variables
                 // We'll need to fetch the comment author
-                let authorName = 'Unknown';
+                let authorName = "Unknown";
                 if (linearClient) {
                     try {
-                        const fullComment = await linearClient.comment({ id: newComment.id });
+                        const fullComment = await linearClient.comment({
+                            id: newComment.id,
+                        });
                         const user = await fullComment.user;
-                        authorName = user?.displayName || user?.name || user?.email || 'Unknown';
+                        authorName =
+                            user?.displayName || user?.name || user?.email || "Unknown";
                     }
                     catch (error) {
-                        console.error('Failed to fetch comment author:', error);
+                        console.error("Failed to fetch comment author:", error);
                     }
                 }
                 prompt = prompt
                     .replace(/{{new_comment_author}}/g, authorName)
                     .replace(/{{new_comment_timestamp}}/g, new Date().toLocaleString())
-                    .replace(/{{new_comment_content}}/g, newComment.body || '');
+                    .replace(/{{new_comment_content}}/g, newComment.body || "");
             }
             else {
                 // Remove the new comment section entirely
-                prompt = prompt.replace(/{{#if new_comment}}[\s\S]*?{{\/if}}/g, '');
+                prompt = prompt.replace(/{{#if new_comment}}[\s\S]*?{{\/if}}/g, "");
             }
             // Append attachment manifest if provided
             if (attachmentManifest) {
                 console.log(`[EdgeWorker] Adding attachment manifest, length: ${attachmentManifest.length} characters`);
-                prompt = prompt + '\n\n' + attachmentManifest;
+                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);
+            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 stateName = state?.name || "Unknown";
+            const fallbackPrompt = `Please help me with the following Linear issue:
 
 Repository: ${repository.name}
 Issue: ${issue.identifier}
 Title: ${issue.title}
-Description: ${issue.description || 'No description provided'}
+Description: ${issue.description || "No description provided"}
 State: ${stateName}
-Priority: ${issue.priority?.toString() || 'None'}
+Priority: ${issue.priority?.toString() || "None"}
 Branch: ${issue.branchName}
 
 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.`;
-        }
-    }
-    /**
-     * 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('');
+${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please analyze this issue and help implement a solution.`;
+            return { prompt: fallbackPrompt, version: undefined };
         }
-        return null;
     }
     /**
      * Get connection status by repository ID
@@ -1137,12 +943,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
@@ -1189,7 +989,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
             }
             // Check if issue is already in a started state
             const currentState = await issue.state;
-            if (currentState?.type === 'started') {
+            if (currentState?.type === "started") {
                 console.log(`Issue ${issue.identifier} is already in started state (${currentState.name})`);
                 return;
             }
@@ -1201,13 +1001,13 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
             }
             // Get available workflow states for the issue's team
             const teamStates = await linearClient.workflowStates({
-                filter: { team: { id: { eq: team.id } } }
+                filter: { team: { id: { eq: team.id } } },
             });
             const states = await teamStates;
             // Find all states with type "started" and pick the one with lowest position
             // This ensures we pick "In Progress" over "In Review" when both have type "started"
             // Linear uses standardized state types: triage, backlog, unstarted, started, completed, canceled
-            const startedStates = states.nodes.filter(state => state.type === 'started');
+            const startedStates = states.nodes.filter((state) => state.type === "started");
             const startedState = startedStates.sort((a, b) => a.position - b.position)[0];
             if (!startedState) {
                 throw new Error('Could not find a state with type "started" for this team');
@@ -1219,7 +1019,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
                 return;
             }
             await linearClient.updateIssue(issue.id, {
-                stateId: startedState.id
+                stateId: startedState.id,
             });
             console.log(`✅ Successfully moved issue ${issue.identifier} to ${startedState.name} state`);
         }
@@ -1231,125 +1031,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)
      */
@@ -1379,27 +1102,27 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
             const maxAttachments = 10;
             // Create attachments directory in home directory
             const workspaceFolderName = basename(workspacePath);
-            const attachmentsDir = join(homedir(), '.cyrus', workspaceFolderName, 'attachments');
+            const attachmentsDir = join(homedir(), ".cyrus", workspaceFolderName, "attachments");
             // Ensure directory exists
             await mkdir(attachmentsDir, { recursive: true });
             // Extract URLs from issue description
-            const descriptionUrls = this.extractAttachmentUrls(issue.description || '');
+            const descriptionUrls = this.extractAttachmentUrls(issue.description || "");
             // Extract URLs from comments if available
             const commentUrls = [];
             const linearClient = this.linearClients.get(repository.id);
             if (linearClient && issue.id) {
                 try {
                     const comments = await linearClient.comments({
-                        filter: { issue: { id: { eq: issue.id } } }
+                        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);
                     }
                 }
                 catch (error) {
-                    console.error('Failed to fetch comments for attachments:', error);
+                    console.error("Failed to fetch comments for attachments:", error);
                 }
             }
             // Combine and deduplicate all URLs
@@ -1423,10 +1146,10 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
                     let finalFilename;
                     if (result.isImage) {
                         imageCount++;
-                        finalFilename = `image_${imageCount}${result.fileType || '.png'}`;
+                        finalFilename = `image_${imageCount}${result.fileType || ".png"}`;
                     }
                     else {
-                        finalFilename = `attachment_${attachmentCount + 1}${result.fileType || ''}`;
+                        finalFilename = `attachment_${attachmentCount + 1}${result.fileType || ""}`;
                     }
                     const finalPath = join(attachmentsDir, finalFilename);
                     // Rename the file to include the correct extension
@@ -1453,17 +1176,17 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
                 downloaded: attachmentCount,
                 imagesDownloaded: imageCount,
                 skipped: skippedCount,
-                failed: failedCount
+                failed: failedCount,
             });
             // Return manifest and directory path if any attachments were downloaded
             return {
                 manifest,
-                attachmentsDir: attachmentCount > 0 ? attachmentsDir : null
+                attachmentsDir: attachmentCount > 0 ? attachmentsDir : null,
             };
         }
         catch (error) {
-            console.error('Error downloading attachments:', error);
-            return { manifest: '', attachmentsDir: null }; // Return empty manifest on error
+            console.error("Error downloading attachments:", error);
+            return { manifest: "", attachmentsDir: null }; // Return empty manifest on error
         }
     }
     /**
@@ -1474,8 +1197,8 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
             console.log(`Downloading attachment from: ${attachmentUrl}`);
             const response = await fetch(attachmentUrl, {
                 headers: {
-                    'Authorization': `Bearer ${linearToken}`
-                }
+                    Authorization: `Bearer ${linearToken}`,
+                },
             });
             if (!response.ok) {
                 console.error(`Attachment download failed: ${response.status} ${response.statusText}`);
@@ -1484,11 +1207,11 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
             const buffer = Buffer.from(await response.arrayBuffer());
             // Detect the file type from the buffer
             const fileType = await fileTypeFromBuffer(buffer);
-            let detectedExtension = undefined;
+            let detectedExtension;
             let isImage = false;
             if (fileType) {
                 detectedExtension = `.${fileType.ext}`;
-                isImage = fileType.mime.startsWith('image/');
+                isImage = fileType.mime.startsWith("image/");
                 console.log(`Detected file type: ${fileType.mime} (${fileType.ext}), is image: ${isImage}`);
             }
             else {
@@ -1514,10 +1237,10 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
      * Generate a markdown section describing downloaded attachments
      */
     generateAttachmentManifest(downloadResult) {
-        const { attachmentMap, imageMap, totalFound, downloaded, imagesDownloaded, skipped, failed } = downloadResult;
-        let manifest = '\n## Downloaded Attachments\n\n';
+        const { attachmentMap, imageMap, totalFound, downloaded, imagesDownloaded, skipped, failed, } = downloadResult;
+        let manifest = "\n## Downloaded Attachments\n\n";
         if (totalFound === 0) {
-            manifest += 'No attachments were found in this issue.\n';
+            manifest += "No attachments were found in this issue.\n";
             return manifest;
         }
         manifest += `Found ${totalFound} attachments. Downloaded ${downloaded}`;
@@ -1530,89 +1253,90 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
         if (failed > 0) {
             manifest += `, failed to download ${failed}`;
         }
-        manifest += '.\n\n';
+        manifest += ".\n\n";
         if (failed > 0) {
-            manifest += '**Note**: Some attachments failed to download. This may be due to authentication issues or the files being unavailable. The agent will continue processing the issue with the available information.\n\n';
+            manifest +=
+                "**Note**: Some attachments failed to download. This may be due to authentication issues or the files being unavailable. The agent will continue processing the issue with the available information.\n\n";
         }
-        manifest += 'Attachments have been downloaded to the `~/.cyrus/<workspace>/attachments` directory:\n\n';
+        manifest +=
+            "Attachments have been downloaded to the `~/.cyrus/<workspace>/attachments` directory:\n\n";
         // List images first
         if (Object.keys(imageMap).length > 0) {
-            manifest += '### Images\n';
+            manifest += "### Images\n";
             Object.entries(imageMap).forEach(([url, localPath], index) => {
                 const filename = basename(localPath);
                 manifest += `${index + 1}. ${filename} - Original URL: ${url}\n`;
                 manifest += `   Local path: ${localPath}\n\n`;
             });
-            manifest += 'You can use the Read tool to view these images.\n\n';
+            manifest += "You can use the Read tool to view these images.\n\n";
         }
         // List other attachments
         if (Object.keys(attachmentMap).length > 0) {
-            manifest += '### Other Attachments\n';
+            manifest += "### Other Attachments\n";
             Object.entries(attachmentMap).forEach(([url, localPath], index) => {
                 const filename = basename(localPath);
                 manifest += `${index + 1}. ${filename} - Original URL: ${url}\n`;
                 manifest += `   Local path: ${localPath}\n\n`;
             });
-            manifest += 'You can use the Read tool to view these files.\n\n';
+            manifest += "You can use the Read tool to view these files.\n\n";
         }
         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
      */
@@ -1620,13 +1344,13 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
         // Always inject the Linear MCP server with the repository's token
         const mcpConfig = {
             linear: {
-                type: 'stdio',
-                command: 'npx',
-                args: ['-y', '@tacticlaunch/mcp-linear'],
+                type: "stdio",
+                command: "npx",
+                args: ["-y", "@tacticlaunch/mcp-linear"],
                 env: {
-                    LINEAR_API_TOKEN: repository.linearToken
-                }
-            }
+                    LINEAR_API_TOKEN: repository.linearToken,
+                },
+            },
         };
         return mcpConfig;
     }
@@ -1635,116 +1359,210 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ''}Please ana
      */
     buildAllowedTools(repository) {
         // Start with configured tools or defaults
-        const baseTools = repository.allowedTools || this.config.defaultAllowedTools || getSafeTools();
+        const baseTools = repository.allowedTools ||
+            this.config.defaultAllowedTools ||
+            getSafeTools();
         // Ensure baseTools is an array
         const baseToolsArray = Array.isArray(baseTools) ? baseTools : [];
         // Linear MCP tools that should always be available
         // See: https://docs.anthropic.com/en/docs/claude-code/iam#tool-specific-permission-rules
-        const linearMcpTools = [
-            "mcp__linear"
-        ];
+        const linearMcpTools = ["mcp__linear"];
         // Combine and deduplicate
         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);
         }
     }
 }