@hasna/testers 0.0.1

package/dist/index.js

@@ -0,0 +1,2515 @@
+// @bun
+// src/types/index.ts
+var MODEL_MAP = {
+  quick: "claude-haiku-4-5-20251001",
+  thorough: "claude-sonnet-4-6-20260311",
+  deep: "claude-opus-4-6-20260311"
+};
+function projectFromRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    path: row.path,
+    description: row.description,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function agentFromRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    role: row.role,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    createdAt: row.created_at,
+    lastSeenAt: row.last_seen_at
+  };
+}
+function scenarioFromRow(row) {
+  return {
+    id: row.id,
+    shortId: row.short_id,
+    projectId: row.project_id,
+    name: row.name,
+    description: row.description,
+    steps: JSON.parse(row.steps),
+    tags: JSON.parse(row.tags),
+    priority: row.priority,
+    model: row.model,
+    timeoutMs: row.timeout_ms,
+    targetPath: row.target_path,
+    requiresAuth: row.requires_auth === 1,
+    authConfig: row.auth_config ? JSON.parse(row.auth_config) : null,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    version: row.version,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function runFromRow(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    status: row.status,
+    url: row.url,
+    model: row.model,
+    headed: row.headed === 1,
+    parallel: row.parallel,
+    total: row.total,
+    passed: row.passed,
+    failed: row.failed,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null
+  };
+}
+function resultFromRow(row) {
+  return {
+    id: row.id,
+    runId: row.run_id,
+    scenarioId: row.scenario_id,
+    status: row.status,
+    reasoning: row.reasoning,
+    error: row.error,
+    stepsCompleted: row.steps_completed,
+    stepsTotal: row.steps_total,
+    durationMs: row.duration_ms,
+    model: row.model,
+    tokensUsed: row.tokens_used,
+    costCents: row.cost_cents,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    createdAt: row.created_at
+  };
+}
+function screenshotFromRow(row) {
+  return {
+    id: row.id,
+    resultId: row.result_id,
+    stepNumber: row.step_number,
+    action: row.action,
+    filePath: row.file_path,
+    width: row.width,
+    height: row.height,
+    timestamp: row.timestamp
+  };
+}
+
+class ScenarioNotFoundError extends Error {
+  constructor(id) {
+    super(`Scenario not found: ${id}`);
+    this.name = "ScenarioNotFoundError";
+  }
+}
+
+class RunNotFoundError extends Error {
+  constructor(id) {
+    super(`Run not found: ${id}`);
+    this.name = "RunNotFoundError";
+  }
+}
+
+class ResultNotFoundError extends Error {
+  constructor(id) {
+    super(`Result not found: ${id}`);
+    this.name = "ResultNotFoundError";
+  }
+}
+
+class VersionConflictError extends Error {
+  constructor(entity, id) {
+    super(`Version conflict on ${entity}: ${id}`);
+    this.name = "VersionConflictError";
+  }
+}
+
+class BrowserError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BrowserError";
+  }
+}
+
+class AIClientError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AIClientError";
+  }
+}
+
+class TodosConnectionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TodosConnectionError";
+  }
+}
+
+class ProjectNotFoundError extends Error {
+  constructor(id) {
+    super(`Project not found: ${id}`);
+    this.name = "ProjectNotFoundError";
+  }
+}
+
+class AgentNotFoundError extends Error {
+  constructor(id) {
+    super(`Agent not found: ${id}`);
+    this.name = "AgentNotFoundError";
+  }
+}
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var db = null;
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function shortUuid() {
+  return uuid().slice(0, 8);
+}
+function resolveDbPath() {
+  const envPath = process.env["TESTERS_DB_PATH"];
+  if (envPath)
+    return envPath;
+  const dir = join(homedir(), ".testers");
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  return join(dir, "testers.db");
+}
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    path TEXT UNIQUE,
+    description TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    role TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS scenarios (
+    id TEXT PRIMARY KEY,
+    short_id TEXT NOT NULL UNIQUE,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    name TEXT NOT NULL,
+    description TEXT NOT NULL DEFAULT '',
+    steps TEXT NOT NULL DEFAULT '[]',
+    tags TEXT NOT NULL DEFAULT '[]',
+    priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low','medium','high','critical')),
+    model TEXT,
+    timeout_ms INTEGER,
+    target_path TEXT,
+    requires_auth INTEGER NOT NULL DEFAULT 0,
+    auth_config TEXT,
+    metadata TEXT DEFAULT '{}',
+    version INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS runs (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','running','passed','failed','cancelled')),
+    url TEXT NOT NULL,
+    model TEXT NOT NULL,
+    headed INTEGER NOT NULL DEFAULT 0,
+    parallel INTEGER NOT NULL DEFAULT 1,
+    total INTEGER NOT NULL DEFAULT 0,
+    passed INTEGER NOT NULL DEFAULT 0,
+    failed INTEGER NOT NULL DEFAULT 0,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    finished_at TEXT,
+    metadata TEXT DEFAULT '{}'
+  );
+
+  CREATE TABLE IF NOT EXISTS results (
+    id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+    scenario_id TEXT NOT NULL REFERENCES scenarios(id) ON DELETE CASCADE,
+    status TEXT NOT NULL DEFAULT 'skipped' CHECK(status IN ('passed','failed','error','skipped')),
+    reasoning TEXT,
+    error TEXT,
+    steps_completed INTEGER NOT NULL DEFAULT 0,
+    steps_total INTEGER NOT NULL DEFAULT 0,
+    duration_ms INTEGER NOT NULL DEFAULT 0,
+    model TEXT NOT NULL,
+    tokens_used INTEGER NOT NULL DEFAULT 0,
+    cost_cents REAL NOT NULL DEFAULT 0,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS screenshots (
+    id TEXT PRIMARY KEY,
+    result_id TEXT NOT NULL REFERENCES results(id) ON DELETE CASCADE,
+    step_number INTEGER NOT NULL,
+    action TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    width INTEGER NOT NULL DEFAULT 0,
+    height INTEGER NOT NULL DEFAULT 0,
+    timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  `,
+  `
+  CREATE INDEX IF NOT EXISTS idx_scenarios_project ON scenarios(project_id);
+  CREATE INDEX IF NOT EXISTS idx_scenarios_priority ON scenarios(priority);
+  CREATE INDEX IF NOT EXISTS idx_scenarios_short_id ON scenarios(short_id);
+  CREATE INDEX IF NOT EXISTS idx_runs_project ON runs(project_id);
+  CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+  CREATE INDEX IF NOT EXISTS idx_results_run ON results(run_id);
+  CREATE INDEX IF NOT EXISTS idx_results_scenario ON results(scenario_id);
+  CREATE INDEX IF NOT EXISTS idx_results_status ON results(status);
+  CREATE INDEX IF NOT EXISTS idx_screenshots_result ON screenshots(result_id);
+  `,
+  `
+  ALTER TABLE projects ADD COLUMN scenario_prefix TEXT DEFAULT 'TST';
+  ALTER TABLE projects ADD COLUMN scenario_counter INTEGER DEFAULT 0;
+  `
+];
+function applyMigrations(database) {
+  const applied = database.query("SELECT id FROM _migrations ORDER BY id").all();
+  const appliedIds = new Set(applied.map((r) => r.id));
+  for (let i = 0;i < MIGRATIONS.length; i++) {
+    const migrationId = i + 1;
+    if (appliedIds.has(migrationId))
+      continue;
+    const migration = MIGRATIONS[i];
+    database.exec(migration);
+    database.query("INSERT INTO _migrations (id, applied_at) VALUES (?, ?)").run(migrationId, now());
+  }
+}
+function getDatabase() {
+  if (db)
+    return db;
+  const dbPath = resolveDbPath();
+  const dir = dirname(dbPath);
+  if (dbPath !== ":memory:" && !existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  db = new Database(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      id INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  applyMigrations(db);
+  return db;
+}
+function closeDatabase() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+function resetDatabase() {
+  closeDatabase();
+  const database = getDatabase();
+  database.exec("DELETE FROM screenshots");
+  database.exec("DELETE FROM results");
+  database.exec("DELETE FROM runs");
+  database.exec("DELETE FROM scenarios");
+  database.exec("DELETE FROM agents");
+  database.exec("DELETE FROM projects");
+}
+function resolvePartialId(table, partialId) {
+  const database = getDatabase();
+  const rows = database.query(`SELECT id FROM ${table} WHERE id LIKE ? || '%'`).all(partialId);
+  if (rows.length === 1)
+    return rows[0].id;
+  return null;
+}
+// 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, 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, 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 ");
+  }
+  sql += " ORDER BY created_at DESC";
+  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 (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 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/db/runs.ts
+function createRun(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO runs (id, project_id, status, url, model, headed, parallel, total, passed, failed, started_at, finished_at, metadata)
+    VALUES (?, ?, 'pending', ?, ?, ?, ?, 0, 0, 0, ?, NULL, ?)
+  `).run(id, input.projectId ?? null, input.url, input.model, input.headed ? 1 : 0, input.parallel ?? 1, timestamp, input.model ? JSON.stringify({}) : null);
+  return getRun(id);
+}
+function getRun(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM runs WHERE id = ?").get(id);
+  if (row)
+    return runFromRow(row);
+  const fullId = resolvePartialId("runs", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM runs WHERE id = ?").get(fullId);
+    if (row)
+      return runFromRow(row);
+  }
+  return null;
+}
+function listRuns(filter) {
+  const db2 = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.projectId) {
+    conditions.push("project_id = ?");
+    params.push(filter.projectId);
+  }
+  if (filter?.status) {
+    conditions.push("status = ?");
+    params.push(filter.status);
+  }
+  let sql = "SELECT * FROM runs";
+  if (conditions.length > 0) {
+    sql += " WHERE " + conditions.join(" AND ");
+  }
+  sql += " ORDER BY started_at DESC";
+  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(runFromRow);
+}
+function updateRun(id, updates) {
+  const db2 = getDatabase();
+  const existing = getRun(id);
+  if (!existing) {
+    throw new Error(`Run not found: ${id}`);
+  }
+  const sets = [];
+  const params = [];
+  if (updates.status !== undefined) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.url !== undefined) {
+    sets.push("url = ?");
+    params.push(updates.url);
+  }
+  if (updates.model !== undefined) {
+    sets.push("model = ?");
+    params.push(updates.model);
+  }
+  if (updates.headed !== undefined) {
+    sets.push("headed = ?");
+    params.push(updates.headed);
+  }
+  if (updates.parallel !== undefined) {
+    sets.push("parallel = ?");
+    params.push(updates.parallel);
+  }
+  if (updates.total !== undefined) {
+    sets.push("total = ?");
+    params.push(updates.total);
+  }
+  if (updates.passed !== undefined) {
+    sets.push("passed = ?");
+    params.push(updates.passed);
+  }
+  if (updates.failed !== undefined) {
+    sets.push("failed = ?");
+    params.push(updates.failed);
+  }
+  if (updates.started_at !== undefined) {
+    sets.push("started_at = ?");
+    params.push(updates.started_at);
+  }
+  if (updates.finished_at !== undefined) {
+    sets.push("finished_at = ?");
+    params.push(updates.finished_at);
+  }
+  if (updates.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(updates.metadata);
+  }
+  if (sets.length === 0) {
+    return existing;
+  }
+  params.push(existing.id);
+  db2.query(`UPDATE runs SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  return getRun(existing.id);
+}
+function deleteRun(id) {
+  const db2 = getDatabase();
+  const run = getRun(id);
+  if (!run)
+    return false;
+  const result = db2.query("DELETE FROM runs WHERE id = ?").run(run.id);
+  return result.changes > 0;
+}
+// src/db/results.ts
+function createResult(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO results (id, run_id, scenario_id, status, reasoning, error, steps_completed, steps_total, duration_ms, model, tokens_used, cost_cents, metadata, created_at)
+    VALUES (?, ?, ?, 'skipped', NULL, NULL, 0, ?, 0, ?, 0, 0, '{}', ?)
+  `).run(id, input.runId, input.scenarioId, input.stepsTotal, input.model, timestamp);
+  return getResult(id);
+}
+function getResult(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM results WHERE id = ?").get(id);
+  if (row)
+    return resultFromRow(row);
+  const fullId = resolvePartialId("results", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM results WHERE id = ?").get(fullId);
+    if (row)
+      return resultFromRow(row);
+  }
+  return null;
+}
+function listResults(runId) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM results WHERE run_id = ? ORDER BY created_at ASC").all(runId);
+  return rows.map(resultFromRow);
+}
+function updateResult(id, updates) {
+  const db2 = getDatabase();
+  const existing = getResult(id);
+  if (!existing) {
+    throw new Error(`Result not found: ${id}`);
+  }
+  const sets = [];
+  const params = [];
+  if (updates.status !== undefined) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.reasoning !== undefined) {
+    sets.push("reasoning = ?");
+    params.push(updates.reasoning);
+  }
+  if (updates.error !== undefined) {
+    sets.push("error = ?");
+    params.push(updates.error);
+  }
+  if (updates.stepsCompleted !== undefined) {
+    sets.push("steps_completed = ?");
+    params.push(updates.stepsCompleted);
+  }
+  if (updates.durationMs !== undefined) {
+    sets.push("duration_ms = ?");
+    params.push(updates.durationMs);
+  }
+  if (updates.tokensUsed !== undefined) {
+    sets.push("tokens_used = ?");
+    params.push(updates.tokensUsed);
+  }
+  if (updates.costCents !== undefined) {
+    sets.push("cost_cents = ?");
+    params.push(updates.costCents);
+  }
+  if (sets.length === 0) {
+    return existing;
+  }
+  params.push(existing.id);
+  db2.query(`UPDATE results SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  return getResult(existing.id);
+}
+function getResultsByRun(runId) {
+  return listResults(runId);
+}
+// src/db/screenshots.ts
+function createScreenshot(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO screenshots (id, result_id, step_number, action, file_path, width, height, timestamp)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, input.resultId, input.stepNumber, input.action, input.filePath, input.width, input.height, timestamp);
+  return getScreenshot(id);
+}
+function getScreenshot(id) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM screenshots WHERE id = ?").get(id);
+  return row ? screenshotFromRow(row) : null;
+}
+function listScreenshots(resultId) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM screenshots WHERE result_id = ? ORDER BY step_number ASC").all(resultId);
+  return rows.map(screenshotFromRow);
+}
+function getScreenshotsByResult(resultId) {
+  return listScreenshots(resultId);
+}
+// src/db/projects.ts
+function createProject(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO projects (id, name, path, description, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(id, input.name, input.path ?? null, input.description ?? null, timestamp, timestamp);
+  return getProject(id);
+}
+function getProject(id) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM projects WHERE id = ?").get(id);
+  return row ? projectFromRow(row) : null;
+}
+function getProjectByPath(path) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM projects WHERE path = ?").get(path);
+  return row ? projectFromRow(row) : null;
+}
+function listProjects() {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM projects ORDER BY created_at DESC").all();
+  return rows.map(projectFromRow);
+}
+function ensureProject(name, path) {
+  const db2 = getDatabase();
+  const byPath = db2.query("SELECT * FROM projects WHERE path = ?").get(path);
+  if (byPath)
+    return projectFromRow(byPath);
+  const byName = db2.query("SELECT * FROM projects WHERE name = ?").get(name);
+  if (byName)
+    return projectFromRow(byName);
+  return createProject({ name, path });
+}
+// src/db/agents.ts
+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 getAgentByName(name) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM agents WHERE name = ?").get(name);
+  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/config.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { readFileSync, existsSync as existsSync2 } from "fs";
+var CONFIG_DIR = join2(homedir2(), ".testers");
+var CONFIG_PATH = join2(CONFIG_DIR, "config.json");
+function getDefaultConfig() {
+  return {
+    defaultModel: "claude-haiku-4-5-20251001",
+    models: { ...MODEL_MAP },
+    browser: {
+      headless: true,
+      viewport: { width: 1280, height: 720 },
+      timeout: 60000
+    },
+    screenshots: {
+      dir: join2(homedir2(), ".testers", "screenshots"),
+      format: "png",
+      quality: 90,
+      fullPage: false
+    }
+  };
+}
+function loadConfig() {
+  const defaults = getDefaultConfig();
+  let fileConfig = {};
+  if (existsSync2(CONFIG_PATH)) {
+    try {
+      const raw = readFileSync(CONFIG_PATH, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {}
+  }
+  const config = {
+    defaultModel: fileConfig.defaultModel ?? defaults.defaultModel,
+    models: fileConfig.models ? { ...defaults.models, ...fileConfig.models } : { ...defaults.models },
+    browser: fileConfig.browser ? { ...defaults.browser, ...fileConfig.browser } : { ...defaults.browser },
+    screenshots: fileConfig.screenshots ? { ...defaults.screenshots, ...fileConfig.screenshots } : { ...defaults.screenshots },
+    anthropicApiKey: fileConfig.anthropicApiKey,
+    todosDbPath: fileConfig.todosDbPath
+  };
+  const envModel = process.env["TESTERS_MODEL"];
+  if (envModel) {
+    config.defaultModel = envModel;
+  }
+  const envScreenshotsDir = process.env["TESTERS_SCREENSHOTS_DIR"];
+  if (envScreenshotsDir) {
+    config.screenshots.dir = envScreenshotsDir;
+  }
+  const envApiKey = process.env["ANTHROPIC_API_KEY"];
+  if (envApiKey) {
+    config.anthropicApiKey = envApiKey;
+  }
+  return config;
+}
+function resolveModel(nameOrId) {
+  if (nameOrId in MODEL_MAP) {
+    return MODEL_MAP[nameOrId];
+  }
+  return nameOrId;
+}
+// src/lib/browser.ts
+import { chromium } from "playwright";
+import { execSync } from "child_process";
+var DEFAULT_VIEWPORT = { width: 1280, height: 720 };
+async function launchBrowser(options) {
+  const headless = options?.headless ?? true;
+  const viewport = options?.viewport ?? DEFAULT_VIEWPORT;
+  try {
+    const browser = await chromium.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}`);
+  }
+}
+async function getPage(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) {
+  try {
+    await browser.close();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BrowserError(`Failed to close browser: ${message}`);
+  }
+}
+
+class BrowserPool {
+  pool = [];
+  maxSize;
+  headless;
+  viewport;
+  constructor(size, options) {
+    this.maxSize = size;
+    this.headless = options?.headless ?? true;
+    this.viewport = options?.viewport ?? DEFAULT_VIEWPORT;
+  }
+  async acquire() {
+    const idle = this.pool.find((entry) => !entry.inUse);
+    if (idle) {
+      idle.inUse = true;
+      const page = await getPage(idle.browser, { viewport: this.viewport });
+      return { browser: idle.browser, page };
+    }
+    if (this.pool.length < this.maxSize) {
+      const browser = await launchBrowser({
+        headless: this.headless,
+        viewport: this.viewport
+      });
+      const entry = { browser, inUse: true };
+      this.pool.push(entry);
+      const page = await getPage(browser, { viewport: this.viewport });
+      return { browser, page };
+    }
+    return new Promise((resolve, reject) => {
+      const interval = setInterval(() => {
+        const available = this.pool.find((entry) => !entry.inUse);
+        if (available) {
+          clearInterval(interval);
+          available.inUse = true;
+          getPage(available.browser, { viewport: this.viewport }).then((page) => resolve({ browser: available.browser, page })).catch(reject);
+        }
+      }, 50);
+    });
+  }
+  release(browser) {
+    const entry = this.pool.find((e) => e.browser === browser);
+    if (entry) {
+      entry.inUse = false;
+    }
+  }
+  async closeAll() {
+    const closePromises = this.pool.map((entry) => entry.browser.close().catch(() => {}));
+    await Promise.all(closePromises);
+    this.pool.length = 0;
+  }
+}
+async function installBrowser() {
+  try {
+    execSync("bunx playwright install chromium", {
+      stdio: "inherit"
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BrowserError(`Failed to install browser: ${message}`);
+  }
+}
+// src/lib/screenshotter.ts
+import { mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function generateFilename(stepNumber, action) {
+  const padded = String(stepNumber).padStart(3, "0");
+  const slug = slugify(action);
+  return `${padded}-${slug}.png`;
+}
+function getScreenshotDir(baseDir, runId, scenarioSlug) {
+  return join3(baseDir, runId, scenarioSlug);
+}
+function ensureDir(dirPath) {
+  if (!existsSync3(dirPath)) {
+    mkdirSync2(dirPath, { recursive: true });
+  }
+}
+var DEFAULT_BASE_DIR = join3(homedir3(), ".testers", "screenshots");
+
+class Screenshotter {
+  baseDir;
+  format;
+  quality;
+  fullPage;
+  constructor(options = {}) {
+    this.baseDir = options.baseDir ?? DEFAULT_BASE_DIR;
+    this.format = options.format ?? "png";
+    this.quality = options.quality ?? 90;
+    this.fullPage = options.fullPage ?? false;
+  }
+  async capture(page, options) {
+    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug);
+    const filename = generateFilename(options.stepNumber, options.action);
+    const filePath = join3(dir, filename);
+    ensureDir(dir);
+    await page.screenshot({
+      path: filePath,
+      fullPage: this.fullPage,
+      type: this.format,
+      quality: this.format === "jpeg" ? this.quality : undefined
+    });
+    const viewport = page.viewportSize() ?? { width: 0, height: 0 };
+    return {
+      filePath,
+      width: viewport.width,
+      height: viewport.height,
+      timestamp: new Date().toISOString()
+    };
+  }
+  async captureFullPage(page, options) {
+    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug);
+    const filename = generateFilename(options.stepNumber, options.action);
+    const filePath = join3(dir, filename);
+    ensureDir(dir);
+    await page.screenshot({
+      path: filePath,
+      fullPage: true,
+      type: this.format,
+      quality: this.format === "jpeg" ? this.quality : undefined
+    });
+    const viewport = page.viewportSize() ?? { width: 0, height: 0 };
+    return {
+      filePath,
+      width: viewport.width,
+      height: viewport.height,
+      timestamp: new Date().toISOString()
+    };
+  }
+  async captureElement(page, selector, options) {
+    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug);
+    const filename = generateFilename(options.stepNumber, options.action);
+    const filePath = join3(dir, filename);
+    ensureDir(dir);
+    await page.locator(selector).screenshot({
+      path: filePath,
+      type: this.format,
+      quality: this.format === "jpeg" ? this.quality : undefined
+    });
+    const viewport = page.viewportSize() ?? { width: 0, height: 0 };
+    return {
+      filePath,
+      width: viewport.width,
+      height: viewport.height,
+      timestamp: new Date().toISOString()
+    };
+  }
+}
+// src/lib/ai-client.ts
+import Anthropic from "@anthropic-ai/sdk";
+function resolveModel2(nameOrPreset) {
+  if (nameOrPreset in MODEL_MAP) {
+    return MODEL_MAP[nameOrPreset];
+  }
+  return nameOrPreset;
+}
+var BROWSER_TOOLS = [
+  {
+    name: "navigate",
+    description: "Navigate the browser to a specific URL.",
+    input_schema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "The URL to navigate to." }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "click",
+    description: "Click on an element matching the given CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the element to click."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "fill",
+    description: "Fill an input field with the given value.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the input field."
+        },
+        value: {
+          type: "string",
+          description: "The value to fill into the input."
+        }
+      },
+      required: ["selector", "value"]
+    }
+  },
+  {
+    name: "select_option",
+    description: "Select an option from a dropdown/select element.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the select element."
+        },
+        value: {
+          type: "string",
+          description: "The value of the option to select."
+        }
+      },
+      required: ["selector", "value"]
+    }
+  },
+  {
+    name: "screenshot",
+    description: "Take a screenshot of the current page state.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "get_text",
+    description: "Get the text content of an element matching the selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the element."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "get_url",
+    description: "Get the current page URL.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "wait_for",
+    description: "Wait for an element matching the selector to appear on the page.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector to wait for."
+        },
+        timeout: {
+          type: "number",
+          description: "Maximum time to wait in milliseconds (default: 10000)."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "go_back",
+    description: "Navigate back to the previous page.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "press_key",
+    description: "Press a keyboard key (e.g., Enter, Tab, Escape, ArrowDown).",
+    input_schema: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          description: "The key to press (e.g., 'Enter', 'Tab', 'Escape')."
+        }
+      },
+      required: ["key"]
+    }
+  },
+  {
+    name: "assert_visible",
+    description: "Assert that an element matching the selector is visible on the page. Returns 'true' or 'false'.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the element to check."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "assert_text",
+    description: "Assert that the given text is visible somewhere on the page. Returns 'true' or 'false'.",
+    input_schema: {
+      type: "object",
+      properties: {
+        text: {
+          type: "string",
+          description: "The text to search for on the page."
+        }
+      },
+      required: ["text"]
+    }
+  },
+  {
+    name: "report_result",
+    description: "Report the final test result. Call this when you have completed testing the scenario. This MUST be the last tool you call.",
+    input_schema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["passed", "failed"],
+          description: "Whether the test scenario passed or failed."
+        },
+        reasoning: {
+          type: "string",
+          description: "Detailed explanation of why the test passed or failed, including any issues found."
+        }
+      },
+      required: ["status", "reasoning"]
+    }
+  }
+];
+async function executeTool(page, screenshotter, toolName, toolInput, context) {
+  try {
+    switch (toolName) {
+      case "navigate": {
+        const url = toolInput.url;
+        await page.goto(url, { waitUntil: "domcontentloaded" });
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "navigate"
+        });
+        return {
+          result: `Navigated to ${url}`,
+          screenshot
+        };
+      }
+      case "click": {
+        const selector = toolInput.selector;
+        await page.click(selector);
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "click"
+        });
+        return {
+          result: `Clicked element: ${selector}`,
+          screenshot
+        };
+      }
+      case "fill": {
+        const selector = toolInput.selector;
+        const value = toolInput.value;
+        await page.fill(selector, value);
+        return {
+          result: `Filled "${selector}" with value`
+        };
+      }
+      case "select_option": {
+        const selector = toolInput.selector;
+        const value = toolInput.value;
+        await page.selectOption(selector, value);
+        return {
+          result: `Selected option "${value}" in ${selector}`
+        };
+      }
+      case "screenshot": {
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "screenshot"
+        });
+        return {
+          result: "Screenshot captured",
+          screenshot
+        };
+      }
+      case "get_text": {
+        const selector = toolInput.selector;
+        const text = await page.locator(selector).textContent();
+        return {
+          result: text ?? "(no text content)"
+        };
+      }
+      case "get_url": {
+        return {
+          result: page.url()
+        };
+      }
+      case "wait_for": {
+        const selector = toolInput.selector;
+        const timeout = typeof toolInput.timeout === "number" ? toolInput.timeout : 1e4;
+        await page.waitForSelector(selector, { timeout });
+        return {
+          result: `Element "${selector}" appeared`
+        };
+      }
+      case "go_back": {
+        await page.goBack();
+        return {
+          result: "Navigated back"
+        };
+      }
+      case "press_key": {
+        const key = toolInput.key;
+        await page.keyboard.press(key);
+        return {
+          result: `Pressed key: ${key}`
+        };
+      }
+      case "assert_visible": {
+        const selector = toolInput.selector;
+        try {
+          const visible = await page.locator(selector).isVisible();
+          return { result: visible ? "true" : "false" };
+        } catch {
+          return { result: "false" };
+        }
+      }
+      case "assert_text": {
+        const text = toolInput.text;
+        try {
+          const bodyText = await page.locator("body").textContent();
+          const found = bodyText ? bodyText.includes(text) : false;
+          return { result: found ? "true" : "false" };
+        } catch {
+          return { result: "false" };
+        }
+      }
+      case "report_result": {
+        const status = toolInput.status;
+        const reasoning = toolInput.reasoning;
+        return {
+          result: `Test ${status}: ${reasoning}`
+        };
+      }
+      default:
+        return { result: `Unknown tool: ${toolName}` };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { result: `Error executing ${toolName}: ${message}` };
+  }
+}
+async function runAgentLoop(options) {
+  const {
+    client,
+    page,
+    scenario,
+    screenshotter,
+    model,
+    runId,
+    maxTurns = 30
+  } = options;
+  const systemPrompt = [
+    "You are a QA testing agent. Test the following scenario by interacting with the browser.",
+    "Use the provided tools to navigate, click, fill forms, and verify results.",
+    "When done, call report_result with your findings.",
+    "Be methodical: navigate to the target page first, then follow the test steps.",
+    "If a step fails, try reasonable alternatives before reporting failure.",
+    "Always report a final result \u2014 never leave a test incomplete."
+  ].join(" ");
+  const userParts = [
+    `**Scenario:** ${scenario.name}`,
+    `**Description:** ${scenario.description}`
+  ];
+  if (scenario.targetPath) {
+    userParts.push(`**Target Path:** ${scenario.targetPath}`);
+  }
+  if (scenario.steps.length > 0) {
+    userParts.push("**Steps:**");
+    for (let i = 0;i < scenario.steps.length; i++) {
+      userParts.push(`${i + 1}. ${scenario.steps[i]}`);
+    }
+  }
+  const userMessage = userParts.join(`
+`);
+  const screenshots = [];
+  let tokensUsed = 0;
+  let stepNumber = 0;
+  const scenarioSlug = scenario.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  let messages = [
+    { role: "user", content: userMessage }
+  ];
+  try {
+    for (let turn = 0;turn < maxTurns; turn++) {
+      const response = await client.messages.create({
+        model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        tools: BROWSER_TOOLS,
+        messages
+      });
+      if (response.usage) {
+        tokensUsed += response.usage.input_tokens + response.usage.output_tokens;
+      }
+      const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
+      if (toolUseBlocks.length === 0 && response.stop_reason === "end_turn") {
+        const textBlocks = response.content.filter((block) => block.type === "text");
+        const textReasoning = textBlocks.map((b) => b.text).join(`
+`);
+        return {
+          status: "error",
+          reasoning: textReasoning || "Agent ended without calling report_result",
+          stepsCompleted: stepNumber,
+          tokensUsed,
+          screenshots
+        };
+      }
+      const toolResults = [];
+      for (const toolBlock of toolUseBlocks) {
+        stepNumber++;
+        const toolInput = toolBlock.input;
+        const execResult = await executeTool(page, screenshotter, toolBlock.name, toolInput, { runId, scenarioSlug, stepNumber });
+        if (execResult.screenshot) {
+          screenshots.push({
+            ...execResult.screenshot,
+            action: toolBlock.name,
+            stepNumber
+          });
+        }
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolBlock.id,
+          content: execResult.result
+        });
+        if (toolBlock.name === "report_result") {
+          const status = toolInput.status;
+          const reasoning = toolInput.reasoning;
+          return {
+            status,
+            reasoning,
+            stepsCompleted: stepNumber,
+            tokensUsed,
+            screenshots
+          };
+        }
+      }
+      messages = [
+        ...messages,
+        { role: "assistant", content: response.content },
+        { role: "user", content: toolResults }
+      ];
+    }
+    return {
+      status: "error",
+      reasoning: `Agent reached maximum turn limit (${maxTurns}) without reporting a result`,
+      stepsCompleted: stepNumber,
+      tokensUsed,
+      screenshots
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new AIClientError(`Agent loop failed: ${message}`);
+  }
+}
+function createClient(apiKey) {
+  const key = apiKey ?? process.env["ANTHROPIC_API_KEY"];
+  if (!key) {
+    throw new AIClientError("No Anthropic API key provided. Set ANTHROPIC_API_KEY or pass it explicitly.");
+  }
+  return new Anthropic({ apiKey: key });
+}
+// src/lib/runner.ts
+var eventHandler = null;
+function onRunEvent(handler) {
+  eventHandler = handler;
+}
+function emit(event) {
+  if (eventHandler)
+    eventHandler(event);
+}
+async function runSingleScenario(scenario, runId, options) {
+  const config = loadConfig();
+  const model = resolveModel2(options.model ?? scenario.model ?? config.defaultModel);
+  const client = createClient(options.apiKey ?? config.anthropicApiKey);
+  const screenshotter = new Screenshotter({
+    baseDir: options.screenshotDir ?? config.screenshots.dir
+  });
+  const result = createResult({
+    runId,
+    scenarioId: scenario.id,
+    model,
+    stepsTotal: scenario.steps.length || 10
+  });
+  emit({ type: "scenario:start", scenarioId: scenario.id, scenarioName: scenario.name, resultId: result.id, runId });
+  let browser = null;
+  let page = null;
+  try {
+    browser = await launchBrowser({ headless: !(options.headed ?? false) });
+    page = await getPage(browser, {
+      viewport: config.browser.viewport
+    });
+    const targetUrl = scenario.targetPath ? `${options.url.replace(/\/$/, "")}${scenario.targetPath}` : options.url;
+    await page.goto(targetUrl, { timeout: options.timeout ?? config.browser.timeout });
+    const agentResult = await runAgentLoop({
+      client,
+      page,
+      scenario,
+      screenshotter,
+      model,
+      runId,
+      maxTurns: 30
+    });
+    for (const ss of agentResult.screenshots) {
+      createScreenshot({
+        resultId: result.id,
+        stepNumber: ss.stepNumber,
+        action: ss.action,
+        filePath: ss.filePath,
+        width: ss.width,
+        height: ss.height
+      });
+      emit({ type: "screenshot:captured", screenshotPath: ss.filePath, scenarioId: scenario.id, runId });
+    }
+    const updatedResult = updateResult(result.id, {
+      status: agentResult.status,
+      reasoning: agentResult.reasoning,
+      stepsCompleted: agentResult.stepsCompleted,
+      durationMs: Date.now() - new Date(result.createdAt).getTime(),
+      tokensUsed: agentResult.tokensUsed,
+      costCents: estimateCost(model, agentResult.tokensUsed)
+    });
+    const eventType = agentResult.status === "passed" ? "scenario:pass" : "scenario:fail";
+    emit({ type: eventType, scenarioId: scenario.id, scenarioName: scenario.name, resultId: result.id, runId });
+    return updatedResult;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    const updatedResult = updateResult(result.id, {
+      status: "error",
+      error: errorMsg,
+      durationMs: Date.now() - new Date(result.createdAt).getTime()
+    });
+    emit({ type: "scenario:error", scenarioId: scenario.id, scenarioName: scenario.name, error: errorMsg, runId });
+    return updatedResult;
+  } finally {
+    if (browser)
+      await closeBrowser(browser);
+  }
+}
+async function runBatch(scenarios, options) {
+  const config = loadConfig();
+  const model = resolveModel2(options.model ?? config.defaultModel);
+  const parallel = options.parallel ?? 1;
+  const run = createRun({
+    url: options.url,
+    model,
+    headed: options.headed,
+    parallel,
+    projectId: options.projectId
+  });
+  updateRun(run.id, { status: "running", total: scenarios.length });
+  const results = [];
+  if (parallel <= 1) {
+    for (const scenario of scenarios) {
+      const result = await runSingleScenario(scenario, run.id, options);
+      results.push(result);
+    }
+  } else {
+    const queue = [...scenarios];
+    const running = [];
+    const processNext = async () => {
+      const scenario = queue.shift();
+      if (!scenario)
+        return;
+      const result = await runSingleScenario(scenario, run.id, options);
+      results.push(result);
+      await processNext();
+    };
+    const workers = Math.min(parallel, scenarios.length);
+    for (let i = 0;i < workers; i++) {
+      running.push(processNext());
+    }
+    await Promise.all(running);
+  }
+  const passed = results.filter((r) => r.status === "passed").length;
+  const failed = results.filter((r) => r.status === "failed" || r.status === "error").length;
+  const finalStatus = failed > 0 ? "failed" : "passed";
+  const finalRun = updateRun(run.id, {
+    status: finalStatus,
+    passed,
+    failed,
+    total: scenarios.length,
+    finished_at: new Date().toISOString()
+  });
+  emit({ type: "run:complete", runId: run.id });
+  return { run: finalRun, results };
+}
+async function runByFilter(options) {
+  let scenarios;
+  if (options.scenarioIds && options.scenarioIds.length > 0) {
+    const all = listScenarios({ projectId: options.projectId });
+    scenarios = all.filter((s) => options.scenarioIds.includes(s.id) || options.scenarioIds.includes(s.shortId));
+  } else {
+    scenarios = listScenarios({
+      projectId: options.projectId,
+      tags: options.tags,
+      priority: options.priority
+    });
+  }
+  if (scenarios.length === 0) {
+    const config = loadConfig();
+    const model = resolveModel2(options.model ?? config.defaultModel);
+    const run = createRun({ url: options.url, model, projectId: options.projectId });
+    updateRun(run.id, { status: "passed", total: 0, finished_at: new Date().toISOString() });
+    return { run: getRun(run.id), results: [] };
+  }
+  return runBatch(scenarios, options);
+}
+function estimateCost(model, tokens) {
+  const costs = {
+    "claude-haiku-4-5-20251001": 0.1,
+    "claude-sonnet-4-6-20260311": 0.9,
+    "claude-opus-4-6-20260311": 3
+  };
+  const costPer1M = costs[model] ?? 0.5;
+  return tokens / 1e6 * costPer1M * 100;
+}
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    blackBright: [90, 39],
+    gray: [90, 39],
+    grey: [90, 39],
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    bgGrey: [100, 49],
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = new Map;
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "process";
+import os from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== undefined) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
+` : `
+`) + postfix;
+    endIndex = index + 1;
+    index = string.indexOf(`
+`, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk = (...strings) => strings.join(" ");
+  applyOptions(chalk, options);
+  Object.setPrototypeOf(chalk, createChalk.prototype);
+  return chalk;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === undefined) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== undefined) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf(`
+`);
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/lib/reporter.ts
+function formatTerminal(run, results) {
+  const lines = [];
+  lines.push("");
+  lines.push(source_default.bold(`  Run ${run.id.slice(0, 8)} \u2014 ${run.url}`));
+  lines.push(source_default.dim(`  Model: ${run.model} | Parallel: ${run.parallel} | Headed: ${run.headed ? "yes" : "no"}`));
+  lines.push("");
+  for (const result of results) {
+    const scenario = getScenario(result.scenarioId);
+    const name = scenario ? `${scenario.shortId}: ${scenario.name}` : result.scenarioId.slice(0, 8);
+    const screenshots = listScreenshots(result.id);
+    const duration = `${(result.durationMs / 1000).toFixed(1)}s`;
+    const screenshotCount = screenshots.length;
+    let statusIcon;
+    let statusColor;
+    switch (result.status) {
+      case "passed":
+        statusIcon = source_default.green("PASS");
+        statusColor = source_default.green;
+        break;
+      case "failed":
+        statusIcon = source_default.red("FAIL");
+        statusColor = source_default.red;
+        break;
+      case "error":
+        statusIcon = source_default.yellow("ERR ");
+        statusColor = source_default.yellow;
+        break;
+      default:
+        statusIcon = source_default.dim("SKIP");
+        statusColor = source_default.dim;
+        break;
+    }
+    lines.push(`  ${statusIcon}  ${statusColor(name)}  ${source_default.dim(duration)}  ${source_default.dim(`${screenshotCount} screenshots`)}`);
+    if (result.reasoning && (result.status === "failed" || result.status === "error")) {
+      lines.push(source_default.dim(`         ${result.reasoning}`));
+    }
+    if (result.error) {
+      lines.push(source_default.red(`         ${result.error}`));
+    }
+  }
+  lines.push("");
+  lines.push(formatSummary(run));
+  lines.push("");
+  return lines.join(`
+`);
+}
+function formatSummary(run) {
+  const duration = run.finishedAt ? `${((new Date(run.finishedAt).getTime() - new Date(run.startedAt).getTime()) / 1000).toFixed(1)}s` : "running";
+  const passedStr = source_default.green(`${run.passed} passed`);
+  const failedStr = run.failed > 0 ? source_default.red(` ${run.failed} failed`) : "";
+  const totalStr = source_default.dim(` (${run.total} total)`);
+  return `  ${passedStr}${failedStr}${totalStr} in ${duration}`;
+}
+function formatJSON(run, results) {
+  const output = {
+    run: {
+      id: run.id,
+      url: run.url,
+      status: run.status,
+      model: run.model,
+      headed: run.headed,
+      parallel: run.parallel,
+      total: run.total,
+      passed: run.passed,
+      failed: run.failed,
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt
+    },
+    results: results.map((r) => {
+      const scenario = getScenario(r.scenarioId);
+      const screenshots = listScreenshots(r.id);
+      return {
+        id: r.id,
+        scenarioId: r.scenarioId,
+        scenarioName: scenario?.name ?? null,
+        scenarioShortId: scenario?.shortId ?? null,
+        status: r.status,
+        reasoning: r.reasoning,
+        error: r.error,
+        stepsCompleted: r.stepsCompleted,
+        stepsTotal: r.stepsTotal,
+        durationMs: r.durationMs,
+        model: r.model,
+        tokensUsed: r.tokensUsed,
+        costCents: r.costCents,
+        screenshots: screenshots.map((s) => ({
+          stepNumber: s.stepNumber,
+          action: s.action,
+          filePath: s.filePath
+        }))
+      };
+    }),
+    summary: {
+      total: run.total,
+      passed: run.passed,
+      failed: run.failed,
+      totalTokens: results.reduce((sum, r) => sum + r.tokensUsed, 0),
+      totalCostCents: results.reduce((sum, r) => sum + r.costCents, 0),
+      durationMs: run.finishedAt ? new Date(run.finishedAt).getTime() - new Date(run.startedAt).getTime() : null
+    }
+  };
+  return JSON.stringify(output, null, 2);
+}
+function getExitCode(run) {
+  if (run.status === "passed")
+    return 0;
+  if (run.status === "failed")
+    return 1;
+  return 2;
+}
+function formatRunList(runs) {
+  const lines = [];
+  lines.push("");
+  lines.push(source_default.bold("  Recent Runs"));
+  lines.push("");
+  if (runs.length === 0) {
+    lines.push(source_default.dim("  No runs found."));
+    lines.push("");
+    return lines.join(`
+`);
+  }
+  for (const run of runs) {
+    const statusIcon = run.status === "passed" ? source_default.green("PASS") : run.status === "failed" ? source_default.red("FAIL") : run.status === "running" ? source_default.blue("RUN ") : source_default.dim(run.status.toUpperCase().padEnd(4));
+    const date = new Date(run.startedAt).toLocaleString();
+    const id = run.id.slice(0, 8);
+    lines.push(`  ${statusIcon}  ${source_default.dim(id)}  ${run.url}  ${source_default.dim(`${run.passed}/${run.total}`)}  ${source_default.dim(date)}`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function formatScenarioList(scenarios) {
+  const lines = [];
+  lines.push("");
+  lines.push(source_default.bold("  Scenarios"));
+  lines.push("");
+  if (scenarios.length === 0) {
+    lines.push(source_default.dim("  No scenarios found. Use 'testers add' to create one."));
+    lines.push("");
+    return lines.join(`
+`);
+  }
+  for (const s of scenarios) {
+    const priorityColor = s.priority === "critical" ? source_default.red : s.priority === "high" ? source_default.yellow : s.priority === "medium" ? source_default.blue : source_default.dim;
+    const tags = s.tags.length > 0 ? source_default.dim(` [${s.tags.join(", ")}]`) : "";
+    lines.push(`  ${source_default.cyan(s.shortId)}  ${s.name}  ${priorityColor(s.priority)}${tags}`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function formatResultDetail(result, screenshots) {
+  const lines = [];
+  const scenario = getScenario(result.scenarioId);
+  lines.push("");
+  lines.push(source_default.bold(`  Result ${result.id.slice(0, 8)}`));
+  if (scenario) {
+    lines.push(`  Scenario: ${scenario.shortId} \u2014 ${scenario.name}`);
+  }
+  lines.push(`  Status: ${result.status === "passed" ? source_default.green("PASSED") : source_default.red(result.status.toUpperCase())}`);
+  lines.push(`  Model: ${result.model}`);
+  lines.push(`  Duration: ${(result.durationMs / 1000).toFixed(1)}s`);
+  lines.push(`  Steps: ${result.stepsCompleted}/${result.stepsTotal}`);
+  lines.push(`  Tokens: ${result.tokensUsed} (~$${(result.costCents / 100).toFixed(4)})`);
+  if (result.reasoning) {
+    lines.push("");
+    lines.push(source_default.bold("  Reasoning:"));
+    lines.push(`  ${result.reasoning}`);
+  }
+  if (result.error) {
+    lines.push("");
+    lines.push(source_default.red.bold("  Error:"));
+    lines.push(source_default.red(`  ${result.error}`));
+  }
+  if (screenshots.length > 0) {
+    lines.push("");
+    lines.push(source_default.bold(`  Screenshots (${screenshots.length}):`));
+    for (const ss of screenshots) {
+      lines.push(`  ${source_default.dim(`${String(ss.stepNumber).padStart(3, "0")}`)} ${ss.action} \u2014 ${source_default.dim(ss.filePath)}`);
+    }
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+// 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 };
+}
+function markTodoDone(taskId) {
+  const dbPath = resolveTodosDbPath();
+  if (!existsSync4(dbPath))
+    return false;
+  const db2 = new Database2(dbPath);
+  try {
+    const task = db2.query("SELECT id, version FROM tasks WHERE id LIKE ? || '%'").get(taskId);
+    if (!task)
+      return false;
+    db2.query("UPDATE tasks SET status = 'completed', completed_at = datetime('now'), version = version + 1, updated_at = datetime('now') WHERE id = ? AND version = ?").run(task.id, task.version);
+    return true;
+  } finally {
+    db2.close();
+  }
+}
+export {
+  uuid,
+  updateScenario,
+  updateRun,
+  updateResult,
+  taskToScenarioInput,
+  slugify,
+  shortUuid,
+  screenshotFromRow,
+  scenarioFromRow,
+  runSingleScenario,
+  runFromRow,
+  runByFilter,
+  runBatch,
+  runAgentLoop,
+  resultFromRow,
+  resolvePartialId,
+  resolveModel as resolveModelConfig,
+  resolveModel2 as resolveModel,
+  resetDatabase,
+  registerAgent,
+  pullTasks,
+  projectFromRow,
+  onRunEvent,
+  now,
+  markTodoDone,
+  loadConfig,
+  listScreenshots,
+  listScenarios,
+  listRuns,
+  listResults,
+  listProjects,
+  listAgents,
+  launchBrowser,
+  installBrowser,
+  importFromTodos,
+  getScreenshotsByResult,
+  getScreenshotDir,
+  getScreenshot,
+  getScenarioByShortId,
+  getScenario,
+  getRun,
+  getResultsByRun,
+  getResult,
+  getProjectByPath,
+  getProject,
+  getPage,
+  getExitCode,
+  getDefaultConfig,
+  getDatabase,
+  getAgentByName,
+  getAgent,
+  generateFilename,
+  formatTerminal,
+  formatSummary,
+  formatScenarioList,
+  formatRunList,
+  formatResultDetail,
+  formatJSON,
+  executeTool,
+  ensureProject,
+  ensureDir,
+  deleteScenario,
+  deleteRun,
+  createScreenshot,
+  createScenario,
+  createRun,
+  createResult,
+  createProject,
+  createClient,
+  connectToTodos,
+  closeDatabase,
+  closeBrowser,
+  agentFromRow,
+  VersionConflictError,
+  TodosConnectionError,
+  Screenshotter,
+  ScenarioNotFoundError,
+  RunNotFoundError,
+  ResultNotFoundError,
+  ProjectNotFoundError,
+  MODEL_MAP,
+  BrowserPool,
+  BrowserError,
+  BROWSER_TOOLS,
+  AgentNotFoundError,
+  AIClientError
+};