cyrus-edge-worker 0.2.3 → 0.2.4

package/dist/AgentSessionManager.js

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import { AgentActivitySignal, AgentSessionStatus, AgentSessionType, } from "cyrus-core";
 /**
  * Manages Agent Sessions integration with Claude Code SDK
@@ -6,7 +7,7 @@ import { AgentActivitySignal, AgentSessionStatus, AgentSessionType, } from "cyru
  *
  * CURRENTLY BEING HANDLED 'per repository'
  */
-export class AgentSessionManager {
+export class AgentSessionManager extends EventEmitter {
     issueTracker;
     sessions = new Map();
     entries = new Map(); // Stores a list of session entries per each session by its linearAgentActivitySessionId
@@ -17,12 +18,11 @@ export class AgentSessionManager {
     sharedApplicationServer;
     getParentSessionId;
     resumeParentSession;
-    resumeNextSubroutine;
-    constructor(issueTracker, getParentSessionId, resumeParentSession, resumeNextSubroutine, procedureRouter, sharedApplicationServer) {
+    constructor(issueTracker, getParentSessionId, resumeParentSession, procedureRouter, sharedApplicationServer) {
+        super();
         this.issueTracker = issueTracker;
         this.getParentSessionId = getParentSessionId;
         this.resumeParentSession = resumeParentSession;
-        this.resumeNextSubroutine = resumeNextSubroutine;
         this.procedureRouter = procedureRouter;
         this.sharedApplicationServer = sharedApplicationServer;
     }
@@ -49,7 +49,8 @@ export class AgentSessionManager {
         return agentSession;
     }
     /**
-     * Create a new Agent Session from Claude system initialization
+     * Update Agent Session with session ID from system initialization
+     * Automatically detects whether it's Claude or Gemini based on the runner
      */
     updateAgentSessionWithClaudeSessionId(linearAgentActivitySessionId, claudeSystemMessage) {
         const linearSession = this.sessions.get(linearAgentActivitySessionId);
@@ -57,7 +58,16 @@ export class AgentSessionManager {
             console.warn(`[AgentSessionManager] No Linear session found for linearAgentActivitySessionId ${linearAgentActivitySessionId}`);
             return;
         }
-        linearSession.claudeSessionId = claudeSystemMessage.session_id;
+        // Determine which runner is being used
+        const runner = linearSession.agentRunner;
+        const isGeminiRunner = runner?.constructor.name === "GeminiRunner";
+        // Update the appropriate session ID based on runner type
+        if (isGeminiRunner) {
+            linearSession.geminiSessionId = claudeSystemMessage.session_id;
+        }
+        else {
+            linearSession.claudeSessionId = claudeSystemMessage.session_id;
+        }
         linearSession.updatedAt = Date.now();
         linearSession.metadata = {
             ...linearSession.metadata, // Preserve existing metadata
@@ -68,17 +78,24 @@ export class AgentSessionManager {
         };
     }
     /**
-     * Create a session entry from Claude user/assistant message (without syncing to Linear)
+     * Create a session entry from user/assistant message (without syncing to Linear)
      */
-    async createSessionEntry(_linearAgentActivitySessionId, sdkMessage) {
+    async createSessionEntry(linearAgentActivitySessionId, sdkMessage) {
         // Extract tool info if this is an assistant message
         const toolInfo = sdkMessage.type === "assistant" ? this.extractToolInfo(sdkMessage) : null;
         // Extract tool_use_id and error status if this is a user message with tool_result
         const toolResultInfo = sdkMessage.type === "user"
             ? this.extractToolResultInfo(sdkMessage)
             : null;
+        // Determine which runner is being used
+        const session = this.sessions.get(linearAgentActivitySessionId);
+        const runner = session?.agentRunner;
+        const isGeminiRunner = runner?.constructor.name === "GeminiRunner";
         const sessionEntry = {
-            claudeSessionId: sdkMessage.session_id,
+            // Set the appropriate session ID based on runner type
+            ...(isGeminiRunner
+                ? { geminiSessionId: sdkMessage.session_id }
+                : { claudeSessionId: sdkMessage.session_id }),
             type: sdkMessage.type,
             content: this.extractContent(sdkMessage),
             metadata: {
@@ -98,354 +115,6 @@ export class AgentSessionManager {
         // DON'T store locally yet - wait until we actually post to Linear
         return sessionEntry;
     }
-    /**
-     * Format TodoWrite tool parameter as a nice checklist
-     */
-    formatTodoWriteParameter(jsonContent) {
-        try {
-            const data = JSON.parse(jsonContent);
-            if (!data.todos || !Array.isArray(data.todos)) {
-                return jsonContent;
-            }
-            const todos = data.todos;
-            // Keep original order but add status indicators
-            let formatted = "\n";
-            todos.forEach((todo, index) => {
-                let statusEmoji = "";
-                if (todo.status === "completed") {
-                    statusEmoji = "✅ ";
-                }
-                else if (todo.status === "in_progress") {
-                    statusEmoji = "🔄 ";
-                }
-                else if (todo.status === "pending") {
-                    statusEmoji = "⏳ ";
-                }
-                formatted += `${statusEmoji}${todo.content}`;
-                if (index < todos.length - 1) {
-                    formatted += "\n";
-                }
-            });
-            return formatted;
-        }
-        catch (error) {
-            console.error("[AgentSessionManager] Failed to format TodoWrite parameter:", error);
-            return jsonContent;
-        }
-    }
-    /**
-     * Format tool input for display in Linear agent activities
-     * Converts raw tool inputs into user-friendly parameter strings
-     */
-    formatToolParameter(toolName, toolInput) {
-        // If input is already a string, return it
-        if (typeof toolInput === "string") {
-            return toolInput;
-        }
-        try {
-            switch (toolName) {
-                case "Bash":
-                case "↪ Bash": {
-                    // Show command only - description goes in action field via formatToolActionName
-                    return toolInput.command || JSON.stringify(toolInput);
-                }
-                case "Read":
-                case "↪ Read":
-                    if (toolInput.file_path) {
-                        let param = toolInput.file_path;
-                        if (toolInput.offset !== undefined ||
-                            toolInput.limit !== undefined) {
-                            const start = toolInput.offset || 0;
-                            const end = toolInput.limit ? start + toolInput.limit : "end";
-                            param += ` (lines ${start + 1}-${end})`;
-                        }
-                        return param;
-                    }
-                    break;
-                case "Edit":
-                case "↪ Edit":
-                    if (toolInput.file_path) {
-                        return toolInput.file_path;
-                    }
-                    break;
-                case "Write":
-                case "↪ Write":
-                    if (toolInput.file_path) {
-                        return toolInput.file_path;
-                    }
-                    break;
-                case "Grep":
-                case "↪ Grep":
-                    if (toolInput.pattern) {
-                        let param = `Pattern: \`${toolInput.pattern}\``;
-                        if (toolInput.path) {
-                            param += ` in ${toolInput.path}`;
-                        }
-                        if (toolInput.glob) {
-                            param += ` (${toolInput.glob})`;
-                        }
-                        if (toolInput.type) {
-                            param += ` [${toolInput.type} files]`;
-                        }
-                        return param;
-                    }
-                    break;
-                case "Glob":
-                case "↪ Glob":
-                    if (toolInput.pattern) {
-                        let param = `Pattern: \`${toolInput.pattern}\``;
-                        if (toolInput.path) {
-                            param += ` in ${toolInput.path}`;
-                        }
-                        return param;
-                    }
-                    break;
-                case "Task":
-                case "↪ Task":
-                    if (toolInput.description) {
-                        return toolInput.description;
-                    }
-                    break;
-                case "WebFetch":
-                case "↪ WebFetch":
-                    if (toolInput.url) {
-                        return toolInput.url;
-                    }
-                    break;
-                case "WebSearch":
-                case "↪ WebSearch":
-                    if (toolInput.query) {
-                        return `Query: ${toolInput.query}`;
-                    }
-                    break;
-                case "NotebookEdit":
-                case "↪ NotebookEdit":
-                    if (toolInput.notebook_path) {
-                        let param = toolInput.notebook_path;
-                        if (toolInput.cell_id) {
-                            param += ` (cell ${toolInput.cell_id})`;
-                        }
-                        return param;
-                    }
-                    break;
-                default:
-                    // For MCP tools or other unknown tools, try to extract meaningful info
-                    if (toolName.startsWith("mcp__")) {
-                        // Extract key fields that are commonly meaningful
-                        const meaningfulFields = [
-                            "query",
-                            "id",
-                            "issueId",
-                            "title",
-                            "name",
-                            "path",
-                            "file",
-                        ];
-                        for (const field of meaningfulFields) {
-                            if (toolInput[field]) {
-                                return `${field}: ${toolInput[field]}`;
-                            }
-                        }
-                    }
-                    break;
-            }
-            // Fallback to JSON but make it compact
-            return JSON.stringify(toolInput);
-        }
-        catch (error) {
-            console.error("[AgentSessionManager] Failed to format tool parameter:", error);
-            return JSON.stringify(toolInput);
-        }
-    }
-    /**
-     * Format tool action name with description for Bash tool
-     * Puts the description in round brackets after the tool name in the action field
-     */
-    formatToolActionName(toolName, toolInput, isError) {
-        // Handle Bash tool with description
-        if (toolName === "Bash" || toolName === "↪ Bash") {
-            // Check if toolInput has a description field
-            if (toolInput &&
-                typeof toolInput === "object" &&
-                "description" in toolInput &&
-                toolInput.description) {
-                const baseName = isError ? `${toolName} (Error)` : toolName;
-                return `${baseName} (${toolInput.description})`;
-            }
-        }
-        // Default formatting for other tools or Bash without description
-        return isError ? `${toolName} (Error)` : toolName;
-    }
-    /**
-     * Format tool result for display in Linear agent activities
-     * Converts raw tool results into formatted Markdown
-     */
-    formatToolResult(toolName, toolInput, result, isError) {
-        // If there's an error, wrap in error formatting
-        if (isError) {
-            return `\`\`\`\n${result}\n\`\`\``;
-        }
-        try {
-            switch (toolName) {
-                case "Bash":
-                case "↪ Bash": {
-                    // Show command first if not already in parameter
-                    let formatted = "";
-                    if (toolInput.command && !toolInput.description) {
-                        formatted += `\`\`\`bash\n${toolInput.command}\n\`\`\`\n\n`;
-                    }
-                    // Then show output
-                    if (result?.trim()) {
-                        formatted += `\`\`\`\n${result}\n\`\`\``;
-                    }
-                    else {
-                        formatted += "*No output*";
-                    }
-                    return formatted;
-                }
-                case "Read":
-                case "↪ Read":
-                    // For Read, the result is file content - use code block
-                    if (result?.trim()) {
-                        // Clean up the result: remove line numbers and system-reminder tags
-                        let cleanedResult = result;
-                        // Remove line numbers (format: "  123→")
-                        cleanedResult = cleanedResult.replace(/^\s*\d+→/gm, "");
-                        // Remove system-reminder blocks
-                        cleanedResult = cleanedResult.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "");
-                        // Trim only blank lines (not horizontal whitespace) to preserve indentation
-                        cleanedResult = cleanedResult
-                            .replace(/^\n+/, "")
-                            .replace(/\n+$/, "");
-                        // Try to detect language from file extension
-                        let lang = "";
-                        if (toolInput.file_path) {
-                            const ext = toolInput.file_path.split(".").pop()?.toLowerCase();
-                            const langMap = {
-                                ts: "typescript",
-                                tsx: "typescript",
-                                js: "javascript",
-                                jsx: "javascript",
-                                py: "python",
-                                rb: "ruby",
-                                go: "go",
-                                rs: "rust",
-                                java: "java",
-                                c: "c",
-                                cpp: "cpp",
-                                cs: "csharp",
-                                php: "php",
-                                swift: "swift",
-                                kt: "kotlin",
-                                scala: "scala",
-                                sh: "bash",
-                                bash: "bash",
-                                zsh: "bash",
-                                yml: "yaml",
-                                yaml: "yaml",
-                                json: "json",
-                                xml: "xml",
-                                html: "html",
-                                css: "css",
-                                scss: "scss",
-                                md: "markdown",
-                                sql: "sql",
-                            };
-                            lang = langMap[ext || ""] || "";
-                        }
-                        return `\`\`\`${lang}\n${cleanedResult}\n\`\`\``;
-                    }
-                    return "*Empty file*";
-                case "Edit":
-                case "↪ Edit": {
-                    // For Edit, show changes as a diff
-                    // Extract old_string and new_string from toolInput
-                    if (toolInput.old_string && toolInput.new_string) {
-                        // Format as a unified diff
-                        const oldLines = toolInput.old_string.split("\n");
-                        const newLines = toolInput.new_string.split("\n");
-                        let diff = "```diff\n";
-                        // Add context lines before changes (show all old lines with - prefix)
-                        for (const line of oldLines) {
-                            diff += `-${line}\n`;
-                        }
-                        // Add new lines with + prefix
-                        for (const line of newLines) {
-                            diff += `+${line}\n`;
-                        }
-                        diff += "```";
-                        return diff;
-                    }
-                    // Fallback to result if old/new strings not available
-                    if (result?.trim()) {
-                        return result;
-                    }
-                    return "*Edit completed*";
-                }
-                case "Write":
-                case "↪ Write":
-                    // For Write, just confirm
-                    if (result?.trim()) {
-                        return result; // In case there's an error or message
-                    }
-                    return "*File written successfully*";
-                case "Grep":
-                case "↪ Grep": {
-                    // Format grep results
-                    if (result?.trim()) {
-                        const lines = result.split("\n");
-                        // If it looks like file paths (files_with_matches mode)
-                        if (lines.length > 0 &&
-                            lines[0] &&
-                            !lines[0].includes(":") &&
-                            lines[0].trim().length > 0) {
-                            return `Found ${lines.filter((l) => l.trim()).length} matching files:\n\`\`\`\n${result}\n\`\`\``;
-                        }
-                        // Otherwise it's content matches
-                        return `\`\`\`\n${result}\n\`\`\``;
-                    }
-                    return "*No matches found*";
-                }
-                case "Glob":
-                case "↪ Glob": {
-                    if (result?.trim()) {
-                        const lines = result.split("\n").filter((l) => l.trim());
-                        return `Found ${lines.length} matching files:\n\`\`\`\n${result}\n\`\`\``;
-                    }
-                    return "*No files found*";
-                }
-                case "Task":
-                case "↪ Task":
-                    // Task results can be complex - keep as is but in code block if multiline
-                    if (result?.trim()) {
-                        if (result.includes("\n")) {
-                            return `\`\`\`\n${result}\n\`\`\``;
-                        }
-                        return result;
-                    }
-                    return "*Task completed*";
-                case "WebFetch":
-                case "↪ WebFetch":
-                case "WebSearch":
-                case "↪ WebSearch":
-                    // Web results are usually formatted, keep as is
-                    return result || "*No results*";
-                default:
-                    // For unknown tools, use code block if result has multiple lines
-                    if (result?.trim()) {
-                        if (result.includes("\n") && result.length > 100) {
-                            return `\`\`\`\n${result}\n\`\`\``;
-                        }
-                        return result;
-                    }
-                    return "*Completed*";
-            }
-        }
-        catch (error) {
-            console.error("[AgentSessionManager] Failed to format tool result:", error);
-            return result || "";
-        }
-    }
     /**
      * Complete a session from Claude result message
      */
@@ -485,9 +154,10 @@ export class AgentSessionManager {
             console.log(`[AgentSessionManager] Subroutine completed with error, not triggering next subroutine`);
             return;
         }
-        const claudeSessionId = session.claudeSessionId;
-        if (!claudeSessionId) {
-            console.error(`[AgentSessionManager] No Claude session ID found for procedure session`);
+        // Get the session ID (either Claude or Gemini)
+        const sessionId = session.claudeSessionId || session.geminiSessionId;
+        if (!sessionId) {
+            console.error(`[AgentSessionManager] No session ID found for procedure session`);
             return;
         }
         // Check if there's a next subroutine
@@ -548,16 +218,13 @@ export class AgentSessionManager {
             }
             // Advance procedure state
             console.log(`[AgentSessionManager] Subroutine completed, advancing to next: ${nextSubroutine.name}`);
-            this.procedureRouter.advanceToNextSubroutine(session, claudeSessionId);
-            // Trigger next subroutine
-            if (this.resumeNextSubroutine) {
-                try {
-                    await this.resumeNextSubroutine(linearAgentActivitySessionId);
-                }
-                catch (error) {
-                    console.error(`[AgentSessionManager] Failed to trigger next subroutine:`, error);
-                }
-            }
+            this.procedureRouter.advanceToNextSubroutine(session, sessionId);
+            // Emit event for EdgeWorker to handle subroutine transition
+            // This replaces the callback pattern and allows EdgeWorker to subscribe
+            this.emit("subroutineComplete", {
+                linearAgentActivitySessionId,
+                session,
+            });
         }
         else {
             // Procedure complete - post final result
@@ -653,11 +320,18 @@ export class AgentSessionManager {
         this.sessions.set(linearAgentActivitySessionId, session);
     }
     /**
-     * Add result entry from Claude result message
+     * Add result entry from result message
      */
     async addResultEntry(linearAgentActivitySessionId, resultMessage) {
+        // Determine which runner is being used
+        const session = this.sessions.get(linearAgentActivitySessionId);
+        const runner = session?.agentRunner;
+        const isGeminiRunner = runner?.constructor.name === "GeminiRunner";
         const resultEntry = {
-            claudeSessionId: resultMessage.session_id,
+            // Set the appropriate session ID based on runner type
+            ...(isGeminiRunner
+                ? { geminiSessionId: resultMessage.session_id }
+                : { claudeSessionId: resultMessage.session_id }),
             type: "result",
             content: "result" in resultMessage ? resultMessage.result : "",
             metadata: {
@@ -800,15 +474,23 @@ export class AgentSessionManager {
                             if (entry.metadata.toolUseId) {
                                 this.toolCallsByToolUseId.delete(entry.metadata.toolUseId);
                             }
-                            // Skip creating activity for TodoWrite results since TodoWrite already created a non-ephemeral thought
-                            if (toolName === "TodoWrite" || toolName === "↪ TodoWrite") {
+                            // Skip creating activity for TodoWrite/write_todos results since they already created a non-ephemeral thought
+                            if (toolName === "TodoWrite" ||
+                                toolName === "↪ TodoWrite" ||
+                                toolName === "write_todos") {
+                                return;
+                            }
+                            // Get formatter from runner
+                            const formatter = session.agentRunner?.getFormatter();
+                            if (!formatter) {
+                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
                                 return;
                             }
-                            // Format parameter and result using our formatters
-                            const formattedParameter = this.formatToolParameter(toolName, toolInput);
-                            const formattedResult = this.formatToolResult(toolName, toolInput, toolResult.content?.trim() || "", toolResult.isError);
+                            // Format parameter and result using runner's formatter
+                            const formattedParameter = formatter.formatToolParameter(toolName, toolInput);
+                            const formattedResult = formatter.formatToolResult(toolName, toolInput, toolResult.content?.trim() || "", toolResult.isError);
                             // Format the action name (with description for Bash tool)
-                            const formattedAction = this.formatToolActionName(toolName, toolInput, toolResult.isError);
+                            const formattedAction = formatter.formatToolActionName(toolName, toolInput, toolResult.isError);
                             content = {
                                 type: "action",
                                 action: formattedAction,
@@ -844,20 +526,32 @@ export class AgentSessionManager {
                                 input: entry.metadata.toolInput || entry.content,
                             });
                         }
-                        // Special handling for TodoWrite tool - treat as thought instead of action
-                        if (toolName === "TodoWrite") {
-                            const formattedTodos = this.formatTodoWriteParameter(entry.content);
+                        // Special handling for TodoWrite tool (Claude) and write_todos (Gemini) - treat as thought instead of action
+                        if (toolName === "TodoWrite" || toolName === "write_todos") {
+                            // Get formatter from runner
+                            const formatter = session.agentRunner?.getFormatter();
+                            if (!formatter) {
+                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                return;
+                            }
+                            const formattedTodos = formatter.formatTodoWriteParameter(entry.content);
                             content = {
                                 type: "thought",
                                 body: formattedTodos,
                             };
-                            // TodoWrite is not ephemeral
+                            // TodoWrite/write_todos is not ephemeral
                             ephemeral = false;
                         }
                         else if (toolName === "Task") {
+                            // Get formatter from runner
+                            const formatter = session.agentRunner?.getFormatter();
+                            if (!formatter) {
+                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                return;
+                            }
                             // Special handling for Task tool - add start marker and track active task
                             const toolInput = entry.metadata.toolInput || entry.content;
-                            const formattedParameter = this.formatToolParameter(toolName, toolInput);
+                            const formattedParameter = formatter.formatToolParameter(toolName, toolInput);
                             const displayName = toolName;
                             // Track this as the active Task for this session
                             if (entry.metadata?.toolUseId) {
@@ -873,6 +567,12 @@ export class AgentSessionManager {
                             ephemeral = false;
                         }
                         else {
+                            // Get formatter from runner
+                            const formatter = session.agentRunner?.getFormatter();
+                            if (!formatter) {
+                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                return;
+                            }
                             // Other tools - check if they're within an active Task
                             const toolInput = entry.metadata.toolInput || entry.content;
                             let displayName = toolName;
@@ -882,7 +582,7 @@ export class AgentSessionManager {
                                     displayName = `↪ ${toolName}`;
                                 }
                             }
-                            const formattedParameter = this.formatToolParameter(displayName, toolInput);
+                            const formattedParameter = formatter.formatToolParameter(displayName, toolInput);
                             content = {
                                 type: "action",
                                 action: displayName,
@@ -979,33 +679,33 @@ export class AgentSessionManager {
         return Array.from(this.sessions.values()).filter((session) => session.status === AgentSessionStatus.Active);
     }
     /**
-     * Add or update ClaudeRunner for a session
+     * Add or update agent runner for a session
      */
-    addClaudeRunner(linearAgentActivitySessionId, claudeRunner) {
+    addAgentRunner(linearAgentActivitySessionId, agentRunner) {
         const session = this.sessions.get(linearAgentActivitySessionId);
         if (!session) {
             console.warn(`[AgentSessionManager] No session found for linearAgentActivitySessionId ${linearAgentActivitySessionId}`);
             return;
         }
-        session.claudeRunner = claudeRunner;
+        session.agentRunner = agentRunner;
         session.updatedAt = Date.now();
-        console.log(`[AgentSessionManager] Added ClaudeRunner to session ${linearAgentActivitySessionId}`);
+        console.log(`[AgentSessionManager] Added agent runner to session ${linearAgentActivitySessionId}`);
     }
     /**
-     *  Get all ClaudeRunners
+     *  Get all agent runners
      */
-    getAllClaudeRunners() {
+    getAllAgentRunners() {
         return Array.from(this.sessions.values())
-            .map((session) => session.claudeRunner)
+            .map((session) => session.agentRunner)
             .filter((runner) => runner !== undefined);
     }
     /**
-     * Get all ClaudeRunners for a specific issue
+     * Get all agent runners for a specific issue
      */
-    getClaudeRunnersForIssue(issueId) {
+    getAgentRunnersForIssue(issueId) {
         return Array.from(this.sessions.values())
             .filter((session) => session.issueId === issueId)
-            .map((session) => session.claudeRunner)
+            .map((session) => session.agentRunner)
             .filter((runner) => runner !== undefined);
     }
     /**
@@ -1028,18 +728,18 @@ export class AgentSessionManager {
         return Array.from(this.sessions.values());
     }
     /**
-     * Get ClaudeRunner for a specific session
+     * Get agent runner for a specific session
      */
-    getClaudeRunner(linearAgentActivitySessionId) {
+    getAgentRunner(linearAgentActivitySessionId) {
         const session = this.sessions.get(linearAgentActivitySessionId);
-        return session?.claudeRunner;
+        return session?.agentRunner;
     }
     /**
-     * Check if a ClaudeRunner exists for a session
+     * Check if an agent runner exists for a session
      */
-    hasClaudeRunner(linearAgentActivitySessionId) {
+    hasAgentRunner(linearAgentActivitySessionId) {
         const session = this.sessions.get(linearAgentActivitySessionId);
-        return session?.claudeRunner !== undefined;
+        return session?.agentRunner !== undefined;
     }
     /**
      * Create a thought activity
@@ -1240,8 +940,8 @@ export class AgentSessionManager {
         const entries = {};
         // Serialize sessions
         for (const [sessionId, session] of this.sessions.entries()) {
-            // Exclude claudeRunner from serialization as it's not serializable
-            const { claudeRunner: _claudeRunner, ...serializableSession } = session;
+            // Exclude agentRunner from serialization as it's not serializable
+            const { agentRunner: _agentRunner, ...serializableSession } = session;
             sessions[sessionId] = serializableSession;
         }
         // Serialize entries