browsertrack 0.0.1 → 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,2829 @@
+#!/usr/bin/env node
+
+// packages/cli/src/index.ts
+import { Command } from "commander";
+import fs5 from "fs";
+import path6 from "path";
+
+// packages/daemon/src/config.ts
+import os from "os";
+import path from "path";
+function getDaemonConfig(overrides = {}) {
+  const homeDir = os.homedir();
+  const dataDir = overrides.dataDir || path.join(homeDir, ".browsertrack");
+  const dbPath = overrides.dbPath || path.join(dataDir, "browsertrack.db");
+  const screenshotsDir = overrides.screenshotsDir || path.join(dataDir, "projects");
+  return {
+    host: overrides.host || "127.0.0.1",
+    port: overrides.port || 7331,
+    dataDir,
+    dbPath,
+    screenshotsDir,
+    maxEventsPerSession: overrides.maxEventsPerSession || 1e3,
+    verbose: !!overrides.verbose
+  };
+}
+
+// packages/daemon/src/storage/db.ts
+import Database from "better-sqlite3";
+import fs from "fs";
+import path2 from "path";
+var StorageDB = class {
+  db;
+  constructor(dbPath) {
+    const dir = path2.dirname(dbPath);
+    fs.mkdirSync(dir, { recursive: true });
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.initTables();
+  }
+  initTables() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT UNIQUE,
+        origin TEXT,
+        path TEXT,
+        created_at TEXT,
+        updated_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        project_id TEXT,
+        origin TEXT,
+        url TEXT,
+        title TEXT,
+        user_agent TEXT,
+        connected_at TEXT,
+        last_seen_at TEXT,
+        active INTEGER DEFAULT 1
+      );
+
+      CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        session_id TEXT,
+        event_type TEXT,
+        payload TEXT,
+        timestamp INTEGER,
+        route TEXT,
+        url TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS incidents (
+        id TEXT PRIMARY KEY,
+        project_id TEXT,
+        session_id TEXT,
+        type TEXT,
+        severity TEXT,
+        message TEXT,
+        source_file TEXT,
+        source_line INTEGER,
+        source_col INTEGER,
+        fingerprint TEXT UNIQUE,
+        route TEXT,
+        first_seen TEXT,
+        last_seen TEXT,
+        occurrences INTEGER DEFAULT 1,
+        status TEXT DEFAULT 'OPEN',
+        stack TEXT,
+        breadcrumbs TEXT,
+        network_failures TEXT,
+        last_element TEXT,
+        screenshot_path TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS incident_occurrences (
+        id TEXT PRIMARY KEY,
+        incident_id TEXT,
+        session_id TEXT,
+        timestamp TEXT,
+        route TEXT,
+        url TEXT,
+        stack TEXT,
+        breadcrumbs TEXT,
+        last_element TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS screenshots (
+        id TEXT PRIMARY KEY,
+        incident_id TEXT,
+        file_path TEXT,
+        format TEXT,
+        width INTEGER,
+        height INTEGER,
+        created_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS verifications (
+        id TEXT PRIMARY KEY,
+        incident_id TEXT,
+        status TEXT,
+        checks TEXT,
+        before_screenshot TEXT,
+        after_screenshot TEXT,
+        message TEXT,
+        created_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS notes (
+        id TEXT PRIMARY KEY,
+        project_id TEXT,
+        session_id TEXT,
+        type TEXT,
+        message TEXT,
+        route TEXT,
+        url TEXT,
+        viewport_json TEXT,
+        scroll_json TEXT,
+        target_json TEXT,
+        element_context_json TEXT,
+        region_json TEXT,
+        screenshot_path TEXT,
+        incident_id TEXT,
+        status TEXT DEFAULT 'OPEN',
+        created_at TEXT,
+        updated_at TEXT,
+        resolved_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS note_verifications (
+        id TEXT PRIMARY KEY,
+        note_id TEXT,
+        status TEXT,
+        checks TEXT,
+        geometry_diff TEXT,
+        before_screenshot TEXT,
+        after_screenshot TEXT,
+        message TEXT,
+        created_at TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id, timestamp);
+      CREATE INDEX IF NOT EXISTS idx_incidents_project ON incidents(project_id, status);
+      CREATE INDEX IF NOT EXISTS idx_incidents_fp ON incidents(fingerprint);
+      CREATE INDEX IF NOT EXISTS idx_notes_project ON notes(project_id, status);
+    `);
+  }
+  // --- PROJECTS ---
+  upsertProject(project) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.db.prepare("SELECT * FROM projects WHERE name = ? OR origin = ?").get(project.name, project.origin);
+    if (existing) {
+      this.db.prepare("UPDATE projects SET name = ?, origin = ?, path = COALESCE(?, path), updated_at = ? WHERE id = ?").run(project.name, project.origin, project.path || null, now, existing.id);
+      return {
+        id: existing.id,
+        name: project.name,
+        origin: project.origin,
+        path: project.path || existing.path,
+        createdAt: existing.created_at,
+        updatedAt: now
+      };
+    }
+    this.db.prepare("INSERT INTO projects (id, name, origin, path, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(project.id, project.name, project.origin, project.path || null, now, now);
+    return {
+      id: project.id,
+      name: project.name,
+      origin: project.origin,
+      path: project.path,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  getProject(idOrName) {
+    const row = this.db.prepare("SELECT * FROM projects WHERE id = ? OR name = ?").get(idOrName, idOrName);
+    if (!row) return null;
+    return {
+      id: row.id,
+      name: row.name,
+      origin: row.origin,
+      path: row.path,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  getProjectByOrigin(origin) {
+    const row = this.db.prepare("SELECT * FROM projects WHERE origin = ?").get(origin);
+    if (!row) return null;
+    return {
+      id: row.id,
+      name: row.name,
+      origin: row.origin,
+      path: row.path,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  listProjects() {
+    const rows = this.db.prepare("SELECT * FROM projects ORDER BY updated_at DESC").all();
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      origin: row.origin,
+      path: row.path,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    }));
+  }
+  // --- SESSIONS ---
+  upsertSession(session) {
+    const existing = this.db.prepare("SELECT id FROM sessions WHERE id = ?").get(session.id);
+    if (existing) {
+      this.db.prepare("UPDATE sessions SET url = ?, title = ?, last_seen_at = ?, active = ? WHERE id = ?").run(session.url, session.title, session.lastSeenAt, session.active ? 1 : 0, session.id);
+    } else {
+      this.db.prepare(
+        "INSERT INTO sessions (id, project_id, origin, url, title, user_agent, connected_at, last_seen_at, active) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+      ).run(
+        session.id,
+        session.projectId,
+        session.origin,
+        session.url,
+        session.title,
+        session.userAgent,
+        session.connectedAt,
+        session.lastSeenAt,
+        session.active ? 1 : 0
+      );
+    }
+  }
+  getSession(id) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    if (!row) return null;
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      origin: row.origin,
+      url: row.url,
+      title: row.title,
+      userAgent: row.user_agent,
+      connectedAt: row.connected_at,
+      lastSeenAt: row.last_seen_at,
+      active: row.active === 1
+    };
+  }
+  listSessions(projectId, activeOnly = false) {
+    let sql = "SELECT * FROM sessions WHERE 1=1";
+    const params = [];
+    if (projectId) {
+      sql += " AND project_id = ?";
+      params.push(projectId);
+    }
+    if (activeOnly) {
+      sql += " AND active = 1";
+    }
+    sql += " ORDER BY last_seen_at DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      id: row.id,
+      projectId: row.project_id,
+      origin: row.origin,
+      url: row.url,
+      title: row.title,
+      userAgent: row.user_agent,
+      connectedAt: row.connected_at,
+      lastSeenAt: row.last_seen_at,
+      active: row.active === 1
+    }));
+  }
+  deactivateSession(id) {
+    this.db.prepare("UPDATE sessions SET active = 0, last_seen_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  // --- EVENTS & RETENTION ---
+  insertEvent(event) {
+    this.db.prepare("INSERT INTO events (id, session_id, event_type, payload, timestamp, route, url) VALUES (?, ?, ?, ?, ?, ?, ?)").run(
+      event.id,
+      event.sessionId,
+      event.eventType,
+      JSON.stringify(event.payload),
+      event.timestamp,
+      event.route || "",
+      event.url || ""
+    );
+  }
+  pruneSessionEvents(sessionId, maxEvents = 1e3) {
+    this.db.prepare(
+      `DELETE FROM events 
+         WHERE session_id = ? AND id NOT IN (
+           SELECT id FROM events WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?
+         )`
+    ).run(sessionId, sessionId, maxEvents);
+  }
+  getEvents(options) {
+    let sql = "SELECT * FROM events WHERE 1=1";
+    const params = [];
+    if (options.sessionId) {
+      sql += " AND session_id = ?";
+      params.push(options.sessionId);
+    }
+    if (options.eventType) {
+      sql += " AND event_type = ?";
+      params.push(options.eventType);
+    }
+    sql += " ORDER BY timestamp DESC LIMIT ?";
+    params.push(options.limit || 50);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      id: r.id,
+      sessionId: r.session_id,
+      eventType: r.event_type,
+      payload: JSON.parse(r.payload),
+      timestamp: r.timestamp,
+      route: r.route,
+      url: r.url
+    }));
+  }
+  // --- INCIDENTS ---
+  findIncidentByFingerprint(fingerprint) {
+    const row = this.db.prepare("SELECT * FROM incidents WHERE fingerprint = ?").get(fingerprint);
+    if (!row) return null;
+    return this.mapIncidentRow(row);
+  }
+  getIncident(id) {
+    const row = this.db.prepare("SELECT * FROM incidents WHERE id = ?").get(id);
+    if (!row) return null;
+    return this.mapIncidentRow(row);
+  }
+  listIncidents(options = {}) {
+    let sql = "SELECT * FROM incidents WHERE 1=1";
+    const params = [];
+    if (options.projectId) {
+      sql += " AND project_id = ?";
+      params.push(options.projectId);
+    }
+    if (options.status) {
+      sql += " AND status = ?";
+      params.push(options.status);
+    }
+    if (options.severity) {
+      sql += " AND severity = ?";
+      params.push(options.severity);
+    }
+    sql += " ORDER BY last_seen DESC LIMIT ?";
+    params.push(options.limit || 50);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => this.mapIncidentRow(r));
+  }
+  insertIncident(incident) {
+    this.db.prepare(
+      `INSERT INTO incidents (
+          id, project_id, session_id, type, severity, message, source_file, source_line, source_col,
+          fingerprint, route, first_seen, last_seen, occurrences, status, stack, breadcrumbs,
+          network_failures, last_element, screenshot_path
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      incident.id,
+      incident.projectId,
+      incident.sessionId,
+      incident.type,
+      incident.severity,
+      incident.message,
+      incident.source.file,
+      incident.source.line,
+      incident.source.column || null,
+      incident.fingerprint,
+      incident.route,
+      incident.firstSeen,
+      incident.lastSeen,
+      incident.occurrences,
+      incident.status,
+      incident.stack || null,
+      JSON.stringify(incident.breadcrumbs || []),
+      JSON.stringify(incident.networkFailures || []),
+      incident.lastElement ? JSON.stringify(incident.lastElement) : null,
+      incident.screenshots?.error || null
+    );
+  }
+  updateIncidentOccurrence(incidentId, update) {
+    this.db.prepare(
+      `UPDATE incidents 
+         SET session_id = ?, last_seen = ?, occurrences = ?, route = ?, breadcrumbs = ?, last_element = COALESCE(?, last_element), stack = COALESCE(?, stack)
+         WHERE id = ?`
+    ).run(
+      update.sessionId,
+      update.lastSeen,
+      update.occurrences,
+      update.route,
+      JSON.stringify(update.breadcrumbs || []),
+      update.lastElement ? JSON.stringify(update.lastElement) : null,
+      update.stack || null,
+      incidentId
+    );
+  }
+  updateIncidentStatus(id, status) {
+    this.db.prepare("UPDATE incidents SET status = ? WHERE id = ?").run(status, id);
+  }
+  insertIncidentOccurrence(occurrence) {
+    this.db.prepare(
+      `INSERT INTO incident_occurrences (id, incident_id, session_id, timestamp, route, url, stack, breadcrumbs, last_element)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      occurrence.id,
+      occurrence.incidentId,
+      occurrence.sessionId,
+      occurrence.timestamp,
+      occurrence.route,
+      occurrence.url,
+      occurrence.stack || null,
+      JSON.stringify(occurrence.breadcrumbs || []),
+      occurrence.lastElement ? JSON.stringify(occurrence.lastElement) : null
+    );
+  }
+  // --- VERIFICATIONS ---
+  insertVerification(v) {
+    this.db.prepare(
+      `INSERT INTO verifications (id, incident_id, status, checks, before_screenshot, after_screenshot, message, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      v.id,
+      v.incidentId,
+      v.status,
+      JSON.stringify(v.checks),
+      v.beforeScreenshot || null,
+      v.afterScreenshot || null,
+      v.message || null,
+      v.createdAt
+    );
+  }
+  getLatestVerification(incidentId) {
+    const row = this.db.prepare("SELECT * FROM verifications WHERE incident_id = ? ORDER BY created_at DESC LIMIT 1").get(incidentId);
+    if (!row) return null;
+    return {
+      incidentId: row.incident_id,
+      status: row.status,
+      checks: JSON.parse(row.checks || "[]"),
+      screenshots: {
+        before: row.before_screenshot || void 0,
+        after: row.after_screenshot || void 0
+      },
+      timestamp: row.created_at,
+      message: row.message || void 0
+    };
+  }
+  // --- VISUAL NOTES ---
+  insertNote(note) {
+    this.db.prepare(
+      `INSERT INTO notes (
+          id, project_id, session_id, type, message, route, url,
+          viewport_json, scroll_json, target_json, element_context_json, region_json,
+          screenshot_path, incident_id, status, created_at, updated_at, resolved_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      note.id,
+      note.projectId,
+      note.sessionId,
+      note.type,
+      note.message,
+      note.route,
+      note.url,
+      JSON.stringify(note.viewport),
+      JSON.stringify(note.scroll),
+      note.target ? JSON.stringify(note.target) : null,
+      note.elementContext ? JSON.stringify(note.elementContext) : null,
+      note.region ? JSON.stringify(note.region) : null,
+      note.screenshots?.original || null,
+      note.incidentId || null,
+      note.status,
+      note.createdAt,
+      note.updatedAt,
+      note.resolvedAt || null
+    );
+  }
+  getNote(id) {
+    const row = this.db.prepare("SELECT * FROM notes WHERE id = ?").get(id);
+    if (!row) return null;
+    return this.mapNoteRow(row);
+  }
+  listNotes(options = {}) {
+    let sql = "SELECT * FROM notes WHERE 1=1";
+    const params = [];
+    if (options.projectId) {
+      sql += " AND project_id = ?";
+      params.push(options.projectId);
+    }
+    if (options.status) {
+      sql += " AND status = ?";
+      params.push(options.status);
+    }
+    sql += " ORDER BY created_at DESC LIMIT ?";
+    params.push(options.limit || 50);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => this.mapNoteRow(r));
+  }
+  updateNoteStatus(id, status) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const resolvedAt = status === "RESOLVED" ? now : null;
+    this.db.prepare("UPDATE notes SET status = ?, updated_at = ?, resolved_at = COALESCE(?, resolved_at) WHERE id = ?").run(status, now, resolvedAt, id);
+  }
+  updateNote(id, updates) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const current = this.getNote(id);
+    if (!current) return;
+    this.db.prepare(
+      `UPDATE notes 
+         SET message = COALESCE(?, message), status = COALESCE(?, status),
+             screenshot_path = COALESCE(?, screenshot_path), updated_at = ?
+         WHERE id = ?`
+    ).run(
+      updates.message || null,
+      updates.status || null,
+      updates.screenshots?.original || updates.screenshots?.after || null,
+      now,
+      id
+    );
+  }
+  insertNoteVerification(v) {
+    this.db.prepare(
+      `INSERT INTO note_verifications (
+          id, note_id, status, checks, geometry_diff, before_screenshot, after_screenshot, message, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      `nver_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      v.noteId,
+      v.status,
+      JSON.stringify(v.checks),
+      v.geometryDiff ? JSON.stringify(v.geometryDiff) : null,
+      v.screenshots?.before || null,
+      v.screenshots?.after || null,
+      v.message || null,
+      v.timestamp
+    );
+  }
+  getLatestNoteVerification(noteId) {
+    const row = this.db.prepare("SELECT * FROM note_verifications WHERE note_id = ? ORDER BY created_at DESC LIMIT 1").get(noteId);
+    if (!row) return null;
+    return {
+      noteId: row.note_id,
+      status: row.status,
+      checks: JSON.parse(row.checks || "[]"),
+      geometryDiff: row.geometry_diff ? JSON.parse(row.geometry_diff) : void 0,
+      screenshots: {
+        before: row.before_screenshot || void 0,
+        after: row.after_screenshot || void 0
+      },
+      timestamp: row.created_at,
+      message: row.message || void 0
+    };
+  }
+  clearAll() {
+    this.db.exec(`
+      DELETE FROM events;
+      DELETE FROM incident_occurrences;
+      DELETE FROM incidents;
+      DELETE FROM screenshots;
+      DELETE FROM verifications;
+      DELETE FROM notes;
+      DELETE FROM note_verifications;
+      DELETE FROM sessions;
+    `);
+  }
+  mapIncidentRow(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      sessionId: row.session_id,
+      type: row.type,
+      severity: row.severity,
+      message: row.message,
+      source: {
+        file: row.source_file,
+        line: row.source_line,
+        column: row.source_col || void 0
+      },
+      fingerprint: row.fingerprint,
+      route: row.route,
+      firstSeen: row.first_seen,
+      lastSeen: row.last_seen,
+      occurrences: row.occurrences,
+      status: row.status,
+      stack: row.stack || void 0,
+      breadcrumbs: JSON.parse(row.breadcrumbs || "[]"),
+      networkFailures: JSON.parse(row.network_failures || "[]"),
+      lastElement: row.last_element ? JSON.parse(row.last_element) : void 0,
+      screenshots: row.screenshot_path ? {
+        error: row.screenshot_path
+      } : void 0
+    };
+  }
+  mapNoteRow(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      sessionId: row.session_id,
+      type: row.type,
+      message: row.message,
+      route: row.route,
+      url: row.url,
+      viewport: JSON.parse(row.viewport_json || "{}"),
+      scroll: JSON.parse(row.scroll_json || "{}"),
+      target: row.target_json ? JSON.parse(row.target_json) : void 0,
+      elementContext: row.element_context_json ? JSON.parse(row.element_context_json) : void 0,
+      region: row.region_json ? JSON.parse(row.region_json) : void 0,
+      status: row.status,
+      incidentId: row.incident_id || void 0,
+      screenshots: row.screenshot_path ? {
+        original: row.screenshot_path
+      } : void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      resolvedAt: row.resolved_at || void 0
+    };
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// packages/daemon/src/storage/screenshot-store.ts
+import fs2 from "fs";
+import path3 from "path";
+var ScreenshotStore = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+    fs2.mkdirSync(this.baseDir, { recursive: true });
+  }
+  saveScreenshot(projectId, incidentId, name, dataUrl) {
+    try {
+      if (!dataUrl || !dataUrl.startsWith("data:image/")) return null;
+      const match = dataUrl.match(/^data:image\/([a-zA-Z0-9+]+);base64,(.+)$/);
+      if (!match) return null;
+      let format = match[1].toLowerCase();
+      if (format === "jpeg") format = "jpg";
+      const base64Data = match[2];
+      const buffer = Buffer.from(base64Data, "base64");
+      const targetDir = path3.join(this.baseDir, projectId || "default", "incidents", incidentId);
+      fs2.mkdirSync(targetDir, { recursive: true });
+      const fileName = `${name}.${format}`;
+      const filePath = path3.join(targetDir, fileName);
+      fs2.writeFileSync(filePath, buffer);
+      return { filePath, format };
+    } catch {
+      return null;
+    }
+  }
+  getScreenshotPath(projectId, incidentId, name) {
+    const targetDir = path3.join(this.baseDir, projectId || "default", "incidents", incidentId);
+    if (!fs2.existsSync(targetDir)) return null;
+    const files = fs2.readdirSync(targetDir);
+    const match = files.find((f) => f.startsWith(`${name}.`));
+    if (match) {
+      return path3.join(targetDir, match);
+    }
+    return null;
+  }
+};
+
+// packages/daemon/src/session/manager.ts
+var SessionManager = class {
+  activeSockets = /* @__PURE__ */ new Map();
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  registerSocket(sessionId, ws, origin, projectId) {
+    this.activeSockets.set(sessionId, {
+      sessionId,
+      ws,
+      origin,
+      projectId,
+      pendingCommands: /* @__PURE__ */ new Map()
+    });
+  }
+  unregisterSocket(sessionId) {
+    const active = this.activeSockets.get(sessionId);
+    if (active) {
+      for (const pending of active.pendingCommands.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("Session disconnected before command completed"));
+      }
+      active.pendingCommands.clear();
+      this.activeSockets.delete(sessionId);
+      this.db.deactivateSession(sessionId);
+    }
+  }
+  handleCommandResponse(sessionId, response) {
+    const active = this.activeSockets.get(sessionId);
+    if (!active) return;
+    const pending = active.pendingCommands.get(response.id);
+    if (pending) {
+      clearTimeout(pending.timer);
+      active.pendingCommands.delete(response.id);
+      pending.resolve(response);
+    }
+  }
+  async sendCommand(sessionId, command, timeoutMs = 5e3) {
+    const active = this.activeSockets.get(sessionId);
+    if (!active || active.ws.readyState !== 1) {
+      return {
+        id: command.id,
+        ok: false,
+        error: `Session ${sessionId} is not actively connected`
+      };
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        active.pendingCommands.delete(command.id);
+        resolve({
+          id: command.id,
+          ok: false,
+          error: `Command ${command.type} timed out after ${timeoutMs}ms`
+        });
+      }, timeoutMs);
+      active.pendingCommands.set(command.id, {
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        active.ws.send(
+          JSON.stringify({
+            type: "command",
+            command
+          })
+        );
+      } catch (err) {
+        clearTimeout(timer);
+        active.pendingCommands.delete(command.id);
+        resolve({
+          id: command.id,
+          ok: false,
+          error: err?.message || "Failed to send command over WebSocket"
+        });
+      }
+    });
+  }
+  getActiveSessionForProject(projectId) {
+    for (const active of this.activeSockets.values()) {
+      if (active.projectId === projectId) {
+        return this.db.getSession(active.sessionId);
+      }
+    }
+    return null;
+  }
+  getAnyActiveSession() {
+    const first = this.activeSockets.keys().next().value;
+    if (!first) return null;
+    return this.db.getSession(first);
+  }
+  getActiveCount() {
+    return this.activeSockets.size;
+  }
+};
+
+// packages/daemon/src/incidents/engine.ts
+import crypto from "crypto";
+
+// packages/core/src/fingerprint.ts
+function normalizeErrorMessage(message) {
+  if (!message) return "unknown_error";
+  return message.trim().replace(/0x[0-9a-fA-F]+/g, "0x<HEX>").replace(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/g, "<UUID>").replace(/\?[tv]=[\w.-]+/g, "").replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z?/g, "<TIMESTAMP>").replace(/#\d+/g, "#<ID>").replace(/\s+/g, " ");
+}
+function normalizeSourceFile(filename) {
+  if (!filename) return "unknown_source";
+  let cleaned = filename.trim();
+  try {
+    if (cleaned.startsWith("http://") || cleaned.startsWith("https://")) {
+      const url = new URL(cleaned);
+      cleaned = url.pathname;
+    }
+  } catch {
+    cleaned = cleaned.replace(/^https?:\/\/[^/]+/, "");
+  }
+  cleaned = cleaned.split("?")[0].split("#")[0];
+  cleaned = cleaned.replace(/\\/g, "/");
+  return cleaned || "unknown_source";
+}
+function extractSourceFromStack(stack) {
+  if (!stack) return null;
+  const lines = stack.split("\n");
+  for (const line of lines) {
+    const match = line.match(/(?:at\s+(?:.*?\s+\()?)?(https?:\/\/[^\s)]+|file:\/\/[^\s)]+|\/[^\s)]+):(\d+):(\d+)\)?/);
+    if (match) {
+      return {
+        file: normalizeSourceFile(match[1]),
+        line: parseInt(match[2], 10),
+        column: parseInt(match[3], 10)
+      };
+    }
+  }
+  return null;
+}
+function djb2Hash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function computeFingerprint(input) {
+  const normType = (input.type || "Error").trim().toLowerCase();
+  const normMsg = normalizeErrorMessage(input.message);
+  let sourceFile = normalizeSourceFile(input.sourceFile);
+  let line = input.line || 0;
+  if ((sourceFile === "unknown_source" || line === 0) && input.stack) {
+    const extracted = extractSourceFromStack(input.stack);
+    if (extracted) {
+      sourceFile = extracted.file;
+      line = extracted.line;
+    }
+  }
+  const rawKey = `${normType}::${normMsg}::${sourceFile}::${line}`;
+  const hash = djb2Hash(rawKey);
+  return `fp_${hash}`;
+}
+
+// packages/core/src/redaction.ts
+var SENSITIVE_KEY_PATTERNS = [
+  /^authorization$/i,
+  /^cookie$/i,
+  /^set-cookie$/i,
+  /password/i,
+  /token/i,
+  /secret/i,
+  /api[-_]?key/i,
+  /access[-_]?token/i,
+  /refresh[-_]?token/i,
+  /credentials/i,
+  /private[-_]?key/i,
+  /ssn/i,
+  /credit[-_]?card/i,
+  /cvv/i
+];
+var SENSITIVE_QUERY_PARAMS = [
+  "token",
+  "auth",
+  "key",
+  "apikey",
+  "api_key",
+  "secret",
+  "password",
+  "access_token",
+  "refresh_token",
+  "code",
+  "signature"
+];
+var REDACTED_PLACEHOLDER = "[REDACTED]";
+function isSensitiveKey(key) {
+  if (!key) return false;
+  const cleaned = key.replace(/[-_]/g, "");
+  return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key) || pattern.test(cleaned));
+}
+function redactUrl(rawUrl) {
+  if (!rawUrl) return rawUrl;
+  try {
+    const isRelative = !rawUrl.startsWith("http://") && !rawUrl.startsWith("https://") && !rawUrl.startsWith("ws://") && !rawUrl.startsWith("wss://");
+    const base = "http://localhost";
+    const parsed = new URL(rawUrl, base);
+    let changed = false;
+    for (const param of SENSITIVE_QUERY_PARAMS) {
+      if (parsed.searchParams.has(param)) {
+        parsed.searchParams.set(param, REDACTED_PLACEHOLDER);
+        changed = true;
+      }
+    }
+    for (const key of Array.from(parsed.searchParams.keys())) {
+      if (isSensitiveKey(key)) {
+        parsed.searchParams.set(key, REDACTED_PLACEHOLDER);
+        changed = true;
+      }
+    }
+    if (!changed) return rawUrl;
+    let result = isRelative ? parsed.pathname + parsed.search + parsed.hash : parsed.toString();
+    result = result.replace(/%5BREDACTED%5D/g, REDACTED_PLACEHOLDER);
+    return result;
+  } catch {
+    let safe = rawUrl;
+    for (const param of SENSITIVE_QUERY_PARAMS) {
+      const reg = new RegExp(`([?&]${param}=)[^&#]+`, "gi");
+      safe = safe.replace(reg, `$1${REDACTED_PLACEHOLDER}`);
+    }
+    return safe;
+  }
+}
+function redactSensitiveData(data, maxDepth = 6, currentDepth = 0) {
+  if (data === null || data === void 0) return data;
+  if (typeof data !== "object") return data;
+  if (currentDepth > maxDepth) return "[DEPTH_EXCEEDED]";
+  if (Array.isArray(data)) {
+    return data.map((item) => redactSensitiveData(item, maxDepth, currentDepth + 1));
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (typeof value === "object" && value !== null) {
+      result[key] = redactSensitiveData(value, maxDepth, currentDepth + 1);
+    } else if (isSensitiveKey(key)) {
+      result[key] = REDACTED_PLACEHOLDER;
+    } else if (typeof value === "string") {
+      if (value.startsWith("http://") || value.startsWith("https://") || value.includes("?")) {
+        result[key] = redactUrl(value);
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// packages/daemon/src/incidents/engine.ts
+var IncidentEngine = class {
+  db;
+  screenshotStore;
+  constructor(db, screenshotStore) {
+    this.db = db;
+    this.screenshotStore = screenshotStore;
+  }
+  processClientEvent(message) {
+    const session = this.db.getSession(message.sessionId);
+    const projectId = session?.projectId || "default";
+    const sanitizedBreadcrumbs = (message.breadcrumbs || []).map((b) => redactSensitiveData(b));
+    const sanitizedLastElement = message.lastElement ? redactSensitiveData(message.lastElement) : void 0;
+    const networkFailures = sanitizedBreadcrumbs.filter((b) => (b.type === "fetch" || b.type === "xhr") && b.level === "error" && b.data).map((b) => ({
+      url: b.message.split(" ")[1] || "",
+      method: b.message.split(" ")[0] || "GET",
+      status: b.data?.status,
+      durationMs: b.data?.durationMs || 0,
+      error: b.data?.error,
+      aborted: b.data?.aborted,
+      timestamp: b.timestamp
+    }));
+    if (message.eventType === "runtime_error" || message.eventType === "unhandled_rejection") {
+      const payload = message.payload;
+      return this.handleErrorEvent({
+        projectId,
+        sessionId: message.sessionId,
+        type: payload.errorType || "runtime_exception",
+        severity: "error",
+        message: payload.message || "Unknown runtime error",
+        stack: payload.stack,
+        sourceFile: payload.filename,
+        line: payload.lineno,
+        column: payload.colno,
+        route: message.route || "/",
+        url: message.url,
+        breadcrumbs: sanitizedBreadcrumbs,
+        networkFailures,
+        lastElement: sanitizedLastElement,
+        screenshotDataUrl: message.screenshot
+      });
+    }
+    if (message.eventType === "console") {
+      const payload = message.payload;
+      if (payload.level === "error") {
+        return this.handleErrorEvent({
+          projectId,
+          sessionId: message.sessionId,
+          type: "console_error",
+          severity: "error",
+          message: payload.message,
+          stack: payload.stack,
+          route: message.route || "/",
+          url: message.url,
+          breadcrumbs: sanitizedBreadcrumbs,
+          networkFailures,
+          lastElement: sanitizedLastElement,
+          screenshotDataUrl: message.screenshot
+        });
+      }
+    }
+    return null;
+  }
+  handleErrorEvent(input) {
+    const extracted = (!input.sourceFile || !input.line) && input.stack ? extractSourceFromStack(input.stack) : null;
+    const rawSource = input.sourceFile || extracted?.file || "unknown_source";
+    const sourceFile = normalizeSourceFile(rawSource);
+    const line = input.line || extracted?.line || 0;
+    const column = input.column || extracted?.column;
+    const fingerprint = computeFingerprint({
+      type: input.type,
+      message: input.message,
+      sourceFile,
+      line,
+      column,
+      stack: input.stack
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.db.findIncidentByFingerprint(fingerprint);
+    if (existing) {
+      const updatedOccurrences = existing.occurrences + 1;
+      this.db.updateIncidentOccurrence(existing.id, {
+        sessionId: input.sessionId,
+        lastSeen: now,
+        occurrences: updatedOccurrences,
+        route: input.route,
+        breadcrumbs: input.breadcrumbs,
+        lastElement: input.lastElement,
+        stack: input.stack
+      });
+      const occurrenceId = `occ_${crypto.randomUUID().slice(0, 8)}`;
+      this.db.insertIncidentOccurrence({
+        id: occurrenceId,
+        incidentId: existing.id,
+        sessionId: input.sessionId,
+        timestamp: now,
+        route: input.route,
+        url: input.url,
+        stack: input.stack,
+        breadcrumbs: input.breadcrumbs,
+        lastElement: input.lastElement
+      });
+      return {
+        ...existing,
+        occurrences: updatedOccurrences,
+        lastSeen: now,
+        breadcrumbs: input.breadcrumbs,
+        lastElement: input.lastElement || existing.lastElement
+      };
+    }
+    const incidentId = `inc_${crypto.randomUUID().slice(0, 8)}`;
+    let screenshotPath;
+    if (input.screenshotDataUrl) {
+      const saved = this.screenshotStore.saveScreenshot(input.projectId, incidentId, "error", input.screenshotDataUrl);
+      if (saved) {
+        screenshotPath = saved.filePath;
+      }
+    }
+    const newIncident = {
+      id: incidentId,
+      projectId: input.projectId,
+      sessionId: input.sessionId,
+      type: input.type,
+      severity: input.severity,
+      message: input.message,
+      source: {
+        file: sourceFile,
+        line,
+        column
+      },
+      fingerprint,
+      route: input.route,
+      firstSeen: now,
+      lastSeen: now,
+      occurrences: 1,
+      status: "OPEN",
+      stack: input.stack,
+      breadcrumbs: input.breadcrumbs,
+      networkFailures: input.networkFailures,
+      lastElement: input.lastElement,
+      screenshots: screenshotPath ? { error: screenshotPath } : void 0
+    };
+    this.db.insertIncident(newIncident);
+    this.db.insertIncidentOccurrence({
+      id: `occ_${crypto.randomUUID().slice(0, 8)}`,
+      incidentId,
+      sessionId: input.sessionId,
+      timestamp: now,
+      route: input.route,
+      url: input.url,
+      stack: input.stack,
+      breadcrumbs: input.breadcrumbs,
+      lastElement: input.lastElement
+    });
+    return newIncident;
+  }
+};
+
+// packages/daemon/src/notes/engine.ts
+import crypto2 from "crypto";
+import path4 from "path";
+import fs3 from "fs";
+var NotesEngine = class {
+  db;
+  screenshotStore;
+  constructor(db, screenshotStore) {
+    this.db = db;
+    this.screenshotStore = screenshotStore;
+  }
+  createNoteFromClient(payload) {
+    const session = this.db.getSession(payload.sessionId);
+    const projectId = session?.projectId || "default";
+    const noteId = `note_${crypto2.randomUUID().slice(0, 8)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let screenshotPath;
+    if (payload.screenshot) {
+      const saved = this.saveNoteScreenshot(projectId, noteId, "original", payload.screenshot);
+      if (saved) {
+        screenshotPath = saved;
+      }
+    }
+    const note = {
+      id: noteId,
+      projectId,
+      sessionId: payload.sessionId,
+      type: payload.noteType || "element",
+      message: payload.message,
+      route: payload.route || "/",
+      url: payload.url || "",
+      viewport: payload.viewport || { width: 1280, height: 800, devicePixelRatio: 1 },
+      scroll: payload.scroll || { scrollX: 0, scrollY: 0 },
+      target: payload.target,
+      elementContext: payload.elementContext,
+      region: payload.region,
+      status: "OPEN",
+      incidentId: payload.incidentId,
+      screenshots: screenshotPath ? { original: screenshotPath } : void 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.insertNote(note);
+    return note;
+  }
+  saveNoteScreenshot(projectId, noteId, name, dataUrl) {
+    try {
+      if (!dataUrl || !dataUrl.startsWith("data:image/")) return null;
+      const match = dataUrl.match(/^data:image\/([a-zA-Z0-9+]+);base64,(.+)$/);
+      if (!match) return null;
+      let format = match[1].toLowerCase();
+      if (format === "jpeg") format = "jpg";
+      const base64Data = match[2];
+      const buffer = Buffer.from(base64Data, "base64");
+      const targetDir = path4.join(this.screenshotStore.baseDir, projectId || "default", "notes", noteId);
+      fs3.mkdirSync(targetDir, { recursive: true });
+      const fileName = `${name}.${format}`;
+      const filePath = path4.join(targetDir, fileName);
+      fs3.writeFileSync(filePath, buffer);
+      return filePath;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// packages/daemon/src/notes/verification.ts
+import crypto3 from "crypto";
+var NoteVerificationEngine = class {
+  db;
+  sessionManager;
+  notesEngine;
+  constructor(db, sessionManager, notesEngine) {
+    this.db = db;
+    this.sessionManager = sessionManager;
+    this.notesEngine = notesEngine;
+  }
+  async verifyNote(noteId, options = {}) {
+    const note = this.db.getNote(noteId);
+    if (!note) {
+      return {
+        noteId,
+        status: "FAILED",
+        checks: [{ type: "note_exists", passed: false, details: `Note ${noteId} not found` }],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: `Note ${noteId} not found in database`
+      };
+    }
+    let session = this.sessionManager.getActiveSessionForProject(note.projectId);
+    if (!session) {
+      session = this.sessionManager.getAnyActiveSession();
+    }
+    if (!session) {
+      const result = {
+        noteId,
+        status: "INCONCLUSIVE",
+        checks: [],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: "No active browser session currently connected to verify visual note."
+      };
+      this.recordNoteVerification(result, note);
+      return result;
+    }
+    this.db.updateNoteStatus(noteId, "VERIFYING");
+    const pageStateCmd = await this.sessionManager.sendCommand(session.id, {
+      id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+      type: "get_page_state"
+    });
+    const currentRoute = pageStateCmd.result?.route || "/";
+    const isRouteMatch = currentRoute === note.route || currentRoute.startsWith(note.route);
+    if (!isRouteMatch && note.route) {
+      await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+        type: "navigate",
+        params: { url: note.route }
+      });
+      await new Promise((r) => setTimeout(r, options.observationWindowMs || 1e3));
+    }
+    const checks = [];
+    checks.push({
+      type: "route_loaded",
+      passed: true,
+      details: `Route ${note.route || "/"} loaded`
+    });
+    const targetSelector = note.target?.selector || (note.type === "page" ? "body" : "body");
+    let elementExists = true;
+    let elementVisible = true;
+    let currentRect;
+    let overflowResult;
+    if (note.type === "element" && targetSelector) {
+      const queryCmd = await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+        type: "query_element",
+        params: { selector: targetSelector }
+      });
+      elementExists = queryCmd.ok && !!queryCmd.result?.exists;
+      elementVisible = queryCmd.ok && !!queryCmd.result?.visible;
+      currentRect = queryCmd.result?.boundingRect;
+      checks.push({
+        type: "element_exists",
+        passed: elementExists,
+        details: elementExists ? `Element ${targetSelector} exists in DOM` : `Element ${targetSelector} not found`
+      });
+      checks.push({
+        type: "element_visible",
+        passed: elementVisible,
+        details: elementVisible ? `Element ${targetSelector} is visible` : `Element ${targetSelector} is hidden`
+      });
+      const overflowCmd = await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+        type: "check_overflow",
+        params: { selector: targetSelector }
+      });
+      if (overflowCmd.ok && overflowCmd.result) {
+        const ovf = overflowCmd.result;
+        overflowResult = ovf;
+        const isOverflowingNow = !!ovf.overflow;
+        checks.push({
+          type: "no_viewport_overflow",
+          passed: !isOverflowingNow,
+          details: !isOverflowingNow ? `Element fits within viewport (width: ${ovf.viewportWidth}px, rect right: ${ovf.rect?.right}px)` : `Element overflows viewport by ${ovf.overflowRightPx}px (rect right: ${ovf.rect?.right}px, viewport: ${ovf.viewportWidth}px)`
+        });
+      }
+    }
+    let afterScreenshotPath;
+    const captureCmd = await this.sessionManager.sendCommand(session.id, {
+      id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+      type: "capture_element",
+      params: { selector: targetSelector }
+    });
+    if (captureCmd.ok && captureCmd.result?.dataUrl) {
+      const saved = this.notesEngine.saveNoteScreenshot(note.projectId, note.id, "after", captureCmd.result.dataUrl);
+      if (saved) {
+        afterScreenshotPath = saved;
+      }
+    }
+    const beforeRect = note.target?.boundingRect;
+    const overflowFixed = overflowResult ? !overflowResult.overflow : void 0;
+    const geometryDiff = {
+      before: beforeRect,
+      current: currentRect || overflowResult?.rect,
+      viewportWidth: overflowResult?.viewportWidth || note.viewport.width,
+      overflowFixed,
+      overflowPx: overflowResult?.overflowRightPx || 0
+    };
+    const anyFailed = checks.some((c) => !c.passed);
+    let status = "VERIFIED";
+    if (anyFailed) {
+      status = "FAILED";
+    } else {
+      status = "VERIFIED";
+    }
+    const verificationResult = {
+      noteId,
+      status,
+      checks,
+      geometryDiff,
+      screenshots: {
+        before: note.screenshots?.original,
+        after: afterScreenshotPath
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message: status === "VERIFIED" ? "Visual note verified: target element is present, visible, and layout checks (including viewport overflow) passed." : "Visual note verification failed: target element missing, hidden, or still overflowing."
+    };
+    this.recordNoteVerification(verificationResult, note);
+    return verificationResult;
+  }
+  recordNoteVerification(result, note) {
+    this.db.updateNoteStatus(note.id, result.status);
+    this.db.insertNoteVerification(result);
+  }
+};
+
+// packages/daemon/src/verification/engine.ts
+import crypto4 from "crypto";
+var VerificationEngine = class {
+  db;
+  sessionManager;
+  screenshotStore;
+  constructor(db, sessionManager, screenshotStore) {
+    this.db = db;
+    this.sessionManager = sessionManager;
+    this.screenshotStore = screenshotStore;
+  }
+  async verifyIncident(incidentId, recipe) {
+    const incident = this.db.getIncident(incidentId);
+    if (!incident) {
+      return {
+        incidentId,
+        status: "FAILED",
+        checks: [{ type: "no_incident", passed: false, details: `Incident ${incidentId} not found` }],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: `Incident ${incidentId} not found in database`
+      };
+    }
+    let session = this.sessionManager.getActiveSessionForProject(incident.projectId);
+    if (!session) {
+      session = this.sessionManager.getAnyActiveSession();
+    }
+    if (!session) {
+      const result = {
+        incidentId,
+        status: "INCONCLUSIVE",
+        checks: [],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: "No active browser session currently connected to verify the fix."
+      };
+      this.recordVerification(result, incident);
+      return result;
+    }
+    this.db.updateIncidentStatus(incidentId, "VERIFYING");
+    const baselineOccurrences = incident.occurrences;
+    const targetRoute = recipe?.route || incident.route;
+    const observationMs = recipe?.observationWindowMs || 2e3;
+    if (recipe?.route && recipe.route !== incident.route) {
+      await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
+        type: "navigate",
+        params: { url: recipe.route }
+      });
+    } else {
+      await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
+        type: "reload",
+        params: { force: true }
+      });
+    }
+    await new Promise((resolve) => setTimeout(resolve, observationMs));
+    const freshIncident = this.db.getIncident(incidentId);
+    const hasReoccurred = freshIncident ? freshIncident.occurrences > baselineOccurrences : false;
+    const checks = [];
+    checks.push({
+      type: "no_incident",
+      passed: !hasReoccurred,
+      details: hasReoccurred ? `Incident reoccurred (${freshIncident?.occurrences} occurrences vs baseline ${baselineOccurrences})` : "No recurring error observed during verification window"
+    });
+    const probes = recipe?.expect || [];
+    for (const probe of probes) {
+      const probeRes = await this.evaluateProbe(session.id, probe);
+      checks.push(probeRes);
+    }
+    let afterScreenshotPath;
+    const targetSelector = recipe?.targetSelector || incident.lastElement?.selector;
+    if (targetSelector) {
+      const captureCmd = await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
+        type: "capture_element",
+        params: { selector: targetSelector }
+      });
+      if (captureCmd.ok && captureCmd.result?.dataUrl) {
+        const saved = this.screenshotStore.saveScreenshot(
+          incident.projectId,
+          incident.id,
+          "verified",
+          captureCmd.result.dataUrl
+        );
+        if (saved) {
+          afterScreenshotPath = saved.filePath;
+        }
+      }
+    }
+    let verdict = "VERIFIED";
+    const anyCheckFailed = checks.some((c) => !c.passed);
+    if (anyCheckFailed || hasReoccurred) {
+      verdict = "FAILED";
+    } else {
+      const wasInteractionError = incident.breadcrumbs.some((b) => b.type === "click" || b.type === "submit");
+      if (wasInteractionError && probes.length === 0) {
+        verdict = "INCONCLUSIVE";
+      }
+    }
+    const verificationResult = {
+      incidentId,
+      status: verdict,
+      checks,
+      screenshots: {
+        before: incident.screenshots?.error,
+        after: afterScreenshotPath
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message: verdict === "VERIFIED" ? "Fix verified: Error did not reoccur and all checks passed." : verdict === "FAILED" ? "Verification failed: Error reoccurred or probe expectation was not met." : "Verification inconclusive: Error did not appear on reload, but specific interaction may need manual verification or custom probes."
+    };
+    this.recordVerification(verificationResult, incident);
+    return verificationResult;
+  }
+  async evaluateProbe(sessionId, probe) {
+    try {
+      switch (probe.type) {
+        case "element_exists": {
+          if (!probe.selector) {
+            return { type: probe.type, passed: false, details: "Missing selector in probe" };
+          }
+          const res = await this.sessionManager.sendCommand(sessionId, {
+            id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
+            type: "query_element",
+            params: { selector: probe.selector }
+          });
+          const exists = res.ok && !!res.result?.exists;
+          return {
+            type: probe.type,
+            passed: exists,
+            details: exists ? `Element ${probe.selector} exists in DOM` : `Element ${probe.selector} does not exist`
+          };
+        }
+        case "element_visible": {
+          if (!probe.selector) {
+            return { type: probe.type, passed: false, details: "Missing selector in probe" };
+          }
+          const res = await this.sessionManager.sendCommand(sessionId, {
+            id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
+            type: "query_element",
+            params: { selector: probe.selector }
+          });
+          const visible = res.ok && !!res.result?.exists && !!res.result?.visible;
+          return {
+            type: probe.type,
+            passed: visible,
+            details: visible ? `Element ${probe.selector} is visible` : `Element ${probe.selector} is not visible`
+          };
+        }
+        case "text_contains": {
+          if (!probe.selector || !probe.text) {
+            return { type: probe.type, passed: false, details: "Missing selector or text in probe" };
+          }
+          const res = await this.sessionManager.sendCommand(sessionId, {
+            id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
+            type: "query_element",
+            params: { selector: probe.selector }
+          });
+          const innerText = res.result?.innerText || "";
+          const contains = res.ok && innerText.includes(probe.text);
+          return {
+            type: probe.type,
+            passed: contains,
+            details: contains ? `Element ${probe.selector} contains text "${probe.text}"` : `Element text "${innerText}" did not contain "${probe.text}"`
+          };
+        }
+        case "route_is": {
+          if (!probe.route) {
+            return { type: probe.type, passed: false, details: "Missing route in probe" };
+          }
+          const res = await this.sessionManager.sendCommand(sessionId, {
+            id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
+            type: "get_page_state"
+          });
+          const currentRoute = res.result?.route || "";
+          const matches = res.ok && (currentRoute === probe.route || currentRoute.startsWith(probe.route));
+          return {
+            type: probe.type,
+            passed: matches,
+            details: matches ? `Current route matches ${probe.route}` : `Current route is "${currentRoute}", expected "${probe.route}"`
+          };
+        }
+        default:
+          return {
+            type: probe.type,
+            passed: true,
+            details: `Probe ${probe.type} evaluated`
+          };
+      }
+    } catch (err) {
+      return {
+        type: probe.type,
+        passed: false,
+        details: err?.message || "Probe execution error"
+      };
+    }
+  }
+  recordVerification(result, incident) {
+    this.db.updateIncidentStatus(incident.id, result.status);
+    this.db.insertVerification({
+      id: `ver_${crypto4.randomUUID().slice(0, 8)}`,
+      incidentId: incident.id,
+      status: result.status,
+      checks: result.checks,
+      beforeScreenshot: result.screenshots?.before,
+      afterScreenshot: result.screenshots?.after,
+      message: result.message,
+      createdAt: result.timestamp
+    });
+  }
+};
+
+// packages/daemon/src/server/http.ts
+import fs4 from "fs";
+import path5 from "path";
+import { fileURLToPath } from "url";
+function createHttpHandler(db, sessionManager, baseScreenshotsDir) {
+  return (req, res) => {
+    const parsedUrl = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+    const pathname = parsedUrl.pathname;
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (pathname === "/health" || pathname === "/") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          status: "ok",
+          name: "browsertrack",
+          version: "0.1.0",
+          activeSessions: sessionManager.getActiveCount(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      return;
+    }
+    if (pathname === "/client.js" || pathname === "/browserdiag.js") {
+      let scriptContent = "";
+      try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path5.dirname(__filename);
+        const candidatePaths = [
+          path5.resolve(__dirname, "../client.iife.js"),
+          path5.resolve(__dirname, "../../dist/client.iife.js"),
+          path5.resolve(__dirname, "../../../dist/client.iife.js")
+        ];
+        for (const p of candidatePaths) {
+          if (fs4.existsSync(p)) {
+            scriptContent = fs4.readFileSync(p, "utf-8");
+            break;
+          }
+        }
+      } catch {
+      }
+      if (!scriptContent) {
+        scriptContent = `console.warn("[BrowserTrack] Standalone client bundle not built yet. Run 'npm run build'.");`;
+      }
+      res.writeHead(200, {
+        "Content-Type": "application/javascript; charset=utf-8",
+        "Cache-Control": "no-cache"
+      });
+      res.end(scriptContent);
+      return;
+    }
+    if (pathname === "/api/projects") {
+      const projects = db.listProjects();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, projects }));
+      return;
+    }
+    if (pathname === "/api/sessions") {
+      const projectId = parsedUrl.searchParams.get("project") || void 0;
+      const activeOnly = parsedUrl.searchParams.get("active") === "true";
+      const sessions = db.listSessions(projectId, activeOnly);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, sessions }));
+      return;
+    }
+    if (pathname === "/api/incidents") {
+      const projectId = parsedUrl.searchParams.get("project") || void 0;
+      const status = parsedUrl.searchParams.get("status") || void 0;
+      const limit = parseInt(parsedUrl.searchParams.get("limit") || "50", 10);
+      const incidents = db.listIncidents({ projectId, status, limit });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, incidents }));
+      return;
+    }
+    if (pathname.startsWith("/api/incidents/")) {
+      const incidentId = pathname.replace("/api/incidents/", "");
+      const incident = db.getIncident(incidentId);
+      if (!incident) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Incident not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, incident }));
+      return;
+    }
+    if (pathname === "/api/notes") {
+      const projectId = parsedUrl.searchParams.get("project") || void 0;
+      const status = parsedUrl.searchParams.get("status") || void 0;
+      const limit = parseInt(parsedUrl.searchParams.get("limit") || "50", 10);
+      const notes = db.listNotes({ projectId, status, limit });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, notes }));
+      return;
+    }
+    if (pathname.startsWith("/api/notes/")) {
+      const noteId = pathname.replace("/api/notes/", "");
+      const note = db.getNote(noteId);
+      if (!note) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Note not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, note }));
+      return;
+    }
+    if (pathname.startsWith("/screenshots/")) {
+      const relativePath = pathname.replace("/screenshots/", "");
+      const filePath = path5.join(baseScreenshotsDir, relativePath);
+      if (fs4.existsSync(filePath) && fs4.statSync(filePath).isFile()) {
+        const ext = path5.extname(filePath).toLowerCase();
+        const mimeTypes = {
+          ".webp": "image/webp",
+          ".png": "image/png",
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg"
+        };
+        res.writeHead(200, { "Content-Type": mimeTypes[ext] || "application/octet-stream" });
+        fs4.createReadStream(filePath).pipe(res);
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: false, error: "Screenshot not found" }));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: false, error: "Not found" }));
+  };
+}
+
+// packages/daemon/src/server/ws.ts
+import crypto5 from "crypto";
+function setupWebSocketServer(wss, db, sessionManager, incidentEngine, notesEngine, maxEventsPerSession = 1e3, verbose = false) {
+  wss.on("connection", (ws) => {
+    let currentSessionId = null;
+    ws.on("message", (raw) => {
+      try {
+        const text = typeof raw === "string" ? raw : raw.toString("utf-8");
+        const data = JSON.parse(text);
+        if (data.type === "hello") {
+          const hello = data;
+          const sessionId = `sess_${crypto5.randomUUID().slice(0, 8)}`;
+          currentSessionId = sessionId;
+          let project = hello.projectId ? db.getProject(hello.projectId) : null;
+          if (!project && hello.origin) {
+            project = db.getProjectByOrigin(hello.origin);
+          }
+          if (!project) {
+            let projName = "default";
+            try {
+              const url = new URL(hello.origin || "http://localhost");
+              projName = url.port ? `app-${url.port}` : url.hostname;
+            } catch {
+              projName = "app";
+            }
+            project = db.upsertProject({
+              id: `proj_${crypto5.randomUUID().slice(0, 8)}`,
+              name: projName,
+              origin: hello.origin || "http://localhost"
+            });
+          }
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          db.upsertSession({
+            id: sessionId,
+            projectId: project.id,
+            origin: hello.origin || "",
+            url: hello.url || "",
+            title: hello.title || "",
+            userAgent: hello.userAgent || "",
+            connectedAt: now,
+            lastSeenAt: now,
+            active: true
+          });
+          sessionManager.registerSocket(sessionId, ws, hello.origin || "", project.id);
+          ws.send(
+            JSON.stringify({
+              type: "hello_ack",
+              sessionId,
+              projectId: project.id,
+              projectName: project.name
+            })
+          );
+          if (verbose) {
+            console.log(`[BrowserTrack] New session connected: ${sessionId} (${project.name} @ ${hello.origin})`);
+          }
+          return;
+        }
+        if (data.type === "event") {
+          const eventMsg = data;
+          const sessionId = eventMsg.sessionId || currentSessionId;
+          if (!sessionId) return;
+          const eventId = `evt_${crypto5.randomUUID().slice(0, 8)}`;
+          db.insertEvent({
+            id: eventId,
+            sessionId,
+            eventType: eventMsg.eventType,
+            payload: eventMsg.payload,
+            timestamp: eventMsg.timestamp || Date.now(),
+            route: eventMsg.route,
+            url: eventMsg.url
+          });
+          db.pruneSessionEvents(sessionId, maxEventsPerSession);
+          const incident = incidentEngine.processClientEvent(eventMsg);
+          if (incident && verbose) {
+            console.log(
+              `[BrowserTrack] Incident recorded: ${incident.id} (${incident.type}: ${incident.message}) [${incident.occurrences}x]`
+            );
+          }
+          return;
+        }
+        if (data.type === "create_note" && notesEngine) {
+          const note = notesEngine.createNoteFromClient({
+            sessionId: data.sessionId || currentSessionId || "",
+            noteType: data.noteType,
+            message: data.message,
+            route: data.route,
+            url: data.url,
+            viewport: data.viewport,
+            scroll: data.scroll,
+            target: data.target,
+            elementContext: data.elementContext,
+            region: data.region,
+            screenshot: data.screenshot,
+            incidentId: data.incidentId
+          });
+          if (verbose) {
+            console.log(`[BrowserTrack] Visual note created: ${note.id} on ${note.route} ("${note.message}")`);
+          }
+          ws.send(
+            JSON.stringify({
+              type: "note_created_ack",
+              noteId: note.id,
+              status: note.status
+            })
+          );
+          return;
+        }
+        if (data.type === "command_response") {
+          const res = data.response;
+          const sessionId = data.sessionId || currentSessionId;
+          if (sessionId && res) {
+            sessionManager.handleCommandResponse(sessionId, res);
+          }
+          return;
+        }
+      } catch (err) {
+        if (verbose) {
+          console.error("[BrowserTrack] WebSocket message error:", err?.message);
+        }
+      }
+    });
+    ws.on("close", () => {
+      if (currentSessionId) {
+        sessionManager.unregisterSocket(currentSessionId);
+        if (verbose) {
+          console.log(`[BrowserTrack] Session disconnected: ${currentSessionId}`);
+        }
+      }
+    });
+    ws.on("error", () => {
+      if (currentSessionId) {
+        sessionManager.unregisterSocket(currentSessionId);
+      }
+    });
+  });
+}
+
+// packages/daemon/src/server/daemon.ts
+import http from "http";
+import { WebSocketServer } from "ws";
+var BrowserTrackDaemon = class {
+  config;
+  db;
+  screenshotStore;
+  sessionManager;
+  incidentEngine;
+  notesEngine;
+  verificationEngine;
+  noteVerificationEngine;
+  httpServer = null;
+  wss = null;
+  isRunning = false;
+  constructor(config = {}) {
+    this.config = getDaemonConfig(config);
+    this.db = new StorageDB(this.config.dbPath);
+    this.screenshotStore = new ScreenshotStore(this.config.screenshotsDir);
+    this.sessionManager = new SessionManager(this.db);
+    this.incidentEngine = new IncidentEngine(this.db, this.screenshotStore);
+    this.notesEngine = new NotesEngine(this.db, this.screenshotStore);
+    this.verificationEngine = new VerificationEngine(this.db, this.sessionManager, this.screenshotStore);
+    this.noteVerificationEngine = new NoteVerificationEngine(this.db, this.sessionManager, this.notesEngine);
+  }
+  async start() {
+    if (this.isRunning) return;
+    const httpHandler = createHttpHandler(this.db, this.sessionManager, this.config.screenshotsDir);
+    this.httpServer = http.createServer(httpHandler);
+    this.wss = new WebSocketServer({ server: this.httpServer });
+    setupWebSocketServer(
+      this.wss,
+      this.db,
+      this.sessionManager,
+      this.incidentEngine,
+      this.notesEngine,
+      this.config.maxEventsPerSession,
+      this.config.verbose
+    );
+    await new Promise((resolve, reject) => {
+      this.httpServer.listen(this.config.port, this.config.host, () => {
+        this.isRunning = true;
+        if (this.config.verbose) {
+          console.log(`[BrowserTrack] Daemon running at http://${this.config.host}:${this.config.port}`);
+        }
+        resolve();
+      });
+      this.httpServer.once("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  async stop() {
+    if (!this.isRunning) return;
+    if (this.wss) {
+      for (const client of this.wss.clients) {
+        try {
+          client.terminate();
+        } catch {
+        }
+      }
+      await new Promise((resolve) => {
+        this.wss.close(() => resolve());
+      });
+      this.wss = null;
+    }
+    if (this.httpServer) {
+      if (typeof this.httpServer.closeAllConnections === "function") {
+        this.httpServer.closeAllConnections();
+      }
+      await new Promise((resolve) => {
+        this.httpServer.close(() => resolve());
+      });
+      this.httpServer = null;
+    }
+    try {
+      this.db.close();
+    } catch {
+    }
+    this.isRunning = false;
+  }
+  getStatus() {
+    return {
+      isRunning: this.isRunning,
+      host: this.config.host,
+      port: this.config.port,
+      activeSessions: this.sessionManager.getActiveCount(),
+      dbPath: this.config.dbPath
+    };
+  }
+};
+
+// packages/daemon/src/index.ts
+function createDaemon(config = {}) {
+  return new BrowserTrackDaemon(config);
+}
+
+// packages/mcp/src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// packages/mcp/src/handlers.ts
+async function handleToolCall(name, args, ctx) {
+  const { db, sessionManager, verificationEngine, noteVerificationEngine } = ctx;
+  switch (name) {
+    case "list_projects": {
+      const projects = db.listProjects();
+      return {
+        projects: projects.map((p) => ({
+          id: p.id,
+          name: p.name,
+          origin: p.origin,
+          path: p.path,
+          updatedAt: p.updatedAt
+        }))
+      };
+    }
+    case "list_sessions": {
+      const activeOnly = args.activeOnly !== false;
+      const sessions = db.listSessions(args.projectId, activeOnly);
+      return {
+        count: sessions.length,
+        sessions: sessions.map((s) => ({
+          id: s.id,
+          projectId: s.projectId,
+          origin: s.origin,
+          url: s.url,
+          title: s.title,
+          active: s.active,
+          lastSeenAt: s.lastSeenAt
+        }))
+      };
+    }
+    case "list_incidents": {
+      const incidents = db.listIncidents({
+        projectId: args.projectId,
+        status: args.status,
+        severity: args.severity,
+        limit: args.limit || 20
+      });
+      return {
+        total: incidents.length,
+        incidents: incidents.map((inc) => ({
+          id: inc.id,
+          type: inc.type,
+          severity: inc.severity,
+          message: inc.message,
+          source: `${inc.source.file}:${inc.source.line}`,
+          route: inc.route,
+          status: inc.status,
+          occurrences: inc.occurrences,
+          firstSeen: inc.firstSeen,
+          lastSeen: inc.lastSeen
+        }))
+      };
+    }
+    case "get_incident": {
+      const incident = db.getIncident(args.incidentId);
+      if (!incident) {
+        throw new Error(`Incident '${args.incidentId}' not found.`);
+      }
+      const breadcrumbsTimeline = incident.breadcrumbs.slice(-15).map((b) => {
+        const time = new Date(b.timestamp).toISOString().split("T")[1]?.slice(0, 8);
+        return `[${time}] ${b.message}`;
+      });
+      return {
+        id: incident.id,
+        status: incident.status,
+        type: incident.type,
+        severity: incident.severity,
+        message: incident.message,
+        source: {
+          file: incident.source.file,
+          line: incident.source.line,
+          column: incident.source.column
+        },
+        route: incident.route,
+        occurrences: incident.occurrences,
+        firstSeen: incident.firstSeen,
+        lastSeen: incident.lastSeen,
+        stack: incident.stack,
+        lastInteractedElement: incident.lastElement ? {
+          selector: incident.lastElement.selector,
+          tag: incident.lastElement.tag,
+          visible: incident.lastElement.visible,
+          innerText: incident.lastElement.innerText,
+          outerHTML: incident.lastElement.outerHTML
+        } : void 0,
+        recentBreadcrumbs: breadcrumbsTimeline,
+        networkFailures: incident.networkFailures,
+        screenshot: incident.screenshots?.error
+      };
+    }
+    case "get_console": {
+      const limit = args.limit || 30;
+      const events = db.getEvents({
+        sessionId: args.sessionId,
+        eventType: "console",
+        limit
+      });
+      return {
+        logs: events.map((e) => ({
+          level: e.payload.level,
+          message: e.payload.message,
+          timestamp: new Date(e.timestamp).toISOString(),
+          route: e.route
+        }))
+      };
+    }
+    case "get_network_failures": {
+      const limit = args.limit || 20;
+      const events = db.getEvents({
+        sessionId: args.sessionId,
+        limit: 100
+      });
+      const failures = events.filter((e) => (e.eventType === "fetch" || e.eventType === "xhr") && (e.payload.status >= 400 || e.payload.error)).slice(0, limit).map((e) => ({
+        url: e.payload.url,
+        method: e.payload.method,
+        status: e.payload.status,
+        error: e.payload.error,
+        durationMs: e.payload.durationMs,
+        timestamp: new Date(e.timestamp).toISOString()
+      }));
+      return { failures };
+    }
+    case "get_breadcrumbs": {
+      if (args.incidentId) {
+        const incident = db.getIncident(args.incidentId);
+        if (!incident) {
+          throw new Error(`Incident '${args.incidentId}' not found.`);
+        }
+        return {
+          incidentId: args.incidentId,
+          breadcrumbs: incident.breadcrumbs.slice(-(args.limit || 50))
+        };
+      }
+      const events = db.getEvents({
+        sessionId: args.sessionId,
+        limit: args.limit || 50
+      });
+      return {
+        breadcrumbs: events.map((e) => ({
+          type: e.eventType,
+          message: e.payload.message || `${e.eventType} on ${e.route}`,
+          timestamp: new Date(e.timestamp).toISOString(),
+          route: e.route
+        }))
+      };
+    }
+    case "get_page_state": {
+      if (!sessionManager) {
+        throw new Error("Live browser connection not available: Daemon session manager not attached.");
+      }
+      let session = args.sessionId ? db.getSession(args.sessionId) : sessionManager.getAnyActiveSession();
+      if (!session) {
+        throw new Error("No active browser session connected.");
+      }
+      const cmdRes = await sessionManager.sendCommand(session.id, {
+        id: `cmd_mcp_${Date.now()}`,
+        type: "get_page_state"
+      });
+      if (!cmdRes.ok) {
+        throw new Error(cmdRes.error || "Failed to retrieve page state from browser.");
+      }
+      return cmdRes.result;
+    }
+    case "capture_element": {
+      if (!sessionManager) {
+        throw new Error("Live browser connection not available: Daemon session manager not attached.");
+      }
+      let session = args.sessionId ? db.getSession(args.sessionId) : sessionManager.getAnyActiveSession();
+      if (!session) {
+        throw new Error("No active browser session connected.");
+      }
+      const cmdRes = await sessionManager.sendCommand(session.id, {
+        id: `cmd_mcp_${Date.now()}`,
+        type: "capture_element",
+        params: { selector: args.selector }
+      });
+      if (!cmdRes.ok) {
+        throw new Error(cmdRes.error || cmdRes.reason || "Failed to capture element screenshot.");
+      }
+      return {
+        ok: true,
+        format: cmdRes.result?.format || "webp",
+        width: cmdRes.result?.width,
+        height: cmdRes.result?.height,
+        dataUrlPreview: cmdRes.result?.dataUrl ? `${cmdRes.result.dataUrl.slice(0, 100)}...` : void 0
+      };
+    }
+    case "verify_incident": {
+      if (!verificationEngine) {
+        throw new Error("Verification engine not available: Daemon session manager not attached.");
+      }
+      const res = await verificationEngine.verifyIncident(args.incidentId, {
+        route: args.route,
+        targetSelector: args.targetSelector,
+        expect: args.expect,
+        observationWindowMs: args.observationWindowMs
+      });
+      return res;
+    }
+    case "get_verification": {
+      const v = db.getLatestVerification(args.incidentId);
+      if (!v) {
+        throw new Error(`No verification records found for incident '${args.incidentId}'.`);
+      }
+      return v;
+    }
+    case "list_notes": {
+      const notes = db.listNotes({
+        projectId: args.projectId,
+        status: args.status,
+        limit: args.limit || 20
+      });
+      return {
+        total: notes.length,
+        notes: notes.map((n) => ({
+          id: n.id,
+          type: n.type,
+          status: n.status,
+          route: n.route,
+          viewport: `${n.viewport.width} \xD7 ${n.viewport.height}`,
+          target: n.target?.selector || n.type,
+          message: n.message,
+          screenshotAvailable: !!n.screenshots?.original,
+          createdAt: n.createdAt
+        }))
+      };
+    }
+    case "get_note": {
+      const note = db.getNote(args.noteId);
+      if (!note) {
+        throw new Error(`Visual note '${args.noteId}' not found.`);
+      }
+      const project = db.getProject(note.projectId);
+      return {
+        id: note.id,
+        type: note.type,
+        status: note.status,
+        message: note.message,
+        route: note.route,
+        url: note.url,
+        viewport: note.viewport,
+        scroll: note.scroll,
+        target: note.target,
+        elementContext: note.elementContext,
+        region: note.region,
+        screenshot: {
+          available: !!note.screenshots?.original,
+          original: note.screenshots?.original,
+          after: note.screenshots?.after
+        },
+        project: project ? {
+          id: project.id,
+          name: project.name,
+          origin: project.origin,
+          path: project.path
+        } : void 0,
+        relatedIncidentId: note.incidentId,
+        createdAt: note.createdAt,
+        updatedAt: note.updatedAt,
+        resolvedAt: note.resolvedAt
+      };
+    }
+    case "resolve_note": {
+      const note = db.getNote(args.noteId);
+      if (!note) {
+        throw new Error(`Visual note '${args.noteId}' not found.`);
+      }
+      db.updateNoteStatus(args.noteId, "RESOLVED");
+      return {
+        ok: true,
+        noteId: args.noteId,
+        status: "RESOLVED",
+        resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    case "reopen_note": {
+      const note = db.getNote(args.noteId);
+      if (!note) {
+        throw new Error(`Visual note '${args.noteId}' not found.`);
+      }
+      db.updateNoteStatus(args.noteId, "OPEN");
+      return {
+        ok: true,
+        noteId: args.noteId,
+        status: "OPEN"
+      };
+    }
+    case "verify_note": {
+      if (!noteVerificationEngine) {
+        throw new Error("Note verification engine not available: Daemon session manager not attached.");
+      }
+      const res = await noteVerificationEngine.verifyNote(args.noteId, {
+        observationWindowMs: args.observationWindowMs
+      });
+      return res;
+    }
+    case "get_note_verification": {
+      const v = db.getLatestNoteVerification(args.noteId);
+      if (!v) {
+        throw new Error(`No verification records found for visual note '${args.noteId}'.`);
+      }
+      return v;
+    }
+    case "capture_note_context": {
+      if (!sessionManager) {
+        throw new Error("Live browser connection not available: Daemon session manager not attached.");
+      }
+      let session = args.sessionId ? db.getSession(args.sessionId) : sessionManager.getAnyActiveSession();
+      if (!session) {
+        throw new Error("No active browser session connected.");
+      }
+      const queryCmd = await sessionManager.sendCommand(session.id, {
+        id: `cmd_ctx_${Date.now()}`,
+        type: "query_element",
+        params: { selector: args.selector }
+      });
+      const overflowCmd = await sessionManager.sendCommand(session.id, {
+        id: `cmd_ovf_${Date.now()}`,
+        type: "check_overflow",
+        params: { selector: args.selector }
+      });
+      const styleCmd = await sessionManager.sendCommand(session.id, {
+        id: `cmd_sty_${Date.now()}`,
+        type: "get_element_style",
+        params: { selector: args.selector }
+      });
+      return {
+        selector: args.selector,
+        element: queryCmd.result,
+        overflow: overflowCmd.result,
+        styles: styleCmd.result?.styles
+      };
+    }
+    default:
+      throw new Error(`Unknown MCP tool: ${name}`);
+  }
+}
+
+// packages/mcp/src/tools.ts
+var TOOLS = [
+  {
+    name: "list_projects",
+    description: "List all registered projects tracked by BrowserTrack/BrowserDiag",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "list_sessions",
+    description: "List active and recent browser sessions connected to the local development daemon",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: { type: "string", description: "Filter sessions by project ID or name" },
+        activeOnly: { type: "boolean", description: "Show only currently active WebSocket sessions (default: true)" }
+      }
+    }
+  },
+  {
+    name: "list_incidents",
+    description: "List recorded browser runtime errors, unhandled rejections, and console errors grouped into incidents",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: { type: "string", description: "Filter by project ID or name" },
+        status: {
+          type: "string",
+          enum: ["OPEN", "FIX_ATTEMPTED", "VERIFYING", "VERIFIED", "FAILED", "INCONCLUSIVE"],
+          description: "Filter by incident status"
+        },
+        severity: {
+          type: "string",
+          enum: ["error", "warn", "fatal"],
+          description: "Filter by severity"
+        },
+        limit: { type: "number", description: "Maximum number of incidents to return (default: 20)" }
+      }
+    }
+  },
+  {
+    name: "get_incident",
+    description: "Retrieve compact and high-signal debugging context for a specific error incident (stack trace, breadcrumbs, network failures, last interacted element, error screenshot)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        incidentId: { type: "string", description: "The unique ID of the incident (e.g. inc_42)" }
+      },
+      required: ["incidentId"]
+    }
+  },
+  {
+    name: "get_console",
+    description: "Get recent console logs, warnings, and errors from a browser session",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Browser session ID (optional, defaults to active session)" },
+        limit: { type: "number", description: "Number of console logs to retrieve (default: 30)" }
+      }
+    }
+  },
+  {
+    name: "get_network_failures",
+    description: "Get recent failed HTTP network requests (4xx, 5xx, network errors, timeouts, aborts)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Browser session ID (optional)" },
+        limit: { type: "number", description: "Maximum number of failed requests to return (default: 20)" }
+      }
+    }
+  },
+  {
+    name: "get_breadcrumbs",
+    description: "Get the sequence of recent user interactions, navigations, console logs, and network events prior to an error",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Browser session ID (optional)" },
+        incidentId: { type: "string", description: "Incident ID to fetch breadcrumbs from (optional)" },
+        limit: { type: "number", description: "Maximum number of breadcrumbs (default: 50)" }
+      }
+    }
+  },
+  {
+    name: "get_page_state",
+    description: "Query the live page state (URL, route, document title, readyState, active element) from the connected browser session",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Target session ID (optional, defaults to active)" }
+      }
+    }
+  },
+  {
+    name: "capture_element",
+    description: "Capture a screenshot of a specific DOM element or the entire visible page in the active browser tab",
+    inputSchema: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: 'CSS selector of the element to capture (e.g. [data-testid="user-card"])' },
+        sessionId: { type: "string", description: "Browser session ID (optional)" }
+      }
+    }
+  },
+  {
+    name: "verify_incident",
+    description: "Trigger closed-loop verification of a bug fix: reloads the browser, checks if the incident reoccurs, evaluates optional verification probes, and records before/after screenshots",
+    inputSchema: {
+      type: "object",
+      properties: {
+        incidentId: { type: "string", description: "The ID of the incident to verify" },
+        route: { type: "string", description: "Optional route to navigate to for verification (defaults to incident route)" },
+        targetSelector: { type: "string", description: "Optional element selector to inspect and capture after-fix screenshot" },
+        expect: {
+          type: "array",
+          description: "Optional verification probes to evaluate after reload",
+          items: {
+            type: "object",
+            properties: {
+              type: {
+                type: "string",
+                enum: ["element_exists", "element_visible", "text_contains", "route_is", "no_incident"]
+              },
+              selector: { type: "string" },
+              text: { type: "string" },
+              route: { type: "string" }
+            },
+            required: ["type"]
+          }
+        },
+        observationWindowMs: { type: "number", description: "Observation window in milliseconds (default: 2000)" }
+      },
+      required: ["incidentId"]
+    }
+  },
+  {
+    name: "get_verification",
+    description: "Retrieve the latest verification result and before/after screenshot artifacts for an incident",
+    inputSchema: {
+      type: "object",
+      properties: {
+        incidentId: { type: "string", description: "The ID of the incident" }
+      },
+      required: ["incidentId"]
+    }
+  },
+  {
+    name: "list_notes",
+    description: "List visual development notes / screen annotations left on elements, regions, or pages during development",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: { type: "string", description: "Filter notes by project ID or name" },
+        status: {
+          type: "string",
+          enum: ["OPEN", "IN_PROGRESS", "VERIFYING", "RESOLVED", "FAILED", "INCONCLUSIVE"],
+          description: "Filter by note status (default: OPEN)"
+        },
+        limit: { type: "number", description: "Maximum number of notes to return (default: 20)" }
+      }
+    }
+  },
+  {
+    name: "get_note",
+    description: "Retrieve full debugging context for a visual note (message, route, viewport dimensions, target element selector, DOM context, screenshot file path, project path)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        noteId: { type: "string", description: "The unique ID of the visual note (e.g. note_42)" }
+      },
+      required: ["noteId"]
+    }
+  },
+  {
+    name: "resolve_note",
+    description: "Mark a visual note as RESOLVED once the layout or styling issue has been fixed",
+    inputSchema: {
+      type: "object",
+      properties: {
+        noteId: { type: "string", description: "The ID of the visual note to resolve" }
+      },
+      required: ["noteId"]
+    }
+  },
+  {
+    name: "reopen_note",
+    description: "Reopen a previously resolved visual note",
+    inputSchema: {
+      type: "object",
+      properties: {
+        noteId: { type: "string", description: "The ID of the visual note to reopen" }
+      },
+      required: ["noteId"]
+    }
+  },
+  {
+    name: "verify_note",
+    description: "Run closed-loop layout & visual verification for a note: checks route, element existence/visibility, evaluates viewport overflow probes, captures after-screenshot, and computes geometry diff",
+    inputSchema: {
+      type: "object",
+      properties: {
+        noteId: { type: "string", description: "The ID of the visual note to verify" },
+        observationWindowMs: { type: "number", description: "Observation window in milliseconds (default: 1000)" }
+      },
+      required: ["noteId"]
+    }
+  },
+  {
+    name: "get_note_verification",
+    description: "Retrieve the latest verification result, before/after screenshot references, and layout geometry diff for a visual note",
+    inputSchema: {
+      type: "object",
+      properties: {
+        noteId: { type: "string", description: "The ID of the visual note" }
+      },
+      required: ["noteId"]
+    }
+  },
+  {
+    name: "capture_note_context",
+    description: "Inspect live DOM context, bounding box, overflow, and styles for a target element in the active browser tab",
+    inputSchema: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector of the target element" },
+        sessionId: { type: "string", description: "Browser session ID (optional)" }
+      },
+      required: ["selector"]
+    }
+  }
+];
+
+// packages/mcp/src/server.ts
+function createMcpServer(options = {}) {
+  const config = getDaemonConfig({ dbPath: options.dbPath });
+  const db = options.context?.db || new StorageDB(config.dbPath);
+  const screenshotStore = new ScreenshotStore(config.screenshotsDir);
+  const sessionManager = options.context?.sessionManager || new SessionManager(db);
+  const verificationEngine = options.context?.verificationEngine || new VerificationEngine(db, sessionManager, screenshotStore);
+  const notesEngine = new NotesEngine(db, screenshotStore);
+  const noteVerificationEngine = options.context?.noteVerificationEngine || new NoteVerificationEngine(db, sessionManager, notesEngine);
+  const ctx = {
+    db,
+    sessionManager,
+    verificationEngine,
+    noteVerificationEngine,
+    daemonUrl: `http://${config.host}:${config.port}`,
+    ...options.context
+  };
+  const server = new Server(
+    {
+      name: "browsertrack-mcp",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      const result = await handleToolCall(name, args || {}, ctx);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    } catch (err) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Error executing tool ${name}: ${err?.message || String(err)}`
+          }
+        ]
+      };
+    }
+  });
+  return {
+    server,
+    async startStdio() {
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+    }
+  };
+}
+
+// packages/cli/src/index.ts
+var program = new Command();
+program.name("browsertrack").description("Local browser diagnostics + MCP bridge for coding agents").version("0.1.0");
+function getPidFilePath() {
+  const config = getDaemonConfig();
+  return path6.join(config.dataDir, "daemon.pid");
+}
+function savePid(pid) {
+  const pidFile = getPidFilePath();
+  fs5.mkdirSync(path6.dirname(pidFile), { recursive: true });
+  fs5.writeFileSync(pidFile, String(pid), "utf-8");
+}
+function readPid() {
+  try {
+    const pidFile = getPidFilePath();
+    if (fs5.existsSync(pidFile)) {
+      const pidStr = fs5.readFileSync(pidFile, "utf-8").trim();
+      const pid = parseInt(pidStr, 10);
+      if (!isNaN(pid)) return pid;
+    }
+  } catch {
+  }
+  return null;
+}
+function removePid() {
+  try {
+    const pidFile = getPidFilePath();
+    if (fs5.existsSync(pidFile)) {
+      fs5.unlinkSync(pidFile);
+    }
+  } catch {
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+program.command("start").description("Start the local BrowserTrack daemon and HTTP/WS server").option("-p, --port <number>", "Server port", "7331").option("-h, --host <host>", "Server host", "127.0.0.1").option("-v, --verbose", "Enable verbose logging", false).action(async (options) => {
+  const existingPid = readPid();
+  if (existingPid && isProcessRunning(existingPid)) {
+    console.log(`[BrowserTrack] Daemon is already running (PID: ${existingPid})`);
+    return;
+  }
+  const port = parseInt(options.port, 10);
+  const daemon = createDaemon({
+    port,
+    host: options.host,
+    verbose: options.verbose
+  });
+  try {
+    await daemon.start();
+    savePid(process.pid);
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    console.log("  \u{1F50D} BrowserTrack Daemon Active");
+    console.log(`  \u{1F310} Server:    http://${daemon.config.host}:${daemon.config.port}`);
+    console.log(`  \u{1F50C} WebSocket: ws://${daemon.config.host}:${daemon.config.port}`);
+    console.log(`  \u{1F4E6} Script:    <script src="http://${daemon.config.host}:${daemon.config.port}/client.js"></script>`);
+    console.log(`  \u{1F4BE} Database:  ${daemon.config.dbPath}`);
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    let isShuttingDown = false;
+    const shutdown = async () => {
+      if (isShuttingDown) {
+        process.exit(0);
+      }
+      isShuttingDown = true;
+      console.log("\n[BrowserTrack] Shutting down daemon...");
+      removePid();
+      const forceExitTimer = setTimeout(() => {
+        process.exit(0);
+      }, 800);
+      forceExitTimer.unref();
+      try {
+        await daemon.stop();
+      } catch {
+      }
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (err) {
+    console.error("[BrowserTrack] Failed to start daemon:", err.message);
+    process.exit(1);
+  }
+});
+program.command("stop").description("Stop the running BrowserTrack daemon").action(async () => {
+  const pid = readPid();
+  if (!pid || !isProcessRunning(pid)) {
+    console.log("[BrowserTrack] Daemon is not currently running.");
+    removePid();
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    removePid();
+    console.log(`[BrowserTrack] Stopped daemon (PID: ${pid}).`);
+  } catch (err) {
+    console.error(`[BrowserTrack] Failed to stop daemon:`, err.message);
+  }
+});
+program.command("status").description("Check if the BrowserTrack daemon is running and view active sessions").action(async () => {
+  const pid = readPid();
+  const isRunning = pid ? isProcessRunning(pid) : false;
+  const config = getDaemonConfig();
+  console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  console.log(`  Status:       ${isRunning ? "\u{1F7E2} RUNNING" : "\u26AA STOPPED"}${isRunning ? ` (PID: ${pid})` : ""}`);
+  console.log(`  Endpoint:     http://${config.host}:${config.port}`);
+  console.log(`  Database:     ${config.dbPath}`);
+  if (fs5.existsSync(config.dbPath)) {
+    try {
+      const db = new StorageDB(config.dbPath);
+      const projects = db.listProjects();
+      const sessions = db.listSessions(void 0, true);
+      const incidents = db.listIncidents({ limit: 100 });
+      const openIncidents = incidents.filter((i) => i.status === "OPEN");
+      console.log(`  Projects:     ${projects.length}`);
+      console.log(`  Live Sessions: ${sessions.length}`);
+      console.log(`  Open Errors:  ${openIncidents.length} (${incidents.length} total recorded)`);
+      db.close();
+    } catch {
+    }
+  }
+  console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+});
+var projectCommand = program.command("project").description("Manage tracked project mappings");
+projectCommand.command("add <name>").description("Register a project with origin and filesystem path").requiredOption("-o, --origin <origin>", "Project origin (e.g. http://localhost:5173)").option("-p, --path <path>", "Filesystem path (e.g. /path/to/project)").action((name, options) => {
+  const config = getDaemonConfig();
+  const db = new StorageDB(config.dbPath);
+  const resolvedPath = options.path ? path6.resolve(options.path) : void 0;
+  const proj = db.upsertProject({
+    id: `proj_${name}`,
+    name,
+    origin: options.origin,
+    path: resolvedPath
+  });
+  console.log(`[BrowserTrack] Registered project '${proj.name}':`);
+  console.log(`  ID:     ${proj.id}`);
+  console.log(`  Origin: ${proj.origin}`);
+  console.log(`  Path:   ${proj.path || "(none)"}`);
+  db.close();
+});
+program.command("projects").description("List all tracked projects").action(() => {
+  const config = getDaemonConfig();
+  const db = new StorageDB(config.dbPath);
+  const projects = db.listProjects();
+  if (projects.length === 0) {
+    console.log("[BrowserTrack] No projects registered yet. Projects will be auto-detected upon browser connection.");
+  } else {
+    console.log("\nTracked Projects:");
+    for (const p of projects) {
+      console.log(`  \u2022 ${p.name.padEnd(16)} | ${p.origin.padEnd(26)} | ${p.path || "(auto-detected)"}`);
+    }
+    console.log("");
+  }
+  db.close();
+});
+program.command("errors").description("List recorded runtime errors and incidents").option("-p, --project <project>", "Filter by project name or ID").option("-s, --status <status>", "Filter by status (OPEN, VERIFIED, FAILED, etc.)").option("-l, --limit <number>", "Limit result count", "20").action((options) => {
+  const config = getDaemonConfig();
+  const db = new StorageDB(config.dbPath);
+  const limit = parseInt(options.limit, 10);
+  const incidents = db.listIncidents({
+    projectId: options.project,
+    status: options.status,
+    limit
+  });
+  if (incidents.length === 0) {
+    console.log("[BrowserTrack] No incidents found matching the filter.");
+  } else {
+    console.log(`
+Incidents (${incidents.length}):`);
+    for (const inc of incidents) {
+      const statusBadge = inc.status === "OPEN" ? "\u{1F534} OPEN" : inc.status === "VERIFIED" ? "\u{1F7E2} VERIFIED" : inc.status === "FAILED" ? "\u274C FAILED" : `\u26AA ${inc.status}`;
+      console.log(`  ${inc.id.padEnd(12)} [${statusBadge}] (${inc.occurrences}x) ${inc.type}: ${inc.message}`);
+      console.log(`    Source: ${inc.source.file}:${inc.source.line} | Route: ${inc.route}`);
+    }
+    console.log("");
+  }
+  db.close();
+});
+var noteCmd = program.command("note").description("Inspect or manage visual development notes");
+noteCmd.command("show <noteId>").description("Show full context for a specific visual note").action((noteId) => {
+  const config = getDaemonConfig();
+  const db = new StorageDB(config.dbPath);
+  const note = db.getNote(noteId);
+  if (!note) {
+    console.log(`[BrowserTrack] Note '${noteId}' not found.`);
+  } else {
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    console.log(`  \u{1F4DD} Visual Note: ${note.id} [${note.status}]`);
+    console.log(`  \u{1F4CD} Route:       ${note.route} (${note.url})`);
+    console.log(`  \u{1F4D0} Viewport:    ${note.viewport.width} \xD7 ${note.viewport.height} (dpr: ${note.viewport.devicePixelRatio})`);
+    if (note.target) {
+      console.log(`  \u{1F3AF} Target:      ${note.target.selector}`);
+      console.log(`     Bounds:      x:${note.target.boundingRect.x}, y:${note.target.boundingRect.y}, ${note.target.boundingRect.width}\xD7${note.target.boundingRect.height}`);
+    }
+    console.log(`  \u{1F4AC} Note:        "${note.message}"`);
+    if (note.screenshots?.original) {
+      console.log(`  \u{1F5BC}\uFE0F  Screenshot:  ${note.screenshots.original}`);
+    }
+    console.log(`  \u{1F552} Created:     ${note.createdAt}`);
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  }
+  db.close();
+});
+noteCmd.command("resolve <noteId>").description("Mark a visual note as resolved").action((noteId) => {
+  const config = getDaemonConfig();
+  const db = new StorageDB(config.dbPath);
+  const note = db.getNote(noteId);
+  if (!note) {
+    console.log(`[BrowserTrack] Note '${noteId}' not found.`);
+  } else {
+    db.updateNoteStatus(noteId, "RESOLVED");
+    console.log(`[BrowserTrack] Marked note '${noteId}' as RESOLVED.`);
+  }
+  db.close();
+});
+noteCmd.command("reopen <noteId>").description("Reopen a visual note").action((noteId) => {
+  const config = getDaemonConfig();
+  const db = new StorageDB(config.dbPath);
+  const note = db.getNote(noteId);
+  if (!note) {
+    console.log(`[BrowserTrack] Note '${noteId}' not found.`);
+  } else {
+    db.updateNoteStatus(noteId, "OPEN");
+    console.log(`[BrowserTrack] Reopened note '${noteId}' (status: OPEN).`);
+  }
+  db.close();
+});
+program.command("notes").description("List visual development notes").option("-p, --project <project>", "Filter by project name or ID").option("-s, --status <status>", "Filter by status (OPEN, RESOLVED, etc.)").option("-l, --limit <number>", "Limit result count", "20").action((options) => {
+  const config = getDaemonConfig();
+  const db = new StorageDB(config.dbPath);
+  const limit = parseInt(options.limit, 10);
+  const notes = db.listNotes({
+    projectId: options.project,
+    status: options.status,
+    limit
+  });
+  if (notes.length === 0) {
+    console.log("[BrowserTrack] No visual notes found.");
+  } else {
+    console.log(`
+Visual Notes (${notes.length}):`);
+    for (const n of notes) {
+      const badge = n.status === "OPEN" ? "\u{1F7E1} OPEN" : n.status === "RESOLVED" ? "\u{1F7E2} RESOLVED" : `\u26AA ${n.status}`;
+      console.log(`  ${n.id.padEnd(12)} [${badge}] Route: ${n.route.padEnd(16)} | Target: ${n.target?.selector || n.type}`);
+      console.log(`    Note: "${n.message}" (${n.viewport.width}\xD7${n.viewport.height})`);
+    }
+    console.log("");
+  }
+  db.close();
+});
+program.command("inbox").description("View combined developer inbox with active runtime errors and visual notes").option("-p, --project <project>", "Filter by project name or ID").action((options) => {
+  const config = getDaemonConfig();
+  const db = new StorageDB(config.dbPath);
+  const incidents = db.listIncidents({ projectId: options.project, status: "OPEN", limit: 20 });
+  const notes = db.listNotes({ projectId: options.project, status: "OPEN", limit: 20 });
+  console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  console.log(`  \u{1F4E5} Browser Development Inbox ${options.project ? `(${options.project})` : ""}`);
+  console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  if (incidents.length === 0 && notes.length === 0) {
+    console.log("  \u2728 All clear! No open errors or visual notes.");
+  } else {
+    if (incidents.length > 0) {
+      console.log(`
+  \u{1F6A8} Runtime Errors (${incidents.length}):`);
+      for (const inc of incidents) {
+        console.log(`    \u2022 ${inc.id} (${inc.occurrences}x) ${inc.type}: ${inc.message}`);
+        console.log(`      Route: ${inc.route} | Source: ${inc.source.file}:${inc.source.line}`);
+      }
+    }
+    if (notes.length > 0) {
+      console.log(`
+  \u{1F4DD} Visual Notes (${notes.length}):`);
+      for (const n of notes) {
+        console.log(`    \u2022 ${n.id} on ${n.route} (${n.viewport.width}\xD7${n.viewport.height})`);
+        console.log(`      Target: ${n.target?.selector || n.type} | Note: "${n.message}"`);
+      }
+    }
+  }
+  console.log("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  db.close();
+});
+program.command("clear").description("Clear all stored incidents, events, and sessions from the database").action(() => {
+  const config = getDaemonConfig();
+  const db = new StorageDB(config.dbPath);
+  db.clearAll();
+  console.log("[BrowserTrack] Database cleared.");
+  db.close();
+});
+program.command("mcp").description("Launch the Model Context Protocol (MCP) server over stdio").action(async () => {
+  try {
+    const server = createMcpServer();
+    await server.startStdio();
+  } catch (err) {
+    console.error("[BrowserTrack] MCP Server error:", err?.message);
+    process.exit(1);
+  }
+});
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map