cyrus-edge-worker 0.0.27 → 0.0.28

package/dist/EdgeWorker.js

@@ -1,10 +1,9 @@
 import { EventEmitter } from "node:events";
 import { mkdir, readdir, 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, getAllTools, getReadOnlyTools, getSafeTools, } from "cyrus-claude-runner";
+import { ClaudeRunner, getAllTools, getCoordinatorTools, getReadOnlyTools, 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";
@@ -25,10 +24,15 @@ export class EdgeWorker extends EventEmitter {
     ndjsonClients = new Map(); // listeners for webhook events, one per linear token
     persistenceManager;
     sharedApplicationServer;
+    cyrusHome;
+    childToParentAgentSession = new Map(); // Maps child agentSessionId to parent agentSessionId
     constructor(config) {
         super();
         this.config = config;
-        this.persistenceManager = new PersistenceManager();
+        this.cyrusHome = config.cyrusHome;
+        this.persistenceManager = new PersistenceManager(join(this.cyrusHome, "state"));
+        console.log(`[EdgeWorker Constructor] Initializing parent-child session mapping system`);
+        console.log(`[EdgeWorker Constructor] Parent-child mapping initialized with 0 entries`);
         // Initialize shared application server
         const serverPort = config.serverPort || config.webhookPort || 3456;
         const serverHost = config.serverHost || "localhost";
@@ -46,8 +50,46 @@ export class EdgeWorker extends EventEmitter {
                     accessToken: repo.linearToken,
                 });
                 this.linearClients.set(repo.id, linearClient);
-                // Create AgentSessionManager for this repository
-                this.agentSessionManagers.set(repo.id, new AgentSessionManager(linearClient));
+                // Create AgentSessionManager for this repository with parent session lookup and resume callback
+                //
+                // Note: This pattern works (despite appearing recursive) because:
+                // 1. The agentSessionManager variable is captured by the closure after it's assigned
+                // 2. JavaScript's variable hoisting means 'agentSessionManager' exists (but is undefined) when the arrow function is created
+                // 3. By the time the callback is actually invoked (when a child session completes), agentSessionManager is fully initialized
+                // 4. The callback only executes asynchronously, well after the constructor has completed and agentSessionManager is assigned
+                //
+                // This allows the AgentSessionManager to call back into itself to access its own sessions,
+                // enabling child sessions to trigger parent session resumption using the same manager instance.
+                const agentSessionManager = new AgentSessionManager(linearClient, (childSessionId) => {
+                    console.log(`[Parent-Child Lookup] Looking up parent session for child ${childSessionId}`);
+                    const parentId = this.childToParentAgentSession.get(childSessionId);
+                    console.log(`[Parent-Child Lookup] Child ${childSessionId} -> Parent ${parentId || "not found"}`);
+                    return parentId;
+                }, async (parentSessionId, prompt) => {
+                    console.log(`[Parent Session Resume] Child session completed, resuming parent session ${parentSessionId}`);
+                    // Get the parent session and repository
+                    // This works because by the time this callback runs, agentSessionManager is fully initialized
+                    console.log(`[Parent Session Resume] Retrieving parent session ${parentSessionId} from agent session manager`);
+                    const parentSession = agentSessionManager.getSession(parentSessionId);
+                    if (!parentSession) {
+                        console.error(`[Parent Session Resume] Parent session ${parentSessionId} not found in agent session manager`);
+                        return;
+                    }
+                    console.log(`[Parent Session Resume] Found parent session - Issue: ${parentSession.issueId}, Workspace: ${parentSession.workspace.path}`);
+                    await this.postParentResumeAcknowledgment(parentSessionId, repo.id);
+                    // Resume the parent session with the child's result
+                    console.log(`[Parent Session Resume] Resuming parent Claude session with child results`);
+                    try {
+                        await this.resumeClaudeSession(parentSession, repo, parentSessionId, agentSessionManager, prompt, "", // No attachment manifest for child results
+                        false);
+                        console.log(`[Parent Session Resume] Successfully resumed parent session ${parentSessionId} with child results`);
+                    }
+                    catch (error) {
+                        console.error(`[Parent Session Resume] Failed to resume parent session ${parentSessionId}:`, error);
+                        console.error(`[Parent Session Resume] Error context - Parent issue: ${parentSession.issueId}, Repository: ${repo.name}`);
+                    }
+                });
+                this.agentSessionManagers.set(repo.id, agentSessionManager);
             }
         }
         // Group repositories by token to minimize NDJSON connections
@@ -212,17 +254,16 @@ export class EdgeWorker extends EventEmitter {
      * 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") {
-            console.log(`[EdgeWorker] Webhook payload:`, JSON.stringify(webhook, null, 2));
+            console.log(`[handleWebhook] Full webhook payload:`, JSON.stringify(webhook, null, 2));
         }
         // Find the appropriate repository for this webhook
         const repository = await this.findRepositoryForWebhook(webhook, repos);
         if (!repository) {
-            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(`[handleWebhook] No repository configured for webhook from workspace ${webhook.organizationId}`);
+                console.log(`[handleWebhook] Available repositories:`, repos.map((r) => ({
                     name: r.name,
                     workspaceId: r.linearWorkspaceId,
                     teamKeys: r.teamKeys,
@@ -231,20 +272,16 @@ export class EdgeWorker extends EventEmitter {
             }
             return;
         }
-        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)) {
-                console.log(`[EdgeWorker] Ignoring traditional issue assigned webhook - using agent session events instead`);
                 return;
             }
             else if (isIssueCommentMentionWebhook(webhook)) {
-                console.log(`[EdgeWorker] Ignoring traditional comment mention webhook - using agent session events instead`);
                 return;
             }
             else if (isIssueNewCommentWebhook(webhook)) {
-                console.log(`[EdgeWorker] Ignoring traditional new comment webhook - using agent session events instead`);
                 return;
             }
             else if (isIssueUnassignedWebhook(webhook)) {
@@ -258,11 +295,13 @@ export class EdgeWorker extends EventEmitter {
                 await this.handleUserPostedAgentActivity(webhook, repository);
             }
             else {
-                console.log(`Unhandled webhook type: ${webhook.action}`);
+                if (process.env.CYRUS_WEBHOOK_DEBUG === "true") {
+                    console.log(`[handleWebhook] Unhandled webhook type: ${webhook.action} for repository ${repository.name}`);
+                }
             }
         }
         catch (error) {
-            console.error(`[EdgeWorker] Failed to process webhook: ${webhook.action}`, error);
+            console.error(`[handleWebhook] Failed to process webhook: ${webhook.action} for repository ${repository.name}`, error);
             // Don't re-throw webhook processing errors to prevent application crashes
             // The error has been logged and individual webhook failures shouldn't crash the entire system
         }
@@ -437,7 +476,7 @@ export class EdgeWorker extends EventEmitter {
         const attachmentResult = await this.downloadIssueAttachments(fullIssue, repository, workspace.path);
         // Pre-create attachments directory even if no attachments exist yet
         const workspaceFolderName = basename(workspace.path);
-        const attachmentsDir = join(homedir(), ".cyrus", workspaceFolderName, "attachments");
+        const attachmentsDir = join(this.cyrusHome, workspaceFolderName, "attachments");
         await mkdir(attachmentsDir, { recursive: true });
         // Build allowed directories list - always include attachments directory
         const allowedDirectories = [attachmentsDir];
@@ -481,13 +520,14 @@ export class EdgeWorker extends EventEmitter {
         const sessionData = await this.createLinearAgentSession(linearAgentActivitySessionId, issue, repository, agentSessionManager);
         // Destructure the session data (excluding allowedTools which we'll build with promptType)
         const { session, fullIssue, workspace: _workspace, attachmentResult, attachmentsDir: _attachmentsDir, allowedDirectories, } = sessionData;
-        // Only fetch labels and determine system prompt for delegation (not mentions)
+        // Fetch labels (needed for both model selection and system prompt determination)
+        const labels = await this.fetchIssueLabels(fullIssue);
+        // Only determine system prompt for delegation (not mentions)
         let systemPrompt;
         let systemPromptVersion;
         let promptType;
         if (!isMentionTriggered) {
-            // Fetch issue labels and determine system prompt (delegation case)
-            const labels = await this.fetchIssueLabels(fullIssue);
+            // Determine system prompt based on labels (delegation case)
             const systemPromptResult = await this.determineSystemPromptFromLabels(labels, repository);
             systemPrompt = systemPromptResult?.prompt;
             systemPromptVersion = systemPromptResult?.version;
@@ -504,7 +544,9 @@ export class EdgeWorker extends EventEmitter {
         const allowedTools = this.buildAllowedTools(repository, promptType);
         console.log(`[EdgeWorker] Configured allowed tools for ${fullIssue.identifier}:`, allowedTools);
         // Create Claude runner with attachment directory access and optional system prompt
-        const runnerConfig = this.buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, systemPrompt, allowedTools, allowedDirectories);
+        const runnerConfig = this.buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, agentSessionManager, systemPrompt, allowedTools, allowedDirectories, undefined, // resumeSessionId
+        linearAgentActivitySessionId, // Pass current session ID as parent context
+        labels);
         const runner = new ClaudeRunner(runnerConfig);
         // Store runner by comment ID
         agentSessionManager.addClaudeRunner(linearAgentActivitySessionId, runner);
@@ -600,7 +642,7 @@ export class EdgeWorker extends EventEmitter {
         }
         // Always set up attachments directory, even if no attachments in current comment
         const workspaceFolderName = basename(session.workspace.path);
-        const attachmentsDir = join(homedir(), ".cyrus", workspaceFolderName, "attachments");
+        const attachmentsDir = join(this.cyrusHome, workspaceFolderName, "attachments");
         // Ensure directory exists
         await mkdir(attachmentsDir, { recursive: true });
         let attachmentManifest = "";
@@ -659,44 +701,9 @@ export class EdgeWorker extends EventEmitter {
             existingRunner.addStreamMessage(fullPrompt);
             return; // Exit early - comment has been added to stream
         }
-        // Stop existing runner if it's not streaming or stream addition failed
-        if (existingRunner) {
-            existingRunner.stop();
-        }
-        // For newly created sessions or sessions without claudeSessionId, create a fresh Claude session
-        const needsNewClaudeSession = isNewSession || !session.claudeSessionId;
+        // Use the new resumeClaudeSession function
         try {
-            // Fetch full issue details to get labels (needed for both new and existing sessions)
-            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;
-            const promptType = systemPromptResult?.type;
-            // Build allowed tools list with Linear MCP tools (now with prompt type context)
-            const allowedTools = this.buildAllowedTools(repository, promptType);
-            console.log(`[EdgeWorker] Configured allowed tools for ${issue.identifier} (continued session):`, allowedTools);
-            const allowedDirectories = [attachmentsDir];
-            // Create runner - resume existing session or start new one
-            const runnerConfig = this.buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, systemPrompt, allowedTools, allowedDirectories, needsNewClaudeSession ? undefined : session.claudeSessionId);
-            const runner = new ClaudeRunner(runnerConfig);
-            // Store new runner by comment thread root
-            // Store runner by comment ID
-            agentSessionManager.addClaudeRunner(linearAgentActivitySessionId, runner);
-            // Save state after mapping changes
-            await this.savePersistedState();
-            // Prepare the prompt - different logic for new vs existing sessions
-            const fullPrompt = await this.buildSessionPrompt(isNewSession, fullIssue, repository, promptBody, attachmentManifest);
-            if (isNewSession) {
-                console.log(`[EdgeWorker] Building initial prompt for new session for issue ${fullIssue.identifier}`);
-            }
-            // Start streaming session
-            const sessionType = needsNewClaudeSession ? "new" : "resumed";
-            console.log(`[EdgeWorker] Starting ${sessionType} streaming session for issue ${issue.identifier}`);
-            await runner.startStreaming(fullPrompt);
+            await this.resumeClaudeSession(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest, isNewSession);
         }
         catch (error) {
             console.error("Failed to continue conversation:", error);
@@ -776,7 +783,12 @@ export class EdgeWorker extends EventEmitter {
             return undefined;
         }
         // Check each prompt type for matching labels
-        const promptTypes = ["debugger", "builder", "scoper"];
+        const promptTypes = [
+            "debugger",
+            "builder",
+            "scoper",
+            "orchestrator",
+        ];
         for (const promptType of promptTypes) {
             const promptConfig = repository.labelPrompts[promptType];
             // Handle both old array format and new object format for backward compatibility
@@ -1255,6 +1267,26 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
      * @param issue Full Linear issue object from Linear SDK
      * @param repositoryId Repository ID for Linear client lookup
      */
+    /**
+     * Get the repository configuration for a given session
+     */
+    getRepositoryForSession(session) {
+        // Find the repository that matches the session's workspace path
+        for (const repo of this.config.repositories) {
+            if (session.workspace.path.includes(repo.workspaceBaseDir)) {
+                return repo;
+            }
+        }
+        // Fallback: try to find by issue ID in Linear client
+        for (const [repoId, _] of this.linearClients) {
+            const repo = this.config.repositories.find((r) => r.id === repoId);
+            if (repo) {
+                // Additional checks could be added here if needed
+                return repo;
+            }
+        }
+        return undefined;
+    }
     async moveIssueToStartedState(issue, repositoryId) {
         try {
             const linearClient = this.linearClients.get(repositoryId);
@@ -1369,7 +1401,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
     async downloadIssueAttachments(issue, repository, workspacePath) {
         // Create attachments directory in home directory
         const workspaceFolderName = basename(workspacePath);
-        const attachmentsDir = join(homedir(), ".cyrus", workspaceFolderName, "attachments");
+        const attachmentsDir = join(this.cyrusHome, workspaceFolderName, "attachments");
         try {
             const attachmentMap = {};
             const imageMap = {};
@@ -1713,7 +1745,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
      * Build MCP configuration with automatic Linear server injection
      */
     buildMcpConfig(repository) {
-        // Always inject the Linear MCP server with the repository's token
+        // Always inject the Linear MCP servers with the repository's token
         const mcpConfig = {
             linear: {
                 type: "stdio",
@@ -1723,6 +1755,14 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
                     LINEAR_API_TOKEN: repository.linearToken,
                 },
             },
+            "cyrus-mcp-tools": {
+                type: "stdio",
+                command: "npx",
+                args: ["-y", "cyrus-mcp-tools"],
+                env: {
+                    LINEAR_API_TOKEN: repository.linearToken,
+                },
+            },
         };
         return mcpConfig;
     }
@@ -1740,6 +1780,8 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
                 return getSafeTools();
             case "all":
                 return getAllTools();
+            case "coordinator":
+                return getCoordinatorTools();
             default:
                 // If it's a string but not a preset, treat it as a single tool
                 return [preset];
@@ -1766,18 +1808,137 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
     /**
      * Build Claude runner configuration with common settings
      */
-    buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, systemPrompt, allowedTools, allowedDirectories, resumeSessionId) {
+    buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, agentSessionManager, systemPrompt, allowedTools, allowedDirectories, resumeSessionId, parentAgentSessionId, labels) {
+        // Build hooks configuration
+        const hooks = {
+            PostToolUse: [
+                {
+                    matcher: "mcp__cyrus-mcp-tools__linear_agent_session_create",
+                    hooks: [
+                        async (input, _toolUseID, _options) => {
+                            // Check if this is the linear_agent_session_create tool
+                            if (input.tool_name ===
+                                "mcp__cyrus-mcp-tools__linear_agent_session_create") {
+                                const toolResponse = input.tool_response;
+                                // The response is an array with a single object containing type and text fields
+                                // Parse the JSON from the text field to get the agentSessionId
+                                if (Array.isArray(toolResponse) &&
+                                    toolResponse.length > 0 &&
+                                    toolResponse[0].type === "text" &&
+                                    toolResponse[0].text) {
+                                    try {
+                                        const responseData = JSON.parse(toolResponse[0].text);
+                                        const childAgentSessionId = responseData.agentSessionId;
+                                        // If there's a parent session, create the mapping
+                                        if (parentAgentSessionId && childAgentSessionId) {
+                                            console.log(`[Parent-Child Mapping] Creating: child ${childAgentSessionId} -> parent ${parentAgentSessionId}`);
+                                            this.childToParentAgentSession.set(childAgentSessionId, parentAgentSessionId);
+                                            console.log(`[Parent-Child Mapping] Successfully created. Total mappings: ${this.childToParentAgentSession.size}`);
+                                            // Save state after adding new mapping
+                                            this.savePersistedState().catch((error) => {
+                                                console.error(`[Parent-Child Mapping] Failed to save state after creating mapping:`, error);
+                                            });
+                                        }
+                                    }
+                                    catch (error) {
+                                        console.error(`[Parent-Child Mapping] Failed to parse agentSessionId from tool response:`, error);
+                                    }
+                                }
+                            }
+                            return { continue: true };
+                        },
+                    ],
+                },
+                {
+                    matcher: "mcp__cyrus-mcp-tools__linear_agent_give_feedback",
+                    hooks: [
+                        async (input, _toolUseID, _options) => {
+                            // Check if this is the give_feedback tool
+                            if (input.tool_name ===
+                                "mcp__cyrus-mcp-tools__linear_agent_give_feedback") {
+                                const toolInput = input.tool_input;
+                                const childAgentSessionId = toolInput?.agentSessionId;
+                                const feedbackMessage = toolInput?.message;
+                                if (childAgentSessionId && feedbackMessage) {
+                                    console.log(`[Give Feedback] Triggering child session resumption: ${childAgentSessionId}`);
+                                    // Get the child session
+                                    const childSession = agentSessionManager.getSession(childAgentSessionId);
+                                    if (!childSession) {
+                                        console.error(`[Give Feedback] Child session not found: ${childAgentSessionId}`);
+                                        return { continue: true };
+                                    }
+                                    // Find the repository for this session
+                                    const repo = this.getRepositoryForSession(childSession);
+                                    if (!repo) {
+                                        console.error(`[Give Feedback] Repository not found for child session: ${childAgentSessionId}`);
+                                        return { continue: true };
+                                    }
+                                    // Prepare the prompt with the feedback message and child session ID
+                                    const prompt = `Feedback from parent session regarding child agent session ${childAgentSessionId}:\n\n${feedbackMessage}`;
+                                    // Resume the child session with the feedback
+                                    try {
+                                        await this.resumeClaudeSession(childSession, repo, childAgentSessionId, agentSessionManager, prompt, "", // No attachment manifest for feedback
+                                        false);
+                                        console.log(`[Give Feedback] Successfully resumed child session ${childAgentSessionId} with feedback`);
+                                    }
+                                    catch (error) {
+                                        console.error(`[Give Feedback] Failed to resume child session ${childAgentSessionId}:`, error);
+                                    }
+                                }
+                            }
+                            return { continue: true };
+                        },
+                    ],
+                },
+            ],
+        };
+        // Check for model override labels (case-insensitive)
+        let modelOverride;
+        let fallbackModelOverride;
+        if (labels && labels.length > 0) {
+            const lowercaseLabels = labels.map((label) => label.toLowerCase());
+            // Check for model override labels: opus, sonnet, haiku
+            if (lowercaseLabels.includes("opus")) {
+                modelOverride = "opus";
+                console.log(`[EdgeWorker] Model override via label: opus (for session ${linearAgentActivitySessionId})`);
+            }
+            else if (lowercaseLabels.includes("sonnet")) {
+                modelOverride = "sonnet";
+                console.log(`[EdgeWorker] Model override via label: sonnet (for session ${linearAgentActivitySessionId})`);
+            }
+            else if (lowercaseLabels.includes("haiku")) {
+                modelOverride = "haiku";
+                console.log(`[EdgeWorker] Model override via label: haiku (for session ${linearAgentActivitySessionId})`);
+            }
+            // If a model override is found, also set a reasonable fallback
+            if (modelOverride) {
+                // Set fallback to the next lower tier: opus->sonnet, sonnet->haiku, haiku->haiku
+                if (modelOverride === "opus") {
+                    fallbackModelOverride = "sonnet";
+                }
+                else if (modelOverride === "sonnet") {
+                    fallbackModelOverride = "haiku";
+                }
+                else {
+                    fallbackModelOverride = "haiku";
+                }
+            }
+        }
         const config = {
             workingDirectory: session.workspace.path,
             allowedTools,
             allowedDirectories,
             workspaceName: session.issue?.identifier || session.issueId,
+            cyrusHome: this.cyrusHome,
             mcpConfigPath: repository.mcpConfigPath,
             mcpConfig: this.buildMcpConfig(repository),
             appendSystemPrompt: (systemPrompt || "") + LAST_MESSAGE_MARKER,
-            // Use repository-specific model or fall back to global default
-            model: repository.model || this.config.defaultModel,
-            fallbackModel: repository.fallbackModel || this.config.defaultFallbackModel,
+            // Priority order: label override > repository config > global default
+            model: modelOverride || repository.model || this.config.defaultModel,
+            fallbackModel: fallbackModelOverride ||
+                repository.fallbackModel ||
+                this.config.defaultFallbackModel,
+            hooks,
             onMessage: (message) => {
                 this.handleClaudeMessage(linearAgentActivitySessionId, message, repository.id);
             },
@@ -1823,7 +1984,7 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
         }
         // 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", "mcp__cyrus-mcp-tools"];
         // Combine and deduplicate
         const allTools = [...new Set([...baseTools, ...linearMcpTools])];
         console.log(`[EdgeWorker] Tool selection for ${repository.name}: ${allTools.length} tools from ${toolSource}`);
@@ -1879,9 +2040,12 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
             agentSessions[repositoryId] = serializedState.sessions;
             agentSessionEntries[repositoryId] = serializedState.entries;
         }
+        // Serialize child to parent agent session mapping
+        const childToParentAgentSession = Object.fromEntries(this.childToParentAgentSession.entries());
         return {
             agentSessions,
             agentSessionEntries,
+            childToParentAgentSession,
         };
     }
     /**
@@ -1900,6 +2064,11 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
                 }
             }
         }
+        // Restore child to parent agent session mapping
+        if (state.childToParentAgentSession) {
+            this.childToParentAgentSession = new Map(Object.entries(state.childToParentAgentSession));
+            console.log(`[EdgeWorker] Restored ${this.childToParentAgentSession.size} child-to-parent agent session mappings`);
+        }
     }
     /**
      * Post instant acknowledgment thought when agent session is created
@@ -1930,6 +2099,35 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
             console.error(`[EdgeWorker] Error posting instant acknowledgment:`, error);
         }
     }
+    /**
+     * Post parent resume acknowledgment thought when parent session is resumed from child
+     */
+    async postParentResumeAcknowledgment(linearAgentActivitySessionId, repositoryId) {
+        try {
+            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: "Resuming from child session",
+                },
+            };
+            const result = await linearClient.createAgentActivity(activityInput);
+            if (result.success) {
+                console.log(`[EdgeWorker] Posted parent resumption acknowledgment thought for session ${linearAgentActivitySessionId}`);
+            }
+            else {
+                console.error(`[EdgeWorker] Failed to post parent resumption acknowledgment:`, result);
+            }
+        }
+        catch (error) {
+            console.error(`[EdgeWorker] Error posting parent resumption acknowledgment:`, error);
+        }
+    }
     /**
      * Post thought about system prompt selection based on labels
      */
@@ -1977,6 +2175,18 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
                             selectedPromptType = "scoper";
                             triggerLabel = scoperLabel;
                         }
+                        else {
+                            // Check orchestrator labels
+                            const orchestratorConfig = repository.labelPrompts.orchestrator;
+                            const orchestratorLabels = Array.isArray(orchestratorConfig)
+                                ? orchestratorConfig
+                                : orchestratorConfig?.labels;
+                            const orchestratorLabel = orchestratorLabels?.find((label) => labels.includes(label));
+                            if (orchestratorLabel) {
+                                selectedPromptType = "orchestrator";
+                                triggerLabel = orchestratorLabel;
+                            }
+                        }
                     }
                 }
             }
@@ -2003,6 +2213,72 @@ ${newComment ? `New comment to address:\n${newComment.body}\n\n` : ""}Please ana
             console.error(`[EdgeWorker] Error posting system prompt selection thought:`, error);
         }
     }
+    /**
+     * Resume or create a Claude session with the given prompt
+     * This is the core logic for handling prompted agent activities
+     * @param session The Cyrus agent session
+     * @param repository The repository configuration
+     * @param linearAgentActivitySessionId The Linear agent session ID
+     * @param agentSessionManager The agent session manager
+     * @param promptBody The prompt text to send
+     * @param attachmentManifest Optional attachment manifest
+     * @param isNewSession Whether this is a new session
+     */
+    async resumeClaudeSession(session, repository, linearAgentActivitySessionId, agentSessionManager, promptBody, attachmentManifest = "", isNewSession = false) {
+        // Check for existing runner
+        const existingRunner = session.claudeRunner;
+        // If there's an existing streaming runner, add to it
+        if (existingRunner?.isStreaming()) {
+            let fullPrompt = promptBody;
+            if (attachmentManifest) {
+                fullPrompt = `${promptBody}\n\n${attachmentManifest}`;
+            }
+            fullPrompt = `${fullPrompt}${LAST_MESSAGE_MARKER}`;
+            existingRunner.addStreamMessage(fullPrompt);
+            return;
+        }
+        // Stop existing runner if it's not streaming
+        if (existingRunner) {
+            existingRunner.stop();
+        }
+        // Determine if we need a new Claude session
+        const needsNewClaudeSession = isNewSession || !session.claudeSessionId;
+        // Fetch full issue details
+        const fullIssue = await this.fetchFullIssueDetails(session.issueId, repository.id);
+        if (!fullIssue) {
+            console.error(`[resumeClaudeSession] Failed to fetch full issue details for ${session.issueId}`);
+            throw new Error(`Failed to fetch full issue details for ${session.issueId}`);
+        }
+        // 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 promptType = systemPromptResult?.type;
+        // Build allowed tools list
+        const allowedTools = this.buildAllowedTools(repository, promptType);
+        // Set up attachments directory
+        const workspaceFolderName = basename(session.workspace.path);
+        const attachmentsDir = join(this.cyrusHome, workspaceFolderName, "attachments");
+        await mkdir(attachmentsDir, { recursive: true });
+        const allowedDirectories = [attachmentsDir];
+        // Create runner configuration
+        const runnerConfig = this.buildClaudeRunnerConfig(session, repository, linearAgentActivitySessionId, agentSessionManager, systemPrompt, allowedTools, allowedDirectories, needsNewClaudeSession ? undefined : session.claudeSessionId, linearAgentActivitySessionId, labels);
+        const runner = new ClaudeRunner(runnerConfig);
+        // Store runner
+        agentSessionManager.addClaudeRunner(linearAgentActivitySessionId, runner);
+        // Save state
+        await this.savePersistedState();
+        // Prepare the full prompt
+        const fullPrompt = await this.buildSessionPrompt(isNewSession, fullIssue, repository, promptBody, attachmentManifest);
+        // Start streaming session
+        try {
+            await runner.startStreaming(fullPrompt);
+        }
+        catch (error) {
+            console.error(`[resumeClaudeSession] Failed to start streaming session for ${linearAgentActivitySessionId}:`, error);
+            throw error;
+        }
+    }
     /**
      * Post instant acknowledgment thought when receiving prompted webhook
      */