@hasna/testers 0.0.12 → 0.0.14

package/dist/mcp/index.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env bun
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -128,6 +132,24 @@ function scheduleFromRow(row) {
     updatedAt: row.updated_at
   };
 }
+function scanIssueFromRow(row) {
+  return {
+    id: row.id,
+    fingerprint: row.fingerprint,
+    type: row.type,
+    severity: row.severity,
+    pageUrl: row.page_url,
+    message: row.message,
+    detail: row.detail ? JSON.parse(row.detail) : null,
+    status: row.status,
+    occurrenceCount: row.occurrence_count,
+    firstSeenAt: row.first_seen_at,
+    lastSeenAt: row.last_seen_at,
+    resolvedAt: row.resolved_at,
+    todoTaskId: row.todo_task_id,
+    projectId: row.project_id
+  };
+}
 function flowFromRow(row) {
   return {
     id: row.id,
@@ -445,10 +467,223 @@ var init_database = __esm(() => {
   `,
     `
   ALTER TABLE runs ADD COLUMN is_baseline INTEGER NOT NULL DEFAULT 0;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS scan_issues (
+    id TEXT PRIMARY KEY,
+    fingerprint TEXT NOT NULL UNIQUE,
+    type TEXT NOT NULL,
+    severity TEXT NOT NULL DEFAULT 'medium',
+    page_url TEXT NOT NULL,
+    message TEXT NOT NULL,
+    detail TEXT,
+    status TEXT NOT NULL DEFAULT 'open',
+    occurrence_count INTEGER NOT NULL DEFAULT 1,
+    first_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+    resolved_at TEXT,
+    todo_task_id TEXT,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_scan_issues_fingerprint ON scan_issues(fingerprint);
+  CREATE INDEX IF NOT EXISTS idx_scan_issues_status ON scan_issues(status);
+  CREATE INDEX IF NOT EXISTS idx_scan_issues_type ON scan_issues(type);
+  CREATE INDEX IF NOT EXISTS idx_scan_issues_project ON scan_issues(project_id);
   `
   ];
 });
 
+// src/db/scenarios.ts
+function nextShortId(projectId) {
+  const db2 = getDatabase();
+  if (projectId) {
+    const project = db2.query("SELECT scenario_prefix, scenario_counter FROM projects WHERE id = ?").get(projectId);
+    if (project) {
+      const next = project.scenario_counter + 1;
+      db2.query("UPDATE projects SET scenario_counter = ? WHERE id = ?").run(next, projectId);
+      return `${project.scenario_prefix}-${next}`;
+    }
+  }
+  return shortUuid();
+}
+function createScenario(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const short_id = nextShortId(input.projectId);
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO scenarios (id, short_id, project_id, name, description, steps, tags, priority, model, timeout_ms, target_path, requires_auth, auth_config, metadata, assertions, version, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+  `).run(id, short_id, input.projectId ?? null, input.name, input.description, JSON.stringify(input.steps ?? []), JSON.stringify(input.tags ?? []), input.priority ?? "medium", input.model ?? null, input.timeoutMs ?? null, input.targetPath ?? null, input.requiresAuth ? 1 : 0, input.authConfig ? JSON.stringify(input.authConfig) : null, input.metadata ? JSON.stringify(input.metadata) : null, JSON.stringify(input.assertions ?? []), timestamp, timestamp);
+  return getScenario(id);
+}
+function getScenario(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM scenarios WHERE id = ?").get(id);
+  if (row)
+    return scenarioFromRow(row);
+  row = db2.query("SELECT * FROM scenarios WHERE short_id = ?").get(id);
+  if (row)
+    return scenarioFromRow(row);
+  const fullId = resolvePartialId("scenarios", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM scenarios WHERE id = ?").get(fullId);
+    if (row)
+      return scenarioFromRow(row);
+  }
+  return null;
+}
+function getScenarioByShortId(shortId) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM scenarios WHERE short_id = ?").get(shortId);
+  return row ? scenarioFromRow(row) : null;
+}
+function listScenarios(filter) {
+  const db2 = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.projectId) {
+    conditions.push("project_id = ?");
+    params.push(filter.projectId);
+  }
+  if (filter?.tags && filter.tags.length > 0) {
+    for (const tag of filter.tags) {
+      conditions.push("tags LIKE ?");
+      params.push(`%"${tag}"%`);
+    }
+  }
+  if (filter?.priority) {
+    conditions.push("priority = ?");
+    params.push(filter.priority);
+  }
+  if (filter?.search) {
+    conditions.push("(name LIKE ? OR description LIKE ?)");
+    const term = `%${filter.search}%`;
+    params.push(term, term);
+  }
+  let sql = "SELECT * FROM scenarios";
+  if (conditions.length > 0) {
+    sql += " WHERE " + conditions.join(" AND ");
+  }
+  const sortField = filter?.sort ?? "date";
+  const sortDir = filter?.desc === false ? "ASC" : "DESC";
+  const orderByCol = sortField === "name" ? "name" : sortField === "priority" ? "CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END" : "created_at";
+  sql += ` ORDER BY ${orderByCol} ${sortDir}`;
+  if (filter?.limit) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
+  }
+  if (filter?.offset) {
+    sql += " OFFSET ?";
+    params.push(filter.offset);
+  }
+  const rows = db2.query(sql).all(...params);
+  return rows.map(scenarioFromRow);
+}
+function updateScenario(id, input, version) {
+  const db2 = getDatabase();
+  const existing = getScenario(id);
+  if (!existing) {
+    throw new Error(`Scenario not found: ${id}`);
+  }
+  if (existing.version !== version) {
+    throw new VersionConflictError("scenario", existing.id);
+  }
+  const sets = [];
+  const params = [];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.steps !== undefined) {
+    sets.push("steps = ?");
+    params.push(JSON.stringify(input.steps));
+  }
+  if (input.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.priority !== undefined) {
+    sets.push("priority = ?");
+    params.push(input.priority);
+  }
+  if (input.model !== undefined) {
+    sets.push("model = ?");
+    params.push(input.model);
+  }
+  if (input.timeoutMs !== undefined) {
+    sets.push("timeout_ms = ?");
+    params.push(input.timeoutMs);
+  }
+  if (input.targetPath !== undefined) {
+    sets.push("target_path = ?");
+    params.push(input.targetPath);
+  }
+  if (input.requiresAuth !== undefined) {
+    sets.push("requires_auth = ?");
+    params.push(input.requiresAuth ? 1 : 0);
+  }
+  if (input.authConfig !== undefined) {
+    sets.push("auth_config = ?");
+    params.push(JSON.stringify(input.authConfig));
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (input.assertions !== undefined) {
+    sets.push("assertions = ?");
+    params.push(JSON.stringify(input.assertions));
+  }
+  if (sets.length === 0) {
+    return existing;
+  }
+  sets.push("version = ?");
+  params.push(version + 1);
+  sets.push("updated_at = ?");
+  params.push(now());
+  params.push(existing.id);
+  params.push(version);
+  const result = db2.query(`UPDATE scenarios SET ${sets.join(", ")} WHERE id = ? AND version = ?`).run(...params);
+  if (result.changes === 0) {
+    throw new VersionConflictError("scenario", existing.id);
+  }
+  return getScenario(existing.id);
+}
+function findStaleScenarios(days) {
+  const db2 = getDatabase();
+  const rows = db2.query(`
+    SELECT s.*, MAX(r.created_at) AS last_run_at
+    FROM scenarios s
+    LEFT JOIN results r ON r.scenario_id = s.id
+    GROUP BY s.id
+    HAVING last_run_at IS NULL
+       OR last_run_at < datetime('now', ? || ' days')
+    ORDER BY last_run_at ASC NULLS FIRST
+  `).all(`-${days}`);
+  return rows.map((row) => ({
+    ...scenarioFromRow(row),
+    lastRunAt: row.last_run_at
+  }));
+}
+function deleteScenario(id) {
+  const db2 = getDatabase();
+  const scenario = getScenario(id);
+  if (!scenario)
+    return false;
+  const result = db2.query("DELETE FROM scenarios WHERE id = ?").run(scenario.id);
+  return result.changes > 0;
+}
+var init_scenarios = __esm(() => {
+  init_types();
+  init_database();
+});
+
 // src/lib/browser-lightpanda.ts
 var exports_browser_lightpanda = {};
 __export(exports_browser_lightpanda, {
@@ -611,40 +846,209 @@ var init_browser_lightpanda = __esm(() => {
   init_types();
 });
 
-// src/db/flows.ts
-var exports_flows = {};
-__export(exports_flows, {
-  topologicalSort: () => topologicalSort,
-  removeDependency: () => removeDependency,
-  listFlows: () => listFlows,
-  getTransitiveDependencies: () => getTransitiveDependencies,
-  getFlow: () => getFlow,
-  getDependents: () => getDependents,
-  getDependencies: () => getDependencies,
-  deleteFlow: () => deleteFlow,
-  createFlow: () => createFlow,
-  addDependency: () => addDependency
-});
-function addDependency(scenarioId, dependsOn) {
-  const db2 = getDatabase();
-  const visited = new Set;
-  const queue = [dependsOn];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current === scenarioId) {
-      throw new DependencyCycleError(scenarioId, dependsOn);
-    }
-    if (visited.has(current))
-      continue;
-    visited.add(current);
-    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
-    for (const dep of deps) {
-      if (!visited.has(dep.depends_on)) {
-        queue.push(dep.depends_on);
-      }
+// src/lib/browser.ts
+import { chromium as chromium2 } from "playwright";
+async function launchBrowser(options) {
+  const engine = options?.engine ?? process.env["TESTERS_BROWSER_ENGINE"] ?? "playwright";
+  if (engine === "lightpanda") {
+    const { launchLightpanda: launchLightpanda2, isLightpandaAvailable: isLightpandaAvailable2 } = await Promise.resolve().then(() => (init_browser_lightpanda(), exports_browser_lightpanda));
+    if (!isLightpandaAvailable2()) {
+      throw new BrowserError("Lightpanda not installed. Run: testers install-browser --engine lightpanda");
     }
+    return launchLightpanda2({ viewport: options?.viewport });
+  }
+  const headless = options?.headless ?? true;
+  const viewport = options?.viewport ?? DEFAULT_VIEWPORT;
+  try {
+    const browser = await chromium2.launch({
+      headless,
+      args: [
+        `--window-size=${viewport.width},${viewport.height}`
+      ]
+    });
+    return browser;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BrowserError(`Failed to launch browser: ${message}`);
   }
-  db2.query("INSERT OR IGNORE INTO scenario_dependencies (scenario_id, depends_on) VALUES (?, ?)").run(scenarioId, dependsOn);
+}
+async function getPage(browser, options) {
+  const engine = options?.engine ?? "playwright";
+  if (engine === "lightpanda") {
+    const { getLightpandaPage: getLightpandaPage2 } = await Promise.resolve().then(() => (init_browser_lightpanda(), exports_browser_lightpanda));
+    return getLightpandaPage2(browser, options);
+  }
+  const viewport = options?.viewport ?? DEFAULT_VIEWPORT;
+  try {
+    const context = await browser.newContext({
+      viewport,
+      userAgent: options?.userAgent,
+      locale: options?.locale
+    });
+    const page = await context.newPage();
+    return page;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BrowserError(`Failed to create page: ${message}`);
+  }
+}
+async function closeBrowser(browser, engine) {
+  if (engine === "lightpanda") {
+    const { closeLightpanda: closeLightpanda2 } = await Promise.resolve().then(() => (init_browser_lightpanda(), exports_browser_lightpanda));
+    return closeLightpanda2(browser);
+  }
+  try {
+    await browser.close();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BrowserError(`Failed to close browser: ${message}`);
+  }
+}
+var DEFAULT_VIEWPORT;
+var init_browser = __esm(() => {
+  init_types();
+  DEFAULT_VIEWPORT = { width: 1280, height: 720 };
+});
+
+// src/lib/todos-connector.ts
+import { Database as Database2 } from "bun:sqlite";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+function resolveTodosDbPath() {
+  const envPath = process.env["TODOS_DB_PATH"];
+  if (envPath)
+    return envPath;
+  return join4(homedir4(), ".todos", "todos.db");
+}
+function connectToTodos() {
+  const dbPath = resolveTodosDbPath();
+  if (!existsSync4(dbPath)) {
+    throw new TodosConnectionError(`Todos database not found at ${dbPath}. Install @hasna/todos or set TODOS_DB_PATH.`);
+  }
+  const db2 = new Database2(dbPath, { readonly: true });
+  db2.exec("PRAGMA foreign_keys = ON");
+  return db2;
+}
+function pullTasks(options = {}) {
+  const db2 = connectToTodos();
+  try {
+    let query = "SELECT id, short_id, title, description, status, priority, tags, project_id FROM tasks WHERE 1=1";
+    const params = [];
+    if (options.status) {
+      query += " AND status = ?";
+      params.push(options.status);
+    } else {
+      query += " AND status IN ('pending', 'in_progress')";
+    }
+    if (options.priority) {
+      query += " AND priority = ?";
+      params.push(options.priority);
+    }
+    if (options.projectName) {
+      const project = db2.query("SELECT id FROM projects WHERE name = ?").get(options.projectName);
+      if (project) {
+        query += " AND project_id = ?";
+        params.push(project.id);
+      }
+    }
+    query += " ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END";
+    const tasks = db2.query(query).all(...params);
+    if (options.tags && options.tags.length > 0) {
+      return tasks.filter((task) => {
+        const taskTags = JSON.parse(task.tags || "[]");
+        return options.tags.some((tag) => taskTags.includes(tag));
+      });
+    }
+    return tasks;
+  } finally {
+    db2.close();
+  }
+}
+function taskToScenarioInput(task, projectId) {
+  const tags = JSON.parse(task.tags || "[]");
+  const priority = ["low", "medium", "high", "critical"].includes(task.priority) ? task.priority : "medium";
+  const steps = [];
+  if (task.description) {
+    const lines = task.description.split(`
+`);
+    for (const line of lines) {
+      const match = line.match(/^\s*\d+[\.\)]\s*(.+)/);
+      if (match?.[1]) {
+        steps.push(match[1].trim());
+      }
+    }
+  }
+  return {
+    name: task.title.replace(/^(OPE\d+-\d+|[A-Z]+-\d+):\s*/, ""),
+    description: task.description || task.title,
+    steps,
+    tags,
+    priority,
+    projectId,
+    metadata: { todosTaskId: task.id, todosShortId: task.short_id }
+  };
+}
+function importFromTodos(options = {}) {
+  const tasks = pullTasks({
+    projectName: options.projectName,
+    tags: options.tags ?? ["qa", "test", "testing"],
+    priority: options.priority
+  });
+  const existing = listScenarios({ projectId: options.projectId });
+  const existingTodoIds = new Set(existing.filter((s) => s.metadata?.todosTaskId).map((s) => s.metadata.todosTaskId));
+  let imported = 0;
+  let skipped = 0;
+  for (const task of tasks) {
+    if (existingTodoIds.has(task.id)) {
+      skipped++;
+      continue;
+    }
+    const input = taskToScenarioInput(task, options.projectId);
+    createScenario(input);
+    imported++;
+  }
+  return { imported, skipped };
+}
+var init_todos_connector = __esm(() => {
+  init_scenarios();
+  init_types();
+});
+
+// src/db/flows.ts
+var exports_flows = {};
+__export(exports_flows, {
+  topologicalSort: () => topologicalSort,
+  removeDependency: () => removeDependency,
+  listFlows: () => listFlows,
+  getTransitiveDependencies: () => getTransitiveDependencies,
+  getFlow: () => getFlow,
+  getDependents: () => getDependents,
+  getDependencies: () => getDependencies,
+  deleteFlow: () => deleteFlow,
+  createFlow: () => createFlow,
+  addDependency: () => addDependency
+});
+function addDependency(scenarioId, dependsOn) {
+  const db2 = getDatabase();
+  const visited = new Set;
+  const queue = [dependsOn];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === scenarioId) {
+      throw new DependencyCycleError(scenarioId, dependsOn);
+    }
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
+    for (const dep of deps) {
+      if (!visited.has(dep.depends_on)) {
+        queue.push(dep.depends_on);
+      }
+    }
+  }
+  db2.query("INSERT OR IGNORE INTO scenario_dependencies (scenario_id, depends_on) VALUES (?, ?)").run(scenarioId, dependsOn);
 }
 function removeDependency(scenarioId, dependsOn) {
   const db2 = getDatabase();
@@ -756,10 +1160,632 @@ function deleteFlow(id) {
   const result = db2.query("DELETE FROM flows WHERE id = ?").run(flow.id);
   return result.changes > 0;
 }
-var init_flows = __esm(() => {
-  init_database();
-  init_database();
-  init_types();
+var init_flows = __esm(() => {
+  init_database();
+  init_database();
+  init_types();
+});
+
+// src/db/scan-issues.ts
+var exports_scan_issues = {};
+__export(exports_scan_issues, {
+  upsertScanIssue: () => upsertScanIssue,
+  setScanIssueTodoTaskId: () => setScanIssueTodoTaskId,
+  resolveScanIssue: () => resolveScanIssue,
+  listScanIssues: () => listScanIssues,
+  getScanIssue: () => getScanIssue,
+  fingerprintIssue: () => fingerprintIssue
+});
+function fingerprintIssue(issue) {
+  let pagePattern = issue.pageUrl;
+  try {
+    pagePattern = new URL(issue.pageUrl).pathname;
+  } catch {}
+  const raw = `${issue.type}::${issue.message.slice(0, 200)}::${pagePattern}`;
+  let hash = 5381;
+  for (let i = 0;i < raw.length; i++) {
+    hash = (hash << 5) + hash ^ raw.charCodeAt(i);
+    hash = hash >>> 0;
+  }
+  return `${issue.type}-${hash.toString(16).padStart(8, "0")}`;
+}
+function upsertScanIssue(issue, projectId) {
+  const db2 = getDatabase();
+  const fingerprint = fingerprintIssue(issue);
+  const timestamp = now();
+  const existing = db2.query("SELECT * FROM scan_issues WHERE fingerprint = ?").get(fingerprint);
+  if (!existing) {
+    const id = uuid();
+    db2.query(`
+      INSERT INTO scan_issues (id, fingerprint, type, severity, page_url, message, detail, status, occurrence_count, first_seen_at, last_seen_at, project_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 'open', 1, ?, ?, ?)
+    `).run(id, fingerprint, issue.type, issue.severity, issue.pageUrl, issue.message, issue.detail ? JSON.stringify(issue.detail) : null, timestamp, timestamp, projectId ?? null);
+    const row = db2.query("SELECT * FROM scan_issues WHERE id = ?").get(id);
+    return { issue: scanIssueFromRow(row), outcome: "new" };
+  }
+  const wasResolved = existing.status === "resolved";
+  const newStatus = wasResolved ? "regressed" : "open";
+  db2.query(`
+    UPDATE scan_issues
+    SET occurrence_count = occurrence_count + 1,
+        last_seen_at = ?,
+        status = ?,
+        resolved_at = CASE WHEN ? = 'regressed' THEN NULL ELSE resolved_at END,
+        severity = ?,
+        page_url = ?,
+        message = ?,
+        detail = ?
+    WHERE fingerprint = ?
+  `).run(timestamp, newStatus, newStatus, issue.severity, issue.pageUrl, issue.message, issue.detail ? JSON.stringify(issue.detail) : existing.detail, fingerprint);
+  const updated = db2.query("SELECT * FROM scan_issues WHERE fingerprint = ?").get(fingerprint);
+  return {
+    issue: scanIssueFromRow(updated),
+    outcome: wasResolved ? "regressed" : "existing"
+  };
+}
+function resolveScanIssue(id) {
+  const db2 = getDatabase();
+  const result = db2.query("UPDATE scan_issues SET status = 'resolved', resolved_at = ? WHERE id = ?").run(now(), id);
+  return result.changes > 0;
+}
+function setScanIssueTodoTaskId(id, todoTaskId) {
+  const db2 = getDatabase();
+  db2.query("UPDATE scan_issues SET todo_task_id = ? WHERE id = ?").run(todoTaskId, id);
+}
+function listScanIssues(opts = {}) {
+  const db2 = getDatabase();
+  const conditions = ["1=1"];
+  const params = [];
+  if (opts.status) {
+    conditions.push("status = ?");
+    params.push(opts.status);
+  }
+  if (opts.type) {
+    conditions.push("type = ?");
+    params.push(opts.type);
+  }
+  if (opts.projectId) {
+    conditions.push("project_id = ?");
+    params.push(opts.projectId);
+  }
+  const limitClause = opts.limit ? ` LIMIT ${opts.limit}` : "";
+  const rows = db2.query(`SELECT * FROM scan_issues WHERE ${conditions.join(" AND ")} ORDER BY last_seen_at DESC${limitClause}`).all(...params);
+  return rows.map(scanIssueFromRow);
+}
+function getScanIssue(id) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM scan_issues WHERE id = ?").get(id);
+  return row ? scanIssueFromRow(row) : null;
+}
+var init_scan_issues = __esm(() => {
+  init_types();
+  init_database();
+});
+
+// src/lib/scanners/console.ts
+var exports_console = {};
+__export(exports_console, {
+  scanConsoleErrors: () => scanConsoleErrors
+});
+async function scanConsoleErrors(options) {
+  const { url, pages, headed = false, timeoutMs = 15000 } = options;
+  const start = Date.now();
+  const scannedPages = [];
+  const issues = [];
+  const pageUrls = pages?.length ? pages.map((p) => p.startsWith("http") ? p : `${url.replace(/\/$/, "")}${p}`) : [url];
+  const browser = await launchBrowser({ headless: !headed });
+  try {
+    for (const pageUrl of pageUrls) {
+      const page = await getPage(browser, {});
+      const entries = [];
+      page.on("console", (msg) => {
+        if (msg.type() === "error") {
+          entries.push({ type: "console.error", text: msg.text() });
+        }
+      });
+      page.on("pageerror", (err) => {
+        entries.push({ type: "uncaught", text: err.message, location: err.stack?.split(`
+`)[1]?.trim() });
+      });
+      try {
+        await page.goto(pageUrl, { timeout: timeoutMs, waitUntil: "domcontentloaded" });
+        await page.waitForTimeout(1500);
+        scannedPages.push(pageUrl);
+      } catch {
+        entries.push({ type: "navigation", text: `Failed to navigate to ${pageUrl}` });
+        scannedPages.push(pageUrl);
+      } finally {
+        await page.close();
+      }
+      for (const entry of entries) {
+        if (isIgnoredConsoleError(entry.text))
+          continue;
+        const severity = classifyConsoleSeverity(entry.text);
+        issues.push({
+          type: "console_error",
+          severity,
+          pageUrl,
+          message: entry.text.slice(0, 500),
+          detail: {
+            errorType: entry.type,
+            location: entry.location ?? null
+          }
+        });
+      }
+    }
+  } finally {
+    await closeBrowser(browser);
+  }
+  return {
+    url,
+    pages: scannedPages,
+    scannedAt: new Date().toISOString(),
+    durationMs: Date.now() - start,
+    issues
+  };
+}
+function isIgnoredConsoleError(text) {
+  return IGNORED_PATTERNS.some((p) => p.test(text));
+}
+function classifyConsoleSeverity(text) {
+  const lower = text.toLowerCase();
+  if (/uncaught|unhandled|typeerror|referenceerror|cannot read|is not a function|hydrat/i.test(lower))
+    return "critical";
+  if (/error|failed|exception/i.test(lower))
+    return "high";
+  if (/warning|warn|deprecated/i.test(lower))
+    return "medium";
+  return "low";
+}
+var IGNORED_PATTERNS;
+var init_console = __esm(() => {
+  init_browser();
+  IGNORED_PATTERNS = [
+    /Download the React DevTools/i,
+    /\[HMR\]/,
+    /\[vite\]/i,
+    /favicon\.ico/i,
+    /Content Security Policy/i
+  ];
+});
+
+// src/lib/scanners/network.ts
+var exports_network = {};
+__export(exports_network, {
+  scanNetworkErrors: () => scanNetworkErrors
+});
+async function scanNetworkErrors(options) {
+  const { url, pages, headed = false, timeoutMs = 15000 } = options;
+  const start = Date.now();
+  const scannedPages = [];
+  const issues = [];
+  const pageUrls = pages?.length ? pages.map((p) => p.startsWith("http") ? p : `${url.replace(/\/$/, "")}${p}`) : [url];
+  const browser = await launchBrowser({ headless: !headed });
+  try {
+    for (const pageUrl of pageUrls) {
+      const page = await getPage(browser, {});
+      const entries = [];
+      page.on("response", (resp) => {
+        const reqUrl = resp.url();
+        const status = resp.status();
+        if (shouldIgnoreUrl(reqUrl))
+          return;
+        if (status >= 400) {
+          entries.push({ url: reqUrl, status, method: resp.request().method(), type: resp.request().resourceType(), failed: false });
+        }
+      });
+      page.on("requestfailed", (req) => {
+        const reqUrl = req.url();
+        if (shouldIgnoreUrl(reqUrl))
+          return;
+        entries.push({
+          url: reqUrl,
+          status: 0,
+          method: req.method(),
+          type: req.resourceType(),
+          failed: true,
+          failureText: req.failure()?.errorText
+        });
+      });
+      try {
+        await page.goto(pageUrl, { timeout: timeoutMs, waitUntil: "domcontentloaded" });
+        await page.waitForTimeout(1000);
+        scannedPages.push(pageUrl);
+      } catch {
+        scannedPages.push(pageUrl);
+      } finally {
+        await page.close();
+      }
+      for (const entry of entries) {
+        const severity = classifyNetworkSeverity(entry);
+        const message = entry.failed ? `Request failed: ${entry.method} ${entry.url} \u2014 ${entry.failureText ?? "unknown"}` : `HTTP ${entry.status}: ${entry.method} ${entry.url}`;
+        issues.push({
+          type: "network_error",
+          severity,
+          pageUrl,
+          message: message.slice(0, 500),
+          detail: {
+            requestUrl: entry.url,
+            status: entry.status,
+            method: entry.method,
+            resourceType: entry.type,
+            failureText: entry.failureText ?? null
+          }
+        });
+      }
+    }
+  } finally {
+    await closeBrowser(browser);
+  }
+  return { url, pages: scannedPages, scannedAt: new Date().toISOString(), durationMs: Date.now() - start, issues };
+}
+function shouldIgnoreUrl(reqUrl) {
+  return IGNORE_URL_PATTERNS.some((p) => p.test(reqUrl));
+}
+function classifyNetworkSeverity(entry) {
+  if (entry.failed) {
+    if (entry.failureText?.includes("CORS") || entry.failureText?.includes("blocked"))
+      return "critical";
+    return "high";
+  }
+  if (entry.status >= 500)
+    return "critical";
+  if (entry.status === 401 || entry.status === 403)
+    return "high";
+  if (entry.status >= 400)
+    return "medium";
+  return "low";
+}
+var IGNORE_URL_PATTERNS;
+var init_network = __esm(() => {
+  init_browser();
+  IGNORE_URL_PATTERNS = [
+    /favicon\.ico/i,
+    /\.woff2?$/i,
+    /fonts\.googleapis\.com/i,
+    /analytics\.(google|segment)/i,
+    /hotjar\.com/i,
+    /sentry\.io/i
+  ];
+});
+
+// src/lib/scanners/links.ts
+var exports_links = {};
+__export(exports_links, {
+  scanBrokenLinks: () => scanBrokenLinks
+});
+async function scanBrokenLinks(options) {
+  const { url, maxPages = 30, headed = false, timeoutMs = 12000 } = options;
+  const start = Date.now();
+  const issues = [];
+  const rootOrigin = (() => {
+    try {
+      return new URL(url).origin;
+    } catch {
+      return url;
+    }
+  })();
+  const visited = new Set;
+  const queue = [{ pageUrl: url, sourceUrl: "" }];
+  const browser = await launchBrowser({ headless: !headed });
+  try {
+    while (queue.length > 0 && visited.size < maxPages) {
+      const { pageUrl, sourceUrl } = queue.shift();
+      const normalised = normaliseUrl(pageUrl);
+      if (visited.has(normalised))
+        continue;
+      visited.add(normalised);
+      const page = await getPage(browser, {});
+      let status = 200;
+      let finalUrl = pageUrl;
+      page.on("response", (resp) => {
+        if (resp.url() === pageUrl || resp.url() === normalised) {
+          status = resp.status();
+        }
+      });
+      let hrefs = [];
+      try {
+        const response = await page.goto(pageUrl, { timeout: timeoutMs, waitUntil: "domcontentloaded" });
+        if (response) {
+          status = response.status();
+          finalUrl = response.url();
+        }
+        hrefs = await page.evaluate(() => Array.from(document.querySelectorAll("a[href]")).map((a) => a.href).filter(Boolean));
+      } catch (err) {
+        status = 0;
+      } finally {
+        await page.close();
+      }
+      if (status === 404) {
+        issues.push({
+          type: "broken_link",
+          severity: "high",
+          pageUrl: sourceUrl || url,
+          message: `404 Not Found: ${pageUrl}`,
+          detail: { brokenUrl: pageUrl, sourceUrl, status }
+        });
+      } else if (status === 0) {
+        issues.push({
+          type: "broken_link",
+          severity: "medium",
+          pageUrl: sourceUrl || url,
+          message: `Navigation failed: ${pageUrl}`,
+          detail: { brokenUrl: pageUrl, sourceUrl, status }
+        });
+      }
+      for (const href of hrefs) {
+        try {
+          const linkUrl = new URL(href);
+          if (linkUrl.origin === rootOrigin) {
+            const clean = `${linkUrl.origin}${linkUrl.pathname}`;
+            if (!visited.has(clean)) {
+              queue.push({ pageUrl: clean, sourceUrl: finalUrl });
+            }
+          }
+        } catch {}
+      }
+    }
+  } finally {
+    await closeBrowser(browser);
+  }
+  return {
+    url,
+    pages: Array.from(visited),
+    scannedAt: new Date().toISOString(),
+    durationMs: Date.now() - start,
+    issues
+  };
+}
+function normaliseUrl(rawUrl) {
+  try {
+    const u = new URL(rawUrl);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return rawUrl;
+  }
+}
+var init_links = __esm(() => {
+  init_browser();
+});
+
+// src/lib/scanners/performance.ts
+var exports_performance = {};
+__export(exports_performance, {
+  scanPerformance: () => scanPerformance
+});
+async function scanPerformance(options) {
+  const { url, pages, headed = false, timeoutMs = 20000, thresholds: customThresholds } = options;
+  const thresholds = { ...DEFAULT_THRESHOLDS, ...customThresholds };
+  const start = Date.now();
+  const scannedPages = [];
+  const issues = [];
+  const pageUrls = pages?.length ? pages.map((p) => p.startsWith("http") ? p : `${url.replace(/\/$/, "")}${p}`) : [url];
+  const browser = await launchBrowser({ headless: !headed });
+  try {
+    for (const pageUrl of pageUrls) {
+      const page = await getPage(browser, {});
+      let transferBytes = 0;
+      let requestCount = 0;
+      page.on("response", async (resp) => {
+        requestCount++;
+        try {
+          const headers = resp.headers();
+          const contentLength = parseInt(headers["content-length"] ?? "0", 10);
+          if (!isNaN(contentLength))
+            transferBytes += contentLength;
+        } catch {}
+      });
+      try {
+        await page.goto(pageUrl, { timeout: timeoutMs, waitUntil: "load" });
+        scannedPages.push(pageUrl);
+        const metrics = await page.evaluate((pUrl) => {
+          const nav = performance.getEntriesByType("navigation")[0];
+          const paintEntries = performance.getEntriesByType("paint");
+          const fpEntry = paintEntries.find((e) => e.name === "first-paint");
+          const fcpEntry = paintEntries.find((e) => e.name === "first-contentful-paint");
+          let lcpMs = null;
+          try {
+            const lcpEntries = performance.getEntriesByType("largest-contentful-paint");
+            if (lcpEntries.length > 0) {
+              lcpMs = lcpEntries[lcpEntries.length - 1].startTime;
+            }
+          } catch {}
+          return {
+            pageUrl: pUrl,
+            loadTimeMs: nav ? Math.round(nav.loadEventEnd - nav.startTime) : 0,
+            domContentLoadedMs: nav ? Math.round(nav.domContentLoadedEventEnd - nav.startTime) : 0,
+            firstPaintMs: fpEntry ? Math.round(fpEntry.startTime) : fcpEntry ? Math.round(fcpEntry.startTime) : null,
+            lcpMs,
+            requestCount: 0,
+            transferBytes: 0
+          };
+        }, pageUrl);
+        metrics.requestCount = requestCount;
+        metrics.transferBytes = transferBytes;
+        if (metrics.loadTimeMs > thresholds.loadTimeMs) {
+          issues.push({
+            type: "performance",
+            severity: metrics.loadTimeMs > thresholds.loadTimeMs * 2 ? "critical" : "high",
+            pageUrl,
+            message: `Slow page load: ${metrics.loadTimeMs}ms (threshold: ${thresholds.loadTimeMs}ms)`,
+            detail: { ...metrics }
+          });
+        }
+        if (metrics.domContentLoadedMs > thresholds.domContentLoadedMs) {
+          issues.push({
+            type: "performance",
+            severity: "medium",
+            pageUrl,
+            message: `Slow DOMContentLoaded: ${metrics.domContentLoadedMs}ms (threshold: ${thresholds.domContentLoadedMs}ms)`,
+            detail: { ...metrics }
+          });
+        }
+        if (metrics.lcpMs !== null && metrics.lcpMs > thresholds.lcpMs) {
+          issues.push({
+            type: "performance",
+            severity: metrics.lcpMs > thresholds.lcpMs * 2 ? "critical" : "high",
+            pageUrl,
+            message: `Poor LCP: ${Math.round(metrics.lcpMs)}ms (threshold: ${thresholds.lcpMs}ms)`,
+            detail: { ...metrics }
+          });
+        }
+      } catch (err) {
+        issues.push({
+          type: "performance",
+          severity: "medium",
+          pageUrl,
+          message: `Performance scan failed: ${err instanceof Error ? err.message : String(err)}`,
+          detail: {}
+        });
+      } finally {
+        await page.close();
+      }
+    }
+  } finally {
+    await closeBrowser(browser);
+  }
+  return { url, pages: scannedPages, scannedAt: new Date().toISOString(), durationMs: Date.now() - start, issues };
+}
+var DEFAULT_THRESHOLDS;
+var init_performance = __esm(() => {
+  init_browser();
+  DEFAULT_THRESHOLDS = {
+    loadTimeMs: 5000,
+    domContentLoadedMs: 3000,
+    lcpMs: 2500
+  };
+});
+
+// src/lib/health-scan.ts
+var exports_health_scan = {};
+__export(exports_health_scan, {
+  runHealthScan: () => runHealthScan
+});
+async function runHealthScan(options) {
+  const {
+    url,
+    pages,
+    projectId,
+    headed = false,
+    timeoutMs = 15000,
+    scanners = ["console", "network", "links"],
+    maxPages = 20
+  } = options;
+  const start = Date.now();
+  const results = [];
+  if (scanners.includes("console")) {
+    results.push(await scanConsoleErrors({ url, pages, headed, timeoutMs }));
+  }
+  if (scanners.includes("network")) {
+    results.push(await scanNetworkErrors({ url, pages, headed, timeoutMs }));
+  }
+  if (scanners.includes("links")) {
+    results.push(await scanBrokenLinks({ url, maxPages, headed, timeoutMs }));
+  }
+  if (scanners.includes("performance")) {
+    results.push(await scanPerformance({ url, pages, headed, timeoutMs }));
+  }
+  const allIssues = results.flatMap((r) => r.issues);
+  let newCount = 0;
+  let regressedCount = 0;
+  let existingCount = 0;
+  const newAndRegressed = [];
+  for (const issue of allIssues) {
+    const { issue: persisted, outcome } = upsertScanIssue(issue, projectId);
+    if (outcome === "new") {
+      newCount++;
+      newAndRegressed.push({ issue, persistedId: persisted.id });
+    } else if (outcome === "regressed") {
+      regressedCount++;
+      newAndRegressed.push({ issue, persistedId: persisted.id });
+    } else
+      existingCount++;
+  }
+  await createTodoTasksForIssues(newAndRegressed, url, projectId);
+  await notifyHealthScan(url, { new: newCount, regressed: regressedCount, existing: existingCount, total: allIssues.length });
+  return {
+    url,
+    scannedAt: new Date().toISOString(),
+    durationMs: Date.now() - start,
+    totalIssues: allIssues.length,
+    newIssues: newCount,
+    regressedIssues: regressedCount,
+    existingIssues: existingCount,
+    results
+  };
+}
+async function createTodoTasksForIssues(items, url, _projectId) {
+  const todosProjectId = process.env["TESTERS_TODOS_PROJECT_ID"];
+  if (!todosProjectId || items.length === 0)
+    return;
+  let db2 = null;
+  try {
+    db2 = connectToTodos();
+  } catch {
+    return;
+  }
+  try {
+    for (const { issue, persistedId } of items) {
+      const title = `BUG: [scan] ${issue.type.replace(/_/g, " ")}: ${issue.message.slice(0, 80)}`;
+      const id = crypto.randomUUID();
+      const now2 = new Date().toISOString();
+      const description = [
+        `Health scan detected a ${issue.type.replace(/_/g, " ")} issue.`,
+        ``,
+        `**URL:** ${url}`,
+        `**Page:** ${issue.pageUrl}`,
+        `**Severity:** ${issue.severity}`,
+        `**Message:** ${issue.message}`,
+        issue.detail ? `**Detail:**
+\`\`\`json
+${JSON.stringify(issue.detail, null, 2)}
+\`\`\`` : null
+      ].filter(Boolean).join(`
+`);
+      try {
+        db2.query(`
+          INSERT INTO tasks (id, short_id, title, description, status, priority, tags, project_id, version, created_at, updated_at)
+          VALUES (?, ?, ?, ?, 'pending', ?, ?, ?, 1, ?, ?)
+        `).run(id, `SCAN-${id.slice(0, 6)}`, title, description, issue.severity, JSON.stringify(["bug", "scan", issue.type, "auto-created"]), todosProjectId, now2, now2);
+        setScanIssueTodoTaskId(persistedId, id);
+      } catch {}
+    }
+  } finally {
+    db2.close();
+  }
+}
+async function notifyHealthScan(url, counts) {
+  const baseUrl = process.env["TESTERS_CONVERSATIONS_URL"];
+  const space = process.env["TESTERS_CONVERSATIONS_SPACE"];
+  if (!baseUrl || !space)
+    return;
+  if (counts.new === 0 && counts.regressed === 0)
+    return;
+  const icon = counts.new + counts.regressed > 0 ? "\uD83D\uDEA8" : "\u2705";
+  const message = [
+    `${icon} **Health scan** \u2014 ${url}`,
+    ``,
+    `**New issues:** ${counts.new}`,
+    `**Regressed:** ${counts.regressed}`,
+    `**Known (skipped):** ${counts.existing}`,
+    `**Total found:** ${counts.total}`
+  ].join(`
+`);
+  try {
+    await fetch(`${baseUrl.replace(/\/$/, "")}/api/spaces/${encodeURIComponent(space)}/messages`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content: message, from: "testers-health-scan" })
+    });
+  } catch {}
+}
+var init_health_scan = __esm(() => {
+  init_console();
+  init_network();
+  init_links();
+  init_performance();
+  init_scan_issues();
+  init_todos_connector();
 });
 
 // src/mcp/index.ts
@@ -4739,193 +5765,8 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-// src/db/scenarios.ts
-init_types();
-init_database();
-function nextShortId(projectId) {
-  const db2 = getDatabase();
-  if (projectId) {
-    const project = db2.query("SELECT scenario_prefix, scenario_counter FROM projects WHERE id = ?").get(projectId);
-    if (project) {
-      const next = project.scenario_counter + 1;
-      db2.query("UPDATE projects SET scenario_counter = ? WHERE id = ?").run(next, projectId);
-      return `${project.scenario_prefix}-${next}`;
-    }
-  }
-  return shortUuid();
-}
-function createScenario(input) {
-  const db2 = getDatabase();
-  const id = uuid();
-  const short_id = nextShortId(input.projectId);
-  const timestamp = now();
-  db2.query(`
-    INSERT INTO scenarios (id, short_id, project_id, name, description, steps, tags, priority, model, timeout_ms, target_path, requires_auth, auth_config, metadata, assertions, version, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
-  `).run(id, short_id, input.projectId ?? null, input.name, input.description, JSON.stringify(input.steps ?? []), JSON.stringify(input.tags ?? []), input.priority ?? "medium", input.model ?? null, input.timeoutMs ?? null, input.targetPath ?? null, input.requiresAuth ? 1 : 0, input.authConfig ? JSON.stringify(input.authConfig) : null, input.metadata ? JSON.stringify(input.metadata) : null, JSON.stringify(input.assertions ?? []), timestamp, timestamp);
-  return getScenario(id);
-}
-function getScenario(id) {
-  const db2 = getDatabase();
-  let row = db2.query("SELECT * FROM scenarios WHERE id = ?").get(id);
-  if (row)
-    return scenarioFromRow(row);
-  row = db2.query("SELECT * FROM scenarios WHERE short_id = ?").get(id);
-  if (row)
-    return scenarioFromRow(row);
-  const fullId = resolvePartialId("scenarios", id);
-  if (fullId) {
-    row = db2.query("SELECT * FROM scenarios WHERE id = ?").get(fullId);
-    if (row)
-      return scenarioFromRow(row);
-  }
-  return null;
-}
-function getScenarioByShortId(shortId) {
-  const db2 = getDatabase();
-  const row = db2.query("SELECT * FROM scenarios WHERE short_id = ?").get(shortId);
-  return row ? scenarioFromRow(row) : null;
-}
-function listScenarios(filter) {
-  const db2 = getDatabase();
-  const conditions = [];
-  const params = [];
-  if (filter?.projectId) {
-    conditions.push("project_id = ?");
-    params.push(filter.projectId);
-  }
-  if (filter?.tags && filter.tags.length > 0) {
-    for (const tag of filter.tags) {
-      conditions.push("tags LIKE ?");
-      params.push(`%"${tag}"%`);
-    }
-  }
-  if (filter?.priority) {
-    conditions.push("priority = ?");
-    params.push(filter.priority);
-  }
-  if (filter?.search) {
-    conditions.push("(name LIKE ? OR description LIKE ?)");
-    const term = `%${filter.search}%`;
-    params.push(term, term);
-  }
-  let sql = "SELECT * FROM scenarios";
-  if (conditions.length > 0) {
-    sql += " WHERE " + conditions.join(" AND ");
-  }
-  const sortField = filter?.sort ?? "date";
-  const sortDir = filter?.desc === false ? "ASC" : "DESC";
-  const orderByCol = sortField === "name" ? "name" : sortField === "priority" ? "CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END" : "created_at";
-  sql += ` ORDER BY ${orderByCol} ${sortDir}`;
-  if (filter?.limit) {
-    sql += " LIMIT ?";
-    params.push(filter.limit);
-  }
-  if (filter?.offset) {
-    sql += " OFFSET ?";
-    params.push(filter.offset);
-  }
-  const rows = db2.query(sql).all(...params);
-  return rows.map(scenarioFromRow);
-}
-function updateScenario(id, input, version) {
-  const db2 = getDatabase();
-  const existing = getScenario(id);
-  if (!existing) {
-    throw new Error(`Scenario not found: ${id}`);
-  }
-  if (existing.version !== version) {
-    throw new VersionConflictError("scenario", existing.id);
-  }
-  const sets = [];
-  const params = [];
-  if (input.name !== undefined) {
-    sets.push("name = ?");
-    params.push(input.name);
-  }
-  if (input.description !== undefined) {
-    sets.push("description = ?");
-    params.push(input.description);
-  }
-  if (input.steps !== undefined) {
-    sets.push("steps = ?");
-    params.push(JSON.stringify(input.steps));
-  }
-  if (input.tags !== undefined) {
-    sets.push("tags = ?");
-    params.push(JSON.stringify(input.tags));
-  }
-  if (input.priority !== undefined) {
-    sets.push("priority = ?");
-    params.push(input.priority);
-  }
-  if (input.model !== undefined) {
-    sets.push("model = ?");
-    params.push(input.model);
-  }
-  if (input.timeoutMs !== undefined) {
-    sets.push("timeout_ms = ?");
-    params.push(input.timeoutMs);
-  }
-  if (input.targetPath !== undefined) {
-    sets.push("target_path = ?");
-    params.push(input.targetPath);
-  }
-  if (input.requiresAuth !== undefined) {
-    sets.push("requires_auth = ?");
-    params.push(input.requiresAuth ? 1 : 0);
-  }
-  if (input.authConfig !== undefined) {
-    sets.push("auth_config = ?");
-    params.push(JSON.stringify(input.authConfig));
-  }
-  if (input.metadata !== undefined) {
-    sets.push("metadata = ?");
-    params.push(JSON.stringify(input.metadata));
-  }
-  if (input.assertions !== undefined) {
-    sets.push("assertions = ?");
-    params.push(JSON.stringify(input.assertions));
-  }
-  if (sets.length === 0) {
-    return existing;
-  }
-  sets.push("version = ?");
-  params.push(version + 1);
-  sets.push("updated_at = ?");
-  params.push(now());
-  params.push(existing.id);
-  params.push(version);
-  const result = db2.query(`UPDATE scenarios SET ${sets.join(", ")} WHERE id = ? AND version = ?`).run(...params);
-  if (result.changes === 0) {
-    throw new VersionConflictError("scenario", existing.id);
-  }
-  return getScenario(existing.id);
-}
-function findStaleScenarios(days) {
-  const db2 = getDatabase();
-  const rows = db2.query(`
-    SELECT s.*, MAX(r.created_at) AS last_run_at
-    FROM scenarios s
-    LEFT JOIN results r ON r.scenario_id = s.id
-    GROUP BY s.id
-    HAVING last_run_at IS NULL
-       OR last_run_at < datetime('now', ? || ' days')
-    ORDER BY last_run_at ASC NULLS FIRST
-  `).all(`-${days}`);
-  return rows.map((row) => ({
-    ...scenarioFromRow(row),
-    lastRunAt: row.last_run_at
-  }));
-}
-function deleteScenario(id) {
-  const db2 = getDatabase();
-  const scenario = getScenario(id);
-  if (!scenario)
-    return false;
-  const result = db2.query("DELETE FROM scenarios WHERE id = ?").run(scenario.id);
-  return result.changes > 0;
-}
+// src/mcp/index.ts
+init_scenarios();
 
 // src/db/runs.ts
 init_types();
@@ -5186,94 +6027,53 @@ function ensureProject(name, path) {
 
 // src/db/agents.ts
 init_types();
-init_database();
-function registerAgent(input) {
-  const db2 = getDatabase();
-  const existing = db2.query("SELECT * FROM agents WHERE name = ?").get(input.name);
-  if (existing) {
-    db2.query("UPDATE agents SET last_seen_at = ? WHERE id = ?").run(now(), existing.id);
-    return getAgent(existing.id);
-  }
-  const id = uuid();
-  const timestamp = now();
-  db2.query(`
-    INSERT INTO agents (id, name, description, role, metadata, created_at, last_seen_at)
-    VALUES (?, ?, ?, ?, '{}', ?, ?)
-  `).run(id, input.name, input.description ?? null, input.role ?? null, timestamp, timestamp);
-  return getAgent(id);
-}
-function getAgent(id) {
-  const db2 = getDatabase();
-  const row = db2.query("SELECT * FROM agents WHERE id = ?").get(id);
-  return row ? agentFromRow(row) : null;
-}
-function listAgents() {
-  const db2 = getDatabase();
-  const rows = db2.query("SELECT * FROM agents ORDER BY created_at DESC").all();
-  return rows.map(agentFromRow);
-}
-
-// src/lib/browser.ts
-import { chromium as chromium2 } from "playwright";
-init_types();
-var DEFAULT_VIEWPORT = { width: 1280, height: 720 };
-async function launchBrowser(options) {
-  const engine = options?.engine ?? process.env["TESTERS_BROWSER_ENGINE"] ?? "playwright";
-  if (engine === "lightpanda") {
-    const { launchLightpanda: launchLightpanda2, isLightpandaAvailable: isLightpandaAvailable2 } = await Promise.resolve().then(() => (init_browser_lightpanda(), exports_browser_lightpanda));
-    if (!isLightpandaAvailable2()) {
-      throw new BrowserError("Lightpanda not installed. Run: testers install-browser --engine lightpanda");
-    }
-    return launchLightpanda2({ viewport: options?.viewport });
-  }
-  const headless = options?.headless ?? true;
-  const viewport = options?.viewport ?? DEFAULT_VIEWPORT;
-  try {
-    const browser = await chromium2.launch({
-      headless,
-      args: [
-        `--window-size=${viewport.width},${viewport.height}`
-      ]
-    });
-    return browser;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new BrowserError(`Failed to launch browser: ${message}`);
+init_database();
+function registerAgent(input) {
+  const db2 = getDatabase();
+  const existing = db2.query("SELECT * FROM agents WHERE name = ?").get(input.name);
+  if (existing) {
+    db2.query("UPDATE agents SET last_seen_at = ? WHERE id = ?").run(now(), existing.id);
+    return getAgent(existing.id);
   }
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO agents (id, name, description, role, metadata, created_at, last_seen_at)
+    VALUES (?, ?, ?, ?, '{}', ?, ?)
+  `).run(id, input.name, input.description ?? null, input.role ?? null, timestamp, timestamp);
+  return getAgent(id);
 }
-async function getPage(browser, options) {
-  const engine = options?.engine ?? "playwright";
-  if (engine === "lightpanda") {
-    const { getLightpandaPage: getLightpandaPage2 } = await Promise.resolve().then(() => (init_browser_lightpanda(), exports_browser_lightpanda));
-    return getLightpandaPage2(browser, options);
-  }
-  const viewport = options?.viewport ?? DEFAULT_VIEWPORT;
-  try {
-    const context = await browser.newContext({
-      viewport,
-      userAgent: options?.userAgent,
-      locale: options?.locale
-    });
-    const page = await context.newPage();
-    return page;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new BrowserError(`Failed to create page: ${message}`);
-  }
+function getAgent(id) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM agents WHERE id = ?").get(id);
+  return row ? agentFromRow(row) : null;
 }
-async function closeBrowser(browser, engine) {
-  if (engine === "lightpanda") {
-    const { closeLightpanda: closeLightpanda2 } = await Promise.resolve().then(() => (init_browser_lightpanda(), exports_browser_lightpanda));
-    return closeLightpanda2(browser);
-  }
-  try {
-    await browser.close();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new BrowserError(`Failed to close browser: ${message}`);
-  }
+function listAgents() {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM agents ORDER BY created_at DESC").all();
+  return rows.map(agentFromRow);
+}
+function heartbeatAgent(id) {
+  const db2 = getDatabase();
+  const affected = db2.query("UPDATE agents SET last_seen_at = ? WHERE id = ?").run(now(), id);
+  if (affected.changes === 0)
+    return null;
+  return getAgent(id);
+}
+function setAgentFocus(id, scenarioId) {
+  const db2 = getDatabase();
+  const agent = getAgent(id);
+  if (!agent)
+    return null;
+  const metadata = { ...agent.metadata ?? {}, focus: scenarioId };
+  db2.query("UPDATE agents SET metadata = ?, last_seen_at = ? WHERE id = ?").run(JSON.stringify(metadata), now(), id);
+  return getAgent(id);
 }
 
+// src/lib/runner.ts
+init_scenarios();
+init_browser();
+
 // src/lib/screenshotter.ts
 import { mkdirSync as mkdirSync2, existsSync as existsSync2, writeFileSync } from "fs";
 import { join as join2 } from "path";
@@ -6329,6 +7129,98 @@ async function pushFailedRunToLogs(run, failedResults, scenarios) {
   } catch {}
 }
 
+// src/lib/failure-pipeline.ts
+init_todos_connector();
+async function createFailureTasks(run, failedResults, scenarios) {
+  if (failedResults.length === 0)
+    return { created: 0, skipped: 0 };
+  const projectId = process.env["TESTERS_TODOS_PROJECT_ID"];
+  if (!projectId)
+    return { created: 0, skipped: 0 };
+  let db2 = null;
+  try {
+    db2 = connectToTodos();
+  } catch {
+    return { created: 0, skipped: 0 };
+  }
+  const scenarioMap = new Map(scenarios.map((s) => [s.id, s]));
+  let created = 0;
+  let skipped = 0;
+  try {
+    for (const result of failedResults) {
+      const scenario = scenarioMap.get(result.scenarioId);
+      const title = `BUG: [testers] ${scenario?.name ?? result.scenarioId} failed`;
+      const existing = db2.query("SELECT id FROM tasks WHERE title = ? AND status NOT IN ('completed', 'cancelled') LIMIT 1").get(title);
+      if (existing) {
+        skipped++;
+        continue;
+      }
+      const id = crypto.randomUUID();
+      const now2 = new Date().toISOString();
+      const description = [
+        `Test failure detected by open-testers.`,
+        ``,
+        `**Run:** ${run.id}`,
+        `**URL:** ${run.url}`,
+        `**Scenario:** ${scenario?.name ?? result.scenarioId}`,
+        `**Status:** ${result.status}`,
+        result.error ? `**Error:** ${result.error}` : null,
+        result.reasoning ? `**Reasoning:** ${result.reasoning.slice(0, 500)}` : null,
+        `**Duration:** ${result.durationMs ? `${(result.durationMs / 1000).toFixed(1)}s` : "N/A"}`,
+        `**Tokens:** ${result.tokensUsed ?? 0}`
+      ].filter(Boolean).join(`
+`);
+      try {
+        db2.query(`
+          INSERT INTO tasks (id, short_id, title, description, status, priority, tags, project_id, version, created_at, updated_at)
+          VALUES (?, ?, ?, ?, 'pending', 'high', ?, ?, 1, ?, ?)
+        `).run(id, `BUG-${id.slice(0, 6)}`, title, description, JSON.stringify(["bug", "testers", "auto-created"]), projectId, now2, now2);
+        created++;
+      } catch {
+        skipped++;
+      }
+    }
+  } finally {
+    db2.close();
+  }
+  return { created, skipped };
+}
+async function notifyFailureToConversations(run, failedResults, scenarios) {
+  const baseUrl = process.env["TESTERS_CONVERSATIONS_URL"];
+  const space = process.env["TESTERS_CONVERSATIONS_SPACE"];
+  if (!baseUrl || !space)
+    return;
+  const scenarioMap = new Map(scenarios.map((s) => [s.id, s]));
+  const total = run.total;
+  const failedCount = failedResults.length;
+  const passedCount = run.passed;
+  const failureLines = failedResults.slice(0, 5).map((r) => {
+    const name = scenarioMap.get(r.scenarioId)?.name ?? r.scenarioId;
+    const err = r.error ? ` \u2014 ${r.error.slice(0, 120)}` : "";
+    return `  \u274C ${name}${err}`;
+  });
+  const extra = failedResults.length > 5 ? `  \u2026 and ${failedResults.length - 5} more` : "";
+  const message = [
+    `\uD83D\uDEA8 **Testers run failed** \u2014 ${failedCount}/${total} scenarios failed`,
+    ``,
+    `**URL:** ${run.url}`,
+    `**Run ID:** \`${run.id}\``,
+    `**Pass rate:** ${passedCount}/${total}`,
+    ``,
+    `**Failures:**`,
+    ...failureLines,
+    extra
+  ].filter((l) => l !== "").join(`
+`);
+  try {
+    await fetch(`${baseUrl.replace(/\/$/, "")}/api/spaces/${encodeURIComponent(space)}/messages`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content: message, from: "testers" })
+    });
+  } catch {}
+}
+
 // src/lib/runner.ts
 var eventHandler = null;
 function emit(event) {
@@ -6562,6 +7454,8 @@ async function runBatch(scenarios, options) {
   if (finalRun.status === "failed") {
     const failedResults = results.filter((r) => r.status === "failed" || r.status === "error");
     pushFailedRunToLogs(finalRun, failedResults, scenarios).catch(() => {});
+    createFailureTasks(finalRun, failedResults, scenarios).catch(() => {});
+    notifyFailureToConversations(finalRun, failedResults, scenarios).catch(() => {});
   }
   return { run: finalRun, results };
 }
@@ -6675,108 +7569,60 @@ function estimateCost(model, tokens) {
   return tokens / 1e6 * costPer1M * 100;
 }
 
-// src/lib/todos-connector.ts
-import { Database as Database2 } from "bun:sqlite";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir4 } from "os";
-init_types();
-function resolveTodosDbPath() {
-  const envPath = process.env["TODOS_DB_PATH"];
-  if (envPath)
-    return envPath;
-  return join4(homedir4(), ".todos", "todos.db");
-}
-function connectToTodos() {
-  const dbPath = resolveTodosDbPath();
-  if (!existsSync4(dbPath)) {
-    throw new TodosConnectionError(`Todos database not found at ${dbPath}. Install @hasna/todos or set TODOS_DB_PATH.`);
-  }
-  const db2 = new Database2(dbPath, { readonly: true });
-  db2.exec("PRAGMA foreign_keys = ON");
-  return db2;
-}
-function pullTasks(options = {}) {
-  const db2 = connectToTodos();
-  try {
-    let query = "SELECT id, short_id, title, description, status, priority, tags, project_id FROM tasks WHERE 1=1";
-    const params = [];
-    if (options.status) {
-      query += " AND status = ?";
-      params.push(options.status);
-    } else {
-      query += " AND status IN ('pending', 'in_progress')";
-    }
-    if (options.priority) {
-      query += " AND priority = ?";
-      params.push(options.priority);
-    }
-    if (options.projectName) {
-      const project = db2.query("SELECT id FROM projects WHERE name = ?").get(options.projectName);
-      if (project) {
-        query += " AND project_id = ?";
-        params.push(project.id);
+// src/lib/affected.ts
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\x00DS\x00").replace(/\*/g, "[^/]*").replace(/\x00DS\x00/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function matchFilesToScenarios(filePaths, scenarios, mappings = []) {
+  if (filePaths.length === 0)
+    return scenarios;
+  const compiledMappings = mappings.map((m) => ({
+    regex: globToRegex(m.glob),
+    tags: m.tags
+  }));
+  const normPaths = filePaths.map((p) => p.replace(/\\/g, "/").toLowerCase());
+  const matchedIds = new Set;
+  for (const scenario of scenarios) {
+    let matched = false;
+    if (!matched) {
+      for (const { regex, tags } of compiledMappings) {
+        if (normPaths.some((fp) => regex.test(fp)) && tags.some((tag) => scenario.tags.includes(tag))) {
+          matched = true;
+          break;
+        }
       }
     }
-    query += " ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END";
-    const tasks = db2.query(query).all(...params);
-    if (options.tags && options.tags.length > 0) {
-      return tasks.filter((task) => {
-        const taskTags = JSON.parse(task.tags || "[]");
-        return options.tags.some((tag) => taskTags.includes(tag));
-      });
+    if (!matched && scenario.targetPath) {
+      const segments = scenario.targetPath.replace(/^\//, "").split("/").filter((s) => s.length > 2);
+      if (segments.some((seg) => normPaths.some((fp) => fp.includes(seg.toLowerCase())))) {
+        matched = true;
+      }
     }
-    return tasks;
-  } finally {
-    db2.close();
-  }
-}
-function taskToScenarioInput(task, projectId) {
-  const tags = JSON.parse(task.tags || "[]");
-  const priority = ["low", "medium", "high", "critical"].includes(task.priority) ? task.priority : "medium";
-  const steps = [];
-  if (task.description) {
-    const lines = task.description.split(`
-`);
-    for (const line of lines) {
-      const match = line.match(/^\s*\d+[\.\)]\s*(.+)/);
-      if (match?.[1]) {
-        steps.push(match[1].trim());
+    if (!matched) {
+      for (const tag of scenario.tags) {
+        if (tag.length > 2 && normPaths.some((fp) => fp.includes(tag.toLowerCase()))) {
+          matched = true;
+          break;
+        }
       }
     }
-  }
-  return {
-    name: task.title.replace(/^(OPE\d+-\d+|[A-Z]+-\d+):\s*/, ""),
-    description: task.description || task.title,
-    steps,
-    tags,
-    priority,
-    projectId,
-    metadata: { todosTaskId: task.id, todosShortId: task.short_id }
-  };
-}
-function importFromTodos(options = {}) {
-  const tasks = pullTasks({
-    projectName: options.projectName,
-    tags: options.tags ?? ["qa", "test", "testing"],
-    priority: options.priority
-  });
-  const existing = listScenarios({ projectId: options.projectId });
-  const existingTodoIds = new Set(existing.filter((s) => s.metadata?.todosTaskId).map((s) => s.metadata.todosTaskId));
-  let imported = 0;
-  let skipped = 0;
-  for (const task of tasks) {
-    if (existingTodoIds.has(task.id)) {
-      skipped++;
-      continue;
+    if (!matched) {
+      const nameWords = scenario.name.toLowerCase().split(/[\s\-_/]+/).filter((w) => w.length > 3);
+      if (nameWords.some((word) => normPaths.some((fp) => fp.includes(word)))) {
+        matched = true;
+      }
     }
-    const input = taskToScenarioInput(task, options.projectId);
-    createScenario(input);
-    imported++;
+    if (matched)
+      matchedIds.add(scenario.id);
   }
-  return { imported, skipped };
+  return scenarios.filter((s) => matchedIds.has(s.id));
 }
 
+// src/mcp/index.ts
+init_scan_issues();
+init_todos_connector();
+
 // src/db/schedules.ts
 init_database();
 init_types();
@@ -7640,6 +8486,188 @@ server.tool("get_stale_scenarios", "List scenarios that have not been run recent
     return errorResponse(error);
   }
 });
+server.tool("run_affected_scenarios", "Run only the scenarios relevant to a set of changed files. Matches files to scenarios via explicit glob\u2192tag rules, targetPath keywords, and name/tag inference. Returns immediately \u2014 poll with get_run.", {
+  url: exports_external.string().describe("Target URL to test against"),
+  filePaths: exports_external.array(exports_external.string()).describe("Changed file paths (relative or absolute)"),
+  mappings: exports_external.array(exports_external.object({
+    glob: exports_external.string().describe("File glob pattern (supports * and **)"),
+    tags: exports_external.array(exports_external.string()).describe("Run scenarios tagged with these if glob matches")
+  })).optional().describe("Explicit file glob \u2192 scenario tag mappings"),
+  projectId: exports_external.string().optional().describe("Restrict to scenarios in this project"),
+  model: exports_external.string().optional().describe(MODEL_DESC),
+  headed: exports_external.boolean().optional().describe("Run browser in headed mode"),
+  parallel: exports_external.number().optional().describe("Number of parallel workers")
+}, async ({ url, filePaths, mappings, projectId, model, headed, parallel }) => {
+  try {
+    const allScenarios = listScenarios({ projectId });
+    const matched = matchFilesToScenarios(filePaths, allScenarios, mappings ?? []);
+    if (matched.length === 0) {
+      return json({ runId: null, scenarioCount: 0, matchedScenarios: [], message: "No scenarios matched the provided file paths." });
+    }
+    const scenarioIds = matched.map((s) => s.id);
+    const { runId, scenarioCount } = startRunAsync({ url, scenarioIds, model, headed, parallel, projectId });
+    return json({
+      runId,
+      scenarioCount,
+      url,
+      status: "running",
+      matchedScenarios: matched.map((s) => ({ id: s.id, shortId: s.shortId, name: s.name, tags: s.tags })),
+      message: "Poll with get_run to check progress."
+    });
+  } catch (error) {
+    return errorResponse(error);
+  }
+});
+server.tool("heartbeat", "Update an agent's last_seen_at timestamp. Call regularly to signal the agent is alive.", {
+  agentId: exports_external.string().describe("Agent ID to heartbeat")
+}, async ({ agentId }) => {
+  try {
+    const agent = heartbeatAgent(agentId);
+    if (!agent)
+      return errorResponse(notFoundErr(agentId, "Agent"));
+    return json({ ok: true, agentId: agent.id, lastSeenAt: agent.lastSeenAt });
+  } catch (error) {
+    return errorResponse(error);
+  }
+});
+server.tool("set_focus", "Set (or clear) an agent's current focus scenario. Stored in agent metadata.", {
+  agentId: exports_external.string().describe("Agent ID"),
+  scenarioId: exports_external.string().nullable().describe("Scenario ID the agent is working on, or null to clear")
+}, async ({ agentId, scenarioId }) => {
+  try {
+    const agent = setAgentFocus(agentId, scenarioId);
+    if (!agent)
+      return errorResponse(notFoundErr(agentId, "Agent"));
+    return json({ ok: true, agentId: agent.id, focus: agent.metadata?.focus ?? null });
+  } catch (error) {
+    return errorResponse(error);
+  }
+});
+server.tool("scan_console_errors", "Visit pages headlessly and collect JS/React console errors, uncaught exceptions, and unhandled promise rejections.", {
+  url: exports_external.string().describe("Root URL to scan"),
+  pages: exports_external.array(exports_external.string()).optional().describe("Specific paths to visit (e.g. ['/login', '/dashboard']). Defaults to root URL only."),
+  projectId: exports_external.string().optional().describe("Project ID for deduplication tracking"),
+  headed: exports_external.boolean().optional().describe("Run browser in headed mode"),
+  timeoutMs: exports_external.number().optional().describe("Navigation timeout per page (default 15000)")
+}, async ({ url, pages, projectId, headed, timeoutMs }) => {
+  try {
+    const { scanConsoleErrors: scanConsoleErrors2 } = await Promise.resolve().then(() => (init_console(), exports_console));
+    const { upsertScanIssue: upsertScanIssue2 } = await Promise.resolve().then(() => (init_scan_issues(), exports_scan_issues));
+    const result = await scanConsoleErrors2({ url, pages, headed, timeoutMs });
+    const deduped = result.issues.map((issue) => {
+      const { outcome } = upsertScanIssue2(issue, projectId);
+      return { ...issue, outcome };
+    });
+    return json({ ...result, issues: deduped });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("scan_network_errors", "Visit pages and intercept network requests, flagging 5xx errors, 4xx on API routes, CORS failures, and request timeouts.", {
+  url: exports_external.string().describe("Root URL to scan"),
+  pages: exports_external.array(exports_external.string()).optional().describe("Specific paths to visit"),
+  projectId: exports_external.string().optional().describe("Project ID for deduplication tracking"),
+  headed: exports_external.boolean().optional(),
+  timeoutMs: exports_external.number().optional()
+}, async ({ url, pages, projectId, headed, timeoutMs }) => {
+  try {
+    const { scanNetworkErrors: scanNetworkErrors2 } = await Promise.resolve().then(() => (init_network(), exports_network));
+    const { upsertScanIssue: upsertScanIssue2 } = await Promise.resolve().then(() => (init_scan_issues(), exports_scan_issues));
+    const result = await scanNetworkErrors2({ url, pages, headed, timeoutMs });
+    const deduped = result.issues.map((issue) => {
+      const { outcome } = upsertScanIssue2(issue, projectId);
+      return { ...issue, outcome };
+    });
+    return json({ ...result, issues: deduped });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("scan_broken_links", "Crawl app from root URL and flag any links that return 404 or fail to load.", {
+  url: exports_external.string().describe("Root URL to crawl from"),
+  maxPages: exports_external.number().optional().describe("Max pages to crawl (default 30)"),
+  projectId: exports_external.string().optional().describe("Project ID for deduplication tracking"),
+  headed: exports_external.boolean().optional(),
+  timeoutMs: exports_external.number().optional()
+}, async ({ url, maxPages, projectId, headed, timeoutMs }) => {
+  try {
+    const { scanBrokenLinks: scanBrokenLinks2 } = await Promise.resolve().then(() => (init_links(), exports_links));
+    const { upsertScanIssue: upsertScanIssue2 } = await Promise.resolve().then(() => (init_scan_issues(), exports_scan_issues));
+    const result = await scanBrokenLinks2({ url, maxPages, headed, timeoutMs });
+    const deduped = result.issues.map((issue) => {
+      const { outcome } = upsertScanIssue2(issue, projectId);
+      return { ...issue, outcome };
+    });
+    return json({ ...result, issues: deduped });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("scan_performance", "Visit pages and measure load time, DOMContentLoaded, and LCP using the Web Performance API. Flags slow pages.", {
+  url: exports_external.string().describe("Root URL to scan"),
+  pages: exports_external.array(exports_external.string()).optional().describe("Specific paths to visit"),
+  projectId: exports_external.string().optional().describe("Project ID for deduplication tracking"),
+  headed: exports_external.boolean().optional(),
+  timeoutMs: exports_external.number().optional(),
+  thresholds: exports_external.object({
+    loadTimeMs: exports_external.number().optional(),
+    domContentLoadedMs: exports_external.number().optional(),
+    lcpMs: exports_external.number().optional()
+  }).optional().describe("Override default thresholds")
+}, async ({ url, pages, projectId, headed, timeoutMs, thresholds }) => {
+  try {
+    const { scanPerformance: scanPerformance2 } = await Promise.resolve().then(() => (init_performance(), exports_performance));
+    const { upsertScanIssue: upsertScanIssue2 } = await Promise.resolve().then(() => (init_scan_issues(), exports_scan_issues));
+    const result = await scanPerformance2({ url, pages, headed, timeoutMs, thresholds });
+    const deduped = result.issues.map((issue) => {
+      const { outcome } = upsertScanIssue2(issue, projectId);
+      return { ...issue, outcome };
+    });
+    return json({ ...result, issues: deduped });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("run_health_scan", "Run all scanners (console, network, links, performance) against a URL. Deduplicates issues, creates todo tasks for new/regressed issues, and posts to conversations space.", {
+  url: exports_external.string().describe("URL to scan"),
+  pages: exports_external.array(exports_external.string()).optional().describe("Specific paths to include"),
+  projectId: exports_external.string().optional().describe("Project ID"),
+  scanners: exports_external.array(exports_external.enum(["console", "network", "links", "performance"])).optional().describe("Which scanners to run (default: console, network, links)"),
+  maxPages: exports_external.number().optional().describe("Max pages for link crawl (default 20)"),
+  headed: exports_external.boolean().optional(),
+  timeoutMs: exports_external.number().optional()
+}, async ({ url, pages, projectId, scanners, maxPages, headed, timeoutMs }) => {
+  try {
+    const { runHealthScan: runHealthScan2 } = await Promise.resolve().then(() => (init_health_scan(), exports_health_scan));
+    const summary = await runHealthScan2({ url, pages, projectId, scanners, maxPages, headed, timeoutMs });
+    return json(summary);
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("list_scan_issues", "List persisted scan issues with optional filters.", {
+  status: exports_external.enum(["open", "resolved", "regressed"]).optional(),
+  type: exports_external.enum(["console_error", "network_error", "broken_link", "performance"]).optional(),
+  projectId: exports_external.string().optional(),
+  limit: exports_external.number().optional()
+}, async ({ status, type, projectId, limit }) => {
+  try {
+    const issues = listScanIssues({ status, type, projectId, limit });
+    return json({ items: issues, total: issues.length });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("resolve_scan_issue", "Mark a scan issue as resolved.", { id: exports_external.string().describe("Scan issue ID") }, async ({ id }) => {
+  try {
+    const ok = resolveScanIssue(id);
+    if (!ok)
+      return errorResponse(notFoundErr(id, "ScanIssue"));
+    return json({ resolved: true, id });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
 async function main() {
   const transport = new StdioServerTransport;
   await server.connect(transport);