@foothill/agent-move 1.0.11 → 1.0.12

package/packages/server/dist/index.js

@@ -1,6 +1,6 @@
 // dist/index.js
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join10 } from "path";
+import { dirname as dirname2, join as join11 } from "path";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import websocket from "@fastify/websocket";
@@ -34,8 +34,13 @@ import { existsSync as existsSync4 } from "fs";
 import { EventEmitter as EventEmitter2 } from "events";
 import { EventEmitter } from "events";
 import { execSync } from "child_process";
-import { EventEmitter as EventEmitter3 } from "events";
 import { randomUUID } from "crypto";
+import { mkdirSync } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir5 } from "os";
+import Database2 from "better-sqlite3";
+import { EventEmitter as EventEmitter3 } from "events";
+import { randomUUID as randomUUID2 } from "crypto";
 var config = {
   port: parseInt(process.env.AGENT_MOVE_PORT || "3333", 10),
   claudeHome: join(homedir(), ".claude"),
@@ -675,6 +680,86 @@ var AGENT_PALETTES = [
   { name: "lime", body: 10275941, outline: 5606191, highlight: 12968357, eye: 3355443, skin: 16767916 },
   { name: "brown", body: 9268835, outline: 5125166, highlight: 12364452, eye: 16777215, skin: 16767916 }
 ];
+var MODEL_PRICING = {
+  // ── Anthropic Claude ────────────────────────────────────────────────────────
+  "claude-opus-4-6": { input: 15, output: 75 },
+  "claude-opus-4-5-20250620": { input: 15, output: 75 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-sonnet-4-5-20250514": { input: 3, output: 15 },
+  "claude-sonnet-4-0-20250514": { input: 3, output: 15 },
+  "claude-haiku-4-5-20251001": { input: 1, output: 5 },
+  "claude-3-7-sonnet-20250219": { input: 3, output: 15 },
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-3-5-haiku-20241022": { input: 1, output: 5 },
+  "claude-3-opus-20240229": { input: 15, output: 75 },
+  // ── OpenAI ──────────────────────────────────────────────────────────────────
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4": { input: 30, output: 60 },
+  "o1": { input: 15, output: 60 },
+  "o1-mini": { input: 1.1, output: 4.4 },
+  "o3": { input: 10, output: 40 },
+  "o3-mini": { input: 1.1, output: 4.4 },
+  "o4-mini": { input: 1.1, output: 4.4 },
+  // ── Google Gemini ───────────────────────────────────────────────────────────
+  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  "gemini-2.5-flash": { input: 0.15, output: 0.6 },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+  "gemini-2.0-flash-lite": { input: 0.075, output: 0.3 },
+  "gemini-1.5-pro": { input: 1.25, output: 5 },
+  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+  // ── DeepSeek ────────────────────────────────────────────────────────────────
+  "deepseek-chat": { input: 0.27, output: 1.1 },
+  // DeepSeek V3
+  "deepseek-reasoner": { input: 0.55, output: 2.19 },
+  // DeepSeek R1
+  // ── xAI Grok ────────────────────────────────────────────────────────────────
+  "grok-3": { input: 3, output: 15 },
+  "grok-3-mini": { input: 0.3, output: 0.5 },
+  "grok-2": { input: 2, output: 10 },
+  // ── Mistral ─────────────────────────────────────────────────────────────────
+  "mistral-large": { input: 2, output: 6 },
+  "mistral-small": { input: 0.1, output: 0.3 },
+  "codestral": { input: 0.1, output: 0.3 }
+};
+var DEFAULT_PRICING = { input: 3, output: 15 };
+function getModelPricing(model) {
+  if (!model)
+    return DEFAULT_PRICING;
+  const m = model.toLowerCase();
+  if (MODEL_PRICING[m])
+    return MODEL_PRICING[m];
+  for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
+    if (m.startsWith(key) || m.includes(key))
+      return pricing;
+  }
+  if (m.includes("opus"))
+    return MODEL_PRICING["claude-opus-4-6"];
+  if (m.includes("haiku"))
+    return MODEL_PRICING["claude-haiku-4-5-20251001"];
+  if (m.includes("sonnet"))
+    return MODEL_PRICING["claude-sonnet-4-6"];
+  if (m.includes("o3-mini") || m.includes("o4-mini"))
+    return MODEL_PRICING["o3-mini"];
+  if (m.includes("o1-mini"))
+    return MODEL_PRICING["o1-mini"];
+  if (m.includes("gemini-2.5"))
+    return MODEL_PRICING["gemini-2.5-pro"];
+  if (m.includes("gemini-2"))
+    return MODEL_PRICING["gemini-2.0-flash"];
+  if (m.includes("gemini"))
+    return MODEL_PRICING["gemini-1.5-pro"];
+  if (m.includes("gpt-4o"))
+    return MODEL_PRICING["gpt-4o"];
+  if (m.includes("deepseek"))
+    return MODEL_PRICING["deepseek-chat"];
+  if (m.includes("grok"))
+    return MODEL_PRICING["grok-3"];
+  if (m.includes("mistral"))
+    return MODEL_PRICING["mistral-large"];
+  return DEFAULT_PRICING;
+}
 function getProjectColorIndex(projectPath) {
   let hash = 0;
   for (let i = 0; i < projectPath.length; i++) {
@@ -682,6 +767,10 @@ function getProjectColorIndex(projectPath) {
   }
   return Math.abs(hash) % AGENT_PALETTES.length;
 }
+function computeAgentCost(tokens) {
+  const pricing = getModelPricing(tokens.model);
+  return tokens.totalInputTokens / 1e6 * pricing.input + tokens.totalOutputTokens / 1e6 * pricing.output + tokens.cacheReadTokens / 1e6 * pricing.input * 0.1 + tokens.cacheCreationTokens / 1e6 * pricing.input * 1.25;
+}
 var OpenCodeParser = class {
   /**
    * Convert an OpenCode part JSON object into a ParsedActivity.
@@ -753,7 +842,7 @@ var OpenCodeParser = class {
     };
   }
 };
-var OpenCodeWatcher = class {
+var OpenCodeWatcher = class _OpenCodeWatcher {
   stateManager;
   watcher = null;
   db = null;
@@ -770,6 +859,19 @@ var OpenCodeWatcher = class {
   seenCallIds = /* @__PURE__ */ new Set();
   /** row id → true — deduplicates text/token events */
   seenIds = /* @__PURE__ */ new Set();
+  /**
+   * Per-session idle timers: after step-finish, if no new step-start
+   * arrives within this window, call hookStop to idle the agent.
+   */
+  stepFinishTimers = /* @__PURE__ */ new Map();
+  static STEP_FINISH_IDLE_MS = 4e3;
+  /**
+   * Per-session shutdown timers: after step-finish, if no new activity
+   * arrives within this longer window, call hookSessionEnd to fully shut
+   * down the agent and finalize the session. This handles /exit and closed terminals.
+   */
+  sessionEndTimers = /* @__PURE__ */ new Map();
+  static SESSION_END_MS = 18e4;
   // Prepared statements (initialised after DB opens)
   stmtAllSessions;
   stmtRecentSessions;
@@ -820,6 +922,12 @@ var OpenCodeWatcher = class {
     this.messages.clear();
     this.seenCallIds.clear();
     this.seenIds.clear();
+    for (const t of this.stepFinishTimers.values())
+      clearTimeout(t);
+    this.stepFinishTimers.clear();
+    for (const t of this.sessionEndTimers.values())
+      clearTimeout(t);
+    this.sessionEndTimers.clear();
   }
   // ── Prepared statements ────────────────────────────────────────────────────
   prepareStatements() {
@@ -908,8 +1016,11 @@ var OpenCodeWatcher = class {
     const activity = this.parser.parseTokenUsage(data);
     if (!activity)
       return;
+    const prefixedId = this.prefixed(row.session_id);
+    this.cancelStepFinishTimer(prefixedId);
+    this.cancelSessionEndTimer(prefixedId);
     const sessionInfo = this.getSessionInfo(row.session_id);
-    this.stateManager.processMessage(this.prefixed(row.session_id), activity, sessionInfo);
+    this.stateManager.processMessage(prefixedId, activity, sessionInfo);
   }
   processPartRow(row) {
     let data;
@@ -923,7 +1034,25 @@ var OpenCodeWatcher = class {
       if (this.seenIds.has(row.id))
         return;
       this.seenIds.add(row.id);
-      this.stateManager.heartbeat(this.prefixed(row.session_id));
+      const prefixedId2 = this.prefixed(row.session_id);
+      if (data.type === "step-start") {
+        this.cancelStepFinishTimer(prefixedId2);
+        this.cancelSessionEndTimer(prefixedId2);
+        this.stateManager.heartbeat(prefixedId2);
+      } else {
+        this.cancelStepFinishTimer(prefixedId2);
+        this.cancelSessionEndTimer(prefixedId2);
+        const idleTimer = setTimeout(() => {
+          this.stepFinishTimers.delete(prefixedId2);
+          this.stateManager.hookStop(prefixedId2);
+        }, _OpenCodeWatcher.STEP_FINISH_IDLE_MS);
+        this.stepFinishTimers.set(prefixedId2, idleTimer);
+        const endTimer = setTimeout(() => {
+          this.sessionEndTimers.delete(prefixedId2);
+          this.stateManager.hookSessionEnd(prefixedId2);
+        }, _OpenCodeWatcher.SESSION_END_MS);
+        this.sessionEndTimers.set(prefixedId2, endTimer);
+      }
       return;
     }
     if (data.type === "tool" && data.callID) {
@@ -938,10 +1067,27 @@ var OpenCodeWatcher = class {
     const activity = this.parser.parsePart(data, messageData);
     if (!activity)
       return;
+    const prefixedId = this.prefixed(row.session_id);
+    this.cancelStepFinishTimer(prefixedId);
+    this.cancelSessionEndTimer(prefixedId);
     const sessionInfo = this.getSessionInfo(row.session_id);
-    this.stateManager.processMessage(this.prefixed(row.session_id), activity, sessionInfo);
+    this.stateManager.processMessage(prefixedId, activity, sessionInfo);
   }
   // ── Helpers ────────────────────────────────────────────────────────────────
+  cancelStepFinishTimer(prefixedId) {
+    const timer = this.stepFinishTimers.get(prefixedId);
+    if (timer) {
+      clearTimeout(timer);
+      this.stepFinishTimers.delete(prefixedId);
+    }
+  }
+  cancelSessionEndTimer(prefixedId) {
+    const timer = this.sessionEndTimers.get(prefixedId);
+    if (timer) {
+      clearTimeout(timer);
+      this.sessionEndTimers.delete(prefixedId);
+    }
+  }
   getSessionInfo(sessionId) {
     const cached = this.sessions.get(sessionId);
     if (cached)
@@ -2095,9 +2241,6 @@ function promoteAgent(deps, agentId) {
   const spawnEvent = { type: "agent:spawn", agent: { ...agent }, timestamp: now };
   recordTimeline(spawnEvent);
   emit("agent:spawn", spawnEvent);
-  const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
-  recordTimeline(updateEvent);
-  emit("agent:update", updateEvent);
 }
 function determineRole(_activity, sessionInfo) {
   if (sessionInfo.isSubagent)
@@ -2172,8 +2315,6 @@ var LONG_RUNNING_TOOLS = /* @__PURE__ */ new Set([
   "WebSearch",
   // Tools that block waiting for user input
   "AskUserQuestion",
-  // Reasoning / extended thinking pseudo-tool (emitted for OpenCode reasoning parts)
-  "thinking",
   // Browser/playwright tools that wait for navigation or network
   "mcp__playwright__browser_navigate",
   "mcp__playwright__browser_wait_for",
@@ -2898,7 +3039,10 @@ var AgentStateManager = class extends EventEmitter2 {
   hookSessionEnd(sessionId) {
     const canonicalId = this.resolveAgentId(sessionId);
     if (this.agents.has(canonicalId)) {
+      console.log(`[hookSessionEnd] Shutting down agent: session=${sessionId.slice(0, 12)}\u2026 canonical=${canonicalId.slice(0, 12)}\u2026`);
       this.shutdown(canonicalId);
+    } else {
+      console.log(`[hookSessionEnd] Agent not found: session=${sessionId.slice(0, 12)}\u2026 canonical=${canonicalId.slice(0, 12)}\u2026 | known agents: [${[...this.agents.keys()].map((k) => k.slice(0, 12)).join(", ")}]`);
     }
   }
   /** Hook: user submitted a prompt — agent is now running */
@@ -3104,27 +3248,12 @@ var Broadcaster = class {
         const fullState = {
           type: "full_state",
           agents: this.stateManager.getAll(),
+          timeline: this.stateManager.getTimeline(),
+          toolchain: this.stateManager.getToolChainSnapshot(),
+          taskgraph: this.stateManager.getTaskGraphSnapshot(),
           timestamp: Date.now()
         };
         ws.send(JSON.stringify(fullState));
-        const timeline = {
-          type: "timeline:snapshot",
-          events: this.stateManager.getTimeline(),
-          timestamp: Date.now()
-        };
-        ws.send(JSON.stringify(timeline));
-        const toolchain = {
-          type: "toolchain:snapshot",
-          data: this.stateManager.getToolChainSnapshot(),
-          timestamp: Date.now()
-        };
-        ws.send(JSON.stringify(toolchain));
-        const taskgraph = {
-          type: "taskgraph:snapshot",
-          data: this.stateManager.getTaskGraphSnapshot(),
-          timestamp: Date.now()
-        };
-        ws.send(JSON.stringify(taskgraph));
       } catch {
         this.clients.delete(ws);
       }
@@ -3238,6 +3367,797 @@ function registerApiRoutes(app, stateManager) {
     return { removed: req.params.id };
   });
 }
+function registerSessionRoutes(app, recorder, stateManager) {
+  const store = recorder.getStore();
+  app.get("/api/sessions/live", async () => {
+    return { sessions: store.listLiveSessions() };
+  });
+  app.get("/api/sessions", async (req) => {
+    const limit = req.query.limit ? parseInt(req.query.limit, 10) : 50;
+    const offset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
+    const sessions = store.listSessions({
+      project: req.query.project,
+      limit,
+      offset
+    });
+    const total = store.getSessionCount(req.query.project);
+    return { sessions, total, limit, offset };
+  });
+  app.get("/api/sessions/compare", async (req, reply) => {
+    const { a, b } = req.query;
+    if (!a || !b)
+      return reply.status(400).send({ error: "Both ?a and ?b session IDs required" });
+    const sessionA = store.getSession(a);
+    const sessionB = store.getSession(b);
+    if (!sessionA)
+      return reply.status(404).send({ error: `Session ${a} not found` });
+    if (!sessionB)
+      return reply.status(404).send({ error: `Session ${b} not found` });
+    const timelineA = store.getTimeline(a);
+    const timelineB = store.getTimeline(b);
+    return {
+      sessionA: { ...sessionA, timeline: timelineA },
+      sessionB: { ...sessionB, timeline: timelineB }
+    };
+  });
+  app.get("/api/sessions/:id", async (req, reply) => {
+    const session = store.getSession(req.params.id);
+    if (!session)
+      return reply.status(404).send({ error: "Session not found" });
+    return session;
+  });
+  app.get("/api/sessions/:id/timeline", async (req, reply) => {
+    const session = store.getSession(req.params.id);
+    if (!session)
+      return reply.status(404).send({ error: "Session not found" });
+    const limit = req.query.limit ? parseInt(req.query.limit, 10) : 1e4;
+    const offset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
+    const timeline = store.getTimeline(req.params.id, { limit, offset });
+    return { timeline };
+  });
+  app.patch("/api/sessions/:id", async (req, reply) => {
+    const body = req.body;
+    let updated = false;
+    if (body.label !== void 0) {
+      updated = store.updateLabel(req.params.id, body.label ?? null) || updated;
+    }
+    if (body.tags) {
+      updated = store.updateTags(req.params.id, body.tags) || updated;
+    }
+    if (!updated)
+      return reply.status(404).send({ error: "Session not found" });
+    return { ok: true };
+  });
+  app.delete("/api/sessions/:id", async (req, reply) => {
+    const deleted = store.deleteSession(req.params.id);
+    if (!deleted)
+      return reply.status(404).send({ error: "Session not found" });
+    return { ok: true };
+  });
+  app.post("/api/sessions/record-current", async (req, reply) => {
+    const body = req.body;
+    let rootId = body?.rootSessionId;
+    if (!rootId) {
+      const agents = stateManager.getAll();
+      if (agents.length === 0) {
+        return reply.status(400).send({ error: "No active agents" });
+      }
+      rootId = agents[0].rootSessionId;
+    }
+    const sessionId = recorder.recordCurrentSession(rootId);
+    if (!sessionId) {
+      return reply.status(400).send({ error: "No session data to record" });
+    }
+    return { sessionId };
+  });
+}
+var DB_DIR = join10(homedir5(), ".agent-move");
+var DB_PATH = join10(DB_DIR, "sessions.db");
+var SCHEMA_VERSION = 2;
+var SessionStore = class {
+  db;
+  constructor(dbPath) {
+    mkdirSync(DB_DIR, { recursive: true });
+    this.db = new Database2(dbPath ?? DB_PATH);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
+    this.initSchema();
+  }
+  initSchema() {
+    this.db.exec(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL)`);
+    const row = this.db.prepare("SELECT version FROM schema_version").get();
+    const currentVersion = row?.version ?? 0;
+    if (currentVersion < SCHEMA_VERSION) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS sessions (
+          id TEXT PRIMARY KEY,
+          source TEXT NOT NULL,
+          root_session_id TEXT NOT NULL,
+          project_name TEXT NOT NULL,
+          project_path TEXT NOT NULL,
+          started_at INTEGER NOT NULL,
+          ended_at INTEGER NOT NULL,
+          duration_ms INTEGER NOT NULL,
+          total_cost REAL NOT NULL DEFAULT 0,
+          total_input_tokens INTEGER NOT NULL DEFAULT 0,
+          total_output_tokens INTEGER NOT NULL DEFAULT 0,
+          total_cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+          total_cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+          total_tool_uses INTEGER NOT NULL DEFAULT 0,
+          agent_count INTEGER NOT NULL DEFAULT 0,
+          model TEXT,
+          label TEXT,
+          tags TEXT NOT NULL DEFAULT '[]',
+          agents_json TEXT NOT NULL DEFAULT '[]',
+          tool_chain_json TEXT NOT NULL DEFAULT '{}'
+        );
+
+        CREATE TABLE IF NOT EXISTS timeline_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          timestamp INTEGER NOT NULL,
+          agent_id TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          zone TEXT,
+          tool TEXT,
+          tool_args TEXT,
+          text_content TEXT,
+          input_tokens INTEGER,
+          output_tokens INTEGER
+        );
+
+        -- Live (in-progress) sessions: written incrementally so data survives crashes
+        CREATE TABLE IF NOT EXISTS live_sessions (
+          root_session_id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          source TEXT NOT NULL DEFAULT 'claude',
+          project_name TEXT NOT NULL,
+          project_path TEXT NOT NULL,
+          started_at INTEGER NOT NULL,
+          last_activity_at INTEGER NOT NULL,
+          agents_json TEXT NOT NULL DEFAULT '[]'
+        );
+
+        CREATE TABLE IF NOT EXISTS live_timeline_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          root_session_id TEXT NOT NULL,
+          timestamp INTEGER NOT NULL,
+          agent_id TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          zone TEXT,
+          tool TEXT,
+          tool_args TEXT,
+          text_content TEXT,
+          input_tokens INTEGER,
+          output_tokens INTEGER
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_timeline_session ON timeline_events(session_id);
+        CREATE INDEX IF NOT EXISTS idx_timeline_timestamp ON timeline_events(session_id, timestamp);
+        CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_name);
+        CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_live_timeline_root ON live_timeline_events(root_session_id);
+      `);
+      if (currentVersion === 0) {
+        this.db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(SCHEMA_VERSION);
+      } else {
+        this.db.prepare("UPDATE schema_version SET version = ?").run(SCHEMA_VERSION);
+      }
+    }
+  }
+  /** Save a complete recorded session with its timeline */
+  saveSession(session, timeline) {
+    const insertSession = this.db.prepare(`
+      INSERT OR REPLACE INTO sessions (
+        id, source, root_session_id, project_name, project_path,
+        started_at, ended_at, duration_ms,
+        total_cost, total_input_tokens, total_output_tokens,
+        total_cache_read_tokens, total_cache_creation_tokens,
+        total_tool_uses, agent_count, model, label, tags,
+        agents_json, tool_chain_json
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+      )
+    `);
+    const insertEvent = this.db.prepare(`
+      INSERT INTO timeline_events (
+        session_id, timestamp, agent_id, kind, zone, tool, tool_args,
+        text_content, input_tokens, output_tokens
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const txn = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM timeline_events WHERE session_id = ?").run(session.id);
+      insertSession.run(session.id, session.source, session.rootSessionId, session.projectName, session.projectPath, session.startedAt, session.endedAt, session.durationMs, session.totalCost, session.totalInputTokens, session.totalOutputTokens, session.totalCacheReadTokens, session.totalCacheCreationTokens, session.totalToolUses, session.agentCount, session.model, session.label, JSON.stringify(session.tags), JSON.stringify(session.agents), JSON.stringify(session.toolChain));
+      for (const evt of timeline) {
+        insertEvent.run(session.id, evt.timestamp, evt.agentId, evt.kind, evt.zone ?? null, evt.tool ?? null, evt.toolArgs ?? null, evt.text ?? null, evt.inputTokens ?? null, evt.outputTokens ?? null);
+      }
+    });
+    txn();
+  }
+  /** List sessions with optional filtering */
+  listSessions(opts) {
+    const limit = opts?.limit ?? 50;
+    const offset = opts?.offset ?? 0;
+    let sql = `SELECT id, source, project_name, started_at, ended_at, duration_ms,
+               total_cost, total_tool_uses, agent_count, model, label, tags
+               FROM sessions`;
+    const params = [];
+    if (opts?.project) {
+      sql += " WHERE project_name = ?";
+      params.push(opts.project);
+    }
+    sql += " ORDER BY started_at DESC LIMIT ? OFFSET ?";
+    params.push(limit, offset);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      id: r.id,
+      source: r.source,
+      projectName: r.project_name,
+      startedAt: r.started_at,
+      endedAt: r.ended_at,
+      durationMs: r.duration_ms,
+      totalCost: r.total_cost,
+      totalToolUses: r.total_tool_uses,
+      agentCount: r.agent_count,
+      model: r.model,
+      label: r.label,
+      tags: JSON.parse(r.tags)
+    }));
+  }
+  /** Get a full session by ID (without timeline) */
+  getSession(id) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    if (!row)
+      return null;
+    return {
+      id: row.id,
+      source: row.source,
+      rootSessionId: row.root_session_id,
+      projectName: row.project_name,
+      projectPath: row.project_path,
+      startedAt: row.started_at,
+      endedAt: row.ended_at,
+      durationMs: row.duration_ms,
+      totalCost: row.total_cost,
+      totalInputTokens: row.total_input_tokens,
+      totalOutputTokens: row.total_output_tokens,
+      totalCacheReadTokens: row.total_cache_read_tokens,
+      totalCacheCreationTokens: row.total_cache_creation_tokens,
+      totalToolUses: row.total_tool_uses,
+      agentCount: row.agent_count,
+      model: row.model,
+      label: row.label,
+      tags: JSON.parse(row.tags),
+      agents: JSON.parse(row.agents_json),
+      toolChain: JSON.parse(row.tool_chain_json)
+    };
+  }
+  /** Get timeline events for a session */
+  getTimeline(sessionId, opts) {
+    const limit = opts?.limit ?? 1e4;
+    const offset = opts?.offset ?? 0;
+    const rows = this.db.prepare(`
+      SELECT timestamp, agent_id, kind, zone, tool, tool_args, text_content,
+             input_tokens, output_tokens
+      FROM timeline_events
+      WHERE session_id = ?
+      ORDER BY timestamp ASC
+      LIMIT ? OFFSET ?
+    `).all(sessionId, limit, offset);
+    return rows.map((r) => ({
+      timestamp: r.timestamp,
+      agentId: r.agent_id,
+      kind: r.kind,
+      ...r.zone && { zone: r.zone },
+      ...r.tool && { tool: r.tool },
+      ...r.tool_args && { toolArgs: r.tool_args },
+      ...r.text_content && { text: r.text_content },
+      ...r.input_tokens != null && { inputTokens: r.input_tokens },
+      ...r.output_tokens != null && { outputTokens: r.output_tokens }
+    }));
+  }
+  /** Delete a session and its timeline */
+  deleteSession(id) {
+    let changed = false;
+    this.db.transaction(() => {
+      this.db.prepare("DELETE FROM timeline_events WHERE session_id = ?").run(id);
+      const result = this.db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+      changed = result.changes > 0;
+    })();
+    return changed;
+  }
+  /** Update session label */
+  updateLabel(id, label) {
+    const result = this.db.prepare("UPDATE sessions SET label = ? WHERE id = ?").run(label, id);
+    return result.changes > 0;
+  }
+  /** Update session tags */
+  updateTags(id, tags) {
+    const result = this.db.prepare("UPDATE sessions SET tags = ? WHERE id = ?").run(JSON.stringify(tags), id);
+    return result.changes > 0;
+  }
+  /** Get total session count (for pagination) */
+  getSessionCount(project) {
+    if (project) {
+      const row2 = this.db.prepare("SELECT COUNT(*) as count FROM sessions WHERE project_name = ?").get(project);
+      return row2.count;
+    }
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM sessions").get();
+    return row.count;
+  }
+  // ── Live session methods (incremental writes for crash safety) ──
+  /** Create or update a live session entry */
+  upsertLiveSession(rootSessionId, data) {
+    this.db.prepare(`
+      INSERT INTO live_sessions (root_session_id, session_id, source, project_name, project_path, started_at, last_activity_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(root_session_id) DO UPDATE SET
+        session_id = excluded.session_id,
+        source = excluded.source,
+        project_name = excluded.project_name,
+        project_path = excluded.project_path,
+        last_activity_at = excluded.last_activity_at
+    `).run(rootSessionId, data.sessionId, data.source, data.projectName, data.projectPath, data.startedAt, Date.now());
+  }
+  /** Update the agent snapshot for a live session */
+  updateLiveAgents(rootSessionId, agentsJson) {
+    this.db.prepare(`
+      UPDATE live_sessions SET agents_json = ?, last_activity_at = ? WHERE root_session_id = ?
+    `).run(agentsJson, Date.now(), rootSessionId);
+  }
+  /** Append a timeline event to the live buffer */
+  appendLiveTimelineEvent(rootSessionId, evt) {
+    this.db.prepare(`
+      INSERT INTO live_timeline_events (root_session_id, timestamp, agent_id, kind, zone, tool, tool_args, text_content, input_tokens, output_tokens)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(rootSessionId, evt.timestamp, evt.agentId, evt.kind, evt.zone ?? null, evt.tool ?? null, evt.toolArgs ?? null, evt.text ?? null, evt.inputTokens ?? null, evt.outputTokens ?? null);
+  }
+  /** Get all live timeline events for a root session */
+  getLiveTimeline(rootSessionId) {
+    const rows = this.db.prepare(`
+      SELECT timestamp, agent_id, kind, zone, tool, tool_args, text_content, input_tokens, output_tokens
+      FROM live_timeline_events WHERE root_session_id = ? ORDER BY timestamp ASC
+    `).all(rootSessionId);
+    return rows.map((r) => ({
+      timestamp: r.timestamp,
+      agentId: r.agent_id,
+      kind: r.kind,
+      ...r.zone && { zone: r.zone },
+      ...r.tool && { tool: r.tool },
+      ...r.tool_args && { toolArgs: r.tool_args },
+      ...r.text_content && { text: r.text_content },
+      ...r.input_tokens != null && { inputTokens: r.input_tokens },
+      ...r.output_tokens != null && { outputTokens: r.output_tokens }
+    }));
+  }
+  /** Remove live session data after finalization (atomic to prevent orphans on crash) */
+  removeLiveSession(rootSessionId) {
+    this.db.transaction(() => {
+      this.db.prepare("DELETE FROM live_timeline_events WHERE root_session_id = ?").run(rootSessionId);
+      this.db.prepare("DELETE FROM live_sessions WHERE root_session_id = ?").run(rootSessionId);
+    })();
+  }
+  /** List currently active (in-progress) live sessions */
+  listLiveSessions() {
+    const rows = this.db.prepare("SELECT root_session_id, source, project_name, started_at, last_activity_at, agents_json FROM live_sessions ORDER BY started_at DESC").all();
+    return rows.map((r) => {
+      let agentCount = 0;
+      try {
+        agentCount = JSON.parse(r.agents_json).length;
+      } catch {
+      }
+      return {
+        rootSessionId: r.root_session_id,
+        source: r.source,
+        projectName: r.project_name,
+        startedAt: r.started_at,
+        lastActivityAt: r.last_activity_at,
+        agentCount
+      };
+    });
+  }
+  /** Get all orphaned live sessions (for crash recovery on startup) */
+  getOrphanedLiveSessions() {
+    return this.db.prepare("SELECT * FROM live_sessions").all().map((r) => ({
+      rootSessionId: r.root_session_id,
+      sessionId: r.session_id,
+      source: r.source,
+      projectName: r.project_name,
+      projectPath: r.project_path,
+      startedAt: r.started_at,
+      lastActivityAt: r.last_activity_at,
+      agentsJson: r.agents_json
+    }));
+  }
+  close() {
+    this.db.close();
+  }
+};
+var FINALIZE_DELAY_MS = 3e3;
+var AGENT_FLUSH_INTERVAL_MS = 3e4;
+var SessionRecorder = class {
+  store;
+  staging = /* @__PURE__ */ new Map();
+  stateManager;
+  flushTimer;
+  constructor(stateManager) {
+    this.stateManager = stateManager;
+    this.store = new SessionStore();
+    this.recoverOrphans();
+    stateManager.on("agent:spawn", (event) => this.onSpawn(event));
+    stateManager.on("agent:update", (event) => this.onUpdate(event));
+    stateManager.on("agent:idle", (event) => this.onIdle(event));
+    stateManager.on("agent:shutdown", (event) => this.onShutdown(event));
+    this.flushTimer = setInterval(() => this.flushAllAgentStates(), AGENT_FLUSH_INTERVAL_MS);
+  }
+  getStore() {
+    return this.store;
+  }
+  /** Record the currently active session (manual trigger) */
+  recordCurrentSession(rootSessionId) {
+    const staging = this.staging.get(rootSessionId);
+    if (!staging)
+      return null;
+    for (const agent of this.stateManager.getAll()) {
+      if (agent.rootSessionId === rootSessionId) {
+        const history = this.stateManager.getHistory(agent.id);
+        staging.agents.set(agent.id, {
+          state: { ...agent },
+          history: [...history],
+          endedAt: Date.now()
+        });
+      }
+    }
+    staging.toolChain = this.stateManager.getToolChainSnapshot();
+    return this.finalize(rootSessionId);
+  }
+  /** Recover orphaned live sessions from DB (previous crash/restart) */
+  recoverOrphans() {
+    const orphans = this.store.getOrphanedLiveSessions();
+    for (const orphan of orphans) {
+      console.log(`Recovering orphaned session: ${orphan.projectName} (root: ${orphan.rootSessionId.slice(0, 12)}...)`);
+      let agents = [];
+      try {
+        agents = JSON.parse(orphan.agentsJson);
+      } catch {
+      }
+      const timeline = this.store.getLiveTimeline(orphan.rootSessionId);
+      const endedAt = orphan.lastActivityAt;
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      let totalCacheRead = 0;
+      let totalCacheCreation = 0;
+      let totalToolUses = 0;
+      let primaryModel = null;
+      for (const ag of agents) {
+        totalInputTokens += ag.totalInputTokens;
+        totalOutputTokens += ag.totalOutputTokens;
+        totalCacheRead += ag.cacheReadTokens;
+        totalCacheCreation += ag.cacheCreationTokens;
+        totalToolUses += ag.toolUseCount;
+        if (!primaryModel && ag.model)
+          primaryModel = ag.model;
+      }
+      if (agents.length === 0) {
+        this.store.removeLiveSession(orphan.rootSessionId);
+        console.log(`Skipped empty orphaned session: ${orphan.rootSessionId.slice(0, 12)}...`);
+        continue;
+      }
+      const sessionId = randomUUID();
+      const totalCost = agents.reduce((sum, ag) => sum + ag.cost, 0);
+      const recorded = {
+        id: sessionId,
+        source: orphan.source,
+        rootSessionId: orphan.rootSessionId,
+        projectName: orphan.projectName,
+        projectPath: orphan.projectPath,
+        startedAt: orphan.startedAt,
+        endedAt,
+        durationMs: endedAt - orphan.startedAt,
+        totalCost,
+        totalInputTokens,
+        totalOutputTokens,
+        totalCacheReadTokens: totalCacheRead,
+        totalCacheCreationTokens: totalCacheCreation,
+        totalToolUses,
+        agentCount: agents.length,
+        model: primaryModel,
+        agents,
+        toolChain: { transitions: [], tools: [], toolCounts: {}, toolSuccesses: {}, toolFailures: {}, toolAvgDuration: {} },
+        label: "(recovered)",
+        tags: []
+      };
+      try {
+        this.store.saveSession(recorded, timeline);
+        console.log(`Recovered session: ${sessionId} (${orphan.projectName}, ${timeline.length} events)`);
+      } catch (err) {
+        console.error("Failed to recover session:", err);
+      }
+      this.store.removeLiveSession(orphan.rootSessionId);
+    }
+  }
+  getOrCreateStaging(agent) {
+    const rootId = agent.rootSessionId;
+    let session = this.staging.get(rootId);
+    if (!session) {
+      const sessionId = randomUUID();
+      const source = rootId.startsWith("oc:") ? "opencode" : "claude";
+      session = {
+        rootSessionId: rootId,
+        sessionId,
+        projectName: agent.projectName,
+        projectPath: agent.projectPath,
+        source,
+        startedAt: agent.spawnedAt,
+        agents: /* @__PURE__ */ new Map(),
+        toolChain: null,
+        finalizeTimer: null
+      };
+      this.staging.set(rootId, session);
+      this.store.upsertLiveSession(rootId, {
+        sessionId,
+        source,
+        projectName: agent.projectName,
+        projectPath: agent.projectPath,
+        startedAt: agent.spawnedAt
+      });
+    }
+    return session;
+  }
+  onSpawn(event) {
+    const agent = event.agent;
+    const session = this.getOrCreateStaging(agent);
+    if (session.finalizeTimer) {
+      clearTimeout(session.finalizeTimer);
+      session.finalizeTimer = null;
+    }
+    const timelineEvent = {
+      timestamp: event.timestamp,
+      agentId: agent.id,
+      kind: "spawn",
+      zone: agent.currentZone
+    };
+    this.store.appendLiveTimelineEvent(session.rootSessionId, timelineEvent);
+  }
+  onUpdate(event) {
+    const agent = event.agent;
+    const session = this.staging.get(agent.rootSessionId);
+    if (!session)
+      return;
+    if (agent.currentTool) {
+      const timelineEvent = {
+        timestamp: event.timestamp,
+        agentId: agent.id,
+        kind: "tool",
+        zone: agent.currentZone,
+        tool: agent.currentTool,
+        toolArgs: agent.currentActivity ?? void 0
+      };
+      this.store.appendLiveTimelineEvent(session.rootSessionId, timelineEvent);
+    }
+  }
+  onIdle(event) {
+    const agent = event.agent;
+    const session = this.staging.get(agent.rootSessionId);
+    if (!session)
+      return;
+    this.store.appendLiveTimelineEvent(session.rootSessionId, {
+      timestamp: event.timestamp,
+      agentId: agent.id,
+      kind: "idle",
+      zone: "idle"
+    });
+  }
+  onShutdown(event) {
+    const agent = event.agent;
+    const rootId = agent.rootSessionId;
+    const session = this.staging.get(rootId);
+    if (!session)
+      return;
+    const history = this.stateManager.getHistory(agent.id);
+    session.agents.set(agent.id, {
+      state: { ...agent },
+      history: [...history],
+      endedAt: event.timestamp
+    });
+    session.toolChain = this.stateManager.getToolChainSnapshot();
+    this.store.appendLiveTimelineEvent(rootId, {
+      timestamp: event.timestamp,
+      agentId: agent.id,
+      kind: "shutdown"
+    });
+    this.flushAgentState(session);
+    const activeAgents = this.stateManager.getAll().filter((a) => a.rootSessionId === rootId && a.id !== agent.id);
+    if (activeAgents.length === 0) {
+      if (session.finalizeTimer)
+        clearTimeout(session.finalizeTimer);
+      session.finalizeTimer = setTimeout(() => {
+        this.finalize(rootId);
+      }, FINALIZE_DELAY_MS);
+    }
+  }
+  /** Flush agent state snapshots to DB for crash safety */
+  flushAgentState(session) {
+    const agents = [];
+    for (const [, staging] of session.agents) {
+      const s = staging.state;
+      agents.push({
+        agentId: s.id,
+        agentName: s.agentName,
+        role: s.role,
+        model: s.model,
+        spawnedAt: s.spawnedAt,
+        endedAt: staging.endedAt,
+        totalInputTokens: s.totalInputTokens,
+        totalOutputTokens: s.totalOutputTokens,
+        cacheReadTokens: s.cacheReadTokens,
+        cacheCreationTokens: s.cacheCreationTokens,
+        toolUseCount: s.toolUseCount,
+        cost: computeAgentCost(s)
+      });
+    }
+    for (const agent of this.stateManager.getAll()) {
+      if (agent.rootSessionId === session.rootSessionId && !session.agents.has(agent.id)) {
+        agents.push({
+          agentId: agent.id,
+          agentName: agent.agentName,
+          role: agent.role,
+          model: agent.model,
+          spawnedAt: agent.spawnedAt,
+          endedAt: Date.now(),
+          totalInputTokens: agent.totalInputTokens,
+          totalOutputTokens: agent.totalOutputTokens,
+          cacheReadTokens: agent.cacheReadTokens,
+          cacheCreationTokens: agent.cacheCreationTokens,
+          toolUseCount: agent.toolUseCount,
+          cost: computeAgentCost(agent)
+        });
+      }
+    }
+    this.store.updateLiveAgents(session.rootSessionId, JSON.stringify(agents));
+  }
+  /** Periodically flush all active sessions' agent states */
+  flushAllAgentStates() {
+    for (const session of this.staging.values()) {
+      this.flushAgentState(session);
+    }
+  }
+  /** Finalize and persist a staged session. Returns the session ID. */
+  finalize(rootSessionId) {
+    const session = this.staging.get(rootSessionId);
+    if (!session) {
+      this.staging.delete(rootSessionId);
+      return null;
+    }
+    if (session.finalizeTimer) {
+      clearTimeout(session.finalizeTimer);
+      session.finalizeTimer = null;
+    }
+    const sessionId = session.sessionId;
+    const now = Date.now();
+    const agents = [];
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheRead = 0;
+    let totalCacheCreation = 0;
+    let totalToolUses = 0;
+    let primaryModel = null;
+    let earliestSpawn = Infinity;
+    let latestEnd = 0;
+    for (const [, staging] of session.agents) {
+      const s = staging.state;
+      const cost = computeAgentCost(s);
+      agents.push({
+        agentId: s.id,
+        agentName: s.agentName,
+        role: s.role,
+        model: s.model,
+        spawnedAt: s.spawnedAt,
+        endedAt: staging.endedAt,
+        totalInputTokens: s.totalInputTokens,
+        totalOutputTokens: s.totalOutputTokens,
+        cacheReadTokens: s.cacheReadTokens,
+        cacheCreationTokens: s.cacheCreationTokens,
+        toolUseCount: s.toolUseCount,
+        cost
+      });
+      totalInputTokens += s.totalInputTokens;
+      totalOutputTokens += s.totalOutputTokens;
+      totalCacheRead += s.cacheReadTokens;
+      totalCacheCreation += s.cacheCreationTokens;
+      totalToolUses += s.toolUseCount;
+      if (s.spawnedAt < earliestSpawn)
+        earliestSpawn = s.spawnedAt;
+      if (staging.endedAt > latestEnd)
+        latestEnd = staging.endedAt;
+      if (s.role === "main" && s.model)
+        primaryModel = s.model;
+      if (!primaryModel && s.model)
+        primaryModel = s.model;
+    }
+    if (agents.length === 0) {
+      this.store.removeLiveSession(rootSessionId);
+      this.staging.delete(rootSessionId);
+      return null;
+    }
+    const endedAt = latestEnd || now;
+    const startedAt = earliestSpawn === Infinity ? session.startedAt : earliestSpawn;
+    const recorded = {
+      id: sessionId,
+      source: session.source,
+      rootSessionId: session.rootSessionId,
+      projectName: session.projectName,
+      projectPath: session.projectPath,
+      startedAt,
+      endedAt,
+      durationMs: endedAt - startedAt,
+      // Sum per-agent costs (each agent already computed with its own model's pricing)
+      totalCost: agents.reduce((sum, ag) => sum + ag.cost, 0),
+      totalInputTokens,
+      totalOutputTokens,
+      totalCacheReadTokens: totalCacheRead,
+      totalCacheCreationTokens: totalCacheCreation,
+      totalToolUses,
+      agentCount: agents.length,
+      model: primaryModel,
+      agents,
+      toolChain: session.toolChain ?? {
+        transitions: [],
+        tools: [],
+        toolCounts: {},
+        toolSuccesses: {},
+        toolFailures: {},
+        toolAvgDuration: {}
+      },
+      label: null,
+      tags: []
+    };
+    const liveTimeline = this.store.getLiveTimeline(rootSessionId);
+    const historyTimeline = this.buildTimelineFromHistory(session);
+    const timeline = historyTimeline.length > 0 ? historyTimeline : liveTimeline;
+    try {
+      this.store.saveSession(recorded, timeline);
+      this.store.removeLiveSession(rootSessionId);
+      console.log(`Session recorded: ${sessionId} (${session.projectName}, ${agents.length} agents, ${totalToolUses} tools, $${recorded.totalCost.toFixed(4)})`);
+    } catch (err) {
+      console.error("Failed to save session:", err);
+      return null;
+    }
+    this.staging.delete(rootSessionId);
+    return sessionId;
+  }
+  /** Build a merged timeline from all agents' activity histories */
+  buildTimelineFromHistory(session) {
+    const events = [];
+    for (const [agentId, staging] of session.agents) {
+      for (const entry of staging.history) {
+        events.push({
+          timestamp: entry.timestamp,
+          agentId,
+          kind: entry.kind,
+          ...entry.zone && { zone: entry.zone },
+          ...entry.tool && { tool: entry.tool },
+          ...entry.toolArgs && { toolArgs: entry.toolArgs },
+          ...entry.text && { text: entry.text },
+          ...entry.inputTokens != null && { inputTokens: entry.inputTokens },
+          ...entry.outputTokens != null && { outputTokens: entry.outputTokens }
+        });
+      }
+    }
+    events.sort((a, b) => a.timestamp - b.timestamp);
+    return events;
+  }
+  dispose() {
+    clearInterval(this.flushTimer);
+    for (const session of this.staging.values()) {
+      if (session.finalizeTimer)
+        clearTimeout(session.finalizeTimer);
+      this.flushAgentState(session);
+    }
+    this.staging.clear();
+    this.store.close();
+  }
+};
 var PERMISSION_TIMEOUT_MS = 5 * 60 * 1e3;
 var HookEventManager = class extends EventEmitter3 {
   stateManager;
@@ -3288,7 +4208,7 @@ var HookEventManager = class extends EventEmitter3 {
   // Private
   // ---------------------------------------------------------------------------
   async handlePermissionRequest(event) {
-    const permissionId = randomUUID();
+    const permissionId = randomUUID2();
     const permission = {
       permissionId,
       sessionId: event.session_id,
@@ -3398,17 +4318,19 @@ async function main() {
   const app = Fastify({ logger: { level: "info" } });
   await app.register(cors, { origin: true });
   await app.register(websocket);
-  const clientDist = join10(__dirname, "..", "..", "client", "dist");
+  const clientDist = join11(__dirname, "..", "..", "client", "dist");
   await app.register(fastifyStatic, {
     root: clientDist,
     prefix: "/",
     wildcard: false
   });
   const stateManager = new AgentStateManager();
+  const sessionRecorder = new SessionRecorder(stateManager);
   const hookManager = new HookEventManager(stateManager);
   const broadcaster = new Broadcaster(stateManager, hookManager);
   registerWsHandler(app, stateManager, broadcaster, hookManager);
   registerApiRoutes(app, stateManager);
+  registerSessionRoutes(app, sessionRecorder, stateManager);
   app.post("/hook", {
     config: { rawBody: false }
   }, async (req, reply) => {
@@ -3456,6 +4378,7 @@ async function main() {
     console.log("Shutting down...");
     for (const w of watchers)
       w.stop();
+    sessionRecorder.dispose();
     hookManager.dispose();
     broadcaster.dispose();
     stateManager.dispose();