agor-live 0.3.7

package/dist/core/tools/index.js

@@ -0,0 +1,3314 @@
+// src/tools/claude/claude-tool.ts
+import * as fs5 from "fs/promises";
+import * as os from "os";
+import * as path4 from "path";
+
+// src/lib/ids.ts
+import { uuidv7 } from "uuidv7";
+function generateId() {
+  return uuidv7();
+}
+
+// src/types/task.ts
+var TaskStatus = {
+  CREATED: "created",
+  RUNNING: "running",
+  STOPPING: "stopping",
+  // Stop requested, waiting for SDK to halt
+  AWAITING_PERMISSION: "awaiting_permission",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  STOPPED: "stopped"
+  // User-requested stop (distinct from failed)
+};
+
+// src/tools/claude/import/transcript-parser.ts
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+function getTranscriptPath(sessionId, projectDir) {
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  if (!homeDir) {
+    throw new Error("Could not determine home directory");
+  }
+  const cwd = projectDir || process.cwd();
+  const projectSlug = cwd.replace(/\//g, "-").replace(/\\/g, "-");
+  const transcriptPath = path.join(
+    homeDir,
+    ".claude",
+    "projects",
+    projectSlug,
+    `${sessionId}.jsonl`
+  );
+  return transcriptPath;
+}
+async function parseTranscript(transcriptPath) {
+  if (!fs.existsSync(transcriptPath)) {
+    throw new Error(`Transcript file not found: ${transcriptPath}`);
+  }
+  const messages = [];
+  const fileStream = fs.createReadStream(transcriptPath);
+  const rl = readline.createInterface({
+    input: fileStream,
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      const message = JSON.parse(line);
+      messages.push(message);
+    } catch (error) {
+      console.error(`Failed to parse line: ${line.substring(0, 100)}...`);
+      throw error;
+    }
+  }
+  return messages;
+}
+async function loadSessionTranscript(sessionId, projectDir) {
+  const transcriptPath = getTranscriptPath(sessionId, projectDir);
+  return parseTranscript(transcriptPath);
+}
+function filterConversationMessages(messages) {
+  return messages.filter((msg) => {
+    if (msg.type === "file-history-snapshot") return false;
+    if (msg.isMeta) return false;
+    const content = msg.message?.content;
+    if (Array.isArray(content) && content.some((c) => c.type === "tool_result")) {
+      return false;
+    }
+    if (typeof content === "string") {
+      if (content.trim().match(/^<(command-name|local-command-stdout|system-reminder)/)) {
+        return false;
+      }
+    }
+    return msg.type === "user" || msg.type === "assistant";
+  });
+}
+function buildConversationTree(messages) {
+  const messageMap = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const message of messages) {
+    if (!message.uuid) continue;
+    const node = {
+      message,
+      children: []
+    };
+    messageMap.set(message.uuid, node);
+  }
+  for (const message of messages) {
+    if (!message.uuid) continue;
+    const node = messageMap.get(message.uuid);
+    if (!node) continue;
+    if (!message.parentUuid) {
+      roots.push(node);
+    } else {
+      const parent = messageMap.get(message.parentUuid);
+      if (parent) {
+        parent.children.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+  }
+  return roots;
+}
+
+// src/tools/claude/import/load-session.ts
+async function loadClaudeSession(sessionId, projectDir) {
+  const transcriptPath = getTranscriptPath(sessionId, projectDir);
+  const messages = await parseTranscript(transcriptPath);
+  const cwdMessage = messages.find((msg) => msg.cwd);
+  const cwd = cwdMessage?.cwd || null;
+  return {
+    sessionId,
+    transcriptPath,
+    cwd,
+    messages
+  };
+}
+
+// src/tools/claude/import/message-converter.ts
+function transcriptToMessage(transcript, sessionId, index) {
+  const content = transcript.message?.content || "";
+  const contentPreview = typeof content === "string" ? content.substring(0, 200) : JSON.stringify(content).substring(0, 200);
+  const role = transcript.message?.role || transcript.type;
+  let toolUses;
+  if (Array.isArray(content)) {
+    const tools = content.filter((c) => c.type === "tool_use");
+    if (tools.length > 0) {
+      toolUses = tools.map((tool) => ({
+        id: tool.id,
+        name: tool.name,
+        input: tool.input || {}
+      }));
+    }
+  }
+  return {
+    message_id: generateId(),
+    session_id: sessionId,
+    type: transcript.type,
+    role,
+    index,
+    timestamp: transcript.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    content_preview: contentPreview,
+    content,
+    tool_uses: toolUses,
+    metadata: {
+      original_id: transcript.uuid,
+      parent_id: transcript.parentUuid || void 0,
+      is_meta: transcript.isMeta
+    }
+  };
+}
+function transcriptsToMessages(transcripts, sessionId) {
+  return transcripts.map((transcript, index) => transcriptToMessage(transcript, sessionId, index));
+}
+
+// src/tools/claude/models.ts
+var AVAILABLE_CLAUDE_MODEL_ALIASES = [
+  {
+    id: "claude-opus-4-1",
+    displayName: "Claude Opus 4.1",
+    family: "claude-4",
+    description: "Most capable model (latest)"
+  },
+  {
+    id: "claude-sonnet-4-5",
+    displayName: "Claude Sonnet 4.5",
+    family: "claude-4",
+    description: "Best for coding (latest)"
+  },
+  {
+    id: "claude-sonnet-4-0",
+    displayName: "Claude Sonnet 4.0",
+    family: "claude-4",
+    description: "Sonnet 4.0 (previous)"
+  },
+  {
+    id: "claude-3-7-sonnet-latest",
+    displayName: "Claude 3.7 Sonnet",
+    family: "claude-3.7",
+    description: "Fast & balanced"
+  },
+  {
+    id: "claude-haiku-4-5",
+    displayName: "Claude Haiku 4.5",
+    family: "claude-4",
+    description: "Fastest (latest)"
+  },
+  {
+    id: "claude-3-5-haiku-latest",
+    displayName: "Claude 3.5 Haiku",
+    family: "claude-3.5",
+    description: "Fastest (previous)"
+  }
+];
+var DEFAULT_CLAUDE_MODEL = "claude-sonnet-4-5";
+
+// src/tools/claude/prompt-service.ts
+import { execSync } from "child_process";
+import * as fs4 from "fs/promises";
+import * as path3 from "path";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// src/lib/validation.ts
+import * as fs2 from "fs/promises";
+async function validateDirectory(path7, context = "Directory") {
+  try {
+    const stats = await fs2.stat(path7);
+    if (!stats.isDirectory()) {
+      throw new Error(`${context} exists but is not a directory: ${path7}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`${context} does not exist: ${path7}`);
+    }
+    throw new Error(`${context} is not accessible: ${path7} (${error})`);
+  }
+}
+
+// src/tools/claude/message-processor.ts
+var SDKMessageProcessor = class {
+  state;
+  constructor(options) {
+    this.state = {
+      sessionId: options.sessionId,
+      existingSdkSessionId: options.existingSdkSessionId,
+      capturedAgentSessionId: void 0,
+      messageCount: 0,
+      lastActivityTime: Date.now(),
+      lastAssistantMessageTime: Date.now(),
+      enableTokenStreaming: options.enableTokenStreaming ?? true,
+      idleTimeoutMs: options.idleTimeoutMs ?? 3e4,
+      // 30s default
+      contentBlockStack: []
+    };
+  }
+  /**
+   * Process an SDK message and return 0 or more events
+   *
+   * @param msg - SDK message to process
+   * @returns Array of events to yield upstream
+   */
+  async process(msg) {
+    this.state.messageCount++;
+    this.state.lastActivityTime = Date.now();
+    if (this.state.messageCount % 10 === 0) {
+      console.debug(`\u{1F4E8} SDK message ${this.state.messageCount}: type=${msg.type}`);
+    }
+    if (process.env.DEBUG_SDK_MESSAGES === "true") {
+      console.log(`\u{1F50D} [DEBUG] Full SDK message ${this.state.messageCount}:`);
+      console.log(JSON.stringify(msg, null, 2));
+    }
+    if (!this.state.capturedAgentSessionId && "session_id" in msg && msg.session_id) {
+      const events = this.captureSessionId(msg.session_id);
+      const messageEvents = await this.routeMessage(msg);
+      return [...events, ...messageEvents];
+    }
+    return this.routeMessage(msg);
+  }
+  /**
+   * Check if processor has timed out due to inactivity
+   */
+  hasTimedOut() {
+    const timeSinceLastAssistant = Date.now() - this.state.lastAssistantMessageTime;
+    return timeSinceLastAssistant > this.state.idleTimeoutMs && this.state.messageCount > 5;
+  }
+  /**
+   * Get current processor state (for debugging/monitoring)
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Route message to appropriate handler based on type
+   */
+  async routeMessage(msg) {
+    switch (msg.type) {
+      case "assistant":
+        return this.handleAssistant(msg);
+      case "user":
+        return this.handleUser(msg);
+      case "stream_event":
+        return this.handleStreamEvent(msg);
+      case "result":
+        return this.handleResult(msg);
+      case "system":
+        return this.handleSystem(msg);
+      default:
+        return this.handleUnknown(msg);
+    }
+  }
+  /**
+   * Capture SDK session ID for conversation continuity
+   */
+  captureSessionId(sessionId) {
+    if (sessionId === this.state.existingSdkSessionId) {
+      return [];
+    }
+    this.state.capturedAgentSessionId = sessionId;
+    console.log(`\u{1F511} New Agent SDK session_id`);
+    return [
+      {
+        type: "session_id_captured",
+        agentSessionId: sessionId
+      }
+    ];
+  }
+  /**
+   * Handle assistant messages (complete responses)
+   */
+  handleAssistant(msg) {
+    this.state.lastAssistantMessageTime = Date.now();
+    const contentBlocks = this.processContentBlocks(msg.message?.content);
+    const toolUses = this.extractToolUses(contentBlocks);
+    return [
+      {
+        type: "complete",
+        role: "assistant" /* ASSISTANT */,
+        content: contentBlocks,
+        toolUses: toolUses.length > 0 ? toolUses : void 0,
+        agentSessionId: this.state.capturedAgentSessionId,
+        resolvedModel: this.state.resolvedModel
+      }
+    ];
+  }
+  /**
+   * Handle user messages (including tool results)
+   */
+  handleUser(msg) {
+    if ("isReplay" in msg && msg.isReplay) {
+      console.debug(`\u{1F504} User message replay (uuid: ${msg.uuid?.substring(0, 8)})`);
+      return [];
+    }
+    const content = msg.message?.content;
+    const uuid = "uuid" in msg ? msg.uuid : void 0;
+    const hasToolResult = Array.isArray(content) && content.some((b) => b.type === "tool_result");
+    const hasText = Array.isArray(content) && content.some((b) => b.type === "text");
+    if (hasToolResult) {
+      const toolResults = content.filter((b) => b.type === "tool_result");
+      console.log(
+        `\u{1F527} SDK user message with ${toolResults.length} tool result(s) (uuid: ${uuid?.substring(0, 8)})`
+      );
+      toolResults.forEach((tr, i) => {
+        const preview = typeof tr.content === "string" ? tr.content.substring(0, 100) : JSON.stringify(tr.content).substring(0, 100);
+        console.log(`   Result ${i + 1}: ${tr.is_error ? "\u274C ERROR" : "\u2705"} ${preview}`);
+      });
+      return [
+        {
+          type: "complete",
+          role: "user" /* USER */,
+          content,
+          // Tool result content
+          toolUses: void 0,
+          agentSessionId: this.state.capturedAgentSessionId,
+          resolvedModel: this.state.resolvedModel
+        }
+      ];
+    } else if (hasText) {
+      const textBlocks = content.filter((b) => b.type === "text");
+      const textPreview = textBlocks[0]?.text?.substring(0, 100) || "";
+      console.log(`\u{1F464} SDK user message (uuid: ${uuid?.substring(0, 8)}): "${textPreview}"`);
+      return [
+        {
+          type: "complete",
+          role: "user" /* USER */,
+          content,
+          toolUses: void 0,
+          agentSessionId: this.state.capturedAgentSessionId,
+          resolvedModel: this.state.resolvedModel
+        }
+      ];
+    } else {
+      console.log(`\u{1F464} SDK user message (uuid: ${uuid?.substring(0, 8)})`);
+      console.log(
+        `   Content types:`,
+        Array.isArray(content) ? content.map((b) => b.type) : "no content"
+      );
+      return [];
+    }
+  }
+  /**
+   * Handle streaming events (partial messages)
+   */
+  handleStreamEvent(msg) {
+    if (!this.state.enableTokenStreaming) {
+      return [];
+    }
+    const event = msg.event;
+    const events = [];
+    if (event?.type === "message_start") {
+      console.debug(`\u{1F3AC} Message start`);
+      events.push({
+        type: "message_start",
+        agentSessionId: this.state.capturedAgentSessionId
+      });
+      const message = event.message;
+      if (message?.model) {
+        this.state.resolvedModel = message.model;
+      }
+    }
+    if (event?.type === "content_block_start") {
+      const block = event.content_block;
+      const blockIndex = event.index;
+      if (block?.type === "tool_use") {
+        const toolName = block.name;
+        const toolId = block.id;
+        console.debug(`\u{1F527} Tool start: ${toolName} (${toolId})`);
+        this.state.contentBlockStack.push({
+          index: blockIndex,
+          type: "tool_use",
+          toolUseId: toolId,
+          toolName
+        });
+        events.push({
+          type: "tool_start",
+          toolName,
+          toolUseId: toolId,
+          agentSessionId: this.state.capturedAgentSessionId
+        });
+      } else if (block?.type === "text") {
+        this.state.contentBlockStack.push({
+          index: blockIndex,
+          type: "text"
+        });
+      }
+    }
+    if (event?.type === "content_block_delta") {
+      const delta = event.delta;
+      if (delta?.type === "text_delta") {
+        const textChunk = delta.text;
+        events.push({
+          type: "partial",
+          textChunk,
+          agentSessionId: this.state.capturedAgentSessionId,
+          resolvedModel: this.state.resolvedModel
+        });
+      } else if (delta?.type === "input_json_delta") {
+        const partialJson = delta.partial_json;
+        if (partialJson) {
+          console.debug(`\u{1F527} Tool input chunk: ${partialJson.substring(0, 50)}...`);
+        }
+      }
+    }
+    if (event?.type === "content_block_stop") {
+      const blockIndex = event.index;
+      const completedBlock = this.state.contentBlockStack.find((b) => b.index === blockIndex);
+      if (completedBlock?.type === "tool_use") {
+        console.debug(`\u{1F3C1} Tool complete: ${completedBlock.toolName} (${completedBlock.toolUseId})`);
+        events.push({
+          type: "tool_complete",
+          toolUseId: completedBlock.toolUseId,
+          agentSessionId: this.state.capturedAgentSessionId
+        });
+      } else {
+        console.debug(`\u{1F3C1} Content block ${blockIndex} complete`);
+      }
+      this.state.contentBlockStack = this.state.contentBlockStack.filter(
+        (b) => b.index !== blockIndex
+      );
+    }
+    if (event?.type === "message_stop") {
+      console.debug(`\u{1F3C1} Message complete`);
+      events.push({
+        type: "message_complete",
+        agentSessionId: this.state.capturedAgentSessionId
+      });
+      this.state.contentBlockStack = [];
+    }
+    return events;
+  }
+  /**
+   * Handle result messages (end of conversation)
+   */
+  handleResult(msg) {
+    const subtype = msg.subtype || "unknown";
+    const duration = msg.duration_ms;
+    const cost = msg.total_cost_usd;
+    console.log(
+      `\u2705 SDK result: ${subtype}${duration ? ` (${duration}ms)` : ""}${cost ? ` ($${cost})` : ""}`
+    );
+    if ("usage" in msg && msg.usage) {
+      console.log(`   Token usage:`, msg.usage);
+    }
+    if ("modelUsage" in msg && msg.modelUsage) {
+      console.log(`   Model usage (with contextWindow):`, JSON.stringify(msg.modelUsage, null, 2));
+    }
+    return [
+      {
+        type: "result",
+        subtype,
+        duration_ms: duration,
+        cost,
+        token_usage: "usage" in msg ? msg.usage : void 0,
+        model_usage: "modelUsage" in msg ? msg.modelUsage : void 0,
+        agentSessionId: this.state.capturedAgentSessionId
+      },
+      {
+        type: "end",
+        reason: "result"
+      }
+    ];
+  }
+  /**
+   * Handle system messages
+   */
+  handleSystem(msg) {
+    if ("subtype" in msg && msg.subtype === "compact_boundary") {
+      console.debug(`\u{1F4E6} SDK compact boundary (memory management)`);
+      return [];
+    }
+    if ("subtype" in msg && msg.subtype === "init") {
+      console.debug(`\u2139\uFE0F  SDK system init:`, {
+        model: msg.model,
+        permissionMode: msg.permissionMode,
+        cwd: msg.cwd,
+        tools: msg.tools?.length,
+        mcp_servers: msg.mcp_servers?.length
+      });
+      if (msg.model) {
+        this.state.resolvedModel = msg.model;
+      }
+      return [];
+    }
+    console.debug(`\u2139\uFE0F  SDK system message:`, msg);
+    return [];
+  }
+  /**
+   * Handle unknown message types
+   */
+  handleUnknown(msg) {
+    console.warn(`\u26A0\uFE0F  Unknown SDK message type: ${msg.type}`, msg);
+    return [];
+  }
+  /**
+   * Process content blocks from SDK message
+   */
+  processContentBlocks(content) {
+    if (!Array.isArray(content)) {
+      return [];
+    }
+    return content.map((block) => {
+      if (block.type === "text") {
+        return {
+          type: "text",
+          text: block.text
+        };
+      } else if (block.type === "tool_use") {
+        return {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      } else {
+        return {
+          ...block,
+          type: block.type
+        };
+      }
+    });
+  }
+  /**
+   * Extract tool uses from content blocks
+   */
+  extractToolUses(contentBlocks) {
+    return contentBlocks.filter((block) => block.type === "tool_use" && block.id && block.name && block.input).map((block) => ({
+      id: block.id,
+      name: block.name,
+      input: block.input
+    }));
+  }
+};
+
+// src/tools/claude/session-context.ts
+import * as fs3 from "fs/promises";
+import * as path2 from "path";
+function generateSessionContext(sessionId) {
+  const shortId = sessionId.substring(0, 8);
+  return `
+
+---
+
+## Agor Session Context
+
+You are currently running within **Agor** (https://agor.live), a multiplayer canvas for orchestrating AI coding agents.
+
+**Your current Agor session ID is: \`${sessionId}\`** (short: \`${shortId}\`)
+
+When you see this ID referenced in prompts or tool calls, it refers to THIS session you're currently in.
+
+For more information about Agor, visit https://agor.live
+`;
+}
+async function appendSessionContextToCLAUDEmd(worktreePath, sessionId) {
+  const claudeMdPath = path2.join(worktreePath, "CLAUDE.md");
+  try {
+    let existingContent = "";
+    try {
+      existingContent = await fs3.readFile(claudeMdPath, "utf-8");
+    } catch (readError) {
+      console.log(`\u{1F4DD} CLAUDE.md doesn't exist at ${claudeMdPath}, will create it`);
+    }
+    if (existingContent.includes("## Agor Session Context")) {
+      console.log(`\u2705 Session context already in CLAUDE.md, skipping append`);
+      return;
+    }
+    const sessionContext = generateSessionContext(sessionId);
+    const newContent = existingContent + sessionContext;
+    await fs3.writeFile(claudeMdPath, newContent, "utf-8");
+    console.log(
+      `\u2705 Appended session context to CLAUDE.md for session ${sessionId.substring(0, 8)}`
+    );
+  } catch (error) {
+    console.error(`\u274C Failed to append session context to CLAUDE.md:`, error);
+  }
+}
+async function removeSessionContextFromCLAUDEmd(worktreePath) {
+  const claudeMdPath = path2.join(worktreePath, "CLAUDE.md");
+  try {
+    const content = await fs3.readFile(claudeMdPath, "utf-8");
+    const contextStart = content.indexOf("\n\n---\n\n## Agor Session Context");
+    if (contextStart === -1) {
+      return;
+    }
+    const cleanedContent = content.substring(0, contextStart);
+    await fs3.writeFile(claudeMdPath, cleanedContent, "utf-8");
+    console.log(`\u2705 Removed session context from CLAUDE.md`);
+  } catch (error) {
+    console.error(`\u274C Failed to remove session context from CLAUDE.md:`, error);
+  }
+}
+
+// src/tools/claude/prompt-service.ts
+function getClaudeCodePath() {
+  try {
+    const path7 = execSync("which claude", { encoding: "utf-8" }).trim();
+    if (path7) return path7;
+  } catch {
+  }
+  const commonPaths = [
+    "/usr/local/bin/claude",
+    "/opt/homebrew/bin/claude",
+    `${process.env.HOME}/.nvm/versions/node/v20.19.4/bin/claude`
+  ];
+  for (const path7 of commonPaths) {
+    try {
+      execSync(`test -x "${path7}"`, { encoding: "utf-8" });
+      return path7;
+    } catch {
+    }
+  }
+  throw new Error(
+    "Claude Code executable not found. Install with: npm install -g @anthropic-ai/claude-code"
+  );
+}
+var ClaudePromptService = class _ClaudePromptService {
+  constructor(messagesRepo, sessionsRepo, apiKey, sessionMCPRepo, mcpServerRepo, permissionService, tasksService, sessionsService, worktreesRepo, messagesService) {
+    this.messagesRepo = messagesRepo;
+    this.sessionsRepo = sessionsRepo;
+    this.apiKey = apiKey;
+    this.sessionMCPRepo = sessionMCPRepo;
+    this.mcpServerRepo = mcpServerRepo;
+    this.permissionService = permissionService;
+    this.tasksService = tasksService;
+    this.sessionsService = sessionsService;
+    this.worktreesRepo = worktreesRepo;
+    this.messagesService = messagesService;
+  }
+  /** Enable token-level streaming from Claude Agent SDK */
+  static ENABLE_TOKEN_STREAMING = true;
+  /** Store active Query objects per session for interruption */
+  // biome-ignore lint/suspicious/noExplicitAny: Query type from SDK is complex
+  activeQueries = /* @__PURE__ */ new Map();
+  /** Track stop requests for immediate loop breaking */
+  stopRequested = /* @__PURE__ */ new Map();
+  /** Serialize permission checks per session to prevent duplicate prompts for concurrent tool calls */
+  permissionLocks = /* @__PURE__ */ new Map();
+  /**
+   * Create PreToolUse hook for permission handling
+   * @private
+   */
+  createPreToolUseHook(sessionId, taskId) {
+    return async (input, toolUseID, options) => {
+      if (!this.permissionService || !this.tasksService) {
+        return {};
+      }
+      let releaseLock;
+      try {
+        const existingLock = this.permissionLocks.get(sessionId);
+        if (existingLock) {
+          console.log(
+            `\u23F3 Waiting for pending permission check to complete (session ${sessionId.substring(0, 8)})`
+          );
+          await existingLock;
+          console.log(`\u2705 Permission check complete, rechecking DB...`);
+        }
+        const session = await this.sessionsRepo.findById(sessionId);
+        if (session?.permission_config?.allowedTools?.includes(input.tool_name)) {
+          console.log(`\u2705 Tool ${input.tool_name} allowed by session config (after queue wait)`);
+          return {
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "allow",
+              permissionDecisionReason: "Allowed by session config"
+            }
+          };
+        }
+        console.log(
+          `\u{1F512} No permission found for ${input.tool_name}, creating lock and prompting user...`
+        );
+        const newLock = new Promise((resolve) => {
+          releaseLock = resolve;
+        });
+        this.permissionLocks.set(sessionId, newLock);
+        const requestId = generateId();
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const existingMessages = await this.messagesRepo.findBySessionId(sessionId);
+        const nextIndex = existingMessages.length;
+        console.log(`\u{1F512} Creating permission request message for ${input.tool_name}`, {
+          request_id: requestId,
+          task_id: taskId,
+          index: nextIndex
+        });
+        const permissionMessage = {
+          message_id: generateId(),
+          session_id: sessionId,
+          task_id: taskId,
+          type: "permission_request",
+          role: "system" /* SYSTEM */,
+          index: nextIndex,
+          timestamp,
+          content_preview: `Permission required: ${input.tool_name}`,
+          content: {
+            request_id: requestId,
+            tool_name: input.tool_name,
+            tool_input: input.tool_input,
+            tool_use_id: toolUseID,
+            status: "pending" /* PENDING */
+          }
+        };
+        try {
+          if (this.messagesService) {
+            await this.messagesService.create(permissionMessage);
+            console.log(`\u2705 Permission request message created successfully`);
+          }
+        } catch (createError) {
+          console.error(`\u274C CRITICAL: Failed to create permission request message:`, createError);
+          throw createError;
+        }
+        try {
+          await this.tasksService.patch(taskId, {
+            status: TaskStatus.AWAITING_PERMISSION
+          });
+          console.log(`\u2705 Task ${taskId} updated to awaiting_permission`);
+        } catch (patchError) {
+          console.error(`\u274C CRITICAL: Failed to patch task ${taskId}:`, patchError);
+          throw patchError;
+        }
+        this.permissionService.emitRequest(sessionId, {
+          requestId,
+          taskId,
+          toolName: input.tool_name,
+          toolInput: input.tool_input,
+          toolUseID,
+          timestamp
+        });
+        const decision = await this.permissionService.waitForDecision(
+          requestId,
+          taskId,
+          options.signal
+        );
+        if (this.messagesService) {
+          const baseContent = typeof permissionMessage.content === "object" && !Array.isArray(permissionMessage.content) ? permissionMessage.content : {};
+          await this.messagesService.patch(permissionMessage.message_id, {
+            content: {
+              ...baseContent,
+              status: decision.allow ? "approved" /* APPROVED */ : "denied" /* DENIED */,
+              scope: decision.remember ? decision.scope : void 0,
+              approved_by: decision.decidedBy,
+              approved_at: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+          console.log(
+            `\u2705 Permission request message updated: ${decision.allow ? "approved" : "denied"}`
+          );
+        }
+        await this.tasksService.patch(taskId, {
+          status: decision.allow ? TaskStatus.RUNNING : TaskStatus.FAILED
+        });
+        if (decision.remember) {
+          const freshSession = await this.sessionsRepo.findById(sessionId);
+          if (!freshSession) {
+            return {
+              hookSpecificOutput: {
+                hookEventName: "PreToolUse",
+                permissionDecision: decision.allow ? "allow" : "deny",
+                permissionDecisionReason: decision.reason
+              }
+            };
+          }
+          if (decision.scope === "session") {
+            const currentAllowed = freshSession.permission_config?.allowedTools || [];
+            const newAllowedTools = [...currentAllowed, input.tool_name];
+            const updateData = {
+              permission_config: {
+                allowedTools: newAllowedTools
+              }
+            };
+            if (this.sessionsService) {
+              await this.sessionsService.patch(sessionId, updateData);
+            } else {
+              await this.sessionsRepo.update(sessionId, updateData);
+            }
+          } else if (decision.scope === "project") {
+            if (freshSession.worktree_id && this.worktreesRepo) {
+              const worktree = await this.worktreesRepo.findById(freshSession.worktree_id);
+              if (worktree) {
+                await this.updateProjectSettings(worktree.path, {
+                  allowTools: [input.tool_name]
+                });
+              }
+            }
+          }
+        }
+        return {
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: decision.allow ? "allow" : "deny",
+            permissionDecisionReason: decision.reason
+          }
+        };
+      } catch (error) {
+        console.error("PreToolUse hook error:", error);
+        try {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          await this.tasksService.patch(taskId, {
+            status: TaskStatus.FAILED,
+            report: `Error: ${errorMessage}
+Timestamp: ${timestamp}`
+          });
+        } catch (updateError) {
+          console.error("Failed to update task status:", updateError);
+        }
+        return {
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: `Permission hook failed: ${error instanceof Error ? error.message : String(error)}`
+          }
+        };
+      } finally {
+        if (releaseLock) {
+          releaseLock();
+          this.permissionLocks.delete(sessionId);
+          console.log(`\u{1F513} Released permission lock for session ${sessionId.substring(0, 8)}`);
+        }
+      }
+    };
+  }
+  /**
+   * Update project-level permissions in .claude/settings.json
+   * @private
+   */
+  async updateProjectSettings(cwd, changes) {
+    const settingsPath = path3.join(cwd, ".claude", "settings.json");
+    let settings = {};
+    try {
+      const content = await fs4.readFile(settingsPath, "utf-8");
+      settings = JSON.parse(content);
+    } catch {
+      settings = { permissions: { allow: { tools: [] } } };
+    }
+    if (!settings.permissions) settings.permissions = {};
+    if (!settings.permissions.allow) settings.permissions.allow = {};
+    if (!settings.permissions.allow.tools) settings.permissions.allow.tools = [];
+    if (changes.allowTools) {
+      settings.permissions.allow.tools = [
+        .../* @__PURE__ */ new Set([...settings.permissions.allow.tools, ...changes.allowTools])
+      ];
+    }
+    if (changes.denyTools) {
+      if (!settings.permissions.deny) settings.permissions.deny = [];
+      settings.permissions.deny = [
+        .../* @__PURE__ */ new Set([...settings.permissions.deny, ...changes.denyTools])
+      ];
+    }
+    const claudeDir = path3.join(cwd, ".claude");
+    try {
+      await fs4.mkdir(claudeDir, { recursive: true });
+    } catch {
+    }
+    await fs4.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  }
+  /**
+   * Load session and initialize query
+   * @private
+   */
+  async setupQuery(sessionId, prompt, taskId, permissionMode, resume = true) {
+    const session = await this.sessionsRepo.findById(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const modelConfig = session.model_config;
+    const model = modelConfig?.model || DEFAULT_CLAUDE_MODEL;
+    let cwd = process.cwd();
+    if (session.worktree_id && this.worktreesRepo) {
+      try {
+        const worktree = await this.worktreesRepo.findById(session.worktree_id);
+        if (worktree) {
+          cwd = worktree.path;
+          console.log(`\u2705 Using worktree path as cwd: ${cwd}`);
+        } else {
+          console.warn(
+            `\u26A0\uFE0F  Session ${sessionId} references non-existent worktree ${session.worktree_id}, using process.cwd(): ${cwd}`
+          );
+        }
+      } catch (error) {
+        console.error(`\u274C Failed to fetch worktree ${session.worktree_id}:`, error);
+        console.warn(`   Falling back to process.cwd(): ${cwd}`);
+      }
+    } else {
+      console.warn(`\u26A0\uFE0F  Session ${sessionId} has no worktree_id, using process.cwd(): ${cwd}`);
+    }
+    this.logPromptStart(sessionId, prompt, cwd, resume ? session.sdk_session_id : void 0);
+    try {
+      await validateDirectory(cwd, "Working directory");
+      try {
+        const files = await fs4.readdir(cwd);
+        const fileCount = files.length;
+        const hasGit = files.includes(".git");
+        const hasClaude = files.includes(".claude");
+        const hasCLAUDEmd = files.includes("CLAUDE.md");
+        console.log(
+          `\u2705 Working directory validated: ${cwd} (${fileCount} files/dirs${hasGit ? ", has .git" : ", NO .git!"}${hasClaude ? ", has .claude/" : ""}${hasCLAUDEmd ? ", has CLAUDE.md" : ""})`
+        );
+        if (fileCount === 0) {
+          console.warn(`\u26A0\uFE0F  Working directory is EMPTY - worktree may be from bare repo!`);
+        } else if (!hasGit) {
+          console.warn(`\u26A0\uFE0F  Working directory has no .git - not a valid worktree!`);
+        }
+        if (!hasCLAUDEmd && !hasClaude) {
+          console.warn(`\u26A0\uFE0F  No CLAUDE.md or .claude/ directory found - SDK may not load properly`);
+        }
+      } catch (listError) {
+        console.warn(`\u26A0\uFE0F  Could not list directory contents:`, listError);
+      }
+      await appendSessionContextToCLAUDEmd(cwd, sessionId);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`\u274C Working directory validation failed: ${errorMessage}`);
+      throw new Error(
+        `${errorMessage}${session.worktree_id ? ` Session references worktree ${session.worktree_id} which may not be initialized.` : ""}`
+      );
+    }
+    const claudeCodePath = getClaudeCodePath();
+    let stderrBuffer = "";
+    const options = {
+      cwd,
+      systemPrompt: { type: "preset", preset: "claude_code" },
+      settingSources: ["user", "project"],
+      // Load user + project permissions, auto-loads CLAUDE.md
+      model,
+      // Use configured model or default
+      pathToClaudeCodeExecutable: claudeCodePath,
+      // Allow access to common directories outside CWD (e.g., /tmp)
+      additionalDirectories: ["/tmp", "/var/tmp"],
+      // Enable token-level streaming (yields partial messages as tokens arrive)
+      includePartialMessages: _ClaudePromptService.ENABLE_TOKEN_STREAMING,
+      // Enable debug logging to see what's happening
+      debug: true,
+      // Capture stderr to get actual error messages (not just "exit code 1")
+      stderr: (data) => {
+        stderrBuffer += data;
+        if (data.trim()) {
+          console.error(`[Claude stderr] ${data.trim()}`);
+        }
+      }
+    };
+    if (permissionMode) {
+      const isRoot = process.getuid?.() === 0;
+      if (isRoot && permissionMode === "bypassPermissions") {
+        console.warn(
+          `\u26A0\uFE0F  Running as root - bypassPermissions not allowed. Falling back to 'default' mode.`
+        );
+        console.warn(`   This is a security restriction from Claude Code SDK.`);
+        options.permissionMode = "default";
+      } else {
+        options.permissionMode = permissionMode;
+      }
+      console.log(`\u{1F510} Permission mode: ${options.permissionMode}`);
+    }
+    const sessionAllowedTools = session.permission_config?.allowedTools || [];
+    if (sessionAllowedTools.length > 0) {
+      options.allowedTools = sessionAllowedTools;
+    }
+    const effectivePermissionMode = options.permissionMode;
+    if (this.permissionService && taskId && effectivePermissionMode !== "bypassPermissions") {
+      options.hooks = {
+        PreToolUse: [
+          {
+            hooks: [this.createPreToolUseHook(sessionId, taskId)]
+          }
+        ]
+      };
+      console.log(`\u{1FA9D} PreToolUse hook added (permission mode: ${effectivePermissionMode})`);
+    }
+    if (this.apiKey || process.env.ANTHROPIC_API_KEY) {
+      options.apiKey = this.apiKey || process.env.ANTHROPIC_API_KEY;
+    }
+    if (resume) {
+      const parentSessionId = session.genealogy?.forked_from_session_id || session.genealogy?.parent_session_id;
+      if (parentSessionId && !session.sdk_session_id && this.sessionsRepo) {
+        const parentSession = await this.sessionsRepo.findById(parentSessionId);
+        if (parentSession?.sdk_session_id) {
+          options.resume = parentSession.sdk_session_id;
+          options.forkSession = true;
+          console.log(
+            `\u{1F374} Forking from parent session: ${parentSession.sdk_session_id.substring(0, 8)}`
+          );
+          console.log(`   SDK will return new session ID for this fork`);
+        } else {
+          console.warn(
+            `\u26A0\uFE0F  Parent session ${parentSessionId.substring(0, 8)} has no sdk_session_id - starting fresh`
+          );
+        }
+      } else if (session?.sdk_session_id) {
+        const hoursSinceUpdate = session.last_updated ? (Date.now() - new Date(session.last_updated).getTime()) / (1e3 * 60 * 60) : 999;
+        const isLikelyStale = hoursSinceUpdate > 24 || // Session older than 24 hours
+        !session.worktree_id;
+        if (isLikelyStale) {
+          console.warn(
+            `\u26A0\uFE0F  Resume session ${session.sdk_session_id.substring(0, 8)} appears stale (${Math.round(hoursSinceUpdate)}h old) - starting fresh`
+          );
+          if (this.sessionsRepo) {
+            await this.sessionsRepo.update(sessionId, { sdk_session_id: void 0 });
+          }
+        } else {
+          options.resume = session.sdk_session_id;
+          console.log(`   Resuming SDK session: ${session.sdk_session_id.substring(0, 8)}`);
+        }
+      }
+    }
+    const mcpToken = session.mcp_token;
+    console.log(`\u{1F50D} [MCP DEBUG] Checking for MCP token in session ${sessionId.substring(0, 8)}`);
+    console.log(
+      `   session.mcp_token: ${mcpToken ? `${mcpToken.substring(0, 16)}...` : "NOT FOUND"}`
+    );
+    if (mcpToken) {
+      const daemonUrl = process.env.VITE_DAEMON_URL || "http://localhost:3030";
+      console.log(`\u{1F50C} Configuring Agor MCP server (self-access to daemon)`);
+      const mcpConfig = {
+        agor: {
+          name: "agor",
+          type: "http",
+          url: `${daemonUrl}/mcp?sessionToken=${mcpToken}`
+        }
+      };
+      options.mcpServers = mcpConfig;
+      console.log(`   MCP server config:`, JSON.stringify(mcpConfig, null, 2));
+      console.log(`   Full URL: ${daemonUrl}/mcp?sessionToken=${mcpToken.substring(0, 16)}...`);
+    } else {
+      console.warn(`\u26A0\uFE0F  No MCP token found for session ${sessionId.substring(0, 8)}`);
+      console.warn(`   Session will not have access to Agor MCP tools`);
+    }
+    if (false) {
+      try {
+        const allServers = [];
+        console.log("\u{1F50C} Fetching MCP servers with hierarchical scoping...");
+        const globalServers = await this.mcpServerRepo?.findAll({
+          scope: "global",
+          enabled: true
+        });
+        console.log(`   \u{1F4CD} Global scope: ${globalServers?.length ?? 0} server(s)`);
+        for (const server of globalServers ?? []) {
+          allServers.push({ server, source: "global" });
+        }
+        let repoId;
+        const worktreeId = session.worktree_id;
+        if (worktreeId && this.worktreesRepo) {
+          const worktree = await this.worktreesRepo.findById(worktreeId);
+          repoId = worktree?.repo_id;
+        }
+        if (repoId) {
+          const repoServers = await this.mcpServerRepo?.findAll({
+            scope: "repo",
+            scopeId: repoId,
+            enabled: true
+          });
+          console.log(`   \u{1F4CD} Repo scope: ${repoServers?.length ?? 0} server(s)`);
+          for (const server of repoServers ?? []) {
+            allServers.push({ server, source: "repo" });
+          }
+        }
+        if (session && this.sessionMCPRepo) {
+          const sessionServers = await this.sessionMCPRepo.listServers(sessionId, true);
+          console.log(`   \u{1F4CD} Session scope: ${sessionServers.length} server(s)`);
+          for (const server of sessionServers) {
+            allServers.push({ server, source: "session" });
+          }
+        } else {
+          console.log("   \u{1F4CD} Session scope: 0 server(s)");
+        }
+        const serverMap = /* @__PURE__ */ new Map();
+        for (const item of allServers) {
+          serverMap.set(item.server.mcp_server_id, item);
+        }
+        const uniqueServers = Array.from(serverMap.values());
+        console.log(
+          `   \u2705 Total: ${uniqueServers.length} unique MCP server(s) after deduplication`
+        );
+        if (uniqueServers.length > 0) {
+          const mcpConfig = {};
+          const allowedTools = [];
+          for (const { server, source } of uniqueServers) {
+            console.log(`   - ${server.name} (${server.transport}) [${source}]`);
+            const serverConfig = {
+              transport: server.transport
+            };
+            if (server.command) serverConfig.command = server.command;
+            if (server.args) serverConfig.args = server.args;
+            if (server.url) serverConfig.url = server.url;
+            if (server.env) serverConfig.env = server.env;
+            mcpConfig[server.name] = serverConfig;
+            if (server.tools) {
+              for (const tool of server.tools) {
+                allowedTools.push(tool.name);
+              }
+            }
+          }
+          options.mcpServers = mcpConfig;
+          console.log(`   \u{1F527} MCP config being passed to SDK:`, JSON.stringify(mcpConfig, null, 2));
+          if (allowedTools.length > 0) {
+            options.allowedTools = allowedTools;
+            console.log(`   \u{1F527} Allowing ${allowedTools.length} MCP tools`);
+          }
+        }
+      } catch (error) {
+        console.warn("\u26A0\uFE0F  Failed to fetch MCP servers for session:", error);
+      }
+    }
+    console.log("\u{1F4E4} Calling query() with:");
+    console.log(`   prompt: "${prompt.substring(0, 100)}${prompt.length > 100 ? "..." : ""}"`);
+    console.log(`   options keys: ${Object.keys(options).join(", ")}`);
+    console.log(
+      `   \u{1F50D} [MCP DEBUG] options.mcpServers:`,
+      options.mcpServers ? JSON.stringify(options.mcpServers, null, 2) : "NOT SET"
+    );
+    console.log(
+      `   Full query call:`,
+      JSON.stringify(
+        {
+          prompt,
+          options
+        },
+        null,
+        2
+      )
+    );
+    let result;
+    try {
+      result = query({
+        prompt,
+        // biome-ignore lint/suspicious/noExplicitAny: SDK Options type doesn't include all available fields
+        options
+      });
+      console.log(`\u2705 query() returned AsyncGenerator successfully`);
+    } catch (syncError) {
+      console.error(`\u274C CRITICAL: query() threw synchronous error (very unusual):`, syncError);
+      console.error(`   Claude Code path: ${claudeCodePath}`);
+      console.error(`   CWD: ${cwd}`);
+      console.error(
+        `   API key set: ${this.apiKey ? "YES (custom)" : process.env.ANTHROPIC_API_KEY ? "YES (env)" : "NO"}`
+      );
+      console.error(`   Resume session: ${options.resume || "none (fresh session)"}`);
+      throw syncError;
+    }
+    this.activeQueries.set(sessionId, result);
+    const getStderr = () => stderrBuffer;
+    return { query: result, resolvedModel: model, getStderr };
+  }
+  /**
+   * Log prompt start with context
+   * @private
+   */
+  logPromptStart(sessionId, _prompt, _cwd, agentSessionId) {
+    console.log(`\u{1F916} Prompting Claude for session ${sessionId.substring(0, 8)}...`);
+    if (agentSessionId) {
+      console.log(`   Resuming session: ${agentSessionId}`);
+    }
+  }
+  /**
+   * Prompt a session using Claude Agent SDK (streaming version with text chunking)
+   *
+   * Yields both complete assistant messages AND text chunks as they're generated.
+   * This enables real-time typewriter effect in the UI.
+   *
+   * @param sessionId - Session to prompt
+   * @param prompt - User prompt
+   * @param taskId - Optional task ID for permission tracking
+   * @param permissionMode - Optional permission mode for SDK
+   * @param chunkCallback - Optional callback for text chunks (3-10 words)
+   * @returns Async generator yielding assistant messages with SDK session ID
+   */
+  async *promptSessionStreaming(sessionId, prompt, taskId, permissionMode, _chunkCallback) {
+    const {
+      query: result,
+      resolvedModel,
+      getStderr
+    } = await this.setupQuery(sessionId, prompt, taskId, permissionMode, true);
+    const session = await this.sessionsRepo?.findById(sessionId);
+    const existingSdkSessionId = session?.sdk_session_id;
+    const processor = new SDKMessageProcessor({
+      sessionId,
+      existingSdkSessionId,
+      enableTokenStreaming: _ClaudePromptService.ENABLE_TOKEN_STREAMING,
+      idleTimeoutMs: 12e4
+      // 2 minutes - allows time for long operations (web search, file reads, etc.)
+    });
+    try {
+      for await (const msg of result) {
+        if (this.stopRequested.get(sessionId)) {
+          console.log(
+            `\u{1F6D1} Stop requested for session ${sessionId.substring(0, 8)}, breaking event loop`
+          );
+          this.stopRequested.delete(sessionId);
+          break;
+        }
+        if (processor.hasTimedOut()) {
+          const state = processor.getState();
+          console.warn(
+            `\u23F1\uFE0F  No assistant messages for ${Math.round((Date.now() - state.lastAssistantMessageTime) / 1e3)}s - assuming conversation complete`
+          );
+          console.warn(
+            `   SDK may not have sent 'result' message - breaking loop as safety measure`
+          );
+          break;
+        }
+        const events = await processor.process(msg);
+        for (const event of events) {
+          if (event.type === "session_id_captured") {
+            if (this.sessionsRepo) {
+              await this.sessionsRepo.update(sessionId, {
+                sdk_session_id: event.agentSessionId
+              });
+              console.log(`\u{1F4BE} Stored Agent SDK session_id in database`);
+            }
+            continue;
+          }
+          if (event.type === "end") {
+            console.log(`\u{1F3C1} Conversation ended: ${event.reason}`);
+            break;
+          }
+          yield event;
+        }
+        if (events.some((e) => e.type === "end")) {
+          break;
+        }
+      }
+    } catch (error) {
+      this.activeQueries.delete(sessionId);
+      const state = processor.getState();
+      const stderrOutput = getStderr();
+      const errorContext = stderrOutput ? `
+
+Claude Code stderr output:
+${stderrOutput}` : "";
+      const enhancedError = new Error(
+        `Claude SDK error after ${state.messageCount} messages: ${error instanceof Error ? error.message : String(error)}${errorContext}`
+      );
+      if (error instanceof Error && error.stack) {
+        enhancedError.stack = error.stack;
+      }
+      console.error(`\u274C SDK iteration failed:`, {
+        sessionId: sessionId.substring(0, 8),
+        messageCount: state.messageCount,
+        error: error instanceof Error ? error.message : String(error),
+        stderr: stderrOutput || "(no stderr output)"
+      });
+      throw enhancedError;
+    }
+    this.activeQueries.delete(sessionId);
+  }
+  /**
+   * Prompt a session using Claude Agent SDK (non-streaming version)
+   *
+   * The Agent SDK automatically:
+   * - Loads CLAUDE.md from the working directory
+   * - Uses Claude Code preset system prompt
+   * - Handles streaming via async generators
+   *
+   * @param sessionId - Session to prompt
+   * @param prompt - User prompt
+   * @returns Complete assistant response with metadata
+   */
+  async promptSession(sessionId, prompt) {
+    const { query: result, getStderr } = await this.setupQuery(
+      sessionId,
+      prompt,
+      void 0,
+      void 0,
+      false
+    );
+    const session = await this.sessionsRepo?.findById(sessionId);
+    const existingSdkSessionId = session?.sdk_session_id;
+    const processor = new SDKMessageProcessor({
+      sessionId,
+      existingSdkSessionId,
+      enableTokenStreaming: false,
+      // Non-streaming mode
+      idleTimeoutMs: 12e4
+      // 2 minutes - allows time for long operations
+    });
+    const assistantMessages = [];
+    let tokenUsage;
+    for await (const msg of result) {
+      const events = await processor.process(msg);
+      for (const event of events) {
+        if (event.type === "complete" && event.role === "assistant" /* ASSISTANT */) {
+          assistantMessages.push({
+            content: event.content,
+            toolUses: event.toolUses
+          });
+        }
+        if (event.type === "result" && event.token_usage) {
+          tokenUsage = event.token_usage;
+        }
+        if (event.type === "end") {
+          break;
+        }
+      }
+    }
+    this.activeQueries.delete(sessionId);
+    return {
+      messages: assistantMessages,
+      inputTokens: tokenUsage?.input_tokens || 0,
+      outputTokens: tokenUsage?.output_tokens || 0
+    };
+  }
+  /**
+   * Stop currently executing task
+   *
+   * Uses Claude Agent SDK's native interrupt() method to gracefully stop execution.
+   * This is the same mechanism used by the Escape key in Claude Code CLI.
+   *
+   * @param sessionId - Session identifier
+   * @returns Success status
+   */
+  async stopTask(sessionId) {
+    console.log(`\u{1F6D1} Stopping task for session ${sessionId.substring(0, 8)}`);
+    const queryObj = this.activeQueries.get(sessionId);
+    if (!queryObj) {
+      return {
+        success: false,
+        reason: "No active task found for this session"
+      };
+    }
+    try {
+      this.stopRequested.set(sessionId, true);
+      await queryObj.interrupt();
+      this.activeQueries.delete(sessionId);
+      console.log(`\u2705 Stopped Claude execution for session ${sessionId.substring(0, 8)}`);
+      return { success: true };
+    } catch (error) {
+      console.error("Failed to interrupt Claude execution:", error);
+      this.stopRequested.delete(sessionId);
+      return {
+        success: false,
+        reason: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+
+// src/tools/claude/claude-tool.ts
+function extractTokenUsage(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const obj = raw;
+  return {
+    input_tokens: typeof obj.input_tokens === "number" ? obj.input_tokens : void 0,
+    output_tokens: typeof obj.output_tokens === "number" ? obj.output_tokens : void 0,
+    total_tokens: typeof obj.total_tokens === "number" ? obj.total_tokens : void 0,
+    cache_read_tokens: typeof obj.cache_read_input_tokens === "number" ? obj.cache_read_input_tokens : void 0,
+    cache_creation_tokens: typeof obj.cache_creation_input_tokens === "number" ? obj.cache_creation_input_tokens : void 0
+  };
+}
+var ClaudeTool = class {
+  constructor(messagesRepo, sessionsRepo, apiKey, messagesService, sessionMCPRepo, mcpServerRepo, permissionService, tasksService, sessionsService, worktreesRepo) {
+    this.messagesRepo = messagesRepo;
+    this.sessionsRepo = sessionsRepo;
+    this.messagesService = messagesService;
+    this.tasksService = tasksService;
+    if (messagesRepo && sessionsRepo) {
+      this.promptService = new ClaudePromptService(
+        messagesRepo,
+        sessionsRepo,
+        apiKey,
+        sessionMCPRepo,
+        mcpServerRepo,
+        permissionService,
+        tasksService,
+        sessionsService,
+        worktreesRepo,
+        messagesService
+      );
+    }
+  }
+  toolType = "claude-code";
+  name = "Claude Code";
+  promptService;
+  getCapabilities() {
+    return {
+      supportsSessionImport: true,
+      // ✅ We have transcript parsing
+      supportsSessionCreate: false,
+      // ❌ Waiting for SDK
+      supportsLiveExecution: true,
+      // ✅ Now supported via Anthropic SDK
+      supportsSessionFork: false,
+      supportsChildSpawn: false,
+      supportsGitState: true,
+      // Transcripts contain git state
+      supportsStreaming: true
+      // ✅ Streaming via callbacks during message generation
+    };
+  }
+  async checkInstalled() {
+    try {
+      const claudeDir = path4.join(os.homedir(), ".claude");
+      const stats = await fs5.stat(claudeDir);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  async importSession(sessionId, options) {
+    const session = await loadClaudeSession(sessionId, options?.projectDir);
+    const messages = transcriptsToMessages(session.messages, session.sessionId);
+    const metadata = {
+      sessionId: session.sessionId,
+      toolType: this.toolType,
+      status: TaskStatus.COMPLETED,
+      // Historical sessions are always completed
+      createdAt: new Date(session.messages[0]?.timestamp || Date.now()),
+      lastUpdatedAt: new Date(
+        session.messages[session.messages.length - 1]?.timestamp || Date.now()
+      ),
+      workingDirectory: session.cwd || void 0,
+      messageCount: session.messages.length
+    };
+    return {
+      sessionId: session.sessionId,
+      toolType: this.toolType,
+      messages,
+      metadata,
+      workingDirectory: session.cwd || void 0
+    };
+  }
+  /**
+   * Execute a prompt against a session WITH real-time streaming
+   *
+   * Creates user message, streams response chunks from Claude, then creates complete assistant messages.
+   * Calls streamingCallbacks during message generation for real-time UI updates.
+   * Agent SDK may return multiple assistant messages (e.g., tool invocation, then response).
+   *
+   * @param sessionId - Session to execute prompt in
+   * @param prompt - User prompt text
+   * @param taskId - Optional task ID for linking messages
+   * @param permissionMode - Optional permission mode for SDK
+   * @param streamingCallbacks - Optional callbacks for real-time streaming (enables typewriter effect)
+   * @returns User message ID and array of assistant message IDs
+   */
+  async executePromptWithStreaming(sessionId, prompt, taskId, permissionMode, streamingCallbacks) {
+    if (!this.promptService || !this.messagesRepo) {
+      throw new Error("ClaudeTool not initialized with repositories for live execution");
+    }
+    if (!this.messagesService) {
+      throw new Error("ClaudeTool not initialized with messagesService for live execution");
+    }
+    const existingMessages = await this.messagesRepo.findBySessionId(sessionId);
+    let nextIndex = existingMessages.length;
+    const userMessage = await this.createUserMessage(sessionId, prompt, taskId, nextIndex++);
+    const assistantMessageIds = [];
+    let capturedAgentSessionId;
+    let resolvedModel;
+    let currentMessageId = null;
+    let streamStartTime = Date.now();
+    let firstTokenTime = null;
+    let tokenUsage;
+    let durationMs;
+    let contextWindow;
+    let contextWindowLimit;
+    for await (const event of this.promptService.promptSessionStreaming(
+      sessionId,
+      prompt,
+      taskId,
+      permissionMode
+    )) {
+      if (!resolvedModel && "resolvedModel" in event && event.resolvedModel) {
+        resolvedModel = event.resolvedModel;
+      }
+      if (!capturedAgentSessionId && event.agentSessionId) {
+        capturedAgentSessionId = event.agentSessionId;
+        await this.captureAgentSessionId(sessionId, capturedAgentSessionId);
+      }
+      if (event.type === "tool_start") {
+        if (this.tasksService && taskId) {
+          this.tasksService.emit("tool:start", {
+            task_id: taskId,
+            session_id: sessionId,
+            tool_use_id: event.toolUseId,
+            tool_name: event.toolName
+          });
+        }
+      }
+      if (event.type === "tool_complete") {
+        if (this.tasksService && taskId) {
+          this.tasksService.emit("tool:complete", {
+            task_id: taskId,
+            session_id: sessionId,
+            tool_use_id: event.toolUseId
+          });
+        }
+      }
+      if ("token_usage" in event && event.token_usage) {
+        tokenUsage = extractTokenUsage(event.token_usage);
+      }
+      if ("duration_ms" in event && typeof event.duration_ms === "number") {
+        durationMs = event.duration_ms;
+      }
+      if ("model_usage" in event && event.model_usage) {
+        const modelUsage = event.model_usage;
+        let maxUsage = 0;
+        let maxLimit = 0;
+        for (const modelData of Object.values(modelUsage)) {
+          const usage = (modelData.inputTokens || 0) + (modelData.outputTokens || 0) + (modelData.cacheReadInputTokens || 0) + (modelData.cacheCreationInputTokens || 0);
+          const limit = modelData.contextWindow || 0;
+          if (usage > maxUsage) {
+            maxUsage = usage;
+            maxLimit = limit;
+          }
+        }
+        contextWindow = maxUsage;
+        contextWindowLimit = maxLimit;
+        console.log(
+          `\u{1F50D} [ClaudeTool] Context window: ${contextWindow}/${contextWindowLimit} (${(contextWindow / contextWindowLimit * 100).toFixed(1)}%)`
+        );
+      }
+      if (event.type === "partial" && event.textChunk) {
+        if (!currentMessageId) {
+          currentMessageId = generateId();
+          firstTokenTime = Date.now();
+          const ttfb = firstTokenTime - streamStartTime;
+          console.debug(`\u23F1\uFE0F [SDK] TTFB: ${ttfb}ms`);
+          if (streamingCallbacks) {
+            streamingCallbacks.onStreamStart(currentMessageId, {
+              session_id: sessionId,
+              task_id: taskId,
+              role: "assistant" /* ASSISTANT */,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+        if (streamingCallbacks) {
+          streamingCallbacks.onStreamChunk(currentMessageId, event.textChunk);
+        }
+      } else if (event.type === "complete" && event.content) {
+        if (currentMessageId && streamingCallbacks && "role" in event && event.role === "assistant" /* ASSISTANT */) {
+          const streamEndTime = Date.now();
+          streamingCallbacks.onStreamEnd(currentMessageId);
+          const totalTime = streamEndTime - streamStartTime;
+          const streamingTime = firstTokenTime ? streamEndTime - firstTokenTime : 0;
+          console.debug(
+            `\u23F1\uFE0F [Streaming] Complete - TTFB: ${firstTokenTime ? firstTokenTime - streamStartTime : 0}ms, streaming: ${streamingTime}ms, total: ${totalTime}ms`
+          );
+        }
+        if ("role" in event && event.role === "assistant" /* ASSISTANT */) {
+          const assistantMessageId = currentMessageId || generateId();
+          await this.createAssistantMessage(
+            sessionId,
+            assistantMessageId,
+            event.content,
+            event.toolUses,
+            taskId,
+            nextIndex++,
+            resolvedModel
+          );
+          assistantMessageIds.push(assistantMessageId);
+          currentMessageId = null;
+          streamStartTime = Date.now();
+          firstTokenTime = null;
+        } else if ("role" in event && event.role === "user" /* USER */) {
+          const userMessageId = generateId();
+          await this.createUserMessageFromContent(
+            sessionId,
+            userMessageId,
+            event.content,
+            taskId,
+            nextIndex++
+          );
+        }
+      }
+    }
+    return {
+      userMessageId: userMessage.message_id,
+      assistantMessageIds,
+      tokenUsage,
+      durationMs,
+      agentSessionId: capturedAgentSessionId,
+      contextWindow,
+      contextWindowLimit
+    };
+  }
+  /**
+   * Create user message in database (from text prompt)
+   * @private
+   */
+  async createUserMessage(sessionId, prompt, taskId, nextIndex) {
+    const userMessage = {
+      message_id: generateId(),
+      session_id: sessionId,
+      type: "user",
+      role: "user" /* USER */,
+      index: nextIndex,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content_preview: prompt.substring(0, 200),
+      content: prompt,
+      task_id: taskId
+    };
+    await this.messagesService?.create(userMessage);
+    return userMessage;
+  }
+  /**
+   * Create user message from SDK content (tool results, etc.)
+   * @private
+   */
+  async createUserMessageFromContent(sessionId, messageId, content, taskId, nextIndex) {
+    let contentPreview = "";
+    for (const block of content) {
+      if (block.type === "text" && block.text) {
+        contentPreview = block.text.substring(0, 200);
+        break;
+      } else if (block.type === "tool_result" && block.content) {
+        const resultText = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+        contentPreview = `Tool result: ${resultText.substring(0, 180)}`;
+        break;
+      }
+    }
+    const userMessage = {
+      message_id: messageId,
+      session_id: sessionId,
+      type: "user",
+      role: "user" /* USER */,
+      index: nextIndex,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content_preview: contentPreview,
+      content,
+      // Tool result blocks
+      task_id: taskId
+    };
+    await this.messagesService?.create(userMessage);
+    return userMessage;
+  }
+  /**
+   * Capture and store Agent SDK session_id for conversation continuity
+   * @private
+   */
+  async captureAgentSessionId(sessionId, agentSessionId) {
+    console.log(
+      `\u{1F511} Captured Agent SDK session_id for Agor session ${sessionId}: ${agentSessionId}`
+    );
+    if (this.sessionsRepo) {
+      console.log(
+        `\u{1F4DD} About to update session with: ${JSON.stringify({ sdk_session_id: agentSessionId })}`
+      );
+      const updated = await this.sessionsRepo.update(sessionId, {
+        sdk_session_id: agentSessionId
+      });
+      console.log(`\u{1F4BE} Stored Agent SDK session_id in Agor session`);
+      console.log(`\u{1F50D} Verify: updated.sdk_session_id = ${updated.sdk_session_id}`);
+    }
+  }
+  /**
+   * Create complete assistant message in database
+   * @private
+   */
+  async createAssistantMessage(sessionId, messageId, content, toolUses, taskId, nextIndex, resolvedModel) {
+    const textBlocks = content.filter((b) => b.type === "text").map((b) => b.text || "");
+    const fullTextContent = textBlocks.join("");
+    const contentPreview = fullTextContent.substring(0, 200);
+    const message = {
+      message_id: messageId,
+      session_id: sessionId,
+      type: "assistant",
+      role: "assistant" /* ASSISTANT */,
+      index: nextIndex,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content_preview: contentPreview,
+      content,
+      tool_uses: toolUses,
+      task_id: taskId,
+      metadata: {
+        model: resolvedModel || DEFAULT_CLAUDE_MODEL,
+        tokens: {
+          input: 0,
+          // TODO: Extract from SDK
+          output: 0
+        }
+      }
+    };
+    await this.messagesService?.create(message);
+    if (taskId && resolvedModel && this.tasksService) {
+      await this.tasksService.patch(taskId, { model: resolvedModel });
+    }
+    return message;
+  }
+  /**
+   * Execute a prompt against a session (non-streaming version)
+   *
+   * Creates user message, streams response from Claude, creates assistant messages.
+   * Agent SDK may return multiple assistant messages (e.g., tool invocation, then response).
+   * Returns user message ID and array of assistant message IDs.
+   *
+   * Also captures and stores the Agent SDK session_id for conversation continuity.
+   */
+  async executePrompt(sessionId, prompt, taskId, permissionMode) {
+    if (!this.promptService || !this.messagesRepo) {
+      throw new Error("ClaudeTool not initialized with repositories for live execution");
+    }
+    if (!this.messagesService) {
+      throw new Error("ClaudeTool not initialized with messagesService for live execution");
+    }
+    const existingMessages = await this.messagesRepo.findBySessionId(sessionId);
+    let nextIndex = existingMessages.length;
+    const userMessage = await this.createUserMessage(sessionId, prompt, taskId, nextIndex++);
+    const assistantMessageIds = [];
+    let capturedAgentSessionId;
+    let resolvedModel;
+    let tokenUsage;
+    let durationMs;
+    let contextWindow;
+    let contextWindowLimit;
+    for await (const event of this.promptService.promptSessionStreaming(
+      sessionId,
+      prompt,
+      taskId,
+      permissionMode
+    )) {
+      if (!resolvedModel && "resolvedModel" in event && event.resolvedModel) {
+        resolvedModel = event.resolvedModel;
+      }
+      if (!capturedAgentSessionId && event.agentSessionId) {
+        capturedAgentSessionId = event.agentSessionId;
+        await this.captureAgentSessionId(sessionId, capturedAgentSessionId);
+      }
+      if ("token_usage" in event && event.token_usage) {
+        tokenUsage = extractTokenUsage(event.token_usage);
+      }
+      if ("duration_ms" in event && typeof event.duration_ms === "number") {
+        durationMs = event.duration_ms;
+      }
+      if ("model_usage" in event && event.model_usage) {
+        const modelUsage = event.model_usage;
+        let maxUsage = 0;
+        let maxLimit = 0;
+        for (const modelData of Object.values(modelUsage)) {
+          const usage = (modelData.inputTokens || 0) + (modelData.outputTokens || 0) + (modelData.cacheReadInputTokens || 0) + (modelData.cacheCreationInputTokens || 0);
+          const limit = modelData.contextWindow || 0;
+          if (usage > maxUsage) {
+            maxUsage = usage;
+            maxLimit = limit;
+          }
+        }
+        contextWindow = maxUsage;
+        contextWindowLimit = maxLimit;
+        console.log(
+          `\u{1F50D} [ClaudeTool] Context window: ${contextWindow}/${contextWindowLimit} (${(contextWindow / contextWindowLimit * 100).toFixed(1)}%)`
+        );
+      }
+      if (event.type === "partial") {
+        continue;
+      }
+      if (event.type === "complete" && event.content) {
+        const messageId = generateId();
+        await this.createAssistantMessage(
+          sessionId,
+          messageId,
+          event.content,
+          event.toolUses,
+          taskId,
+          nextIndex++,
+          resolvedModel
+        );
+        assistantMessageIds.push(messageId);
+      }
+    }
+    return {
+      userMessageId: userMessage.message_id,
+      assistantMessageIds,
+      tokenUsage,
+      durationMs,
+      agentSessionId: capturedAgentSessionId,
+      contextWindow,
+      contextWindowLimit
+    };
+  }
+  /**
+   * Stop currently executing task in session
+   *
+   * Uses Claude Agent SDK's native interrupt() method to gracefully stop execution.
+   *
+   * @param sessionId - Session identifier
+   * @param taskId - Optional task ID (not used for Claude, session-level stop)
+   * @returns Success status and reason if failed
+   */
+  async stopTask(sessionId, taskId) {
+    if (!this.promptService) {
+      return {
+        success: false,
+        reason: "ClaudeTool not initialized with prompt service"
+      };
+    }
+    const result = await this.promptService.stopTask(sessionId);
+    if (result.success) {
+      return {
+        success: true,
+        partialResult: {
+          taskId: taskId || "unknown",
+          status: "cancelled"
+        }
+      };
+    }
+    return result;
+  }
+};
+
+// src/tools/claude/import/task-extractor.ts
+function extractTasksFromMessages(messages, sessionId) {
+  const tasks = [];
+  const userMessageIndices = messages.map((msg, idx) => msg.type === "user" ? idx : -1).filter((idx) => idx !== -1);
+  for (let i = 0; i < userMessageIndices.length; i++) {
+    const startIndex = userMessageIndices[i];
+    const userMessage = messages[startIndex];
+    const endIndex = i < userMessageIndices.length - 1 ? userMessageIndices[i + 1] - 1 : messages.length - 1;
+    const messagesInRange = messages.slice(startIndex, endIndex + 1);
+    const toolUseCount = messagesInRange.reduce((count, msg) => {
+      return count + (msg.tool_uses?.length ?? 0);
+    }, 0);
+    let fullPrompt = "";
+    if (typeof userMessage.content === "string") {
+      fullPrompt = userMessage.content;
+    } else if (Array.isArray(userMessage.content)) {
+      const textContent = userMessage.content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
+      fullPrompt = textContent || JSON.stringify(userMessage.content);
+    } else {
+      fullPrompt = JSON.stringify(userMessage.content);
+    }
+    const cleanPrompt = fullPrompt.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+    const description = cleanPrompt.substring(0, 120) + (cleanPrompt.length > 120 ? "..." : "");
+    const startTimestamp = userMessage.timestamp;
+    const endMessage = messages[endIndex];
+    const endTimestamp = endMessage?.timestamp;
+    tasks.push({
+      task_id: generateId(),
+      session_id: sessionId,
+      full_prompt: fullPrompt,
+      description,
+      status: TaskStatus.COMPLETED,
+      // Imported sessions are historical
+      message_range: {
+        start_index: startIndex,
+        end_index: endIndex,
+        start_timestamp: startTimestamp,
+        end_timestamp: endTimestamp
+      },
+      git_state: {
+        ref_at_start: "unknown",
+        // No git tracking in Claude Code transcripts
+        sha_at_start: "unknown"
+        // No git tracking in Claude Code transcripts
+      },
+      model: userMessage.metadata?.model || "claude-sonnet-4-5",
+      tool_use_count: toolUseCount,
+      created_at: startTimestamp,
+      completed_at: endTimestamp
+    });
+  }
+  return tasks;
+}
+
+// src/tools/codex/codex-tool.ts
+import { execSync as execSync2 } from "child_process";
+
+// src/tools/codex/models.ts
+var DEFAULT_CODEX_MODEL = "gpt-5-codex";
+var CODEX_MINI_MODEL = "codex-mini-latest";
+var CODEX_MODELS = {
+  "gpt-5-codex": "gpt-5-codex",
+  "codex-mini": "codex-mini-latest",
+  "gpt-4o": "gpt-4o",
+  "gpt-4o-mini": "gpt-4o-mini"
+};
+
+// src/tools/codex/prompt-service.ts
+import * as fs6 from "fs/promises";
+import * as path5 from "path";
+import { Codex } from "@openai/codex-sdk";
+var CodexPromptService = class {
+  constructor(_messagesRepo, sessionsRepo, apiKey) {
+    this.sessionsRepo = sessionsRepo;
+    this.codex = new Codex({
+      apiKey: apiKey || process.env.OPENAI_API_KEY
+    });
+  }
+  codex;
+  lastApprovalPolicy = null;
+  stopRequested = /* @__PURE__ */ new Map();
+  /**
+   * Generate ~/.codex/config.toml for approval_policy setting
+   *
+   * NOTE: approval_policy cannot be passed via ThreadOptions, so we must use config.toml.
+   * We minimize file writes by tracking the last set value and only updating when it changes.
+   */
+  async ensureApprovalPolicy(permissionMode) {
+    const approvalPolicyMap = {
+      ask: "untrusted",
+      // Ask before running any command
+      auto: "on-request",
+      // Model decides when to ask (recommended)
+      "on-failure": "on-failure",
+      // Ask only when commands fail
+      "allow-all": "never"
+      // Never ask, auto-approve all operations
+    };
+    const approvalPolicy = approvalPolicyMap[permissionMode];
+    if (this.lastApprovalPolicy === approvalPolicy) {
+      return;
+    }
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (!homeDir) {
+      console.warn("\u26A0\uFE0F  Could not determine home directory, skipping approval_policy config");
+      return;
+    }
+    const codexConfigDir = path5.join(homeDir, ".codex");
+    const configPath = path5.join(codexConfigDir, "config.toml");
+    const configContent = `# Codex configuration (approval_policy only - sandboxMode passed via SDK)
+# Generated by Agor - ${(/* @__PURE__ */ new Date()).toISOString()}
+
+# Approval policy controls when Codex asks before running commands
+# Options: "untrusted", "on-request", "on-failure", "never"
+approval_policy = "${approvalPolicy}"
+`;
+    await fs6.mkdir(codexConfigDir, { recursive: true });
+    await fs6.writeFile(configPath, configContent, "utf-8");
+    this.lastApprovalPolicy = approvalPolicy;
+    console.log(`\u{1F4DD} [Codex] Set approval_policy = "${approvalPolicy}" in ~/.codex/config.toml`);
+  }
+  /**
+   * Convert Codex item to ToolUse format
+   * Maps different Codex item types to Agor tool use schema
+   */
+  itemToToolUse(item, status) {
+    switch (item.type) {
+      case "command_execution":
+        return {
+          id: item.id,
+          name: "bash",
+          input: { command: item.command },
+          ...status === "completed" && {
+            output: item.aggregated_output || "",
+            status: item.status
+          }
+        };
+      case "file_change":
+        return {
+          id: item.id,
+          name: "edit_files",
+          input: {
+            changes: item.changes || []
+          },
+          ...status === "completed" && {
+            status: item.status
+          }
+        };
+      case "mcp_tool_call":
+        return {
+          id: item.id,
+          name: `${item.server}.${item.tool}`,
+          input: {},
+          ...status === "completed" && {
+            status: item.status
+          }
+        };
+      case "web_search":
+        return {
+          id: item.id,
+          name: "web_search",
+          input: { query: item.query }
+        };
+      case "reasoning":
+        return null;
+      case "todo_list":
+        return null;
+      case "agent_message":
+        return null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Execute prompt with streaming support
+   *
+   * Uses Codex SDK's runStreamed() method for real-time event streaming.
+   * Yields partial text chunks and complete messages.
+   *
+   * @param sessionId - Agor session ID
+   * @param prompt - User prompt
+   * @param taskId - Optional task ID
+   * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+   * @returns Async generator of streaming events
+   */
+  async *promptSessionStreaming(sessionId, prompt, _taskId, permissionMode) {
+    const session = await this.sessionsRepo.findById(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    console.log(`\u{1F50D} [Codex] Starting prompt execution for session ${sessionId.substring(0, 8)}`);
+    console.log(`   Permission mode: ${permissionMode || "not specified (will use default)"}`);
+    console.log(`   Existing thread ID: ${session.sdk_session_id || "none (will create new)"}`);
+    const effectivePermissionMode = permissionMode || session.permission_config?.mode || "auto";
+    const sandboxModeMap = {
+      ask: "read-only",
+      auto: "workspace-write",
+      "on-failure": "workspace-write",
+      "allow-all": "workspace-write"
+    };
+    const sandboxMode = sandboxModeMap[effectivePermissionMode];
+    await this.ensureApprovalPolicy(effectivePermissionMode);
+    console.log(`   Configured: sandboxMode=${sandboxMode}, approval_policy via config.toml`);
+    const threadOptions = {
+      workingDirectory: process.cwd(),
+      // Temporary fallback
+      skipGitRepoCheck: false,
+      sandboxMode
+    };
+    const sessionPermissionMode = session.permission_config?.mode || "auto";
+    const permissionModeChanged = effectivePermissionMode !== sessionPermissionMode;
+    let thread;
+    if (session.sdk_session_id) {
+      console.log(`\u{1F504} [Codex] Resuming thread: ${session.sdk_session_id}`);
+      thread = this.codex.resumeThread(session.sdk_session_id, threadOptions);
+      if (permissionModeChanged) {
+        console.log(
+          `\u2699\uFE0F  [Codex] Permission mode changed: ${sessionPermissionMode} \u2192 ${effectivePermissionMode}`
+        );
+        console.log(`   Sending slash commands to update thread settings...`);
+        const approvalModeMap = {
+          ask: "untrusted",
+          auto: "on-request",
+          "on-failure": "on-failure",
+          "allow-all": "never"
+        };
+        const approvalMode = approvalModeMap[effectivePermissionMode];
+        const slashCommand = `/approvals ${approvalMode}`;
+        console.log(`   Executing: ${slashCommand}`);
+        try {
+          await thread.run(slashCommand);
+          console.log(`\u2705 [Codex] Thread settings updated successfully`);
+        } catch (error) {
+          console.error(`\u274C [Codex] Failed to update thread settings:`, error);
+        }
+      }
+    } else {
+      console.log(`\u{1F195} [Codex] Creating new thread`);
+      thread = this.codex.startThread(threadOptions);
+    }
+    try {
+      console.log(
+        `\u25B6\uFE0F  [Codex] Running prompt: "${prompt.substring(0, 50)}${prompt.length > 50 ? "..." : ""}"`
+      );
+      const { events } = await thread.runStreamed(prompt);
+      let currentMessage = [];
+      let threadId = session.sdk_session_id || "";
+      let resolvedModel;
+      let allToolUses = [];
+      for await (const event of events) {
+        if (this.stopRequested.get(sessionId)) {
+          console.log(`\u{1F6D1} Stop requested for session ${sessionId}, breaking event loop`);
+          this.stopRequested.delete(sessionId);
+          break;
+        }
+        switch (event.type) {
+          case "turn.started":
+            allToolUses = [];
+            break;
+          case "item.started":
+            if (event.item) {
+              const toolUseStart = this.itemToToolUse(event.item, "started");
+              if (toolUseStart) {
+                yield {
+                  type: "tool_start",
+                  toolUse: toolUseStart,
+                  threadId: thread.id || void 0
+                };
+              }
+            }
+            break;
+          case "item.updated":
+            break;
+          case "item.completed":
+            if (event.item) {
+              const toolUseComplete = this.itemToToolUse(event.item, "completed");
+              if (toolUseComplete) {
+                allToolUses.push({
+                  id: toolUseComplete.id,
+                  name: toolUseComplete.name,
+                  input: toolUseComplete.input
+                });
+                currentMessage.push({
+                  type: "tool_use",
+                  id: toolUseComplete.id,
+                  name: toolUseComplete.name,
+                  input: toolUseComplete.input
+                });
+                if (toolUseComplete.output !== void 0 || toolUseComplete.status) {
+                  const isError = toolUseComplete.status === "failed" || toolUseComplete.status === "error";
+                  let content = toolUseComplete.output || "";
+                  if (!content && toolUseComplete.status) {
+                    content = `[${toolUseComplete.status}]`;
+                  }
+                  currentMessage.push({
+                    type: "tool_result",
+                    tool_use_id: toolUseComplete.id,
+                    content,
+                    is_error: isError
+                  });
+                }
+                yield {
+                  type: "tool_complete",
+                  toolUse: toolUseComplete,
+                  threadId: thread.id || void 0
+                };
+              }
+              if ("text" in event.item && event.item.type === "agent_message") {
+                currentMessage.push({
+                  type: "text",
+                  text: event.item.text
+                });
+              }
+            }
+            break;
+          case "turn.completed": {
+            threadId = thread.id || "";
+            yield {
+              type: "complete",
+              content: currentMessage,
+              toolUses: allToolUses.length > 0 ? allToolUses : void 0,
+              threadId,
+              resolvedModel: resolvedModel || DEFAULT_CODEX_MODEL
+            };
+            currentMessage = [];
+            allToolUses = [];
+            break;
+          }
+          case "turn.failed":
+            console.error("\u274C Codex turn failed:", event.error);
+            throw new Error(`Codex execution failed: ${event.error}`);
+          default:
+            break;
+        }
+      }
+    } catch (error) {
+      console.error("\u274C Codex streaming error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Execute prompt (non-streaming version)
+   *
+   * Collects all streaming events and returns complete result.
+   *
+   * @param sessionId - Agor session ID
+   * @param prompt - User prompt
+   * @param taskId - Optional task ID
+   * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+   * @returns Complete prompt result
+   */
+  async promptSession(sessionId, prompt, taskId, permissionMode) {
+    const messages = [];
+    let threadId = "";
+    const inputTokens = 0;
+    const outputTokens = 0;
+    for await (const event of this.promptSessionStreaming(
+      sessionId,
+      prompt,
+      taskId,
+      permissionMode
+    )) {
+      if (event.type === "complete") {
+        messages.push({
+          content: event.content,
+          toolUses: event.toolUses
+        });
+        threadId = event.threadId;
+      }
+    }
+    return {
+      messages,
+      inputTokens,
+      outputTokens,
+      threadId
+    };
+  }
+  /**
+   * Stop currently executing task
+   *
+   * Sets a stop flag that is checked in the event loop.
+   * The loop will break on the next iteration, stopping execution gracefully.
+   *
+   * @param sessionId - Session identifier
+   * @returns Success status
+   */
+  stopTask(sessionId) {
+    this.stopRequested.set(sessionId, true);
+    console.log(`\u{1F6D1} Stop requested for Codex session ${sessionId}`);
+    return { success: true };
+  }
+};
+
+// src/tools/codex/codex-tool.ts
+var CodexTool = class {
+  constructor(messagesRepo, sessionsRepo, apiKey, messagesService, tasksService) {
+    this.messagesRepo = messagesRepo;
+    this.sessionsRepo = sessionsRepo;
+    this.messagesService = messagesService;
+    this.tasksService = tasksService;
+    if (messagesRepo && sessionsRepo) {
+      this.promptService = new CodexPromptService(messagesRepo, sessionsRepo, apiKey);
+    }
+  }
+  toolType = "codex";
+  name = "OpenAI Codex";
+  promptService;
+  getCapabilities() {
+    return {
+      supportsSessionImport: false,
+      // ❌ Deferred until we have real JSONL format
+      supportsSessionCreate: false,
+      // ❌ Not exposed (handled via executeTask)
+      supportsLiveExecution: true,
+      // ✅ Via Codex SDK
+      supportsSessionFork: false,
+      supportsChildSpawn: false,
+      supportsGitState: false,
+      // Agor manages git state
+      supportsStreaming: true
+      // ✅ Via runStreamed()
+    };
+  }
+  async checkInstalled() {
+    try {
+      execSync2("which codex", { encoding: "utf-8" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Execute a prompt against a session WITH real-time streaming
+   *
+   * Creates user message, streams response chunks from Codex, then creates complete assistant messages.
+   * Calls streamingCallbacks during message generation for real-time UI updates.
+   *
+   * @param sessionId - Session to execute prompt in
+   * @param prompt - User prompt text
+   * @param taskId - Optional task ID for linking messages
+   * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+   * @param streamingCallbacks - Optional callbacks for real-time streaming (enables typewriter effect)
+   * @returns User message ID and array of assistant message IDs
+   */
+  async executePromptWithStreaming(sessionId, prompt, taskId, permissionMode, streamingCallbacks) {
+    if (!this.promptService || !this.messagesRepo) {
+      throw new Error("CodexTool not initialized with repositories for live execution");
+    }
+    if (!this.messagesService) {
+      throw new Error("CodexTool not initialized with messagesService for live execution");
+    }
+    const existingMessages = await this.messagesRepo.findBySessionId(sessionId);
+    let nextIndex = existingMessages.length;
+    const userMessage = await this.createUserMessage(sessionId, prompt, taskId, nextIndex++);
+    const assistantMessageIds = [];
+    let capturedThreadId;
+    let resolvedModel;
+    let currentMessageId = null;
+    let _streamStartTime = Date.now();
+    let _firstTokenTime = null;
+    for await (const event of this.promptService.promptSessionStreaming(
+      sessionId,
+      prompt,
+      taskId,
+      permissionMode
+    )) {
+      if (!resolvedModel) {
+        if (event.type === "partial") {
+          resolvedModel = event.resolvedModel;
+        } else if (event.type === "complete") {
+          resolvedModel = event.resolvedModel;
+        }
+      }
+      if (!capturedThreadId && event.threadId) {
+        capturedThreadId = event.threadId;
+        await this.captureThreadId(sessionId, capturedThreadId);
+      }
+      if (event.type === "partial" && event.textChunk) {
+        if (!currentMessageId) {
+          currentMessageId = generateId();
+          _firstTokenTime = Date.now();
+          if (streamingCallbacks) {
+            streamingCallbacks.onStreamStart(currentMessageId, {
+              session_id: sessionId,
+              task_id: taskId,
+              role: "assistant" /* ASSISTANT */,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+        if (streamingCallbacks) {
+          streamingCallbacks.onStreamChunk(currentMessageId, event.textChunk);
+        }
+      } else if (event.type === "tool_complete") {
+        const toolMessageId = generateId();
+        const toolContent = [
+          {
+            type: "tool_use",
+            id: event.toolUse.id,
+            name: event.toolUse.name,
+            input: event.toolUse.input
+          },
+          ...event.toolUse.output !== void 0 || event.toolUse.status ? [
+            {
+              type: "tool_result",
+              tool_use_id: event.toolUse.id,
+              content: event.toolUse.output || `[${event.toolUse.status}]`,
+              is_error: event.toolUse.status === "failed" || event.toolUse.status === "error"
+            }
+          ] : []
+        ];
+        await this.createAssistantMessage(
+          sessionId,
+          toolMessageId,
+          toolContent,
+          [
+            {
+              id: event.toolUse.id,
+              name: event.toolUse.name,
+              input: event.toolUse.input
+            }
+          ],
+          taskId,
+          nextIndex++,
+          resolvedModel
+        );
+        assistantMessageIds.push(toolMessageId);
+      } else if (event.type === "complete" && event.content) {
+        const textOnlyContent = event.content.filter(
+          (block) => block.type === "text"
+          // Only keep text blocks
+        );
+        if (textOnlyContent.length > 0) {
+          const _fullText = textOnlyContent.map((block) => block.text || "").join("");
+          const assistantMessageId = currentMessageId || generateId();
+          await this.createAssistantMessage(
+            sessionId,
+            assistantMessageId,
+            textOnlyContent,
+            void 0,
+            // No tool uses in this message (already saved separately)
+            taskId,
+            nextIndex++,
+            resolvedModel
+          );
+          assistantMessageIds.push(assistantMessageId);
+          currentMessageId = null;
+        }
+        _streamStartTime = Date.now();
+        _firstTokenTime = null;
+      }
+    }
+    return {
+      userMessageId: userMessage.message_id,
+      assistantMessageIds
+    };
+  }
+  /**
+   * Create user message in database
+   * @private
+   */
+  async createUserMessage(sessionId, prompt, taskId, nextIndex) {
+    const userMessage = {
+      message_id: generateId(),
+      session_id: sessionId,
+      type: "user",
+      role: "user" /* USER */,
+      index: nextIndex,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content_preview: prompt.substring(0, 200),
+      content: prompt,
+      task_id: taskId
+    };
+    await this.messagesService?.create(userMessage);
+    return userMessage;
+  }
+  /**
+   * Capture and store Codex thread ID for conversation continuity
+   * @private
+   */
+  async captureThreadId(sessionId, threadId) {
+    console.log(`\u{1F511} Captured Codex thread ID for Agor session ${sessionId}: ${threadId}`);
+    if (this.sessionsRepo) {
+      await this.sessionsRepo.update(sessionId, { sdk_session_id: threadId });
+      console.log(`\u{1F4BE} Stored Codex thread ID in Agor session`);
+    }
+  }
+  /**
+   * Create complete assistant message in database
+   * @private
+   */
+  async createAssistantMessage(sessionId, messageId, content, toolUses, taskId, nextIndex, resolvedModel) {
+    const textBlocks = content.filter((b) => b.type === "text").map((b) => b.text || "");
+    const fullTextContent = textBlocks.join("");
+    const contentPreview = fullTextContent.substring(0, 200);
+    const message = {
+      message_id: messageId,
+      session_id: sessionId,
+      type: "assistant",
+      role: "assistant" /* ASSISTANT */,
+      index: nextIndex,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content_preview: contentPreview,
+      content,
+      tool_uses: toolUses,
+      task_id: taskId,
+      metadata: {
+        model: resolvedModel || DEFAULT_CODEX_MODEL,
+        tokens: {
+          input: 0,
+          // TODO: Extract from Codex SDK
+          output: 0
+        }
+      }
+    };
+    await this.messagesService?.create(message);
+    if (taskId && resolvedModel && this.tasksService) {
+      await this.tasksService.patch(taskId, { model: resolvedModel });
+    }
+    return message;
+  }
+  /**
+   * Execute a prompt against a session (non-streaming version)
+   *
+   * Creates user message, collects response from Codex, creates assistant messages.
+   * Returns user message ID and array of assistant message IDs.
+   *
+   * @param sessionId - Session to execute prompt in
+   * @param prompt - User prompt text
+   * @param taskId - Optional task ID for linking messages
+   * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+   */
+  async executePrompt(sessionId, prompt, taskId, permissionMode) {
+    if (!this.promptService || !this.messagesRepo) {
+      throw new Error("CodexTool not initialized with repositories for live execution");
+    }
+    if (!this.messagesService) {
+      throw new Error("CodexTool not initialized with messagesService for live execution");
+    }
+    const existingMessages = await this.messagesRepo.findBySessionId(sessionId);
+    let nextIndex = existingMessages.length;
+    const userMessage = await this.createUserMessage(sessionId, prompt, taskId, nextIndex++);
+    const assistantMessageIds = [];
+    let capturedThreadId;
+    let resolvedModel;
+    for await (const event of this.promptService.promptSessionStreaming(
+      sessionId,
+      prompt,
+      taskId,
+      permissionMode
+    )) {
+      if (!resolvedModel) {
+        if (event.type === "partial") {
+          resolvedModel = event.resolvedModel;
+        } else if (event.type === "complete") {
+          resolvedModel = event.resolvedModel;
+        }
+      }
+      if (!capturedThreadId && event.threadId) {
+        capturedThreadId = event.threadId;
+        await this.captureThreadId(sessionId, capturedThreadId);
+      }
+      if (event.type === "partial" || event.type === "tool_start" || event.type === "tool_complete") {
+        continue;
+      }
+      if (event.type === "complete" && event.content) {
+        const messageId = generateId();
+        await this.createAssistantMessage(
+          sessionId,
+          messageId,
+          event.content,
+          event.toolUses,
+          taskId,
+          nextIndex++,
+          resolvedModel
+        );
+        assistantMessageIds.push(messageId);
+      }
+    }
+    return {
+      userMessageId: userMessage.message_id,
+      assistantMessageIds
+    };
+  }
+  /**
+   * Stop currently executing task in session
+   *
+   * Uses a flag-based approach to break the event loop on the next iteration.
+   *
+   * @param sessionId - Session identifier
+   * @param taskId - Optional task ID (not used for Codex, session-level stop)
+   * @returns Success status and reason if failed
+   */
+  async stopTask(sessionId, taskId) {
+    if (!this.promptService) {
+      return {
+        success: false,
+        reason: "CodexTool not initialized with prompt service"
+      };
+    }
+    const result = this.promptService.stopTask(sessionId);
+    if (result.success) {
+      return {
+        success: true,
+        partialResult: {
+          taskId: taskId || "unknown",
+          status: "cancelled"
+        }
+      };
+    }
+    return result;
+  }
+};
+
+// src/tools/gemini/gemini-tool.ts
+import { execSync as execSync3 } from "child_process";
+
+// src/tools/gemini/models.ts
+var DEFAULT_GEMINI_MODEL = "gemini-2.5-flash";
+var GEMINI_MODELS = {
+  "gemini-2.5-pro": {
+    name: "Gemini 2.5 Pro",
+    description: "Most capable model for complex reasoning and multi-step tasks",
+    inputPrice: "Higher",
+    // Pricing not publicly disclosed yet
+    outputPrice: "Higher",
+    useCase: "Complex refactoring, architecture decisions, advanced debugging"
+  },
+  "gemini-2.5-flash": {
+    name: "Gemini 2.5 Flash",
+    description: "Balanced performance and cost for most agentic coding tasks",
+    inputPrice: "$0.30",
+    outputPrice: "$2.50",
+    useCase: "Feature development, bug fixes, code reviews, testing"
+  },
+  "gemini-2.5-flash-lite": {
+    name: "Gemini 2.5 Flash-Lite",
+    description: "Ultra-fast, low-cost model for simple tasks",
+    inputPrice: "$0.10",
+    outputPrice: "$0.40",
+    useCase: "File search, summaries, simple edits, code formatting"
+  }
+};
+
+// src/tools/gemini/prompt-service.ts
+import * as crypto from "crypto";
+import * as fs7 from "fs/promises";
+import * as os2 from "os";
+import * as path6 from "path";
+import {
+  ApprovalMode,
+  AuthType,
+  Config,
+  executeToolCall,
+  GeminiClient,
+  GeminiEventType
+} from "@google/gemini-cli-core";
+var GeminiPromptService = class {
+  constructor(_messagesRepo, sessionsRepo, _apiKey) {
+    this.sessionsRepo = sessionsRepo;
+  }
+  sessionClients = /* @__PURE__ */ new Map();
+  activeControllers = /* @__PURE__ */ new Map();
+  /**
+   * Execute prompt with streaming via @google/gemini-cli-core SDK
+   *
+   * @param sessionId - Agor session ID
+   * @param prompt - User prompt text
+   * @param taskId - Optional task ID for message linking
+   * @param permissionMode - Agor permission mode ('ask' | 'auto' | 'allow-all')
+   * @yields Streaming events (partial chunks and complete messages)
+   */
+  async *promptSessionStreaming(sessionId, prompt, _taskId, permissionMode) {
+    const client = await this.getOrCreateClient(sessionId, permissionMode);
+    const session = await this.sessionsRepo.findById(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const model = session.model_config?.model || DEFAULT_GEMINI_MODEL;
+    let parts = [{ text: prompt }];
+    const abortController = new AbortController();
+    this.activeControllers.set(sessionId, abortController);
+    const promptId = `${sessionId}-${Date.now()}`;
+    try {
+      let loopCount = 0;
+      const MAX_LOOPS = 50;
+      while (loopCount < MAX_LOOPS) {
+        loopCount++;
+        console.debug(`[Gemini Loop ${loopCount}] Starting turn with ${parts.length} parts`);
+        const stream = client.sendMessageStream(parts, abortController.signal, promptId);
+        let fullTextContent = "";
+        const toolUses = [];
+        const pendingToolCalls = [];
+        for await (const event of stream) {
+          const eventValue = "value" in event ? event.value : void 0;
+          console.debug(
+            `[Gemini Event] ${event.type}:`,
+            eventValue ? JSON.stringify(eventValue).slice(0, 100) : "(no value)"
+          );
+          switch (event.type) {
+            case GeminiEventType.Content: {
+              const textChunk = event.value || "";
+              fullTextContent += textChunk;
+              yield {
+                type: "partial",
+                textChunk,
+                resolvedModel: model,
+                sessionId
+              };
+              break;
+            }
+            case GeminiEventType.ToolCallRequest: {
+              const { name, args, callId } = event.value;
+              toolUses.push({
+                id: callId,
+                name,
+                input: args
+              });
+              pendingToolCalls.push({
+                callId,
+                name,
+                args
+              });
+              yield {
+                type: "tool_start",
+                toolName: name,
+                toolInput: args
+              };
+              break;
+            }
+            case GeminiEventType.ToolCallResponse: {
+              const toolResponse = event.value;
+              yield {
+                type: "tool_complete",
+                toolName: toolResponse.name || "unknown",
+                result: toolResponse.response || toolResponse
+              };
+              break;
+            }
+            case GeminiEventType.Finished: {
+              console.debug(
+                `[Gemini Turn Finished] Text: ${fullTextContent.length} chars, Tools: ${toolUses.length}`
+              );
+              const content = [];
+              if (fullTextContent) {
+                content.push({
+                  type: "text",
+                  text: fullTextContent
+                });
+              }
+              for (const toolUse of toolUses) {
+                content.push({
+                  type: "tool_use",
+                  id: toolUse.id,
+                  name: toolUse.name,
+                  input: toolUse.input
+                });
+              }
+              if (content.length > 0) {
+                yield {
+                  type: "complete",
+                  content,
+                  toolUses: toolUses.length > 0 ? toolUses : void 0,
+                  resolvedModel: model,
+                  sessionId
+                };
+              }
+              await this.updateSessionHistory(sessionId, client);
+              break;
+            }
+            case GeminiEventType.Error: {
+              const errorValue = "value" in event ? event.value : "Unknown error";
+              console.error(`Gemini SDK error: ${JSON.stringify(errorValue)}`);
+              let errorMessage = "Unknown error";
+              if (typeof errorValue === "object" && errorValue !== null) {
+                if ("error" in errorValue && typeof errorValue.error === "object" && errorValue.error !== null) {
+                  const errorObj = errorValue.error;
+                  errorMessage = errorObj.message || JSON.stringify(errorValue);
+                } else {
+                  errorMessage = JSON.stringify(errorValue);
+                }
+              } else if (typeof errorValue === "string") {
+                errorMessage = errorValue;
+              }
+              throw new Error(`Gemini execution failed: ${errorMessage}`);
+            }
+            case GeminiEventType.Thought: {
+              const thoughtValue = "value" in event ? event.value : "";
+              console.debug(`[Gemini Thought] ${thoughtValue}`);
+              break;
+            }
+            case GeminiEventType.ToolCallConfirmation: {
+              console.warn(
+                "[Gemini] Tool call needs confirmation - this should not happen in AUTO_EDIT/YOLO mode!"
+              );
+              console.warn("[Gemini] Confirmation details:", JSON.stringify(event.value, null, 2));
+              break;
+            }
+            default: {
+              const debugValue = "value" in event ? event.value : "";
+              console.debug(`[Gemini Event] ${event.type}:`, debugValue);
+              break;
+            }
+          }
+        }
+        if (pendingToolCalls.length === 0) {
+          console.debug("[Gemini Loop] No pending tool calls - conversation complete!");
+          break;
+        }
+        console.debug(`[Gemini Loop] Found ${pendingToolCalls.length} pending tool calls`);
+        const config = client.config;
+        const functionResponseParts = [];
+        for (const toolCall of pendingToolCalls) {
+          try {
+            console.debug(
+              `[Gemini Loop] Executing tool: ${toolCall.name} with args:`,
+              JSON.stringify(toolCall.args).slice(0, 100)
+            );
+            const response = await executeToolCall(
+              config,
+              {
+                callId: toolCall.callId,
+                name: toolCall.name,
+                args: toolCall.args,
+                isClientInitiated: false,
+                prompt_id: promptId
+              },
+              abortController.signal
+            );
+            console.debug(`[Gemini Loop] Tool ${toolCall.name} executed successfully`);
+            functionResponseParts.push(...response.responseParts);
+          } catch (error) {
+            console.error(`[Gemini Loop] Error executing tool ${toolCall.name}:`, error);
+            functionResponseParts.push({
+              functionResponse: {
+                name: toolCall.name,
+                response: { error: String(error) }
+              }
+            });
+          }
+        }
+        parts = functionResponseParts;
+        console.debug(
+          `[Gemini Loop] Sending ${functionResponseParts.length} tool result parts back to model...`
+        );
+      }
+      if (loopCount >= MAX_LOOPS) {
+        console.warn(
+          `[Gemini Loop] Hit maximum loop count (${MAX_LOOPS}) - stopping to prevent infinite loop`
+        );
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        console.log(`\u{1F6D1} Gemini execution stopped for session ${sessionId}`);
+        return;
+      }
+      console.error("Gemini streaming error:", error);
+      throw error;
+    } finally {
+      this.activeControllers.delete(sessionId);
+    }
+  }
+  /**
+   * Load session file from SDK's filesystem storage
+   *
+   * Searches for session file in ~/.gemini/tmp/{projectHash}/chats/
+   * matching pattern: session-*-{sessionId-first8}.json
+   */
+  async loadSessionFile(sessionId, projectRoot) {
+    try {
+      const projectHash = crypto.createHash("sha256").update(projectRoot).digest("hex");
+      const chatsDir = path6.join(os2.homedir(), ".gemini", "tmp", projectHash, "chats");
+      try {
+        await fs7.access(chatsDir);
+      } catch {
+        console.debug(`No chats directory found for project ${projectRoot}`);
+        return null;
+      }
+      const sessionIdShort = sessionId.slice(0, 8);
+      const files = await fs7.readdir(chatsDir);
+      const sessionFile = files.find((f) => f.includes(sessionIdShort) && f.endsWith(".json"));
+      if (!sessionFile) {
+        console.debug(`No session file found for ${sessionId} (looking for *${sessionIdShort}*)`);
+        return null;
+      }
+      const filePath = path6.join(chatsDir, sessionFile);
+      const fileContent = await fs7.readFile(filePath, "utf-8");
+      const conversation = JSON.parse(fileContent);
+      console.log(`\u{1F4C2} Found session file: ${sessionFile}`);
+      return { conversation, filePath };
+    } catch (error) {
+      console.error("Error loading session file:", error);
+      return null;
+    }
+  }
+  /**
+   * Get or create GeminiClient for a session
+   *
+   * Manages client lifecycle and session continuity via history restoration.
+   */
+  async getOrCreateClient(sessionId, permissionMode) {
+    const approvalMode = this.mapPermissionMode(permissionMode || "ask");
+    if (this.sessionClients.has(sessionId)) {
+      const existingClient = this.sessionClients.get(sessionId);
+      const config2 = existingClient.config;
+      if (config2 && typeof config2.setApprovalMode === "function") {
+        config2.setApprovalMode(approvalMode);
+        console.log(`\u{1F504} [Gemini] Updated approval mode for existing client: ${approvalMode}`);
+      }
+      return existingClient;
+    }
+    const session = await this.sessionsRepo.findById(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const workingDirectory = process.cwd();
+    const model = session.model_config?.model || DEFAULT_GEMINI_MODEL;
+    console.log(
+      `\u{1F527} [Gemini] Creating new client with approval mode: ${permissionMode || "ask"} \u2192 ${approvalMode}`
+    );
+    const claudeMdPath = path6.join(workingDirectory, "CLAUDE.md");
+    let systemPrompt;
+    try {
+      const claudeMdContent = await fs7.readFile(claudeMdPath, "utf-8");
+      systemPrompt = `# Project Context
+
+${claudeMdContent}`;
+      console.log(`\u{1F4D6} Loaded CLAUDE.md from ${claudeMdPath}`);
+    } catch {
+    }
+    const config = new Config({
+      sessionId,
+      // Use Agor session ID
+      targetDir: workingDirectory,
+      cwd: workingDirectory,
+      model,
+      interactive: false,
+      // Use non-interactive mode (we'll handle tool execution ourselves)
+      approvalMode,
+      debugMode: true,
+      // Enable debug logging to see what's happening
+      folderTrust: true,
+      // CRITICAL: Trust folder to allow YOLO/AUTO_EDIT modes
+      trustedFolder: true,
+      // CRITICAL: Mark folder as trusted
+      fileFiltering: {
+        respectGitIgnore: true,
+        respectGeminiIgnore: true
+      }
+      // output: { format: 'stream-json' }, // Streaming JSON events (omitting for now - may not be needed)
+      // System prompt will be added via first message if provided
+    });
+    await config.initialize();
+    await config.refreshAuth(AuthType.USE_GEMINI);
+    const resumedSessionData = await this.loadSessionFile(sessionId, workingDirectory);
+    const client = new GeminiClient(config);
+    await client.initialize();
+    let hasExistingHistory = false;
+    if (resumedSessionData) {
+      const recordingService = client.getChatRecordingService();
+      if (recordingService) {
+        recordingService.initialize(resumedSessionData);
+        console.log(
+          `\u{1F504} Resumed session from file: ${resumedSessionData.conversation.messages.length} messages`
+        );
+        hasExistingHistory = true;
+        const history = this.convertConversationToHistory(resumedSessionData.conversation);
+        client.setHistory(history);
+      }
+    }
+    if (systemPrompt && !hasExistingHistory) {
+    }
+    this.sessionClients.set(sessionId, client);
+    return client;
+  }
+  /**
+   * Map Agor permission mode to Gemini ApprovalMode
+   *
+   * Gemini SDK supports 3 modes:
+   * - DEFAULT: Prompt for each tool use
+   * - AUTO_EDIT: Auto-approve file edits, prompt for shell/web commands
+   * - YOLO: Auto-approve all operations
+   */
+  mapPermissionMode(permissionMode) {
+    switch (permissionMode) {
+      case "default":
+      case "ask":
+        return ApprovalMode.DEFAULT;
+      // Prompt for each tool use
+      case "acceptEdits":
+      case "auto":
+        return ApprovalMode.YOLO;
+      // Auto-approve all operations (was: AUTO_EDIT)
+      case "bypassPermissions":
+      case "allow-all":
+        return ApprovalMode.YOLO;
+      // Auto-approve all operations
+      default:
+        return ApprovalMode.DEFAULT;
+    }
+  }
+  /**
+   * Convert SDK's ConversationRecord to Gemini Content[] format
+   *
+   * This converts the SDK's session file format into the API format needed for setHistory()
+   */
+  convertConversationToHistory(conversation) {
+    const history = [];
+    for (const msg of conversation.messages) {
+      const role = msg.type === "user" ? "user" : "model";
+      const parts = [];
+      const content = msg.content;
+      if (Array.isArray(content)) {
+        parts.push(...content);
+      } else if (content && typeof content === "object" && "text" in content) {
+        parts.push(content);
+      }
+      if (parts.length > 0) {
+        history.push({ role, parts });
+      }
+    }
+    return history;
+  }
+  /**
+   * Update session history after turn completion
+   *
+   * The SDK's ChatRecordingService automatically persists to filesystem,
+   * so we just log for debugging purposes.
+   */
+  async updateSessionHistory(sessionId, client) {
+    const history = client.getHistory();
+    const recordingService = client.getChatRecordingService();
+    if (recordingService) {
+      console.debug(
+        `\u{1F4DD} Session ${sessionId} history updated: ${history.length} turns (auto-saved to filesystem)`
+      );
+    } else {
+      console.warn(
+        `\u26A0\uFE0F  No ChatRecordingService found for session ${sessionId} - history not persisted`
+      );
+    }
+  }
+  /**
+   * Stop currently executing task
+   *
+   * Calls abort() on the AbortController to gracefully stop streaming.
+   *
+   * @param sessionId - Session identifier
+   * @returns Success status
+   */
+  stopTask(sessionId) {
+    const controller = this.activeControllers.get(sessionId);
+    if (!controller) {
+      return {
+        success: false,
+        reason: "No active task found for this session"
+      };
+    }
+    controller.abort();
+    console.log(`\u{1F6D1} Stopping Gemini task for session ${sessionId}`);
+    return { success: true };
+  }
+  /**
+   * Clean up client for a session (e.g., on session close)
+   */
+  async closeSession(sessionId) {
+    const client = this.sessionClients.get(sessionId);
+    if (client) {
+      await client.resetChat();
+      this.sessionClients.delete(sessionId);
+      console.log(`\u{1F5D1}\uFE0F  Closed Gemini client for session ${sessionId}`);
+    }
+  }
+};
+
+// src/tools/gemini/gemini-tool.ts
+var GeminiTool = class {
+  constructor(messagesRepo, sessionsRepo, apiKey, messagesService, tasksService) {
+    this.messagesRepo = messagesRepo;
+    this.messagesService = messagesService;
+    this.tasksService = tasksService;
+    if (messagesRepo && sessionsRepo) {
+      this.promptService = new GeminiPromptService(messagesRepo, sessionsRepo, apiKey);
+    }
+  }
+  toolType = "gemini";
+  name = "Google Gemini";
+  promptService;
+  getCapabilities() {
+    return {
+      supportsSessionImport: false,
+      // ❌ Deferred until checkpoint format is documented
+      supportsSessionCreate: false,
+      // ❌ Not exposed (handled via executeTask)
+      supportsLiveExecution: true,
+      // ✅ Via @google/gemini-cli-core SDK
+      supportsSessionFork: false,
+      supportsChildSpawn: false,
+      supportsGitState: false,
+      // Agor manages git state
+      supportsStreaming: true
+      // ✅ Via sendMessageStream()
+    };
+  }
+  async checkInstalled() {
+    try {
+      execSync3("which gemini", { encoding: "utf-8" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Execute a prompt against a session WITH real-time streaming
+   *
+   * Creates user message, streams response chunks from Gemini, then creates complete assistant messages.
+   * Calls streamingCallbacks during message generation for real-time UI updates.
+   *
+   * @param sessionId - Session to execute prompt in
+   * @param prompt - User prompt text
+   * @param taskId - Optional task ID for linking messages
+   * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+   * @param streamingCallbacks - Optional callbacks for real-time streaming (enables typewriter effect)
+   * @returns User message ID and array of assistant message IDs
+   */
+  async executePromptWithStreaming(sessionId, prompt, taskId, permissionMode, streamingCallbacks) {
+    if (!this.promptService || !this.messagesRepo) {
+      throw new Error("GeminiTool not initialized with repositories for live execution");
+    }
+    if (!this.messagesService) {
+      throw new Error("GeminiTool not initialized with messagesService for live execution");
+    }
+    const existingMessages = await this.messagesRepo.findBySessionId(sessionId);
+    let nextIndex = existingMessages.length;
+    const userMessage = await this.createUserMessage(sessionId, prompt, taskId, nextIndex++);
+    const assistantMessageIds = [];
+    let resolvedModel;
+    let currentMessageId = null;
+    let streamStartTime = Date.now();
+    let firstTokenTime = null;
+    for await (const event of this.promptService.promptSessionStreaming(
+      sessionId,
+      prompt,
+      taskId,
+      permissionMode
+    )) {
+      if (!resolvedModel) {
+        if (event.type === "partial") {
+          resolvedModel = event.resolvedModel;
+        } else if (event.type === "complete") {
+          resolvedModel = event.resolvedModel;
+        }
+      }
+      if (event.type === "partial" && event.textChunk) {
+        if (!currentMessageId) {
+          currentMessageId = generateId();
+          firstTokenTime = Date.now();
+          const ttfb = firstTokenTime - streamStartTime;
+          console.debug(`\u23F1\uFE0F  [Gemini] TTFB: ${ttfb}ms`);
+          if (streamingCallbacks) {
+            streamingCallbacks.onStreamStart(currentMessageId, {
+              session_id: sessionId,
+              task_id: taskId,
+              role: "assistant" /* ASSISTANT */,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+        if (streamingCallbacks) {
+          streamingCallbacks.onStreamChunk(currentMessageId, event.textChunk);
+        }
+      } else if (event.type === "complete" && event.content) {
+        if (currentMessageId && streamingCallbacks) {
+          const streamEndTime = Date.now();
+          streamingCallbacks.onStreamEnd(currentMessageId);
+          const totalTime = streamEndTime - streamStartTime;
+          const streamingTime = firstTokenTime ? streamEndTime - firstTokenTime : 0;
+          console.debug(
+            `\u23F1\uFE0F  [Streaming] Complete - TTFB: ${firstTokenTime ? firstTokenTime - streamStartTime : 0}ms, streaming: ${streamingTime}ms, total: ${totalTime}ms`
+          );
+        }
+        const assistantMessageId = currentMessageId || generateId();
+        await this.createAssistantMessage(
+          sessionId,
+          assistantMessageId,
+          event.content,
+          event.toolUses,
+          taskId,
+          nextIndex++,
+          resolvedModel
+        );
+        assistantMessageIds.push(assistantMessageId);
+        currentMessageId = null;
+        streamStartTime = Date.now();
+        firstTokenTime = null;
+      }
+    }
+    return {
+      userMessageId: userMessage.message_id,
+      assistantMessageIds
+    };
+  }
+  /**
+   * Create user message in database
+   * @private
+   */
+  async createUserMessage(sessionId, prompt, taskId, nextIndex) {
+    const userMessage = {
+      message_id: generateId(),
+      session_id: sessionId,
+      type: "user",
+      role: "user" /* USER */,
+      index: nextIndex,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content_preview: prompt.substring(0, 200),
+      content: prompt,
+      task_id: taskId
+    };
+    await this.messagesService?.create(userMessage);
+    return userMessage;
+  }
+  /**
+   * Create complete assistant message in database
+   * @private
+   */
+  async createAssistantMessage(sessionId, messageId, content, toolUses, taskId, nextIndex, resolvedModel) {
+    const textBlocks = content.filter((b) => b.type === "text").map((b) => b.text || "");
+    const fullTextContent = textBlocks.join("");
+    const contentPreview = fullTextContent.substring(0, 200);
+    const message = {
+      message_id: messageId,
+      session_id: sessionId,
+      type: "assistant",
+      role: "assistant" /* ASSISTANT */,
+      index: nextIndex,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content_preview: contentPreview,
+      content,
+      tool_uses: toolUses,
+      task_id: taskId,
+      metadata: {
+        model: resolvedModel || DEFAULT_GEMINI_MODEL,
+        tokens: {
+          input: 0,
+          // TODO: Extract from Gemini SDK usage metadata
+          output: 0
+        }
+      }
+    };
+    await this.messagesService?.create(message);
+    if (taskId && resolvedModel && this.tasksService) {
+      await this.tasksService.patch(taskId, { model: resolvedModel });
+    }
+    return message;
+  }
+  /**
+   * Execute a prompt against a session (non-streaming version)
+   *
+   * Creates user message, collects response from Gemini, creates assistant messages.
+   * Returns user message ID and array of assistant message IDs.
+   *
+   * @param sessionId - Session to execute prompt in
+   * @param prompt - User prompt text
+   * @param taskId - Optional task ID for linking messages
+   * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+   */
+  async executePrompt(sessionId, prompt, taskId, permissionMode) {
+    if (!this.promptService || !this.messagesRepo) {
+      throw new Error("GeminiTool not initialized with repositories for live execution");
+    }
+    if (!this.messagesService) {
+      throw new Error("GeminiTool not initialized with messagesService for live execution");
+    }
+    const existingMessages = await this.messagesRepo.findBySessionId(sessionId);
+    let nextIndex = existingMessages.length;
+    const userMessage = await this.createUserMessage(sessionId, prompt, taskId, nextIndex++);
+    const assistantMessageIds = [];
+    let resolvedModel;
+    for await (const event of this.promptService.promptSessionStreaming(
+      sessionId,
+      prompt,
+      taskId,
+      permissionMode
+    )) {
+      if (!resolvedModel) {
+        if (event.type === "partial") {
+          resolvedModel = event.resolvedModel;
+        } else if (event.type === "complete") {
+          resolvedModel = event.resolvedModel;
+        }
+      }
+      if (event.type === "partial" || event.type === "tool_start" || event.type === "tool_complete") {
+        continue;
+      }
+      if (event.type === "complete" && event.content) {
+        const messageId = generateId();
+        await this.createAssistantMessage(
+          sessionId,
+          messageId,
+          event.content,
+          event.toolUses,
+          taskId,
+          nextIndex++,
+          resolvedModel
+        );
+        assistantMessageIds.push(messageId);
+      }
+    }
+    return {
+      userMessageId: userMessage.message_id,
+      assistantMessageIds
+    };
+  }
+  /**
+   * Stop currently executing task in session
+   *
+   * Uses AbortController to gracefully cancel the streaming request.
+   *
+   * @param sessionId - Session identifier
+   * @param taskId - Optional task ID (not used for Gemini, session-level stop)
+   * @returns Success status and reason if failed
+   */
+  async stopTask(sessionId, taskId) {
+    if (!this.promptService) {
+      return {
+        success: false,
+        reason: "GeminiTool not initialized with prompt service"
+      };
+    }
+    const result = this.promptService.stopTask(sessionId);
+    if (result.success) {
+      return {
+        success: true,
+        partialResult: {
+          taskId: taskId || "unknown",
+          status: "cancelled"
+        }
+      };
+    }
+    return result;
+  }
+};
+export {
+  AVAILABLE_CLAUDE_MODEL_ALIASES,
+  CODEX_MINI_MODEL,
+  CODEX_MODELS,
+  ClaudeTool,
+  CodexPromptService,
+  CodexTool,
+  DEFAULT_CLAUDE_MODEL,
+  DEFAULT_CODEX_MODEL,
+  DEFAULT_GEMINI_MODEL,
+  GEMINI_MODELS,
+  GeminiPromptService,
+  GeminiTool,
+  appendSessionContextToCLAUDEmd,
+  buildConversationTree,
+  extractTasksFromMessages,
+  filterConversationMessages,
+  generateSessionContext,
+  getTranscriptPath,
+  loadClaudeSession,
+  loadSessionTranscript,
+  parseTranscript,
+  removeSessionContextFromCLAUDEmd,
+  transcriptToMessage,
+  transcriptsToMessages
+};