cyrus-edge-worker 0.2.21 → 0.2.22

package/dist/AgentSessionManager.js

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import { AgentActivitySignal, AgentSessionStatus, AgentSessionType, } from "cyrus-core";
+import { AgentSessionStatus, AgentSessionType, createLogger, } from "cyrus-core";
 import { DEFAULT_VALIDATION_LOOP_CONFIG, parseValidationResult, renderValidationFixerPrompt, } from "./validation/index.js";
 /**
  * Manages Agent Sessions integration with Claude Code SDK
@@ -9,65 +9,135 @@ import { DEFAULT_VALIDATION_LOOP_CONFIG, parseValidationResult, renderValidation
  * CURRENTLY BEING HANDLED 'per repository'
  */
 export class AgentSessionManager extends EventEmitter {
-    issueTracker;
+    logger;
+    activitySink;
     sessions = new Map();
-    entries = new Map(); // Stores a list of session entries per each session by its linearAgentActivitySessionId
+    entries = new Map(); // Stores a list of session entries per each session by its id
     activeTasksBySession = new Map(); // Maps session ID to active Task tool use ID
     toolCallsByToolUseId = new Map(); // Track tool calls by their tool_use_id
     taskSubjectsByToolUseId = new Map(); // Cache TaskCreate subjects by toolUseId until result arrives with task ID
     taskSubjectsById = new Map(); // Cache task subjects by task ID (e.g., "1" → "Fix login bug")
     activeStatusActivitiesBySession = new Map(); // Maps session ID to active compacting status activity ID
+    stopRequestedSessions = new Set(); // Sessions explicitly stopped by user signal
     procedureAnalyzer;
     sharedApplicationServer;
     getParentSessionId;
     resumeParentSession;
-    constructor(issueTracker, getParentSessionId, resumeParentSession, procedureAnalyzer, sharedApplicationServer) {
+    constructor(activitySink, getParentSessionId, resumeParentSession, procedureAnalyzer, sharedApplicationServer, logger) {
         super();
-        this.issueTracker = issueTracker;
+        this.logger = logger ?? createLogger({ component: "AgentSessionManager" });
+        this.activitySink = activitySink;
         this.getParentSessionId = getParentSessionId;
         this.resumeParentSession = resumeParentSession;
         this.procedureAnalyzer = procedureAnalyzer;
         this.sharedApplicationServer = sharedApplicationServer;
     }
     /**
-     * Initialize a Linear agent session from webhook
-     * The session is already created by Linear, we just need to track it
+     * Get a session-scoped logger with context (sessionId, platform, issueIdentifier).
      */
-    createLinearAgentSession(linearAgentActivitySessionId, issueId, issueMinimal, workspace) {
-        console.log(`[AgentSessionManager] Tracking Linear session ${linearAgentActivitySessionId} for issue ${issueId}`);
+    sessionLog(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return this.logger.withContext({
+            sessionId,
+            platform: session?.issueContext?.trackerId,
+            issueIdentifier: session?.issueContext?.issueIdentifier,
+        });
+    }
+    /**
+     * Initialize an agent session from webhook
+     * The session is already created by the platform, we just need to track it
+     *
+     * @param sessionId - Internal session ID
+     * @param issueId - Issue/PR identifier
+     * @param issueMinimal - Minimal issue data
+     * @param workspace - Workspace configuration
+     * @param platform - Source platform ("linear", "github", "slack"). Defaults to "linear".
+     *                   Only "linear" sessions will have activities streamed to Linear.
+     */
+    createLinearAgentSession(sessionId, issueId, issueMinimal, workspace, platform = "linear") {
+        const log = this.logger.withContext({
+            sessionId,
+            platform,
+            issueIdentifier: issueMinimal.identifier,
+        });
+        log.info(`Tracking session for issue ${issueId}`);
         const agentSession = {
-            linearAgentActivitySessionId,
+            id: sessionId,
+            // Only Linear sessions have a valid external session ID for posting activities
+            externalSessionId: platform === "linear" ? sessionId : undefined,
             type: AgentSessionType.CommentThread,
             status: AgentSessionStatus.Active,
             context: AgentSessionType.CommentThread,
             createdAt: Date.now(),
             updatedAt: Date.now(),
-            issueId,
+            issueContext: {
+                trackerId: platform,
+                issueId: issueId,
+                issueIdentifier: issueMinimal.identifier,
+            },
+            issueId, // Kept for backwards compatibility
             issue: issueMinimal,
             workspace: workspace,
         };
         // Store locally
-        this.sessions.set(linearAgentActivitySessionId, agentSession);
-        this.entries.set(linearAgentActivitySessionId, []);
+        this.sessions.set(sessionId, agentSession);
+        this.entries.set(sessionId, []);
+        return agentSession;
+    }
+    /**
+     * Create an agent session for chat-style platforms (Slack, etc.) that are
+     * not tied to a specific issue or repository.
+     *
+     * Unlike {@link createLinearAgentSession}, this does NOT require issue
+     * context — the session lives in a standalone workspace with no issue
+     * tracker linkage.
+     */
+    createChatSession(sessionId, workspace, platform) {
+        const log = this.logger.withContext({ sessionId, platform });
+        log.info("Creating chat session");
+        const agentSession = {
+            id: sessionId,
+            type: AgentSessionType.CommentThread,
+            status: AgentSessionStatus.Active,
+            context: AgentSessionType.CommentThread,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            workspace,
+        };
+        this.sessions.set(sessionId, agentSession);
+        this.entries.set(sessionId, []);
         return agentSession;
     }
     /**
      * 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);
+    updateAgentSessionWithClaudeSessionId(sessionId, claudeSystemMessage) {
+        const linearSession = this.sessions.get(sessionId);
         if (!linearSession) {
-            console.warn(`[AgentSessionManager] No Linear session found for linearAgentActivitySessionId ${linearAgentActivitySessionId}`);
+            const log = this.sessionLog(sessionId);
+            log.warn(`No session found`);
             return;
         }
         // Determine which runner is being used
         const runner = linearSession.agentRunner;
-        const isGeminiRunner = runner?.constructor.name === "GeminiRunner";
+        const runnerType = runner?.constructor.name === "GeminiRunner"
+            ? "gemini"
+            : runner?.constructor.name === "CodexRunner"
+                ? "codex"
+                : runner?.constructor.name === "CursorRunner"
+                    ? "cursor"
+                    : "claude";
         // Update the appropriate session ID based on runner type
-        if (isGeminiRunner) {
+        if (runnerType === "gemini") {
             linearSession.geminiSessionId = claudeSystemMessage.session_id;
         }
+        else if (runnerType === "codex") {
+            linearSession.codexSessionId = claudeSystemMessage.session_id;
+        }
+        else if (runnerType === "cursor") {
+            linearSession.cursorSessionId = claudeSystemMessage.session_id;
+        }
         else {
             linearSession.claudeSessionId = claudeSystemMessage.session_id;
         }
@@ -83,7 +153,7 @@ export class AgentSessionManager extends EventEmitter {
     /**
      * Create a session entry from user/assistant message (without syncing to Linear)
      */
-    async createSessionEntry(linearAgentActivitySessionId, sdkMessage) {
+    async createSessionEntry(sessionId, 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
@@ -97,14 +167,24 @@ export class AgentSessionManager extends EventEmitter {
         // "error":"rate_limit" field when usage limits are hit
         const sdkError = sdkMessage.type === "assistant" ? sdkMessage.error : undefined;
         // Determine which runner is being used
-        const session = this.sessions.get(linearAgentActivitySessionId);
+        const session = this.sessions.get(sessionId);
         const runner = session?.agentRunner;
-        const isGeminiRunner = runner?.constructor.name === "GeminiRunner";
+        const runnerType = runner?.constructor.name === "GeminiRunner"
+            ? "gemini"
+            : runner?.constructor.name === "CodexRunner"
+                ? "codex"
+                : runner?.constructor.name === "CursorRunner"
+                    ? "cursor"
+                    : "claude";
         const sessionEntry = {
             // Set the appropriate session ID based on runner type
-            ...(isGeminiRunner
+            ...(runnerType === "gemini"
                 ? { geminiSessionId: sdkMessage.session_id }
-                : { claudeSessionId: sdkMessage.session_id }),
+                : runnerType === "codex"
+                    ? { codexSessionId: sdkMessage.session_id }
+                    : runnerType === "cursor"
+                        ? { cursorSessionId: sdkMessage.session_id }
+                        : { claudeSessionId: sdkMessage.session_id }),
             type: sdkMessage.type,
             content: this.extractContent(sdkMessage),
             metadata: {
@@ -128,35 +208,49 @@ export class AgentSessionManager extends EventEmitter {
     /**
      * Complete a session from Claude result message
      */
-    async completeSession(linearAgentActivitySessionId, resultMessage) {
-        const session = this.sessions.get(linearAgentActivitySessionId);
+    async completeSession(sessionId, resultMessage) {
+        const session = this.sessions.get(sessionId);
         if (!session) {
-            console.error(`[AgentSessionManager] No session found for linearAgentActivitySessionId: ${linearAgentActivitySessionId}`);
+            const log = this.sessionLog(sessionId);
+            log.error(`No session found`);
             return;
         }
+        const log = this.sessionLog(sessionId);
         // Clear any active Task when session completes
-        this.activeTasksBySession.delete(linearAgentActivitySessionId);
+        this.activeTasksBySession.delete(sessionId);
         // Clear tool calls tracking for this session
         // Note: We should ideally track by session, but for now clearing all is safer
         // to prevent memory leaks
-        const status = resultMessage.subtype === "success"
-            ? AgentSessionStatus.Complete
-            : AgentSessionStatus.Error;
+        const wasStopRequested = this.consumeStopRequest(sessionId);
+        const status = wasStopRequested
+            ? AgentSessionStatus.Error
+            : resultMessage.subtype === "success"
+                ? AgentSessionStatus.Complete
+                : AgentSessionStatus.Error;
         // Update session status and metadata
-        await this.updateSessionStatus(linearAgentActivitySessionId, status, {
+        await this.updateSessionStatus(sessionId, status, {
             totalCostUsd: resultMessage.total_cost_usd,
             usage: resultMessage.usage,
         });
-        // Handle result using procedure routing system
+        // Handle result using procedure routing system (skip for sessions without procedures, e.g. Slack)
+        if (!this.procedureAnalyzer) {
+            log.info(`Session completed (no procedure routing)`);
+            return;
+        }
+        if (wasStopRequested) {
+            log.info(`Session ${sessionId} was stopped by user; skipping procedure continuation`);
+            return;
+        }
         if ("result" in resultMessage && resultMessage.result) {
-            await this.handleProcedureCompletion(session, linearAgentActivitySessionId, resultMessage);
+            await this.handleProcedureCompletion(session, sessionId, resultMessage);
         }
-        else if (resultMessage.subtype !== "success") {
+        else if (resultMessage.subtype !== "success" &&
+            this.shouldRecoverFromPreviousSubroutine(resultMessage)) {
             // Error result (e.g. error_max_turns from singleTurn subroutines) — try to
             // recover from the last completed subroutine's result so the procedure can still complete.
             const recoveredText = this.procedureAnalyzer?.getLastSubroutineResult(session);
             if (recoveredText) {
-                console.log(`[AgentSessionManager] Recovered result from previous subroutine (subtype: ${resultMessage.subtype}), treating as success for procedure completion`);
+                log.info(`Recovered result from previous subroutine (subtype: ${resultMessage.subtype}), treating as success for procedure completion`);
                 // Create a synthetic success result for procedure routing
                 const syntheticResult = {
                     ...resultMessage,
@@ -164,30 +258,67 @@ export class AgentSessionManager extends EventEmitter {
                     result: recoveredText,
                     is_error: false,
                 };
-                await this.handleProcedureCompletion(session, linearAgentActivitySessionId, syntheticResult);
+                await this.handleProcedureCompletion(session, sessionId, syntheticResult);
             }
             else {
-                console.warn(`[AgentSessionManager] Error result with no recoverable text (subtype: ${resultMessage.subtype}), posting error to Linear`);
-                await this.addResultEntry(linearAgentActivitySessionId, resultMessage);
+                log.warn(`Error result with no recoverable text (subtype: ${resultMessage.subtype}), posting error to Linear`);
+                await this.addResultEntry(sessionId, resultMessage);
             }
         }
+        else if (resultMessage.subtype !== "success") {
+            // Non-recoverable errors (e.g. stop/abort) should not advance procedures.
+            await this.addResultEntry(sessionId, resultMessage);
+        }
+    }
+    shouldRecoverFromPreviousSubroutine(resultMessage) {
+        if (resultMessage.subtype === "error_max_turns") {
+            return true;
+        }
+        const errorText = [
+            resultMessage.subtype,
+            ...("errors" in resultMessage && Array.isArray(resultMessage.errors)
+                ? resultMessage.errors
+                : []),
+            "result" in resultMessage && typeof resultMessage.result === "string"
+                ? resultMessage.result
+                : "",
+        ]
+            .join(" ")
+            .toLowerCase();
+        return (errorText.includes("max turn") ||
+            errorText.includes("turn limit") ||
+            errorText.includes("turns limit"));
+    }
+    consumeStopRequest(linearAgentActivitySessionId) {
+        if (!this.stopRequestedSessions.has(linearAgentActivitySessionId)) {
+            return false;
+        }
+        this.stopRequestedSessions.delete(linearAgentActivitySessionId);
+        return true;
+    }
+    requestSessionStop(linearAgentActivitySessionId) {
+        this.stopRequestedSessions.add(linearAgentActivitySessionId);
     }
     /**
      * Handle completion using procedure routing system
      */
-    async handleProcedureCompletion(session, linearAgentActivitySessionId, resultMessage) {
+    async handleProcedureCompletion(session, sessionId, resultMessage) {
+        const log = this.sessionLog(sessionId);
         if (!this.procedureAnalyzer) {
             throw new Error("ProcedureAnalyzer not available");
         }
         // Check if error occurred
         if (resultMessage.subtype !== "success") {
-            console.log(`[AgentSessionManager] Subroutine completed with error, not triggering next subroutine`);
+            log.info(`Subroutine completed with error, not triggering next subroutine`);
             return;
         }
-        // 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`);
+        // Get the runner session ID (Claude, Gemini, Codex, or Cursor)
+        const runnerSessionId = session.claudeSessionId ||
+            session.geminiSessionId ||
+            session.codexSessionId ||
+            session.cursorSessionId;
+        if (!runnerSessionId) {
+            log.error(`No runner session ID found for procedure session`);
             return;
         }
         // Check if there's a next subroutine
@@ -196,11 +327,11 @@ export class AgentSessionManager extends EventEmitter {
             // More subroutines to run - check if current subroutine requires approval
             const currentSubroutine = this.procedureAnalyzer.getCurrentSubroutine(session);
             if (currentSubroutine?.requiresApproval) {
-                console.log(`[AgentSessionManager] Current subroutine "${currentSubroutine.name}" requires approval before proceeding`);
+                log.info(`Current subroutine "${currentSubroutine.name}" requires approval before proceeding`);
                 // Check if SharedApplicationServer is available
                 if (!this.sharedApplicationServer) {
-                    console.error(`[AgentSessionManager] SharedApplicationServer not available for approval workflow`);
-                    await this.createErrorActivity(linearAgentActivitySessionId, "Approval workflow failed: Server not available");
+                    log.error(`SharedApplicationServer not available for approval workflow`);
+                    await this.createErrorActivity(sessionId, "Approval workflow failed: Server not available");
                     return;
                 }
                 // Extract the final result from the completed subroutine
@@ -209,11 +340,11 @@ export class AgentSessionManager extends EventEmitter {
                     : "No result available";
                 try {
                     // Register approval request with server
-                    const approvalRequest = this.sharedApplicationServer.registerApprovalRequest(linearAgentActivitySessionId);
+                    const approvalRequest = this.sharedApplicationServer.registerApprovalRequest(sessionId);
                     // Post approval elicitation to Linear with auth signal URL
                     const approvalMessage = `The previous step has completed. Please review the result below and approve to continue:\n\n${subroutineResult}`;
-                    await this.createApprovalElicitation(linearAgentActivitySessionId, approvalMessage, approvalRequest.url);
-                    console.log(`[AgentSessionManager] Waiting for approval at URL: ${approvalRequest.url}`);
+                    await this.createApprovalElicitation(sessionId, approvalMessage, approvalRequest.url);
+                    log.info(`Waiting for approval at URL: ${approvalRequest.url}`);
                     // Wait for approval with timeout (30 minutes)
                     const approvalTimeout = 30 * 60 * 1000;
                     const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Approval timeout")), approvalTimeout));
@@ -222,57 +353,57 @@ export class AgentSessionManager extends EventEmitter {
                         timeoutPromise,
                     ]);
                     if (!approved) {
-                        console.log(`[AgentSessionManager] Approval rejected for session ${linearAgentActivitySessionId}`);
-                        await this.createErrorActivity(linearAgentActivitySessionId, `Workflow stopped: User rejected approval.${feedback ? `\n\nFeedback: ${feedback}` : ""}`);
+                        log.info(`Approval rejected`);
+                        await this.createErrorActivity(sessionId, `Workflow stopped: User rejected approval.${feedback ? `\n\nFeedback: ${feedback}` : ""}`);
                         return; // Stop workflow
                     }
-                    console.log(`[AgentSessionManager] Approval granted, continuing to next subroutine`);
+                    log.info(`Approval granted, continuing to next subroutine`);
                     // Optionally post feedback as a thought
                     if (feedback) {
-                        await this.createThoughtActivity(linearAgentActivitySessionId, `User feedback: ${feedback}`);
+                        await this.createThoughtActivity(sessionId, `User feedback: ${feedback}`);
                     }
                     // Continue with advancement (fall through to existing code)
                 }
                 catch (error) {
                     const errorMessage = error.message;
                     if (errorMessage === "Approval timeout") {
-                        console.log(`[AgentSessionManager] Approval timed out for session ${linearAgentActivitySessionId}`);
-                        await this.createErrorActivity(linearAgentActivitySessionId, "Workflow stopped: Approval request timed out after 30 minutes.");
+                        log.info(`Approval timed out`);
+                        await this.createErrorActivity(sessionId, "Workflow stopped: Approval request timed out after 30 minutes.");
                     }
                     else {
-                        console.error(`[AgentSessionManager] Approval request failed:`, error);
-                        await this.createErrorActivity(linearAgentActivitySessionId, `Workflow stopped: Approval request failed - ${errorMessage}`);
+                        log.error(`Approval request failed:`, error);
+                        await this.createErrorActivity(sessionId, `Workflow stopped: Approval request failed - ${errorMessage}`);
                     }
                     return; // Stop workflow
                 }
             }
             // Check if current subroutine uses validation loop
             if (currentSubroutine?.usesValidationLoop) {
-                const handled = await this.handleValidationLoopCompletion(session, linearAgentActivitySessionId, resultMessage, sessionId, nextSubroutine);
+                const handled = await this.handleValidationLoopCompletion(session, sessionId, resultMessage, runnerSessionId, nextSubroutine);
                 if (handled) {
                     return; // Validation loop took over control flow
                 }
                 // If not handled (validation passed or max retries), continue with normal advancement
             }
             // Advance procedure state
-            console.log(`[AgentSessionManager] Subroutine completed, advancing to next: ${nextSubroutine.name}`);
+            log.info(`Subroutine completed, advancing to next: ${nextSubroutine.name}`);
             const subroutineResult = "result" in resultMessage ? resultMessage.result : undefined;
-            this.procedureAnalyzer.advanceToNextSubroutine(session, sessionId, subroutineResult);
+            this.procedureAnalyzer.advanceToNextSubroutine(session, runnerSessionId, subroutineResult);
             // Emit event for EdgeWorker to handle subroutine transition
             // This replaces the callback pattern and allows EdgeWorker to subscribe
             this.emit("subroutineComplete", {
-                linearAgentActivitySessionId,
+                sessionId,
                 session,
             });
         }
         else {
             // Procedure complete - post final result
-            console.log(`[AgentSessionManager] All subroutines completed, posting final result to Linear`);
-            await this.addResultEntry(linearAgentActivitySessionId, resultMessage);
+            log.info(`All subroutines completed, posting final result to Linear`);
+            await this.addResultEntry(sessionId, resultMessage);
             // Handle child session completion
-            const isChildSession = this.getParentSessionId?.(linearAgentActivitySessionId);
+            const isChildSession = this.getParentSessionId?.(sessionId);
             if (isChildSession && this.resumeParentSession) {
-                await this.handleChildSessionCompletion(linearAgentActivitySessionId, resultMessage);
+                await this.handleChildSessionCompletion(sessionId, resultMessage);
             }
         }
     }
@@ -281,7 +412,8 @@ export class AgentSessionManager extends EventEmitter {
      * Returns true if the validation loop took over control flow (needs fixer or retry)
      * Returns false if validation passed or max retries reached (continue with normal advancement)
      */
-    async handleValidationLoopCompletion(session, linearAgentActivitySessionId, resultMessage, _sessionId, _nextSubroutine) {
+    async handleValidationLoopCompletion(session, sessionId, resultMessage, _runnerSessionId, _nextSubroutine) {
+        const log = this.sessionLog(sessionId);
         const maxIterations = DEFAULT_VALIDATION_LOOP_CONFIG.maxIterations;
         // Get or initialize validation loop state
         let validationLoop = session.metadata?.procedure?.validationLoop;
@@ -295,13 +427,13 @@ export class AgentSessionManager extends EventEmitter {
         // Check if we're coming back from the fixer
         if (validationLoop.inFixerMode) {
             // Fixer completed, now we need to re-run verifications
-            console.log(`[AgentSessionManager] Validation fixer completed for iteration ${validationLoop.iteration}, re-running verifications`);
+            log.info(`Validation fixer completed for iteration ${validationLoop.iteration}, re-running verifications`);
             // Clear fixer mode flag
             validationLoop.inFixerMode = false;
             this.updateValidationLoopState(session, validationLoop);
             // Emit event to re-run verifications
             this.emit("validationLoopRerun", {
-                linearAgentActivitySessionId,
+                sessionId,
                 session,
                 iteration: validationLoop.iteration,
             });
@@ -322,27 +454,27 @@ export class AgentSessionManager extends EventEmitter {
             reason: validationResult.reason,
             timestamp: Date.now(),
         });
-        console.log(`[AgentSessionManager] Validation result for iteration ${newIteration}/${maxIterations}: pass=${validationResult.pass}, reason="${validationResult.reason.substring(0, 100)}..."`);
+        log.info(`Validation result for iteration ${newIteration}/${maxIterations}: pass=${validationResult.pass}, reason="${validationResult.reason.substring(0, 100)}..."`);
         // Update state in session
         this.updateValidationLoopState(session, validationLoop);
         // Check if validation passed
         if (validationResult.pass) {
-            console.log(`[AgentSessionManager] Validation passed after ${newIteration} iteration(s)`);
+            log.info(`Validation passed after ${newIteration} iteration(s)`);
             // Clear validation loop state for next subroutine
             this.clearValidationLoopState(session);
             return false; // Continue with normal advancement
         }
         // Check if we've exceeded max retries
         if (newIteration >= maxIterations) {
-            console.log(`[AgentSessionManager] Validation failed after ${newIteration} iterations, continuing anyway`);
+            log.info(`Validation failed after ${newIteration} iterations, continuing anyway`);
             // Post a thought about the failures
-            await this.createThoughtActivity(linearAgentActivitySessionId, `Validation loop exhausted after ${newIteration} attempts. Last failure: ${validationResult.reason}`);
+            await this.createThoughtActivity(sessionId, `Validation loop exhausted after ${newIteration} attempts. Last failure: ${validationResult.reason}`);
             // Clear validation loop state for next subroutine
             this.clearValidationLoopState(session);
             return false; // Continue with normal advancement
         }
         // Validation failed and we have retries left - run the fixer
-        console.log(`[AgentSessionManager] Validation failed, running fixer (iteration ${newIteration}/${maxIterations})`);
+        log.info(`Validation failed, running fixer (iteration ${newIteration}/${maxIterations})`);
         // Set fixer mode flag
         validationLoop.inFixerMode = true;
         this.updateValidationLoopState(session, validationLoop);
@@ -359,7 +491,7 @@ export class AgentSessionManager extends EventEmitter {
         });
         // Emit event for EdgeWorker to run the fixer
         this.emit("validationLoopIteration", {
-            linearAgentActivitySessionId,
+            sessionId,
             session,
             fixerPrompt,
             iteration: newIteration,
@@ -390,76 +522,78 @@ export class AgentSessionManager extends EventEmitter {
     /**
      * Handle child session completion and resume parent
      */
-    async handleChildSessionCompletion(linearAgentActivitySessionId, resultMessage) {
+    async handleChildSessionCompletion(sessionId, resultMessage) {
+        const log = this.sessionLog(sessionId);
         if (!this.getParentSessionId || !this.resumeParentSession) {
             return;
         }
-        const parentAgentSessionId = this.getParentSessionId(linearAgentActivitySessionId);
+        const parentAgentSessionId = this.getParentSessionId(sessionId);
         if (!parentAgentSessionId) {
-            console.error(`[AgentSessionManager] No parent session ID found for child ${linearAgentActivitySessionId}`);
+            log.error(`No parent session ID found for child session`);
             return;
         }
-        console.log(`[AgentSessionManager] Child session ${linearAgentActivitySessionId} completed, resuming parent ${parentAgentSessionId}`);
+        log.info(`Child session completed, resuming parent ${parentAgentSessionId}`);
         try {
             const childResult = "result" in resultMessage
                 ? resultMessage.result
                 : "No result available";
-            const promptToParent = `Child agent session ${linearAgentActivitySessionId} completed with result:\n\n${childResult}`;
-            await this.resumeParentSession(parentAgentSessionId, promptToParent, linearAgentActivitySessionId);
-            console.log(`[AgentSessionManager] Successfully resumed parent session ${parentAgentSessionId}`);
+            const promptToParent = `Child agent session ${sessionId} completed with result:\n\n${childResult}`;
+            await this.resumeParentSession(parentAgentSessionId, promptToParent, sessionId);
+            log.info(`Successfully resumed parent session ${parentAgentSessionId}`);
         }
         catch (error) {
-            console.error(`[AgentSessionManager] Failed to resume parent session:`, error);
+            log.error(`Failed to resume parent session:`, error);
         }
     }
     /**
      * Handle streaming Claude messages and route to appropriate methods
      */
-    async handleClaudeMessage(linearAgentActivitySessionId, message) {
+    async handleClaudeMessage(sessionId, message) {
+        const log = this.sessionLog(sessionId);
         try {
             switch (message.type) {
                 case "system":
                     if (message.subtype === "init") {
-                        this.updateAgentSessionWithClaudeSessionId(linearAgentActivitySessionId, message);
+                        this.updateAgentSessionWithClaudeSessionId(sessionId, message);
                         // Post model notification
                         const systemMessage = message;
                         if (systemMessage.model) {
-                            await this.postModelNotificationThought(linearAgentActivitySessionId, systemMessage.model);
+                            await this.postModelNotificationThought(sessionId, systemMessage.model);
                         }
                     }
                     else if (message.subtype === "status") {
                         // Handle status updates (compacting, etc.)
-                        await this.handleStatusMessage(linearAgentActivitySessionId, message);
+                        await this.handleStatusMessage(sessionId, message);
                     }
                     break;
                 case "user": {
-                    const userEntry = await this.createSessionEntry(linearAgentActivitySessionId, message);
-                    await this.syncEntryToLinear(userEntry, linearAgentActivitySessionId);
+                    const userEntry = await this.createSessionEntry(sessionId, message);
+                    await this.syncEntryToActivitySink(userEntry, sessionId);
                     break;
                 }
                 case "assistant": {
-                    const assistantEntry = await this.createSessionEntry(linearAgentActivitySessionId, message);
-                    await this.syncEntryToLinear(assistantEntry, linearAgentActivitySessionId);
+                    const assistantEntry = await this.createSessionEntry(sessionId, message);
+                    await this.syncEntryToActivitySink(assistantEntry, sessionId);
                     break;
                 }
                 case "result":
-                    await this.completeSession(linearAgentActivitySessionId, message);
+                    await this.completeSession(sessionId, message);
                     break;
                 default:
-                    console.warn(`[AgentSessionManager] Unknown message type: ${message.type}`);
+                    log.warn(`Unknown message type: ${message.type}`);
             }
         }
         catch (error) {
-            console.error(`[AgentSessionManager] Error handling message:`, error);
+            log.error(`Error handling message:`, error);
             // Mark session as error state
-            await this.updateSessionStatus(linearAgentActivitySessionId, AgentSessionStatus.Error);
+            await this.updateSessionStatus(sessionId, AgentSessionStatus.Error);
         }
     }
     /**
      * Update session status and metadata
      */
-    async updateSessionStatus(linearAgentActivitySessionId, status, additionalMetadata) {
-        const session = this.sessions.get(linearAgentActivitySessionId);
+    async updateSessionStatus(sessionId, status, additionalMetadata) {
+        const session = this.sessions.get(sessionId);
         if (!session)
             return;
         session.status = status;
@@ -467,32 +601,51 @@ export class AgentSessionManager extends EventEmitter {
         if (additionalMetadata) {
             session.metadata = { ...session.metadata, ...additionalMetadata };
         }
-        this.sessions.set(linearAgentActivitySessionId, session);
+        this.sessions.set(sessionId, session);
     }
     /**
      * Add result entry from result message
      */
-    async addResultEntry(linearAgentActivitySessionId, resultMessage) {
+    async addResultEntry(sessionId, resultMessage) {
         // Determine which runner is being used
-        const session = this.sessions.get(linearAgentActivitySessionId);
+        const session = this.sessions.get(sessionId);
         const runner = session?.agentRunner;
-        const isGeminiRunner = runner?.constructor.name === "GeminiRunner";
+        const runnerType = runner?.constructor.name === "GeminiRunner"
+            ? "gemini"
+            : runner?.constructor.name === "CodexRunner"
+                ? "codex"
+                : runner?.constructor.name === "CursorRunner"
+                    ? "cursor"
+                    : "claude";
+        // For error results, content may be in errors[] rather than result
+        const content = "result" in resultMessage && typeof resultMessage.result === "string"
+            ? resultMessage.result
+            : resultMessage.is_error &&
+                "errors" in resultMessage &&
+                Array.isArray(resultMessage.errors) &&
+                resultMessage.errors.length > 0
+                ? resultMessage.errors.join("\n")
+                : "";
         const resultEntry = {
             // Set the appropriate session ID based on runner type
-            ...(isGeminiRunner
+            ...(runnerType === "gemini"
                 ? { geminiSessionId: resultMessage.session_id }
-                : { claudeSessionId: resultMessage.session_id }),
+                : runnerType === "codex"
+                    ? { codexSessionId: resultMessage.session_id }
+                    : runnerType === "cursor"
+                        ? { cursorSessionId: resultMessage.session_id }
+                        : { claudeSessionId: resultMessage.session_id }),
             type: "result",
-            content: "result" in resultMessage ? resultMessage.result : "",
+            content,
             metadata: {
                 timestamp: Date.now(),
                 durationMs: resultMessage.duration_ms,
                 isError: resultMessage.is_error,
             },
         };
-        // DON'T store locally - syncEntryToLinear will do it
+        // DON'T store locally - syncEntryToActivitySink will do it
         // Sync to Linear
-        await this.syncEntryToLinear(resultEntry, linearAgentActivitySessionId);
+        await this.syncEntryToActivitySink(resultEntry, sessionId);
     }
     /**
      * Extract content from Claude message
@@ -586,31 +739,32 @@ export class AgentSessionManager extends EventEmitter {
         };
     }
     /**
-     * Sync Agent Session Entry to Linear (create AgentActivity)
+     * Sync session entry to external tracker (create AgentActivity)
      */
-    async syncEntryToLinear(entry, linearAgentActivitySessionId) {
+    async syncEntryToActivitySink(entry, sessionId) {
+        const log = this.sessionLog(sessionId);
         try {
-            const session = this.sessions.get(linearAgentActivitySessionId);
+            const session = this.sessions.get(sessionId);
             if (!session) {
-                console.warn(`[AgentSessionManager] No Linear session for linearAgentActivitySessionId ${linearAgentActivitySessionId}`);
+                log.warn(`No session found`);
                 return;
             }
             // Store entry locally first
-            const entries = this.entries.get(linearAgentActivitySessionId) || [];
+            const entries = this.entries.get(sessionId) || [];
             entries.push(entry);
-            this.entries.set(linearAgentActivitySessionId, entries);
+            this.entries.set(sessionId, entries);
             // Build activity content based on entry type
             let content;
             let ephemeral = false;
             switch (entry.type) {
                 case "user": {
-                    const activeTaskId = this.activeTasksBySession.get(linearAgentActivitySessionId);
+                    const activeTaskId = this.activeTasksBySession.get(sessionId);
                     if (activeTaskId && activeTaskId === entry.metadata?.toolUseId) {
                         content = {
                             type: "thought",
                             body: `✅ Task Completed\n\n\n\n${entry.content}\n\n---\n\n`,
                         };
-                        this.activeTasksBySession.delete(linearAgentActivitySessionId);
+                        this.activeTasksBySession.delete(sessionId);
                     }
                     else if (entry.metadata?.toolUseId) {
                         // This is a tool result - create an action activity with the result
@@ -641,7 +795,7 @@ export class AgentSessionManager extends EventEmitter {
                             if (baseToolName === "TaskUpdate" || baseToolName === "TaskGet") {
                                 const formatter = session.agentRunner?.getFormatter();
                                 if (!formatter) {
-                                    console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                    log.warn(`No formatter available for session ${sessionId}`);
                                     return;
                                 }
                                 // Try to enrich toolInput with subject from cache or result
@@ -706,7 +860,7 @@ export class AgentSessionManager extends EventEmitter {
                             // Get formatter from runner
                             const formatter = session.agentRunner?.getFormatter();
                             if (!formatter) {
-                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                log.warn(`No formatter available`);
                                 return;
                             }
                             // Format parameter and result using runner's formatter
@@ -739,7 +893,7 @@ export class AgentSessionManager extends EventEmitter {
                             // Check if this is a subtask with arrow prefix
                             let storedName = toolName;
                             if (entry.metadata?.parentToolUseId) {
-                                const activeTaskId = this.activeTasksBySession.get(linearAgentActivitySessionId);
+                                const activeTaskId = this.activeTasksBySession.get(sessionId);
                                 if (activeTaskId === entry.metadata?.parentToolUseId) {
                                     storedName = `↪ ${toolName}`;
                                 }
@@ -758,7 +912,7 @@ export class AgentSessionManager extends EventEmitter {
                             // Get formatter from runner
                             const formatter = session.agentRunner?.getFormatter();
                             if (!formatter) {
-                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                log.warn(`No formatter available`);
                                 return;
                             }
                             const formattedTodos = formatter.formatTodoWriteParameter(entry.content);
@@ -773,7 +927,7 @@ export class AgentSessionManager extends EventEmitter {
                             // Get formatter from runner
                             const formatter = session.agentRunner?.getFormatter();
                             if (!formatter) {
-                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                log.warn(`No formatter available for session ${sessionId}`);
                                 return;
                             }
                             // Special handling for Task tools - format as thought instead of action
@@ -801,7 +955,7 @@ export class AgentSessionManager extends EventEmitter {
                             // Get formatter from runner
                             const formatter = session.agentRunner?.getFormatter();
                             if (!formatter) {
-                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                log.warn(`No formatter available for session ${sessionId}`);
                                 return;
                             }
                             // Special handling for ToolSearch - format as thought instead of action
@@ -818,7 +972,7 @@ export class AgentSessionManager extends EventEmitter {
                             // Get formatter from runner
                             const formatter = session.agentRunner?.getFormatter();
                             if (!formatter) {
-                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                log.warn(`No formatter available`);
                                 return;
                             }
                             // Special handling for Task tool - add start marker and track active task
@@ -827,7 +981,7 @@ export class AgentSessionManager extends EventEmitter {
                             const displayName = toolName;
                             // Track this as the active Task for this session
                             if (entry.metadata?.toolUseId) {
-                                this.activeTasksBySession.set(linearAgentActivitySessionId, entry.metadata.toolUseId);
+                                this.activeTasksBySession.set(sessionId, entry.metadata.toolUseId);
                             }
                             content = {
                                 type: "action",
@@ -842,14 +996,14 @@ export class AgentSessionManager extends EventEmitter {
                             // Get formatter from runner
                             const formatter = session.agentRunner?.getFormatter();
                             if (!formatter) {
-                                console.warn(`[AgentSessionManager] No formatter available for session ${linearAgentActivitySessionId}`);
+                                log.warn(`No formatter available`);
                                 return;
                             }
                             // Other tools - check if they're within an active Task
                             const toolInput = entry.metadata.toolInput || entry.content;
                             let displayName = toolName;
                             if (entry.metadata?.parentToolUseId) {
-                                const activeTaskId = this.activeTasksBySession.get(linearAgentActivitySessionId);
+                                const activeTaskId = this.activeTasksBySession.get(sessionId);
                                 if (activeTaskId === entry.metadata?.parentToolUseId) {
                                     displayName = `↪ ${toolName}`;
                                 }
@@ -918,40 +1072,45 @@ export class AgentSessionManager extends EventEmitter {
             if (currentSubroutine?.suppressThoughtPosting) {
                 // Only suppress thoughts and actions, not responses or results
                 if (content.type === "thought" || content.type === "action") {
-                    console.log(`[AgentSessionManager] Suppressing ${content.type} posting for subroutine "${currentSubroutine.name}"`);
-                    return; // Don't post to Linear
+                    log.debug(`Suppressing ${content.type} posting for subroutine "${currentSubroutine.name}"`);
+                    return; // Don't post to tracker
                 }
             }
-            const activityInput = {
-                agentSessionId: session.linearAgentActivitySessionId, // Use the Linear session ID
-                content,
-                ...(ephemeral && { ephemeral: true }),
-            };
-            const result = await this.issueTracker.createAgentActivity(activityInput);
-            if (result.success && result.agentActivity) {
-                const agentActivity = await result.agentActivity;
-                entry.linearAgentActivityId = agentActivity.id;
-                console.log(`[AgentSessionManager] Created ${content.type} activity ${entry.linearAgentActivityId}`);
+            // Ensure we have an external session ID for activity posting
+            if (!session.externalSessionId) {
+                log.debug(`Skipping activity sync - no external session ID (platform: ${session.issueContext?.trackerId || "unknown"})`);
+                return;
             }
-            else {
-                console.error(`[AgentSessionManager] Failed to create Linear activity:`, result);
+            const options = {};
+            if (ephemeral) {
+                options.ephemeral = true;
+            }
+            const result = await this.activitySink.postActivity(session.externalSessionId, content, options);
+            if (result.activityId) {
+                entry.linearAgentActivityId = result.activityId;
+                if (entry.type === "result") {
+                    log.info(`Result message emitted to Linear (activity ${entry.linearAgentActivityId})`);
+                }
+                else {
+                    log.debug(`Created ${content.type} activity ${entry.linearAgentActivityId}`);
+                }
             }
         }
         catch (error) {
-            console.error(`[AgentSessionManager] Failed to sync entry to Linear:`, error);
+            log.error(`Failed to sync entry to activity sink:`, error);
         }
     }
     /**
      * Get session by ID
      */
-    getSession(linearAgentActivitySessionId) {
-        return this.sessions.get(linearAgentActivitySessionId);
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
     }
     /**
      * Get session entries by session ID
      */
-    getSessionEntries(linearAgentActivitySessionId) {
-        return this.entries.get(linearAgentActivitySessionId) || [];
+    getSessionEntries(sessionId) {
+        return this.entries.get(sessionId) || [];
     }
     /**
      * Get all active sessions
@@ -962,15 +1121,16 @@ export class AgentSessionManager extends EventEmitter {
     /**
      * Add or update agent runner for a session
      */
-    addAgentRunner(linearAgentActivitySessionId, agentRunner) {
-        const session = this.sessions.get(linearAgentActivitySessionId);
+    addAgentRunner(sessionId, agentRunner) {
+        const log = this.sessionLog(sessionId);
+        const session = this.sessions.get(sessionId);
         if (!session) {
-            console.warn(`[AgentSessionManager] No session found for linearAgentActivitySessionId ${linearAgentActivitySessionId}`);
+            log.warn(`No session found`);
             return;
         }
         session.agentRunner = agentRunner;
         session.updatedAt = Date.now();
-        console.log(`[AgentSessionManager] Added agent runner to session ${linearAgentActivitySessionId}`);
+        log.debug(`Added agent runner`);
     }
     /**
      *  Get all agent runners
@@ -980,12 +1140,18 @@ export class AgentSessionManager extends EventEmitter {
             .map((session) => session.agentRunner)
             .filter((runner) => runner !== undefined);
     }
+    /**
+     * Resolve the issue ID from a session, checking issueContext first then deprecated issueId.
+     */
+    getSessionIssueId(session) {
+        return session.issueContext?.issueId ?? session.issueId;
+    }
     /**
      * Get all agent runners for a specific issue
      */
     getAgentRunnersForIssue(issueId) {
         return Array.from(this.sessions.values())
-            .filter((session) => session.issueId === issueId)
+            .filter((session) => this.getSessionIssueId(session) === issueId)
             .map((session) => session.agentRunner)
             .filter((runner) => runner !== undefined);
     }
@@ -993,15 +1159,23 @@ export class AgentSessionManager extends EventEmitter {
      * Get sessions by issue ID
      */
     getSessionsByIssueId(issueId) {
-        return Array.from(this.sessions.values()).filter((session) => session.issueId === issueId);
+        return Array.from(this.sessions.values()).filter((session) => this.getSessionIssueId(session) === issueId);
     }
     /**
      * Get active sessions by issue ID
      */
     getActiveSessionsByIssueId(issueId) {
-        return Array.from(this.sessions.values()).filter((session) => session.issueId === issueId &&
+        return Array.from(this.sessions.values()).filter((session) => this.getSessionIssueId(session) === issueId &&
             session.status === AgentSessionStatus.Active);
     }
+    /**
+     * Get active sessions where the issue's branch name matches the given branch.
+     * Useful for detecting when multiple sessions share the same worktree.
+     */
+    getActiveSessionsByBranchName(branchName) {
+        return Array.from(this.sessions.values()).filter((session) => session.status === AgentSessionStatus.Active &&
+            session.issue?.branchName === branchName);
+    }
     /**
      * Get all sessions
      */
@@ -1011,193 +1185,97 @@ export class AgentSessionManager extends EventEmitter {
     /**
      * Get agent runner for a specific session
      */
-    getAgentRunner(linearAgentActivitySessionId) {
-        const session = this.sessions.get(linearAgentActivitySessionId);
+    getAgentRunner(sessionId) {
+        const session = this.sessions.get(sessionId);
         return session?.agentRunner;
     }
     /**
      * Check if an agent runner exists for a session
      */
-    hasAgentRunner(linearAgentActivitySessionId) {
-        const session = this.sessions.get(linearAgentActivitySessionId);
+    hasAgentRunner(sessionId) {
+        const session = this.sessions.get(sessionId);
         return session?.agentRunner !== undefined;
     }
     /**
-     * Create a thought activity
+     * Post an activity to the activity sink for a session.
+     * Consolidates session lookup, externalSessionId guard, try/catch, and logging.
+     *
+     * @returns The activity ID when resolved, `null` otherwise.
      */
-    async createThoughtActivity(sessionId, body) {
+    async postActivity(sessionId, input, label) {
+        const log = this.sessionLog(sessionId);
         const session = this.sessions.get(sessionId);
-        if (!session || !session.linearAgentActivitySessionId) {
-            console.warn(`[AgentSessionManager] No Linear session ID for session ${sessionId}`);
-            return;
+        if (!session || !session.externalSessionId) {
+            log.debug(`Skipping ${label} - no external session ID (platform: ${session?.issueContext?.trackerId || "unknown"})`);
+            return null;
         }
         try {
-            const result = await this.issueTracker.createAgentActivity({
-                agentSessionId: session.linearAgentActivitySessionId,
-                content: {
-                    type: "thought",
-                    body,
-                },
-            });
-            if (result.success) {
-                console.log(`[AgentSessionManager] Created thought activity for session ${sessionId}`);
+            const options = {};
+            if (input.ephemeral !== undefined) {
+                options.ephemeral = input.ephemeral;
             }
-            else {
-                console.error(`[AgentSessionManager] Failed to create thought activity:`, result);
+            if (input.signal) {
+                options.signal = input.signal;
+            }
+            if (input.signalMetadata) {
+                options.signalMetadata = input.signalMetadata;
+            }
+            const result = await this.activitySink.postActivity(session.externalSessionId, input.content, options);
+            if (result.activityId) {
+                log.debug(`Created ${label} activity ${result.activityId}`);
+                return result.activityId;
             }
+            log.debug(`Created ${label}`);
+            return null;
         }
         catch (error) {
-            console.error(`[AgentSessionManager] Error creating thought activity:`, error);
+            log.error(`Error creating ${label}:`, error);
+            return null;
         }
     }
+    /**
+     * Create a thought activity
+     */
+    async createThoughtActivity(sessionId, body) {
+        await this.postActivity(sessionId, { content: { type: "thought", body } }, "thought");
+    }
     /**
      * Create an action activity
      */
     async createActionActivity(sessionId, action, parameter, result) {
-        const session = this.sessions.get(sessionId);
-        if (!session || !session.linearAgentActivitySessionId) {
-            console.warn(`[AgentSessionManager] No Linear session ID for session ${sessionId}`);
-            return;
-        }
-        try {
-            const content = {
-                type: "action",
-                action,
-                parameter,
-            };
-            if (result !== undefined) {
-                content.result = result;
-            }
-            const response = await this.issueTracker.createAgentActivity({
-                agentSessionId: session.linearAgentActivitySessionId,
-                content,
-            });
-            if (response.success) {
-                console.log(`[AgentSessionManager] Created action activity for session ${sessionId}`);
-            }
-            else {
-                console.error(`[AgentSessionManager] Failed to create action activity:`, response);
-            }
-        }
-        catch (error) {
-            console.error(`[AgentSessionManager] Error creating action activity:`, error);
+        const content = { type: "action", action, parameter };
+        if (result !== undefined) {
+            content.result = result;
         }
+        await this.postActivity(sessionId, { content }, "action");
     }
     /**
      * Create a response activity
      */
     async createResponseActivity(sessionId, body) {
-        const session = this.sessions.get(sessionId);
-        if (!session || !session.linearAgentActivitySessionId) {
-            console.warn(`[AgentSessionManager] No Linear session ID for session ${sessionId}`);
-            return;
-        }
-        try {
-            const result = await this.issueTracker.createAgentActivity({
-                agentSessionId: session.linearAgentActivitySessionId,
-                content: {
-                    type: "response",
-                    body,
-                },
-            });
-            if (result.success) {
-                console.log(`[AgentSessionManager] Created response activity for session ${sessionId}`);
-            }
-            else {
-                console.error(`[AgentSessionManager] Failed to create response activity:`, result);
-            }
-        }
-        catch (error) {
-            console.error(`[AgentSessionManager] Error creating response activity:`, error);
-        }
+        await this.postActivity(sessionId, { content: { type: "response", body } }, "response");
     }
     /**
      * Create an error activity
      */
     async createErrorActivity(sessionId, body) {
-        const session = this.sessions.get(sessionId);
-        if (!session || !session.linearAgentActivitySessionId) {
-            console.warn(`[AgentSessionManager] No Linear session ID for session ${sessionId}`);
-            return;
-        }
-        try {
-            const result = await this.issueTracker.createAgentActivity({
-                agentSessionId: session.linearAgentActivitySessionId,
-                content: {
-                    type: "error",
-                    body,
-                },
-            });
-            if (result.success) {
-                console.log(`[AgentSessionManager] Created error activity for session ${sessionId}`);
-            }
-            else {
-                console.error(`[AgentSessionManager] Failed to create error activity:`, result);
-            }
-        }
-        catch (error) {
-            console.error(`[AgentSessionManager] Error creating error activity:`, error);
-        }
+        await this.postActivity(sessionId, { content: { type: "error", body } }, "error");
     }
     /**
      * Create an elicitation activity
      */
     async createElicitationActivity(sessionId, body) {
-        const session = this.sessions.get(sessionId);
-        if (!session || !session.linearAgentActivitySessionId) {
-            console.warn(`[AgentSessionManager] No Linear session ID for session ${sessionId}`);
-            return;
-        }
-        try {
-            const result = await this.issueTracker.createAgentActivity({
-                agentSessionId: session.linearAgentActivitySessionId,
-                content: {
-                    type: "elicitation",
-                    body,
-                },
-            });
-            if (result.success) {
-                console.log(`[AgentSessionManager] Created elicitation activity for session ${sessionId}`);
-            }
-            else {
-                console.error(`[AgentSessionManager] Failed to create elicitation activity:`, result);
-            }
-        }
-        catch (error) {
-            console.error(`[AgentSessionManager] Error creating elicitation activity:`, error);
-        }
+        await this.postActivity(sessionId, { content: { type: "elicitation", body } }, "elicitation");
     }
     /**
      * Create an approval elicitation activity with auth signal
      */
     async createApprovalElicitation(sessionId, body, approvalUrl) {
-        const session = this.sessions.get(sessionId);
-        if (!session || !session.linearAgentActivitySessionId) {
-            console.warn(`[AgentSessionManager] No Linear session ID for session ${sessionId}`);
-            return;
-        }
-        try {
-            const result = await this.issueTracker.createAgentActivity({
-                agentSessionId: session.linearAgentActivitySessionId,
-                content: {
-                    type: "elicitation",
-                    body,
-                },
-                signal: AgentActivitySignal.Auth,
-                signalMetadata: {
-                    url: approvalUrl,
-                },
-            });
-            if (result.success) {
-                console.log(`[AgentSessionManager] Created approval elicitation for session ${sessionId} with URL: ${approvalUrl}`);
-            }
-            else {
-                console.error(`[AgentSessionManager] Failed to create approval elicitation:`, result);
-            }
-        }
-        catch (error) {
-            console.error(`[AgentSessionManager] Error creating approval elicitation:`, error);
-        }
+        await this.postActivity(sessionId, {
+            content: { type: "elicitation", body },
+            signal: "auth",
+            signalMetadata: { url: approvalUrl },
+        }, "approval elicitation");
     }
     /**
      * Clear completed sessions older than specified time
@@ -1207,9 +1285,10 @@ export class AgentSessionManager extends EventEmitter {
         for (const [sessionId, session] of this.sessions.entries()) {
             if ((session.status === "complete" || session.status === "error") &&
                 session.updatedAt < cutoff) {
+                const log = this.sessionLog(sessionId);
                 this.sessions.delete(sessionId);
                 this.entries.delete(sessionId);
-                console.log(`[AgentSessionManager] Cleaned up session ${sessionId}`);
+                log.debug(`Cleaned up session`);
             }
         }
     }
@@ -1254,135 +1333,65 @@ export class AgentSessionManager extends EventEmitter {
             }));
             this.entries.set(sessionId, sessionEntries);
         }
-        console.log(`[AgentSessionManager] Restored ${this.sessions.size} sessions, ${Object.keys(serializedEntries).length} entry collections`);
+        this.logger.debug(`Restored ${this.sessions.size} sessions, ${Object.keys(serializedEntries).length} entry collections`);
     }
     /**
      * Post a thought about the model being used
      */
-    async postModelNotificationThought(linearAgentActivitySessionId, model) {
-        try {
-            const result = await this.issueTracker.createAgentActivity({
-                agentSessionId: linearAgentActivitySessionId,
-                content: {
-                    type: "thought",
-                    body: `Using model: ${model}`,
-                },
-            });
-            if (result.success) {
-                console.log(`[AgentSessionManager] Posted model notification for session ${linearAgentActivitySessionId} (model: ${model})`);
-            }
-            else {
-                console.error(`[AgentSessionManager] Failed to post model notification:`, result);
-            }
-        }
-        catch (error) {
-            console.error(`[AgentSessionManager] Error posting model notification:`, error);
-        }
+    async postModelNotificationThought(sessionId, model) {
+        await this.postActivity(sessionId, { content: { type: "thought", body: `Using model: ${model}` } }, "model notification");
     }
     /**
      * Post an ephemeral "Analyzing your request..." thought and return the activity ID
      */
-    async postAnalyzingThought(linearAgentActivitySessionId) {
-        try {
-            const result = await this.issueTracker.createAgentActivity({
-                agentSessionId: linearAgentActivitySessionId,
-                content: {
-                    type: "thought",
-                    body: "Analyzing your request…",
-                },
-                ephemeral: true,
-            });
-            if (result.success && result.agentActivity) {
-                const activity = await result.agentActivity;
-                console.log(`[AgentSessionManager] Posted analyzing thought for session ${linearAgentActivitySessionId}`);
-                return activity.id;
-            }
-            else {
-                console.error(`[AgentSessionManager] Failed to post analyzing thought:`, result);
-                return null;
-            }
-        }
-        catch (error) {
-            console.error(`[AgentSessionManager] Error posting analyzing thought:`, error);
-            return null;
-        }
+    async postAnalyzingThought(sessionId) {
+        return this.postActivity(sessionId, {
+            content: { type: "thought", body: "Analyzing your request…" },
+            ephemeral: true,
+        }, "analyzing thought");
     }
     /**
      * Post the procedure selection result as a non-ephemeral thought
      */
-    async postProcedureSelectionThought(linearAgentActivitySessionId, procedureName, classification) {
-        try {
-            const result = await this.issueTracker.createAgentActivity({
-                agentSessionId: linearAgentActivitySessionId,
-                content: {
-                    type: "thought",
-                    body: `Selected procedure: **${procedureName}** (classified as: ${classification})`,
-                },
-                ephemeral: false,
-            });
-            if (result.success) {
-                console.log(`[AgentSessionManager] Posted procedure selection for session ${linearAgentActivitySessionId}: ${procedureName}`);
-            }
-            else {
-                console.error(`[AgentSessionManager] Failed to post procedure selection:`, result);
-            }
-        }
-        catch (error) {
-            console.error(`[AgentSessionManager] Error posting procedure selection:`, error);
-        }
+    async postProcedureSelectionThought(sessionId, procedureName, classification) {
+        await this.postActivity(sessionId, {
+            content: {
+                type: "thought",
+                body: `Selected procedure: **${procedureName}** (classified as: ${classification})`,
+            },
+            ephemeral: false,
+        }, "procedure selection");
     }
     /**
      * Handle status messages (compacting, etc.)
      */
-    async handleStatusMessage(linearAgentActivitySessionId, message) {
-        const session = this.sessions.get(linearAgentActivitySessionId);
-        if (!session || !session.linearAgentActivitySessionId) {
-            console.warn(`[AgentSessionManager] No Linear session ID for session ${linearAgentActivitySessionId}`);
+    async handleStatusMessage(sessionId, message) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.externalSessionId) {
+            const log = this.sessionLog(sessionId);
+            log.debug(`Skipping status message - no external session ID (platform: ${session?.issueContext?.trackerId || "unknown"})`);
             return;
         }
-        try {
-            if (message.status === "compacting") {
-                // Create an ephemeral thought for the compacting status
-                const result = await this.issueTracker.createAgentActivity({
-                    agentSessionId: session.linearAgentActivitySessionId,
-                    content: {
-                        type: "thought",
-                        body: "Compacting conversation history…",
-                    },
-                    ephemeral: true,
-                });
-                if (result.success && result.agentActivity) {
-                    const activity = await result.agentActivity;
-                    // Store the activity ID so we can replace it later
-                    this.activeStatusActivitiesBySession.set(linearAgentActivitySessionId, activity.id);
-                    console.log(`[AgentSessionManager] Posted ephemeral compacting status for session ${linearAgentActivitySessionId}`);
-                }
-                else {
-                    console.error(`[AgentSessionManager] Failed to post compacting status:`, result);
-                }
-            }
-            else if (message.status === null) {
-                // Clear the status - post a non-ephemeral thought to replace the ephemeral one
-                const result = await this.issueTracker.createAgentActivity({
-                    agentSessionId: session.linearAgentActivitySessionId,
-                    content: {
-                        type: "thought",
-                        body: "Conversation history compacted",
-                    },
-                    ephemeral: false,
-                });
-                if (result.success) {
-                    // Clean up the stored activity ID
-                    this.activeStatusActivitiesBySession.delete(linearAgentActivitySessionId);
-                    console.log(`[AgentSessionManager] Posted non-ephemeral status clear for session ${linearAgentActivitySessionId}`);
-                }
-                else {
-                    console.error(`[AgentSessionManager] Failed to post status clear:`, result);
-                }
+        if (message.status === "compacting") {
+            const activityId = await this.postActivity(sessionId, {
+                content: {
+                    type: "thought",
+                    body: "Compacting conversation history…",
+                },
+                ephemeral: true,
+            }, "compacting status");
+            if (activityId) {
+                this.activeStatusActivitiesBySession.set(sessionId, activityId);
             }
         }
-        catch (error) {
-            console.error(`[AgentSessionManager] Error handling status message:`, error);
+        else if (message.status === null) {
+            // Clear the status - post a non-ephemeral thought to replace the ephemeral one
+            await this.postActivity(sessionId, {
+                content: { type: "thought", body: "Conversation history compacted" },
+                ephemeral: false,
+            }, "status clear");
+            // Clean up the stored activity ID regardless — stale IDs do no harm
+            this.activeStatusActivitiesBySession.delete(sessionId);
         }
     }
 }