@northflare/runner 0.0.11 → 0.0.13

package/src/components/message-handler-sse.ts

@@ -1,1097 +0,0 @@
-/**
- * MessageHandler - Processes incoming JSONRPC messages from SSE events
- */
-
-import { IRunnerApp } from "../types/runner-interface";
-import {
-  RunnerMessage,
-  MethodHandler,
-  ConversationContext,
-  ConversationConfig,
-} from "../types";
-import { SSEClient, SSEEvent } from "../services/SSEClient";
-import { RunnerAPIClient } from "../services/RunnerAPIClient";
-import { statusLineManager } from "../utils/status-line";
-import { console } from "../utils/console";
-import { createLogger } from "../utils/logger";
-import { isRunnerDebugEnabled } from "../utils/debug";
-
-const logger = createLogger("MessageHandler");
-
-export class MessageHandler {
-  private methodHandlers: Map<string, MethodHandler>;
-  private runner: IRunnerApp;
-  private processedMessages: Set<string> = new Set();
-  private sseClient: SSEClient | null = null;
-  private apiClient: RunnerAPIClient;
-  private isProcessing: boolean = false;
-
-  constructor(runner: IRunnerApp) {
-    this.runner = runner;
-    this.methodHandlers = new Map();
-    this.apiClient = new RunnerAPIClient(runner.config_);
-    this.registerHandlers();
-  }
-
-  async startProcessing(): Promise<void> {
-    console.log("MessageHandler: Starting message processing with SSE...");
-
-    if (this.isProcessing) {
-      logger.warn("Message processing already started");
-      return;
-    }
-
-    this.isProcessing = true;
-
-    // Update API client with runner ID if available
-    const runnerId = this.runner.getRunnerId();
-    if (runnerId) {
-      this.apiClient.setRunnerId(runnerId);
-    }
-
-    // Catch up on missed messages first
-    await this.catchUpMissedMessages();
-
-    // Start SSE connection
-    await this.connectSSE();
-  }
-
-  async stopProcessing(): Promise<void> {
-    console.log("MessageHandler: Stopping message processing...");
-
-    this.isProcessing = false;
-
-    // Stop SSE client
-    if (this.sseClient) {
-      this.sseClient.stop();
-      this.sseClient = null;
-    }
-
-    // Clear processed messages tracking
-    this.processedMessages.clear();
-  }
-
-  /**
-   * Catch up on missed messages since lastProcessedAt
-   */
-  private async catchUpMissedMessages(): Promise<void> {
-    const lastProcessedAt = this.runner.getLastProcessedAt();
-
-    if (!lastProcessedAt) {
-      logger.debug("No lastProcessedAt timestamp, skipping catch-up");
-      return;
-    }
-
-    console.log(
-      `MessageHandler: Catching up on messages since ${lastProcessedAt.toISOString()}`
-    );
-
-    try {
-      const messages = await this.apiClient.fetchMissedMessages({
-        since: lastProcessedAt,
-        limit: 1000,
-      });
-
-      if (messages.length > 0) {
-        console.log(
-          `MessageHandler: Processing ${messages.length} missed messages`
-        );
-
-        // Process messages in order
-        for (const message of messages) {
-          await this.processMessage(message);
-        }
-      } else {
-        console.log("MessageHandler: No missed messages to process");
-      }
-    } catch (error) {
-      logger.error("Failed to catch up on missed messages:", error);
-      // Continue anyway - SSE connection might still work
-    }
-  }
-
-  /**
-   * Connect to SSE endpoint
-   */
-  private async connectSSE(): Promise<void> {
-    const runnerId = this.runner.getRunnerId();
-    if (!runnerId) {
-      throw new Error("Cannot connect to SSE without runner ID");
-    }
-
-    const token = process.env["NORTHFLARE_RUNNER_TOKEN"];
-    if (!token) {
-      throw new Error("Missing NORTHFLARE_RUNNER_TOKEN");
-    }
-
-    console.log("MessageHandler: Connecting to SSE endpoint...");
-
-    this.sseClient = new SSEClient({
-      url: `${this.runner.config_.orchestratorUrl}/api/runner-events`,
-      runnerId,
-      token,
-      onMessage: this.handleSSEEvent.bind(this),
-      onError: (error) => {
-        logger.error("SSE connection error:", error);
-      },
-      onConnect: () => {
-        console.log("MessageHandler: SSE connection established");
-      },
-      onDisconnect: () => {
-        console.log("MessageHandler: SSE connection closed");
-      },
-      reconnectInterval: 1000,
-      maxReconnectInterval: 30000,
-      reconnectMultiplier: 2,
-    });
-
-    // Connect with lastProcessedAt for server-side filtering
-    const lastProcessedAt = this.runner.getLastProcessedAt();
-    await this.sseClient.connect(lastProcessedAt?.toISOString());
-  }
-
-  /**
-   * Handle SSE event
-   */
-  private async handleSSEEvent(event: SSEEvent): Promise<void> {
-    if (event.type === "runner.message") {
-      const message = event.data as RunnerMessage;
-
-      if (isRunnerDebugEnabled()) {
-        logger.debug("Received SSE event", {
-          eventId: event.id,
-          type: event.type,
-          messageId: message?.id,
-          method: message?.payload?.method,
-          createdAt: message?.createdAt,
-        });
-      }
-
-      try {
-        // Process the message
-        await this.processMessage(message);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        logger.error("Failed to process runner.message:", msg);
-        // Do not crash the runner on a single bad message
-        return;
-      }
-    } else if (event.type === "connection.established") {
-      logger.debug("SSE connection established", event.data);
-    } else {
-      logger.debug(`Received event type: ${event.type}`, event.data);
-    }
-  }
-
-  private async processMessage(message: RunnerMessage): Promise<void> {
-    if (isRunnerDebugEnabled()) {
-      logger.debug("processMessage called", {
-        messageId: message.id,
-        method: message.payload?.method,
-        direction: message.direction,
-        createdAt: message.createdAt,
-      });
-    }
-
-    // Skip if already processed
-    if (this.processedMessages.has(message.id)) {
-      return;
-    }
-
-    // Check if we should process this message based on ownership
-    if (!this.shouldProcessMessage(message)) {
-      return;
-    }
-
-    const { method, params } = message.payload;
-
-    if (!method) {
-      await this.sendError(message, "Missing method in message payload");
-      return;
-    }
-
-    const handler = this.methodHandlers.get(method);
-
-    if (!handler) {
-      await this.sendError(message, `Unknown method: ${method}`);
-      return;
-    }
-
-    if (isRunnerDebugEnabled()) {
-      logger.debug("Processing message", {
-        messageId: message.id,
-        method: method,
-        taskId: message.taskId,
-        isActionMessage: this.isActionMessage(message),
-      });
-    }
-
-    try {
-      await handler(params, message);
-      await this.markProcessed(message);
-
-      // Acknowledge ALL messages to update lastProcessedAt
-      await this.acknowledgeMessage(message);
-
-      if (isRunnerDebugEnabled()) {
-        logger.debug("Message acknowledged", {
-          messageId: message.id,
-          method: method,
-          timestamp: message.createdAt,
-          wasActionMessage: this.isActionMessage(message),
-        });
-      }
-    } catch (error) {
-      if (isRunnerDebugEnabled()) {
-        logger.debug("Message processing error", {
-          messageId: message.id,
-          method: method,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-      await this.handleError(message, error);
-    }
-  }
-
-  private shouldProcessMessage(message: RunnerMessage): boolean {
-    const decision = (() => {
-      // Always process our own responses going to orchestrator
-      if (message.direction === "to_orchestrator") {
-        return { shouldProcess: true, reason: "own response to orchestrator" };
-      }
-
-      // Always process UID change messages BEFORE checking timestamp
-      // This is critical because UID changes can update lastProcessedAt itself
-      if (message.payload?.method === "runner.uid.changed") {
-        return { shouldProcess: true, reason: "UID change message" };
-      }
-
-      // Filter by lastProcessedAt (after checking for UID change messages)
-      const lastProcessedAt = this.runner.getLastProcessedAt();
-      if (lastProcessedAt && message.createdAt) {
-        const messageTime = new Date(message.createdAt);
-        if (messageTime <= lastProcessedAt) {
-          return {
-            shouldProcess: false,
-            reason: "message before lastProcessedAt",
-          };
-        }
-      }
-
-      // If we're not the active runner
-      if (!this.runner.getIsActiveRunner()) {
-        // Only process if it's for a pre-handoff conversation by conversationId
-        const cid =
-          message.conversationId || message.payload?.params?.conversationId;
-        if (cid && this.runner.getPreHandoffConversations().has(cid)) {
-          return {
-            shouldProcess: true,
-            reason: "pre-handoff conversation (by conversationId)",
-          };
-        }
-        return { shouldProcess: false, reason: "not active runner" };
-      }
-
-      // We're active and message is after lastProcessedAt
-      return {
-        shouldProcess: true,
-        reason: "active runner, message after watermark",
-      };
-    })();
-
-    if (isRunnerDebugEnabled()) {
-      logger.debug("Message processing decision", {
-        messageId: message.id,
-        method: message.payload?.method,
-        shouldProcess: decision.shouldProcess,
-        reason: decision.reason,
-        runnerUid: this.runner.getRunnerUid(),
-        isActiveRunner: this.runner.getIsActiveRunner(),
-        lastProcessedAt:
-          this.runner.getLastProcessedAt()?.toISOString() || "null",
-        messageCreatedAt: message.createdAt,
-      });
-    }
-
-    return decision.shouldProcess;
-  }
-
-  private isActionMessage(message: RunnerMessage): boolean {
-    const actionMethods = [
-      "conversation.start",
-      "conversation.stop",
-      "conversation.resume",
-      "conversation.config",
-      "message.user",
-    ];
-    return actionMethods.includes(message.payload?.method || "");
-  }
-
-  private async acknowledgeMessage(message: RunnerMessage): Promise<void> {
-    const runnerId = this.runner.getRunnerId();
-    console.log(`[MessageHandler] Sending message.acknowledge:`, {
-      runnerId,
-      messageTimestamp: message.createdAt,
-      messageId: message.id,
-      method: message.payload?.method,
-    });
-
-    try {
-      await this.apiClient.acknowledgeMessage(message.createdAt);
-
-      // Update local lastProcessedAt
-      await this.runner.updateLastProcessedAt!(new Date(message.createdAt));
-
-      console.log(`[MessageHandler] ✅ message.acknowledge sent successfully`);
-    } catch (error) {
-      logger.error("Failed to acknowledge message:", error);
-      // Continue processing even if acknowledgment fails
-    }
-  }
-
-  private async markProcessed(message: RunnerMessage): Promise<void> {
-    // Track processed messages internally
-    this.processedMessages.add(message.id);
-  }
-
-  private async sendError(
-    message: RunnerMessage,
-    errorMessage: string
-  ): Promise<void> {
-    // Send error report with conversation object info if available
-    const conversationObjectType =
-      message.conversationObjectType || (message.taskId ? "Task" : undefined);
-    const conversationObjectId = message.conversationObjectId || message.taskId;
-
-    if (!conversationObjectId) {
-      console.error(
-        `[MessageHandler] Cannot send error report - no conversationObjectId available. Error: ${errorMessage}`
-      );
-      if (isRunnerDebugEnabled()) {
-        logger.debug("Error without conversationObjectId", {
-          messageId: message.id,
-          method: message.payload?.method,
-          error: errorMessage,
-          runnerId: message.runnerId,
-        });
-      }
-      return;
-    }
-
-    await this.runner.notify("error.report", {
-      conversationObjectType,
-      conversationObjectId,
-      messageId: message.id,
-      errorType: "method_error",
-      message: errorMessage,
-      details: {
-        originalMessage: message,
-        timestamp: new Date(),
-      },
-    });
-  }
-
-  private async handleError(message: RunnerMessage, error: any): Promise<void> {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const errorStack = error instanceof Error ? error.stack : undefined;
-
-    // Send error report with conversation object info if available
-    const conversationObjectType =
-      message.conversationObjectType || (message.taskId ? "Task" : undefined);
-    const conversationObjectId = message.conversationObjectId || message.taskId;
-
-    if (!conversationObjectId) {
-      console.error(
-        `[MessageHandler] Cannot send error report - no conversationObjectId available. Processing error: ${errorMessage}`
-      );
-      if (isRunnerDebugEnabled()) {
-        logger.debug("Processing error without conversationObjectId", {
-          messageId: message.id,
-          method: message.payload?.method,
-          error: errorMessage,
-          stack: errorStack,
-          runnerId: message.runnerId,
-        });
-      }
-      return;
-    }
-
-    await this.runner.notify("error.report", {
-      conversationObjectType,
-      conversationObjectId,
-      messageId: message.id,
-      errorType: "processing_error",
-      message: errorMessage,
-      details: {
-        stack: errorStack,
-        originalMessage: message,
-        timestamp: new Date(),
-      },
-    });
-  }
-
-  private registerHandlers(): void {
-    console.log("MessageHandler: Registering handlers...");
-
-    this.methodHandlers = new Map([
-      ["conversation.start", this.handleConversationStart.bind(this)],
-      ["conversation.stop", this.handleConversationStop.bind(this)],
-      ["conversation.resume", this.handleConversationResume.bind(this)],
-      ["conversation.config", this.handleConversationConfig.bind(this)],
-      ["message.user", this.handleUserMessage.bind(this)],
-      ["runner.uid.changed", this.handleUidChanged.bind(this)],
-      ["git.operation", this.handleGitOperation.bind(this)],
-      ["git.cleanup", this.handleGitCleanup.bind(this)],
-    ]);
-  }
-
-  // All the handler methods remain the same as in the original file
-  // Just copy them from the original message-handler.ts starting from line 386
-
-  private async handleConversationStart(
-    params: any,
-    message: RunnerMessage
-  ): Promise<void> {
-    const {
-      conversationObjectType = message.conversationObjectType || "Task",
-      conversationObjectId = message.conversationObjectId ||
-        params.conversation?.objectId,
-      config,
-      initialMessages,
-      conversation,
-    } = params;
-
-    // Validate required parameters
-    if (!config) {
-      throw new Error("Missing required parameter: config");
-    }
-
-    // Require a conversation object
-    const conversationData = conversation;
-    if (!conversationData) {
-      throw new Error(
-        "Missing required parameter: conversation object must be provided"
-      );
-    }
-
-    const finalObjectType =
-      conversationObjectType || conversationData.objectType;
-    const finalObjectId = conversationObjectId || conversationData.objectId;
-    if (!finalObjectId) {
-      throw new Error("Missing conversationObjectId");
-    }
-
-    // Debug log the config
-    console.log(`[MessageHandler] conversation.start config:`, {
-      conversationObjectId,
-      hasConfig: !!config,
-      hasRepository: !!config?.repository,
-      repositoryType: config?.repository?.type,
-      repositoryUrl: config?.repository?.url,
-      workspaceId: config?.workspaceId,
-      fullConfig: JSON.stringify(config, null, 2),
-    });
-
-    // Debug log workspace instructions received
-    console.log(
-      `[MessageHandler] Received conversation with workspaceInstructions:`,
-      {
-        conversationId: conversationData.id,
-        hasWorkspaceInstructions: !!conversationData.workspaceInstructions,
-        workspaceInstructionsLength: conversationData.workspaceInstructions?.length ?? 0,
-        workspaceInstructionsPreview: conversationData.workspaceInstructions?.slice(0, 100),
-        hasGlobalInstructions: !!conversationData.globalInstructions,
-        globalInstructionsLength: conversationData.globalInstructions?.length ?? 0,
-      }
-    );
-
-    const provider = this.resolveAgentProvider(conversationData, config);
-    const manager = this.getManagerForProvider(provider);
-
-    // Start the conversation with the provided/loaded conversation details
-    await manager.startConversation(
-      finalObjectType,
-      finalObjectId,
-      config,
-      initialMessages || [],
-      conversationData
-    );
-
-    // Update status line
-    statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-  }
-
-  private async handleConversationStop(
-    params: any,
-    message: RunnerMessage
-  ): Promise<void> {
-    // Require conversationId (present at message level); do not fall back to agentSessionId/taskId
-    const { conversationId = message.conversationId, reason } = params;
-
-    console.log(`[MessageHandler] handleConversationStop called with:`, {
-      conversationId,
-      messageConversationId: message.conversationId,
-      agentSessionId: params?.agentSessionId,
-      taskId: params?.taskId,
-      params: JSON.stringify(params),
-      activeConversations: this.runner.activeConversations_.size,
-      conversationIds: Array.from(this.runner.activeConversations_.keys()),
-    });
-
-    // Lookup strictly by conversationId
-    let context: ConversationContext | undefined;
-    let targetConversationId: string | undefined;
-    if (conversationId) {
-      context = this.runner.getConversationContext(conversationId);
-      targetConversationId = conversationId;
-    }
-
-    console.log(`[MessageHandler] handleConversationStop lookup result:`, {
-      contextFound: !!context,
-      targetConversationId,
-      contextTaskId: context?.taskId,
-      contextAgentSessionId: context?.agentSessionId,
-    });
-
-    // Check if we have any identifier to work with
-    if (!conversationId) {
-      throw new Error("Missing required parameter: conversationId");
-    }
-
-    if (context && targetConversationId) {
-      context.status = "stopping";
-      const manager = this.getManagerForConversationContext(context);
-      await manager.stopConversation(
-        context.agentSessionId,
-        context,
-        false, // Not a runner shutdown
-        reason // Pass the reason through
-      );
-      context.status = "stopped";
-      this.runner.activeConversations_.delete(targetConversationId);
-
-      // Update status line
-      statusLineManager.updateActiveCount(
-        this.runner.activeConversations_.size
-      );
-    } else {
-      // No conversation found - this is expected as conversations may have already ended
-      // or been cleaned up. Just log it and update status line.
-      console.log(
-        `Conversation stop requested for ${conversationId} - conversation not found or already cleaned up`
-      );
-
-      // If we have a targetConversationId, ensure it's removed from tracking
-      if (targetConversationId) {
-        this.runner.activeConversations_.delete(targetConversationId);
-      }
-
-      statusLineManager.updateActiveCount(
-        this.runner.activeConversations_.size
-      );
-    }
-  }
-
-  private async handleConversationResume(
-    params: any,
-    message: RunnerMessage
-  ): Promise<void> {
-    const {
-      conversationId = message.conversationId,
-      conversation: resumeConversation,
-      config,
-      message: resumeMessage,
-    } = params;
-
-    const cid = params.conversationId || conversationId;
-    if (!cid) {
-      throw new Error("Missing required parameter: conversationId");
-    }
-
-    // Require conversation details
-    const conversationData = resumeConversation;
-    if (!conversationData) {
-      throw new Error(
-        "Missing required parameter: conversation object must be provided"
-      );
-    }
-
-    const agentSessionId = conversationData.agentSessionId;
-    if (!agentSessionId) {
-      throw new Error("Cannot resume conversation without agentSessionId");
-    }
-
-    const provider = this.resolveAgentProvider(conversationData, config);
-    const manager = this.getManagerForProvider(provider);
-    await manager.resumeConversation(
-      conversationData.objectType,
-      conversationData.objectId,
-      agentSessionId,
-      config,
-      conversationData,
-      resumeMessage
-    );
-  }
-
-  private async handleConversationConfig(
-    params: any,
-    message: RunnerMessage
-  ): Promise<void> {
-    const { conversationId, model, permissionsMode, config } = params;
-
-    console.log(`[MessageHandler] handleConversationConfig called with:`, {
-      conversationId,
-      model,
-      permissionsMode,
-      hasConfig: !!config,
-    });
-
-    // Find the active conversation by conversationId only
-    let context: ConversationContext | undefined;
-    if (conversationId) {
-      context = this.runner.getConversationContext(conversationId);
-    }
-
-    if (!context) {
-      throw new Error(
-        `No active conversation found for conversationId: ${conversationId}`
-      );
-    }
-
-    // Validate required parameters
-    if (!model && !permissionsMode) {
-      throw new Error(
-        "At least one of model or permissionsMode must be provided"
-      );
-    }
-
-    // Update the config with new values
-    const newConfig = {
-      ...context.config,
-      ...(model && { model }),
-      ...(permissionsMode && { permissionsMode }),
-      ...config, // Allow full config overrides if provided
-    };
-
-    console.log(
-      `[MessageHandler] Stopping conversation ${context.conversationId} to apply new config`
-    );
-
-    // Stop the current conversation
-    const manager = this.getManagerForConversationContext(context);
-
-    await manager.stopConversation(
-      context.agentSessionId,
-      context,
-      false // Not a runner shutdown, just updating config
-    );
-
-    // Remove from active conversations
-    this.runner.activeConversations_.delete(context.conversationId);
-
-    console.log(
-      `[MessageHandler] Resuming conversation ${context.conversationId} with new config`
-    );
-
-    // Resume with new config
-    await manager.resumeConversation(
-      context.conversationObjectType,
-      context.conversationObjectId,
-      context.agentSessionId,
-      newConfig,
-      {
-        id: context.conversationId,
-        objectType: context.conversationObjectType,
-        objectId: context.conversationObjectId,
-        model: newConfig.model,
-        globalInstructions: context.globalInstructions,
-        workspaceInstructions: context.workspaceInstructions,
-        permissionsMode: newConfig.permissionsMode,
-        agentSessionId: context.agentSessionId,
-      },
-      "<system-instructions>Configuration updated. Please continue with the new settings.</system-instructions>"
-    );
-
-    // Update status line
-    statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-
-    console.log(
-      `[MessageHandler] Conversation ${context.conversationId} config updated successfully`
-    );
-  }
-
-  private async handleUserMessage(
-    params: any,
-    message: RunnerMessage
-  ): Promise<void> {
-    const {
-      conversationId,
-      content,
-      config,
-      conversationObjectType = message.conversationObjectType || "Task",
-      conversationObjectId = message.conversationObjectId,
-      conversation,
-      agentSessionId,
-    } = params;
-
-    // Validate required parameters
-    if (!conversationId) {
-      throw new Error("Missing required parameter: conversationId");
-    }
-
-    if (!content) {
-      throw new Error("Missing required parameter: content");
-    }
-
-    const existingContext = this.runner.getConversationContext(conversationId);
-    const manager = existingContext
-      ? this.getManagerForConversationContext(existingContext)
-      : this.getManagerForProvider(
-          this.resolveAgentProvider(conversation, config)
-        );
-
-    await manager.sendUserMessage(
-      conversationId,
-      content,
-      config,
-      conversationObjectType,
-      conversationObjectId,
-      conversation,
-      agentSessionId
-    );
-  }
-
-  private async handleUidChanged(
-    params: any,
-    _message: RunnerMessage
-  ): Promise<void> {
-    const { runnerUid, lastProcessedAt } = params;
-
-    console.log(
-      `MessageHandler: Handling UID change notification - new UID: ${runnerUid}, lastProcessedAt: ${lastProcessedAt}`
-    );
-
-    if (isRunnerDebugEnabled()) {
-      logger.debug("UID change notification received", {
-        newUid: runnerUid,
-        currentUid: this.runner.getRunnerUid(),
-        newLastProcessedAt: lastProcessedAt,
-        currentLastProcessedAt:
-          this.runner.getLastProcessedAt()?.toISOString() || "null",
-        wasActiveRunner: this.runner.getIsActiveRunner(),
-        activeConversations: this.runner.activeConversations_.size,
-      });
-    }
-
-    // Check if the UID matches ours FIRST, before checking timestamps
-    // This ensures we activate even if we received the message during catch-up
-    if (runnerUid === this.runner.getRunnerUid()) {
-      // This is our UID - we're the active runner
-      console.log("MessageHandler: We are now the active runner");
-      this.runner.setIsActiveRunner(true);
-      await this.runner.updateLastProcessedAt!(
-        lastProcessedAt ? new Date(lastProcessedAt) : null
-      );
-
-      if (isRunnerDebugEnabled()) {
-        logger.debug("Runner activated as primary", {
-          runnerUid: runnerUid,
-          lastProcessedAt: lastProcessedAt,
-          orchestratorUrl: this.runner.config_.orchestratorUrl,
-        });
-      }
-
-      // Emit activation notification - wrap in try/catch to handle failures gracefully
-      try {
-        await this.runner.notify("runner.activate", {
-          runnerId: this.runner.getRunnerId(),
-          runnerUid: runnerUid,
-        });
-      } catch (error) {
-        console.error("Failed to send activation notification:", error);
-        if (isRunnerDebugEnabled()) {
-          logger.debug("Activation notification failed", {
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-      }
-
-      // Start processing messages from the lastProcessedAt point
-      console.log(
-        `MessageHandler: Will process messages after ${
-          lastProcessedAt || "beginning"
-        }`
-      );
-    } else {
-      // Different UID - check if this is an old UID change that we should ignore
-      const currentLastProcessedAt = this.runner.getLastProcessedAt();
-      if (currentLastProcessedAt && lastProcessedAt) {
-        const newTime = new Date(lastProcessedAt);
-        if (newTime < currentLastProcessedAt) {
-          console.log(
-            `MessageHandler: Ignoring old UID change (${lastProcessedAt} < ${currentLastProcessedAt.toISOString()})`
-          );
-          if (isRunnerDebugEnabled()) {
-            logger.debug("Ignoring old UID change", {
-              newUid: runnerUid,
-              newLastProcessedAt: lastProcessedAt,
-              currentLastProcessedAt: currentLastProcessedAt.toISOString(),
-            });
-          }
-          return;
-        }
-      }
-
-      // Different UID - we're being replaced
-      console.log(
-        `MessageHandler: We are being replaced by runner with UID ${runnerUid}`
-      );
-      this.runner.setIsActiveRunner(false);
-
-      // Remember which conversations were active before handoff (by conversationId)
-      for (const [conversationId, context] of this.runner
-        .activeConversations_) {
-        if (context.status === "active") {
-          this.runner.getPreHandoffConversations().add(conversationId);
-        }
-      }
-
-      if (isRunnerDebugEnabled()) {
-        logger.debug("Runner deactivated - being replaced", {
-          newRunnerUid: runnerUid,
-          ourUid: this.runner.getRunnerUid(),
-          preHandoffConversations: Array.from(
-            this.runner.getPreHandoffConversations()
-          ),
-          activeConversationsCount:
-            this.runner.getPreHandoffConversations().size,
-        });
-      }
-
-      console.log(
-        `MessageHandler: Will complete ${
-          this.runner.getPreHandoffConversations().size
-        } active conversations`
-      );
-
-      // Emit deactivation notification - wrap in try/catch to handle failures gracefully
-      try {
-        await this.runner.notify("runner.deactivate", {
-          runnerId: this.runner.getRunnerId(),
-          runnerUid: this.runner.getRunnerUid(),
-          activeConversations: this.runner.getPreHandoffConversations().size,
-        });
-      } catch (error) {
-        console.error("Failed to send deactivation notification:", error);
-        if (isRunnerDebugEnabled()) {
-          logger.debug("Deactivation notification failed", {
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-      }
-    }
-  }
-
-  private async handleGitOperation(
-    params: any,
-    message: RunnerMessage
-  ): Promise<void> {
-    const { taskId, operation, params: opParams } = params;
-
-    if (!taskId || !operation) {
-      throw new Error("Missing required parameters: taskId and operation");
-    }
-
-    console.log(
-      `MessageHandler: Handling Git operation ${operation} for task ${taskId}`
-    );
-
-    const repoManager = this.runner.repositoryManager_;
-
-    try {
-      switch (operation) {
-        case "stage":
-          await repoManager.stageAll(taskId);
-          await this.sendGitStateUpdate(taskId);
-          break;
-
-        case "commit":
-          if (!opParams?.message) {
-            throw new Error("Commit message is required");
-          }
-          const commitHash = await repoManager.commit(
-            taskId,
-            opParams.message,
-            opParams.author
-          );
-          await this.recordGitOperation(taskId, "commit", "succeeded", {
-            commitHash,
-          });
-          await this.sendGitStateUpdate(taskId);
-          break;
-
-        case "push":
-          // TODO: Implement push operation
-          console.log("Push operation not yet implemented");
-          break;
-
-        case "rebase":
-          if (!opParams?.targetBranch) {
-            throw new Error("Target branch is required for rebase");
-          }
-          const rebaseResult = await repoManager.rebaseTask(
-            taskId,
-            opParams.targetBranch
-          );
-          await this.recordGitOperation(
-            taskId,
-            "rebase",
-            rebaseResult.success ? "succeeded" : "failed",
-            rebaseResult
-          );
-          await this.sendGitStateUpdate(taskId);
-          break;
-
-        case "merge":
-          if (!opParams?.targetBranch) {
-            throw new Error("Target branch is required for merge");
-          }
-          const mergeResult = await repoManager.mergeTask(
-            taskId,
-            opParams.targetBranch,
-            opParams.mode
-          );
-          await this.recordGitOperation(
-            taskId,
-            "merge",
-            mergeResult.success ? "succeeded" : "failed",
-            mergeResult
-          );
-          await this.sendGitStateUpdate(taskId);
-          break;
-
-        default:
-          throw new Error(`Unknown Git operation: ${operation}`);
-      }
-    } catch (error) {
-      console.error(
-        `Git operation ${operation} failed for task ${taskId}:`,
-        error
-      );
-      await this.recordGitOperation(taskId, operation, "failed", {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  private async handleGitCleanup(
-    params: any,
-    message: RunnerMessage
-  ): Promise<void> {
-    const { taskId, preserveBranch = false } = params;
-
-    if (!taskId) {
-      throw new Error("Missing required parameter: taskId");
-    }
-
-    console.log(`MessageHandler: Cleaning up Git worktree for task ${taskId}`);
-
-    const repoManager = this.runner.repositoryManager_;
-
-    try {
-      await repoManager.removeTaskWorktree(taskId, { preserveBranch });
-      console.log(`Successfully cleaned up worktree for task ${taskId}`);
-    } catch (error) {
-      console.error(`Failed to clean up worktree for task ${taskId}:`, error);
-      throw error;
-    }
-  }
-
-  private async sendGitStateUpdate(taskId: string): Promise<void> {
-    const repoManager = this.runner.repositoryManager_;
-    const gitState = await repoManager.getTaskState(taskId);
-
-    if (!gitState) {
-      console.error(`No Git state found for task ${taskId}`);
-      return;
-    }
-
-    // Send state update to orchestrator
-    await this.runner.notify("git.state.update", {
-      taskId,
-      state: {
-        branch: gitState.branch,
-        commit: gitState.lastCommit || "",
-        isDirty: false, // TODO: Check actual dirty state
-        ahead: 0, // TODO: Calculate ahead/behind
-        behind: 0,
-      },
-    });
-  }
-
-  private async recordGitOperation(
-    taskId: string,
-    operation: string,
-    status: string,
-    details: any
-  ): Promise<void> {
-    // Send operation record to orchestrator
-    await this.runner.notify("git.operation.record", {
-      taskId,
-      operation,
-      status,
-      details,
-      timestamp: new Date(),
-    });
-  }
-
-  private resolveAgentProvider(
-    conversation?: {
-      providerType?: string;
-      agentProviderType?: string;
-      model?: string;
-    },
-    config?: ConversationConfig
-  ): "openai" | "claude" {
-    const explicitProvider =
-      conversation?.providerType ||
-      conversation?.agentProviderType ||
-      (config as any)?.providerType ||
-      (config as any)?.agentProviderType;
-
-    if (typeof explicitProvider === "string") {
-      const normalized = explicitProvider.toLowerCase();
-      if (normalized === "openai") return "openai";
-      if (normalized === "claude") return "claude";
-    }
-
-    const model =
-      conversation?.model ||
-      (config as any)?.model ||
-      (config as any)?.defaultModel ||
-      "";
-    const normalizedModel = model.toLowerCase();
-
-    const looksLikeCodex =
-      normalizedModel.includes("gpt") ||
-      /^o\d/.test(normalizedModel) ||
-      normalizedModel.includes("openai") ||
-      normalizedModel.includes("codex");
-
-    return looksLikeCodex ? "openai" : "claude";
-  }
-
-  private getManagerForProvider(provider?: string) {
-    if (provider?.toLowerCase() === "openai") {
-      return this.runner.codexManager_;
-    }
-    return this.runner.claudeManager_;
-  }
-
-  private getManagerForConversationContext(context: ConversationContext) {
-    return context.provider === "openai"
-      ? this.runner.codexManager_
-      : this.runner.claudeManager_;
-  }
-}