@northflare/runner 0.0.1

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

@@ -0,0 +1,1011 @@
+/**
+ * MessageHandler - Processes incoming JSONRPC messages from SSE events
+ */
+
+import { IRunnerApp } from "../types/runner-interface";
+import { RunnerMessage, MethodHandler, ConversationContext } 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";
+
+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 (process.env["DEBUG"] === "true") {
+        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 (process.env["DEBUG"] === "true") {
+      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 (process.env["DEBUG"] === "true") {
+      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 (process.env["DEBUG"] === "true") {
+        logger.debug("Message acknowledged", {
+          messageId: message.id,
+          method: method,
+          timestamp: message.createdAt,
+          wasActionMessage: this.isActionMessage(message),
+        });
+      }
+    } catch (error) {
+      if (process.env["DEBUG"] === "true") {
+        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" };
+      }
+
+      // Filter by lastProcessedAt first (before checking active status)
+      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",
+          };
+        }
+      }
+
+      // Always process UID change messages (after time check)
+      if (message.payload?.method === "runner.uid.changed") {
+        return { shouldProcess: true, reason: "UID change message" };
+      }
+
+      // 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 (process.env["DEBUG"] === "true") {
+      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 (process.env["DEBUG"] === "true") {
+        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 (process.env["DEBUG"] === "true") {
+        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),
+    });
+
+    // Start the conversation with the provided/loaded conversation details
+    await this.runner.claudeManager_.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";
+      await this.runner.claudeManager_.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");
+    }
+
+    await this.runner.claudeManager_.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
+    await this.runner.claudeManager_.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 this.runner.claudeManager_.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,
+    } = params;
+
+    // Validate required parameters
+    if (!conversationId) {
+      throw new Error("Missing required parameter: conversationId");
+    }
+
+    if (!content) {
+      throw new Error("Missing required parameter: content");
+    }
+
+    await this.runner.claudeManager_.sendUserMessage(
+      conversationId,
+      content,
+      config,
+      conversationObjectType,
+      conversationObjectId,
+      conversation
+    );
+  }
+
+  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 (process.env["DEBUG"] === "true") {
+      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 (process.env["DEBUG"] === "true") {
+        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 (process.env["DEBUG"] === "true") {
+          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 (process.env["DEBUG"] === "true") {
+            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 (process.env["DEBUG"] === "true") {
+        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 (process.env["DEBUG"] === "true") {
+          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(),
+    });
+  }
+}