@runtimescope/collector 0.6.2 → 0.7.0

package/dist/chunk-6JZXAFPC.js

@@ -0,0 +1,4616 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/ring-buffer.ts
+var RingBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  buffer;
+  head = 0;
+  _count = 0;
+  get count() {
+    return this._count;
+  }
+  push(item) {
+    this.buffer[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    if (this._count < this.capacity) this._count++;
+  }
+  /** Returns all items from oldest to newest. */
+  toArray() {
+    if (this._count === 0) return [];
+    const result = [];
+    const start = this._count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this._count; i++) {
+      const idx = (start + i) % this.capacity;
+      result.push(this.buffer[idx]);
+    }
+    return result;
+  }
+  /** Returns matching items from newest to oldest (most recent first). */
+  query(predicate) {
+    if (this._count === 0) return [];
+    const result = [];
+    const start = this._count < this.capacity ? 0 : this.head;
+    for (let i = this._count - 1; i >= 0; i--) {
+      const idx = (start + i) % this.capacity;
+      const item = this.buffer[idx];
+      if (predicate(item)) result.push(item);
+    }
+    return result;
+  }
+  clear() {
+    this.buffer = new Array(this.capacity);
+    this.head = 0;
+    this._count = 0;
+  }
+};
+
+// src/store.ts
+var EventStore = class {
+  buffer;
+  sessions = /* @__PURE__ */ new Map();
+  sqliteStore = null;
+  currentProject = null;
+  onEventCallbacks = [];
+  redactor = null;
+  constructor(capacity = 1e4) {
+    this.buffer = new RingBuffer(capacity);
+  }
+  setRedactor(redactor) {
+    this.redactor = redactor;
+  }
+  get eventCount() {
+    return this.buffer.count;
+  }
+  setSqliteStore(store, project) {
+    this.sqliteStore = store;
+    this.currentProject = project;
+  }
+  onEvent(callback) {
+    this.onEventCallbacks.push(callback);
+  }
+  removeEventListener(callback) {
+    const idx = this.onEventCallbacks.indexOf(callback);
+    if (idx !== -1) this.onEventCallbacks.splice(idx, 1);
+  }
+  addEvent(event) {
+    if (this.redactor?.isEnabled()) {
+      event = this.redactor.redactEvent(event);
+    }
+    this.buffer.push(event);
+    if (event.eventType === "session") {
+      const se = event;
+      this.sessions.set(se.sessionId, {
+        sessionId: se.sessionId,
+        appName: se.appName,
+        connectedAt: se.connectedAt,
+        sdkVersion: se.sdkVersion,
+        eventCount: 0,
+        isConnected: true
+      });
+    }
+    const session = this.sessions.get(event.sessionId);
+    if (session) session.eventCount++;
+    if (this.sqliteStore && this.currentProject) {
+      this.sqliteStore.addEvent(event, this.currentProject);
+    }
+    for (const cb of this.onEventCallbacks) {
+      try {
+        cb(event);
+      } catch {
+      }
+    }
+  }
+  getNetworkRequests(filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    return this.buffer.query((e) => {
+      if (e.eventType !== "network") return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      const ne = e;
+      if (ne.timestamp < since) return false;
+      if (filter.urlPattern && !ne.url.includes(filter.urlPattern)) return false;
+      if (filter.status !== void 0 && ne.status !== filter.status) return false;
+      if (filter.method && ne.method.toUpperCase() !== filter.method.toUpperCase())
+        return false;
+      return true;
+    });
+  }
+  getConsoleMessages(filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    return this.buffer.query((e) => {
+      if (e.eventType !== "console") return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      const ce = e;
+      if (ce.timestamp < since) return false;
+      if (filter.level && ce.level !== filter.level) return false;
+      if (filter.search && !ce.message.toLowerCase().includes(filter.search.toLowerCase()))
+        return false;
+      return true;
+    });
+  }
+  getSessionInfo() {
+    return Array.from(this.sessions.values());
+  }
+  markDisconnected(sessionId) {
+    const s = this.sessions.get(sessionId);
+    if (s) s.isConnected = false;
+  }
+  getEventTimeline(filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    const typeSet = filter.eventTypes ? new Set(filter.eventTypes) : null;
+    return this.buffer.toArray().filter((e) => {
+      if (e.timestamp < since) return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      if (typeSet && !typeSet.has(e.eventType)) return false;
+      return true;
+    });
+  }
+  getAllEvents(sinceSeconds, sessionId) {
+    const since = sinceSeconds ? Date.now() - sinceSeconds * 1e3 : 0;
+    return this.buffer.toArray().filter((e) => {
+      if (e.timestamp < since) return false;
+      if (sessionId && e.sessionId !== sessionId) return false;
+      return true;
+    });
+  }
+  getSessionIdsForProject(appName) {
+    return Array.from(this.sessions.values()).filter((s) => s.appName === appName).map((s) => s.sessionId);
+  }
+  getStateEvents(filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    return this.buffer.query((e) => {
+      if (e.eventType !== "state") return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      const se = e;
+      if (se.timestamp < since) return false;
+      if (filter.storeId && se.storeId !== filter.storeId) return false;
+      return true;
+    });
+  }
+  getRenderEvents(filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    return this.buffer.query((e) => {
+      if (e.eventType !== "render") return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      const re = e;
+      if (re.timestamp < since) return false;
+      if (filter.componentName) {
+        const hasMatch = re.profiles.some(
+          (p) => p.componentName.toLowerCase().includes(filter.componentName.toLowerCase())
+        );
+        if (!hasMatch) return false;
+      }
+      return true;
+    });
+  }
+  getPerformanceMetrics(filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    return this.buffer.query((e) => {
+      if (e.eventType !== "performance") return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      const pe = e;
+      if (pe.timestamp < since) return false;
+      if (filter.metricName && pe.metricName !== filter.metricName) return false;
+      return true;
+    });
+  }
+  getDatabaseEvents(filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    return this.buffer.query((e) => {
+      if (e.eventType !== "database") return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      const de = e;
+      if (de.timestamp < since) return false;
+      if (filter.table) {
+        const hasTable = de.tablesAccessed.some(
+          (t) => t.toLowerCase() === filter.table.toLowerCase()
+        );
+        if (!hasTable) return false;
+      }
+      if (filter.minDurationMs !== void 0 && de.duration < filter.minDurationMs) return false;
+      if (filter.search && !de.query.toLowerCase().includes(filter.search.toLowerCase()))
+        return false;
+      if (filter.operation && de.operation !== filter.operation) return false;
+      if (filter.source && de.source !== filter.source) return false;
+      return true;
+    });
+  }
+  getCustomEvents(filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    return this.buffer.query((e) => {
+      if (e.eventType !== "custom") return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      const ce = e;
+      if (ce.timestamp < since) return false;
+      if (filter.name && ce.name !== filter.name) return false;
+      return true;
+    });
+  }
+  // ============================================================
+  // Recon event queries — returns the most recent event of each type
+  // ============================================================
+  getLatestReconEvent(eventType, filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    const results = this.buffer.query((e) => {
+      if (e.eventType !== eventType) return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      if (e.timestamp < since) return false;
+      if (filter.url) {
+        const re = e;
+        if (re.url && !re.url.includes(filter.url)) return false;
+      }
+      return true;
+    });
+    return results[0] ?? null;
+  }
+  getReconEvents(eventType, filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    return this.buffer.query((e) => {
+      if (e.eventType !== eventType) return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      if (e.timestamp < since) return false;
+      if (filter.url) {
+        const re = e;
+        if (re.url && !re.url.includes(filter.url)) return false;
+      }
+      return true;
+    });
+  }
+  getReconMetadata(filter = {}) {
+    return this.getLatestReconEvent("recon_metadata", filter);
+  }
+  getReconDesignTokens(filter = {}) {
+    return this.getLatestReconEvent("recon_design_tokens", filter);
+  }
+  getReconFonts(filter = {}) {
+    return this.getLatestReconEvent("recon_fonts", filter);
+  }
+  getReconLayoutTree(filter = {}) {
+    return this.getLatestReconEvent("recon_layout_tree", filter);
+  }
+  getReconAccessibility(filter = {}) {
+    return this.getLatestReconEvent("recon_accessibility", filter);
+  }
+  getReconComputedStyles(filter = {}) {
+    return this.getReconEvents("recon_computed_styles", filter);
+  }
+  getReconElementSnapshots(filter = {}) {
+    return this.getReconEvents("recon_element_snapshot", filter);
+  }
+  getReconAssetInventory(filter = {}) {
+    return this.getLatestReconEvent("recon_asset_inventory", filter);
+  }
+  clear() {
+    const count = this.buffer.count;
+    this.buffer.clear();
+    this.sessions.clear();
+    return { clearedCount: count };
+  }
+};
+
+// src/sqlite-store.ts
+import Database from "better-sqlite3";
+var SqliteStore = class {
+  db;
+  writeBuffer = [];
+  flushTimer = null;
+  batchSize;
+  insertEventStmt;
+  insertSessionStmt;
+  updateSessionDisconnectedStmt;
+  constructor(options) {
+    this.db = new Database(options.dbPath);
+    this.batchSize = options.batchSize ?? 50;
+    if (options.walMode !== false) {
+      this.db.pragma("journal_mode = WAL");
+    }
+    this.db.pragma("synchronous = NORMAL");
+    this.createSchema();
+    this.insertEventStmt = this.db.prepare(`
+      INSERT INTO events (event_id, session_id, project, event_type, timestamp, data)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    this.insertSessionStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO sessions (
+        session_id, project, app_name, connected_at, sdk_version,
+        event_count, is_connected, build_meta
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    this.updateSessionDisconnectedStmt = this.db.prepare(`
+      UPDATE sessions SET is_connected = 0, disconnected_at = ? WHERE session_id = ?
+    `);
+    const flushInterval = options.flushIntervalMs ?? 100;
+    this.flushTimer = setInterval(() => this.flush(), flushInterval);
+  }
+  createSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        event_id TEXT NOT NULL UNIQUE,
+        session_id TEXT NOT NULL,
+        project TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        data TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+      CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_events_type_timestamp ON events(event_type, timestamp);
+      CREATE INDEX IF NOT EXISTS idx_events_project ON events(project);
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        project TEXT NOT NULL,
+        app_name TEXT NOT NULL,
+        connected_at INTEGER NOT NULL,
+        disconnected_at INTEGER,
+        sdk_version TEXT NOT NULL,
+        event_count INTEGER DEFAULT 0,
+        is_connected INTEGER DEFAULT 1,
+        build_meta TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project);
+
+      CREATE TABLE IF NOT EXISTS session_snapshots (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        project TEXT NOT NULL,
+        label TEXT,
+        metrics TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_snapshots_session ON session_snapshots(session_id);
+      CREATE INDEX IF NOT EXISTS idx_snapshots_project ON session_snapshots(project, created_at);
+    `);
+    this.migrateSessionMetrics();
+  }
+  // --- Write Operations ---
+  addEvent(event, project) {
+    this.writeBuffer.push({ event, project });
+    if (this.writeBuffer.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+  flush() {
+    if (this.writeBuffer.length === 0) return;
+    const batch = this.writeBuffer.splice(0);
+    const insertMany = this.db.transaction(() => {
+      for (const { event, project } of batch) {
+        try {
+          this.insertEventStmt.run(
+            event.eventId,
+            event.sessionId,
+            project,
+            event.eventType,
+            event.timestamp,
+            JSON.stringify(event)
+          );
+        } catch {
+        }
+      }
+    });
+    try {
+      insertMany();
+    } catch (err) {
+      console.error("[RuntimeScope] SQLite flush error:", err.message);
+    }
+  }
+  saveSession(info) {
+    this.insertSessionStmt.run(
+      info.sessionId,
+      info.project,
+      info.appName,
+      info.connectedAt,
+      info.sdkVersion,
+      info.eventCount,
+      info.isConnected ? 1 : 0,
+      info.buildMeta ? JSON.stringify(info.buildMeta) : null
+    );
+  }
+  updateSessionDisconnected(sessionId, disconnectedAt) {
+    this.updateSessionDisconnectedStmt.run(disconnectedAt, sessionId);
+  }
+  saveSessionMetrics(sessionId, project, metrics, label) {
+    this.db.prepare(`
+      INSERT INTO session_snapshots (session_id, project, label, metrics, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(sessionId, project, label ?? null, JSON.stringify(metrics), Date.now());
+  }
+  // --- Read Operations ---
+  getEvents(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter.project) {
+      conditions.push("project = ?");
+      params.push(filter.project);
+    }
+    if (filter.sessionId) {
+      conditions.push("session_id = ?");
+      params.push(filter.sessionId);
+    }
+    if (filter.eventTypes && filter.eventTypes.length > 0) {
+      const placeholders = filter.eventTypes.map(() => "?").join(", ");
+      conditions.push(`event_type IN (${placeholders})`);
+      params.push(...filter.eventTypes);
+    }
+    if (filter.since) {
+      conditions.push("timestamp >= ?");
+      params.push(filter.since);
+    }
+    if (filter.until) {
+      conditions.push("timestamp <= ?");
+      params.push(filter.until);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    params.push(filter.limit ?? 1e3);
+    params.push(filter.offset ?? 0);
+    const rows = this.db.prepare(`SELECT data FROM events ${where} ORDER BY timestamp ASC LIMIT ? OFFSET ?`).all(...params);
+    return rows.map((row) => JSON.parse(row.data));
+  }
+  getEventCount(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter.project) {
+      conditions.push("project = ?");
+      params.push(filter.project);
+    }
+    if (filter.sessionId) {
+      conditions.push("session_id = ?");
+      params.push(filter.sessionId);
+    }
+    if (filter.eventTypes && filter.eventTypes.length > 0) {
+      const placeholders = filter.eventTypes.map(() => "?").join(", ");
+      conditions.push(`event_type IN (${placeholders})`);
+      params.push(...filter.eventTypes);
+    }
+    if (filter.since) {
+      conditions.push("timestamp >= ?");
+      params.push(filter.since);
+    }
+    if (filter.until) {
+      conditions.push("timestamp <= ?");
+      params.push(filter.until);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const row = this.db.prepare(`SELECT COUNT(*) as count FROM events ${where}`).get(...params);
+    return row.count;
+  }
+  getSessions(project, limit = 50) {
+    const rows = this.db.prepare(`
+        SELECT session_id, project, app_name, connected_at, disconnected_at,
+               sdk_version, event_count, is_connected, build_meta
+        FROM sessions
+        WHERE project = ?
+        ORDER BY connected_at DESC
+        LIMIT ?
+      `).all(project, limit);
+    return rows.map((row) => ({
+      sessionId: row.session_id,
+      project: row.project,
+      appName: row.app_name,
+      connectedAt: row.connected_at,
+      disconnectedAt: row.disconnected_at ?? void 0,
+      sdkVersion: row.sdk_version,
+      eventCount: row.event_count,
+      isConnected: row.is_connected === 1,
+      buildMeta: row.build_meta ? JSON.parse(row.build_meta) : void 0
+    }));
+  }
+  getSessionMetrics(sessionId) {
+    const row = this.db.prepare("SELECT metrics FROM session_snapshots WHERE session_id = ? ORDER BY created_at DESC LIMIT 1").get(sessionId);
+    return row ? JSON.parse(row.metrics) : null;
+  }
+  getSessionSnapshots(sessionId) {
+    const rows = this.db.prepare(`
+        SELECT id, session_id, project, label, metrics, created_at
+        FROM session_snapshots
+        WHERE session_id = ?
+        ORDER BY created_at ASC
+      `).all(sessionId);
+    return rows.map((row) => ({
+      id: row.id,
+      sessionId: row.session_id,
+      project: row.project,
+      label: row.label ?? void 0,
+      metrics: JSON.parse(row.metrics),
+      createdAt: row.created_at
+    }));
+  }
+  getSnapshotById(snapshotId) {
+    const row = this.db.prepare("SELECT id, session_id, project, label, metrics, created_at FROM session_snapshots WHERE id = ?").get(snapshotId);
+    if (!row) return null;
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      project: row.project,
+      label: row.label ?? void 0,
+      metrics: JSON.parse(row.metrics),
+      createdAt: row.created_at
+    };
+  }
+  getEventsByType(project, eventType, sinceMs) {
+    const conditions = ["project = ?", "event_type = ?"];
+    const params = [project, eventType];
+    if (sinceMs) {
+      conditions.push("timestamp >= ?");
+      params.push(sinceMs);
+    }
+    const where = conditions.join(" AND ");
+    const rows = this.db.prepare(`SELECT data FROM events WHERE ${where} ORDER BY timestamp ASC LIMIT 1000`).all(...params);
+    return rows.map((row) => JSON.parse(row.data));
+  }
+  // --- Migration ---
+  migrateSessionMetrics() {
+    const hasOldTable = this.db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='session_metrics'"
+    ).get();
+    if (hasOldTable) {
+      this.db.exec(`
+        INSERT OR IGNORE INTO session_snapshots (session_id, project, label, metrics, created_at)
+        SELECT session_id, project, 'auto-disconnect', metrics, created_at
+        FROM session_metrics
+      `);
+      this.db.exec("DROP TABLE session_metrics");
+    }
+  }
+  // --- Maintenance ---
+  deleteOldEvents(beforeTimestamp) {
+    const result = this.db.prepare("DELETE FROM events WHERE timestamp < ?").run(beforeTimestamp);
+    return result.changes;
+  }
+  vacuum() {
+    this.db.exec("VACUUM");
+  }
+  close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+    this.db.close();
+  }
+};
+
+// src/rate-limiter.ts
+var SessionRateLimiter = class {
+  windows = /* @__PURE__ */ new Map();
+  maxPerSecond;
+  maxPerMinute;
+  _droppedTotal = 0;
+  constructor(config = {}) {
+    this.maxPerSecond = config.maxEventsPerSecond ?? Infinity;
+    this.maxPerMinute = config.maxEventsPerMinute ?? Infinity;
+  }
+  get droppedTotal() {
+    return this._droppedTotal;
+  }
+  isEnabled() {
+    return this.maxPerSecond !== Infinity || this.maxPerMinute !== Infinity;
+  }
+  /** Returns true if the event should be accepted, false if rate-limited. */
+  allow(sessionId) {
+    if (!this.isEnabled()) return true;
+    if (this.windows.size > 1e4 && !this.windows.has(sessionId)) {
+      this.prune(6e4);
+      if (this.windows.size > 1e4) {
+        this._droppedTotal++;
+        return false;
+      }
+    }
+    const now = Date.now();
+    let w = this.windows.get(sessionId);
+    if (!w) {
+      w = {
+        secondCount: 0,
+        secondStart: now,
+        minuteCount: 0,
+        minuteStart: now,
+        lastWarning: 0
+      };
+      this.windows.set(sessionId, w);
+    }
+    if (now - w.secondStart >= 1e3) {
+      w.secondCount = 0;
+      w.secondStart = now;
+    }
+    if (now - w.minuteStart >= 6e4) {
+      w.minuteCount = 0;
+      w.minuteStart = now;
+    }
+    if (w.secondCount >= this.maxPerSecond) {
+      this._droppedTotal++;
+      this.maybeWarn(sessionId, w, now);
+      return false;
+    }
+    if (w.minuteCount >= this.maxPerMinute) {
+      this._droppedTotal++;
+      this.maybeWarn(sessionId, w, now);
+      return false;
+    }
+    w.secondCount++;
+    w.minuteCount++;
+    return true;
+  }
+  /** Allow a batch of N events. Returns the number accepted. */
+  allowBatch(sessionId, count) {
+    let accepted = 0;
+    for (let i = 0; i < count; i++) {
+      if (this.allow(sessionId)) accepted++;
+      else break;
+    }
+    return accepted;
+  }
+  /** Remove tracking for sessions that haven't been seen in maxAgeMs. */
+  prune(maxAgeMs = 3e5) {
+    const cutoff = Date.now() - maxAgeMs;
+    for (const [id, w] of this.windows) {
+      if (w.minuteStart < cutoff) {
+        this.windows.delete(id);
+      }
+    }
+  }
+  maybeWarn(sessionId, w, now) {
+    if (now - w.lastWarning >= 6e4) {
+      w.lastWarning = now;
+      console.error(
+        `[RuntimeScope] Rate limiting session ${sessionId.slice(0, 8)}... (dropped ${this._droppedTotal} total)`
+      );
+    }
+  }
+};
+
+// src/tls.ts
+import { readFileSync } from "fs";
+function loadTlsOptions(config) {
+  return {
+    cert: readFileSync(config.certPath, "utf-8"),
+    key: readFileSync(config.keyPath, "utf-8"),
+    ...config.caPath ? { ca: readFileSync(config.caPath, "utf-8") } : {}
+  };
+}
+function resolveTlsConfig() {
+  const certPath = process.env.RUNTIMESCOPE_TLS_CERT;
+  const keyPath = process.env.RUNTIMESCOPE_TLS_KEY;
+  if (!certPath || !keyPath) return null;
+  return {
+    certPath,
+    keyPath,
+    caPath: process.env.RUNTIMESCOPE_TLS_CA
+  };
+}
+
+// src/server.ts
+import { createServer as createHttpsServer } from "https";
+import { WebSocketServer } from "ws";
+var CollectorServer = class {
+  wss = null;
+  store;
+  projectManager;
+  authManager = null;
+  rateLimiter;
+  clients = /* @__PURE__ */ new Map();
+  pendingHandshakes = /* @__PURE__ */ new Set();
+  pendingCommands = /* @__PURE__ */ new Map();
+  sqliteStores = /* @__PURE__ */ new Map();
+  connectCallbacks = [];
+  disconnectCallbacks = [];
+  pruneTimer = null;
+  tlsConfig = null;
+  constructor(options = {}) {
+    this.store = new EventStore(options.bufferSize ?? 1e4);
+    this.projectManager = options.projectManager ?? null;
+    this.authManager = options.authManager ?? null;
+    this.rateLimiter = new SessionRateLimiter(options.rateLimits ?? {});
+    this.tlsConfig = options.tls ?? null;
+    if (this.projectManager) {
+      this.projectManager.ensureGlobalDir();
+    }
+    if (this.rateLimiter.isEnabled()) {
+      this.pruneTimer = setInterval(() => this.rateLimiter.prune(), 6e4);
+    }
+  }
+  getStore() {
+    return this.store;
+  }
+  getPort() {
+    const addr = this.wss?.address();
+    return addr && typeof addr === "object" ? addr.port : null;
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  getProjectManager() {
+    return this.projectManager;
+  }
+  getSqliteStore(projectName) {
+    return this.sqliteStores.get(projectName);
+  }
+  getSqliteStores() {
+    return this.sqliteStores;
+  }
+  getRateLimiter() {
+    return this.rateLimiter;
+  }
+  onConnect(cb) {
+    this.connectCallbacks.push(cb);
+  }
+  onDisconnect(cb) {
+    this.disconnectCallbacks.push(cb);
+  }
+  start(options = {}) {
+    const port = options.port ?? 9090;
+    const host = options.host ?? "127.0.0.1";
+    const maxRetries = options.maxRetries ?? 5;
+    const retryDelayMs = options.retryDelayMs ?? 1e3;
+    const tls = options.tls ?? this.tlsConfig;
+    return this.tryStart(port, host, maxRetries, retryDelayMs, tls);
+  }
+  tryStart(port, host, retriesLeft, retryDelayMs, tls) {
+    return new Promise((resolve2, reject) => {
+      let wss;
+      if (tls) {
+        const httpsServer = createHttpsServer(loadTlsOptions(tls));
+        wss = new WebSocketServer({ server: httpsServer });
+        httpsServer.on("listening", () => {
+          this.wss = wss;
+          this.setupConnectionHandler(wss);
+          console.error(`[RuntimeScope] Collector listening on wss://${host}:${port}`);
+          resolve2();
+        });
+        httpsServer.on("error", (err) => {
+          httpsServer.close();
+          this.handleStartError(err, port, host, retriesLeft, retryDelayMs, tls, resolve2, reject);
+        });
+        httpsServer.listen(port, host);
+      } else {
+        wss = new WebSocketServer({ port, host });
+        wss.on("listening", () => {
+          this.wss = wss;
+          this.setupConnectionHandler(wss);
+          console.error(`[RuntimeScope] Collector listening on ws://${host}:${port}`);
+          resolve2();
+        });
+        wss.on("error", (err) => {
+          wss.close();
+          this.handleStartError(err, port, host, retriesLeft, retryDelayMs, tls, resolve2, reject);
+        });
+      }
+    });
+  }
+  handleStartError(err, port, host, retriesLeft, retryDelayMs, tls, resolve2, reject) {
+    if (err.code === "EADDRINUSE" && retriesLeft > 0) {
+      console.error(
+        `[RuntimeScope] Port ${port} in use, retrying in ${retryDelayMs}ms (${retriesLeft} attempts left)...`
+      );
+      setTimeout(() => {
+        this.tryStart(port, host, retriesLeft - 1, retryDelayMs, tls).then(resolve2).catch(reject);
+      }, retryDelayMs);
+    } else {
+      console.error("[RuntimeScope] WebSocket server error:", err.message);
+      reject(err);
+    }
+  }
+  ensureSqliteStore(projectName) {
+    if (!this.projectManager) return null;
+    let sqliteStore = this.sqliteStores.get(projectName);
+    if (!sqliteStore) {
+      try {
+        this.projectManager.ensureProjectDir(projectName);
+        const dbPath = this.projectManager.getProjectDbPath(projectName);
+        sqliteStore = new SqliteStore({ dbPath });
+        this.sqliteStores.set(projectName, sqliteStore);
+        this.store.setSqliteStore(sqliteStore, projectName);
+        console.error(`[RuntimeScope] SQLite store opened for project "${projectName}"`);
+      } catch (err) {
+        console.error(
+          `[RuntimeScope] Failed to open SQLite for "${projectName}":`,
+          err.message
+        );
+        return null;
+      }
+    }
+    return sqliteStore;
+  }
+  setupConnectionHandler(wss) {
+    wss.on("connection", (ws) => {
+      if (this.authManager?.isEnabled()) {
+        this.pendingHandshakes.add(ws);
+        const authTimeout = setTimeout(() => {
+          if (this.pendingHandshakes.has(ws)) {
+            this.pendingHandshakes.delete(ws);
+            try {
+              ws.send(JSON.stringify({
+                type: "error",
+                payload: { code: "AUTH_TIMEOUT", message: "Handshake timeout" },
+                timestamp: Date.now()
+              }));
+            } catch {
+            }
+            ws.close(4001, "Authentication timeout");
+          }
+        }, 5e3);
+        ws.on("close", () => {
+          clearTimeout(authTimeout);
+          this.pendingHandshakes.delete(ws);
+        });
+      }
+      ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this.handleMessage(ws, msg);
+        } catch {
+          console.error("[RuntimeScope] Malformed WebSocket message, ignoring");
+        }
+      });
+      ws.on("close", () => {
+        const clientInfo = this.clients.get(ws);
+        if (clientInfo) {
+          this.store.markDisconnected(clientInfo.sessionId);
+          const sqliteStore = this.sqliteStores.get(clientInfo.projectName);
+          if (sqliteStore) {
+            sqliteStore.updateSessionDisconnected(clientInfo.sessionId, Date.now());
+          }
+          console.error(`[RuntimeScope] Session ${clientInfo.sessionId} disconnected`);
+          for (const cb of this.disconnectCallbacks) {
+            try {
+              cb(clientInfo.sessionId, clientInfo.projectName);
+            } catch {
+            }
+          }
+        }
+        this.clients.delete(ws);
+      });
+      ws.on("error", (err) => {
+        console.error("[RuntimeScope] WebSocket client error:", err.message);
+      });
+    });
+  }
+  handleMessage(ws, msg) {
+    switch (msg.type) {
+      case "handshake": {
+        const payload = msg.payload;
+        if (this.authManager?.isEnabled()) {
+          if (!this.authManager.isAuthorized(payload.authToken)) {
+            try {
+              ws.send(JSON.stringify({
+                type: "error",
+                payload: { code: "AUTH_FAILED", message: "Invalid or missing API key" },
+                timestamp: Date.now()
+              }));
+            } catch {
+            }
+            ws.close(4001, "Authentication failed");
+            return;
+          }
+          this.pendingHandshakes.delete(ws);
+        }
+        const projectName = payload.appName;
+        this.clients.set(ws, {
+          sessionId: payload.sessionId,
+          projectName
+        });
+        const sqliteStore = this.ensureSqliteStore(projectName);
+        if (sqliteStore) {
+          const sessionInfo = {
+            sessionId: payload.sessionId,
+            project: projectName,
+            appName: payload.appName,
+            connectedAt: msg.timestamp,
+            sdkVersion: payload.sdkVersion,
+            eventCount: 0,
+            isConnected: true
+          };
+          sqliteStore.saveSession(sessionInfo);
+        }
+        console.error(
+          `[RuntimeScope] Session ${payload.sessionId} connected (${payload.appName} v${payload.sdkVersion})`
+        );
+        for (const cb of this.connectCallbacks) {
+          try {
+            cb(payload.sessionId, projectName);
+          } catch {
+          }
+        }
+        break;
+      }
+      case "event": {
+        if (this.pendingHandshakes.has(ws)) return;
+        const clientInfo = this.clients.get(ws);
+        const payload = msg.payload;
+        if (Array.isArray(payload.events)) {
+          for (const event of payload.events) {
+            if (clientInfo && !this.rateLimiter.allow(clientInfo.sessionId)) {
+              break;
+            }
+            this.store.addEvent(event);
+          }
+        }
+        break;
+      }
+      case "command_response": {
+        const resp = msg;
+        const pending = this.pendingCommands.get(resp.requestId);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingCommands.delete(resp.requestId);
+          pending.resolve(resp.payload);
+        }
+        break;
+      }
+      case "heartbeat":
+        break;
+    }
+  }
+  /** Find the WebSocket for a given sessionId */
+  findWsBySessionId(sessionId) {
+    for (const [ws, info] of this.clients) {
+      if (info.sessionId === sessionId) return ws;
+    }
+    return void 0;
+  }
+  /** Get the first connected session ID (for single-app use) */
+  getFirstSessionId() {
+    for (const [, info] of this.clients) {
+      return info.sessionId;
+    }
+    return void 0;
+  }
+  /** Get the project name for a session */
+  getProjectForSession(sessionId) {
+    for (const [, info] of this.clients) {
+      if (info.sessionId === sessionId) return info.projectName;
+    }
+    return void 0;
+  }
+  /** Get all connected session IDs with their project names */
+  getConnectedSessions() {
+    const sessions = [];
+    for (const [, info] of this.clients) {
+      sessions.push({ sessionId: info.sessionId, projectName: info.projectName });
+    }
+    return sessions;
+  }
+  /** Send a command to the SDK and await the response */
+  sendCommand(sessionId, command, timeoutMs = 1e4) {
+    return new Promise((resolve2, reject) => {
+      const ws = this.findWsBySessionId(sessionId);
+      if (!ws || ws.readyState !== 1) {
+        reject(new Error(`No active WebSocket for session ${sessionId}`));
+        return;
+      }
+      const timer = setTimeout(() => {
+        this.pendingCommands.delete(command.requestId);
+        reject(new Error(`Command ${command.command} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pendingCommands.set(command.requestId, { resolve: resolve2, reject, timer });
+      try {
+        ws.send(JSON.stringify({
+          type: "command",
+          payload: command,
+          timestamp: Date.now(),
+          sessionId
+        }));
+      } catch (err) {
+        clearTimeout(timer);
+        this.pendingCommands.delete(command.requestId);
+        reject(err);
+      }
+    });
+  }
+  stop() {
+    if (this.pruneTimer) {
+      clearInterval(this.pruneTimer);
+      this.pruneTimer = null;
+    }
+    for (const [name, sqliteStore] of this.sqliteStores) {
+      try {
+        sqliteStore.close();
+        console.error(`[RuntimeScope] SQLite store closed for "${name}"`);
+      } catch {
+      }
+    }
+    this.sqliteStores.clear();
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+      console.error("[RuntimeScope] Collector stopped");
+    }
+  }
+};
+
+// src/project-manager.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_GLOBAL_CONFIG = {
+  defaultPort: 9090,
+  bufferSize: 1e4,
+  httpPort: 9091
+};
+var ProjectManager = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? join(homedir(), ".runtimescope");
+  }
+  get rootDir() {
+    return this.baseDir;
+  }
+  // --- Directory helpers ---
+  getProjectDir(projectName) {
+    const safe = projectName.replace(/[^a-zA-Z0-9_.-]/g, "_");
+    if (!safe || safe === "." || safe === "..") {
+      return join(this.baseDir, "projects", "_invalid");
+    }
+    return join(this.baseDir, "projects", safe);
+  }
+  getProjectDbPath(projectName) {
+    return join(this.getProjectDir(projectName), "events.db");
+  }
+  // --- Lifecycle (idempotent) ---
+  ensureGlobalDir() {
+    this.mkdirp(this.baseDir);
+    this.mkdirp(join(this.baseDir, "projects"));
+    const configPath = join(this.baseDir, "config.json");
+    if (!existsSync(configPath)) {
+      this.writeJson(configPath, DEFAULT_GLOBAL_CONFIG);
+    }
+  }
+  ensureProjectDir(projectName) {
+    const projectDir = this.getProjectDir(projectName);
+    this.mkdirp(projectDir);
+    const configPath = join(projectDir, "config.json");
+    if (!existsSync(configPath)) {
+      const config = {
+        name: projectName,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        settings: {
+          retentionDays: 30
+        }
+      };
+      this.writeJson(configPath, config);
+    }
+  }
+  // --- Config ---
+  getGlobalConfig() {
+    const configPath = join(this.baseDir, "config.json");
+    if (!existsSync(configPath)) return { ...DEFAULT_GLOBAL_CONFIG };
+    return { ...DEFAULT_GLOBAL_CONFIG, ...this.readJson(configPath) };
+  }
+  saveGlobalConfig(config) {
+    this.writeJson(join(this.baseDir, "config.json"), config);
+  }
+  getProjectConfig(projectName) {
+    const configPath = join(this.getProjectDir(projectName), "config.json");
+    if (!existsSync(configPath)) return null;
+    return this.readJson(configPath);
+  }
+  saveProjectConfig(projectName, config) {
+    this.writeJson(join(this.getProjectDir(projectName), "config.json"), config);
+  }
+  getInfrastructureConfig(projectName) {
+    const jsonPath = join(this.getProjectDir(projectName), "infrastructure.json");
+    if (existsSync(jsonPath)) {
+      const config = this.readJson(jsonPath);
+      return this.resolveConfigEnvVars(config);
+    }
+    const yamlPath = join(this.getProjectDir(projectName), "infrastructure.yaml");
+    if (existsSync(yamlPath)) {
+      try {
+        const content = readFileSync2(yamlPath, "utf-8");
+        return this.resolveConfigEnvVars(this.parseSimpleYaml(content));
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  getClaudeInstructions(projectName) {
+    const filePath = join(this.getProjectDir(projectName), "claude-instructions.md");
+    if (!existsSync(filePath)) return null;
+    return readFileSync2(filePath, "utf-8");
+  }
+  // --- Discovery ---
+  listProjects() {
+    const projectsDir = join(this.baseDir, "projects");
+    if (!existsSync(projectsDir)) return [];
+    return readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  }
+  projectExists(projectName) {
+    return existsSync(this.getProjectDir(projectName));
+  }
+  // --- Environment variable resolution ---
+  resolveEnvVars(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
+      return process.env[varName] ?? "";
+    });
+  }
+  // --- Private helpers ---
+  mkdirp(dir) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  readJson(path) {
+    const content = readFileSync2(path, "utf-8");
+    return JSON.parse(content);
+  }
+  writeJson(path, data) {
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  }
+  resolveConfigEnvVars(config) {
+    const resolve2 = (obj) => {
+      if (typeof obj === "string") return this.resolveEnvVars(obj);
+      if (Array.isArray(obj)) return obj.map(resolve2);
+      if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+          result[key] = resolve2(value);
+        }
+        return result;
+      }
+      return obj;
+    };
+    return resolve2(config);
+  }
+  /**
+   * Minimal YAML parser for simple infrastructure config files.
+   * Handles flat key-value pairs and one level of nesting.
+   * For full YAML support, install js-yaml.
+   */
+  parseSimpleYaml(content) {
+    try {
+      const yaml = __require("js-yaml");
+      return yaml.load(content);
+    } catch {
+      try {
+        return JSON.parse(content);
+      } catch {
+        return {};
+      }
+    }
+  }
+};
+
+// src/auth.ts
+import { randomBytes, timingSafeEqual } from "crypto";
+var AuthManager = class {
+  keys = /* @__PURE__ */ new Map();
+  enabled;
+  constructor(config = {}) {
+    this.enabled = config.enabled ?? false;
+    for (const entry of config.apiKeys ?? []) {
+      this.keys.set(entry.key, entry);
+    }
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  /** Validate an API key. Returns the entry if valid, null if invalid. */
+  validate(key) {
+    if (!this.enabled) return null;
+    if (!key) return null;
+    for (const [storedKey, entry] of this.keys) {
+      if (this.safeCompare(key, storedKey)) {
+        return entry;
+      }
+    }
+    return null;
+  }
+  /** Check if request is authorized. Returns true if auth is disabled or key is valid. */
+  isAuthorized(key) {
+    if (!this.enabled) return true;
+    return this.validate(key) !== null;
+  }
+  /** Extract bearer token from Authorization header value. */
+  static extractBearer(header) {
+    if (!header) return void 0;
+    const match = header.match(/^Bearer\s+(\S+)$/i);
+    return match?.[1];
+  }
+  /** Constant-time string comparison to prevent timing attacks. */
+  safeCompare(a, b) {
+    if (a.length !== b.length) return false;
+    try {
+      return timingSafeEqual(Buffer.from(a, "utf-8"), Buffer.from(b, "utf-8"));
+    } catch {
+      return false;
+    }
+  }
+};
+function generateApiKey(label, project) {
+  return {
+    key: randomBytes(32).toString("hex"),
+    label,
+    project,
+    createdAt: Date.now()
+  };
+}
+
+// src/redactor.ts
+var BUILT_IN_RULES = [
+  {
+    name: "jwt",
+    pattern: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+/g,
+    replacement: "[REDACTED:jwt]"
+  },
+  {
+    name: "credit_card",
+    pattern: /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g,
+    replacement: "[REDACTED:cc]"
+  },
+  {
+    name: "ssn",
+    pattern: /\b\d{3}-\d{2}-\d{4}\b/g,
+    replacement: "[REDACTED:ssn]"
+  },
+  {
+    name: "email",
+    pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z]{2,}\b/gi,
+    replacement: "[REDACTED:email]"
+  },
+  {
+    name: "bearer_token",
+    pattern: /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
+    replacement: "Bearer [REDACTED]"
+  },
+  {
+    name: "api_key_param",
+    pattern: /(?:api[_-]?key|apikey|secret|token|password|passwd|authorization)=[^&\s"']+/gi,
+    replacement: "[REDACTED:param]"
+  }
+];
+var DEFAULT_SENSITIVE_KEYS = [
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "accessToken",
+  "refreshToken",
+  "apiKey",
+  "api_key",
+  "authorization",
+  "credit_card",
+  "creditCard",
+  "ssn",
+  "socialSecurity"
+];
+var Redactor = class {
+  rules;
+  sensitiveKeyPattern;
+  enabled;
+  constructor(config = {}) {
+    this.enabled = config.enabled ?? true;
+    this.rules = [];
+    if (config.useBuiltIn !== false) {
+      this.rules.push(...BUILT_IN_RULES);
+    }
+    if (config.rules) {
+      this.rules.push(...config.rules);
+    }
+    const keys = config.sensitiveKeys ?? DEFAULT_SENSITIVE_KEYS;
+    this.sensitiveKeyPattern = keys.length > 0 ? new RegExp(`^(${keys.join("|")})$`, "i") : null;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  /** Apply all redaction rules to a string value. */
+  redactString(value) {
+    let result = value;
+    for (const rule of this.rules) {
+      rule.pattern.lastIndex = 0;
+      result = result.replace(rule.pattern, rule.replacement);
+    }
+    return result;
+  }
+  /**
+   * Deep-walk an event and redact all string fields.
+   * Returns a new event object (does not mutate the original).
+   */
+  redactEvent(event) {
+    if (!this.enabled) return event;
+    return this.deepRedact(event);
+  }
+  deepRedact(value, key) {
+    if (value === null || value === void 0) return value;
+    if (key && this.sensitiveKeyPattern?.test(key)) {
+      return "[REDACTED]";
+    }
+    if (typeof value === "string") {
+      return this.redactString(value);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.deepRedact(item));
+    }
+    if (typeof value === "object") {
+      const result = {};
+      for (const [k, v] of Object.entries(value)) {
+        result[k] = this.deepRedact(v, k);
+      }
+      return result;
+    }
+    return value;
+  }
+};
+
+// src/session-manager.ts
+var SessionManager = class {
+  projectManager;
+  sqliteStores;
+  store;
+  constructor(projectManager, sqliteStores, store) {
+    this.projectManager = projectManager;
+    this.sqliteStores = sqliteStores;
+    this.store = store;
+  }
+  computeMetrics(sessionId, project, events) {
+    const sessionEvents = events.filter((e) => e.sessionId === sessionId);
+    const networkEvents = sessionEvents.filter((e) => e.eventType === "network");
+    const renderEvents = sessionEvents.filter((e) => e.eventType === "render");
+    const stateEvents = sessionEvents.filter((e) => e.eventType === "state");
+    const performanceEvents = sessionEvents.filter((e) => e.eventType === "performance");
+    const databaseEvents = sessionEvents.filter((e) => e.eventType === "database");
+    const consoleEvents = sessionEvents.filter((e) => e.eventType === "console");
+    const endpoints = {};
+    const endpointGroups = /* @__PURE__ */ new Map();
+    for (const e of networkEvents) {
+      const key = `${e.method} ${e.url}`;
+      const group = endpointGroups.get(key) ?? [];
+      group.push(e);
+      endpointGroups.set(key, group);
+    }
+    for (const [key, group] of endpointGroups) {
+      const avgLatency = group.reduce((s, e) => s + e.duration, 0) / group.length;
+      const errorCount2 = group.filter((e) => e.status >= 400).length;
+      endpoints[key] = { avgLatency, errorRate: errorCount2 / group.length, callCount: group.length };
+    }
+    const components = {};
+    for (const re of renderEvents) {
+      for (const p of re.profiles) {
+        const existing = components[p.componentName];
+        if (existing) {
+          existing.renderCount += p.renderCount;
+          existing.avgDuration = (existing.avgDuration + p.avgDuration) / 2;
+        } else {
+          components[p.componentName] = { renderCount: p.renderCount, avgDuration: p.avgDuration };
+        }
+      }
+    }
+    const stores = {};
+    for (const se of stateEvents) {
+      const existing = stores[se.storeId];
+      if (existing) {
+        existing.updateCount++;
+      } else {
+        stores[se.storeId] = { updateCount: 1 };
+      }
+    }
+    const webVitals = {};
+    for (const pe of performanceEvents) {
+      if (pe.rating) {
+        webVitals[pe.metricName] = { value: pe.value, rating: pe.rating };
+      }
+    }
+    const queries = {};
+    const queryGroups = /* @__PURE__ */ new Map();
+    for (const de of databaseEvents) {
+      const group = queryGroups.get(de.normalizedQuery) ?? [];
+      group.push(de);
+      queryGroups.set(de.normalizedQuery, group);
+    }
+    for (const [key, group] of queryGroups) {
+      const avgDuration = group.reduce((s, e) => s + e.duration, 0) / group.length;
+      queries[key] = { avgDuration, callCount: group.length };
+    }
+    const timestamps = sessionEvents.map((e) => e.timestamp);
+    const errorCount = consoleEvents.filter((e) => e.level === "error").length + networkEvents.filter((e) => e.status >= 400).length;
+    return {
+      sessionId,
+      project,
+      connectedAt: timestamps.length > 0 ? Math.min(...timestamps) : Date.now(),
+      disconnectedAt: timestamps.length > 0 ? Math.max(...timestamps) : Date.now(),
+      totalEvents: sessionEvents.length,
+      errorCount,
+      endpoints,
+      components,
+      stores,
+      webVitals,
+      queries
+    };
+  }
+  createSnapshot(sessionId, project, label) {
+    const events = this.store.getAllEvents();
+    const metrics = this.computeMetrics(sessionId, project, events);
+    const sqliteStore = this.sqliteStores.get(project);
+    if (sqliteStore) {
+      sqliteStore.saveSessionMetrics(sessionId, project, metrics, label);
+    }
+    return {
+      sessionId,
+      project,
+      label,
+      metrics,
+      createdAt: Date.now()
+    };
+  }
+  getSessionSnapshots(project, sessionId) {
+    const sqliteStore = this.sqliteStores.get(project);
+    if (!sqliteStore) return [];
+    return sqliteStore.getSessionSnapshots(sessionId);
+  }
+  getSnapshotById(project, snapshotId) {
+    const sqliteStore = this.sqliteStores.get(project);
+    if (!sqliteStore) return null;
+    return sqliteStore.getSnapshotById(snapshotId);
+  }
+  getSessionHistory(project, limit = 20) {
+    const sqliteStore = this.sqliteStores.get(project);
+    if (!sqliteStore) return [];
+    const sessions = sqliteStore.getSessions(project, limit);
+    const snapshots = [];
+    for (const session of sessions) {
+      const metricsData = sqliteStore.getSessionMetrics(session.sessionId);
+      if (metricsData) {
+        snapshots.push({
+          sessionId: session.sessionId,
+          project,
+          metrics: metricsData,
+          buildMeta: session.buildMeta,
+          createdAt: session.disconnectedAt ?? session.connectedAt
+        });
+      }
+    }
+    return snapshots;
+  }
+};
+
+// src/http-server.ts
+import { createServer } from "http";
+import { createServer as createHttpsServer2 } from "https";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { WebSocketServer as WebSocketServer2 } from "ws";
+
+// src/pm/pm-routes.ts
+import { readdir, readFile, writeFile, unlink, mkdir } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { spawn, execSync, execFileSync } from "child_process";
+var LOG_RING_SIZE = 500;
+var managedProcesses = /* @__PURE__ */ new Map();
+function pushLog(mp, stream, line) {
+  const entry = `[${stream}] ${line}`;
+  if (mp.logs.length >= LOG_RING_SIZE) mp.logs.shift();
+  mp.logs.push(entry);
+}
+function createPmRouter(pmStore, discovery, helpers, broadcastDevServer) {
+  const routes = [];
+  function route(method, pattern, handler) {
+    routes.push({ method, pattern, segments: pattern.split("/"), handler });
+  }
+  route("POST", "/api/pm/discover", async (_req, res) => {
+    try {
+      const result = await discovery.discoverAll();
+      helpers.json(res, result);
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("GET", "/api/pm/categories", (_req, res) => {
+    const categories = pmStore.listCategories();
+    helpers.json(res, { data: categories });
+  });
+  route("GET", "/api/pm/projects", (_req, res, params) => {
+    const id = params.get("id");
+    if (id) {
+      const project = pmStore.getProject(id);
+      if (!project) {
+        helpers.json(res, { error: "Project not found" }, 404);
+        return;
+      }
+      const stats = pmStore.getSessionStats(id);
+      helpers.json(res, { ...project, stats });
+      return;
+    }
+    const projects = pmStore.listProjects();
+    helpers.json(res, { data: projects, count: projects.length });
+  });
+  route("GET", "/api/pm/projects/export-csv", (_req, res, params) => {
+    const startDate = params.get("start_date") ?? void 0;
+    const endDate = params.get("end_date") ?? void 0;
+    const hideEmpty = params.get("hide_empty") === "1" || params.get("hide_empty") === "true";
+    const projectIdsRaw = params.get("project_ids") ?? "";
+    const projectIds = projectIdsRaw ? projectIdsRaw.split(",").filter(Boolean) : void 0;
+    const allSummaries = pmStore.getProjectSummaries({ startDate, endDate, hideEmpty });
+    const summaries = projectIds ? allSummaries.filter((s) => projectIds.includes(s.id)) : allSummaries;
+    const projectIdSet = new Set(summaries.map((s) => s.id));
+    const allSessions = [];
+    for (const pid of projectIdSet) {
+      const sessions = pmStore.listSessions(pid, { limit: 1e4, offset: 0, startDate, endDate, hideEmpty });
+      allSessions.push(...sessions);
+    }
+    allSessions.sort((a, b) => b.startedAt - a.startedAt);
+    const csvEscape = (val) => {
+      if (val === null || val === void 0) return "";
+      const s = String(val);
+      if (s.includes(",") || s.includes('"') || s.includes("\n")) {
+        return `"${s.replace(/"/g, '""')}"`;
+      }
+      return s;
+    };
+    const lines = [];
+    lines.push("=== PROJECTS ===");
+    lines.push("Project,Category,Sessions,Messages,Cost ($),Active Time (min),Last Session");
+    for (const p of summaries) {
+      lines.push([
+        csvEscape(p.name),
+        csvEscape(p.category),
+        p.session_count,
+        p.total_messages,
+        (p.total_cost / 1e6).toFixed(2),
+        Math.round(p.total_active_minutes),
+        p.last_session_at ? new Date(p.last_session_at).toISOString().split("T")[0] : ""
+      ].join(","));
+    }
+    lines.push("");
+    lines.push("=== SESSIONS ===");
+    lines.push("Project,Session ID,Slug,Model,Date,Messages,Tokens In,Tokens Out,Cost ($),Active Time (min),Branch");
+    for (const s of allSessions) {
+      const proj = summaries.find((p) => p.id === s.projectId);
+      lines.push([
+        csvEscape(proj?.name ?? s.projectId),
+        csvEscape(s.id),
+        csvEscape(s.slug),
+        csvEscape(s.model),
+        new Date(s.startedAt).toISOString().split("T")[0],
+        s.messageCount,
+        s.totalInputTokens,
+        s.totalOutputTokens,
+        (s.costMicrodollars / 1e6).toFixed(2),
+        Math.round(s.activeMinutes),
+        csvEscape(s.gitBranch)
+      ].join(","));
+    }
+    const csv = lines.join("\n");
+    res.writeHead(200, {
+      "Content-Type": "text/csv",
+      "Content-Disposition": `attachment; filename="runtimescope-export-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.csv"`
+    });
+    res.end(csv);
+  });
+  route("GET", "/api/pm/projects/summaries", (_req, res, params) => {
+    const startDate = params.get("start_date") ?? void 0;
+    const endDate = params.get("end_date") ?? void 0;
+    const hideEmpty = params.get("hide_empty") === "1" || params.get("hide_empty") === "true";
+    const summaries = pmStore.getProjectSummaries({ startDate, endDate, hideEmpty });
+    helpers.json(res, { data: summaries, count: summaries.length });
+  });
+  route("GET", "/api/pm/projects/:id", (_req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    const stats = pmStore.getSessionStats(id);
+    helpers.json(res, { ...project, stats });
+  });
+  route("PUT", "/api/pm/projects/:id", async (req, res, params) => {
+    const id = params.get("id");
+    const body = await helpers.readBody(req, 65536);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const updates = JSON.parse(body);
+      pmStore.updateProject(id, updates);
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("GET", "/api/pm/tasks", (_req, res, params) => {
+    const projectId = params.get("project_id") ?? void 0;
+    const status = params.get("status") ?? void 0;
+    const tasks = pmStore.listTasks(projectId, status);
+    helpers.json(res, { data: tasks, count: tasks.length });
+  });
+  route("POST", "/api/pm/tasks", async (req, res) => {
+    const body = await helpers.readBody(req, 65536);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const data = JSON.parse(body);
+      const now = Date.now();
+      const task = {
+        id: crypto.randomUUID(),
+        projectId: data.projectId ?? void 0,
+        title: data.title,
+        description: data.description ?? void 0,
+        status: data.status ?? "todo",
+        priority: data.priority ?? "medium",
+        labels: data.labels ?? [],
+        source: data.source ?? "manual",
+        sourceRef: data.sourceRef ?? void 0,
+        sortOrder: data.sortOrder ?? now,
+        assignedTo: data.assignedTo ?? void 0,
+        dueDate: data.dueDate ?? void 0,
+        createdAt: now,
+        updatedAt: now,
+        completedAt: void 0
+      };
+      pmStore.createTask(task);
+      helpers.json(res, task, 201);
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("PUT", "/api/pm/tasks/:id", async (req, res, params) => {
+    const id = params.get("id");
+    const body = await helpers.readBody(req, 65536);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const updates = JSON.parse(body);
+      pmStore.updateTask(id, updates);
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("DELETE", "/api/pm/tasks/:id", (_req, res, params) => {
+    const id = params.get("id");
+    pmStore.deleteTask(id);
+    helpers.json(res, { ok: true });
+  });
+  route("PUT", "/api/pm/tasks/:id/reorder", async (req, res, params) => {
+    const id = params.get("id");
+    const body = await helpers.readBody(req, 4096);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const { status, sortOrder } = JSON.parse(body);
+      pmStore.reorderTask(id, status, sortOrder);
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("GET", "/api/pm/sessions", (_req, res, params) => {
+    const projectId = params.get("project_id") ?? void 0;
+    const limit = parseInt(params.get("limit") ?? "100", 10);
+    const offset = parseInt(params.get("offset") ?? "0", 10);
+    const startDate = params.get("start_date") ?? void 0;
+    const endDate = params.get("end_date") ?? void 0;
+    const hideEmpty = params.get("hide_empty") === "1" || params.get("hide_empty") === "true";
+    const sessions = pmStore.listSessions(projectId, { limit, offset, startDate, endDate, hideEmpty });
+    const stats = pmStore.getSessionStats(projectId, { startDate, endDate, hideEmpty });
+    helpers.json(res, { data: sessions, count: sessions.length, total: stats.totalSessions });
+  });
+  route("GET", "/api/pm/sessions/stats", (_req, res, params) => {
+    const projectId = params.get("project_id") || void 0;
+    const startDate = params.get("start_date") ?? void 0;
+    const endDate = params.get("end_date") ?? void 0;
+    const hideEmpty = params.get("hide_empty") === "1" || params.get("hide_empty") === "true";
+    const stats = pmStore.getSessionStats(projectId, { startDate, endDate, hideEmpty });
+    helpers.json(res, stats);
+  });
+  route("GET", "/api/pm/sessions/:id", (_req, res, params) => {
+    const id = params.get("id");
+    const session = pmStore.getSession(id);
+    if (!session) {
+      helpers.json(res, { error: "Session not found" }, 404);
+      return;
+    }
+    helpers.json(res, session);
+  });
+  route("POST", "/api/pm/sessions/:id/refresh", async (_req, res, params) => {
+    const id = params.get("id");
+    const session = pmStore.getSession(id);
+    if (!session) {
+      helpers.json(res, { error: "Session not found" }, 404);
+      return;
+    }
+    try {
+      await discovery.indexSession(id, session.projectId, session.jsonlPath);
+      const updated = pmStore.getSession(id);
+      helpers.json(res, updated);
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("GET", "/api/pm/notes", (_req, res, params) => {
+    const projectId = params.get("project_id") ?? void 0;
+    const pinned = params.get("pinned") === "1" ? true : void 0;
+    const notes = pmStore.listNotes({ projectId, pinned });
+    helpers.json(res, { data: notes, count: notes.length });
+  });
+  route("POST", "/api/pm/notes", async (req, res) => {
+    const body = await helpers.readBody(req, 1048576);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const data = JSON.parse(body);
+      const now = Date.now();
+      const note = {
+        id: crypto.randomUUID(),
+        projectId: data.projectId ?? void 0,
+        sessionId: data.sessionId ?? void 0,
+        title: data.title ?? "Untitled",
+        content: data.content ?? "",
+        pinned: data.pinned ?? false,
+        tags: data.tags ?? [],
+        createdAt: now,
+        updatedAt: now
+      };
+      pmStore.createNote(note);
+      helpers.json(res, note, 201);
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("PUT", "/api/pm/notes/:id", async (req, res, params) => {
+    const id = params.get("id");
+    const body = await helpers.readBody(req, 1048576);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const updates = JSON.parse(body);
+      pmStore.updateNote(id, updates);
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("DELETE", "/api/pm/notes/:id", (_req, res, params) => {
+    const id = params.get("id");
+    pmStore.deleteNote(id);
+    helpers.json(res, { ok: true });
+  });
+  route("GET", "/api/pm/memory/:projectId", async (_req, res, params) => {
+    const projectId = params.get("projectId");
+    const project = pmStore.getProject(projectId);
+    if (!project?.claudeProjectKey) {
+      helpers.json(res, { data: [], count: 0 });
+      return;
+    }
+    const memoryDir = join2(homedir2(), ".claude", "projects", project.claudeProjectKey, "memory");
+    try {
+      const files = await readdir(memoryDir);
+      const mdFiles = files.filter((f) => f.endsWith(".md"));
+      const result = await Promise.all(
+        mdFiles.map(async (filename) => {
+          const content = await readFile(join2(memoryDir, filename), "utf-8");
+          return { filename, content, sizeBytes: Buffer.byteLength(content) };
+        })
+      );
+      helpers.json(res, { data: result, count: result.length });
+    } catch {
+      helpers.json(res, { data: [], count: 0 });
+    }
+  });
+  route("GET", "/api/pm/memory/:projectId/:filename", async (_req, res, params) => {
+    const projectId = params.get("projectId");
+    const filename = sanitizeFilename(params.get("filename"));
+    const project = pmStore.getProject(projectId);
+    if (!project?.claudeProjectKey) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    const filePath = join2(homedir2(), ".claude", "projects", project.claudeProjectKey, "memory", filename);
+    try {
+      const content = await readFile(filePath, "utf-8");
+      helpers.json(res, { filename, content, sizeBytes: Buffer.byteLength(content) });
+    } catch {
+      helpers.json(res, { error: "File not found" }, 404);
+    }
+  });
+  route("PUT", "/api/pm/memory/:projectId/:filename", async (req, res, params) => {
+    const projectId = params.get("projectId");
+    const filename = sanitizeFilename(params.get("filename"));
+    const project = pmStore.getProject(projectId);
+    if (!project?.claudeProjectKey) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    const body = await helpers.readBody(req, 1048576);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const { content } = JSON.parse(body);
+      const memoryDir = join2(homedir2(), ".claude", "projects", project.claudeProjectKey, "memory");
+      await mkdir(memoryDir, { recursive: true });
+      await writeFile(join2(memoryDir, filename), content, "utf-8");
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("DELETE", "/api/pm/memory/:projectId/:filename", async (_req, res, params) => {
+    const projectId = params.get("projectId");
+    const filename = sanitizeFilename(params.get("filename"));
+    const project = pmStore.getProject(projectId);
+    if (!project?.claudeProjectKey) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    const filePath = join2(homedir2(), ".claude", "projects", project.claudeProjectKey, "memory", filename);
+    try {
+      await unlink(filePath);
+      helpers.json(res, { ok: true });
+    } catch {
+      helpers.json(res, { error: "File not found" }, 404);
+    }
+  });
+  route("GET", "/api/pm/rules/:projectId", async (_req, res, params) => {
+    const projectId = params.get("projectId");
+    const project = pmStore.getProject(projectId);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    const paths = getRulesPaths(project.claudeProjectKey, project.path);
+    const result = {
+      global: await readRuleFile(paths.global),
+      project: await readRuleFile(paths.project),
+      local: await readRuleFile(paths.local)
+    };
+    helpers.json(res, result);
+  });
+  route("GET", "/api/pm/rules/:projectId/:scope", async (_req, res, params) => {
+    const projectId = params.get("projectId");
+    const scope = params.get("scope");
+    if (!["global", "project", "local"].includes(scope)) {
+      helpers.json(res, { error: "Invalid scope. Must be: global, project, or local" }, 400);
+      return;
+    }
+    const project = pmStore.getProject(projectId);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    const paths = getRulesPaths(project.claudeProjectKey, project.path);
+    const filePath = paths[scope];
+    helpers.json(res, await readRuleFile(filePath));
+  });
+  route("PUT", "/api/pm/rules/:projectId/:scope", async (req, res, params) => {
+    const projectId = params.get("projectId");
+    const scope = params.get("scope");
+    if (!["global", "project", "local"].includes(scope)) {
+      helpers.json(res, { error: "Invalid scope" }, 400);
+      return;
+    }
+    const project = pmStore.getProject(projectId);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    const body = await helpers.readBody(req, 1048576);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const { content } = JSON.parse(body);
+      const paths = getRulesPaths(project.claudeProjectKey, project.path);
+      const filePath = paths[scope];
+      const dir = join2(filePath, "..");
+      await mkdir(dir, { recursive: true });
+      await writeFile(filePath, content, "utf-8");
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("GET", "/api/pm/projects/:id/scripts", async (_req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    if (!project.path) {
+      helpers.json(res, { data: { scripts: {}, recommended: null } });
+      return;
+    }
+    try {
+      const pkgPath = join2(project.path, "package.json");
+      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+      const scripts = pkg.scripts ?? {};
+      const recommended = ["dev", "start", "serve"].find((s) => s in scripts) ?? null;
+      helpers.json(res, { data: { scripts, recommended } });
+    } catch {
+      helpers.json(res, { data: { scripts: {}, recommended: null } });
+    }
+  });
+  route("GET", "/api/pm/projects/:id/dev-server", (_req, res, params) => {
+    const id = params.get("id");
+    const mp = managedProcesses.get(id);
+    if (!mp) {
+      helpers.json(res, { data: { status: "stopped" } });
+      return;
+    }
+    try {
+      process.kill(mp.pid, 0);
+    } catch {
+      managedProcesses.delete(id);
+      helpers.json(res, { data: { status: "stopped" } });
+      return;
+    }
+    helpers.json(res, {
+      data: {
+        status: mp.status,
+        pid: mp.pid,
+        command: mp.command,
+        startedAt: mp.startedAt,
+        exitCode: mp.exitCode,
+        logs: mp.logs.slice(-100)
+      }
+    });
+  });
+  route("POST", "/api/pm/projects/:id/dev-server", async (req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    if (!project.path) {
+      helpers.json(res, { error: "Project has no filesystem path" }, 400);
+      return;
+    }
+    const existing = managedProcesses.get(id);
+    if (existing) {
+      try {
+        process.kill(existing.pid, 0);
+        helpers.json(res, { error: "Dev server already running", data: { pid: existing.pid, status: existing.status } }, 409);
+        return;
+      } catch {
+        managedProcesses.delete(id);
+      }
+    }
+    const body = await helpers.readBody(req, 4096);
+    let script;
+    let command;
+    if (body) {
+      try {
+        const data = JSON.parse(body);
+        script = data.script;
+        command = data.command;
+      } catch {
+      }
+    }
+    const finalCommand = command ?? (script ? `npm run ${script}` : "npm run dev");
+    const broadcast = broadcastDevServer ?? (() => {
+    });
+    try {
+      const child = spawn(finalCommand, {
+        cwd: project.path,
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const pid = child.pid;
+      if (!pid) {
+        helpers.json(res, { error: "Failed to spawn process" }, 500);
+        return;
+      }
+      const managed = {
+        pid,
+        command: finalCommand,
+        projectId: id,
+        startedAt: Date.now(),
+        status: "starting",
+        child,
+        logs: [],
+        exitCode: null
+      };
+      managedProcesses.set(id, managed);
+      broadcast({ type: "dev_server_status", projectId: id, status: "starting", pid });
+      let detectedPort = null;
+      const flipTimer = setTimeout(() => {
+        if (managed.status === "starting") {
+          managed.status = "running";
+          broadcast({ type: "dev_server_status", projectId: id, status: "running", pid, port: detectedPort });
+        }
+      }, 500);
+      const PORT_RE = /(?:localhost|127\.0\.0\.1|0\.0\.0\.0):(\d{4,5})/;
+      for (const [stream, src] of [["stdout", child.stdout], ["stderr", child.stderr]]) {
+        let buf = "";
+        src.on("data", (chunk) => {
+          if (managed.status === "starting") {
+            managed.status = "running";
+            clearTimeout(flipTimer);
+            broadcast({ type: "dev_server_status", projectId: id, status: "running", pid, port: detectedPort });
+          }
+          buf += chunk.toString("utf-8");
+          const lines = buf.split("\n");
+          buf = lines.pop() ?? "";
+          for (const line of lines) {
+            if (!line) continue;
+            if (!detectedPort) {
+              const portMatch = line.match(PORT_RE);
+              if (portMatch) {
+                detectedPort = parseInt(portMatch[1], 10);
+                broadcast({ type: "dev_server_status", projectId: id, status: "running", pid, port: detectedPort });
+              }
+            }
+            pushLog(managed, stream, line);
+            broadcast({ type: "dev_server_log", projectId: id, stream, line, ts: Date.now() });
+          }
+        });
+      }
+      child.on("exit", (code) => {
+        clearTimeout(flipTimer);
+        managed.status = code === 0 ? "stopped" : "crashed";
+        managed.exitCode = code;
+        broadcast({ type: "dev_server_status", projectId: id, status: managed.status, pid, exitCode: code });
+        setTimeout(() => managedProcesses.delete(id), 5e3);
+      });
+      child.on("error", (err) => {
+        clearTimeout(flipTimer);
+        managed.status = "crashed";
+        pushLog(managed, "stderr", `[error] ${err.message}`);
+        broadcast({ type: "dev_server_status", projectId: id, status: "crashed", pid, error: err.message });
+        setTimeout(() => managedProcesses.delete(id), 5e3);
+      });
+      helpers.json(res, { data: { pid, command: finalCommand, cwd: project.path, status: "starting" } });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("DELETE", "/api/pm/projects/:id/dev-server", async (req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    let signal = "SIGTERM";
+    const body = await helpers.readBody(req, 1024);
+    if (body) {
+      try {
+        const data = JSON.parse(body);
+        if (data.signal === "SIGKILL") signal = "SIGKILL";
+      } catch {
+      }
+    }
+    let pid = null;
+    const managed = managedProcesses.get(id);
+    if (managed) {
+      pid = managed.pid;
+      try {
+        managed.child.kill(signal);
+      } catch {
+      }
+      managedProcesses.delete(id);
+    } else if (project.path) {
+      try {
+        const output = execSync(
+          `lsof -t +D "${project.path}" 2>/dev/null | head -5`,
+          { encoding: "utf-8", timeout: 5e3 }
+        ).trim();
+        const pids = output.split("\n").filter(Boolean).map(Number).filter((n) => n > 1 && n !== process.pid);
+        if (pids.length > 0) pid = pids[0];
+      } catch {
+      }
+    }
+    if (!pid) {
+      helpers.json(res, { error: "No running dev server found for this project" }, 404);
+      return;
+    }
+    try {
+      process.kill(pid, signal);
+      managedProcesses.delete(id);
+      helpers.json(res, { data: { killed: true, pid, signal } });
+    } catch (err) {
+      const code = err.code;
+      managedProcesses.delete(id);
+      if (code === "ESRCH") {
+        helpers.json(res, { data: { killed: true, pid, signal, note: "Process already exited" } });
+      } else {
+        helpers.json(res, { error: `Failed to kill PID ${pid}: ${err.message}` }, 500);
+      }
+    }
+  });
+  route("GET", "/api/pm/projects/:id/git/status", (_req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    if (!project.path) {
+      helpers.json(res, { data: { isGitRepo: false, branch: "", staged: [], unstaged: [], untracked: [] } });
+      return;
+    }
+    if (!isGitRepo(project.path)) {
+      helpers.json(res, { data: { isGitRepo: false, branch: "", staged: [], unstaged: [], untracked: [] } });
+      return;
+    }
+    try {
+      const branch = execGit(["rev-parse", "--abbrev-ref", "HEAD"], project.path).trim();
+      const porcelain = execGit(["status", "--porcelain"], project.path);
+      const { staged, unstaged, untracked } = parseGitStatus(porcelain);
+      helpers.json(res, { data: { isGitRepo: true, branch, staged, unstaged, untracked } });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("GET", "/api/pm/projects/:id/git/log", (_req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    if (!project.path || !isGitRepo(project.path)) {
+      helpers.json(res, { data: [] });
+      return;
+    }
+    try {
+      const raw = execGit(["log", "-30", "--format=%H%x00%h%x00%B%x00%an%x00%cr%x00%D%x01"], project.path);
+      const commits = raw.trim().split("
").filter(Boolean).map((entry) => {
+        const [hash, shortHash, message, author, relativeDate, refs] = entry.trim().split("\0");
+        const fullMsg = (message ?? "").trim();
+        const subject = fullMsg.split("\n")[0];
+        return { hash, shortHash, subject, message: fullMsg, author, relativeDate, refs: refs?.trim() || "" };
+      });
+      helpers.json(res, { data: commits });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("POST", "/api/pm/projects/:id/git/stage", async (req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    if (!project.path || !isGitRepo(project.path)) {
+      helpers.json(res, { error: "Not a git repo" }, 400);
+      return;
+    }
+    const body = await helpers.readBody(req, 65536);
+    let files;
+    if (body) {
+      try {
+        files = JSON.parse(body).files;
+      } catch {
+      }
+    }
+    try {
+      if (files && files.length > 0) {
+        execGit(["add", "--", ...files], project.path);
+      } else {
+        execGit(["add", "-A"], project.path);
+      }
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("POST", "/api/pm/projects/:id/git/unstage", async (req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    if (!project.path || !isGitRepo(project.path)) {
+      helpers.json(res, { error: "Not a git repo" }, 400);
+      return;
+    }
+    const body = await helpers.readBody(req, 65536);
+    let files;
+    if (body) {
+      try {
+        files = JSON.parse(body).files;
+      } catch {
+      }
+    }
+    try {
+      if (files && files.length > 0) {
+        execGit(["restore", "--staged", "--", ...files], project.path);
+      } else {
+        execGit(["reset", "HEAD"], project.path);
+      }
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("POST", "/api/pm/projects/:id/git/commit", async (req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    if (!project.path || !isGitRepo(project.path)) {
+      helpers.json(res, { error: "Not a git repo" }, 400);
+      return;
+    }
+    const body = await helpers.readBody(req, 65536);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const { message } = JSON.parse(body);
+      if (!message || !message.trim()) {
+        helpers.json(res, { error: "Commit message required" }, 400);
+        return;
+      }
+      const output = execGit(["commit", "-m", message], project.path);
+      const hashMatch = output.match(/\[[\w/.-]+ ([a-f0-9]+)\]/);
+      helpers.json(res, { ok: true, hash: hashMatch?.[1] ?? "" });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("GET", "/api/pm/projects/:id/git/diff", (_req, res, params) => {
+    const id = params.get("id");
+    const project = pmStore.getProject(id);
+    if (!project) {
+      helpers.json(res, { error: "Project not found" }, 404);
+      return;
+    }
+    if (!project.path || !isGitRepo(project.path)) {
+      helpers.json(res, { data: { diff: "" } });
+      return;
+    }
+    const staged = params.get("staged") === "1" || params.get("staged") === "true";
+    const file = params.get("file") ?? void 0;
+    try {
+      const args = ["diff"];
+      if (staged) args.push("--staged");
+      if (file) args.push("--", file);
+      const diff = execGit(args, project.path);
+      helpers.json(res, { data: { diff } });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 500);
+    }
+  });
+  route("GET", "/api/pm/capex/:projectId", (_req, res, params) => {
+    const projectId = params.get("projectId");
+    const month = params.get("month") ?? void 0;
+    const confirmed = params.get("confirmed") === "1" ? true : params.get("confirmed") === "0" ? false : void 0;
+    const entries = pmStore.listCapexEntries(projectId, { month, confirmed });
+    helpers.json(res, { data: entries, count: entries.length });
+  });
+  route("GET", "/api/pm/capex/:projectId/summary", (_req, res, params) => {
+    const projectId = params.get("projectId");
+    const startDate = params.get("start_date") ?? void 0;
+    const endDate = params.get("end_date") ?? void 0;
+    const summary = pmStore.getCapexSummary(projectId, { startDate, endDate });
+    helpers.json(res, summary);
+  });
+  route("PUT", "/api/pm/capex/:projectId/:entryId", async (req, res, params) => {
+    const entryId = params.get("entryId");
+    const body = await helpers.readBody(req, 65536);
+    if (!body) {
+      helpers.json(res, { error: "Body required" }, 400);
+      return;
+    }
+    try {
+      const updates = JSON.parse(body);
+      pmStore.updateCapexEntry(entryId, updates);
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("POST", "/api/pm/capex/:projectId/:entryId/confirm", (_req, res, params) => {
+    const entryId = params.get("entryId");
+    pmStore.confirmCapexEntry(entryId);
+    helpers.json(res, { ok: true });
+  });
+  route("GET", "/api/pm/capex/:projectId/export", (_req, res, params) => {
+    const projectId = params.get("projectId");
+    const startDate = params.get("start_date") ?? void 0;
+    const endDate = params.get("end_date") ?? void 0;
+    const csv = pmStore.exportCapexCsv(projectId, { startDate, endDate });
+    res.writeHead(200, {
+      "Content-Type": "text/csv",
+      "Content-Disposition": `attachment; filename="capex-${projectId}.csv"`
+    });
+    res.end(csv);
+  });
+  return {
+    match(method, pathname) {
+      const pathSegments = pathname.split("/");
+      for (const r of routes) {
+        if (r.method !== method) continue;
+        if (r.segments.length !== pathSegments.length) continue;
+        const pathParams = {};
+        let matched = true;
+        for (let i = 0; i < r.segments.length; i++) {
+          if (r.segments[i].startsWith(":")) {
+            pathParams[r.segments[i].slice(1)] = decodeURIComponent(pathSegments[i]);
+          } else if (r.segments[i] !== pathSegments[i]) {
+            matched = false;
+            break;
+          }
+        }
+        if (matched) {
+          return { handler: r.handler, pathParams };
+        }
+      }
+      return null;
+    }
+  };
+}
+function sanitizeFilename(name) {
+  return name.replace(/[/\\]/g, "").replace(/\.\./g, "");
+}
+function getRulesPaths(claudeProjectKey, projectPath) {
+  const home = homedir2();
+  return {
+    global: join2(home, ".claude", "CLAUDE.md"),
+    project: claudeProjectKey ? join2(home, ".claude", "projects", claudeProjectKey, "CLAUDE.md") : join2(projectPath ?? "", ".claude", "CLAUDE.md"),
+    local: projectPath ? join2(projectPath, "CLAUDE.md") : join2(home, "CLAUDE.md")
+  };
+}
+function execGit(args, cwd) {
+  return execFileSync("git", args, { cwd, encoding: "utf-8", timeout: 1e4, maxBuffer: 10 * 1024 * 1024 });
+}
+function isGitRepo(path) {
+  try {
+    execFileSync("git", ["rev-parse", "--git-dir"], { cwd: path, encoding: "utf-8", timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseGitStatus(porcelain) {
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  for (const line of porcelain.split("\n")) {
+    if (!line || line.length < 4) continue;
+    const x = line[0];
+    const y = line[1];
+    const filepath = line.slice(3);
+    let path = filepath;
+    let oldPath;
+    if (filepath.includes(" -> ")) {
+      const parts = filepath.split(" -> ");
+      oldPath = parts[0];
+      path = parts[1];
+    }
+    if (x === "?" && y === "?") {
+      untracked.push({ path, status: "?" });
+      continue;
+    }
+    if (x !== " " && x !== "?") {
+      staged.push({ path, status: x, oldPath });
+    }
+    if (y !== " " && y !== "?") {
+      unstaged.push({ path, status: y });
+    }
+  }
+  return { staged, unstaged, untracked };
+}
+async function readRuleFile(filePath) {
+  try {
+    if (existsSync2(filePath)) {
+      const content = await readFile(filePath, "utf-8");
+      return { path: filePath, content, exists: true };
+    }
+  } catch {
+  }
+  return { path: filePath, content: "", exists: false };
+}
+
+// src/http-server.ts
+var HttpServer = class {
+  server = null;
+  wss = null;
+  store;
+  processMonitor;
+  authManager;
+  allowedOrigins;
+  rateLimiter;
+  dashboardClients = /* @__PURE__ */ new Set();
+  eventListener = null;
+  routes = /* @__PURE__ */ new Map();
+  pmRouter = null;
+  sdkBundlePath = null;
+  activePort = 9091;
+  startedAt = Date.now();
+  constructor(store, processMonitor, options) {
+    this.store = store;
+    this.processMonitor = processMonitor ?? null;
+    this.authManager = options?.authManager ?? null;
+    this.allowedOrigins = options?.allowedOrigins ?? null;
+    this.rateLimiter = options?.rateLimiter ?? null;
+    this.registerRoutes();
+    if (options?.pmStore && options?.discovery) {
+      this.pmRouter = createPmRouter(options.pmStore, options.discovery, {
+        json: (res, data, status) => this.json(res, data, status),
+        readBody: (req, maxBytes) => this.readBody(req, maxBytes)
+      }, (msg) => this.broadcastDevServer(msg));
+    }
+  }
+  registerRoutes() {
+    this.routes.set("GET /api/health", (_req, res) => {
+      this.json(res, {
+        status: "ok",
+        timestamp: Date.now(),
+        uptime: Math.floor((Date.now() - this.startedAt) / 1e3),
+        sessions: this.store.getSessionInfo().filter((s) => s.isConnected).length,
+        authEnabled: this.authManager?.isEnabled() ?? false
+      });
+    });
+    this.routes.set("GET /api/sessions", (_req, res) => {
+      const sessions = this.store.getSessionInfo();
+      this.json(res, { data: sessions, count: sessions.length });
+    });
+    this.routes.set("GET /api/projects", (_req, res) => {
+      const sessions = this.store.getSessionInfo();
+      const projectMap = /* @__PURE__ */ new Map();
+      for (const s of sessions) {
+        const existing = projectMap.get(s.appName);
+        if (existing) {
+          existing.sessions.push(s.sessionId);
+          existing.eventCount += s.eventCount;
+          if (s.isConnected) existing.isConnected = true;
+        } else {
+          projectMap.set(s.appName, {
+            appName: s.appName,
+            sessions: [s.sessionId],
+            isConnected: s.isConnected,
+            eventCount: s.eventCount
+          });
+        }
+      }
+      const projects = Array.from(projectMap.values());
+      this.json(res, { data: projects, count: projects.length });
+    });
+    this.routes.set("GET /api/processes", (_req, res, params) => {
+      if (!this.processMonitor) {
+        this.json(res, { data: [], count: 0 });
+        return;
+      }
+      const type = params.get("type") ?? void 0;
+      const project = params.get("project") ?? void 0;
+      const processes = this.processMonitor.getProcesses({ type, project });
+      this.json(res, { data: processes, count: processes.length });
+    });
+    this.routes.set("DELETE /api/processes", async (req, res, params) => {
+      if (!this.processMonitor) {
+        this.json(res, { error: "Process monitor not available" }, 500);
+        return;
+      }
+      const pid = numParam(params, "pid");
+      if (!pid) {
+        const body = await this.readBody(req, 1024);
+        const parsed = body ? JSON.parse(body) : {};
+        if (!parsed.pid) {
+          this.json(res, { error: "pid is required" }, 400);
+          return;
+        }
+        const result2 = this.processMonitor.killProcess(parsed.pid, parsed.signal ?? "SIGTERM");
+        this.json(res, { data: result2 });
+        return;
+      }
+      const signal = params.get("signal") ?? "SIGTERM";
+      const result = this.processMonitor.killProcess(pid, signal);
+      this.json(res, { data: result });
+    });
+    this.routes.set("GET /api/ports", (_req, res, params) => {
+      if (!this.processMonitor) {
+        this.json(res, { data: [], count: 0 });
+        return;
+      }
+      const port = numParam(params, "port");
+      const ports = this.processMonitor.getPortUsage(port);
+      this.json(res, { data: ports, count: ports.length });
+    });
+    this.routes.set("GET /api/events/network", (_req, res, params) => {
+      const events = this.store.getNetworkRequests({
+        sinceSeconds: numParam(params, "since_seconds"),
+        urlPattern: params.get("url_pattern") ?? void 0,
+        method: params.get("method") ?? void 0,
+        sessionId: params.get("session_id") ?? void 0
+      });
+      this.json(res, { data: events, count: events.length });
+    });
+    this.routes.set("GET /api/events/console", (_req, res, params) => {
+      const events = this.store.getConsoleMessages({
+        sinceSeconds: numParam(params, "since_seconds"),
+        level: params.get("level") ?? void 0,
+        search: params.get("search") ?? void 0,
+        sessionId: params.get("session_id") ?? void 0
+      });
+      this.json(res, { data: events, count: events.length });
+    });
+    this.routes.set("GET /api/events/state", (_req, res, params) => {
+      const events = this.store.getStateEvents({
+        sinceSeconds: numParam(params, "since_seconds"),
+        storeId: params.get("store_id") ?? void 0,
+        sessionId: params.get("session_id") ?? void 0
+      });
+      this.json(res, { data: events, count: events.length });
+    });
+    this.routes.set("GET /api/events/renders", (_req, res, params) => {
+      const events = this.store.getRenderEvents({
+        sinceSeconds: numParam(params, "since_seconds"),
+        componentName: params.get("component") ?? void 0,
+        sessionId: params.get("session_id") ?? void 0
+      });
+      this.json(res, { data: events, count: events.length });
+    });
+    this.routes.set("GET /api/events/performance", (_req, res, params) => {
+      const events = this.store.getPerformanceMetrics({
+        sinceSeconds: numParam(params, "since_seconds"),
+        metricName: params.get("metric") ?? void 0,
+        sessionId: params.get("session_id") ?? void 0
+      });
+      this.json(res, { data: events, count: events.length });
+    });
+    this.routes.set("GET /api/events/database", (_req, res, params) => {
+      const events = this.store.getDatabaseEvents({
+        sinceSeconds: numParam(params, "since_seconds"),
+        table: params.get("table") ?? void 0,
+        minDurationMs: numParam(params, "min_duration_ms"),
+        search: params.get("search") ?? void 0,
+        sessionId: params.get("session_id") ?? void 0
+      });
+      this.json(res, { data: events, count: events.length });
+    });
+    this.routes.set("GET /api/events/timeline", (_req, res, params) => {
+      const eventTypes = params.get("event_types")?.split(",") ?? void 0;
+      const events = this.store.getEventTimeline({
+        sinceSeconds: numParam(params, "since_seconds"),
+        eventTypes,
+        sessionId: params.get("session_id") ?? void 0
+      });
+      this.json(res, { data: events, count: events.length });
+    });
+    this.routes.set("GET /api/events/custom", (_req, res, params) => {
+      const events = this.store.getCustomEvents({
+        name: params.get("name") ?? void 0,
+        sinceSeconds: numParam(params, "since_seconds"),
+        sessionId: params.get("session_id") ?? void 0
+      });
+      this.json(res, { data: events, count: events.length });
+    });
+    this.routes.set("DELETE /api/events", (_req, res) => {
+      const result = this.store.clear();
+      this.json(res, result);
+    });
+    this.routes.set("POST /api/events", async (req, res) => {
+      const body = await this.readBody(req, 1048576);
+      if (!body) {
+        this.json(res, { error: "Request body required", code: "EMPTY_BODY" }, 400);
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(body);
+      } catch {
+        this.json(res, { error: "Invalid JSON", code: "PARSE_ERROR" }, 400);
+        return;
+      }
+      const payload = parsed;
+      if (!payload.sessionId || !Array.isArray(payload.events) || payload.events.length === 0) {
+        this.json(res, {
+          error: "Required: sessionId (string), events (non-empty array)",
+          code: "INVALID_PAYLOAD"
+        }, 400);
+        return;
+      }
+      const sessions = this.store.getSessionInfo();
+      const knownSession = sessions.find((s) => s.sessionId === payload.sessionId);
+      if (!knownSession && payload.appName) {
+        this.store.addEvent({
+          eventId: `session-${payload.sessionId}`,
+          sessionId: payload.sessionId,
+          timestamp: Date.now(),
+          eventType: "session",
+          appName: payload.appName,
+          connectedAt: Date.now(),
+          sdkVersion: payload.sdkVersion ?? "http"
+        });
+      }
+      const VALID_EVENT_TYPES = /* @__PURE__ */ new Set([
+        "network",
+        "console",
+        "session",
+        "state",
+        "render",
+        "dom_snapshot",
+        "performance",
+        "database",
+        "recon_metadata",
+        "recon_design_tokens",
+        "recon_fonts",
+        "recon_layout_tree",
+        "recon_accessibility",
+        "recon_computed_styles",
+        "recon_element_snapshot",
+        "recon_asset_inventory"
+      ]);
+      let accepted = 0;
+      let dropped = 0;
+      let rejected = 0;
+      for (const raw of payload.events) {
+        const event = raw;
+        if (!event.eventType || !VALID_EVENT_TYPES.has(event.eventType)) {
+          rejected++;
+          continue;
+        }
+        if (!event.eventId) event.eventId = `http-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        if (!event.sessionId) event.sessionId = payload.sessionId;
+        if (!event.timestamp) event.timestamp = Date.now();
+        if (this.rateLimiter && !this.rateLimiter.allow(payload.sessionId)) {
+          dropped++;
+          continue;
+        }
+        this.store.addEvent(event);
+        accepted++;
+      }
+      this.json(res, { accepted, dropped, rejected, sessionId: payload.sessionId }, accepted > 0 ? 200 : 429);
+    });
+  }
+  /**
+   * Resolve the SDK IIFE bundle path.
+   * Tries multiple locations for monorepo and installed-package scenarios.
+   */
+  resolveSdkPath() {
+    if (this.sdkBundlePath) return this.sdkBundlePath;
+    const __dir = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+      resolve(__dir, "../../sdk/dist/index.global.js"),
+      // monorepo: packages/collector/dist -> packages/sdk/dist
+      resolve(__dir, "../../../node_modules/@runtimescope/sdk/dist/index.global.js")
+      // npm installed
+    ];
+    for (const p of candidates) {
+      if (existsSync3(p)) {
+        this.sdkBundlePath = p;
+        return p;
+      }
+    }
+    return null;
+  }
+  async start(options = {}) {
+    const basePort = options.port ?? parseInt(process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091", 10);
+    const host = options.host ?? "127.0.0.1";
+    const tls = options.tls;
+    const maxRetries = 5;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const port = basePort + attempt;
+      try {
+        await this.tryStart(port, host, tls);
+        return;
+      } catch (err) {
+        const isAddrInUse = err.code === "EADDRINUSE";
+        if (isAddrInUse && attempt < maxRetries) {
+          console.error(`[RuntimeScope] HTTP port ${port} in use, trying ${port + 1}...`);
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+  tryStart(port, host, tls) {
+    return new Promise((resolve2, reject) => {
+      const handler = (req, res) => this.handleRequest(req, res);
+      const server = tls ? createHttpsServer2(loadTlsOptions(tls), handler) : createServer(handler);
+      this.wss = new WebSocketServer2({ server, path: "/api/ws/events" });
+      this.wss.on("connection", (ws, req) => {
+        if (this.authManager?.isEnabled()) {
+          const wsUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+          const token = wsUrl.searchParams.get("token") ?? AuthManager.extractBearer(req.headers.authorization);
+          if (!this.authManager.isAuthorized(token)) {
+            ws.close(4001, "Authentication required");
+            return;
+          }
+        }
+        this.dashboardClients.add(ws);
+        ws.on("close", () => this.dashboardClients.delete(ws));
+        ws.on("error", () => this.dashboardClients.delete(ws));
+      });
+      this.eventListener = (event) => this.broadcastEvent(event);
+      this.store.onEvent(this.eventListener);
+      server.on("listening", () => {
+        this.server = server;
+        this.activePort = port;
+        this.startedAt = Date.now();
+        const proto = tls ? "https" : "http";
+        console.error(`[RuntimeScope] HTTP API listening on ${proto}://${host}:${port}`);
+        resolve2();
+      });
+      server.on("error", (err) => {
+        this.wss?.close();
+        this.wss = null;
+        if (this.eventListener) {
+          this.store.removeEventListener(this.eventListener);
+          this.eventListener = null;
+        }
+        reject(err);
+      });
+      server.listen(port, host);
+    });
+  }
+  async stop() {
+    if (this.eventListener) {
+      this.store.removeEventListener(this.eventListener);
+      this.eventListener = null;
+    }
+    for (const ws of this.dashboardClients) {
+      ws.close();
+    }
+    this.dashboardClients.clear();
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+    if (this.server) {
+      return new Promise((resolve2) => {
+        this.server.close(() => {
+          this.server = null;
+          console.error("[RuntimeScope] HTTP API stopped");
+          resolve2();
+        });
+      });
+    }
+  }
+  broadcastEvent(event) {
+    if (this.dashboardClients.size === 0) return;
+    const message = JSON.stringify({ type: "event", data: event });
+    for (const ws of this.dashboardClients) {
+      if (ws.readyState === 1) {
+        try {
+          ws.send(message);
+        } catch {
+          this.dashboardClients.delete(ws);
+        }
+      }
+    }
+  }
+  broadcastSessionChange(type, sessionId, appName) {
+    if (this.dashboardClients.size === 0) return;
+    const message = JSON.stringify({ type, sessionId, appName });
+    for (const ws of this.dashboardClients) {
+      if (ws.readyState === 1) {
+        try {
+          ws.send(message);
+        } catch {
+          this.dashboardClients.delete(ws);
+        }
+      }
+    }
+  }
+  broadcastDevServer(msg) {
+    if (this.dashboardClients.size === 0) return;
+    const message = JSON.stringify(msg);
+    for (const ws of this.dashboardClients) {
+      if (ws.readyState === 1) {
+        try {
+          ws.send(message);
+        } catch {
+          this.dashboardClients.delete(ws);
+        }
+      }
+    }
+  }
+  handleRequest(req, res) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    this.setCorsHeaders(req, res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const isPublic = url.pathname === "/api/health" || url.pathname === "/runtimescope.js" || url.pathname === "/snippet";
+    if (!isPublic && this.authManager?.isEnabled()) {
+      const token = AuthManager.extractBearer(req.headers.authorization);
+      if (!this.authManager.isAuthorized(token)) {
+        this.json(res, { error: "Unauthorized", code: "AUTH_FAILED" }, 401);
+        return;
+      }
+    }
+    if (req.method === "GET" && url.pathname === "/runtimescope.js") {
+      const sdkPath = this.resolveSdkPath();
+      if (sdkPath) {
+        const bundle = readFileSync3(sdkPath, "utf-8");
+        res.writeHead(200, {
+          "Content-Type": "application/javascript",
+          "Cache-Control": "no-cache"
+        });
+        res.end(bundle);
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("SDK bundle not found. Run: npm run build -w packages/sdk");
+      }
+      return;
+    }
+    if (req.method === "GET" && url.pathname === "/snippet") {
+      const appName = (url.searchParams.get("app") || "my-app").replace(/[^a-zA-Z0-9_-]/g, "");
+      const wsPort = process.env.RUNTIMESCOPE_PORT ?? "9090";
+      const snippet = `<!-- RuntimeScope SDK \u2014 paste before </body> -->
+<script src="http://localhost:${this.activePort}/runtimescope.js"></script>
+<script>
+  RuntimeScope.init({
+    appName: '${appName}',
+    endpoint: 'ws://localhost:${wsPort}',
+  });
+</script>`;
+      res.writeHead(200, {
+        "Content-Type": "text/plain"
+      });
+      res.end(snippet);
+      return;
+    }
+    const routeKey = `${req.method} ${url.pathname}`;
+    const handler = this.routes.get(routeKey);
+    if (handler) {
+      try {
+        const result = handler(req, res, url.searchParams);
+        if (result instanceof Promise) {
+          result.catch((err) => {
+            this.json(res, { error: err.message }, 500);
+          });
+        }
+      } catch (err) {
+        this.json(res, { error: err.message }, 500);
+      }
+      return;
+    }
+    if (this.pmRouter && url.pathname.startsWith("/api/pm/")) {
+      const match = this.pmRouter.match(req.method, url.pathname);
+      if (match) {
+        for (const [k, v] of Object.entries(match.pathParams)) {
+          url.searchParams.set(k, v);
+        }
+        try {
+          const result = match.handler(req, res, url.searchParams);
+          if (result instanceof Promise) {
+            result.catch((err) => {
+              this.json(res, { error: err.message }, 500);
+            });
+          }
+        } catch (err) {
+          this.json(res, { error: err.message }, 500);
+        }
+        return;
+      }
+    }
+    this.json(res, { error: "Not found", path: url.pathname }, 404);
+  }
+  setCorsHeaders(req, res) {
+    const origin = req.headers.origin;
+    if (this.allowedOrigins && this.allowedOrigins.length > 0) {
+      if (origin && this.allowedOrigins.includes(origin)) {
+        res.setHeader("Access-Control-Allow-Origin", origin);
+        res.setHeader("Vary", "Origin");
+      }
+    } else {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+    }
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  }
+  readBody(req, maxBytes) {
+    return new Promise((resolve2) => {
+      const chunks = [];
+      let size = 0;
+      let resolved = false;
+      const done = (result) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timer);
+        resolve2(result);
+      };
+      const timer = setTimeout(() => {
+        req.destroy();
+        done(null);
+      }, 3e4);
+      req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > maxBytes) {
+          req.destroy();
+          done(null);
+          return;
+        }
+        chunks.push(chunk);
+      });
+      req.on("end", () => {
+        if (size === 0) {
+          done(null);
+          return;
+        }
+        done(Buffer.concat(chunks).toString("utf-8"));
+      });
+      req.on("error", () => done(null));
+    });
+  }
+  json(res, data, status = 200) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  }
+};
+function numParam(params, key) {
+  const val = params.get(key);
+  if (!val) return void 0;
+  const num = parseInt(val, 10);
+  return isNaN(num) ? void 0 : num;
+}
+
+// src/pm/pm-store.ts
+import Database2 from "better-sqlite3";
+var PmStore = class {
+  db;
+  constructor(options) {
+    this.db = new Database2(options.dbPath);
+    if (options.walMode !== false) {
+      this.db.pragma("journal_mode = WAL");
+    }
+    this.db.pragma("synchronous = NORMAL");
+    this.createSchema();
+    this.runMigrations();
+  }
+  createSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS pm_projects (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        path TEXT,
+        claude_project_key TEXT,
+        runtimescope_project TEXT,
+        phase TEXT NOT NULL DEFAULT 'preliminary',
+        management_authorized INTEGER NOT NULL DEFAULT 0,
+        probable_to_complete INTEGER NOT NULL DEFAULT 0,
+        project_status TEXT NOT NULL DEFAULT 'active',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        metadata TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS pm_tasks (
+        id TEXT PRIMARY KEY,
+        project_id TEXT,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL DEFAULT 'todo',
+        priority TEXT NOT NULL DEFAULT 'medium',
+        labels TEXT,
+        source TEXT DEFAULT 'manual',
+        source_ref TEXT,
+        sort_order REAL NOT NULL DEFAULT 0,
+        assigned_to TEXT,
+        due_date TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        FOREIGN KEY (project_id) REFERENCES pm_projects(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pm_tasks_project ON pm_tasks(project_id);
+      CREATE INDEX IF NOT EXISTS idx_pm_tasks_status ON pm_tasks(status);
+      CREATE INDEX IF NOT EXISTS idx_pm_tasks_sort ON pm_tasks(status, sort_order);
+
+      CREATE TABLE IF NOT EXISTS pm_sessions (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        jsonl_path TEXT NOT NULL,
+        jsonl_size INTEGER,
+        first_prompt TEXT,
+        summary TEXT,
+        slug TEXT,
+        model TEXT,
+        version TEXT,
+        git_branch TEXT,
+        message_count INTEGER NOT NULL DEFAULT 0,
+        user_message_count INTEGER NOT NULL DEFAULT 0,
+        assistant_message_count INTEGER NOT NULL DEFAULT 0,
+        total_input_tokens INTEGER NOT NULL DEFAULT 0,
+        total_output_tokens INTEGER NOT NULL DEFAULT 0,
+        total_cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+        total_cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+        cost_microdollars INTEGER NOT NULL DEFAULT 0,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER,
+        active_minutes REAL NOT NULL DEFAULT 0,
+        compaction_count INTEGER NOT NULL DEFAULT 0,
+        pre_compaction_tokens INTEGER,
+        permission_mode TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        FOREIGN KEY (project_id) REFERENCES pm_projects(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pm_sessions_project ON pm_sessions(project_id);
+      CREATE INDEX IF NOT EXISTS idx_pm_sessions_started ON pm_sessions(started_at DESC);
+
+      CREATE TABLE IF NOT EXISTS pm_notes (
+        id TEXT PRIMARY KEY,
+        project_id TEXT,
+        session_id TEXT,
+        title TEXT NOT NULL,
+        content TEXT NOT NULL DEFAULT '',
+        pinned INTEGER NOT NULL DEFAULT 0,
+        tags TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        FOREIGN KEY (project_id) REFERENCES pm_projects(id),
+        FOREIGN KEY (session_id) REFERENCES pm_sessions(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pm_notes_project ON pm_notes(project_id);
+      CREATE INDEX IF NOT EXISTS idx_pm_notes_pinned ON pm_notes(pinned DESC, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS pm_capex_entries (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        classification TEXT NOT NULL DEFAULT 'expensed',
+        work_type TEXT,
+        active_minutes REAL NOT NULL DEFAULT 0,
+        cost_microdollars INTEGER NOT NULL DEFAULT 0,
+        adjustment_factor REAL NOT NULL DEFAULT 1.0,
+        adjusted_cost_microdollars INTEGER NOT NULL DEFAULT 0,
+        confirmed INTEGER NOT NULL DEFAULT 0,
+        confirmed_at INTEGER,
+        confirmed_by TEXT,
+        notes TEXT,
+        period TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        FOREIGN KEY (project_id) REFERENCES pm_projects(id),
+        FOREIGN KEY (session_id) REFERENCES pm_sessions(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pm_capex_project ON pm_capex_entries(project_id);
+      CREATE INDEX IF NOT EXISTS idx_pm_capex_period ON pm_capex_entries(period);
+      CREATE INDEX IF NOT EXISTS idx_pm_capex_confirmed ON pm_capex_entries(confirmed);
+    `);
+  }
+  runMigrations() {
+    try {
+      this.db.exec("ALTER TABLE pm_projects ADD COLUMN category TEXT DEFAULT NULL");
+    } catch {
+    }
+    try {
+      this.db.exec("ALTER TABLE pm_projects ADD COLUMN sdk_installed INTEGER DEFAULT 0");
+    } catch {
+    }
+  }
+  // ============================================================
+  // Projects
+  // ============================================================
+  upsertProject(project) {
+    this.db.prepare(`
+      INSERT INTO pm_projects (id, name, path, claude_project_key, runtimescope_project,
+        phase, management_authorized, probable_to_complete, project_status,
+        category, sdk_installed,
+        created_at, updated_at, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        name = excluded.name,
+        path = COALESCE(excluded.path, pm_projects.path),
+        claude_project_key = COALESCE(excluded.claude_project_key, pm_projects.claude_project_key),
+        runtimescope_project = COALESCE(excluded.runtimescope_project, pm_projects.runtimescope_project),
+        sdk_installed = CASE WHEN excluded.sdk_installed = 1 THEN 1 ELSE pm_projects.sdk_installed END,
+        updated_at = excluded.updated_at,
+        metadata = COALESCE(excluded.metadata, pm_projects.metadata)
+    `).run(
+      project.id,
+      project.name,
+      project.path ?? null,
+      project.claudeProjectKey ?? null,
+      project.runtimescopeProject ?? null,
+      project.phase,
+      project.managementAuthorized ? 1 : 0,
+      project.probableToComplete ? 1 : 0,
+      project.projectStatus,
+      project.category ?? null,
+      project.sdkInstalled ? 1 : 0,
+      project.createdAt,
+      project.updatedAt,
+      project.metadata ? JSON.stringify(project.metadata) : null
+    );
+  }
+  getProject(id) {
+    const row = this.db.prepare("SELECT * FROM pm_projects WHERE id = ?").get(id);
+    return row ? this.mapProjectRow(row) : null;
+  }
+  listProjects() {
+    const rows = this.db.prepare("SELECT * FROM pm_projects ORDER BY name ASC").all();
+    return rows.map((r) => this.mapProjectRow(r));
+  }
+  updateProject(id, updates) {
+    const sets = [];
+    const params = [];
+    if (updates.name !== void 0) {
+      sets.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.phase !== void 0) {
+      sets.push("phase = ?");
+      params.push(updates.phase);
+    }
+    if (updates.managementAuthorized !== void 0) {
+      sets.push("management_authorized = ?");
+      params.push(updates.managementAuthorized ? 1 : 0);
+    }
+    if (updates.probableToComplete !== void 0) {
+      sets.push("probable_to_complete = ?");
+      params.push(updates.probableToComplete ? 1 : 0);
+    }
+    if (updates.projectStatus !== void 0) {
+      sets.push("project_status = ?");
+      params.push(updates.projectStatus);
+    }
+    if (updates.category !== void 0) {
+      sets.push("category = ?");
+      params.push(updates.category);
+    }
+    if (updates.sdkInstalled !== void 0) {
+      sets.push("sdk_installed = ?");
+      params.push(updates.sdkInstalled ? 1 : 0);
+    }
+    if (updates.metadata !== void 0) {
+      sets.push("metadata = ?");
+      params.push(JSON.stringify(updates.metadata));
+    }
+    if (sets.length === 0) return;
+    sets.push("updated_at = ?");
+    params.push(Date.now());
+    params.push(id);
+    this.db.prepare(`UPDATE pm_projects SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  }
+  listCategories() {
+    const rows = this.db.prepare("SELECT DISTINCT category FROM pm_projects WHERE category IS NOT NULL ORDER BY category ASC").all();
+    return rows.map((r) => r.category);
+  }
+  mapProjectRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      path: row.path ?? void 0,
+      claudeProjectKey: row.claude_project_key ?? void 0,
+      runtimescopeProject: row.runtimescope_project ?? void 0,
+      phase: row.phase,
+      managementAuthorized: row.management_authorized === 1,
+      probableToComplete: row.probable_to_complete === 1,
+      projectStatus: row.project_status,
+      category: row.category ?? void 0,
+      sdkInstalled: row.sdk_installed === 1,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    };
+  }
+  // ============================================================
+  // Tasks
+  // ============================================================
+  createTask(task) {
+    this.db.prepare(`
+      INSERT INTO pm_tasks (id, project_id, title, description, status, priority,
+        labels, source, source_ref, sort_order, assigned_to, due_date,
+        created_at, updated_at, completed_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      task.id,
+      task.projectId ?? null,
+      task.title,
+      task.description ?? null,
+      task.status,
+      task.priority,
+      JSON.stringify(task.labels),
+      task.source,
+      task.sourceRef ?? null,
+      task.sortOrder,
+      task.assignedTo ?? null,
+      task.dueDate ?? null,
+      task.createdAt,
+      task.updatedAt,
+      task.completedAt ?? null
+    );
+    return task;
+  }
+  updateTask(id, updates) {
+    const sets = [];
+    const params = [];
+    if (updates.title !== void 0) {
+      sets.push("title = ?");
+      params.push(updates.title);
+    }
+    if (updates.description !== void 0) {
+      sets.push("description = ?");
+      params.push(updates.description);
+    }
+    if (updates.status !== void 0) {
+      sets.push("status = ?");
+      params.push(updates.status);
+    }
+    if (updates.priority !== void 0) {
+      sets.push("priority = ?");
+      params.push(updates.priority);
+    }
+    if (updates.labels !== void 0) {
+      sets.push("labels = ?");
+      params.push(JSON.stringify(updates.labels));
+    }
+    if (updates.sortOrder !== void 0) {
+      sets.push("sort_order = ?");
+      params.push(updates.sortOrder);
+    }
+    if (updates.assignedTo !== void 0) {
+      sets.push("assigned_to = ?");
+      params.push(updates.assignedTo);
+    }
+    if (updates.dueDate !== void 0) {
+      sets.push("due_date = ?");
+      params.push(updates.dueDate);
+    }
+    if (updates.completedAt !== void 0) {
+      sets.push("completed_at = ?");
+      params.push(updates.completedAt);
+    }
+    if (sets.length === 0) return;
+    sets.push("updated_at = ?");
+    params.push(Date.now());
+    params.push(id);
+    this.db.prepare(`UPDATE pm_tasks SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  }
+  deleteTask(id) {
+    this.db.prepare("DELETE FROM pm_tasks WHERE id = ?").run(id);
+  }
+  listTasks(projectId, status) {
+    const conditions = [];
+    const params = [];
+    if (projectId) {
+      conditions.push("project_id = ?");
+      params.push(projectId);
+    }
+    if (status) {
+      conditions.push("status = ?");
+      params.push(status);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT * FROM pm_tasks ${where} ORDER BY sort_order ASC`).all(...params);
+    return rows.map((r) => this.mapTaskRow(r));
+  }
+  reorderTask(id, status, sortOrder) {
+    const now = Date.now();
+    const completedAt = status === "done" ? now : null;
+    this.db.prepare(`
+      UPDATE pm_tasks SET status = ?, sort_order = ?, updated_at = ?, completed_at = COALESCE(?, completed_at)
+      WHERE id = ?
+    `).run(status, sortOrder, now, completedAt, id);
+  }
+  mapTaskRow(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id ?? void 0,
+      title: row.title,
+      description: row.description ?? void 0,
+      status: row.status,
+      priority: row.priority,
+      labels: row.labels ? JSON.parse(row.labels) : [],
+      source: row.source ?? "manual",
+      sourceRef: row.source_ref ?? void 0,
+      sortOrder: row.sort_order,
+      assignedTo: row.assigned_to ?? void 0,
+      dueDate: row.due_date ?? void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      completedAt: row.completed_at ?? void 0
+    };
+  }
+  // ============================================================
+  // Sessions
+  // ============================================================
+  upsertSession(session) {
+    this.db.prepare(`
+      INSERT INTO pm_sessions (id, project_id, jsonl_path, jsonl_size, first_prompt,
+        summary, slug, model, version, git_branch,
+        message_count, user_message_count, assistant_message_count,
+        total_input_tokens, total_output_tokens,
+        total_cache_creation_tokens, total_cache_read_tokens,
+        cost_microdollars, started_at, ended_at, active_minutes,
+        compaction_count, pre_compaction_tokens, permission_mode,
+        created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        jsonl_size = excluded.jsonl_size,
+        first_prompt = COALESCE(excluded.first_prompt, pm_sessions.first_prompt),
+        summary = COALESCE(excluded.summary, pm_sessions.summary),
+        slug = COALESCE(excluded.slug, pm_sessions.slug),
+        model = COALESCE(excluded.model, pm_sessions.model),
+        version = COALESCE(excluded.version, pm_sessions.version),
+        git_branch = COALESCE(excluded.git_branch, pm_sessions.git_branch),
+        message_count = excluded.message_count,
+        user_message_count = excluded.user_message_count,
+        assistant_message_count = excluded.assistant_message_count,
+        total_input_tokens = excluded.total_input_tokens,
+        total_output_tokens = excluded.total_output_tokens,
+        total_cache_creation_tokens = excluded.total_cache_creation_tokens,
+        total_cache_read_tokens = excluded.total_cache_read_tokens,
+        cost_microdollars = excluded.cost_microdollars,
+        ended_at = excluded.ended_at,
+        active_minutes = excluded.active_minutes,
+        compaction_count = excluded.compaction_count,
+        pre_compaction_tokens = excluded.pre_compaction_tokens,
+        permission_mode = excluded.permission_mode,
+        updated_at = excluded.updated_at
+    `).run(
+      session.id,
+      session.projectId,
+      session.jsonlPath,
+      session.jsonlSize ?? null,
+      session.firstPrompt ?? null,
+      session.summary ?? null,
+      session.slug ?? null,
+      session.model ?? null,
+      session.version ?? null,
+      session.gitBranch ?? null,
+      session.messageCount,
+      session.userMessageCount,
+      session.assistantMessageCount,
+      session.totalInputTokens,
+      session.totalOutputTokens,
+      session.totalCacheCreationTokens,
+      session.totalCacheReadTokens,
+      session.costMicrodollars,
+      session.startedAt,
+      session.endedAt ?? null,
+      session.activeMinutes,
+      session.compactionCount,
+      session.preCompactionTokens ?? null,
+      session.permissionMode ?? null,
+      session.createdAt,
+      session.updatedAt
+    );
+  }
+  getSession(id) {
+    const row = this.db.prepare("SELECT * FROM pm_sessions WHERE id = ?").get(id);
+    return row ? this.mapSessionRow(row) : null;
+  }
+  listSessions(projectId, opts) {
+    const limit = opts?.limit ?? 100;
+    const offset = opts?.offset ?? 0;
+    const conditions = [];
+    const params = [];
+    if (projectId) {
+      conditions.push("project_id = ?");
+      params.push(projectId);
+    }
+    if (opts?.startDate) {
+      conditions.push("started_at >= ?");
+      params.push(new Date(opts.startDate).getTime());
+    }
+    if (opts?.endDate) {
+      conditions.push("started_at <= ?");
+      params.push((/* @__PURE__ */ new Date(opts.endDate + "T23:59:59.999Z")).getTime());
+    }
+    if (opts?.hideEmpty) {
+      conditions.push("(message_count > 0 OR total_input_tokens > 0 OR total_output_tokens > 0 OR cost_microdollars > 0 OR active_minutes > 0)");
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT * FROM pm_sessions ${where} ORDER BY started_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+    return rows.map((r) => this.mapSessionRow(r));
+  }
+  getSessionStats(projectId, opts) {
+    const conditions = [];
+    const params = [];
+    if (projectId) {
+      conditions.push("project_id = ?");
+      params.push(projectId);
+    }
+    if (opts?.startDate) {
+      conditions.push("started_at >= ?");
+      params.push(new Date(opts.startDate).getTime());
+    }
+    if (opts?.endDate) {
+      conditions.push("started_at <= ?");
+      params.push((/* @__PURE__ */ new Date(opts.endDate + "T23:59:59.999Z")).getTime());
+    }
+    if (opts?.hideEmpty) {
+      conditions.push("(message_count > 0 OR total_input_tokens > 0 OR total_output_tokens > 0 OR cost_microdollars > 0 OR active_minutes > 0)");
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const row = this.db.prepare(`
+      SELECT
+        COUNT(*) as total_sessions,
+        COALESCE(SUM(active_minutes), 0) as total_active_minutes,
+        COALESCE(SUM(cost_microdollars), 0) as total_cost,
+        COALESCE(SUM(total_input_tokens), 0) as total_input,
+        COALESCE(SUM(total_output_tokens), 0) as total_output,
+        COALESCE(AVG(active_minutes), 0) as avg_minutes
+      FROM pm_sessions ${whereClause}
+    `).get(...params);
+    const modelConditions = [...conditions];
+    if (!modelConditions.some((c) => c.includes("model"))) {
+      modelConditions.push("model IS NOT NULL");
+    }
+    const modelWhere = `WHERE ${modelConditions.join(" AND ")}`;
+    const modelRows = this.db.prepare(`
+      SELECT model, COUNT(*) as sessions, SUM(cost_microdollars) as cost
+      FROM pm_sessions
+      ${modelWhere}
+      GROUP BY model
+      ORDER BY cost DESC
+    `).all(...params);
+    return {
+      totalSessions: row.total_sessions,
+      totalActiveMinutes: row.total_active_minutes,
+      totalCostMicrodollars: row.total_cost,
+      totalInputTokens: row.total_input,
+      totalOutputTokens: row.total_output,
+      avgSessionMinutes: row.avg_minutes,
+      modelBreakdown: modelRows
+    };
+  }
+  getProjectSummaries(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts?.startDate) {
+      conditions.push("s.started_at >= ?");
+      params.push(new Date(opts.startDate).getTime());
+    }
+    if (opts?.endDate) {
+      conditions.push("s.started_at <= ?");
+      params.push((/* @__PURE__ */ new Date(opts.endDate + "T23:59:59.999Z")).getTime());
+    }
+    if (opts?.hideEmpty) {
+      conditions.push("(s.message_count > 0 OR s.total_input_tokens > 0 OR s.total_output_tokens > 0 OR s.cost_microdollars > 0 OR s.active_minutes > 0)");
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = this.db.prepare(`
+      SELECT
+        p.id,
+        p.name,
+        p.path,
+        p.category,
+        p.sdk_installed,
+        p.runtimescope_project,
+        COUNT(s.id) as session_count,
+        COALESCE(SUM(s.cost_microdollars), 0) as total_cost,
+        COALESCE(SUM(s.active_minutes), 0) as total_active_minutes,
+        MAX(s.started_at) as last_session_at,
+        COALESCE(SUM(s.message_count), 0) as total_messages
+      FROM pm_projects p
+      LEFT JOIN pm_sessions s ON s.project_id = p.id ${where ? "AND " + conditions.join(" AND ") : ""}
+      GROUP BY p.id
+      ORDER BY last_session_at DESC NULLS LAST
+    `).all(...params);
+    return rows;
+  }
+  mapSessionRow(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      jsonlPath: row.jsonl_path,
+      jsonlSize: row.jsonl_size ?? void 0,
+      firstPrompt: row.first_prompt ?? void 0,
+      summary: row.summary ?? void 0,
+      slug: row.slug ?? void 0,
+      model: row.model ?? void 0,
+      version: row.version ?? void 0,
+      gitBranch: row.git_branch ?? void 0,
+      messageCount: row.message_count,
+      userMessageCount: row.user_message_count,
+      assistantMessageCount: row.assistant_message_count,
+      totalInputTokens: row.total_input_tokens,
+      totalOutputTokens: row.total_output_tokens,
+      totalCacheCreationTokens: row.total_cache_creation_tokens,
+      totalCacheReadTokens: row.total_cache_read_tokens,
+      costMicrodollars: row.cost_microdollars,
+      startedAt: row.started_at,
+      endedAt: row.ended_at ?? void 0,
+      activeMinutes: row.active_minutes,
+      compactionCount: row.compaction_count,
+      preCompactionTokens: row.pre_compaction_tokens ?? void 0,
+      permissionMode: row.permission_mode ?? void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  // ============================================================
+  // Notes
+  // ============================================================
+  createNote(note) {
+    this.db.prepare(`
+      INSERT INTO pm_notes (id, project_id, session_id, title, content, pinned, tags, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      note.id,
+      note.projectId ?? null,
+      note.sessionId ?? null,
+      note.title,
+      note.content,
+      note.pinned ? 1 : 0,
+      JSON.stringify(note.tags),
+      note.createdAt,
+      note.updatedAt
+    );
+    return note;
+  }
+  updateNote(id, updates) {
+    const sets = [];
+    const params = [];
+    if (updates.title !== void 0) {
+      sets.push("title = ?");
+      params.push(updates.title);
+    }
+    if (updates.content !== void 0) {
+      sets.push("content = ?");
+      params.push(updates.content);
+    }
+    if (updates.pinned !== void 0) {
+      sets.push("pinned = ?");
+      params.push(updates.pinned ? 1 : 0);
+    }
+    if (updates.tags !== void 0) {
+      sets.push("tags = ?");
+      params.push(JSON.stringify(updates.tags));
+    }
+    if (sets.length === 0) return;
+    sets.push("updated_at = ?");
+    params.push(Date.now());
+    params.push(id);
+    this.db.prepare(`UPDATE pm_notes SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  }
+  deleteNote(id) {
+    this.db.prepare("DELETE FROM pm_notes WHERE id = ?").run(id);
+  }
+  listNotes(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts?.projectId) {
+      conditions.push("project_id = ?");
+      params.push(opts.projectId);
+    }
+    if (opts?.pinned !== void 0) {
+      conditions.push("pinned = ?");
+      params.push(opts.pinned ? 1 : 0);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT * FROM pm_notes ${where} ORDER BY pinned DESC, updated_at DESC`).all(...params);
+    return rows.map((r) => this.mapNoteRow(r));
+  }
+  mapNoteRow(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id ?? void 0,
+      sessionId: row.session_id ?? void 0,
+      title: row.title,
+      content: row.content,
+      pinned: row.pinned === 1,
+      tags: row.tags ? JSON.parse(row.tags) : [],
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  // ============================================================
+  // CapEx
+  // ============================================================
+  upsertCapexEntry(entry) {
+    this.db.prepare(`
+      INSERT INTO pm_capex_entries (id, project_id, session_id, classification, work_type,
+        active_minutes, cost_microdollars, adjustment_factor, adjusted_cost_microdollars,
+        confirmed, confirmed_at, confirmed_by, notes, period, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        classification = excluded.classification,
+        work_type = excluded.work_type,
+        active_minutes = excluded.active_minutes,
+        cost_microdollars = excluded.cost_microdollars,
+        adjustment_factor = excluded.adjustment_factor,
+        adjusted_cost_microdollars = excluded.adjusted_cost_microdollars,
+        confirmed = excluded.confirmed,
+        confirmed_at = excluded.confirmed_at,
+        confirmed_by = excluded.confirmed_by,
+        notes = excluded.notes,
+        updated_at = excluded.updated_at
+    `).run(
+      entry.id,
+      entry.projectId,
+      entry.sessionId,
+      entry.classification,
+      entry.workType ?? null,
+      entry.activeMinutes,
+      entry.costMicrodollars,
+      entry.adjustmentFactor,
+      entry.adjustedCostMicrodollars,
+      entry.confirmed ? 1 : 0,
+      entry.confirmedAt ?? null,
+      entry.confirmedBy ?? null,
+      entry.notes ?? null,
+      entry.period,
+      entry.createdAt,
+      entry.updatedAt
+    );
+  }
+  listCapexEntries(projectId, opts) {
+    const conditions = ["project_id = ?"];
+    const params = [projectId];
+    if (opts?.month) {
+      conditions.push("period = ?");
+      params.push(opts.month);
+    }
+    if (opts?.confirmed !== void 0) {
+      conditions.push("confirmed = ?");
+      params.push(opts.confirmed ? 1 : 0);
+    }
+    const where = conditions.join(" AND ");
+    const rows = this.db.prepare(`SELECT * FROM pm_capex_entries WHERE ${where} ORDER BY period DESC, created_at DESC`).all(...params);
+    return rows.map((r) => this.mapCapexRow(r));
+  }
+  updateCapexEntry(id, updates) {
+    const sets = [];
+    const params = [];
+    if (updates.classification !== void 0) {
+      sets.push("classification = ?");
+      params.push(updates.classification);
+    }
+    if (updates.workType !== void 0) {
+      sets.push("work_type = ?");
+      params.push(updates.workType);
+    }
+    if (updates.adjustmentFactor !== void 0) {
+      sets.push("adjustment_factor = ?");
+      params.push(updates.adjustmentFactor);
+      if (updates.costMicrodollars !== void 0) {
+        sets.push("adjusted_cost_microdollars = ?");
+        params.push(Math.round(updates.costMicrodollars * updates.adjustmentFactor));
+      }
+    }
+    if (updates.notes !== void 0) {
+      sets.push("notes = ?");
+      params.push(updates.notes);
+    }
+    if (sets.length === 0) return;
+    sets.push("updated_at = ?");
+    params.push(Date.now());
+    params.push(id);
+    this.db.prepare(`UPDATE pm_capex_entries SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  }
+  confirmCapexEntry(id, confirmedBy) {
+    const now = Date.now();
+    this.db.prepare(`
+      UPDATE pm_capex_entries SET confirmed = 1, confirmed_at = ?, confirmed_by = ?, updated_at = ?
+      WHERE id = ?
+    `).run(now, confirmedBy ?? null, now, id);
+  }
+  getCapexSummary(projectId, opts) {
+    const conditions = ["project_id = ?"];
+    const params = [projectId];
+    if (opts?.startDate) {
+      conditions.push("period >= ?");
+      params.push(opts.startDate);
+    }
+    if (opts?.endDate) {
+      conditions.push("period <= ?");
+      params.push(opts.endDate);
+    }
+    const where = conditions.join(" AND ");
+    const totals = this.db.prepare(`
+      SELECT
+        COUNT(*) as total_sessions,
+        COALESCE(SUM(active_minutes), 0) as total_active_minutes,
+        COALESCE(SUM(adjusted_cost_microdollars), 0) as total_cost,
+        COALESCE(SUM(CASE WHEN classification = 'capitalizable' THEN adjusted_cost_microdollars ELSE 0 END), 0) as cap_cost,
+        COALESCE(SUM(CASE WHEN classification = 'expensed' THEN adjusted_cost_microdollars ELSE 0 END), 0) as exp_cost,
+        COALESCE(SUM(CASE WHEN confirmed = 1 THEN 1 ELSE 0 END), 0) as confirmed_count,
+        COALESCE(SUM(CASE WHEN confirmed = 0 THEN 1 ELSE 0 END), 0) as unconfirmed_count
+      FROM pm_capex_entries WHERE ${where}
+    `).get(...params);
+    const monthlyRows = this.db.prepare(`
+      SELECT
+        period,
+        SUM(CASE WHEN classification = 'capitalizable' THEN adjusted_cost_microdollars ELSE 0 END) as capitalizable,
+        SUM(CASE WHEN classification = 'expensed' THEN adjusted_cost_microdollars ELSE 0 END) as expensed,
+        SUM(active_minutes) as activeMinutes
+      FROM pm_capex_entries
+      WHERE ${where}
+      GROUP BY period
+      ORDER BY period ASC
+    `).all(...params);
+    return {
+      projectId,
+      period: opts?.startDate || opts?.endDate ? { start: opts.startDate ?? "", end: opts.endDate ?? "" } : void 0,
+      totalSessions: totals.total_sessions,
+      totalActiveMinutes: totals.total_active_minutes,
+      totalCostMicrodollars: totals.total_cost,
+      capitalizableCostMicrodollars: totals.cap_cost,
+      expensedCostMicrodollars: totals.exp_cost,
+      confirmedCount: totals.confirmed_count,
+      unconfirmedCount: totals.unconfirmed_count,
+      byMonth: monthlyRows
+    };
+  }
+  exportCapexCsv(projectId, opts) {
+    const entries = this.listCapexEntries(projectId, { month: opts?.startDate });
+    const sessions = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (!sessions.has(entry.sessionId)) {
+        const s = this.getSession(entry.sessionId);
+        if (s) sessions.set(entry.sessionId, s);
+      }
+    }
+    const headers = [
+      "Period",
+      "Session ID",
+      "Session Slug",
+      "Date",
+      "Model",
+      "Active Minutes",
+      "Active Hours",
+      "Cost (USD)",
+      "Classification",
+      "Work Type",
+      "Adjustment Factor",
+      "Adjusted Cost (USD)",
+      "Confirmed",
+      "Confirmed By",
+      "Notes"
+    ];
+    const rows = entries.map((e) => {
+      const s = sessions.get(e.sessionId);
+      const date = s?.startedAt ? new Date(s.startedAt).toISOString().split("T")[0] : "";
+      return [
+        e.period,
+        e.sessionId,
+        s?.slug ?? "",
+        date,
+        s?.model ?? "",
+        e.activeMinutes.toFixed(2),
+        (e.activeMinutes / 60).toFixed(2),
+        (e.costMicrodollars / 1e6).toFixed(4),
+        e.classification,
+        e.workType ?? "",
+        e.adjustmentFactor.toFixed(2),
+        (e.adjustedCostMicrodollars / 1e6).toFixed(4),
+        e.confirmed ? "Yes" : "No",
+        e.confirmedBy ?? "",
+        (e.notes ?? "").replace(/"/g, '""')
+      ].map((v) => `"${v}"`).join(",");
+    });
+    return [headers.join(","), ...rows].join("\n");
+  }
+  mapCapexRow(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      sessionId: row.session_id,
+      classification: row.classification,
+      workType: row.work_type ?? void 0,
+      activeMinutes: row.active_minutes,
+      costMicrodollars: row.cost_microdollars,
+      adjustmentFactor: row.adjustment_factor,
+      adjustedCostMicrodollars: row.adjusted_cost_microdollars,
+      confirmed: row.confirmed === 1,
+      confirmedAt: row.confirmed_at ?? void 0,
+      confirmedBy: row.confirmed_by ?? void 0,
+      notes: row.notes ?? void 0,
+      period: row.period,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  // ============================================================
+  // Cleanup
+  // ============================================================
+  close() {
+    this.db.close();
+  }
+};
+
+// src/pm/session-parser.ts
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+var MODEL_PRICING = {
+  "claude-opus-4-6": { input: 15e6, output: 75e6, cacheWrite: 1875e4, cacheRead: 15e5 },
+  "claude-sonnet-4-6": { input: 3e6, output: 15e6, cacheWrite: 375e4, cacheRead: 3e5 },
+  "claude-sonnet-4-5": { input: 3e6, output: 15e6, cacheWrite: 375e4, cacheRead: 3e5 },
+  "claude-haiku-4-5": { input: 8e5, output: 4e6, cacheWrite: 1e6, cacheRead: 8e4 },
+  "claude-haiku-3-5": { input: 8e5, output: 4e6, cacheWrite: 1e6, cacheRead: 8e4 }
+};
+function calculateActiveMinutes(timestamps, idleThresholdMs = 9e5) {
+  if (timestamps.length < 2) return 0;
+  const sorted = [...timestamps].sort((a, b) => a - b);
+  let activeMs = 0;
+  for (let i = 1; i < sorted.length; i++) {
+    const gap = sorted[i] - sorted[i - 1];
+    if (gap < idleThresholdMs) {
+      activeMs += gap;
+    }
+  }
+  return activeMs / 6e4;
+}
+function lookupPricing(model) {
+  if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+  const stripped = model.replace(/-\d{8}$/, "");
+  if (MODEL_PRICING[stripped]) return MODEL_PRICING[stripped];
+  const keys = Object.keys(MODEL_PRICING);
+  let bestMatch;
+  let bestLen = 0;
+  for (const key of keys) {
+    if (stripped.startsWith(key) && key.length > bestLen) {
+      bestMatch = key;
+      bestLen = key.length;
+    }
+  }
+  if (bestMatch) return MODEL_PRICING[bestMatch];
+  for (const key of keys) {
+    if (key.startsWith(stripped) && key.length > bestLen) {
+      bestMatch = key;
+      bestLen = key.length;
+    }
+  }
+  if (bestMatch) return MODEL_PRICING[bestMatch];
+  return void 0;
+}
+function calculateCostMicrodollars(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+  const pricing = lookupPricing(model);
+  if (!pricing) return 0;
+  return Math.round(
+    (inputTokens * pricing.input + outputTokens * pricing.output + cacheCreationTokens * pricing.cacheWrite + cacheReadTokens * pricing.cacheRead) / 1e6
+  );
+}
+function parseTimestamp(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const ms = Date.parse(value);
+    return Number.isNaN(ms) ? 0 : ms;
+  }
+  return 0;
+}
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (typeof block === "object" && block !== null && block.type === "text") {
+        const text = block.text;
+        if (typeof text === "string") return text;
+      }
+    }
+  }
+  return "";
+}
+async function parseSessionJsonl(jsonlPath, sessionId, projectId) {
+  const session = {
+    id: sessionId,
+    projectId,
+    jsonlPath,
+    messageCount: 0,
+    userMessageCount: 0,
+    assistantMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheCreationTokens: 0,
+    totalCacheReadTokens: 0,
+    costMicrodollars: 0,
+    activeMinutes: 0,
+    compactionCount: 0
+  };
+  const messageTimestamps = [];
+  let firstHumanSeen = false;
+  let earliestTs = Infinity;
+  let latestTs = 0;
+  const rl = createInterface({
+    input: createReadStream(jsonlPath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof obj !== "object" || obj === null) continue;
+    const type = obj.type;
+    const ts = parseTimestamp(obj.timestamp);
+    if (ts > 0) {
+      messageTimestamps.push(ts);
+      if (ts < earliestTs) earliestTs = ts;
+      if (ts > latestTs) latestTs = ts;
+    }
+    if (!session.version && typeof obj.version === "string") {
+      session.version = obj.version;
+    }
+    if (!session.slug && typeof obj.slug === "string") {
+      session.slug = obj.slug;
+    }
+    if (!session.gitBranch && typeof obj.gitBranch === "string") {
+      session.gitBranch = obj.gitBranch;
+    }
+    if (!session.permissionMode && typeof obj.permissionMode === "string") {
+      session.permissionMode = obj.permissionMode;
+    }
+    if (type === "user") {
+      session.messageCount = (session.messageCount ?? 0) + 1;
+      if (!obj.toolUseResult) {
+        session.userMessageCount = (session.userMessageCount ?? 0) + 1;
+        if (!firstHumanSeen) {
+          firstHumanSeen = true;
+          const msg = obj.message;
+          if (msg) {
+            const text = extractTextContent(msg.content);
+            if (text) {
+              session.firstPrompt = text.slice(0, 500);
+            }
+          }
+        }
+      }
+    } else if (type === "assistant") {
+      session.messageCount = (session.messageCount ?? 0) + 1;
+      session.assistantMessageCount = (session.assistantMessageCount ?? 0) + 1;
+      const msg = obj.message;
+      const model = msg?.model ?? obj.model;
+      if (model && typeof model === "string") {
+        session.model = model;
+      }
+      const usage = msg?.usage ?? obj.usage;
+      if (usage && typeof usage === "object") {
+        const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+        const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+        const cacheCreation = typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : 0;
+        const cacheRead = typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : 0;
+        session.totalInputTokens = (session.totalInputTokens ?? 0) + inputTokens;
+        session.totalOutputTokens = (session.totalOutputTokens ?? 0) + outputTokens;
+        session.totalCacheCreationTokens = (session.totalCacheCreationTokens ?? 0) + cacheCreation;
+        session.totalCacheReadTokens = (session.totalCacheReadTokens ?? 0) + cacheRead;
+        if (model) {
+          session.costMicrodollars = (session.costMicrodollars ?? 0) + calculateCostMicrodollars(model, inputTokens, outputTokens, cacheCreation, cacheRead);
+        }
+      }
+    } else if (type === "summary") {
+      session.compactionCount = (session.compactionCount ?? 0) + 1;
+      if (!session.summary && typeof obj.summary === "string") {
+        session.summary = obj.summary;
+      }
+    } else if (type === "system") {
+      session.messageCount = (session.messageCount ?? 0) + 1;
+      const subtype = obj.subtype;
+      if (subtype === "compact_boundary") {
+        session.compactionCount = (session.compactionCount ?? 0) + 1;
+        const meta = obj.compactMetadata;
+        if (meta) {
+          const preTokens = typeof meta.preTokens === "string" ? parseInt(meta.preTokens, 10) : typeof meta.preTokens === "number" ? meta.preTokens : void 0;
+          if (preTokens && !Number.isNaN(preTokens)) {
+            session.preCompactionTokens = preTokens;
+          }
+        }
+      } else {
+        const content = typeof obj.content === "string" ? obj.content : "";
+        if (content.toLowerCase().includes("compact")) {
+          session.compactionCount = (session.compactionCount ?? 0) + 1;
+        }
+      }
+    }
+    const directCost = obj.costUSD ?? obj.cost_usd;
+    if (typeof directCost === "number") {
+      session.costMicrodollars = (session.costMicrodollars ?? 0) + Math.round(directCost * 1e6);
+    }
+  }
+  if (earliestTs < Infinity) {
+    session.startedAt = earliestTs;
+  }
+  if (latestTs > 0) {
+    session.endedAt = latestTs;
+  }
+  session.activeMinutes = calculateActiveMinutes(messageTimestamps);
+  const now = Date.now();
+  session.createdAt = session.startedAt ?? now;
+  session.updatedAt = now;
+  return { session, messageTimestamps };
+}
+
+// src/pm/project-discovery.ts
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import { join as join3, basename as basename2 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+var LOG_PREFIX = "[RuntimeScope PM]";
+async function detectSdkInstalled(projectPath) {
+  try {
+    const pkgPath = join3(projectPath, "package.json");
+    const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if ("@runtimescope/sdk" in allDeps || "@runtimescope/server-sdk" in allDeps) {
+      return true;
+    }
+    if (pkg.workspaces) {
+      const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages ?? [];
+      for (const ws of workspaces) {
+        const wsBase = ws.replace(/\/?\*$/, "");
+        const wsDir = join3(projectPath, wsBase);
+        try {
+          const entries = await readdir2(wsDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isDirectory()) continue;
+            try {
+              const wsPkg = JSON.parse(await readFile2(join3(wsDir, entry.name, "package.json"), "utf-8"));
+              const wsDeps = { ...wsPkg.dependencies, ...wsPkg.devDependencies };
+              if ("@runtimescope/sdk" in wsDeps || "@runtimescope/server-sdk" in wsDeps) {
+                return true;
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    await stat2(join3(projectPath, "node_modules", "@runtimescope"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function emptyResult() {
+  return {
+    projectsDiscovered: 0,
+    projectsUpdated: 0,
+    sessionsDiscovered: 0,
+    sessionsUpdated: 0,
+    errors: []
+  };
+}
+function mergeResults(a, b) {
+  return {
+    projectsDiscovered: (a.projectsDiscovered ?? 0) + (b.projectsDiscovered ?? 0),
+    projectsUpdated: (a.projectsUpdated ?? 0) + (b.projectsUpdated ?? 0),
+    sessionsDiscovered: (a.sessionsDiscovered ?? 0) + (b.sessionsDiscovered ?? 0),
+    sessionsUpdated: (a.sessionsUpdated ?? 0) + (b.sessionsUpdated ?? 0),
+    errors: [...a.errors ?? [], ...b.errors ?? []]
+  };
+}
+function slugifyPath(fsPath) {
+  const parts = fsPath.replace(/\/+$/, "").split("/").filter(Boolean);
+  const segments = parts.length >= 2 ? parts.slice(-2) : parts;
+  return segments.join("--").toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-{3,}/g, "--").replace(/^-|-$/g, "");
+}
+function decodeClaudeKey(key) {
+  const naive = "/" + key.slice(1).replace(/-/g, "/");
+  if (existsSync4(naive)) return naive;
+  const parts = key.slice(1).split("-");
+  return resolvePathSegments(parts);
+}
+function resolvePathSegments(parts) {
+  if (parts.length === 0) return null;
+  function tryResolve(prefix, remaining) {
+    if (remaining.length === 0) {
+      return existsSync4(prefix) ? prefix : null;
+    }
+    for (let count = remaining.length; count >= 1; count--) {
+      const segment = remaining.slice(0, count).join("-");
+      const candidate = join3(prefix, segment);
+      if (count === remaining.length) {
+        if (existsSync4(candidate)) return candidate;
+      } else {
+        try {
+          if (existsSync4(candidate)) {
+            const result = tryResolve(candidate, remaining.slice(count));
+            if (result) return result;
+          }
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+  return tryResolve("/", parts);
+}
+function toPeriod(timestampMs) {
+  const d = new Date(timestampMs);
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  return `${year}-${month}`;
+}
+var ProjectDiscovery = class {
+  constructor(pmStore, projectManager, claudeBaseDir) {
+    this.pmStore = pmStore;
+    this.projectManager = projectManager;
+    this.claudeBaseDir = claudeBaseDir ?? join3(homedir3(), ".claude");
+  }
+  claudeBaseDir;
+  /**
+   * Run full discovery: Claude Code projects + RuntimeScope projects.
+   * Never throws — all errors are captured in the result.
+   */
+  async discoverAll() {
+    const result = emptyResult();
+    try {
+      const [claudeResult, runtimeResult] = await Promise.all([
+        this.discoverClaudeProjects(),
+        this.discoverRuntimeScopeProjects()
+      ]);
+      return mergeResults(claudeResult, runtimeResult);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`${LOG_PREFIX} Fatal discovery error: ${msg}`);
+      result.errors.push(`Fatal discovery error: ${msg}`);
+      return result;
+    }
+  }
+  /**
+   * Discover Claude Code projects from ~/.claude/projects/.
+   */
+  async discoverClaudeProjects() {
+    const result = {
+      projectsDiscovered: 0,
+      projectsUpdated: 0,
+      sessionsDiscovered: 0,
+      sessionsUpdated: 0,
+      errors: []
+    };
+    const projectsDir = join3(this.claudeBaseDir, "projects");
+    try {
+      await stat2(projectsDir);
+    } catch {
+      return result;
+    }
+    let entries;
+    try {
+      const dirEntries = await readdir2(projectsDir, { withFileTypes: true });
+      entries = dirEntries.filter((d) => d.isDirectory()).map((d) => d.name);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`${LOG_PREFIX} Failed to read Claude projects dir: ${msg}`);
+      result.errors.push(`Failed to read Claude projects dir: ${msg}`);
+      return result;
+    }
+    for (const key of entries) {
+      try {
+        await this.processClaudeProject(key, result);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`${LOG_PREFIX} Error processing Claude project ${key}: ${msg}`);
+        result.errors.push(`Claude project ${key}: ${msg}`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Discover RuntimeScope projects from ~/.runtimescope/projects/.
+   */
+  async discoverRuntimeScopeProjects() {
+    const result = {
+      projectsDiscovered: 0,
+      projectsUpdated: 0,
+      sessionsDiscovered: 0,
+      sessionsUpdated: 0,
+      errors: []
+    };
+    try {
+      const runtimeProjects = this.projectManager.listProjects();
+      for (const projectName of runtimeProjects) {
+        try {
+          const projectDir = this.projectManager.getProjectDir(projectName);
+          const id = projectName.toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+          const existingProjects = await this.pmStore.listProjects();
+          const nameLower = projectName.toLowerCase();
+          const existing = existingProjects.find(
+            (p) => p.id === id || p.runtimescopeProject === projectName || p.name.toLowerCase() === nameLower
+          );
+          const now = Date.now();
+          const sourcePath = existing?.path ?? projectDir;
+          const sdkInstalled = await detectSdkInstalled(sourcePath);
+          if (existing) {
+            const updated = {
+              ...existing,
+              runtimescopeProject: projectName,
+              sdkInstalled: sdkInstalled || existing.sdkInstalled,
+              updatedAt: now
+            };
+            await this.pmStore.upsertProject(updated);
+            result.projectsUpdated = (result.projectsUpdated ?? 0) + 1;
+          } else {
+            const fsPath = projectDir;
+            const project = {
+              id,
+              name: projectName,
+              path: fsPath,
+              runtimescopeProject: projectName,
+              phase: "application_development",
+              managementAuthorized: false,
+              probableToComplete: true,
+              projectStatus: "active",
+              sdkInstalled,
+              createdAt: now,
+              updatedAt: now
+            };
+            await this.pmStore.upsertProject(project);
+            result.projectsDiscovered = (result.projectsDiscovered ?? 0) + 1;
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`${LOG_PREFIX} Error processing RuntimeScope project ${projectName}: ${msg}`);
+          result.errors.push(`RuntimeScope project ${projectName}: ${msg}`);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`${LOG_PREFIX} Failed to list RuntimeScope projects: ${msg}`);
+      result.errors.push(`Failed to list RuntimeScope projects: ${msg}`);
+    }
+    return result;
+  }
+  /**
+   * Index all sessions for a given project.
+   * Returns the number of sessions indexed (new or updated).
+   */
+  async indexProjectSessions(projectId) {
+    const existingProjects = await this.pmStore.listProjects();
+    const project = existingProjects.find((p) => p.id === projectId);
+    if (!project) {
+      console.error(`${LOG_PREFIX} Project not found: ${projectId}`);
+      return 0;
+    }
+    if (!project.claudeProjectKey) {
+      return 0;
+    }
+    const projectDir = join3(this.claudeBaseDir, "projects", project.claudeProjectKey);
+    let sessionsIndexed = 0;
+    try {
+      const indexPath = join3(projectDir, "sessions-index.json");
+      let indexEntries = null;
+      try {
+        const indexContent = await readFile2(indexPath, "utf-8");
+        const index = JSON.parse(indexContent);
+        indexEntries = index.entries ?? [];
+      } catch {
+      }
+      const dirEntries = await readdir2(projectDir, { withFileTypes: true });
+      const jsonlFiles = dirEntries.filter((d) => d.isFile() && d.name.endsWith(".jsonl")).map((d) => d.name);
+      for (const jsonlFile of jsonlFiles) {
+        try {
+          const sessionId = jsonlFile.replace(".jsonl", "");
+          const jsonlPath = join3(projectDir, jsonlFile);
+          const fileStat = await stat2(jsonlPath);
+          const fileSize = fileStat.size;
+          const existingSession = await this.pmStore.getSession(sessionId);
+          if (existingSession && existingSession.jsonlSize === fileSize) {
+            continue;
+          }
+          const indexEntry = indexEntries?.find((e) => e.sessionId === sessionId);
+          let session;
+          if (indexEntry) {
+            session = this.buildSessionFromIndex(indexEntry, projectId, jsonlPath, fileSize);
+          } else {
+            session = await this.buildSessionFromJsonl(sessionId, projectId, jsonlPath, fileSize);
+          }
+          await this.pmStore.upsertSession(session);
+          await this.upsertCapexStub(session);
+          sessionsIndexed++;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`${LOG_PREFIX} Error indexing session ${jsonlFile}: ${msg}`);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`${LOG_PREFIX} Error indexing sessions for project ${projectId}: ${msg}`);
+    }
+    return sessionsIndexed;
+  }
+  // ---------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------
+  /**
+   * Process a single Claude project directory key.
+   */
+  async processClaudeProject(key, result) {
+    const projectDir = join3(this.claudeBaseDir, "projects", key);
+    let fsPath = decodeClaudeKey(key);
+    if (!fsPath) {
+      fsPath = await this.resolvePathFromIndex(projectDir);
+    }
+    const id = fsPath ? slugifyPath(fsPath) : slugifyPath(key);
+    const name = fsPath ? basename2(fsPath) : key;
+    const now = Date.now();
+    const existingProjects = await this.pmStore.listProjects();
+    const nameLower = name.toLowerCase();
+    const existing = existingProjects.find(
+      (p) => p.id === id || p.claudeProjectKey === key || p.name.toLowerCase() === nameLower
+    );
+    const resolvedPath = fsPath ?? existing?.path;
+    const sdkInstalled = resolvedPath ? await detectSdkInstalled(resolvedPath) : false;
+    if (existing) {
+      const updated = {
+        ...existing,
+        claudeProjectKey: key,
+        path: fsPath ?? existing.path,
+        sdkInstalled: sdkInstalled || existing.sdkInstalled,
+        updatedAt: now
+      };
+      await this.pmStore.upsertProject(updated);
+      result.projectsUpdated = (result.projectsUpdated ?? 0) + 1;
+    } else {
+      const project = {
+        id,
+        name,
+        path: fsPath ?? void 0,
+        claudeProjectKey: key,
+        phase: "application_development",
+        managementAuthorized: false,
+        probableToComplete: true,
+        projectStatus: "active",
+        sdkInstalled,
+        createdAt: now,
+        updatedAt: now
+      };
+      await this.pmStore.upsertProject(project);
+      result.projectsDiscovered = (result.projectsDiscovered ?? 0) + 1;
+    }
+    const actualId = existing ? existing.id : id;
+    const sessionsIndexed = await this.indexSessionsForClaudeProject(actualId, key);
+    result.sessionsDiscovered = (result.sessionsDiscovered ?? 0) + sessionsIndexed.discovered;
+    result.sessionsUpdated = (result.sessionsUpdated ?? 0) + sessionsIndexed.updated;
+  }
+  /**
+   * Try to resolve the filesystem path from the sessions-index.json projectPath field.
+   */
+  async resolvePathFromIndex(projectDir) {
+    try {
+      const indexPath = join3(projectDir, "sessions-index.json");
+      const content = await readFile2(indexPath, "utf-8");
+      const index = JSON.parse(content);
+      const entry = index.entries?.find((e) => e.projectPath);
+      return entry?.projectPath ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Index sessions for a Claude project directly (used during discovery).
+   * Returns counts of discovered and updated sessions.
+   */
+  async indexSessionsForClaudeProject(projectId, claudeKey) {
+    const counts = { discovered: 0, updated: 0 };
+    const projectDir = join3(this.claudeBaseDir, "projects", claudeKey);
+    try {
+      let indexEntries = null;
+      try {
+        const indexPath = join3(projectDir, "sessions-index.json");
+        const indexContent = await readFile2(indexPath, "utf-8");
+        const index = JSON.parse(indexContent);
+        indexEntries = index.entries ?? [];
+      } catch {
+      }
+      const dirEntries = await readdir2(projectDir, { withFileTypes: true });
+      const jsonlFiles = dirEntries.filter((d) => d.isFile() && d.name.endsWith(".jsonl")).map((d) => d.name);
+      for (const jsonlFile of jsonlFiles) {
+        try {
+          const sessionId = jsonlFile.replace(".jsonl", "");
+          const jsonlPath = join3(projectDir, jsonlFile);
+          const fileStat = await stat2(jsonlPath);
+          const fileSize = fileStat.size;
+          const existingSession = await this.pmStore.getSession(sessionId);
+          if (existingSession && existingSession.jsonlSize === fileSize) {
+            continue;
+          }
+          const indexEntry = indexEntries?.find((e) => e.sessionId === sessionId);
+          let session;
+          if (indexEntry) {
+            session = this.buildSessionFromIndex(indexEntry, projectId, jsonlPath, fileSize);
+          } else {
+            session = await this.buildSessionFromJsonl(sessionId, projectId, jsonlPath, fileSize);
+          }
+          await this.pmStore.upsertSession(session);
+          await this.upsertCapexStub(session);
+          if (existingSession) {
+            counts.updated++;
+          } else {
+            counts.discovered++;
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`${LOG_PREFIX} Error indexing session ${jsonlFile} in ${claudeKey}: ${msg}`);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`${LOG_PREFIX} Error scanning sessions for ${claudeKey}: ${msg}`);
+    }
+    return counts;
+  }
+  /**
+   * Build a PmSession from the fast sessions-index.json entry.
+   * Token counts and cost are zeroed since the index doesn't contain them;
+   * they will be populated on a subsequent full parse if needed.
+   */
+  buildSessionFromIndex(entry, projectId, jsonlPath, jsonlSize) {
+    const now = Date.now();
+    const startedAt = new Date(entry.created).getTime();
+    const endedAt = entry.modified ? new Date(entry.modified).getTime() : void 0;
+    const activeMinutes = endedAt ? Math.max(1, Math.round((endedAt - startedAt) / 6e4)) : 0;
+    return {
+      id: entry.sessionId,
+      projectId,
+      jsonlPath,
+      jsonlSize,
+      firstPrompt: entry.firstPrompt ?? void 0,
+      summary: entry.summary ?? void 0,
+      slug: void 0,
+      model: void 0,
+      version: void 0,
+      gitBranch: entry.gitBranch ?? void 0,
+      messageCount: entry.messageCount ?? 0,
+      userMessageCount: 0,
+      assistantMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCacheCreationTokens: 0,
+      totalCacheReadTokens: 0,
+      costMicrodollars: 0,
+      startedAt,
+      endedAt,
+      activeMinutes,
+      compactionCount: 0,
+      preCompactionTokens: void 0,
+      permissionMode: void 0,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  /**
+   * Build a PmSession by fully parsing a .jsonl file.
+   */
+  async buildSessionFromJsonl(sessionId, projectId, jsonlPath, jsonlSize) {
+    const now = Date.now();
+    let fileMtime = now;
+    try {
+      const fstat = await stat2(jsonlPath);
+      fileMtime = fstat.mtimeMs;
+    } catch {
+    }
+    try {
+      const { session: parsed, messageTimestamps } = await parseSessionJsonl(jsonlPath, sessionId, projectId);
+      const activeMinutes = calculateActiveMinutes(messageTimestamps);
+      const costMicrodollars = parsed.costMicrodollars ?? calculateCostMicrodollars(
+        parsed.model ?? "",
+        parsed.totalInputTokens ?? 0,
+        parsed.totalOutputTokens ?? 0,
+        parsed.totalCacheCreationTokens ?? 0,
+        parsed.totalCacheReadTokens ?? 0
+      );
+      return {
+        id: sessionId,
+        projectId,
+        jsonlPath,
+        jsonlSize,
+        firstPrompt: parsed.firstPrompt ?? void 0,
+        summary: parsed.summary ?? void 0,
+        slug: parsed.slug ?? void 0,
+        model: parsed.model ?? void 0,
+        version: parsed.version ?? void 0,
+        gitBranch: parsed.gitBranch ?? void 0,
+        messageCount: parsed.messageCount ?? 0,
+        userMessageCount: parsed.userMessageCount ?? 0,
+        assistantMessageCount: parsed.assistantMessageCount ?? 0,
+        totalInputTokens: parsed.totalInputTokens ?? 0,
+        totalOutputTokens: parsed.totalOutputTokens ?? 0,
+        totalCacheCreationTokens: parsed.totalCacheCreationTokens ?? 0,
+        totalCacheReadTokens: parsed.totalCacheReadTokens ?? 0,
+        costMicrodollars,
+        startedAt: parsed.startedAt ?? fileMtime,
+        endedAt: parsed.endedAt ?? void 0,
+        activeMinutes,
+        compactionCount: parsed.compactionCount ?? 0,
+        preCompactionTokens: parsed.preCompactionTokens ?? void 0,
+        permissionMode: parsed.permissionMode ?? void 0,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`${LOG_PREFIX} Failed to parse session ${sessionId}: ${msg}`);
+      return {
+        id: sessionId,
+        projectId,
+        jsonlPath,
+        jsonlSize,
+        messageCount: 0,
+        userMessageCount: 0,
+        assistantMessageCount: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCacheCreationTokens: 0,
+        totalCacheReadTokens: 0,
+        costMicrodollars: 0,
+        startedAt: fileMtime,
+        activeMinutes: 0,
+        compactionCount: 0,
+        createdAt: now,
+        updatedAt: now
+      };
+    }
+  }
+  /**
+   * Create or update a CapEx entry stub for a session.
+   * Defaults to 'expensed' classification, unconfirmed.
+   */
+  async upsertCapexStub(session) {
+    try {
+      const now = Date.now();
+      const entry = {
+        id: `capex-${session.id}`,
+        projectId: session.projectId,
+        sessionId: session.id,
+        classification: "expensed",
+        workType: void 0,
+        activeMinutes: session.activeMinutes,
+        costMicrodollars: session.costMicrodollars,
+        adjustmentFactor: 1,
+        adjustedCostMicrodollars: session.costMicrodollars,
+        confirmed: false,
+        confirmedAt: void 0,
+        confirmedBy: void 0,
+        notes: void 0,
+        period: toPeriod(session.startedAt),
+        createdAt: now,
+        updatedAt: now
+      };
+      await this.pmStore.upsertCapexEntry(entry);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`${LOG_PREFIX} Failed to create CapEx stub for session ${session.id}: ${msg}`);
+    }
+  }
+};
+
+export {
+  __require,
+  RingBuffer,
+  EventStore,
+  SqliteStore,
+  SessionRateLimiter,
+  loadTlsOptions,
+  resolveTlsConfig,
+  CollectorServer,
+  ProjectManager,
+  AuthManager,
+  generateApiKey,
+  BUILT_IN_RULES,
+  Redactor,
+  SessionManager,
+  HttpServer,
+  PmStore,
+  calculateActiveMinutes,
+  calculateCostMicrodollars,
+  parseSessionJsonl,
+  ProjectDiscovery
+};
+//# sourceMappingURL=chunk-6JZXAFPC.js.map