@foothill/agent-move 1.0.10 → 1.0.12

package/packages/server/dist/storage/session-recorder.js

@@ -0,0 +1,941 @@
+// dist/storage/session-recorder.js
+import { randomUUID } from "crypto";
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import Database from "better-sqlite3";
+var ZONES = [
+  // Row 0
+  {
+    id: "search",
+    label: "Search",
+    description: "Grep, WebSearch \u2014 Research & lookup",
+    icon: "\u{1F4DA}",
+    color: 15381256,
+    colStart: 0,
+    colSpan: 5,
+    rowStart: 0,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "terminal",
+    label: "Terminal",
+    description: "Bash commands \u2014 Server room",
+    icon: "\u{1F4BB}",
+    color: 2278750,
+    colStart: 5,
+    colSpan: 3,
+    rowStart: 0,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "web",
+    label: "Web",
+    description: "WebFetch, Browser \u2014 Network hub",
+    icon: "\u{1F310}",
+    color: 9133302,
+    colStart: 8,
+    colSpan: 4,
+    rowStart: 0,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  // Row 1
+  {
+    id: "files",
+    label: "Files",
+    description: "Read, Write, Edit, Glob \u2014 File storage",
+    icon: "\u{1F4C1}",
+    color: 3900150,
+    colStart: 0,
+    colSpan: 4,
+    rowStart: 1,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "thinking",
+    label: "Thinking",
+    description: "Planning, Questions \u2014 Conference area",
+    icon: "\u{1F4AD}",
+    color: 16347926,
+    colStart: 4,
+    colSpan: 5,
+    rowStart: 1,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "messaging",
+    label: "Messaging",
+    description: "SendMessage, Teams \u2014 Chat & relax",
+    icon: "\u{1F4AC}",
+    color: 15485081,
+    colStart: 9,
+    colSpan: 3,
+    rowStart: 1,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  // Row 2
+  {
+    id: "spawn",
+    label: "Spawn",
+    description: "Agent spawn/despawn \u2014 Entry portal",
+    icon: "\u{1F300}",
+    color: 11032055,
+    colStart: 0,
+    colSpan: 3,
+    rowStart: 2,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "idle",
+    label: "Idle",
+    description: "Idle agents rest here \u2014 Kitchen & lounge",
+    icon: "\u2615",
+    color: 7041664,
+    colStart: 3,
+    colSpan: 5,
+    rowStart: 2,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "tasks",
+    label: "Tasks",
+    description: "TaskCreate, TaskUpdate \u2014 Kanban & planning",
+    icon: "\u{1F4CB}",
+    color: 1357990,
+    colStart: 8,
+    colSpan: 4,
+    rowStart: 2,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  }
+];
+var ZONE_MAP = new Map(ZONES.map((z) => [z.id, z]));
+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 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 DB_DIR = join(homedir(), ".agent-move");
+var DB_PATH = join(DB_DIR, "sessions.db");
+var SCHEMA_VERSION = 2;
+var SessionStore = class {
+  db;
+  constructor(dbPath) {
+    mkdirSync(DB_DIR, { recursive: true });
+    this.db = new Database(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();
+  }
+};
+export {
+  SessionRecorder
+};