@foothill/agent-move 1.0.9 → 1.0.10

package/packages/server/dist/index.js

@@ -1,6 +1,6 @@
 // dist/index.js
 import { fileURLToPath } from "url";
-import { dirname, join as join6 } from "path";
+import { dirname as dirname2, join as join10 } from "path";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import websocket from "@fastify/websocket";
@@ -10,8 +10,8 @@ import { join } from "path";
 import chokidar from "chokidar";
 import { stat as stat2, open } from "fs/promises";
 import { join as join4, basename } from "path";
-import { existsSync } from "fs";
 import { join as join2 } from "path";
+import { existsSync } from "fs";
 import { readdir, stat } from "fs/promises";
 import { join as join3 } from "path";
 import chokidar2 from "chokidar";
@@ -19,6 +19,18 @@ import Database from "better-sqlite3";
 import { homedir as homedir2 } from "os";
 import { join as join5 } from "path";
 import { existsSync as existsSync2 } from "fs";
+import chokidar3 from "chokidar";
+import { stat as stat3, open as open2 } from "fs/promises";
+import { join as join7, basename as basename2, dirname } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import chokidar4 from "chokidar";
+import { stat as stat4, open as open3, readdir as readdir2 } from "fs/promises";
+import { join as join9, basename as basename4 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join8, basename as basename3 } from "path";
+import { existsSync as existsSync4 } from "fs";
 import { EventEmitter as EventEmitter2 } from "events";
 import { EventEmitter } from "events";
 import { execSync } from "child_process";
@@ -35,7 +47,11 @@ var config = {
   activeThresholdMs: 10 * 60 * 1e3,
   // 10 minutes
   /** Enable OpenCode session watching (auto-detected if storage dir exists) */
-  enableOpenCode: process.env.AGENT_MOVE_OPENCODE !== "false"
+  enableOpenCode: process.env.AGENT_MOVE_OPENCODE !== "false",
+  /** Enable pi coding agent session watching (auto-detected if sessions dir exists) */
+  enablePi: process.env.AGENT_MOVE_PI !== "false",
+  /** Enable Codex CLI session watching (auto-detected if sessions dir exists) */
+  enableCodex: process.env.AGENT_MOVE_CODEX !== "false"
 };
 var JsonlParser = class {
   parseLine(line) {
@@ -128,6 +144,38 @@ var JsonlParser = class {
     return null;
   }
 };
+function resolveEncodedPath(root, segments) {
+  try {
+    const parts = segments.split("-").filter(Boolean);
+    let currentPath = root;
+    let lastName = "";
+    let i = 0;
+    while (i < parts.length) {
+      let found = false;
+      const maxLen = Math.min(parts.length - i, 6);
+      for (let len = 1; len <= maxLen; len++) {
+        const segment = parts.slice(i, i + len).join("-");
+        for (const prefix of ["", "."]) {
+          const testPath = join2(currentPath, prefix + segment);
+          if (existsSync(testPath)) {
+            currentPath = testPath;
+            lastName = prefix + segment;
+            i += len;
+            found = true;
+            break;
+          }
+        }
+        if (found)
+          break;
+      }
+      if (!found)
+        break;
+    }
+    return lastName || null;
+  } catch {
+    return null;
+  }
+}
 var ClaudePaths = class {
   /**
    * Parse a JSONL session file path to extract project info.
@@ -140,6 +188,7 @@ var ClaudePaths = class {
     const projectsIdx = parts.indexOf("projects");
     if (projectsIdx === -1 || projectsIdx + 1 >= parts.length) {
       return {
+        agentType: "claude",
         projectPath: "unknown",
         projectName: "Unknown",
         isSubagent: false,
@@ -153,6 +202,7 @@ var ClaudePaths = class {
     const isSubagent = depthAfterProject > 1;
     const parentSessionId = isSubagent ? parts[projectsIdx + 2] : null;
     return {
+      agentType: "claude",
       projectPath: encodedProjectName,
       projectName,
       isSubagent,
@@ -166,80 +216,37 @@ var ClaudePaths = class {
    * e.g., "C--projects-fts-temp-agent-move" → "agent-move"
    */
   decodeProjectName(encoded) {
-    const resolved = this.resolveToFolderName(encoded);
-    if (resolved)
-      return resolved;
+    const driveMatch = encoded.match(/^([A-Za-z])--(.*)/);
+    const unixMatch = !driveMatch && encoded.match(/^-(.*)/);
+    if (driveMatch) {
+      const resolved = resolveEncodedPath(driveMatch[1] + ":/", driveMatch[2]);
+      if (resolved)
+        return resolved;
+    } else if (unixMatch) {
+      const resolved = resolveEncodedPath("/", unixMatch[1]);
+      if (resolved)
+        return resolved;
+    }
     const parts = encoded.split("-").filter((p) => p.length > 0);
     if (parts.length <= 2)
       return parts.join("/");
     return parts.slice(-2).join("/");
   }
-  /**
-   * Greedily resolve the encoded path against the filesystem.
-   * Tries each dash-segment as a directory, joining multiple segments
-   * when a single one doesn't exist (to handle dashes in folder names).
-   */
-  resolveToFolderName(encoded) {
-    try {
-      let root;
-      let rest;
-      const driveMatch = encoded.match(/^([A-Za-z])--(.*)/);
-      const unixMatch = !driveMatch && encoded.match(/^-(.*)/);
-      if (driveMatch) {
-        root = driveMatch[1] + ":/";
-        rest = driveMatch[2];
-      } else if (unixMatch) {
-        root = "/";
-        rest = unixMatch[1];
-      } else {
-        return null;
-      }
-      const parts = rest.split("-").filter(Boolean);
-      let currentPath = root;
-      let lastName = "";
-      let i = 0;
-      while (i < parts.length) {
-        let found = false;
-        const maxLen = Math.min(parts.length - i, 6);
-        for (let len = 1; len <= maxLen; len++) {
-          const segment = parts.slice(i, i + len).join("-");
-          for (const prefix of ["", "."]) {
-            const testPath = join2(currentPath, prefix + segment);
-            if (existsSync(testPath)) {
-              currentPath = testPath;
-              lastName = prefix + segment;
-              i += len;
-              found = true;
-              break;
-            }
-          }
-          if (found)
-            break;
-        }
-        if (!found)
-          break;
-      }
-      return lastName || null;
-    } catch {
-      return null;
-    }
-  }
 };
 var claudePaths = new ClaudePaths();
 var SessionScanner = class {
-  claudeHome;
-  constructor(claudeHome) {
-    this.claudeHome = claudeHome;
+  rootDir;
+  constructor(rootDir) {
+    this.rootDir = rootDir;
   }
-  /** Find all recently active JSONL session files */
+  /** Find the most recently modified JSONL per project subdirectory */
   async scan() {
     const results = [];
-    const projectsDir = join3(this.claudeHome, "projects");
     try {
-      const projects = await readdir(projectsDir);
+      const projects = await readdir(this.rootDir);
       const now = Date.now();
       for (const project of projects) {
-        const projectDir = join3(projectsDir, project);
+        const projectDir = join3(this.rootDir, project);
         try {
           const projectStat = await stat(projectDir);
           if (!projectStat.isDirectory())
@@ -269,7 +276,6 @@ var SessionScanner = class {
         }
       }
     } catch {
-      console.log("No projects directory found \u2014 will wait for new sessions");
     }
     return results;
   }
@@ -287,7 +293,7 @@ var FileWatcher = class {
     this.stateManager = stateManager;
   }
   async start() {
-    const scanner = new SessionScanner(this.claudeHome);
+    const scanner = new SessionScanner(join4(this.claudeHome, "projects"));
     const existingFiles = await scanner.scan();
     for (const file of existingFiles) {
       await this.processFile(file);
@@ -358,6 +364,16 @@ var FileWatcher = class {
     }
   }
 };
+function createFallbackSession(agentType, name) {
+  return {
+    agentType,
+    projectPath: name,
+    projectName: name,
+    isSubagent: false,
+    projectDir: name,
+    parentSessionId: null
+  };
+}
 function getOpenCodeDbPath() {
   const home = homedir2();
   const candidates = [
@@ -376,6 +392,7 @@ function parseOpenCodeSession(row) {
   const segments = row.directory.replace(/\\/g, "/").split("/").filter(Boolean);
   const projectName = segments[segments.length - 1] || "opencode";
   return {
+    agentType: "opencode",
     // Use the actual directory as projectPath so getGitBranch() gets a valid cwd.
     // projectDir uses the project_id hash to group agents belonging to the same project.
     projectPath: row.directory || row.project_id,
@@ -435,7 +452,7 @@ function getZoneForTool(toolName) {
   return TOOL_ZONE_MAP[toolName] ?? "thinking";
 }
 var TOOL_NAME_MAP = {
-  // OpenCode lowercase → canonical PascalCase
+  // OpenCode / pi lowercase → canonical PascalCase
   read: "Read",
   write: "Write",
   edit: "Edit",
@@ -446,7 +463,36 @@ var TOOL_NAME_MAP = {
   websearch: "WebSearch",
   webfetch: "WebFetch",
   todoread: "TodoRead",
-  todowrite: "TodoWrite"
+  todowrite: "TodoWrite",
+  // pi-specific tool names
+  "edit-diff": "Patch",
+  find: "Glob",
+  ls: "Bash",
+  truncate: "Write",
+  // Codex CLI tool names
+  shell_command: "Bash",
+  exec_command: "Bash",
+  read_file: "Read",
+  apply_patch: "Patch",
+  list_dir: "Bash",
+  grep_files: "Grep",
+  web_search: "WebSearch",
+  js_repl: "Bash",
+  js_repl_reset: "Bash",
+  spawn_agent: "Agent",
+  send_input: "Agent",
+  wait: "Agent",
+  close_agent: "Agent",
+  resume_agent: "Agent",
+  spawn_agents_on_csv: "Agent",
+  report_agent_job_result: "Agent",
+  request_user_input: "AskUserQuestion",
+  request_permissions: "AskUserQuestion",
+  update_plan: "TodoWrite",
+  view_image: "Read",
+  image_generation: "Write",
+  write_stdin: "Bash",
+  search_apps: "WebSearch"
 };
 function normalizeToolName(name) {
   return TOOL_NAME_MAP[name] ?? name;
@@ -907,13 +953,597 @@ var OpenCodeWatcher = class {
     return id.startsWith("oc:") ? id : `oc:${id}`;
   }
   fallbackSession() {
-    return {
-      projectPath: "opencode",
-      projectName: "opencode",
-      isSubagent: false,
-      projectDir: "opencode",
-      parentSessionId: null
+    return createFallbackSession("opencode", "opencode");
+  }
+};
+var PiParser = class {
+  /**
+   * Parse a single JSONL line from a pi session file into a raw object.
+   * Returns the parsed JSON, or null on parse error.
+   */
+  parseRaw(line) {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Extract a ParsedActivity from a pre-parsed JSONL entry.
+   * Returns null for non-actionable entries (session header, user messages, etc.).
+   */
+  parseEntry(entry) {
+    if (entry.type !== "message")
+      return null;
+    const msg = entry.message;
+    if (!msg || msg.role !== "assistant")
+      return null;
+    return this.parseAssistantMessage(msg);
+  }
+  /**
+   * Check if a pre-parsed entry is a session header.
+   */
+  isSessionHeader(entry) {
+    return entry.type === "session";
+  }
+  parseAssistantMessage(msg) {
+    const content = msg.content;
+    if (!Array.isArray(content))
+      return null;
+    for (const block of content) {
+      if (block.type === "toolCall") {
+        const tool = block;
+        return {
+          type: "tool_use",
+          toolName: normalizeToolName(tool.name),
+          toolInput: normalizeToolInput(tool.arguments ?? {}),
+          model: msg.model,
+          inputTokens: msg.usage?.input,
+          outputTokens: msg.usage?.output,
+          cacheReadTokens: msg.usage?.cacheRead,
+          cacheCreationTokens: msg.usage?.cacheWrite
+        };
+      }
+    }
+    for (const block of content) {
+      if (block.type === "text") {
+        const text = block.text?.trim() ?? "";
+        if (text.length > 0 && text.length < 200) {
+          return {
+            type: "text",
+            text,
+            model: msg.model,
+            inputTokens: msg.usage?.input,
+            outputTokens: msg.usage?.output,
+            cacheReadTokens: msg.usage?.cacheRead,
+            cacheCreationTokens: msg.usage?.cacheWrite
+          };
+        }
+      }
+    }
+    for (const block of content) {
+      if (block.type === "thinking") {
+        const thinking = block.thinking?.trim() ?? "";
+        return {
+          type: "tool_use",
+          toolName: "thinking",
+          toolInput: thinking.length > 0 ? { thought: thinking.slice(0, 120) } : void 0,
+          model: msg.model,
+          inputTokens: msg.usage?.input,
+          outputTokens: msg.usage?.output,
+          cacheReadTokens: msg.usage?.cacheRead,
+          cacheCreationTokens: msg.usage?.cacheWrite
+        };
+      }
+    }
+    if (msg.usage && (msg.usage.input || msg.usage.output)) {
+      return {
+        type: "token_usage",
+        inputTokens: msg.usage.input,
+        outputTokens: msg.usage.output,
+        cacheReadTokens: msg.usage.cacheRead,
+        cacheCreationTokens: msg.usage.cacheWrite,
+        model: msg.model
+      };
+    }
+    return null;
+  }
+};
+function getPiSessionsDir() {
+  const candidate = join6(homedir3(), ".pi", "agent", "sessions");
+  return existsSync3(candidate) ? candidate : null;
+}
+function decodePiProjectDir(encoded) {
+  let inner = encoded;
+  if (inner.startsWith("--") && inner.endsWith("--")) {
+    inner = inner.slice(2, -2);
+  }
+  const driveMatch = inner.match(/^([A-Za-z])--(.*)/);
+  if (driveMatch) {
+    const resolved = resolveEncodedPath(driveMatch[1] + ":/", driveMatch[2]);
+    if (resolved)
+      return resolved;
+  } else {
+    const resolved = resolveEncodedPath("/", inner);
+    if (resolved)
+      return resolved;
+  }
+  const parts = inner.split("-").filter(Boolean);
+  if (parts.length <= 2)
+    return parts.join("/");
+  return parts.slice(-2).join("-");
+}
+function parsePiSessionInfo(header, dirName) {
+  const projectName = decodePiProjectDir(dirName);
+  return {
+    agentType: "pi",
+    projectPath: header.cwd || dirName,
+    projectName,
+    isSubagent: !!header.parentSession,
+    projectDir: dirName,
+    parentSessionId: header.parentSession ? extractSessionIdFromPath(header.parentSession) : null
+  };
+}
+function extractSessionIdFromPath(filePath) {
+  const match = filePath.match(/([^/\\]+)\.jsonl$/);
+  if (!match)
+    return null;
+  const parts = match[1].split("_");
+  const uuid = parts[parts.length - 1];
+  return uuid ? `pi:${uuid}` : null;
+}
+var PiWatcher = class {
+  stateManager;
+  watcher = null;
+  byteOffsets = /* @__PURE__ */ new Map();
+  parser = new PiParser();
+  /** Per-file lock to prevent concurrent processFile calls */
+  fileLocks = /* @__PURE__ */ new Map();
+  /** Cached session info per file (parsed from session header) */
+  sessionInfoCache = /* @__PURE__ */ new Map();
+  constructor(stateManager) {
+    this.stateManager = stateManager;
+  }
+  async start() {
+    const sessionsDir = getPiSessionsDir();
+    if (!sessionsDir) {
+      console.log("[pi] No sessions directory found \u2014 pi not installed or not yet used");
+      return;
+    }
+    console.log(`[pi] Sessions directory found at ${sessionsDir}`);
+    const scanner = new SessionScanner(sessionsDir);
+    const existingFiles = await scanner.scan();
+    for (const file of existingFiles) {
+      await this.processFile(file);
+    }
+    const pattern = join7(sessionsDir, "**", "*.jsonl");
+    this.watcher = chokidar3.watch(pattern, {
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
+    });
+    this.watcher.on("add", (filePath) => {
+      console.log(`[pi] New session file: ${filePath}`);
+      this.processFile(filePath);
+    });
+    this.watcher.on("change", (filePath) => {
+      this.processFile(filePath);
+    });
+    console.log(`[pi] Watching for JSONL files in ${sessionsDir}`);
+  }
+  stop() {
+    this.watcher?.close();
+    this.byteOffsets.clear();
+    this.fileLocks.clear();
+    this.sessionInfoCache.clear();
+  }
+  processFile(filePath) {
+    const prev = this.fileLocks.get(filePath) ?? Promise.resolve();
+    const next = prev.then(() => this.doProcessFile(filePath)).catch(() => {
+    }).finally(() => {
+      if (this.fileLocks.get(filePath) === next) {
+        this.fileLocks.delete(filePath);
+      }
+    });
+    this.fileLocks.set(filePath, next);
+  }
+  async doProcessFile(filePath) {
+    try {
+      const fileStats = await stat3(filePath);
+      const currentOffset = this.byteOffsets.get(filePath) ?? 0;
+      if (fileStats.size <= currentOffset)
+        return;
+      const handle = await open2(filePath, "r");
+      try {
+        const buffer = Buffer.alloc(fileStats.size - currentOffset);
+        await handle.read(buffer, 0, buffer.length, currentOffset);
+        this.byteOffsets.set(filePath, fileStats.size);
+        const newContent = buffer.toString("utf-8");
+        const lines = newContent.split("\n").filter((l) => l.trim());
+        const sessionId = this.extractSessionId(filePath);
+        let sessionInfo = this.sessionInfoCache.get(filePath);
+        let hadParsedActivity = false;
+        for (const line of lines) {
+          const raw = this.parser.parseRaw(line);
+          if (!raw)
+            continue;
+          if (!sessionInfo && this.parser.isSessionHeader(raw)) {
+            const dirName = this.getProjectDirName(filePath);
+            sessionInfo = parsePiSessionInfo(raw, dirName);
+            this.sessionInfoCache.set(filePath, sessionInfo);
+            continue;
+          }
+          const parsed = this.parser.parseEntry(raw);
+          if (parsed) {
+            hadParsedActivity = true;
+            if (!sessionInfo) {
+              sessionInfo = this.buildFallbackSession(filePath);
+              this.sessionInfoCache.set(filePath, sessionInfo);
+            }
+            this.stateManager.processMessage(sessionId, parsed, sessionInfo);
+          }
+        }
+        if (!hadParsedActivity && lines.length > 0) {
+          this.stateManager.heartbeat(sessionId);
+        }
+      } finally {
+        await handle.close();
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        console.error(`[pi] Error processing ${filePath}:`, err);
+      }
+    }
+  }
+  /**
+   * Extract a prefixed session ID from a pi session file path.
+   * Filename format: {timestamp}_{uuid}.jsonl
+   */
+  extractSessionId(filePath) {
+    const name = basename2(filePath, ".jsonl");
+    return `pi:${name}`;
+  }
+  buildFallbackSession(filePath) {
+    const dirName = this.getProjectDirName(filePath);
+    const name = dirName.replace(/^--|--$/g, "") || "pi";
+    return createFallbackSession("pi", name);
+  }
+  /**
+   * Get the encoded project directory name from a session file path.
+   * Path: .../sessions/--encoded-path--/{timestamp}_{uuid}.jsonl
+   */
+  getProjectDirName(filePath) {
+    const dir = dirname(filePath).replace(/\\/g, "/");
+    const parts = dir.split("/");
+    return parts[parts.length - 1] || "unknown";
+  }
+};
+var CodexParser = class {
+  /**
+   * Parse a single JSONL line into the envelope structure.
+   */
+  parseRaw(line) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj && typeof obj.type === "string") {
+        return obj;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Try to extract session_meta payload. Returns null if not a session_meta envelope.
+   */
+  tryGetSessionMeta(envelope) {
+    if (envelope.type !== "session_meta")
+      return null;
+    return envelope.payload;
+  }
+  /**
+   * Try to extract model from a turn_context envelope. Returns null otherwise.
+   */
+  tryGetModel(envelope) {
+    if (envelope.type !== "turn_context")
+      return null;
+    const model = envelope.payload?.model;
+    return model ?? null;
+  }
+  /**
+   * Parse a Codex JSONL envelope into a ParsedActivity.
+   * Model is passed in from the watcher (tracked per-file).
+   * Returns null for non-actionable entries.
+   */
+  parseEntry(envelope, model) {
+    if (envelope.type === "response_item") {
+      return this.parseResponseItem(envelope.payload, model);
+    }
+    if (envelope.type === "event_msg") {
+      return this.parseEventMsg(envelope.payload, model);
+    }
+    return null;
+  }
+  parseResponseItem(payload, model) {
+    const itemType = payload.type;
+    if (itemType === "function_call") {
+      const fc = payload;
+      let toolInput = {};
+      try {
+        toolInput = JSON.parse(fc.arguments);
+      } catch {
+      }
+      return {
+        type: "tool_use",
+        toolName: normalizeToolName(fc.name),
+        toolInput: normalizeToolInput(toolInput),
+        model: model ?? void 0
+      };
+    }
+    if (itemType.endsWith("_call") && itemType !== "function_call") {
+      const nativeName = itemType.replace(/_call$/, "");
+      const toolInput = {};
+      const action = payload.action;
+      if (action?.query)
+        toolInput.query = action.query;
+      return {
+        type: "tool_use",
+        toolName: normalizeToolName(nativeName),
+        toolInput,
+        model: model ?? void 0
+      };
+    }
+    return null;
+  }
+  parseEventMsg(payload, model) {
+    const eventType = payload.type;
+    if (eventType === "token_count") {
+      const info = payload.info;
+      if (!info?.last_token_usage)
+        return null;
+      const usage = info.last_token_usage;
+      return {
+        type: "token_usage",
+        inputTokens: usage.input_tokens,
+        outputTokens: (usage.output_tokens ?? 0) + (usage.reasoning_output_tokens ?? 0),
+        cacheReadTokens: usage.cached_input_tokens,
+        model: model ?? void 0
+      };
+    }
+    if (eventType === "agent_message") {
+      const text = payload.message?.trim();
+      if (text && text.length > 0 && text.length < 200) {
+        return { type: "text", text, model: model ?? void 0 };
+      }
+    }
+    if (eventType === "agent_reasoning") {
+      const text = payload.text?.trim();
+      if (!text)
+        return null;
+      return {
+        type: "tool_use",
+        toolName: "thinking",
+        toolInput: { thought: text.slice(0, 120) },
+        model: model ?? void 0
+      };
+    }
+    return null;
+  }
+};
+function getCodexSessionsDir() {
+  const candidate = join8(homedir4(), ".codex", "sessions");
+  return existsSync4(candidate) ? candidate : null;
+}
+var UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/;
+function extractCodexSessionId(filePath) {
+  const name = basename3(filePath, ".jsonl");
+  const match = name.match(UUID_RE);
+  if (match) {
+    return `codex:${match[1]}`;
+  }
+  return `codex:${name}`;
+}
+function parseCodexSessionInfo(meta) {
+  const cwd = meta.cwd || "codex";
+  const parts = cwd.replace(/\\/g, "/").split("/").filter(Boolean);
+  const projectName = parts[parts.length - 1] || "codex";
+  return {
+    agentType: "codex",
+    projectPath: cwd,
+    projectName,
+    isSubagent: false,
+    projectDir: cwd,
+    parentSessionId: null
+  };
+}
+function createCodexSubagentSession(parentSessionId, parentInfo) {
+  return {
+    agentType: "codex",
+    projectPath: parentInfo.projectPath,
+    projectName: parentInfo.projectName,
+    isSubagent: true,
+    projectDir: parentInfo.projectDir,
+    parentSessionId
+  };
+}
+var CodexWatcher = class {
+  stateManager;
+  watcher = null;
+  byteOffsets = /* @__PURE__ */ new Map();
+  parser = new CodexParser();
+  /** Per-file lock to prevent concurrent processFile calls */
+  fileLocks = /* @__PURE__ */ new Map();
+  /** Cached session info per file (parsed from session_meta) */
+  sessionInfoCache = /* @__PURE__ */ new Map();
+  /** Per-file model tracking (from turn_context events) */
+  fileModels = /* @__PURE__ */ new Map();
+  /** Deduplication of spawn_agent call IDs already processed */
+  seenSubagentCalls = /* @__PURE__ */ new Set();
+  /** Counter for generating unique subagent session IDs */
+  subagentCounter = 0;
+  constructor(stateManager) {
+    this.stateManager = stateManager;
+  }
+  async start() {
+    const sessionsDir = getCodexSessionsDir();
+    if (!sessionsDir) {
+      console.log("[codex] No sessions directory found \u2014 Codex CLI not installed or not yet used");
+      return;
+    }
+    console.log(`[codex] Sessions directory found at ${sessionsDir}`);
+    const existingFiles = await this.scanDeep(sessionsDir);
+    for (const file of existingFiles) {
+      await this.processFile(file);
+    }
+    const pattern = join9(sessionsDir, "**", "*.jsonl");
+    const usePolling = process.platform === "win32";
+    this.watcher = chokidar4.watch(pattern, {
+      persistent: true,
+      ignoreInitial: true,
+      usePolling,
+      interval: usePolling ? 500 : void 0,
+      awaitWriteFinish: usePolling ? false : { stabilityThreshold: 200, pollInterval: 50 }
+    });
+    this.watcher.on("add", (filePath) => {
+      console.log(`[codex] New session file: ${filePath}`);
+      this.processFile(filePath);
+    });
+    this.watcher.on("change", (filePath) => {
+      this.processFile(filePath);
+    });
+    console.log(`[codex] Watching for JSONL files in ${sessionsDir} (polling: ${usePolling})`);
+  }
+  stop() {
+    this.watcher?.close();
+    this.byteOffsets.clear();
+    this.fileLocks.clear();
+    this.sessionInfoCache.clear();
+    this.fileModels.clear();
+    this.seenSubagentCalls.clear();
+  }
+  /**
+   * Recursively scan for recently-modified JSONL files under the sessions dir.
+   * Codex nests files as sessions/YYYY/MM/DD/rollout-*.jsonl.
+   */
+  async scanDeep(dir) {
+    const results = [];
+    const now = Date.now();
+    const walk = async (current) => {
+      try {
+        const entries = await readdir2(current, { withFileTypes: true });
+        for (const entry of entries) {
+          const full = join9(current, entry.name);
+          if (entry.isDirectory()) {
+            await walk(full);
+          } else if (entry.name.endsWith(".jsonl")) {
+            try {
+              const s = await stat4(full);
+              if (now - s.mtimeMs < config.activeThresholdMs) {
+                results.push(full);
+              }
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
     };
+    await walk(dir);
+    return results;
+  }
+  processFile(filePath) {
+    const prev = this.fileLocks.get(filePath) ?? Promise.resolve();
+    const next = prev.then(() => this.doProcessFile(filePath)).catch(() => {
+    }).finally(() => {
+      if (this.fileLocks.get(filePath) === next) {
+        this.fileLocks.delete(filePath);
+      }
+    });
+    this.fileLocks.set(filePath, next);
+  }
+  async doProcessFile(filePath) {
+    try {
+      const fileStats = await stat4(filePath);
+      const currentOffset = this.byteOffsets.get(filePath) ?? 0;
+      if (fileStats.size <= currentOffset)
+        return;
+      const handle = await open3(filePath, "r");
+      try {
+        const buffer = Buffer.alloc(fileStats.size - currentOffset);
+        await handle.read(buffer, 0, buffer.length, currentOffset);
+        this.byteOffsets.set(filePath, fileStats.size);
+        const newContent = buffer.toString("utf-8");
+        const lines = newContent.split("\n").filter((l) => l.trim());
+        const sessionId = extractCodexSessionId(filePath);
+        let sessionInfo = this.sessionInfoCache.get(filePath);
+        let hadParsedActivity = false;
+        for (const line of lines) {
+          const envelope = this.parser.parseRaw(line);
+          if (!envelope)
+            continue;
+          if (!sessionInfo) {
+            const meta = this.parser.tryGetSessionMeta(envelope);
+            if (meta) {
+              sessionInfo = parseCodexSessionInfo(meta);
+              this.sessionInfoCache.set(filePath, sessionInfo);
+              continue;
+            }
+          }
+          const model = this.parser.tryGetModel(envelope);
+          if (model) {
+            this.fileModels.set(filePath, model);
+            continue;
+          }
+          const currentModel = this.fileModels.get(filePath) ?? null;
+          const parsed = this.parser.parseEntry(envelope, currentModel);
+          if (parsed) {
+            hadParsedActivity = true;
+            if (!sessionInfo) {
+              sessionInfo = this.buildFallbackSession(filePath);
+              this.sessionInfoCache.set(filePath, sessionInfo);
+            }
+            if (parsed.type === "tool_use" && parsed.toolName === "Agent") {
+              this.handleSubagentSpawn(sessionId, sessionInfo, parsed, envelope.payload);
+            }
+            this.stateManager.processMessage(sessionId, parsed, sessionInfo);
+          }
+        }
+        if (!hadParsedActivity && lines.length > 0) {
+          this.stateManager.heartbeat(sessionId);
+        }
+      } finally {
+        await handle.close();
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        console.error(`[codex] Error processing ${filePath}:`, err);
+      }
+    }
+  }
+  /**
+   * When a spawn_agent tool call is detected, create a synthetic subagent session
+   * so the visualization shows the child agent.
+   */
+  handleSubagentSpawn(parentSessionId, parentInfo, parsed, payload) {
+    const callId = payload.call_id;
+    if (!callId || this.seenSubagentCalls.has(callId))
+      return;
+    this.subagentCounter++;
+    this.seenSubagentCalls.add(callId);
+    const subSessionId = `codex:sub-${parentSessionId.replace("codex:", "")}-${this.subagentCounter}`;
+    const subInfo = createCodexSubagentSession(parentSessionId, parentInfo);
+    const agentName = parsed.toolInput?.agent_type || parsed.toolInput?.message?.slice(0, 30) || `agent-${this.subagentCounter}`;
+    this.stateManager.processMessage(subSessionId, {
+      type: "tool_use",
+      toolName: "thinking",
+      toolInput: { thought: `Subagent: ${agentName}` },
+      model: parsed.model,
+      agentName
+    }, subInfo);
+  }
+  buildFallbackSession(filePath) {
+    const name = basename4(filePath, ".jsonl");
+    return createFallbackSession("codex", name);
   }
 };
 var COOLDOWN_MS = 6e4;
@@ -1169,6 +1799,9 @@ var TaskGraphManager = class {
     if (toolName === "TaskUpdate") {
       return this.handleUpdate(agentId, agentName, toolInput, projectName, root);
     }
+    if (toolName === "TodoWrite" || toolName === "update_plan") {
+      return this.handlePlanUpdate(agentId, agentName, toolInput, projectName, root);
+    }
     return false;
   }
   handleCreate(agentId, agentName, toolInput, projectName, root) {
@@ -1274,6 +1907,83 @@ var TaskGraphManager = class {
     }
     return changed;
   }
+  /**
+   * Handle plan/todo updates from multiple formats:
+   * - Codex update_plan: {plan: [{step: "...", status: "pending"|"in_progress"|"completed"}, ...]}
+   * - Claude Code / OpenCode TodoWrite: {todos: [{id, content, status}, ...]}
+   * Each call replaces the full plan — we sync to create/update tasks accordingly.
+   */
+  handlePlanUpdate(agentId, agentName, toolInput, projectName, root) {
+    const input = toolInput;
+    if (!input)
+      return false;
+    const steps = this.extractPlanSteps(input);
+    if (steps.length === 0)
+      return false;
+    let changed = false;
+    const existingBySubject = /* @__PURE__ */ new Map();
+    for (const [key, task] of this.tasks) {
+      if (key.startsWith(root + "::")) {
+        existingBySubject.set(task.subject, task);
+      }
+    }
+    for (const { subject, status } of steps) {
+      const existing = existingBySubject.get(subject);
+      if (existing) {
+        if (existing.status !== status) {
+          existing.status = status;
+          changed = true;
+        }
+      } else {
+        const count = (this.counters.get(root) ?? 0) + 1;
+        this.counters.set(root, count);
+        const shortId = String(count);
+        const key = this.scopedKey(root, shortId);
+        const node = {
+          id: shortId,
+          subject,
+          status,
+          owner: void 0,
+          agentId,
+          agentName,
+          projectName,
+          blocks: [],
+          blockedBy: [],
+          timestamp: Date.now(),
+          _rootKey: key
+        };
+        this.tasks.set(key, node);
+        existingBySubject.set(subject, node);
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  /**
+   * Extract plan steps from various tool input formats into a common shape.
+   */
+  extractPlanSteps(input) {
+    const planSteps = input.plan;
+    if (Array.isArray(planSteps) && planSteps.length > 0) {
+      return planSteps.filter((s) => s.step?.trim()).map((s) => ({ subject: s.step.trim(), status: this.normalizePlanStatus(s.status) }));
+    }
+    const todos = input.todos;
+    if (Array.isArray(todos) && todos.length > 0) {
+      return todos.filter((t) => t.content?.trim()).map((t) => ({ subject: t.content.trim(), status: this.normalizePlanStatus(t.status) }));
+    }
+    return [];
+  }
+  normalizePlanStatus(status) {
+    if (!status)
+      return "pending";
+    if (status === "in_progress" || status === "in-progress")
+      return "in_progress";
+    if (status === "completed" || status === "done")
+      return "completed";
+    if (status === "deleted" || status === "cancelled")
+      return "deleted";
+    return "pending";
+  }
   /**
    * Mark a task as completed (hook-sourced — TaskCompleted event).
    * Returns true if the status actually changed.
@@ -1495,7 +2205,7 @@ function processToolUseActivity(deps, agent, activity, now) {
   anomalyDetector.setAgentName(agentId, agent.agentName ?? agent.projectName ?? agentId.slice(0, 10));
   anomalyDetector.checkToolUse(agentId, toolName);
   toolChainTracker.recordToolUse(agentId, toolName);
-  if (toolName === "TaskCreate" || toolName === "TaskUpdate") {
+  if (toolName === "TaskCreate" || toolName === "TaskUpdate" || toolName === "TodoWrite") {
     const graphChanged = taskGraphManager.processToolUse(agentId, agent.agentName ?? agentId.slice(0, 10), toolName, activity.toolInput, agent.projectName, agent.rootSessionId);
     if (graphChanged) {
       emit("taskgraph:changed", { data: taskGraphManager.getSnapshot(), timestamp: Date.now() });
@@ -1919,6 +2629,7 @@ var AgentStateManager = class extends EventEmitter2 {
       agent = {
         id: sessionId,
         sessionId,
+        agentType: sessionInfo.agentType,
         rootSessionId,
         projectPath: sessionInfo.projectPath,
         projectName: sessionInfo.projectName,
@@ -2682,12 +3393,12 @@ function buildResponse(decision) {
     }
   };
 }
-var __dirname = dirname(fileURLToPath(import.meta.url));
+var __dirname = dirname2(fileURLToPath(import.meta.url));
 async function main() {
   const app = Fastify({ logger: { level: "info" } });
   await app.register(cors, { origin: true });
   await app.register(websocket);
-  const clientDist = join6(__dirname, "..", "..", "client", "dist");
+  const clientDist = join10(__dirname, "..", "..", "client", "dist");
   await app.register(fastifyStatic, {
     root: clientDist,
     prefix: "/",
@@ -2719,7 +3430,9 @@ async function main() {
   });
   const watchers = [
     new FileWatcher(config.claudeHome, stateManager),
-    ...config.enableOpenCode ? [new OpenCodeWatcher(stateManager)] : []
+    ...config.enableOpenCode ? [new OpenCodeWatcher(stateManager)] : [],
+    ...config.enablePi ? [new PiWatcher(stateManager)] : [],
+    ...config.enableCodex ? [new CodexWatcher(stateManager)] : []
   ];
   for (const w of watchers) {
     await w.start();