mcp-scraper 0.2.8 → 0.2.9

package/dist/bin/api-server.cjs

@@ -6913,6 +6913,7 @@ __export(db_exports, {
   claimPendingKpoJob: () => claimPendingKpoJob,
   completeJob: () => completeJob,
   completeKpoJob: () => completeKpoJob,
+  completeWorkflowRunRecord: () => completeWorkflowRunRecord,
   consumePasswordResetToken: () => consumePasswordResetToken,
   countActiveJobsForUser: () => countActiveJobsForUser,
   countActiveUsers: () => countActiveUsers,
@@ -6921,11 +6922,15 @@ __export(db_exports, {
   createPasswordResetToken: () => createPasswordResetToken,
   createRunningJob: () => createRunningJob,
   createUser: () => createUser,
+  createWorkflowRun: () => createWorkflowRun,
+  createWorkflowSchedule: () => createWorkflowSchedule,
   creditMc: () => creditMc,
   deactivateUser: () => deactivateUser,
   debitMc: () => debitMc,
+  deleteWorkflowSchedule: () => deleteWorkflowSchedule,
   failJob: () => failJob,
   failKpoJob: () => failKpoJob,
+  failWorkflowRunRecord: () => failWorkflowRunRecord,
   finishHarvestAttempt: () => finishHarvestAttempt,
   generateApiKey: () => generateApiKey,
   getDb: () => getDb,
@@ -6938,19 +6943,32 @@ __export(db_exports, {
   getUserById: () => getUserById,
   getUserByStripeCustomerId: () => getUserByStripeCustomerId,
   getUserStats: () => getUserStats,
+  getWorkflowArtifact: () => getWorkflowArtifact,
+  getWorkflowRun: () => getWorkflowRun,
+  getWorkflowRunByIdempotencyKey: () => getWorkflowRunByIdempotencyKey,
+  getWorkflowSchedule: () => getWorkflowSchedule,
   hashPassword: () => hashPassword,
   ledgerExistsForOperation: () => ledgerExistsForOperation,
   ledgerExistsForStripePI: () => ledgerExistsForStripePI,
+  listDueWorkflowSchedules: () => listDueWorkflowSchedules,
   listHarvestAttempts: () => listHarvestAttempts,
   listJobs: () => listJobs,
   listKpoJobs: () => listKpoJobs,
   listRequestEvents: () => listRequestEvents,
   listUsers: () => listUsers,
+  listWorkflowArtifacts: () => listWorkflowArtifacts,
+  listWorkflowRuns: () => listWorkflowRuns,
+  listWorkflowSchedules: () => listWorkflowSchedules,
   logKpoPhaseComplete: () => logKpoPhaseComplete,
   logRequestEvent: () => logRequestEvent,
+  markWorkflowRunRunning: () => markWorkflowRunRunning,
+  markWorkflowScheduleRan: () => markWorkflowScheduleRan,
   migrate: () => migrate,
+  patchWorkflowSchedule: () => patchWorkflowSchedule,
   reconcileBalanceMc: () => reconcileBalanceMc,
   recordStripeEvent: () => recordStripeEvent,
+  recordWorkflowWebhookDelivery: () => recordWorkflowWebhookDelivery,
+  replaceWorkflowArtifacts: () => replaceWorkflowArtifacts,
   revokeApiKey: () => revokeApiKey,
   rotateApiKey: () => rotateApiKey,
   setConcurrencySubId: () => setConcurrencySubId,
@@ -7162,6 +7180,75 @@ async function migrate() {
     )
   `);
   await db.execute(`CREATE INDEX IF NOT EXISTS request_events_user_created_at ON request_events(user_id, created_at DESC)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS workflow_schedules (
+      id             TEXT PRIMARY KEY,
+      user_id        INTEGER NOT NULL REFERENCES users(id),
+      workflow_id    TEXT NOT NULL,
+      name           TEXT NOT NULL,
+      input_json     TEXT NOT NULL,
+      cadence        TEXT NOT NULL,
+      cron_expr      TEXT,
+      timezone       TEXT NOT NULL DEFAULT 'UTC',
+      webhook_url    TEXT,
+      status         TEXT NOT NULL DEFAULT 'active',
+      next_run_at    TEXT,
+      last_run_at    TEXT,
+      created_at     TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at     TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_schedules_user_status ON workflow_schedules(user_id, status, created_at DESC)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_schedules_due ON workflow_schedules(status, next_run_at)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id              TEXT PRIMARY KEY,
+      user_id         INTEGER NOT NULL REFERENCES users(id),
+      schedule_id     TEXT,
+      workflow_id     TEXT NOT NULL,
+      input_json      TEXT NOT NULL,
+      status          TEXT NOT NULL DEFAULT 'queued',
+      manifest_json   TEXT,
+      error_message   TEXT,
+      queued_at       TEXT NOT NULL DEFAULT (datetime('now')),
+      started_at      TEXT,
+      completed_at    TEXT,
+      idempotency_key TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_runs_user_created ON workflow_runs(user_id, queued_at DESC)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_runs_schedule ON workflow_runs(schedule_id, queued_at DESC)`);
+  await db.execute(`CREATE UNIQUE INDEX IF NOT EXISTS workflow_runs_idempotency ON workflow_runs(idempotency_key) WHERE idempotency_key IS NOT NULL`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS workflow_artifacts (
+      id           TEXT PRIMARY KEY,
+      run_id       TEXT NOT NULL REFERENCES workflow_runs(id),
+      user_id      INTEGER NOT NULL REFERENCES users(id),
+      kind         TEXT NOT NULL,
+      label        TEXT NOT NULL,
+      path         TEXT NOT NULL,
+      content_type TEXT NOT NULL,
+      bytes        INTEGER,
+      rows_count   INTEGER,
+      created_at   TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_artifacts_run ON workflow_artifacts(run_id)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS workflow_webhook_deliveries (
+      id           TEXT PRIMARY KEY,
+      run_id       TEXT NOT NULL REFERENCES workflow_runs(id),
+      schedule_id  TEXT,
+      user_id      INTEGER NOT NULL REFERENCES users(id),
+      webhook_url  TEXT NOT NULL,
+      status       TEXT NOT NULL,
+      attempts     INTEGER NOT NULL DEFAULT 0,
+      last_error   TEXT,
+      created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+      delivered_at TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_webhook_deliveries_run ON workflow_webhook_deliveries(run_id)`);
   await db.execute(`
     CREATE TABLE IF NOT EXISTS stripe_events (
       event_id     TEXT PRIMARY KEY,
@@ -7551,6 +7638,290 @@ async function listRequestEvents(userId, limit = 100) {
   });
   return res.rows.map((r) => rowToRequestEvent(r));
 }
+function parseJsonRecordValue(value) {
+  if (value == null) return {};
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function rowToWorkflowSchedule(row) {
+  return {
+    id: String(row.id),
+    user_id: Number(row.user_id),
+    workflow_id: String(row.workflow_id),
+    name: String(row.name),
+    input: parseJsonRecordValue(row.input_json),
+    cadence: String(row.cadence),
+    cron_expr: row.cron_expr != null ? String(row.cron_expr) : null,
+    timezone: String(row.timezone ?? "UTC"),
+    webhook_url: row.webhook_url != null ? String(row.webhook_url) : null,
+    status: String(row.status),
+    next_run_at: row.next_run_at != null ? String(row.next_run_at) : null,
+    last_run_at: row.last_run_at != null ? String(row.last_run_at) : null,
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at)
+  };
+}
+function rowToWorkflowRun(row) {
+  return {
+    id: String(row.id),
+    user_id: Number(row.user_id),
+    schedule_id: row.schedule_id != null ? String(row.schedule_id) : null,
+    workflow_id: String(row.workflow_id),
+    input: parseJsonRecordValue(row.input_json),
+    status: String(row.status),
+    manifest: row.manifest_json != null ? parseNullableJson(row.manifest_json) : null,
+    error_message: row.error_message != null ? String(row.error_message) : null,
+    queued_at: String(row.queued_at),
+    started_at: row.started_at != null ? String(row.started_at) : null,
+    completed_at: row.completed_at != null ? String(row.completed_at) : null,
+    idempotency_key: row.idempotency_key != null ? String(row.idempotency_key) : null
+  };
+}
+function rowToWorkflowArtifact(row) {
+  return {
+    id: String(row.id),
+    run_id: String(row.run_id),
+    user_id: Number(row.user_id),
+    kind: String(row.kind),
+    label: String(row.label),
+    path: String(row.path),
+    content_type: String(row.content_type),
+    bytes: row.bytes != null ? Number(row.bytes) : null,
+    rows_count: row.rows_count != null ? Number(row.rows_count) : null,
+    created_at: String(row.created_at)
+  };
+}
+async function createWorkflowSchedule(input) {
+  const id = (0, import_node_crypto.randomUUID)();
+  await getDb().execute({
+    sql: `
+      INSERT INTO workflow_schedules (
+        id, user_id, workflow_id, name, input_json, cadence, timezone, webhook_url, next_run_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      id,
+      input.userId,
+      input.workflowId,
+      input.name,
+      JSON.stringify(input.workflowInput),
+      input.cadence,
+      input.timezone ?? "UTC",
+      input.webhookUrl ?? null,
+      input.nextRunAt ?? null
+    ]
+  });
+  const schedule = await getWorkflowSchedule(id, input.userId);
+  if (!schedule) throw new Error("Failed to create workflow schedule");
+  return schedule;
+}
+async function getWorkflowSchedule(id, userId) {
+  const res = userId == null ? await getDb().execute({ sql: "SELECT * FROM workflow_schedules WHERE id = ? AND status != ? LIMIT 1", args: [id, "deleted"] }) : await getDb().execute({ sql: "SELECT * FROM workflow_schedules WHERE id = ? AND user_id = ? AND status != ? LIMIT 1", args: [id, userId, "deleted"] });
+  return res.rows[0] ? rowToWorkflowSchedule(res.rows[0]) : null;
+}
+async function listWorkflowSchedules(userId) {
+  const res = await getDb().execute({
+    sql: `SELECT * FROM workflow_schedules WHERE user_id = ? AND status != 'deleted' ORDER BY created_at DESC LIMIT 100`,
+    args: [userId]
+  });
+  return res.rows.map((r) => rowToWorkflowSchedule(r));
+}
+async function patchWorkflowSchedule(input) {
+  const sets = [];
+  const args = [];
+  if (input.name !== void 0) {
+    sets.push("name = ?");
+    args.push(input.name);
+  }
+  if (input.status !== void 0) {
+    sets.push("status = ?");
+    args.push(input.status);
+  }
+  if (input.workflowInput !== void 0) {
+    sets.push("input_json = ?");
+    args.push(JSON.stringify(input.workflowInput));
+  }
+  if (input.cadence !== void 0) {
+    sets.push("cadence = ?");
+    args.push(input.cadence);
+  }
+  if (input.timezone !== void 0) {
+    sets.push("timezone = ?");
+    args.push(input.timezone);
+  }
+  if (input.webhookUrl !== void 0) {
+    sets.push("webhook_url = ?");
+    args.push(input.webhookUrl);
+  }
+  if (input.nextRunAt !== void 0) {
+    sets.push("next_run_at = ?");
+    args.push(input.nextRunAt);
+  }
+  if (sets.length === 0) return getWorkflowSchedule(input.id, input.userId);
+  sets.push(`updated_at = datetime('now')`);
+  await getDb().execute({
+    sql: `UPDATE workflow_schedules SET ${sets.join(", ")} WHERE id = ? AND user_id = ? AND status != 'deleted'`,
+    args: [...args, input.id, input.userId]
+  });
+  return getWorkflowSchedule(input.id, input.userId);
+}
+async function deleteWorkflowSchedule(id, userId) {
+  const res = await getDb().execute({
+    sql: `UPDATE workflow_schedules SET status = 'deleted', updated_at = datetime('now') WHERE id = ? AND user_id = ? AND status != 'deleted'`,
+    args: [id, userId]
+  });
+  return res.rowsAffected > 0;
+}
+async function listDueWorkflowSchedules(nowIso, limit = 10) {
+  const res = await getDb().execute({
+    sql: `
+      SELECT * FROM workflow_schedules
+      WHERE status = 'active' AND next_run_at IS NOT NULL AND next_run_at <= ?
+      ORDER BY next_run_at ASC
+      LIMIT ?
+    `,
+    args: [nowIso, limit]
+  });
+  return res.rows.map((r) => rowToWorkflowSchedule(r));
+}
+async function markWorkflowScheduleRan(id, lastRunAt, nextRunAt) {
+  await getDb().execute({
+    sql: `UPDATE workflow_schedules SET last_run_at = ?, next_run_at = ?, updated_at = datetime('now') WHERE id = ?`,
+    args: [lastRunAt, nextRunAt, id]
+  });
+}
+async function createWorkflowRun(input) {
+  const id = input.id ?? (0, import_node_crypto.randomUUID)();
+  const args = [
+    id,
+    input.userId,
+    input.scheduleId ?? null,
+    input.workflowId,
+    JSON.stringify(input.workflowInput),
+    input.idempotencyKey ?? null
+  ];
+  try {
+    await getDb().execute({
+      sql: `
+        INSERT INTO workflow_runs (id, user_id, schedule_id, workflow_id, input_json, idempotency_key)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `,
+      args
+    });
+  } catch (err) {
+    if (input.idempotencyKey) {
+      const existing = await getWorkflowRunByIdempotencyKey(input.idempotencyKey);
+      if (existing) return existing;
+    }
+    throw err;
+  }
+  const run = await getWorkflowRun(id, input.userId);
+  if (!run) throw new Error("Failed to create workflow run");
+  return run;
+}
+async function getWorkflowRun(id, userId) {
+  const res = userId == null ? await getDb().execute({ sql: "SELECT * FROM workflow_runs WHERE id = ? LIMIT 1", args: [id] }) : await getDb().execute({ sql: "SELECT * FROM workflow_runs WHERE id = ? AND user_id = ? LIMIT 1", args: [id, userId] });
+  return res.rows[0] ? rowToWorkflowRun(res.rows[0]) : null;
+}
+async function getWorkflowRunByIdempotencyKey(idempotencyKey) {
+  const res = await getDb().execute({ sql: "SELECT * FROM workflow_runs WHERE idempotency_key = ? LIMIT 1", args: [idempotencyKey] });
+  return res.rows[0] ? rowToWorkflowRun(res.rows[0]) : null;
+}
+async function listWorkflowRuns(userId, limit = 50) {
+  const res = await getDb().execute({
+    sql: "SELECT * FROM workflow_runs WHERE user_id = ? ORDER BY queued_at DESC LIMIT ?",
+    args: [userId, limit]
+  });
+  return res.rows.map((r) => rowToWorkflowRun(r));
+}
+async function markWorkflowRunRunning(id) {
+  await getDb().execute({
+    sql: `UPDATE workflow_runs SET status = 'running', started_at = COALESCE(started_at, datetime('now')) WHERE id = ?`,
+    args: [id]
+  });
+}
+async function completeWorkflowRunRecord(id, status, manifest) {
+  await getDb().execute({
+    sql: `UPDATE workflow_runs SET status = ?, manifest_json = ?, completed_at = datetime('now') WHERE id = ?`,
+    args: [status, JSON.stringify(manifest), id]
+  });
+}
+async function failWorkflowRunRecord(id, errorMessage4, manifest) {
+  await getDb().execute({
+    sql: `UPDATE workflow_runs SET status = 'failed', error_message = ?, manifest_json = ?, completed_at = datetime('now') WHERE id = ?`,
+    args: [errorMessage4, manifest == null ? null : JSON.stringify(manifest), id]
+  });
+}
+function workflowArtifactContentType(kind) {
+  if (kind === "html_report") return "text/html; charset=utf-8";
+  if (kind === "csv") return "text/csv; charset=utf-8";
+  if (kind === "json") return "application/json; charset=utf-8";
+  return "text/plain; charset=utf-8";
+}
+async function replaceWorkflowArtifacts(runId, userId, artifacts) {
+  const db = getDb();
+  await db.execute({ sql: "DELETE FROM workflow_artifacts WHERE run_id = ? AND user_id = ?", args: [runId, userId] });
+  for (const artifact of artifacts) {
+    await db.execute({
+      sql: `
+        INSERT INTO workflow_artifacts (id, run_id, user_id, kind, label, path, content_type, bytes, rows_count)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      args: [
+        (0, import_node_crypto.randomUUID)(),
+        runId,
+        userId,
+        artifact.kind,
+        artifact.label,
+        artifact.path,
+        workflowArtifactContentType(artifact.kind),
+        artifact.bytes ?? null,
+        artifact.rows ?? null
+      ]
+    });
+  }
+  return listWorkflowArtifacts(runId, userId);
+}
+async function listWorkflowArtifacts(runId, userId) {
+  const res = await getDb().execute({
+    sql: "SELECT * FROM workflow_artifacts WHERE run_id = ? AND user_id = ? ORDER BY created_at ASC",
+    args: [runId, userId]
+  });
+  return res.rows.map((r) => rowToWorkflowArtifact(r));
+}
+async function getWorkflowArtifact(id, userId) {
+  const res = await getDb().execute({
+    sql: "SELECT * FROM workflow_artifacts WHERE id = ? AND user_id = ? LIMIT 1",
+    args: [id, userId]
+  });
+  return res.rows[0] ? rowToWorkflowArtifact(res.rows[0]) : null;
+}
+async function recordWorkflowWebhookDelivery(input) {
+  await getDb().execute({
+    sql: `
+      INSERT INTO workflow_webhook_deliveries (
+        id, run_id, schedule_id, user_id, webhook_url, status, attempts, last_error, delivered_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      (0, import_node_crypto.randomUUID)(),
+      input.runId,
+      input.scheduleId ?? null,
+      input.userId,
+      input.webhookUrl,
+      input.status,
+      input.attempts,
+      input.lastError ?? null,
+      input.status === "delivered" ? (/* @__PURE__ */ new Date()).toISOString() : null
+    ]
+  });
+}
 async function countActiveUsers() {
   const res = await getDb().execute(`SELECT COUNT(*) as n FROM users WHERE active = 1`);
   return Number(res.rows[0]?.n ?? 0);
@@ -10395,8 +10766,8 @@ var init_FacebookAdExtractor = __esm({
                 const pos = st.getPropertyValue("mask-position") || st.getPropertyValue("-webkit-mask-position") || st.getPropertyValue("background-position") || "";
                 const m = pos.match(/(-?\d+)px\s+(-?\d+)px/);
                 if (!m) continue;
-                const platform = sm[parseInt(m[2])];
-                if (platform && !platforms2.includes(platform)) platforms2.push(platform);
+                const platform2 = sm[parseInt(m[2])];
+                if (platform2 && !platforms2.includes(platform2)) platforms2.push(platform2);
               }
               for (const el2 of Array.from(root2.querySelectorAll("span,div"))) {
                 const txt = t(el2);
@@ -14277,6 +14648,7 @@ function csvRowsFor(result) {
         result_position: null,
         business_name: null,
         review_stars: null,
+        review_count: null,
         category: null,
         address: null,
         phone: null,
@@ -14310,6 +14682,7 @@ function csvRowsFor(result) {
         result_position: business.position,
         business_name: business.name,
         review_stars: business.rating,
+        review_count: business.reviewCount,
         category: business.category,
         address: business.address,
         phone: business.phone,
@@ -14350,6 +14723,7 @@ async function saveDirectoryCsv(result) {
     "result_position",
     "business_name",
     "review_stars",
+    "review_count",
     "category",
     "address",
     "phone",
@@ -14498,10 +14872,1200 @@ var init_directory_routes = __esm({
   }
 });
 
+// src/lib/slugify.ts
+function slugify(s) {
+  return s.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+var init_slugify = __esm({
+  "src/lib/slugify.ts"() {
+    "use strict";
+  }
+});
+
+// src/workflows/artifact-writer.ts
+function workflowOutputBaseDir(outputDir) {
+  return outputDir?.trim() || process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || (0, import_node_path7.join)((0, import_node_os4.homedir)(), "Downloads", "mcp-scraper");
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function safeSlug(value) {
+  return slugify(value).replace(/^-+|-+$/g, "").slice(0, 80) || "run";
+}
+function indexPath(baseDir = workflowOutputBaseDir()) {
+  return (0, import_node_path7.join)(baseDir, "workflows", "index.json");
+}
+async function readIndex(baseDir) {
+  const path6 = indexPath(baseDir);
+  if (!(0, import_node_fs4.existsSync)(path6)) return { runs: [] };
+  try {
+    return JSON.parse(await (0, import_promises6.readFile)(path6, "utf8"));
+  } catch {
+    return { runs: [] };
+  }
+}
+async function updateWorkflowIndex(manifest, manifestPath, baseDir) {
+  if (manifest.status === "running") return;
+  const path6 = indexPath(baseDir);
+  const index = await readIndex(baseDir);
+  const report = manifest.artifacts.find((a) => a.kind === "html_report")?.path ?? null;
+  const entry = {
+    workflow: manifest.workflow,
+    runId: manifest.runId,
+    status: manifest.status,
+    startedAt: manifest.startedAt,
+    reportPath: report,
+    manifestPath,
+    summary: `${manifest.title} (${manifest.status})`
+  };
+  index.runs = [entry, ...index.runs.filter((r) => r.runId !== manifest.runId)].slice(0, 200);
+  await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(path6), { recursive: true });
+  await (0, import_promises6.writeFile)(path6, JSON.stringify(index, null, 2), "utf8");
+}
+var import_promises6, import_node_fs4, import_node_os4, import_node_path7, import_node_child_process2, ArtifactWriter;
+var init_artifact_writer = __esm({
+  "src/workflows/artifact-writer.ts"() {
+    "use strict";
+    import_promises6 = require("fs/promises");
+    import_node_fs4 = require("fs");
+    import_node_os4 = require("os");
+    import_node_path7 = require("path");
+    import_node_child_process2 = require("child_process");
+    init_csv();
+    init_slugify();
+    ArtifactWriter = class _ArtifactWriter {
+      constructor(workflowId, title, runId, baseDir, runDir, startedAt, input) {
+        this.workflowId = workflowId;
+        this.title = title;
+        this.runId = runId;
+        this.baseDir = baseDir;
+        this.runDir = runDir;
+        this.startedAt = startedAt;
+        this.input = input;
+      }
+      workflowId;
+      title;
+      runId;
+      baseDir;
+      runDir;
+      startedAt;
+      input;
+      artifacts = [];
+      static async create(workflowId, title, input, outputDir, forcedRunId) {
+        const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const runId = forcedRunId?.trim() || `${timestamp()}-${safeSlug(workflowId)}-${Math.random().toString(36).slice(2, 8)}`;
+        const nameSource = String(input.keyword ?? input.query ?? input.domain ?? input.state ?? workflowId);
+        const baseDir = workflowOutputBaseDir(outputDir);
+        const runDir = (0, import_node_path7.join)(baseDir, "workflows", workflowId, `${timestamp()}-${safeSlug(nameSource)}-${safeSlug(runId).slice(0, 20)}`);
+        await (0, import_promises6.mkdir)(runDir, { recursive: true });
+        return new _ArtifactWriter(workflowId, title, runId, baseDir, runDir, startedAt, input);
+      }
+      async remember(kind, label, path6, rows) {
+        const size = await (0, import_promises6.stat)(path6).then((s) => s.size).catch(() => void 0);
+        this.artifacts.push({ kind, label, path: path6, bytes: size, rows });
+        return path6;
+      }
+      async writeJson(label, relativePath, data) {
+        const path6 = (0, import_node_path7.join)(this.runDir, relativePath);
+        await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(path6), { recursive: true });
+        await (0, import_promises6.writeFile)(path6, JSON.stringify(data, null, 2), "utf8");
+        return this.remember("json", label, path6);
+      }
+      async writeText(label, relativePath, text, kind = "markdown") {
+        const path6 = (0, import_node_path7.join)(this.runDir, relativePath);
+        await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(path6), { recursive: true });
+        await (0, import_promises6.writeFile)(path6, text, "utf8");
+        return this.remember(kind, label, path6);
+      }
+      async writeCsv(label, relativePath, headers, rows) {
+        const path6 = (0, import_node_path7.join)(this.runDir, relativePath);
+        await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(path6), { recursive: true });
+        await (0, import_promises6.writeFile)(path6, rowsToCsv(headers, rows), "utf8");
+        return this.remember("csv", label, path6, rows.length);
+      }
+      async writeHtml(label, relativePath, html) {
+        return this.writeText(label, relativePath, html, "html_report");
+      }
+      async writeManifest(status, counts, warnings, errors) {
+        const manifest = {
+          workflow: this.workflowId,
+          title: this.title,
+          runId: this.runId,
+          status,
+          startedAt: this.startedAt,
+          completedAt: status === "running" ? null : (/* @__PURE__ */ new Date()).toISOString(),
+          input: this.input,
+          artifacts: this.artifacts,
+          warnings,
+          errors,
+          counts
+        };
+        const path6 = (0, import_node_path7.join)(this.runDir, "manifest.json");
+        await (0, import_promises6.writeFile)(path6, JSON.stringify(manifest, null, 2), "utf8");
+        await updateWorkflowIndex(manifest, path6, this.baseDir);
+        return path6;
+      }
+    };
+  }
+});
+
+// src/workflows/http-client.ts
+var WorkflowHttpClient;
+var init_http_client2 = __esm({
+  "src/workflows/http-client.ts"() {
+    "use strict";
+    WorkflowHttpClient = class {
+      constructor(apiUrl, apiKey, fetchImpl = fetch) {
+        this.apiUrl = apiUrl;
+        this.apiKey = apiKey;
+        this.fetchImpl = fetchImpl;
+      }
+      apiUrl;
+      apiKey;
+      fetchImpl;
+      async post(path6, body, timeoutMs = 18e4) {
+        const res = await this.fetchImpl(`${this.apiUrl.replace(/\/$/, "")}${path6}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": this.apiKey
+          },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          const message = typeof data.error === "string" ? data.error : `Workflow API ${path6} failed with ${res.status}`;
+          throw new Error(message);
+        }
+        return data;
+      }
+    };
+  }
+});
+
+// src/workflows/report-renderer.ts
+function escapeHtml(value) {
+  return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderTable(table) {
+  const rows = table.rows.map((row) => `<tr>${table.columns.map((col) => `<td>${escapeHtml(row[col])}</td>`).join("")}</tr>`).join("\n");
+  return [
+    `<section>`,
+    `<h2>${escapeHtml(table.title)}</h2>`,
+    `<div class="table-wrap"><table>`,
+    `<thead><tr>${table.columns.map((col) => `<th>${escapeHtml(col)}</th>`).join("")}</tr></thead>`,
+    `<tbody>${rows || `<tr><td colspan="${table.columns.length}">No rows</td></tr>`}</tbody>`,
+    `</table></div>`,
+    `</section>`
+  ].join("\n");
+}
+function renderWorkflowReport(input) {
+  const warnings = input.warnings?.length ? `<section class="warnings"><h2>Warnings</h2><ul>${input.warnings.map((w) => `<li>${escapeHtml(w)}</li>`).join("")}</ul></section>` : "";
+  const sections = (input.sections ?? []).map((section) => `<section><h2>${escapeHtml(section.title)}</h2><p>${escapeHtml(section.body)}</p></section>`).join("\n");
+  const tables = (input.tables ?? []).map(renderTable).join("\n");
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "<head>",
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    `<title>${escapeHtml(input.title)}</title>`,
+    "<style>",
+    ':root{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color:#172026;background:#f6f7f8}',
+    "body{margin:0;padding:32px}main{max-width:1180px;margin:0 auto;background:#fff;border:1px solid #d9dee3;border-radius:8px;padding:28px}",
+    "h1{font-size:30px;line-height:1.15;margin:0 0 8px}h2{font-size:18px;margin:28px 0 12px}p{line-height:1.55;color:#3d4952}.sub{color:#66737f;margin:0 0 20px}",
+    ".summary{background:#eef6f8;border-left:4px solid #12829a;padding:14px 16px;margin:20px 0}.warnings{background:#fff7e8;border-left:4px solid #c87b00;padding:12px 16px}",
+    ".table-wrap{overflow:auto;border:1px solid #dfe5ea;border-radius:8px}table{border-collapse:collapse;width:100%;font-size:13px}th,td{border-bottom:1px solid #edf0f2;padding:9px 10px;text-align:left;vertical-align:top}th{background:#f3f5f7;color:#31404c;position:sticky;top:0}tr:last-child td{border-bottom:0}",
+    "</style>",
+    "</head>",
+    "<body><main>",
+    `<h1>${escapeHtml(input.title)}</h1>`,
+    input.subtitle ? `<p class="sub">${escapeHtml(input.subtitle)}</p>` : "",
+    `<div class="summary">${escapeHtml(input.summary)}</div>`,
+    warnings,
+    sections,
+    tables,
+    "</main></body></html>"
+  ].join("\n");
+}
+var init_report_renderer = __esm({
+  "src/workflows/report-renderer.ts"() {
+    "use strict";
+  }
+});
+
+// src/workflows/workflows/agent-packet.ts
+function normalizeDomain(value) {
+  if (!value) return null;
+  try {
+    const url = new URL(value.includes("://") ? value : `https://${value}`);
+    return url.hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return value.replace(/^https?:\/\//, "").replace(/^www\./, "").split("/")[0]?.toLowerCase() || null;
+  }
+}
+function domainFromUrl(url) {
+  return normalizeDomain(url) ?? "";
+}
+function sourceRows(input, serp, paa) {
+  const target = normalizeDomain(input.domain);
+  const rows = [];
+  for (const result of serp?.organicResults ?? []) {
+    const domain = normalizeDomain(result.domain) ?? domainFromUrl(result.url);
+    rows.push({
+      surface: "organic",
+      position: result.position,
+      title: result.title,
+      url: result.url,
+      domain,
+      question: "",
+      answer_excerpt: result.snippet ?? "",
+      is_target: target ? domain === target : false,
+      is_competitor: target ? domain !== target : true
+    });
+  }
+  for (const row of paa?.flat ?? []) {
+    const url = row.source_cite ?? "";
+    const domain = normalizeDomain(row.source_site ?? "") ?? (url ? domainFromUrl(url) : "");
+    rows.push({
+      surface: "paa",
+      position: "",
+      title: row.source_title ?? row.source_site ?? "",
+      url,
+      domain,
+      question: row.question,
+      answer_excerpt: (row.answer ?? "").slice(0, 240),
+      is_target: target ? domain === target : false,
+      is_competitor: target ? Boolean(domain && domain !== target) : Boolean(domain)
+    });
+  }
+  for (const [i, cite] of (serp?.aiOverview?.citations ?? []).entries()) {
+    const url = cite.href ?? "";
+    const domain = url ? domainFromUrl(url) : "";
+    rows.push({
+      surface: "ai_overview",
+      position: i + 1,
+      title: cite.text ?? "",
+      url,
+      domain,
+      question: "",
+      answer_excerpt: "",
+      is_target: target ? domain === target : false,
+      is_competitor: target ? Boolean(domain && domain !== target) : Boolean(domain)
+    });
+  }
+  return rows;
+}
+function competitorRows(rows, targetDomain) {
+  const byDomain = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const domain = String(row.domain ?? "");
+    if (!domain || domain === targetDomain) continue;
+    const entry = byDomain.get(domain) ?? { organic: [], paa: 0, ai: 0, urls: /* @__PURE__ */ new Set() };
+    if (row.surface === "organic" && row.position) entry.organic.push(Number(row.position));
+    if (row.surface === "paa") entry.paa += 1;
+    if (row.surface === "ai_overview") entry.ai += 1;
+    if (row.url) entry.urls.add(String(row.url));
+    byDomain.set(domain, entry);
+  }
+  return [...byDomain.entries()].map(([domain, entry]) => ({
+    domain,
+    organic_best_position: entry.organic.length ? Math.min(...entry.organic) : "",
+    organic_count: entry.organic.length,
+    paa_mentions: entry.paa,
+    ai_overview_citations: entry.ai,
+    source_url_count: entry.urls.size
+  })).sort((a, b) => Number(a.organic_best_position || 999) - Number(b.organic_best_position || 999));
+}
+var import_zod19, AgentPacketInputSchema, agentPacketWorkflowDefinition;
+var init_agent_packet = __esm({
+  "src/workflows/workflows/agent-packet.ts"() {
+    "use strict";
+    import_zod19 = require("zod");
+    init_report_renderer();
+    AgentPacketInputSchema = import_zod19.z.object({
+      keyword: import_zod19.z.string().min(1),
+      domain: import_zod19.z.string().optional(),
+      location: import_zod19.z.string().optional(),
+      maxQuestions: import_zod19.z.number().int().min(1).max(200).default(40),
+      includeSerp: import_zod19.z.boolean().default(true),
+      includePaa: import_zod19.z.boolean().default(true),
+      includeAiOverview: import_zod19.z.boolean().default(true),
+      returnPartial: import_zod19.z.boolean().default(true)
+    });
+    agentPacketWorkflowDefinition = {
+      id: "agent-packet",
+      title: "Agent-Ready SEO Packet",
+      description: "Create an evidence folder for AI agents from live SERP/PAA/AI search surfaces.",
+      inputSchema: AgentPacketInputSchema,
+      async run(input, ctx) {
+        await ctx.artifacts.writeManifest("running", {}, [], []);
+        const warnings = [];
+        const errors = [];
+        let serp = null;
+        let paa = null;
+        if (input.includeSerp) {
+          try {
+            serp = await ctx.client.post("/harvest/sync", {
+              query: input.keyword,
+              location: input.location,
+              serpOnly: true,
+              maxQuestions: 1,
+              format: "json"
+            }, 18e4);
+          } catch (err) {
+            warnings.push(`SERP evidence unavailable: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        if (input.includePaa) {
+          try {
+            paa = await ctx.client.post("/harvest/sync", {
+              query: input.keyword,
+              location: input.location,
+              maxQuestions: input.maxQuestions,
+              format: "json"
+            }, 28e4);
+          } catch (err) {
+            warnings.push(`PAA evidence unavailable: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        if (!serp && !paa && !input.returnPartial) throw new Error("No SEO evidence was collected");
+        const rows = sourceRows(input, serp, paa);
+        const target = normalizeDomain(input.domain);
+        const competitors = competitorRows(rows, target);
+        const evidence = {
+          input,
+          serp: serp ?? { status: "skipped" },
+          paa: paa ?? { status: "skipped" },
+          target: {
+            domain: target,
+            organicPositions: rows.filter((r) => r.surface === "organic" && r.is_target).map((r) => Number(r.position)),
+            citedInAiOverview: rows.some((r) => r.surface === "ai_overview" && r.is_target),
+            citedInPaa: rows.some((r) => r.surface === "paa" && r.is_target)
+          },
+          competitors,
+          warnings
+        };
+        await ctx.artifacts.writeJson("Evidence JSON", "evidence.json", evidence);
+        await ctx.artifacts.writeCsv("Sources CSV", "sources.csv", ["surface", "position", "title", "url", "domain", "question", "answer_excerpt", "is_target", "is_competitor"], rows);
+        await ctx.artifacts.writeCsv("Competitors CSV", "competitors.csv", ["domain", "organic_best_position", "organic_count", "paa_mentions", "ai_overview_citations", "source_url_count"], competitors);
+        const brief = [
+          `# SEO Evidence Brief: ${input.keyword}`,
+          "",
+          `Location: ${input.location ?? "not specified"}`,
+          `Target domain: ${target ?? "not specified"}`,
+          "",
+          "## Evidence Summary",
+          `- Organic rows: ${rows.filter((r) => r.surface === "organic").length}`,
+          `- PAA rows: ${rows.filter((r) => r.surface === "paa").length}`,
+          `- AI Overview citations: ${rows.filter((r) => r.surface === "ai_overview").length}`,
+          `- Competitor domains: ${competitors.length}`,
+          "",
+          "## Recommended Use",
+          "Use the CSV files as source of truth. Tie content recommendations to evidence rows and mark unsupported ideas as assumptions."
+        ].join("\n");
+        await ctx.artifacts.writeText("Brief", "brief.md", brief);
+        await ctx.artifacts.writeText("Agent tasks", "tasks.md", [
+          "# Agent Tasks",
+          "",
+          "- [ ] Read `evidence.json` before writing recommendations.",
+          "- [ ] Compare the target domain against `competitors.csv`.",
+          "- [ ] Use `sources.csv` for citations and source-grounded page sections.",
+          "- [ ] Mark unsupported recommendations as assumptions."
+        ].join("\n"));
+        await ctx.artifacts.writeText("Agent instructions", "agent-instructions.md", [
+          "# Agent Instructions",
+          "",
+          "You are working from an MCP Scraper SEO evidence packet. Use `evidence.json` and CSV files as source of truth. Do not invent citations. If a recommendation is not supported by evidence, mark it as an assumption."
+        ].join("\n"));
+        const summary = `${rows.length} evidence rows and ${competitors.length} competitor domains collected.`;
+        const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+          title: "Agent-Ready SEO Packet",
+          subtitle: `${input.keyword}${input.location ? ` \xB7 ${input.location}` : ""}`,
+          summary,
+          warnings,
+          tables: [
+            { title: "Competitor Domains", columns: ["domain", "organic_best_position", "organic_count", "paa_mentions", "ai_overview_citations", "source_url_count"], rows: competitors.slice(0, 50) },
+            { title: "Evidence Sources", columns: ["surface", "position", "title", "domain", "question", "is_target"], rows: rows.slice(0, 100) }
+          ]
+        }));
+        const status = warnings.length ? "partial" : "succeeded";
+        const counts = { sources: rows.length, competitors: competitors.length };
+        await ctx.artifacts.writeManifest(status, counts, warnings, errors);
+        return { title: "Agent-Ready SEO Packet", summary, status, counts, warnings, errors, reportPath };
+      }
+    };
+  }
+});
+
+// src/workflows/workflows/directory.ts
+function directoryRows(result) {
+  const rows = [];
+  for (const city of result.cities) {
+    if (!city.results.length) {
+      rows.push({
+        source_query: result.query,
+        source_location: city.location,
+        city: city.city,
+        state: city.state,
+        population: city.population,
+        result_position: null,
+        business_name: null,
+        review_stars: null,
+        review_count: null,
+        category: null,
+        address: null,
+        phone: null,
+        website_url: null,
+        place_url: null,
+        cid: null,
+        cid_decimal: null,
+        result_status: city.status,
+        error: city.error
+      });
+      continue;
+    }
+    for (const business of city.results) {
+      rows.push({
+        source_query: result.query,
+        source_location: city.location,
+        city: city.city,
+        state: city.state,
+        population: city.population,
+        result_position: business.position,
+        business_name: business.name,
+        review_stars: business.rating,
+        review_count: business.reviewCount,
+        category: business.category,
+        address: business.address,
+        phone: business.phone,
+        website_url: business.websiteUrl,
+        place_url: business.placeUrl,
+        cid: business.cid,
+        cid_decimal: business.cidDecimal,
+        result_status: city.status,
+        error: city.error
+      });
+    }
+  }
+  return rows;
+}
+var import_zod20, DirectoryWorkflowCliInputSchema, DIRECTORY_CSV_HEADERS, directoryWorkflowDefinition;
+var init_directory = __esm({
+  "src/workflows/workflows/directory.ts"() {
+    "use strict";
+    import_zod20 = require("zod");
+    init_report_renderer();
+    DirectoryWorkflowCliInputSchema = import_zod20.z.object({
+      query: import_zod20.z.string().min(1),
+      state: import_zod20.z.string().min(2).default("TN"),
+      minPopulation: import_zod20.z.number().int().min(0).default(1e5),
+      maxCities: import_zod20.z.number().int().min(1).max(100).default(25),
+      maxResultsPerCity: import_zod20.z.number().int().min(1).max(50).default(20),
+      concurrency: import_zod20.z.number().int().min(1).max(5).default(5),
+      proxyMode: import_zod20.z.enum(["location", "configured", "none"]).default("location"),
+      saveCsv: import_zod20.z.boolean().default(true)
+    });
+    DIRECTORY_CSV_HEADERS = [
+      "source_query",
+      "source_location",
+      "city",
+      "state",
+      "population",
+      "result_position",
+      "business_name",
+      "review_stars",
+      "review_count",
+      "category",
+      "address",
+      "phone",
+      "website_url",
+      "place_url",
+      "cid",
+      "cid_decimal",
+      "result_status",
+      "error"
+    ];
+    directoryWorkflowDefinition = {
+      id: "directory",
+      title: "Directory Workflow",
+      description: "Select city markets and export Google Maps business candidates.",
+      inputSchema: DirectoryWorkflowCliInputSchema,
+      async run(input, ctx) {
+        await ctx.artifacts.writeManifest("running", {}, [], []);
+        const result = await ctx.client.post("/directory/run", input, 9e5);
+        await ctx.artifacts.writeJson("Directory evidence", "evidence.json", result);
+        const rows = directoryRows(result);
+        await ctx.artifacts.writeCsv("Directory CSV", "exports/directory.csv", DIRECTORY_CSV_HEADERS, rows);
+        const cityRows = result.cities.map((city) => ({
+          city: city.city,
+          state: city.state,
+          population: city.population,
+          status: city.status,
+          result_count: city.resultCount,
+          error: city.error ?? ""
+        }));
+        const topRows = rows.filter((row) => row.business_name).slice(0, 100).map((row) => ({
+          city: row.city,
+          position: row.result_position,
+          business: row.business_name,
+          rating: row.review_stars,
+          reviews: row.review_count,
+          category: row.category,
+          website: row.website_url
+        }));
+        const summary = `${result.selectedCityCount} cities processed with ${result.totalResultCount} Maps results.`;
+        await ctx.artifacts.writeText("Summary", "summary.md", `# Directory Workflow
+
+${summary}
+`);
+        const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+          title: "Directory Workflow",
+          subtitle: `${input.query} \xB7 ${input.state}`,
+          summary,
+          warnings: result.warnings,
+          tables: [
+            { title: "Cities", columns: ["city", "state", "population", "status", "result_count", "error"], rows: cityRows },
+            { title: "Top Results", columns: ["city", "position", "business", "rating", "reviews", "category", "website"], rows: topRows }
+          ]
+        }));
+        const status = result.cities.some((city) => city.status === "failed") ? "partial" : "succeeded";
+        const counts = { cities: result.selectedCityCount, results: result.totalResultCount, rows: rows.length };
+        await ctx.artifacts.writeManifest(status, counts, result.warnings, []);
+        return { title: "Directory Workflow", summary, status, counts, warnings: result.warnings, errors: [], reportPath };
+      }
+    };
+  }
+});
+
+// src/workflows/workflows/local-competitive-audit.ts
+async function mapLimit2(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      out[index] = await fn(items[index], index);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return out;
+}
+function numberFrom(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const parsed = Number(String(value).replace(/[^\d.]/g, ""));
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function median(values) {
+  const nums = values.filter((v) => v !== null).sort((a, b) => a - b);
+  if (!nums.length) return null;
+  return nums[Math.floor(nums.length / 2)] ?? null;
+}
+function termsFrom(texts) {
+  const stop = /* @__PURE__ */ new Set(["the", "and", "for", "with", "that", "this", "was", "were", "are", "you", "our", "they", "had", "have", "not", "but", "from", "very", "great", "good"]);
+  const counts = /* @__PURE__ */ new Map();
+  for (const text of texts) {
+    for (const token of text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/)) {
+      if (token.length < 4 || stop.has(token)) continue;
+      counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8).map(([term, count]) => `${term} (${count})`).join("; ");
+}
+var import_zod21, LocalCompetitiveAuditInputSchema, localCompetitiveAuditWorkflowDefinition;
+var init_local_competitive_audit = __esm({
+  "src/workflows/workflows/local-competitive-audit.ts"() {
+    "use strict";
+    import_zod21 = require("zod");
+    init_report_renderer();
+    init_directory();
+    LocalCompetitiveAuditInputSchema = import_zod21.z.object({
+      query: import_zod21.z.string().min(1),
+      state: import_zod21.z.string().min(2).default("TN"),
+      minPopulation: import_zod21.z.number().int().min(0).default(1e5),
+      maxCities: import_zod21.z.number().int().min(1).max(100).default(25),
+      maxResultsPerCity: import_zod21.z.number().int().min(1).max(50).default(20),
+      hydrateTop: import_zod21.z.number().int().min(0).max(10).default(5),
+      maxReviews: import_zod21.z.number().int().min(0).max(500).default(50),
+      concurrency: import_zod21.z.number().int().min(1).max(5).default(5),
+      proxyMode: import_zod21.z.enum(["location", "configured", "none"]).default("location"),
+      returnPartial: import_zod21.z.boolean().default(true)
+    });
+    localCompetitiveAuditWorkflowDefinition = {
+      id: "local-competitive-audit",
+      title: "Local Competitive Audit",
+      description: "Audit local Maps competitors, categories, review counts, and review themes across city markets.",
+      inputSchema: LocalCompetitiveAuditInputSchema,
+      async run(input, ctx) {
+        await ctx.artifacts.writeManifest("running", {}, [], []);
+        const warnings = [];
+        const errors = [];
+        const directory = await ctx.client.post("/directory/run", {
+          query: input.query,
+          state: input.state,
+          minPopulation: input.minPopulation,
+          maxCities: input.maxCities,
+          maxResultsPerCity: input.maxResultsPerCity,
+          concurrency: input.concurrency,
+          proxyMode: input.proxyMode,
+          saveCsv: true
+        }, 9e5);
+        await ctx.artifacts.writeJson("Directory raw JSON", "raw/directory-workflow.json", directory);
+        const baseRows = directoryRows(directory);
+        await ctx.artifacts.writeCsv("Base directory CSV", "exports/directory.csv", DIRECTORY_CSV_HEADERS, baseRows);
+        const selected = directory.cities.flatMap(
+          (city) => city.results.slice(0, input.hydrateTop).map((result) => ({ city, result }))
+        );
+        const seen = /* @__PURE__ */ new Set();
+        const deduped = selected.filter(({ city, result }) => {
+          const key = result.cid ?? result.placeUrl ?? `${city.location}:${result.name.toLowerCase()}`;
+          if (seen.has(key)) return false;
+          seen.add(key);
+          return true;
+        });
+        const hydrated = await mapLimit2(deduped, 3, async ({ city, result }, index) => {
+          try {
+            const detail = await ctx.client.post("/maps/place", {
+              businessName: result.name,
+              location: city.location,
+              includeReviews: input.maxReviews > 0,
+              maxReviews: Math.max(1, input.maxReviews)
+            }, 18e4);
+            await ctx.artifacts.writeJson(`${result.name} profile`, `raw/maps-place-intel/${index + 1}-${result.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}.json`, detail);
+            return { city, result, detail, error: null };
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            warnings.push(`Profile hydration failed for ${result.name} (${city.location}): ${message}`);
+            return { city, result, detail: null, error: message };
+          }
+        });
+        const competitorRows2 = hydrated.map(({ city, result, detail, error }) => {
+          const reviews = detail?.reviews ?? [];
+          const ownerResponses = reviews.filter((r) => r.ownerResponse).length;
+          return {
+            city: city.city,
+            state: city.state,
+            source_location: city.location,
+            result_position: result.position,
+            business_name: result.name,
+            category: detail?.category ?? result.category,
+            review_stars: detail?.rating ?? result.rating,
+            review_count: detail?.reviewCount ?? result.reviewCount,
+            phone: result.phone,
+            website_url: detail?.website ?? result.websiteUrl,
+            place_url: result.placeUrl,
+            cid: result.cid,
+            cid_decimal: result.cidDecimal,
+            hydrated: detail ? "true" : "false",
+            reviews_status: detail?.reviewsStatus ?? "",
+            review_topics: (detail?.reviewTopics ?? []).map((t) => `${t.label} (${t.count})`).join("; "),
+            owner_response_rate: reviews.length ? (ownerResponses / reviews.length).toFixed(2) : "",
+            error: error ?? ""
+          };
+        });
+        const reviewInsightRows = hydrated.map(({ city, result, detail }) => {
+          const reviews = detail?.reviews ?? [];
+          const positive = reviews.filter((r) => Number(r.stars) >= 5 && r.text).map((r) => r.text);
+          const negative = reviews.filter((r) => Number(r.stars) > 0 && Number(r.stars) <= 3 && r.text).map((r) => r.text);
+          return {
+            city: city.city,
+            business_name: result.name,
+            cid: result.cid,
+            review_count: detail?.reviewCount ?? result.reviewCount,
+            average_rating: detail?.rating ?? result.rating,
+            topics: (detail?.reviewTopics ?? []).map((t) => `${t.label} (${t.count})`).join("; "),
+            praise_terms: termsFrom(positive),
+            complaint_terms: termsFrom(negative),
+            positive_sample: positive[0]?.slice(0, 280) ?? "",
+            negative_sample: negative[0]?.slice(0, 280) ?? ""
+          };
+        });
+        const citySummaryRows = directory.cities.map((city) => {
+          const resultReviewCounts = city.results.map((r) => numberFrom(r.reviewCount));
+          const resultRatings = city.results.map((r) => numberFrom(r.rating));
+          const topThreeReviews = city.results.slice(0, 3).map((r) => numberFrom(r.reviewCount)).filter((v) => v !== null);
+          const categories = /* @__PURE__ */ new Map();
+          for (const result of city.results) {
+            if (!result.category) continue;
+            categories.set(result.category, (categories.get(result.category) ?? 0) + 1);
+          }
+          const medReviews = median(resultReviewCounts);
+          const medRating = median(resultRatings);
+          const topThreeAvg = topThreeReviews.length ? Math.round(topThreeReviews.reduce((a, b) => a + b, 0) / topThreeReviews.length) : null;
+          const difficulty = Math.min(100, Math.round((topThreeAvg ?? 0) / 20 + (medRating ?? 0) * 10 + city.results.filter((r) => r.websiteUrl).length));
+          const opportunity = Math.max(0, 100 - difficulty);
+          return {
+            city: city.city,
+            state: city.state,
+            population: city.population,
+            result_count: city.resultCount,
+            median_review_count: medReviews ?? "",
+            median_rating: medRating ?? "",
+            top_three_average_review_count: topThreeAvg ?? "",
+            top_categories: [...categories.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([cat, count]) => `${cat} (${count})`).join("; "),
+            opportunity_score: opportunity,
+            difficulty_score: difficulty
+          };
+        });
+        await ctx.artifacts.writeCsv("Competitors CSV", "competitors.csv", ["city", "state", "source_location", "result_position", "business_name", "category", "review_stars", "review_count", "phone", "website_url", "place_url", "cid", "cid_decimal", "hydrated", "reviews_status", "review_topics", "owner_response_rate", "error"], competitorRows2);
+        await ctx.artifacts.writeCsv("Review insights CSV", "review-insights.csv", ["city", "business_name", "cid", "review_count", "average_rating", "topics", "praise_terms", "complaint_terms", "positive_sample", "negative_sample"], reviewInsightRows);
+        await ctx.artifacts.writeCsv("City summary CSV", "city-summary.csv", ["city", "state", "population", "result_count", "median_review_count", "median_rating", "top_three_average_review_count", "top_categories", "opportunity_score", "difficulty_score"], citySummaryRows);
+        await ctx.artifacts.writeJson("Audit evidence", "evidence.json", { input, directory, hydrated, citySummaryRows, competitorRows: competitorRows2, reviewInsightRows });
+        await ctx.artifacts.writeText("Agent tasks", "tasks.md", [
+          "# Local Competitive Audit Tasks",
+          "",
+          "- [ ] Review city opportunity and difficulty scores as heuristics, not absolute truth.",
+          "- [ ] Use review topics and samples as customer-language evidence.",
+          "- [ ] Compare target GBP category, review count, and website quality against top competitors.",
+          "- [ ] Identify cities with low review-count leaders and weak website coverage."
+        ].join("\n"));
+        const summary = `${directory.selectedCityCount} cities, ${directory.totalResultCount} Maps results, ${hydrated.filter((h) => h.detail).length} hydrated profiles.`;
+        await ctx.artifacts.writeText("Summary", "summary.md", `# Local Competitive Audit
+
+${summary}
+`);
+        const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+          title: "Local Competitive Audit",
+          subtitle: `${input.query} \xB7 ${input.state}`,
+          summary,
+          warnings,
+          tables: [
+            { title: "City Opportunity", columns: ["city", "state", "population", "result_count", "median_review_count", "median_rating", "top_three_average_review_count", "top_categories", "opportunity_score", "difficulty_score"], rows: citySummaryRows },
+            { title: "Hydrated Competitors", columns: ["city", "result_position", "business_name", "category", "review_stars", "review_count", "hydrated", "review_topics"], rows: competitorRows2.slice(0, 100) },
+            { title: "Review Insights", columns: ["city", "business_name", "topics", "praise_terms", "complaint_terms"], rows: reviewInsightRows.slice(0, 100) }
+          ]
+        }));
+        const status = warnings.length || directory.cities.some((city) => city.status === "failed") ? "partial" : "succeeded";
+        const counts = { cities: directory.selectedCityCount, mapsResults: directory.totalResultCount, hydratedProfiles: hydrated.filter((h) => h.detail).length };
+        await ctx.artifacts.writeManifest(status, counts, warnings, errors);
+        return { title: "Local Competitive Audit", summary, status, counts, warnings, errors, reportPath };
+      }
+    };
+  }
+});
+
+// src/workflows/registry.ts
+function listWorkflowDefinitions() {
+  return DEFINITIONS.map(({ id, title, description }) => ({ id, title, description }));
+}
+function workflowDefinition(id) {
+  const definition = DEFINITIONS.find((def) => def.id === id);
+  if (!definition) throw new Error(`Unknown workflow "${id}". Available: ${DEFINITIONS.map((def) => def.id).join(", ")}`);
+  return definition;
+}
+async function runWorkflow(id, rawInput, options = {}) {
+  const definition = workflowDefinition(id);
+  const input = definition.inputSchema.parse(rawInput);
+  const apiKey = options.apiKey?.trim() || process.env.MCP_SCRAPER_API_KEY?.trim();
+  if (!apiKey) throw new Error("MCP_SCRAPER_API_KEY is required for workflow runs. Pass --api-key or set the environment variable.");
+  const apiUrl = options.apiUrl?.trim() || process.env.MCP_SCRAPER_API_URL?.trim() || "https://mcpscraper.dev";
+  const artifacts = await ArtifactWriter.create(definition.id, definition.title, input, options.outputDir, options.runId);
+  const client2 = new WorkflowHttpClient(apiUrl, apiKey, options.fetchImpl);
+  try {
+    return await definition.run(input, {
+      runId: artifacts.runId,
+      startedAt: artifacts.startedAt,
+      client: client2,
+      artifacts,
+      signal: options.signal
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await artifacts.writeText("Failure", "summary.md", `# ${definition.title}
+
+${message}
+`);
+    await artifacts.writeManifest("failed", {}, [], [message]);
+    throw err;
+  }
+}
+var import_zod22, DEFINITIONS;
+var init_registry2 = __esm({
+  "src/workflows/registry.ts"() {
+    "use strict";
+    import_zod22 = require("zod");
+    init_artifact_writer();
+    init_http_client2();
+    init_agent_packet();
+    init_directory();
+    init_local_competitive_audit();
+    DEFINITIONS = [
+      directoryWorkflowDefinition,
+      agentPacketWorkflowDefinition,
+      localCompetitiveAuditWorkflowDefinition
+    ];
+  }
+});
+
+// src/api/workflow-routes.ts
+function hostedWorkflowOutputDir() {
+  return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
+}
+function originFromUrl(url) {
+  const parsed = new URL(url);
+  return `${parsed.protocol}//${parsed.host}`;
+}
+function addCadence(fromIso, cadence) {
+  const next = new Date(fromIso);
+  if (!Number.isFinite(next.getTime())) return new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString();
+  if (cadence === "daily") next.setUTCDate(next.getUTCDate() + 1);
+  else if (cadence === "weekly") next.setUTCDate(next.getUTCDate() + 7);
+  else next.setUTCMonth(next.getUTCMonth() + 1);
+  return next.toISOString();
+}
+function defaultNextRunAt(cadence) {
+  return addCadence((/* @__PURE__ */ new Date()).toISOString(), cadence);
+}
+function validateWorkflowInput(workflowId, input) {
+  const definition = workflowDefinition(workflowId);
+  return definition.inputSchema.parse(input);
+}
+async function validateWebhookUrl(url) {
+  if (!url) return null;
+  const result = await validatePublicHttpUrl(url, { field: "webhookUrl", requireHttps: true });
+  if (result.error) throw new Error(result.error);
+  return url;
+}
+function runDownloadUrl(c, runId, artifactId) {
+  return `${originFromUrl(c.req.url)}/workflows/runs/${runId}/artifacts/${artifactId}`;
+}
+function exposeRun(c, run, artifacts = []) {
+  return {
+    ...run,
+    artifacts: artifacts.map((artifact) => ({
+      ...artifact,
+      downloadUrl: runDownloadUrl(c, run.id, artifact.id)
+    }))
+  };
+}
+async function persistRunArtifacts(runId, userId, manifest) {
+  if (!manifest) return [];
+  return replaceWorkflowArtifacts(runId, userId, manifest.artifacts);
+}
+async function readManifestFromSummary(summary) {
+  if (!summary.reportPath) return null;
+  const manifestPath = summary.reportPath.replace(/report\.html$/, "manifest.json");
+  try {
+    return JSON.parse(await (0, import_promises7.readFile)(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function webhookSignature(body, timestamp2) {
+  const secret2 = process.env.MCP_SCRAPER_WEBHOOK_SECRET?.trim();
+  if (!secret2) return null;
+  return (0, import_node_crypto2.createHmac)("sha256", secret2).update(`${timestamp2}.${body}`).digest("hex");
+}
+async function deliverWorkflowWebhook(input) {
+  if (!input.webhookUrl) return;
+  const payload = {
+    event: input.run.status === "failed" ? "workflow.run.failed" : input.run.status === "partial" ? "workflow.run.partial" : "workflow.run.succeeded",
+    runId: input.run.id,
+    scheduleId: input.scheduleId,
+    workflowId: input.run.workflow_id,
+    status: input.run.status,
+    completedAt: input.run.completed_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      title: input.summary?.title ?? input.run.workflow_id,
+      counts: input.summary?.counts ?? {},
+      warnings: input.summary?.warnings ?? [],
+      errors: input.summary?.errors ?? (input.run.error_message ? [input.run.error_message] : [])
+    },
+    artifacts: input.artifacts.map((artifact) => ({
+      kind: artifact.kind,
+      label: artifact.label,
+      path: artifact.path
+    }))
+  };
+  const body = JSON.stringify(payload);
+  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+  const headers = {
+    "Content-Type": "application/json",
+    "x-mcp-scraper-timestamp": timestamp2
+  };
+  const signature = webhookSignature(body, timestamp2);
+  if (signature) headers["x-mcp-scraper-signature"] = signature;
+  let lastError = null;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const res = await fetch(input.webhookUrl, { method: "POST", headers, body, signal: AbortSignal.timeout(15e3) });
+      if (res.ok) {
+        await recordWorkflowWebhookDelivery({ runId: input.run.id, scheduleId: input.scheduleId, userId: input.userId, webhookUrl: input.webhookUrl, status: "delivered", attempts: attempt });
+        return;
+      }
+      lastError = `HTTP ${res.status}`;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+    }
+    await new Promise((resolve) => setTimeout(resolve, attempt * 500));
+  }
+  await recordWorkflowWebhookDelivery({ runId: input.run.id, scheduleId: input.scheduleId, userId: input.userId, webhookUrl: input.webhookUrl, status: "failed", attempts: 3, lastError });
+}
+async function executeWorkflowRun(input) {
+  await markWorkflowRunRunning(input.runId);
+  try {
+    const summary = await runWorkflow(input.workflowId, input.workflowInput, {
+      apiKey: input.user.api_key,
+      apiUrl: input.apiUrl,
+      outputDir: hostedWorkflowOutputDir(),
+      runId: input.runId
+    });
+    const manifest = await readManifestFromSummary(summary);
+    await completeWorkflowRunRecord(input.runId, summary.status, manifest ?? { summary });
+    const run = await getWorkflowRun(input.runId, input.user.id);
+    if (!run) throw new Error("Workflow run disappeared after execution");
+    const artifacts = await persistRunArtifacts(input.runId, input.user.id, manifest);
+    await deliverWorkflowWebhook({ userId: input.user.id, run, scheduleId: input.scheduleId ?? null, webhookUrl: input.webhookUrl ?? null, summary, artifacts });
+    return { run, summary, artifacts };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await failWorkflowRunRecord(input.runId, message, { error: message });
+    const run = await getWorkflowRun(input.runId, input.user.id);
+    if (!run) throw err;
+    await deliverWorkflowWebhook({ userId: input.user.id, run, scheduleId: input.scheduleId ?? null, webhookUrl: input.webhookUrl ?? null, summary: null, artifacts: [] });
+    throw err;
+  }
+}
+async function dispatchDueWorkflowSchedules(apiUrl, limit = 3) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const due = await listDueWorkflowSchedules(now, limit);
+  const results = [];
+  for (const schedule of due) {
+    const user = await getUserById(schedule.user_id);
+    if (!user) {
+      results.push({ scheduleId: schedule.id, status: "failed", error: "User not found" });
+      continue;
+    }
+    const scheduledFor = schedule.next_run_at ?? now;
+    const run = await createWorkflowRun({
+      userId: user.id,
+      scheduleId: schedule.id,
+      workflowId: schedule.workflow_id,
+      workflowInput: schedule.input,
+      idempotencyKey: `${schedule.id}:${scheduledFor}`
+    });
+    await markWorkflowScheduleRan(schedule.id, now, addCadence(scheduledFor, schedule.cadence));
+    if (run.status !== "queued") {
+      results.push({ scheduleId: schedule.id, runId: run.id, status: run.status });
+      continue;
+    }
+    try {
+      const executed = await executeWorkflowRun({
+        runId: run.id,
+        user,
+        workflowId: schedule.workflow_id,
+        workflowInput: schedule.input,
+        apiUrl,
+        scheduleId: schedule.id,
+        webhookUrl: schedule.webhook_url
+      });
+      results.push({ scheduleId: schedule.id, runId: executed.run.id, status: executed.run.status });
+    } catch (err) {
+      results.push({ scheduleId: schedule.id, runId: run.id, status: "failed", error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { dispatched: results.length, results };
+}
+var import_node_crypto2, import_promises7, import_hono7, import_zod23, workflowApp, WorkflowInputSchema, WorkflowIdSchema, CadenceSchema, ScheduleStatusSchema, RunBodySchema, ScheduleCreateSchema, SchedulePatchSchema;
+var init_workflow_routes = __esm({
+  "src/api/workflow-routes.ts"() {
+    "use strict";
+    import_node_crypto2 = require("crypto");
+    import_promises7 = require("fs/promises");
+    import_hono7 = require("hono");
+    import_zod23 = require("zod");
+    init_artifact_writer();
+    init_registry2();
+    init_api_auth();
+    init_db();
+    init_url_utils();
+    workflowApp = new import_hono7.Hono();
+    WorkflowInputSchema = import_zod23.z.record(import_zod23.z.unknown()).default({});
+    WorkflowIdSchema = import_zod23.z.string().min(1);
+    CadenceSchema = import_zod23.z.enum(["daily", "weekly", "monthly"]);
+    ScheduleStatusSchema = import_zod23.z.enum(["active", "paused"]);
+    RunBodySchema = import_zod23.z.object({
+      workflowId: WorkflowIdSchema,
+      input: WorkflowInputSchema,
+      webhookUrl: import_zod23.z.string().url().optional()
+    });
+    ScheduleCreateSchema = import_zod23.z.object({
+      workflowId: WorkflowIdSchema,
+      name: import_zod23.z.string().min(1).max(120).optional(),
+      input: WorkflowInputSchema,
+      cadence: CadenceSchema.default("weekly"),
+      timezone: import_zod23.z.string().min(1).max(64).default("UTC"),
+      webhookUrl: import_zod23.z.string().url().optional(),
+      nextRunAt: import_zod23.z.string().datetime().optional()
+    });
+    SchedulePatchSchema = import_zod23.z.object({
+      name: import_zod23.z.string().min(1).max(120).optional(),
+      status: ScheduleStatusSchema.optional(),
+      input: WorkflowInputSchema.optional(),
+      cadence: CadenceSchema.optional(),
+      timezone: import_zod23.z.string().min(1).max(64).optional(),
+      webhookUrl: import_zod23.z.string().url().nullable().optional(),
+      nextRunAt: import_zod23.z.string().datetime().nullable().optional()
+    });
+    workflowApp.get("/definitions", createApiKeyAuth(), (c) => {
+      return c.json({ workflows: listWorkflowDefinitions() });
+    });
+    workflowApp.post("/run", createApiKeyAuth(), async (c) => {
+      const user = c.get("user");
+      const parsed = RunBodySchema.safeParse(await c.req.json().catch(() => ({})));
+      if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+      let input;
+      let webhookUrl;
+      try {
+        input = validateWorkflowInput(parsed.data.workflowId, parsed.data.input);
+        webhookUrl = await validateWebhookUrl(parsed.data.webhookUrl);
+      } catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+      }
+      const run = await createWorkflowRun({ userId: user.id, workflowId: parsed.data.workflowId, workflowInput: input });
+      try {
+        const executed = await executeWorkflowRun({
+          runId: run.id,
+          user,
+          workflowId: parsed.data.workflowId,
+          workflowInput: input,
+          apiUrl: originFromUrl(c.req.url),
+          webhookUrl
+        });
+        return c.json({ run: exposeRun(c, executed.run, executed.artifacts), summary: executed.summary });
+      } catch (err) {
+        const failed = await getWorkflowRun(run.id, user.id);
+        return c.json({ run: failed, error: err instanceof Error ? err.message : String(err) }, 500);
+      }
+    });
+    workflowApp.get("/runs", createApiKeyAuth(), async (c) => {
+      const user = c.get("user");
+      const runs = await listWorkflowRuns(user.id);
+      return c.json({ runs });
+    });
+    workflowApp.get("/runs/:id", createApiKeyAuth(), async (c) => {
+      const user = c.get("user");
+      const run = await getWorkflowRun(c.req.param("id"), user.id);
+      if (!run) return c.json({ error: "Run not found" }, 404);
+      const artifacts = await listWorkflowArtifacts(run.id, user.id);
+      return c.json({ run: exposeRun(c, run, artifacts) });
+    });
+    workflowApp.get("/runs/:id/artifacts/:artifactId", createApiKeyAuth(), async (c) => {
+      const user = c.get("user");
+      const run = await getWorkflowRun(c.req.param("id"), user.id);
+      if (!run) return c.json({ error: "Run not found" }, 404);
+      const artifact = await getWorkflowArtifact(c.req.param("artifactId"), user.id);
+      if (!artifact || artifact.run_id !== run.id) return c.json({ error: "Artifact not found" }, 404);
+      try {
+        const content = await (0, import_promises7.readFile)(artifact.path);
+        return new Response(content, {
+          headers: {
+            "Content-Type": artifact.content_type,
+            "Content-Disposition": `attachment; filename="${artifact.path.split("/").pop() || artifact.id}"`
+          }
+        });
+      } catch {
+        return c.json({ error: "Artifact file is no longer available" }, 410);
+      }
+    });
+    workflowApp.post("/schedules", createApiKeyAuth(), async (c) => {
+      const user = c.get("user");
+      const parsed = ScheduleCreateSchema.safeParse(await c.req.json().catch(() => ({})));
+      if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+      let input;
+      let webhookUrl;
+      try {
+        input = validateWorkflowInput(parsed.data.workflowId, parsed.data.input);
+        webhookUrl = await validateWebhookUrl(parsed.data.webhookUrl);
+      } catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+      }
+      const schedule = await createWorkflowSchedule({
+        userId: user.id,
+        workflowId: parsed.data.workflowId,
+        name: parsed.data.name ?? workflowDefinition(parsed.data.workflowId).title,
+        workflowInput: input,
+        cadence: parsed.data.cadence,
+        timezone: parsed.data.timezone,
+        webhookUrl,
+        nextRunAt: parsed.data.nextRunAt ?? defaultNextRunAt(parsed.data.cadence)
+      });
+      return c.json({ schedule }, 201);
+    });
+    workflowApp.get("/schedules", createApiKeyAuth(), async (c) => {
+      const user = c.get("user");
+      return c.json({ schedules: await listWorkflowSchedules(user.id) });
+    });
+    workflowApp.patch("/schedules/:id", createApiKeyAuth(), async (c) => {
+      const user = c.get("user");
+      const existing = await getWorkflowSchedule(c.req.param("id"), user.id);
+      if (!existing) return c.json({ error: "Schedule not found" }, 404);
+      const parsed = SchedulePatchSchema.safeParse(await c.req.json().catch(() => ({})));
+      if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+      let nextInput;
+      let webhookUrl;
+      try {
+        nextInput = parsed.data.input ? validateWorkflowInput(existing.workflow_id, parsed.data.input) : void 0;
+        webhookUrl = parsed.data.webhookUrl === void 0 ? void 0 : await validateWebhookUrl(parsed.data.webhookUrl);
+      } catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+      }
+      const schedule = await patchWorkflowSchedule({
+        id: existing.id,
+        userId: user.id,
+        name: parsed.data.name,
+        status: parsed.data.status,
+        workflowInput: nextInput,
+        cadence: parsed.data.cadence,
+        timezone: parsed.data.timezone,
+        webhookUrl,
+        nextRunAt: parsed.data.nextRunAt
+      });
+      return c.json({ schedule });
+    });
+    workflowApp.delete("/schedules/:id", createApiKeyAuth(), async (c) => {
+      const user = c.get("user");
+      const deleted = await deleteWorkflowSchedule(c.req.param("id"), user.id);
+      if (!deleted) return c.json({ error: "Schedule not found" }, 404);
+      return c.json({ ok: true });
+    });
+    workflowApp.post("/schedules/:id/run", createApiKeyAuth(), async (c) => {
+      const user = c.get("user");
+      const schedule = await getWorkflowSchedule(c.req.param("id"), user.id);
+      if (!schedule) return c.json({ error: "Schedule not found" }, 404);
+      const run = await createWorkflowRun({ userId: user.id, scheduleId: schedule.id, workflowId: schedule.workflow_id, workflowInput: schedule.input });
+      try {
+        const executed = await executeWorkflowRun({
+          runId: run.id,
+          user,
+          workflowId: schedule.workflow_id,
+          workflowInput: schedule.input,
+          apiUrl: originFromUrl(c.req.url),
+          scheduleId: schedule.id,
+          webhookUrl: schedule.webhook_url
+        });
+        return c.json({ run: exposeRun(c, executed.run, executed.artifacts), summary: executed.summary });
+      } catch (err) {
+        const failed = await getWorkflowRun(run.id, user.id);
+        return c.json({ run: failed, error: err instanceof Error ? err.message : String(err) }, 500);
+      }
+    });
+    workflowApp.post("/cron/dispatch", async (c) => {
+      const secret2 = c.req.header("authorization");
+      if (!process.env.CRON_SECRET || secret2 !== `Bearer ${process.env.CRON_SECRET}`) {
+        return c.json({ error: "Unauthorized" }, 401);
+      }
+      return c.json(await dispatchDueWorkflowSchedules(originFromUrl(c.req.url)));
+    });
+  }
+});
+
 // src/serp-intelligence/page-snapshot-extractor.ts
 function sha256(value) {
   if (!value) return null;
-  return (0, import_node_crypto2.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
 }
 function countWords(markdown) {
   const matches = markdown.trim().match(/\b[\p{L}\p{N}][\p{L}\p{N}'-]*\b/gu);
@@ -14801,11 +16365,11 @@ async function capturePageSnapshots(targets, options = {}) {
     }
   };
 }
-var import_node_crypto2, import_p_limit3, DEFAULT_TIMEOUT_MS, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_CONTENT_CHARS;
+var import_node_crypto3, import_p_limit3, DEFAULT_TIMEOUT_MS, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_CONTENT_CHARS;
 var init_page_snapshot_extractor = __esm({
   "src/serp-intelligence/page-snapshot-extractor.ts"() {
     "use strict";
-    import_node_crypto2 = require("crypto");
+    import_node_crypto3 = require("crypto");
     import_p_limit3 = __toESM(require("p-limit"), 1);
     init_kpo_extractor();
     init_url_utils();
@@ -15510,7 +17074,7 @@ var init_PAAExtractor = __esm({
             const titleText = texts.find((t) => !/^\d+:\d+$/.test(t) && t.length > 5) ?? "";
             if (!titleText) continue;
             let title = titleText;
-            let platform = "";
+            let platform2 = "";
             let channel = "";
             for (const p of sels.platforms) {
               let lastIdx = -1;
@@ -15526,13 +17090,13 @@ var init_PAAExtractor = __esm({
               const isSourceTag = /^[\s·]/.test(after) || after.trim() === "";
               if (!isSourceTag) continue;
               title = titleText.slice(0, lastIdx).trim();
-              platform = p;
+              platform2 = p;
               const stripped = after.replace(/^[\s·]+/, "");
               const dotIdx = stripped.indexOf("\xB7");
               channel = (dotIdx === -1 ? stripped : stripped.slice(0, dotIdx)).trim();
               break;
             }
-            if (title) results.push({ title, channel, platform, duration, url: href });
+            if (title) results.push({ title, channel, platform: platform2, duration, url: href });
           }
           return results;
         }, svSels);
@@ -15576,10 +17140,10 @@ var init_PAAExtractor = __esm({
             const engagement = engagementParts[0] ?? "";
             const dateCandidates = allSpans.map((s2) => s2.textContent?.trim() ?? "").filter((t) => /\d+ (day|week|month|year|hour)s? ago|Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec/.test(t));
             const date = ytDate || (dateCandidates[0] ?? "");
-            const platform = platformText || (ytChannel ? "YouTube" : "");
+            const platform2 = platformText || (ytChannel ? "YouTube" : "");
             const source = ytChannel || sourceText;
             let type = "unknown";
-            const pl = platform.toLowerCase();
+            const pl = platform2.toLowerCase();
             const src = source.toLowerCase();
             const srcRaw = sourceText.toLowerCase();
             if (pl.includes("reddit") || src.startsWith("r/")) type = "reddit";
@@ -15588,7 +17152,7 @@ var init_PAAExtractor = __esm({
             else if (pl.includes("tiktok") || srcRaw.includes("tiktok")) type = "tiktok";
             else if (pl.includes("youtube") || !!ytChannel) type = "youtube";
             else type = "news";
-            return { type, title, url, source, platform, popularComment, engagement, date, duration, authorNote };
+            return { type, title, url, source, platform: platform2, popularComment, engagement, date, duration, authorNote };
           });
         }, sels);
       }
@@ -16050,52 +17614,52 @@ var init_PAAExtractor = __esm({
 });
 
 // src/output/OutputSerializer.ts
-var import_node_fs4, import_node_path7, import_papaparse2, OutputSerializer;
+var import_node_fs5, import_node_path8, import_papaparse2, OutputSerializer;
 var init_OutputSerializer = __esm({
   "src/output/OutputSerializer.ts"() {
     "use strict";
-    import_node_fs4 = require("fs");
-    import_node_path7 = __toESM(require("path"), 1);
+    import_node_fs5 = require("fs");
+    import_node_path8 = __toESM(require("path"), 1);
     import_papaparse2 = __toESM(require("papaparse"), 1);
     OutputSerializer = class {
       async writeJSON(result, outputDir) {
-        await import_node_fs4.promises.mkdir(outputDir, { recursive: true });
+        await import_node_fs5.promises.mkdir(outputDir, { recursive: true });
         const slug = result.seed.toLowerCase().replace(/\W+/g, "-").slice(0, 40);
         const filename = `${slug}-${Date.now()}.json`;
-        const fullPath = import_node_path7.default.join(outputDir, filename);
-        await import_node_fs4.promises.writeFile(fullPath, JSON.stringify(result, null, 2), "utf8");
+        const fullPath = import_node_path8.default.join(outputDir, filename);
+        await import_node_fs5.promises.writeFile(fullPath, JSON.stringify(result, null, 2), "utf8");
         return fullPath;
       }
       async writeCSV(rows, outputDir) {
-        await import_node_fs4.promises.mkdir(outputDir, { recursive: true });
+        await import_node_fs5.promises.mkdir(outputDir, { recursive: true });
         const seedRaw = rows[0]?.seed_query ?? "paa";
         const slug = seedRaw.toLowerCase().replace(/\W+/g, "-").slice(0, 40);
         const csv = import_papaparse2.default.unparse(rows, { header: true });
         const filename = `${slug}-${Date.now()}.csv`;
-        const fullPath = import_node_path7.default.join(outputDir, filename);
-        await import_node_fs4.promises.writeFile(fullPath, csv, "utf8");
+        const fullPath = import_node_path8.default.join(outputDir, filename);
+        await import_node_fs5.promises.writeFile(fullPath, csv, "utf8");
         return fullPath;
       }
       async writeVideoCSV(videos, seed, outputDir) {
-        await import_node_fs4.promises.mkdir(outputDir, { recursive: true });
+        await import_node_fs5.promises.mkdir(outputDir, { recursive: true });
         const slug = seed.toLowerCase().replace(/\W+/g, "-").slice(0, 40);
         const csv = import_papaparse2.default.unparse(videos, { header: true });
         const filename = `${slug}-videos-${Date.now()}.csv`;
-        const fullPath = import_node_path7.default.join(outputDir, filename);
-        await import_node_fs4.promises.writeFile(fullPath, csv, "utf8");
+        const fullPath = import_node_path8.default.join(outputDir, filename);
+        await import_node_fs5.promises.writeFile(fullPath, csv, "utf8");
         return fullPath;
       }
       async writeForumCSV(forums, seed, outputDir) {
-        await import_node_fs4.promises.mkdir(outputDir, { recursive: true });
+        await import_node_fs5.promises.mkdir(outputDir, { recursive: true });
         const slug = seed.toLowerCase().replace(/\W+/g, "-").slice(0, 40);
         const csv = import_papaparse2.default.unparse(forums, { header: true });
         const filename = `${slug}-forums-${Date.now()}.csv`;
-        const fullPath = import_node_path7.default.join(outputDir, filename);
-        await import_node_fs4.promises.writeFile(fullPath, csv, "utf8");
+        const fullPath = import_node_path8.default.join(outputDir, filename);
+        await import_node_fs5.promises.writeFile(fullPath, csv, "utf8");
         return fullPath;
       }
       async writeAIOverviewCSV(citations, text, seed, outputDir) {
-        await import_node_fs4.promises.mkdir(outputDir, { recursive: true });
+        await import_node_fs5.promises.mkdir(outputDir, { recursive: true });
         const slug = seed.toLowerCase().replace(/\W+/g, "-").slice(0, 40);
         const rows = citations.map((c, i) => ({
           seed_query: seed,
@@ -16105,12 +17669,12 @@ var init_OutputSerializer = __esm({
         }));
         const csv = import_papaparse2.default.unparse(rows, { header: true });
         const filename = `${slug}-ai-overview-${Date.now()}.csv`;
-        const fullPath = import_node_path7.default.join(outputDir, filename);
-        await import_node_fs4.promises.writeFile(fullPath, csv, "utf8");
+        const fullPath = import_node_path8.default.join(outputDir, filename);
+        await import_node_fs5.promises.writeFile(fullPath, csv, "utf8");
         return fullPath;
       }
       async writeAIModeCSV(citations, text, seed, outputDir) {
-        await import_node_fs4.promises.mkdir(outputDir, { recursive: true });
+        await import_node_fs5.promises.mkdir(outputDir, { recursive: true });
         const slug = seed.toLowerCase().replace(/\W+/g, "-").slice(0, 40);
         const rows = citations.map((c, i) => ({
           seed_query: seed,
@@ -16120,18 +17684,18 @@ var init_OutputSerializer = __esm({
         }));
         const csv = import_papaparse2.default.unparse(rows, { header: true });
         const filename = `${slug}-ai-mode-${Date.now()}.csv`;
-        const fullPath = import_node_path7.default.join(outputDir, filename);
-        await import_node_fs4.promises.writeFile(fullPath, csv, "utf8");
+        const fullPath = import_node_path8.default.join(outputDir, filename);
+        await import_node_fs5.promises.writeFile(fullPath, csv, "utf8");
         return fullPath;
       }
       async writeWhatPeopleSayingCSV(cards, seed, outputDir) {
-        await import_node_fs4.promises.mkdir(outputDir, { recursive: true });
+        await import_node_fs5.promises.mkdir(outputDir, { recursive: true });
         const slug = seed.toLowerCase().replace(/\W+/g, "-").slice(0, 40);
         const rows = cards.map((c) => ({ seed_query: seed, ...c }));
         const csv = import_papaparse2.default.unparse(rows, { header: true });
         const filename = `${slug}-what-people-saying-${Date.now()}.csv`;
-        const fullPath = import_node_path7.default.join(outputDir, filename);
-        await import_node_fs4.promises.writeFile(fullPath, csv, "utf8");
+        const fullPath = import_node_path8.default.join(outputDir, filename);
+        await import_node_fs5.promises.writeFile(fullPath, csv, "utf8");
         return fullPath;
       }
     };
@@ -16682,11 +18246,11 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var import_zod19, SerpIntelligenceDeviceValues, SerpIntelligenceProxyModeValues, SerpIntelligenceAttemptOutcomeValues, SerpIntelligenceLocalizationStatusValues, SerpPageSnapshotSourceKindValues, SerpPageFetchStatusValues, SerpPageFetchedViaValues, HostnameSuffixPattern, Ipv4Pattern, SerpIntelligencePublicHttpUrlSchema, SerpIntelligenceCaptureBodySchema, SerpIntelligencePageSnapshotRequestSchema, SerpIntelligencePageSnapshotsBodySchema, SerpIntelligenceAICitationSchema, SerpIntelligenceOrganicResultSchema, SerpIntelligenceLocationEvidenceSchema, SerpIntelligenceHarvestResultSchema, SerpIntelligenceCaptureAttemptSchema, SerpPageSnapshotCaptureSchema, SerpIntelligenceCaptureResponseSchema, SerpIntelligencePageSnapshotsResponseSchema;
+var import_zod24, SerpIntelligenceDeviceValues, SerpIntelligenceProxyModeValues, SerpIntelligenceAttemptOutcomeValues, SerpIntelligenceLocalizationStatusValues, SerpPageSnapshotSourceKindValues, SerpPageFetchStatusValues, SerpPageFetchedViaValues, HostnameSuffixPattern, Ipv4Pattern, SerpIntelligencePublicHttpUrlSchema, SerpIntelligenceCaptureBodySchema, SerpIntelligencePageSnapshotRequestSchema, SerpIntelligencePageSnapshotsBodySchema, SerpIntelligenceAICitationSchema, SerpIntelligenceOrganicResultSchema, SerpIntelligenceLocationEvidenceSchema, SerpIntelligenceHarvestResultSchema, SerpIntelligenceCaptureAttemptSchema, SerpPageSnapshotCaptureSchema, SerpIntelligenceCaptureResponseSchema, SerpIntelligencePageSnapshotsResponseSchema;
 var init_schemas4 = __esm({
   "src/serp-intelligence/schemas.ts"() {
     "use strict";
-    import_zod19 = require("zod");
+    import_zod24 = require("zod");
     SerpIntelligenceDeviceValues = ["desktop", "mobile"];
     SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
     SerpIntelligenceAttemptOutcomeValues = [
@@ -16720,171 +18284,171 @@ var init_schemas4 = __esm({
     SerpPageFetchedViaValues = ["fetch", "headless", "browser", "mcp"];
     HostnameSuffixPattern = /(^|\.)localhost$/i;
     Ipv4Pattern = /^\d{1,3}(?:\.\d{1,3}){3}$/;
-    SerpIntelligencePublicHttpUrlSchema = import_zod19.z.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-    SerpIntelligenceCaptureBodySchema = import_zod19.z.object({
-      query: import_zod19.z.string().trim().min(1, "query is required"),
-      location: import_zod19.z.string().trim().min(1).optional(),
-      gl: import_zod19.z.string().trim().length(2).default("us"),
-      hl: import_zod19.z.string().trim().length(2).default("en"),
-      device: import_zod19.z.enum(SerpIntelligenceDeviceValues).default("desktop"),
-      proxyMode: import_zod19.z.enum(SerpIntelligenceProxyModeValues).default("location"),
-      proxyZip: import_zod19.z.string().regex(/^\d{5}$/).optional(),
-      pages: import_zod19.z.number().int().min(1).max(2).default(1),
-      debug: import_zod19.z.boolean().default(false),
-      includePageSnapshots: import_zod19.z.boolean().default(false),
-      pageSnapshotLimit: import_zod19.z.number().int().min(0).max(10).default(0)
+    SerpIntelligencePublicHttpUrlSchema = import_zod24.z.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+    SerpIntelligenceCaptureBodySchema = import_zod24.z.object({
+      query: import_zod24.z.string().trim().min(1, "query is required"),
+      location: import_zod24.z.string().trim().min(1).optional(),
+      gl: import_zod24.z.string().trim().length(2).default("us"),
+      hl: import_zod24.z.string().trim().length(2).default("en"),
+      device: import_zod24.z.enum(SerpIntelligenceDeviceValues).default("desktop"),
+      proxyMode: import_zod24.z.enum(SerpIntelligenceProxyModeValues).default("location"),
+      proxyZip: import_zod24.z.string().regex(/^\d{5}$/).optional(),
+      pages: import_zod24.z.number().int().min(1).max(2).default(1),
+      debug: import_zod24.z.boolean().default(false),
+      includePageSnapshots: import_zod24.z.boolean().default(false),
+      pageSnapshotLimit: import_zod24.z.number().int().min(0).max(10).default(0)
     }).strict();
-    SerpIntelligencePageSnapshotRequestSchema = import_zod19.z.object({
+    SerpIntelligencePageSnapshotRequestSchema = import_zod24.z.object({
       url: SerpIntelligencePublicHttpUrlSchema,
-      sourceKind: import_zod19.z.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-      sourcePosition: import_zod19.z.number().int().min(1).optional()
+      sourceKind: import_zod24.z.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+      sourcePosition: import_zod24.z.number().int().min(1).optional()
     }).strict();
-    SerpIntelligencePageSnapshotsBodySchema = import_zod19.z.object({
-      urls: import_zod19.z.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
-      targets: import_zod19.z.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-      maxConcurrency: import_zod19.z.number().int().min(1).max(5).default(2),
-      timeoutMs: import_zod19.z.number().int().min(1e3).max(6e4).default(15e3),
-      debug: import_zod19.z.boolean().default(false)
+    SerpIntelligencePageSnapshotsBodySchema = import_zod24.z.object({
+      urls: import_zod24.z.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+      targets: import_zod24.z.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+      maxConcurrency: import_zod24.z.number().int().min(1).max(5).default(2),
+      timeoutMs: import_zod24.z.number().int().min(1e3).max(6e4).default(15e3),
+      debug: import_zod24.z.boolean().default(false)
     }).strict();
-    SerpIntelligenceAICitationSchema = import_zod19.z.object({
-      text: import_zod19.z.string(),
-      href: import_zod19.z.string()
+    SerpIntelligenceAICitationSchema = import_zod24.z.object({
+      text: import_zod24.z.string(),
+      href: import_zod24.z.string()
     }).strict();
-    SerpIntelligenceOrganicResultSchema = import_zod19.z.object({
-      position: import_zod19.z.number().int().min(1),
-      title: import_zod19.z.string(),
-      url: import_zod19.z.string(),
-      domain: import_zod19.z.string(),
-      cite: import_zod19.z.string().nullable(),
-      snippet: import_zod19.z.string().nullable(),
-      isRedditStyle: import_zod19.z.boolean(),
-      inlineRating: import_zod19.z.object({
-        value: import_zod19.z.string(),
-        count: import_zod19.z.string()
+    SerpIntelligenceOrganicResultSchema = import_zod24.z.object({
+      position: import_zod24.z.number().int().min(1),
+      title: import_zod24.z.string(),
+      url: import_zod24.z.string(),
+      domain: import_zod24.z.string(),
+      cite: import_zod24.z.string().nullable(),
+      snippet: import_zod24.z.string().nullable(),
+      isRedditStyle: import_zod24.z.boolean(),
+      inlineRating: import_zod24.z.object({
+        value: import_zod24.z.string(),
+        count: import_zod24.z.string()
       }).strict().nullable()
     }).strict();
-    SerpIntelligenceLocationEvidenceSchema = import_zod19.z.object({
-      status: import_zod19.z.enum(SerpIntelligenceLocalizationStatusValues),
-      expected: import_zod19.z.object({
-        city: import_zod19.z.string(),
-        regionCode: import_zod19.z.string().nullable(),
-        canonicalLocation: import_zod19.z.string()
+    SerpIntelligenceLocationEvidenceSchema = import_zod24.z.object({
+      status: import_zod24.z.enum(SerpIntelligenceLocalizationStatusValues),
+      expected: import_zod24.z.object({
+        city: import_zod24.z.string(),
+        regionCode: import_zod24.z.string().nullable(),
+        canonicalLocation: import_zod24.z.string()
       }).strict().nullable(),
-      candidates: import_zod19.z.array(import_zod19.z.object({
-        city: import_zod19.z.string(),
-        regionCode: import_zod19.z.string(),
-        count: import_zod19.z.number().int().min(0),
-        examples: import_zod19.z.array(import_zod19.z.string())
+      candidates: import_zod24.z.array(import_zod24.z.object({
+        city: import_zod24.z.string(),
+        regionCode: import_zod24.z.string(),
+        count: import_zod24.z.number().int().min(0),
+        examples: import_zod24.z.array(import_zod24.z.string())
       }).strict())
     }).strict();
-    SerpIntelligenceHarvestResultSchema = import_zod19.z.object({
-      seed: import_zod19.z.string(),
-      location: import_zod19.z.string().nullable(),
-      extractedAt: import_zod19.z.string(),
-      totalQuestions: import_zod19.z.number().int().min(0),
-      surface: import_zod19.z.enum(["web", "aim", "unknown"]),
-      aiOverview: import_zod19.z.object({
-        detected: import_zod19.z.boolean(),
-        text: import_zod19.z.string().nullable(),
-        citations: import_zod19.z.array(SerpIntelligenceAICitationSchema),
-        expanded: import_zod19.z.boolean().optional(),
-        fullyExpanded: import_zod19.z.boolean().optional(),
-        sections: import_zod19.z.array(import_zod19.z.string()).optional()
+    SerpIntelligenceHarvestResultSchema = import_zod24.z.object({
+      seed: import_zod24.z.string(),
+      location: import_zod24.z.string().nullable(),
+      extractedAt: import_zod24.z.string(),
+      totalQuestions: import_zod24.z.number().int().min(0),
+      surface: import_zod24.z.enum(["web", "aim", "unknown"]),
+      aiOverview: import_zod24.z.object({
+        detected: import_zod24.z.boolean(),
+        text: import_zod24.z.string().nullable(),
+        citations: import_zod24.z.array(SerpIntelligenceAICitationSchema),
+        expanded: import_zod24.z.boolean().optional(),
+        fullyExpanded: import_zod24.z.boolean().optional(),
+        sections: import_zod24.z.array(import_zod24.z.string()).optional()
       }).strict(),
-      aiMode: import_zod19.z.object({
-        detected: import_zod19.z.boolean(),
-        text: import_zod19.z.string().nullable(),
-        citations: import_zod19.z.array(SerpIntelligenceAICitationSchema)
+      aiMode: import_zod24.z.object({
+        detected: import_zod24.z.boolean(),
+        text: import_zod24.z.string().nullable(),
+        citations: import_zod24.z.array(SerpIntelligenceAICitationSchema)
       }).strict(),
-      tree: import_zod19.z.array(import_zod19.z.unknown()),
-      flat: import_zod19.z.array(import_zod19.z.unknown()),
-      videos: import_zod19.z.array(import_zod19.z.unknown()),
-      forums: import_zod19.z.array(import_zod19.z.unknown()),
-      organicResults: import_zod19.z.array(SerpIntelligenceOrganicResultSchema),
-      localPack: import_zod19.z.array(import_zod19.z.unknown()),
-      entityIds: import_zod19.z.object({
-        entities: import_zod19.z.array(import_zod19.z.object({
-          name: import_zod19.z.string(),
-          kgId: import_zod19.z.string().nullable(),
-          cid: import_zod19.z.string().nullable(),
-          gcid: import_zod19.z.string().nullable()
+      tree: import_zod24.z.array(import_zod24.z.unknown()),
+      flat: import_zod24.z.array(import_zod24.z.unknown()),
+      videos: import_zod24.z.array(import_zod24.z.unknown()),
+      forums: import_zod24.z.array(import_zod24.z.unknown()),
+      organicResults: import_zod24.z.array(SerpIntelligenceOrganicResultSchema),
+      localPack: import_zod24.z.array(import_zod24.z.unknown()),
+      entityIds: import_zod24.z.object({
+        entities: import_zod24.z.array(import_zod24.z.object({
+          name: import_zod24.z.string(),
+          kgId: import_zod24.z.string().nullable(),
+          cid: import_zod24.z.string().nullable(),
+          gcid: import_zod24.z.string().nullable()
         }).strict()),
-        kgIds: import_zod19.z.array(import_zod19.z.string()),
-        cids: import_zod19.z.array(import_zod19.z.string()),
-        gcids: import_zod19.z.array(import_zod19.z.string())
+        kgIds: import_zod24.z.array(import_zod24.z.string()),
+        cids: import_zod24.z.array(import_zod24.z.string()),
+        gcids: import_zod24.z.array(import_zod24.z.string())
       }).strict(),
-      stats: import_zod19.z.object({
-        seed: import_zod19.z.string(),
-        totalQuestions: import_zod19.z.number().int().min(0),
-        maxDepthReached: import_zod19.z.number().int().min(0),
-        durationMs: import_zod19.z.number().min(0),
-        errorCount: import_zod19.z.number().int().min(0)
+      stats: import_zod24.z.object({
+        seed: import_zod24.z.string(),
+        totalQuestions: import_zod24.z.number().int().min(0),
+        maxDepthReached: import_zod24.z.number().int().min(0),
+        durationMs: import_zod24.z.number().min(0),
+        errorCount: import_zod24.z.number().int().min(0)
       }).strict(),
-      diagnostics: import_zod19.z.object({
-        completionStatus: import_zod19.z.enum(["paa_found", "no_paa", "serp_only"]),
-        problem: import_zod19.z.null(),
-        warnings: import_zod19.z.array(import_zod19.z.unknown()).optional(),
-        debug: import_zod19.z.object({
+      diagnostics: import_zod24.z.object({
+        completionStatus: import_zod24.z.enum(["paa_found", "no_paa", "serp_only"]),
+        problem: import_zod24.z.null(),
+        warnings: import_zod24.z.array(import_zod24.z.unknown()).optional(),
+        debug: import_zod24.z.object({
           locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
         }).passthrough().optional()
       }).passthrough(),
-      whatPeopleSaying: import_zod19.z.array(import_zod19.z.unknown())
+      whatPeopleSaying: import_zod24.z.array(import_zod24.z.unknown())
     }).strict();
-    SerpIntelligenceCaptureAttemptSchema = import_zod19.z.object({
-      attemptNumber: import_zod19.z.number().int().min(1),
-      outcome: import_zod19.z.enum(SerpIntelligenceAttemptOutcomeValues),
-      startedAt: import_zod19.z.string().optional(),
-      completedAt: import_zod19.z.string().optional(),
-      durationMs: import_zod19.z.number().min(0).optional(),
-      problemCode: import_zod19.z.string().optional(),
-      message: import_zod19.z.string().optional(),
-      kernelSessionId: import_zod19.z.string().nullable().optional(),
-      cleanupSucceeded: import_zod19.z.boolean().nullable().optional()
+    SerpIntelligenceCaptureAttemptSchema = import_zod24.z.object({
+      attemptNumber: import_zod24.z.number().int().min(1),
+      outcome: import_zod24.z.enum(SerpIntelligenceAttemptOutcomeValues),
+      startedAt: import_zod24.z.string().optional(),
+      completedAt: import_zod24.z.string().optional(),
+      durationMs: import_zod24.z.number().min(0).optional(),
+      problemCode: import_zod24.z.string().optional(),
+      message: import_zod24.z.string().optional(),
+      kernelSessionId: import_zod24.z.string().nullable().optional(),
+      cleanupSucceeded: import_zod24.z.boolean().nullable().optional()
     }).strict();
-    SerpPageSnapshotCaptureSchema = import_zod19.z.object({
+    SerpPageSnapshotCaptureSchema = import_zod24.z.object({
       url: SerpIntelligencePublicHttpUrlSchema,
       requestedUrl: SerpIntelligencePublicHttpUrlSchema,
       finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-      sourceKind: import_zod19.z.enum(SerpPageSnapshotSourceKindValues),
-      sourcePosition: import_zod19.z.number().int().min(1).nullable(),
-      status: import_zod19.z.enum(SerpPageFetchStatusValues),
-      fetchedVia: import_zod19.z.enum(SerpPageFetchedViaValues).nullable(),
-      httpStatus: import_zod19.z.number().int().min(100).max(599).nullable(),
-      contentType: import_zod19.z.string().nullable(),
-      title: import_zod19.z.string().nullable(),
+      sourceKind: import_zod24.z.enum(SerpPageSnapshotSourceKindValues),
+      sourcePosition: import_zod24.z.number().int().min(1).nullable(),
+      status: import_zod24.z.enum(SerpPageFetchStatusValues),
+      fetchedVia: import_zod24.z.enum(SerpPageFetchedViaValues).nullable(),
+      httpStatus: import_zod24.z.number().int().min(100).max(599).nullable(),
+      contentType: import_zod24.z.string().nullable(),
+      title: import_zod24.z.string().nullable(),
       canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-      metaDescription: import_zod19.z.string().nullable(),
-      headings: import_zod19.z.array(import_zod19.z.object({
-        level: import_zod19.z.number().int().min(1).max(6),
-        text: import_zod19.z.string()
+      metaDescription: import_zod24.z.string().nullable(),
+      headings: import_zod24.z.array(import_zod24.z.object({
+        level: import_zod24.z.number().int().min(1).max(6),
+        text: import_zod24.z.string()
       }).strict()).default([]),
-      artifact: import_zod19.z.object({
-        htmlBlobUrl: import_zod19.z.string().url().nullable(),
-        textBlobUrl: import_zod19.z.string().url().nullable(),
-        markdownBlobUrl: import_zod19.z.string().url().nullable(),
-        screenshotBlobUrl: import_zod19.z.string().url().nullable(),
-        contentSha256: import_zod19.z.string().nullable(),
-        capturedAt: import_zod19.z.string().nullable()
+      artifact: import_zod24.z.object({
+        htmlBlobUrl: import_zod24.z.string().url().nullable(),
+        textBlobUrl: import_zod24.z.string().url().nullable(),
+        markdownBlobUrl: import_zod24.z.string().url().nullable(),
+        screenshotBlobUrl: import_zod24.z.string().url().nullable(),
+        contentSha256: import_zod24.z.string().nullable(),
+        capturedAt: import_zod24.z.string().nullable()
       }).strict(),
-      error: import_zod19.z.object({
-        code: import_zod19.z.string(),
-        message: import_zod19.z.string()
+      error: import_zod24.z.object({
+        code: import_zod24.z.string(),
+        message: import_zod24.z.string()
       }).strict().nullable()
     }).strict();
-    SerpIntelligenceCaptureResponseSchema = import_zod19.z.object({
+    SerpIntelligenceCaptureResponseSchema = import_zod24.z.object({
       harvestResult: SerpIntelligenceHarvestResultSchema,
-      attempts: import_zod19.z.array(SerpIntelligenceCaptureAttemptSchema),
+      attempts: import_zod24.z.array(SerpIntelligenceCaptureAttemptSchema),
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-      pageSnapshotArtifacts: import_zod19.z.array(SerpPageSnapshotCaptureSchema),
-      billing: import_zod19.z.object({
-        creditsUsed: import_zod19.z.number().min(0).optional(),
-        requestId: import_zod19.z.string().optional(),
-        jobId: import_zod19.z.string().optional()
+      pageSnapshotArtifacts: import_zod24.z.array(SerpPageSnapshotCaptureSchema),
+      billing: import_zod24.z.object({
+        creditsUsed: import_zod24.z.number().min(0).optional(),
+        requestId: import_zod24.z.string().optional(),
+        jobId: import_zod24.z.string().optional()
       }).strict().optional()
     }).strict();
-    SerpIntelligencePageSnapshotsResponseSchema = import_zod19.z.object({
-      pageSnapshotArtifacts: import_zod19.z.array(SerpPageSnapshotCaptureSchema),
-      attempts: import_zod19.z.array(SerpIntelligenceCaptureAttemptSchema).default([])
+    SerpIntelligencePageSnapshotsResponseSchema = import_zod24.z.object({
+      pageSnapshotArtifacts: import_zod24.z.array(SerpPageSnapshotCaptureSchema),
+      attempts: import_zod24.z.array(SerpIntelligenceCaptureAttemptSchema).default([])
     }).strict();
   }
 });
@@ -17128,11 +18692,11 @@ function pageSnapshotTargetsFromBody(body) {
     sourcePosition: null
   }));
 }
-var import_hono7, SERP_INTELLIGENCE_RATE_LIMIT, SERP_INTELLIGENCE_RATE_WINDOW_SECONDS, POST_CAPTURE_ROUTE_LABEL, POST_PAGE_SNAPSHOTS_ROUTE_LABEL, serpIntelligenceApp;
+var import_hono8, SERP_INTELLIGENCE_RATE_LIMIT, SERP_INTELLIGENCE_RATE_WINDOW_SECONDS, POST_CAPTURE_ROUTE_LABEL, POST_PAGE_SNAPSHOTS_ROUTE_LABEL, serpIntelligenceApp;
 var init_serp_intelligence_routes = __esm({
   "src/api/serp-intelligence-routes.ts"() {
     "use strict";
-    import_hono7 = require("hono");
+    import_hono8 = require("hono");
     init_browser_service_env();
     init_page_snapshot_extractor();
     init_serp_capture_service();
@@ -17144,7 +18708,7 @@ var init_serp_intelligence_routes = __esm({
     SERP_INTELLIGENCE_RATE_WINDOW_SECONDS = 60;
     POST_CAPTURE_ROUTE_LABEL = "POST /capture";
     POST_PAGE_SNAPSHOTS_ROUTE_LABEL = "POST /page-snapshots";
-    serpIntelligenceApp = new import_hono7.Hono();
+    serpIntelligenceApp = new import_hono8.Hono();
     serpIntelligenceApp.use("*", createApiKeyAuth());
     serpIntelligenceApp.post("/capture", async (c) => {
       void POST_CAPTURE_ROUTE_LABEL;
@@ -17262,133 +18826,133 @@ var PACKAGE_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    PACKAGE_VERSION = "0.2.8";
+    PACKAGE_VERSION = "0.2.9";
   }
 });
 
 // src/mcp/mcp-tool-schemas.ts
-var import_zod20, HarvestPaaInputSchema, ExtractUrlInputSchema, MapSiteUrlsInputSchema, ExtractSiteInputSchema, YoutubeHarvestInputSchema, YoutubeTranscribeInputSchema, FacebookPageIntelInputSchema, FacebookAdSearchInputSchema, FacebookAdTranscribeInputSchema, MapsPlaceIntelInputSchema, MapsSearchInputSchema, DirectoryWorkflowInputSchema, RankTrackerModeSchema, RankTrackerBlueprintInputSchema, NullableString, MapsSearchAttemptOutput, MapsSearchOutputSchema, DirectoryMapsBusinessOutput, DirectoryWorkflowOutputSchema, RankTrackerToolPlanOutput, RankTrackerTableOutput, RankTrackerCronJobOutput, RankTrackerBlueprintOutputSchema, OrganicResultOutput, AiOverviewOutput, EntityIdsOutput, HarvestPaaOutputSchema, SearchSerpOutputSchema, ExtractUrlOutputSchema, ExtractSiteOutputSchema, MapsPlaceIntelOutputSchema, CreditsInfoOutputSchema, MapSiteUrlsOutputSchema, YoutubeHarvestOutputSchema, FacebookAdSearchOutputSchema, FacebookPageIntelOutputSchema, CreditsInfoInputSchema, SearchSerpInputSchema, CaptureSerpSnapshotInputSchema, ScreenshotInputSchema, CaptureSerpPageSnapshotsInputSchema;
+var import_zod25, HarvestPaaInputSchema, ExtractUrlInputSchema, MapSiteUrlsInputSchema, ExtractSiteInputSchema, YoutubeHarvestInputSchema, YoutubeTranscribeInputSchema, FacebookPageIntelInputSchema, FacebookAdSearchInputSchema, FacebookAdTranscribeInputSchema, MapsPlaceIntelInputSchema, MapsSearchInputSchema, DirectoryWorkflowInputSchema, RankTrackerModeSchema, RankTrackerBlueprintInputSchema, NullableString, MapsSearchAttemptOutput, MapsSearchOutputSchema, DirectoryMapsBusinessOutput, DirectoryWorkflowOutputSchema, RankTrackerToolPlanOutput, RankTrackerTableOutput, RankTrackerCronJobOutput, RankTrackerBlueprintOutputSchema, OrganicResultOutput, AiOverviewOutput, EntityIdsOutput, HarvestPaaOutputSchema, SearchSerpOutputSchema, ExtractUrlOutputSchema, ExtractSiteOutputSchema, MapsPlaceIntelOutputSchema, CreditsInfoOutputSchema, MapSiteUrlsOutputSchema, YoutubeHarvestOutputSchema, FacebookAdSearchOutputSchema, FacebookPageIntelOutputSchema, CreditsInfoInputSchema, SearchSerpInputSchema, CaptureSerpSnapshotInputSchema, ScreenshotInputSchema, CaptureSerpPageSnapshotsInputSchema;
 var init_mcp_tool_schemas = __esm({
   "src/mcp/mcp-tool-schemas.ts"() {
     "use strict";
-    import_zod20 = require("zod");
+    import_zod25 = require("zod");
     HarvestPaaInputSchema = {
-      query: import_zod20.z.string().min(1).describe('Core search topic only. If the user says "best hvac company in Denver CO", use query="best hvac company" and location="Denver, CO". Do not include the location in query when it can be separated.'),
-      location: import_zod20.z.string().optional().describe('City, region, or country for geo-targeted results, inferred from the user request when present, e.g. "Denver, CO", "Tokyo, Japan", "London, UK".'),
-      maxQuestions: import_zod20.z.number().int().min(1).max(200).default(30).describe("Number of PAA questions to extract. Default 30. Maximum 200. Use 10 for quick probes, 30 for normal research, 100-200 when the user asks for everything/full/deep research. Larger harvests get a longer server time budget (151-200 questions \u2192 up to 280s). Credits are charged by extracted question; unused request hold is refunded."),
-      gl: import_zod20.z.string().length(2).default("us").describe("Google country code inferred from location or user language. Examples: United States us, United Kingdom gb, Japan jp, Canada ca, Australia au."),
-      hl: import_zod20.z.string().default("en").describe("Google interface/content language inferred from the user request. Use en unless the user asks for another language or locale."),
-      device: import_zod20.z.enum(["desktop", "mobile"]).default("desktop").describe("SERP device context. Use desktop by default; use mobile only when the user asks for mobile rankings."),
-      proxyMode: import_zod20.z.enum(["location", "configured", "none"]).default("location").describe("Proxy targeting mode. Use location by default for US city/state SERPs; it creates a fresh residential proxy ID per attempt. If Google shows a CAPTCHA/challenge, browser-service sessions briefly wait for the automatic solver first, then retry with a fresh proxy/session if the challenge does not clear. Also retries proxy tunnel failure and wrong-location evidence before returning. Use configured only for the static configured proxy. Use none only for direct-network debugging."),
-      proxyZip: import_zod20.z.string().regex(/^\d{5}$/).optional().describe("Optional US ZIP override for residential location proxy targeting. Use when the user gives a specific ZIP or when city-center targeting needs to be forced. With proxyMode location this ZIP is used for each fresh proxy attempt."),
-      debug: import_zod20.z.boolean().default(false).describe("Include sanitized browser/session/location diagnostics in the response. Use true when debugging localization, CAPTCHA, or proxy behavior.")
+      query: import_zod25.z.string().min(1).describe('Core search topic only. If the user says "best hvac company in Denver CO", use query="best hvac company" and location="Denver, CO". Do not include the location in query when it can be separated.'),
+      location: import_zod25.z.string().optional().describe('City, region, or country for geo-targeted results, inferred from the user request when present, e.g. "Denver, CO", "Tokyo, Japan", "London, UK".'),
+      maxQuestions: import_zod25.z.number().int().min(1).max(200).default(30).describe("Number of PAA questions to extract. Default 30. Maximum 200. Use 10 for quick probes, 30 for normal research, 100-200 when the user asks for everything/full/deep research. Larger harvests get a longer server time budget (151-200 questions \u2192 up to 280s). Credits are charged by extracted question; unused request hold is refunded."),
+      gl: import_zod25.z.string().length(2).default("us").describe("Google country code inferred from location or user language. Examples: United States us, United Kingdom gb, Japan jp, Canada ca, Australia au."),
+      hl: import_zod25.z.string().default("en").describe("Google interface/content language inferred from the user request. Use en unless the user asks for another language or locale."),
+      device: import_zod25.z.enum(["desktop", "mobile"]).default("desktop").describe("SERP device context. Use desktop by default; use mobile only when the user asks for mobile rankings."),
+      proxyMode: import_zod25.z.enum(["location", "configured", "none"]).default("location").describe("Proxy targeting mode. Use location by default for US city/state SERPs; it creates a fresh residential proxy ID per attempt. If Google shows a CAPTCHA/challenge, browser-service sessions briefly wait for the automatic solver first, then retry with a fresh proxy/session if the challenge does not clear. Also retries proxy tunnel failure and wrong-location evidence before returning. Use configured only for the static configured proxy. Use none only for direct-network debugging."),
+      proxyZip: import_zod25.z.string().regex(/^\d{5}$/).optional().describe("Optional US ZIP override for residential location proxy targeting. Use when the user gives a specific ZIP or when city-center targeting needs to be forced. With proxyMode location this ZIP is used for each fresh proxy attempt."),
+      debug: import_zod25.z.boolean().default(false).describe("Include sanitized browser/session/location diagnostics in the response. Use true when debugging localization, CAPTCHA, or proxy behavior.")
     };
     ExtractUrlInputSchema = {
-      url: import_zod20.z.string().url().describe("Public http/https URL to extract. Use this when the user provides one specific page URL."),
-      screenshot: import_zod20.z.boolean().default(false).describe("Also capture a full-page screenshot of the URL. Saved to ~/Downloads/mcp-scraper/screenshots/ and returned inline. Use when the user asks to see or capture the page visually."),
-      screenshotDevice: import_zod20.z.enum(["desktop", "mobile"]).default("desktop").describe("Viewport for screenshot. desktop = 1440\xD7900. mobile = 390\xD7844. Default desktop."),
-      extractBranding: import_zod20.z.boolean().default(false).describe("Extract brand colors, fonts, logo, and favicon using a rendered browser session. Returns colorScheme (light/dark), colors (primary/accent/background/text/heading as hex), fonts (heading/body family names), and assets (logo URL, favicon URL). Use when the user asks about brand colors, site theme, or brand assets."),
-      downloadMedia: import_zod20.z.boolean().default(false).describe("Extract and download all page media (images, video, audio) to ~/Downloads/mcp-scraper/media/. Ad networks, tracking pixels, and noise URLs are filtered automatically. Use when the user asks to download or harvest assets from a page."),
-      mediaTypes: import_zod20.z.array(import_zod20.z.enum(["image", "video", "audio"])).default(["image", "video", "audio"]).describe("Which media types to download. Default all three."),
-      allowLocal: import_zod20.z.boolean().default(false).describe("Allow localhost and private-network URLs. For local development only.")
+      url: import_zod25.z.string().url().describe("Public http/https URL to extract. Use this when the user provides one specific page URL."),
+      screenshot: import_zod25.z.boolean().default(false).describe("Also capture a full-page screenshot of the URL. Saved to ~/Downloads/mcp-scraper/screenshots/ and returned inline. Use when the user asks to see or capture the page visually."),
+      screenshotDevice: import_zod25.z.enum(["desktop", "mobile"]).default("desktop").describe("Viewport for screenshot. desktop = 1440\xD7900. mobile = 390\xD7844. Default desktop."),
+      extractBranding: import_zod25.z.boolean().default(false).describe("Extract brand colors, fonts, logo, and favicon using a rendered browser session. Returns colorScheme (light/dark), colors (primary/accent/background/text/heading as hex), fonts (heading/body family names), and assets (logo URL, favicon URL). Use when the user asks about brand colors, site theme, or brand assets."),
+      downloadMedia: import_zod25.z.boolean().default(false).describe("Extract and download all page media (images, video, audio) to ~/Downloads/mcp-scraper/media/. Ad networks, tracking pixels, and noise URLs are filtered automatically. Use when the user asks to download or harvest assets from a page."),
+      mediaTypes: import_zod25.z.array(import_zod25.z.enum(["image", "video", "audio"])).default(["image", "video", "audio"]).describe("Which media types to download. Default all three."),
+      allowLocal: import_zod25.z.boolean().default(false).describe("Allow localhost and private-network URLs. For local development only.")
     };
     MapSiteUrlsInputSchema = {
-      url: import_zod20.z.string().url().describe("Public website URL or domain to crawl for internal URLs. Use before extract_site when the user asks to audit/map/crawl a site."),
-      maxUrls: import_zod20.z.number().int().min(1).max(500).optional().describe("Maximum URLs to discover. Use 100 for normal maps, higher when the user asks for a full inventory.")
+      url: import_zod25.z.string().url().describe("Public website URL or domain to crawl for internal URLs. Use before extract_site when the user asks to audit/map/crawl a site."),
+      maxUrls: import_zod25.z.number().int().min(1).max(500).optional().describe("Maximum URLs to discover. Use 100 for normal maps, higher when the user asks for a full inventory.")
     };
     ExtractSiteInputSchema = {
-      url: import_zod20.z.string().url().describe("Public website URL or domain to extract across multiple pages. Use when the user asks for a site audit, website crawl, or full-site content/schema extraction."),
-      maxPages: import_zod20.z.number().int().min(1).max(50).optional().describe("Maximum pages to extract. Use 50 when the user asks for full results or a complete crawl within MCP limits.")
+      url: import_zod25.z.string().url().describe("Public website URL or domain to extract across multiple pages. Use when the user asks for a site audit, website crawl, or full-site content/schema extraction."),
+      maxPages: import_zod25.z.number().int().min(1).max(50).optional().describe("Maximum pages to extract. Use 50 when the user asks for full results or a complete crawl within MCP limits.")
     };
     YoutubeHarvestInputSchema = {
-      mode: import_zod20.z.enum(["search", "channel"]).describe("Use search for topic/keyword requests. Use channel when the user provides @handle, channel ID, or channel URL."),
-      query: import_zod20.z.string().optional().describe("Required when mode is search. The YouTube search topic in the user\u2019s words."),
-      channelHandle: import_zod20.z.string().optional().describe("YouTube channel handle, channel ID, or URL. Examples: @mkbhd, UC..., https://youtube.com/@mkbhd."),
-      maxVideos: import_zod20.z.number().int().min(1).max(500).default(50).describe("Number of videos to return. Default 50. Increase when user asks for full channel/history.")
+      mode: import_zod25.z.enum(["search", "channel"]).describe("Use search for topic/keyword requests. Use channel when the user provides @handle, channel ID, or channel URL."),
+      query: import_zod25.z.string().optional().describe("Required when mode is search. The YouTube search topic in the user\u2019s words."),
+      channelHandle: import_zod25.z.string().optional().describe("YouTube channel handle, channel ID, or URL. Examples: @mkbhd, UC..., https://youtube.com/@mkbhd."),
+      maxVideos: import_zod25.z.number().int().min(1).max(500).default(50).describe("Number of videos to return. Default 50. Increase when user asks for full channel/history.")
     };
     YoutubeTranscribeInputSchema = {
-      videoId: import_zod20.z.string().min(1).describe("YouTube video ID, e.g. dQw4w9WgXcQ")
+      videoId: import_zod25.z.string().min(1).describe("YouTube video ID, e.g. dQw4w9WgXcQ")
     };
     FacebookPageIntelInputSchema = {
-      pageId: import_zod20.z.string().optional(),
-      libraryId: import_zod20.z.string().optional(),
-      query: import_zod20.z.string().optional().describe("Advertiser or brand name when pageId/libraryId is not known. One of pageId, libraryId, or query is required."),
-      maxAds: import_zod20.z.number().int().min(1).max(200).default(50),
-      country: import_zod20.z.string().length(2).default("US")
+      pageId: import_zod25.z.string().optional(),
+      libraryId: import_zod25.z.string().optional(),
+      query: import_zod25.z.string().optional().describe("Advertiser or brand name when pageId/libraryId is not known. One of pageId, libraryId, or query is required."),
+      maxAds: import_zod25.z.number().int().min(1).max(200).default(50),
+      country: import_zod25.z.string().length(2).default("US")
     };
     FacebookAdSearchInputSchema = {
-      query: import_zod20.z.string().min(1).describe("Advertiser, brand, competitor, niche, or keyword to search in Facebook Ad Library."),
-      country: import_zod20.z.string().length(2).default("US"),
-      maxResults: import_zod20.z.number().int().min(1).max(20).default(10)
+      query: import_zod25.z.string().min(1).describe("Advertiser, brand, competitor, niche, or keyword to search in Facebook Ad Library."),
+      country: import_zod25.z.string().length(2).default("US"),
+      maxResults: import_zod25.z.number().int().min(1).max(20).default(10)
     };
     FacebookAdTranscribeInputSchema = {
-      videoUrl: import_zod20.z.string().url().describe("Facebook CDN video URL from a facebook_page_intel result")
+      videoUrl: import_zod25.z.string().url().describe("Facebook CDN video URL from a facebook_page_intel result")
     };
     MapsPlaceIntelInputSchema = {
-      businessName: import_zod20.z.string().min(1).describe('Business name only. If user says "Elite Roofing Denver CO", use businessName="Elite Roofing" and location="Denver, CO".'),
-      location: import_zod20.z.string().min(1).describe('City/region/country where the business should be searched, e.g. "Denver, CO". Infer from the user request when possible.'),
-      gl: import_zod20.z.string().length(2).default("us").describe("Google country code inferred from location."),
-      hl: import_zod20.z.string().length(2).default("en").describe("Language inferred from user request."),
-      includeReviews: import_zod20.z.boolean().default(false).describe("Whether to fetch individual review cards"),
-      maxReviews: import_zod20.z.number().int().min(1).max(500).default(50).describe("Max review cards to return (requires includeReviews: true)")
+      businessName: import_zod25.z.string().min(1).describe('Business name only. If user says "Elite Roofing Denver CO", use businessName="Elite Roofing" and location="Denver, CO".'),
+      location: import_zod25.z.string().min(1).describe('City/region/country where the business should be searched, e.g. "Denver, CO". Infer from the user request when possible.'),
+      gl: import_zod25.z.string().length(2).default("us").describe("Google country code inferred from location."),
+      hl: import_zod25.z.string().length(2).default("en").describe("Language inferred from user request."),
+      includeReviews: import_zod25.z.boolean().default(false).describe("Whether to fetch individual review cards"),
+      maxReviews: import_zod25.z.number().int().min(1).max(500).default(50).describe("Max review cards to return (requires includeReviews: true)")
     };
     MapsSearchInputSchema = {
-      query: import_zod20.z.string().min(1).describe('Business category, niche, keyword, or search term. If the user says "roofers in Denver CO", use query="roofers" and location="Denver, CO". Do not put the location here when it can be separated.'),
-      location: import_zod20.z.string().optional().describe('City, region, country, or service area for the Maps search, e.g. "Denver, CO". Infer from the user request when present.'),
-      gl: import_zod20.z.string().length(2).default("us").describe("Google country code inferred from location."),
-      hl: import_zod20.z.string().length(2).default("en").describe("Language inferred from user request."),
-      maxResults: import_zod20.z.number().int().min(1).max(50).default(10).describe("Number of Google Maps business/profile candidates to return. Default 10. Maximum 50. Use 10 unless the user asks for more."),
-      proxyMode: import_zod20.z.enum(["location", "configured", "none"]).default("location").describe("Proxy targeting mode. Use location by default for US city/state Maps searches; retryable failures create a new residential proxy ID and new browser session for up to 5 attempts. Use configured for the server proxy ID, and none only for local direct-network debugging."),
-      proxyZip: import_zod20.z.string().regex(/^\d{5}$/).optional().describe("Optional US ZIP override for residential location proxy targeting. Use when the user gives a specific ZIP or city-center ZIP."),
-      debug: import_zod20.z.boolean().default(false).describe("Include sanitized browser/proxy diagnostics when debugging Maps localization, CAPTCHA, or proxy behavior.")
+      query: import_zod25.z.string().min(1).describe('Business category, niche, keyword, or search term. If the user says "roofers in Denver CO", use query="roofers" and location="Denver, CO". Do not put the location here when it can be separated.'),
+      location: import_zod25.z.string().optional().describe('City, region, country, or service area for the Maps search, e.g. "Denver, CO". Infer from the user request when present.'),
+      gl: import_zod25.z.string().length(2).default("us").describe("Google country code inferred from location."),
+      hl: import_zod25.z.string().length(2).default("en").describe("Language inferred from user request."),
+      maxResults: import_zod25.z.number().int().min(1).max(50).default(10).describe("Number of Google Maps business/profile candidates to return. Default 10. Maximum 50. Use 10 unless the user asks for more."),
+      proxyMode: import_zod25.z.enum(["location", "configured", "none"]).default("location").describe("Proxy targeting mode. Use location by default for US city/state Maps searches; retryable failures create a new residential proxy ID and new browser session for up to 5 attempts. Use configured for the server proxy ID, and none only for local direct-network debugging."),
+      proxyZip: import_zod25.z.string().regex(/^\d{5}$/).optional().describe("Optional US ZIP override for residential location proxy targeting. Use when the user gives a specific ZIP or city-center ZIP."),
+      debug: import_zod25.z.boolean().default(false).describe("Include sanitized browser/proxy diagnostics when debugging Maps localization, CAPTCHA, or proxy behavior.")
     };
     DirectoryWorkflowInputSchema = {
-      query: import_zod20.z.string().min(1).describe("Business category, niche, or keyword to search on Google Maps for every selected market, e.g. roofers, dentists, med spas. Do not include the city here."),
-      state: import_zod20.z.string().min(2).default("TN").describe("US state abbreviation or state name used to select Census places, e.g. TN or Tennessee."),
-      minPopulation: import_zod20.z.number().int().min(0).default(1e5).describe('Minimum Census place population for market selection. Use 100000 for "cities above 100k population".'),
-      populationYear: import_zod20.z.number().int().min(2020).max(2025).default(2025).describe("Census population estimate year from the 2020-2025 Population Estimates Program city/place dataset."),
-      maxCities: import_zod20.z.number().int().min(1).max(100).default(25).describe("Maximum number of markets to process after sorting by population descending."),
-      maxResultsPerCity: import_zod20.z.number().int().min(1).max(50).default(50).describe("Google Maps business/profile candidates to collect for each city. Maximum 50."),
-      concurrency: import_zod20.z.number().int().min(1).max(5).default(5).describe("How many city Maps searches to run in parallel. Use 5 for broad directory batches unless debugging."),
-      includeZipGroups: import_zod20.z.boolean().default(true).describe("Attach ZIP groups from a configured US ZIPS CSV when available. Set MCP_SCRAPER_USZIPS_CSV_PATH on the API server or pass usZipsCsvPath in local/test mode."),
-      usZipsCsvPath: import_zod20.z.string().optional().describe("Local/test-only path to a US ZIPS CSV with state_abbr, zipcode, county, city columns, such as Lead Magician tools/analytics/data/uszips.csv. Deployed APIs should use MCP_SCRAPER_USZIPS_CSV_PATH instead."),
-      saveCsv: import_zod20.z.boolean().default(true).describe("Save a directory-ready CSV to the MCP Scraper output directory and return its path. CSV rows include source_location, result_position, business_name, review_stars, category, address, phone, hours_status, website_url, directions_url, place_url, CID fields, population, and ZIP groups."),
-      proxyMode: import_zod20.z.enum(["location", "configured", "none"]).default("location").describe("Proxy targeting mode for every city Maps search. Use location by default for US city/state batches; retryable failures create a new residential proxy ID and new browser session for up to 5 attempts per city. Use configured for the server proxy ID, and none only for local direct-network debugging."),
-      proxyZip: import_zod20.z.string().regex(/^\d{5}$/).optional().describe("Optional ZIP override for proxy targeting. Normally omit it so each city can use its Lead Magician ZIP group or city/state location."),
-      debug: import_zod20.z.boolean().default(false).describe("Include sanitized browser/proxy diagnostics in each Maps browser session when supported.")
+      query: import_zod25.z.string().min(1).describe("Business category, niche, or keyword to search on Google Maps for every selected market, e.g. roofers, dentists, med spas. Do not include the city here."),
+      state: import_zod25.z.string().min(2).default("TN").describe("US state abbreviation or state name used to select Census places, e.g. TN or Tennessee."),
+      minPopulation: import_zod25.z.number().int().min(0).default(1e5).describe('Minimum Census place population for market selection. Use 100000 for "cities above 100k population".'),
+      populationYear: import_zod25.z.number().int().min(2020).max(2025).default(2025).describe("Census population estimate year from the 2020-2025 Population Estimates Program city/place dataset."),
+      maxCities: import_zod25.z.number().int().min(1).max(100).default(25).describe("Maximum number of markets to process after sorting by population descending."),
+      maxResultsPerCity: import_zod25.z.number().int().min(1).max(50).default(50).describe("Google Maps business/profile candidates to collect for each city. Maximum 50."),
+      concurrency: import_zod25.z.number().int().min(1).max(5).default(5).describe("How many city Maps searches to run in parallel. Use 5 for broad directory batches unless debugging."),
+      includeZipGroups: import_zod25.z.boolean().default(true).describe("Attach ZIP groups from a configured US ZIPS CSV when available. Set MCP_SCRAPER_USZIPS_CSV_PATH on the API server or pass usZipsCsvPath in local/test mode."),
+      usZipsCsvPath: import_zod25.z.string().optional().describe("Local/test-only path to a US ZIPS CSV with state_abbr, zipcode, county, city columns, such as Lead Magician tools/analytics/data/uszips.csv. Deployed APIs should use MCP_SCRAPER_USZIPS_CSV_PATH instead."),
+      saveCsv: import_zod25.z.boolean().default(true).describe("Save a directory-ready CSV to the MCP Scraper output directory and return its path. CSV rows include source_location, result_position, business_name, review_stars, review_count, category, address, phone, hours_status, website_url, directions_url, place_url, CID fields, population, and ZIP groups."),
+      proxyMode: import_zod25.z.enum(["location", "configured", "none"]).default("location").describe("Proxy targeting mode for every city Maps search. Use location by default for US city/state batches; retryable failures create a new residential proxy ID and new browser session for up to 5 attempts per city. Use configured for the server proxy ID, and none only for local direct-network debugging."),
+      proxyZip: import_zod25.z.string().regex(/^\d{5}$/).optional().describe("Optional ZIP override for proxy targeting. Normally omit it so each city can use its Lead Magician ZIP group or city/state location."),
+      debug: import_zod25.z.boolean().default(false).describe("Include sanitized browser/proxy diagnostics in each Maps browser session when supported.")
     };
-    RankTrackerModeSchema = import_zod20.z.enum(["maps", "organic", "ai_overview", "paa"]);
+    RankTrackerModeSchema = import_zod25.z.enum(["maps", "organic", "ai_overview", "paa"]);
     RankTrackerBlueprintInputSchema = {
-      projectName: import_zod20.z.string().min(1).optional().describe("Optional name for the rank tracker project, client, or campaign."),
-      targetDomain: import_zod20.z.string().min(1).optional().describe("Primary domain to track in organic results, AI Overview citations, and PAA sources, e.g. example.com."),
-      targetBusinessName: import_zod20.z.string().min(1).optional().describe("Primary Google Business Profile or brand/business name to match in Maps results. Required for reliable Maps rank tracking."),
-      trackingModes: import_zod20.z.array(RankTrackerModeSchema).min(1).max(4).default(["maps", "organic", "ai_overview", "paa"]).describe("Rank tracker surfaces to build. maps uses directory_workflow/maps_search. organic uses search_serp. ai_overview uses search_serp/harvest_paa. paa uses harvest_paa source presence."),
-      keywords: import_zod20.z.array(import_zod20.z.string().min(1)).max(200).default([]).describe("Seed keywords or service queries to track. Leave empty when the downstream AI should create the keyword table from user input."),
-      locations: import_zod20.z.array(import_zod20.z.string().min(1)).max(100).default([]).describe("Markets, cities, ZIPs, or service areas to track. Use city/state strings like Denver, CO for localized SERP and Maps checks."),
-      competitors: import_zod20.z.array(import_zod20.z.string().min(1)).max(100).default([]).describe("Optional competitor domains or business names to persist as comparison targets."),
-      database: import_zod20.z.enum(["postgres", "neon", "supabase", "sqlite", "mysql"]).default("postgres").describe("Database family the downstream AI should target when generating migrations."),
-      scheduleCadence: import_zod20.z.enum(["daily", "weekly", "monthly", "custom"]).default("weekly").describe("Default recurring rank check cadence for the generated cron/heartbeat plan."),
-      customCron: import_zod20.z.string().min(1).optional().describe("Cron expression to use when scheduleCadence is custom."),
-      timezone: import_zod20.z.string().min(1).default("UTC").describe("IANA timezone for scheduled rank checks, e.g. America/Denver."),
-      includeCron: import_zod20.z.boolean().default(true).describe("Include a cron or heartbeat worker plan. Keep true for production rank trackers."),
-      includeDashboard: import_zod20.z.boolean().default(true).describe("Include dashboard/reporting requirements in the generated prompt."),
-      includeAlerts: import_zod20.z.boolean().default(true).describe("Include alert rules for rank movement and SERP feature gains/losses."),
-      notes: import_zod20.z.string().max(4e3).optional().describe("Extra product, client, stack, or hosting requirements to include in the implementation prompt.")
+      projectName: import_zod25.z.string().min(1).optional().describe("Optional name for the rank tracker project, client, or campaign."),
+      targetDomain: import_zod25.z.string().min(1).optional().describe("Primary domain to track in organic results, AI Overview citations, and PAA sources, e.g. example.com."),
+      targetBusinessName: import_zod25.z.string().min(1).optional().describe("Primary Google Business Profile or brand/business name to match in Maps results. Required for reliable Maps rank tracking."),
+      trackingModes: import_zod25.z.array(RankTrackerModeSchema).min(1).max(4).default(["maps", "organic", "ai_overview", "paa"]).describe("Rank tracker surfaces to build. maps uses directory_workflow/maps_search. organic uses search_serp. ai_overview uses search_serp/harvest_paa. paa uses harvest_paa source presence."),
+      keywords: import_zod25.z.array(import_zod25.z.string().min(1)).max(200).default([]).describe("Seed keywords or service queries to track. Leave empty when the downstream AI should create the keyword table from user input."),
+      locations: import_zod25.z.array(import_zod25.z.string().min(1)).max(100).default([]).describe("Markets, cities, ZIPs, or service areas to track. Use city/state strings like Denver, CO for localized SERP and Maps checks."),
+      competitors: import_zod25.z.array(import_zod25.z.string().min(1)).max(100).default([]).describe("Optional competitor domains or business names to persist as comparison targets."),
+      database: import_zod25.z.enum(["postgres", "neon", "supabase", "sqlite", "mysql"]).default("postgres").describe("Database family the downstream AI should target when generating migrations."),
+      scheduleCadence: import_zod25.z.enum(["daily", "weekly", "monthly", "custom"]).default("weekly").describe("Default recurring rank check cadence for the generated cron/heartbeat plan."),
+      customCron: import_zod25.z.string().min(1).optional().describe("Cron expression to use when scheduleCadence is custom."),
+      timezone: import_zod25.z.string().min(1).default("UTC").describe("IANA timezone for scheduled rank checks, e.g. America/Denver."),
+      includeCron: import_zod25.z.boolean().default(true).describe("Include a cron or heartbeat worker plan. Keep true for production rank trackers."),
+      includeDashboard: import_zod25.z.boolean().default(true).describe("Include dashboard/reporting requirements in the generated prompt."),
+      includeAlerts: import_zod25.z.boolean().default(true).describe("Include alert rules for rank movement and SERP feature gains/losses."),
+      notes: import_zod25.z.string().max(4e3).optional().describe("Extra product, client, stack, or hosting requirements to include in the implementation prompt.")
     };
-    NullableString = import_zod20.z.string().nullable();
-    MapsSearchAttemptOutput = import_zod20.z.object({
-      attemptNumber: import_zod20.z.number().int().min(1),
-      maxAttempts: import_zod20.z.number().int().min(1),
-      status: import_zod20.z.enum(["ok", "failed"]),
-      outcome: import_zod20.z.string(),
-      willRetry: import_zod20.z.boolean(),
-      durationMs: import_zod20.z.number().int().min(0),
-      resultCount: import_zod20.z.number().int().min(0),
+    NullableString = import_zod25.z.string().nullable();
+    MapsSearchAttemptOutput = import_zod25.z.object({
+      attemptNumber: import_zod25.z.number().int().min(1),
+      maxAttempts: import_zod25.z.number().int().min(1),
+      status: import_zod25.z.enum(["ok", "failed"]),
+      outcome: import_zod25.z.string(),
+      willRetry: import_zod25.z.boolean(),
+      durationMs: import_zod25.z.number().int().min(0),
+      resultCount: import_zod25.z.number().int().min(0),
       error: NullableString,
-      proxyMode: import_zod20.z.enum(["location", "configured", "none"]),
-      proxyResolutionSource: import_zod20.z.enum(["disabled", "location_reused", "location_created", "configured_fallback", "unavailable"]).nullable(),
+      proxyMode: import_zod25.z.enum(["location", "configured", "none"]),
+      proxyResolutionSource: import_zod25.z.enum(["disabled", "location_reused", "location_created", "configured_fallback", "unavailable"]).nullable(),
       proxyIdSuffix: NullableString,
-      proxyTargetLevel: import_zod20.z.enum(["zip", "city", "state"]).nullable(),
+      proxyTargetLevel: import_zod25.z.enum(["zip", "city", "state"]).nullable(),
       proxyTargetLocation: NullableString,
       proxyTargetZip: NullableString,
       browserSessionIdSuffix: NullableString,
@@ -17397,17 +18961,17 @@ var init_mcp_tool_schemas = __esm({
       observedRegion: NullableString
     });
     MapsSearchOutputSchema = {
-      query: import_zod20.z.string(),
-      location: import_zod20.z.string().nullable(),
-      searchQuery: import_zod20.z.string(),
-      searchUrl: import_zod20.z.string().url(),
-      extractedAt: import_zod20.z.string(),
-      requestedMaxResults: import_zod20.z.number().int().min(1).max(50),
-      resultCount: import_zod20.z.number().int().min(0).max(50),
-      results: import_zod20.z.array(import_zod20.z.object({
-        position: import_zod20.z.number().int().min(1),
-        name: import_zod20.z.string(),
-        placeUrl: import_zod20.z.string().url(),
+      query: import_zod25.z.string(),
+      location: import_zod25.z.string().nullable(),
+      searchQuery: import_zod25.z.string(),
+      searchUrl: import_zod25.z.string().url(),
+      extractedAt: import_zod25.z.string(),
+      requestedMaxResults: import_zod25.z.number().int().min(1).max(50),
+      resultCount: import_zod25.z.number().int().min(0).max(50),
+      results: import_zod25.z.array(import_zod25.z.object({
+        position: import_zod25.z.number().int().min(1),
+        name: import_zod25.z.string(),
+        placeUrl: import_zod25.z.string().url(),
         cid: NullableString,
         cidDecimal: NullableString,
         rating: NullableString,
@@ -17418,15 +18982,15 @@ var init_mcp_tool_schemas = __esm({
         hoursStatus: NullableString,
         websiteUrl: NullableString,
         directionsUrl: NullableString,
-        metadata: import_zod20.z.array(import_zod20.z.string())
+        metadata: import_zod25.z.array(import_zod25.z.string())
       })),
-      attempts: import_zod20.z.array(MapsSearchAttemptOutput),
-      durationMs: import_zod20.z.number().int().min(0)
+      attempts: import_zod25.z.array(MapsSearchAttemptOutput),
+      durationMs: import_zod25.z.number().int().min(0)
     };
-    DirectoryMapsBusinessOutput = import_zod20.z.object({
-      position: import_zod20.z.number().int().min(1),
-      name: import_zod20.z.string(),
-      placeUrl: import_zod20.z.string().url(),
+    DirectoryMapsBusinessOutput = import_zod25.z.object({
+      position: import_zod25.z.number().int().min(1),
+      name: import_zod25.z.string(),
+      placeUrl: import_zod25.z.string().url(),
       cid: NullableString,
       cidDecimal: NullableString,
       rating: NullableString,
@@ -17437,113 +19001,113 @@ var init_mcp_tool_schemas = __esm({
       hoursStatus: NullableString,
       websiteUrl: NullableString,
       directionsUrl: NullableString,
-      metadata: import_zod20.z.array(import_zod20.z.string())
+      metadata: import_zod25.z.array(import_zod25.z.string())
     });
     DirectoryWorkflowOutputSchema = {
-      query: import_zod20.z.string(),
-      state: import_zod20.z.string(),
-      minPopulation: import_zod20.z.number().int().min(0),
-      populationYear: import_zod20.z.number().int().min(2020).max(2025),
-      maxResultsPerCity: import_zod20.z.number().int().min(1).max(50),
-      concurrency: import_zod20.z.number().int().min(1).max(5),
-      censusSourceUrl: import_zod20.z.string().url(),
+      query: import_zod25.z.string(),
+      state: import_zod25.z.string(),
+      minPopulation: import_zod25.z.number().int().min(0),
+      populationYear: import_zod25.z.number().int().min(2020).max(2025),
+      maxResultsPerCity: import_zod25.z.number().int().min(1).max(50),
+      concurrency: import_zod25.z.number().int().min(1).max(5),
+      censusSourceUrl: import_zod25.z.string().url(),
       usZipsSourcePath: NullableString,
-      warnings: import_zod20.z.array(import_zod20.z.string()),
-      extractedAt: import_zod20.z.string(),
-      selectedCityCount: import_zod20.z.number().int().min(0),
-      totalResultCount: import_zod20.z.number().int().min(0),
+      warnings: import_zod25.z.array(import_zod25.z.string()),
+      extractedAt: import_zod25.z.string(),
+      selectedCityCount: import_zod25.z.number().int().min(0),
+      totalResultCount: import_zod25.z.number().int().min(0),
       csvPath: NullableString,
-      cities: import_zod20.z.array(import_zod20.z.object({
-        city: import_zod20.z.string(),
-        state: import_zod20.z.string(),
-        location: import_zod20.z.string(),
-        cityKey: import_zod20.z.string(),
-        censusName: import_zod20.z.string(),
-        population: import_zod20.z.number().int().min(0),
-        populationYear: import_zod20.z.number().int().min(2020).max(2025),
-        zips: import_zod20.z.array(import_zod20.z.string()),
-        counties: import_zod20.z.array(import_zod20.z.string()),
-        status: import_zod20.z.enum(["ok", "empty", "failed"]),
+      cities: import_zod25.z.array(import_zod25.z.object({
+        city: import_zod25.z.string(),
+        state: import_zod25.z.string(),
+        location: import_zod25.z.string(),
+        cityKey: import_zod25.z.string(),
+        censusName: import_zod25.z.string(),
+        population: import_zod25.z.number().int().min(0),
+        populationYear: import_zod25.z.number().int().min(2020).max(2025),
+        zips: import_zod25.z.array(import_zod25.z.string()),
+        counties: import_zod25.z.array(import_zod25.z.string()),
+        status: import_zod25.z.enum(["ok", "empty", "failed"]),
         error: NullableString,
-        resultCount: import_zod20.z.number().int().min(0),
-        durationMs: import_zod20.z.number().int().min(0),
-        attempts: import_zod20.z.array(MapsSearchAttemptOutput),
-        results: import_zod20.z.array(DirectoryMapsBusinessOutput)
+        resultCount: import_zod25.z.number().int().min(0),
+        durationMs: import_zod25.z.number().int().min(0),
+        attempts: import_zod25.z.array(MapsSearchAttemptOutput),
+        results: import_zod25.z.array(DirectoryMapsBusinessOutput)
       })),
-      durationMs: import_zod20.z.number().int().min(0)
+      durationMs: import_zod25.z.number().int().min(0)
     };
-    RankTrackerToolPlanOutput = import_zod20.z.object({
-      tool: import_zod20.z.string(),
-      purpose: import_zod20.z.string()
+    RankTrackerToolPlanOutput = import_zod25.z.object({
+      tool: import_zod25.z.string(),
+      purpose: import_zod25.z.string()
     });
-    RankTrackerTableOutput = import_zod20.z.object({
-      name: import_zod20.z.string(),
-      purpose: import_zod20.z.string(),
-      keyColumns: import_zod20.z.array(import_zod20.z.string())
+    RankTrackerTableOutput = import_zod25.z.object({
+      name: import_zod25.z.string(),
+      purpose: import_zod25.z.string(),
+      keyColumns: import_zod25.z.array(import_zod25.z.string())
     });
-    RankTrackerCronJobOutput = import_zod20.z.object({
-      name: import_zod20.z.string(),
-      purpose: import_zod20.z.string(),
-      modes: import_zod20.z.array(RankTrackerModeSchema),
-      recommendedTools: import_zod20.z.array(import_zod20.z.string())
+    RankTrackerCronJobOutput = import_zod25.z.object({
+      name: import_zod25.z.string(),
+      purpose: import_zod25.z.string(),
+      modes: import_zod25.z.array(RankTrackerModeSchema),
+      recommendedTools: import_zod25.z.array(import_zod25.z.string())
     });
     RankTrackerBlueprintOutputSchema = {
-      projectName: import_zod20.z.string(),
+      projectName: import_zod25.z.string(),
       targetDomain: NullableString,
       targetBusinessName: NullableString,
-      trackingModes: import_zod20.z.array(RankTrackerModeSchema),
-      database: import_zod20.z.string(),
-      recommendedTools: import_zod20.z.array(RankTrackerToolPlanOutput),
-      tables: import_zod20.z.array(RankTrackerTableOutput),
-      cron: import_zod20.z.object({
-        enabled: import_zod20.z.boolean(),
-        cadence: import_zod20.z.string(),
-        expression: import_zod20.z.string(),
-        timezone: import_zod20.z.string(),
-        jobs: import_zod20.z.array(RankTrackerCronJobOutput)
+      trackingModes: import_zod25.z.array(RankTrackerModeSchema),
+      database: import_zod25.z.string(),
+      recommendedTools: import_zod25.z.array(RankTrackerToolPlanOutput),
+      tables: import_zod25.z.array(RankTrackerTableOutput),
+      cron: import_zod25.z.object({
+        enabled: import_zod25.z.boolean(),
+        cadence: import_zod25.z.string(),
+        expression: import_zod25.z.string(),
+        timezone: import_zod25.z.string(),
+        jobs: import_zod25.z.array(RankTrackerCronJobOutput)
       }),
-      metrics: import_zod20.z.array(import_zod20.z.string()),
-      implementationPrompt: import_zod20.z.string()
+      metrics: import_zod25.z.array(import_zod25.z.string()),
+      implementationPrompt: import_zod25.z.string()
     };
-    OrganicResultOutput = import_zod20.z.object({
-      position: import_zod20.z.number().int(),
-      title: import_zod20.z.string(),
-      url: import_zod20.z.string(),
-      domain: import_zod20.z.string(),
+    OrganicResultOutput = import_zod25.z.object({
+      position: import_zod25.z.number().int(),
+      title: import_zod25.z.string(),
+      url: import_zod25.z.string(),
+      domain: import_zod25.z.string(),
       snippet: NullableString
     });
-    AiOverviewOutput = import_zod20.z.object({
-      detected: import_zod20.z.boolean(),
+    AiOverviewOutput = import_zod25.z.object({
+      detected: import_zod25.z.boolean(),
       text: NullableString
     }).nullable();
-    EntityIdsOutput = import_zod20.z.object({
-      kgIds: import_zod20.z.array(import_zod20.z.string()),
-      cids: import_zod20.z.array(import_zod20.z.string()),
-      gcids: import_zod20.z.array(import_zod20.z.string())
+    EntityIdsOutput = import_zod25.z.object({
+      kgIds: import_zod25.z.array(import_zod25.z.string()),
+      cids: import_zod25.z.array(import_zod25.z.string()),
+      gcids: import_zod25.z.array(import_zod25.z.string())
     }).nullable();
     HarvestPaaOutputSchema = {
-      query: import_zod20.z.string(),
+      query: import_zod25.z.string(),
       location: NullableString,
-      questionCount: import_zod20.z.number().int().min(0),
+      questionCount: import_zod25.z.number().int().min(0),
       completionStatus: NullableString,
-      questions: import_zod20.z.array(import_zod20.z.object({
-        question: import_zod20.z.string(),
+      questions: import_zod25.z.array(import_zod25.z.object({
+        question: import_zod25.z.string(),
         answer: NullableString,
         sourceTitle: NullableString,
         sourceSite: NullableString
       })),
-      organicResults: import_zod20.z.array(OrganicResultOutput),
+      organicResults: import_zod25.z.array(OrganicResultOutput),
       aiOverview: AiOverviewOutput,
       entityIds: EntityIdsOutput,
-      durationMs: import_zod20.z.number().min(0).nullable()
+      durationMs: import_zod25.z.number().min(0).nullable()
     };
     SearchSerpOutputSchema = {
-      query: import_zod20.z.string(),
+      query: import_zod25.z.string(),
       location: NullableString,
-      organicResults: import_zod20.z.array(OrganicResultOutput),
-      localPack: import_zod20.z.array(import_zod20.z.object({
-        position: import_zod20.z.number().int(),
-        name: import_zod20.z.string(),
+      organicResults: import_zod25.z.array(OrganicResultOutput),
+      localPack: import_zod25.z.array(import_zod25.z.object({
+        position: import_zod25.z.number().int(),
+        name: import_zod25.z.string(),
         rating: NullableString,
         reviewCount: NullableString,
         websiteUrl: NullableString
@@ -17552,31 +19116,31 @@ var init_mcp_tool_schemas = __esm({
       entityIds: EntityIdsOutput
     };
     ExtractUrlOutputSchema = {
-      url: import_zod20.z.string(),
+      url: import_zod25.z.string(),
       title: NullableString,
-      headings: import_zod20.z.array(import_zod20.z.object({
-        level: import_zod20.z.number().int(),
-        text: import_zod20.z.string()
+      headings: import_zod25.z.array(import_zod25.z.object({
+        level: import_zod25.z.number().int(),
+        text: import_zod25.z.string()
       })),
-      schemaBlockCount: import_zod20.z.number().int().min(0),
+      schemaBlockCount: import_zod25.z.number().int().min(0),
       entityName: NullableString,
-      entityTypes: import_zod20.z.array(import_zod20.z.string()),
-      napScore: import_zod20.z.number().nullable(),
-      missingSchemaFields: import_zod20.z.array(import_zod20.z.string()),
+      entityTypes: import_zod25.z.array(import_zod25.z.string()),
+      napScore: import_zod25.z.number().nullable(),
+      missingSchemaFields: import_zod25.z.array(import_zod25.z.string()),
       screenshotSaved: NullableString
     };
     ExtractSiteOutputSchema = {
-      url: import_zod20.z.string(),
-      pageCount: import_zod20.z.number().int().min(0),
-      pages: import_zod20.z.array(import_zod20.z.object({
-        url: import_zod20.z.string(),
+      url: import_zod25.z.string(),
+      pageCount: import_zod25.z.number().int().min(0),
+      pages: import_zod25.z.array(import_zod25.z.object({
+        url: import_zod25.z.string(),
         title: NullableString,
-        schemaTypes: import_zod20.z.array(import_zod20.z.string())
+        schemaTypes: import_zod25.z.array(import_zod25.z.string())
       })),
-      durationMs: import_zod20.z.number().min(0)
+      durationMs: import_zod25.z.number().min(0)
     };
     MapsPlaceIntelOutputSchema = {
-      name: import_zod20.z.string(),
+      name: import_zod25.z.string(),
       rating: NullableString,
       reviewCount: NullableString,
       category: NullableString,
@@ -17588,60 +19152,60 @@ var init_mcp_tool_schemas = __esm({
       kgmid: NullableString,
       cidDecimal: NullableString,
       cidUrl: NullableString,
-      lat: import_zod20.z.number().nullable(),
-      lng: import_zod20.z.number().nullable(),
-      reviewsStatus: import_zod20.z.string(),
-      reviewsCollected: import_zod20.z.number().int().min(0),
-      reviewTopics: import_zod20.z.array(import_zod20.z.object({
-        label: import_zod20.z.string(),
-        count: import_zod20.z.string()
+      lat: import_zod25.z.number().nullable(),
+      lng: import_zod25.z.number().nullable(),
+      reviewsStatus: import_zod25.z.string(),
+      reviewsCollected: import_zod25.z.number().int().min(0),
+      reviewTopics: import_zod25.z.array(import_zod25.z.object({
+        label: import_zod25.z.string(),
+        count: import_zod25.z.string()
       }))
     };
     CreditsInfoOutputSchema = {
-      balanceCredits: import_zod20.z.number().nullable(),
-      matchedCost: import_zod20.z.object({
-        label: import_zod20.z.string(),
-        credits: import_zod20.z.number(),
-        unit: import_zod20.z.string(),
+      balanceCredits: import_zod25.z.number().nullable(),
+      matchedCost: import_zod25.z.object({
+        label: import_zod25.z.string(),
+        credits: import_zod25.z.number(),
+        unit: import_zod25.z.string(),
         notes: NullableString
       }).nullable(),
-      costs: import_zod20.z.array(import_zod20.z.object({
-        key: import_zod20.z.string(),
-        label: import_zod20.z.string(),
-        credits: import_zod20.z.number(),
-        unit: import_zod20.z.string(),
+      costs: import_zod25.z.array(import_zod25.z.object({
+        key: import_zod25.z.string(),
+        label: import_zod25.z.string(),
+        credits: import_zod25.z.number(),
+        unit: import_zod25.z.string(),
         notes: NullableString
       })),
-      ledger: import_zod20.z.array(import_zod20.z.object({
-        createdAt: import_zod20.z.string(),
-        operation: import_zod20.z.string(),
-        credits: import_zod20.z.number(),
+      ledger: import_zod25.z.array(import_zod25.z.object({
+        createdAt: import_zod25.z.string(),
+        operation: import_zod25.z.string(),
+        credits: import_zod25.z.number(),
         description: NullableString
       }))
     };
     MapSiteUrlsOutputSchema = {
-      startUrl: import_zod20.z.string(),
-      totalFound: import_zod20.z.number().int().min(0),
-      truncated: import_zod20.z.boolean(),
-      okCount: import_zod20.z.number().int().min(0),
-      redirectCount: import_zod20.z.number().int().min(0),
-      brokenCount: import_zod20.z.number().int().min(0),
-      urls: import_zod20.z.array(import_zod20.z.object({
-        url: import_zod20.z.string(),
-        status: import_zod20.z.number().int().nullable()
+      startUrl: import_zod25.z.string(),
+      totalFound: import_zod25.z.number().int().min(0),
+      truncated: import_zod25.z.boolean(),
+      okCount: import_zod25.z.number().int().min(0),
+      redirectCount: import_zod25.z.number().int().min(0),
+      brokenCount: import_zod25.z.number().int().min(0),
+      urls: import_zod25.z.array(import_zod25.z.object({
+        url: import_zod25.z.string(),
+        status: import_zod25.z.number().int().nullable()
       })),
-      durationMs: import_zod20.z.number().min(0)
+      durationMs: import_zod25.z.number().min(0)
     };
     YoutubeHarvestOutputSchema = {
-      mode: import_zod20.z.string(),
-      videoCount: import_zod20.z.number().int().min(0),
-      channel: import_zod20.z.object({
+      mode: import_zod25.z.string(),
+      videoCount: import_zod25.z.number().int().min(0),
+      channel: import_zod25.z.object({
         title: NullableString,
         subscriberCount: NullableString
       }).nullable(),
-      videos: import_zod20.z.array(import_zod20.z.object({
-        videoId: import_zod20.z.string(),
-        title: import_zod20.z.string(),
+      videos: import_zod25.z.array(import_zod25.z.object({
+        videoId: import_zod25.z.string(),
+        title: import_zod25.z.string(),
         channelName: NullableString,
         views: NullableString,
         duration: NullableString,
@@ -17649,21 +19213,21 @@ var init_mcp_tool_schemas = __esm({
       }))
     };
     FacebookAdSearchOutputSchema = {
-      query: import_zod20.z.string(),
-      advertiserCount: import_zod20.z.number().int().min(0),
-      advertisers: import_zod20.z.array(import_zod20.z.object({
+      query: import_zod25.z.string(),
+      advertiserCount: import_zod25.z.number().int().min(0),
+      advertisers: import_zod25.z.array(import_zod25.z.object({
         name: NullableString,
-        adCount: import_zod20.z.number().int().nullable(),
+        adCount: import_zod25.z.number().int().nullable(),
         libraryId: NullableString
       }))
     };
     FacebookPageIntelOutputSchema = {
       advertiserName: NullableString,
-      totalAds: import_zod20.z.number().int().min(0),
-      activeCount: import_zod20.z.number().int().min(0),
-      videoCount: import_zod20.z.number().int().min(0),
-      imageCount: import_zod20.z.number().int().min(0),
-      ads: import_zod20.z.array(import_zod20.z.object({
+      totalAds: import_zod25.z.number().int().min(0),
+      activeCount: import_zod25.z.number().int().min(0),
+      videoCount: import_zod25.z.number().int().min(0),
+      imageCount: import_zod25.z.number().int().min(0),
+      ads: import_zod25.z.array(import_zod25.z.object({
         libraryId: NullableString,
         status: NullableString,
         creativeType: NullableString,
@@ -17671,58 +19235,58 @@ var init_mcp_tool_schemas = __esm({
         cta: NullableString,
         startDate: NullableString,
         videoUrl: NullableString,
-        variations: import_zod20.z.number().int().nullable()
+        variations: import_zod25.z.number().int().nullable()
       }))
     };
     CreditsInfoInputSchema = {
-      item: import_zod20.z.string().optional().describe('Optional tool, action, or feature to look up, e.g. "maps reviews", "extract_url", or "YouTube transcription"'),
-      includeLedger: import_zod20.z.boolean().default(false).describe("Whether to include recent credit ledger entries")
+      item: import_zod25.z.string().optional().describe('Optional tool, action, or feature to look up, e.g. "maps reviews", "extract_url", or "YouTube transcription"'),
+      includeLedger: import_zod25.z.boolean().default(false).describe("Whether to include recent credit ledger entries")
     };
     SearchSerpInputSchema = {
-      query: import_zod20.z.string().min(1).describe('Core search topic only. Separate location when possible. If user says "best dentist in Brooklyn NY serp", use query="best dentist" and location="Brooklyn, NY".'),
-      location: import_zod20.z.string().optional().describe("City, region, or country for geo-targeted results, inferred from user request when present."),
-      gl: import_zod20.z.string().length(2).default("us").describe("Google country code inferred from location or user language."),
-      hl: import_zod20.z.string().default("en").describe("Google interface/content language inferred from user request."),
-      device: import_zod20.z.enum(["desktop", "mobile"]).default("desktop").describe("SERP device context. Use desktop by default; use mobile only when the user asks for mobile rankings."),
-      proxyMode: import_zod20.z.enum(["location", "configured", "none"]).default("location").describe("Proxy targeting mode. Use location by default for US city/state SERPs; it creates a fresh residential proxy ID per attempt. If Google shows a CAPTCHA/challenge, browser-service sessions briefly wait for the automatic solver first, then retry with a fresh proxy/session if the challenge does not clear. Also retries proxy tunnel failure and wrong-location evidence before returning. Use configured only for the static configured proxy. Use none only for direct-network debugging."),
-      proxyZip: import_zod20.z.string().regex(/^\d{5}$/).optional().describe("Optional US ZIP override for residential location proxy targeting. Use when the user gives a specific ZIP or when city-center targeting needs to be forced. With proxyMode location this ZIP is used for each fresh proxy attempt."),
-      debug: import_zod20.z.boolean().default(false).describe("Include sanitized browser/session/location diagnostics in the response. Use true when debugging localization, CAPTCHA, or proxy behavior."),
-      pages: import_zod20.z.number().int().min(1).max(2).default(1).describe("Number of result pages to fetch (1\u20132)")
+      query: import_zod25.z.string().min(1).describe('Core search topic only. Separate location when possible. If user says "best dentist in Brooklyn NY serp", use query="best dentist" and location="Brooklyn, NY".'),
+      location: import_zod25.z.string().optional().describe("City, region, or country for geo-targeted results, inferred from user request when present."),
+      gl: import_zod25.z.string().length(2).default("us").describe("Google country code inferred from location or user language."),
+      hl: import_zod25.z.string().default("en").describe("Google interface/content language inferred from user request."),
+      device: import_zod25.z.enum(["desktop", "mobile"]).default("desktop").describe("SERP device context. Use desktop by default; use mobile only when the user asks for mobile rankings."),
+      proxyMode: import_zod25.z.enum(["location", "configured", "none"]).default("location").describe("Proxy targeting mode. Use location by default for US city/state SERPs; it creates a fresh residential proxy ID per attempt. If Google shows a CAPTCHA/challenge, browser-service sessions briefly wait for the automatic solver first, then retry with a fresh proxy/session if the challenge does not clear. Also retries proxy tunnel failure and wrong-location evidence before returning. Use configured only for the static configured proxy. Use none only for direct-network debugging."),
+      proxyZip: import_zod25.z.string().regex(/^\d{5}$/).optional().describe("Optional US ZIP override for residential location proxy targeting. Use when the user gives a specific ZIP or when city-center targeting needs to be forced. With proxyMode location this ZIP is used for each fresh proxy attempt."),
+      debug: import_zod25.z.boolean().default(false).describe("Include sanitized browser/session/location diagnostics in the response. Use true when debugging localization, CAPTCHA, or proxy behavior."),
+      pages: import_zod25.z.number().int().min(1).max(2).default(1).describe("Number of result pages to fetch (1\u20132)")
     };
     CaptureSerpSnapshotInputSchema = {
-      query: import_zod20.z.string().min(1).describe("Core search query to capture as a structured SERP Intelligence snapshot. Separate the place into location when the user gives a city, region, country, or ZIP."),
-      location: import_zod20.z.string().optional().describe("City, region, country, or service area used for localized Google results. MCP Scraper records location evidence; UULE alone is not proof of localization."),
-      gl: import_zod20.z.string().length(2).default("us").describe("Google country code inferred from the requested market, e.g. us, gb, ca, au."),
-      hl: import_zod20.z.string().default("en").describe("Google interface/content language inferred from the user request."),
-      device: import_zod20.z.enum(["desktop", "mobile"]).default("desktop").describe("SERP device context. Use mobile only when the user asks for mobile rankings or mobile SERP evidence."),
-      proxyMode: import_zod20.z.enum(["location", "configured", "none"]).default("location").describe("Proxy behavior for capture. Use location for localized US residential evidence; it creates a fresh proxy ID per attempt. If Google shows a CAPTCHA/challenge, browser-service sessions briefly wait for the automatic solver first, then retry with a fresh proxy/session if the challenge does not clear. Also retries proxy tunnel failure and wrong-location evidence before returning. Use configured only for the static residential proxy, and none only for direct-network debugging."),
-      proxyZip: import_zod20.z.string().regex(/^\d{5}$/).optional().describe("Optional US ZIP override for residential location proxy targeting when a precise city-center or ZIP proxy is needed. With proxyMode location this ZIP is used for each fresh proxy attempt."),
-      pages: import_zod20.z.number().int().min(1).max(2).default(1).describe("Number of Google result pages to capture. Use 1 normally and 2 only when the user needs deeper ranking evidence."),
-      debug: import_zod20.z.boolean().default(false).describe("Include sanitized browser, proxy, and location diagnostics. Use true when debugging localization, CAPTCHA, proxy selection, or capture reliability."),
-      includePageSnapshots: import_zod20.z.boolean().default(false).describe("Also capture ranking-page snapshots for selected SERP URLs through the same product capture path."),
-      pageSnapshotLimit: import_zod20.z.number().int().min(0).max(10).default(0).describe("Maximum ranking-page snapshots to capture when includePageSnapshots is true. Use 0 when only SERP evidence is needed.")
+      query: import_zod25.z.string().min(1).describe("Core search query to capture as a structured SERP Intelligence snapshot. Separate the place into location when the user gives a city, region, country, or ZIP."),
+      location: import_zod25.z.string().optional().describe("City, region, country, or service area used for localized Google results. MCP Scraper records location evidence; UULE alone is not proof of localization."),
+      gl: import_zod25.z.string().length(2).default("us").describe("Google country code inferred from the requested market, e.g. us, gb, ca, au."),
+      hl: import_zod25.z.string().default("en").describe("Google interface/content language inferred from the user request."),
+      device: import_zod25.z.enum(["desktop", "mobile"]).default("desktop").describe("SERP device context. Use mobile only when the user asks for mobile rankings or mobile SERP evidence."),
+      proxyMode: import_zod25.z.enum(["location", "configured", "none"]).default("location").describe("Proxy behavior for capture. Use location for localized US residential evidence; it creates a fresh proxy ID per attempt. If Google shows a CAPTCHA/challenge, browser-service sessions briefly wait for the automatic solver first, then retry with a fresh proxy/session if the challenge does not clear. Also retries proxy tunnel failure and wrong-location evidence before returning. Use configured only for the static residential proxy, and none only for direct-network debugging."),
+      proxyZip: import_zod25.z.string().regex(/^\d{5}$/).optional().describe("Optional US ZIP override for residential location proxy targeting when a precise city-center or ZIP proxy is needed. With proxyMode location this ZIP is used for each fresh proxy attempt."),
+      pages: import_zod25.z.number().int().min(1).max(2).default(1).describe("Number of Google result pages to capture. Use 1 normally and 2 only when the user needs deeper ranking evidence."),
+      debug: import_zod25.z.boolean().default(false).describe("Include sanitized browser, proxy, and location diagnostics. Use true when debugging localization, CAPTCHA, proxy selection, or capture reliability."),
+      includePageSnapshots: import_zod25.z.boolean().default(false).describe("Also capture ranking-page snapshots for selected SERP URLs through the same product capture path."),
+      pageSnapshotLimit: import_zod25.z.number().int().min(0).max(10).default(0).describe("Maximum ranking-page snapshots to capture when includePageSnapshots is true. Use 0 when only SERP evidence is needed.")
     };
     ScreenshotInputSchema = {
-      url: import_zod20.z.string().url().describe("URL to capture as a full-page screenshot. Use http or https. Pass allowLocal: true to capture localhost or private-network URLs during development."),
-      device: import_zod20.z.enum(["desktop", "mobile"]).default("desktop").describe("Viewport profile. desktop = 1440\xD7900. mobile = 390\xD7844. Use desktop by default; use mobile when the user asks for a mobile view."),
-      allowLocal: import_zod20.z.boolean().default(false).describe("Allow localhost and private-network URLs (127.x, 192.168.x, 10.x, etc.). For local development only \u2014 not for production use.")
+      url: import_zod25.z.string().url().describe("URL to capture as a full-page screenshot. Use http or https. Pass allowLocal: true to capture localhost or private-network URLs during development."),
+      device: import_zod25.z.enum(["desktop", "mobile"]).default("desktop").describe("Viewport profile. desktop = 1440\xD7900. mobile = 390\xD7844. Use desktop by default; use mobile when the user asks for a mobile view."),
+      allowLocal: import_zod25.z.boolean().default(false).describe("Allow localhost and private-network URLs (127.x, 192.168.x, 10.x, etc.). For local development only \u2014 not for production use.")
     };
     CaptureSerpPageSnapshotsInputSchema = {
-      urls: import_zod20.z.array(import_zod20.z.string().url()).min(1).max(25).describe("Public HTTP/HTTPS URLs to capture as SERP Intelligence page snapshots. Do not pass localhost, private IPs, file URLs, or internal admin URLs."),
-      targets: import_zod20.z.array(import_zod20.z.object({
-        url: import_zod20.z.string().url().describe("Public HTTP/HTTPS URL to capture."),
-        sourceKind: import_zod20.z.enum(["organic", "ai_citation", "local_pack_website", "configured_target", "site_subject"]).default("configured_target").describe("Why this page is being captured for SERP Intelligence evidence."),
-        sourcePosition: import_zod20.z.number().int().min(1).optional().describe("Ranking or citation position when the page came from SERP evidence.")
+      urls: import_zod25.z.array(import_zod25.z.string().url()).min(1).max(25).describe("Public HTTP/HTTPS URLs to capture as SERP Intelligence page snapshots. Do not pass localhost, private IPs, file URLs, or internal admin URLs."),
+      targets: import_zod25.z.array(import_zod25.z.object({
+        url: import_zod25.z.string().url().describe("Public HTTP/HTTPS URL to capture."),
+        sourceKind: import_zod25.z.enum(["organic", "ai_citation", "local_pack_website", "configured_target", "site_subject"]).default("configured_target").describe("Why this page is being captured for SERP Intelligence evidence."),
+        sourcePosition: import_zod25.z.number().int().min(1).optional().describe("Ranking or citation position when the page came from SERP evidence.")
       }).strict()).min(1).max(25).optional().describe("Structured page snapshot targets. Use this instead of urls when source kind or position should be preserved."),
-      maxConcurrency: import_zod20.z.number().int().min(1).max(5).default(2).describe("Parallel page captures. Use 2 normally; higher values can increase proxy/browser pressure."),
-      timeoutMs: import_zod20.z.number().int().min(1e3).max(6e4).default(15e3).describe("Per-page capture timeout in milliseconds. Increase for slow pages; timeout artifacts are returned as structured capture failures."),
-      debug: import_zod20.z.boolean().default(false).describe("Include sanitized browser/proxy diagnostics for page snapshot debugging. Use true for capture, network, or proxy troubleshooting.")
+      maxConcurrency: import_zod25.z.number().int().min(1).max(5).default(2).describe("Parallel page captures. Use 2 normally; higher values can increase proxy/browser pressure."),
+      timeoutMs: import_zod25.z.number().int().min(1e3).max(6e4).default(15e3).describe("Per-page capture timeout in milliseconds. Increase for slow pages; timeout artifacts are returned as structured capture failures."),
+      debug: import_zod25.z.boolean().default(false).describe("Include sanitized browser/proxy diagnostics for page snapshot debugging. Use true for capture, network, or proxy troubleshooting.")
     };
   }
 });
 
 // src/mcp/rank-tracker-blueprint.ts
-function normalizeDomain(value) {
+function normalizeDomain2(value) {
   const trimmed = value?.trim();
   if (!trimmed) return null;
   try {
@@ -17984,7 +19548,7 @@ function buildPrompt(input, modes, tools, tables, jobs, metrics, expression, tar
 }
 function buildRankTrackerBlueprint(input) {
   const trackingModes = uniqueModes(input.trackingModes);
-  const targetDomain = normalizeDomain(input.targetDomain);
+  const targetDomain = normalizeDomain2(input.targetDomain);
   const targetBusinessName = input.targetBusinessName?.trim() || null;
   const projectName = input.projectName?.trim() || "MCP Scraper Rank Tracker";
   const database = input.database || "postgres";
@@ -18072,7 +19636,7 @@ function localPlanningToolAnnotations(title) {
 function listSavedReports() {
   try {
     const dir = outputBaseDir();
-    return (0, import_node_fs5.readdirSync)(dir).filter((f) => f.endsWith(".md")).map((f) => ({ filename: f, mtimeMs: (0, import_node_fs5.statSync)((0, import_node_path8.join)(dir, f)).mtimeMs })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, 100);
+    return (0, import_node_fs6.readdirSync)(dir).filter((f) => f.endsWith(".md")).map((f) => ({ filename: f, mtimeMs: (0, import_node_fs6.statSync)((0, import_node_path9.join)(dir, f)).mtimeMs })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, 100);
   } catch {
     return [];
   }
@@ -18096,9 +19660,9 @@ function registerSavedReportResources(server) {
     },
     async (uri, variables) => {
       const requested = Array.isArray(variables.filename) ? variables.filename[0] : variables.filename;
-      const filename = (0, import_node_path8.basename)(decodeURIComponent(String(requested ?? "")));
+      const filename = (0, import_node_path9.basename)(decodeURIComponent(String(requested ?? "")));
       if (!filename.endsWith(".md")) throw new Error("Only saved .md reports can be read");
-      const text = (0, import_node_fs5.readFileSync)((0, import_node_path8.join)(outputBaseDir(), filename), "utf8");
+      const text = (0, import_node_fs6.readFileSync)((0, import_node_path9.join)(outputBaseDir(), filename), "utf8");
       return { contents: [{ uri: uri.href, mimeType: "text/markdown", text }] };
     }
   );
@@ -18197,7 +19761,7 @@ function registerPaaExtractorMcpTools(server, executor, options = {}) {
   }, async (input) => formatMapsSearch(await executor.mapsSearch(input), input));
   server.registerTool("directory_workflow", {
     title: "Directory Workflow: Markets + Maps",
-    description: withReportNote('Build directory/prospecting datasets by selecting US city markets from the free Census Population Estimates city/place dataset, optionally joining configured US ZIPS/Lead Magician ZIP groups, then running Google Maps business searches for each city in parallel. Use this when the user wants "all cities over 100k population in a state", "build a directory CSV", "find markets then get Maps data", or similar location-database + Maps workflows. Set minPopulation, state, query, maxResultsPerCity, and concurrency. Use concurrency up to 5 for parallel city sessions. Keep proxyMode as location so each city search creates fresh residential proxy IDs and browser sessions; retryable city failures rotate to a new proxy and new browser session for up to 5 attempts. Saved CSV rows include source_location, result_position, business_name, review_stars, category, address, phone, hours_status, website_url, directions_url, place_url, cid, cid_decimal, city population, and ZIP groups. Structured city results include sanitized attempt telemetry. This workflow captures star ratings from Maps list cards, not profile review counts; use maps_place_intel only when a selected profile needs deeper review details. For local Lead Magician ZIP enrichment, set MCP_SCRAPER_USZIPS_CSV_PATH on the API server or pass usZipsCsvPath only in local/test mode.'),
+    description: withReportNote('Build directory/prospecting datasets by selecting US city markets from the free Census Population Estimates city/place dataset, optionally joining configured US ZIPS/Lead Magician ZIP groups, then running Google Maps business searches for each city in parallel. Use this when the user wants "all cities over 100k population in a state", "build a directory CSV", "find markets then get Maps data", or similar location-database + Maps workflows. Set minPopulation, state, query, maxResultsPerCity, and concurrency. Use concurrency up to 5 for parallel city sessions. Keep proxyMode as location so each city search creates fresh residential proxy IDs and browser sessions; retryable city failures rotate to a new proxy and new browser session for up to 5 attempts. Saved CSV rows include source_location, result_position, business_name, review_stars, review_count, category, address, phone, hours_status, website_url, directions_url, place_url, cid, cid_decimal, city population, and ZIP groups. Structured city results include sanitized attempt telemetry. Use maps_place_intel only when a selected profile needs deeper review topics, profile review count confirmation, or review cards. For local Lead Magician ZIP enrichment, set MCP_SCRAPER_USZIPS_CSV_PATH on the API server or pass usZipsCsvPath only in local/test mode.'),
     inputSchema: DirectoryWorkflowInputSchema,
     outputSchema: DirectoryWorkflowOutputSchema,
     annotations: liveWebToolAnnotations("Directory Workflow: Markets + Maps")
@@ -18223,13 +19787,13 @@ function registerPaaExtractorMcpTools(server, executor, options = {}) {
     }
   }, async (input) => formatCreditsInfo(await executor.creditsInfo(input), input));
 }
-var import_mcp, import_node_fs5, import_node_path8;
+var import_mcp, import_node_fs6, import_node_path9;
 var init_paa_mcp_server = __esm({
   "src/mcp/paa-mcp-server.ts"() {
     "use strict";
     import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-    import_node_fs5 = require("fs");
-    import_node_path8 = require("path");
+    import_node_fs6 = require("fs");
+    import_node_path9 = require("path");
     init_version();
     init_mcp_response_formatter();
     init_mcp_tool_schemas();
@@ -18396,11 +19960,11 @@ function registerSerpIntelligenceCaptureTools(server, executor) {
     annotations: liveWebToolAnnotations("SERP Intelligence Page Snapshots")
   }, async (input) => executor.captureSerpPageSnapshots(input));
 }
-var import_hono8, import_webStandardStreamableHttp, mcpApp;
+var import_hono9, import_webStandardStreamableHttp, mcpApp;
 var init_mcp_routes = __esm({
   "src/mcp/mcp-routes.ts"() {
     "use strict";
-    import_hono8 = require("hono");
+    import_hono9 = require("hono");
     import_webStandardStreamableHttp = require("@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js");
     init_paa_mcp_server();
     init_http_mcp_tool_executor();
@@ -18408,7 +19972,7 @@ var init_mcp_routes = __esm({
     init_db();
     init_mcp_tool_schemas();
     configureReportSaving(false);
-    mcpApp = new import_hono8.Hono();
+    mcpApp = new import_hono9.Hono();
     mcpApp.all("/", async (c) => {
       try {
         const keyOrError = await requireMcpCallerKey(c);
@@ -18480,7 +20044,7 @@ async function migrateBrowserAgent() {
 }
 async function createSessionRow(input) {
   const db = getDb();
-  const id = `bas_${(0, import_node_crypto3.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bas_${(0, import_node_crypto4.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
     sql: `INSERT INTO browser_agent_sessions (id, runtime_session_id, live_view_url, cdp_ws_url, status, label, user_id, last_action_at)
           VALUES (?, ?, ?, ?, 'open', ?, ?, datetime('now'))`,
@@ -18541,7 +20105,7 @@ async function recordAction(input) {
     sql: `INSERT INTO browser_agent_actions (id, session_id, type, params_json, ok, error)
           VALUES (?, ?, ?, ?, ?, ?)`,
     args: [
-      `baa_${(0, import_node_crypto3.randomUUID)().replace(/-/g, "").slice(0, 20)}`,
+      `baa_${(0, import_node_crypto4.randomUUID)().replace(/-/g, "").slice(0, 20)}`,
       input.sessionId,
       input.type,
       input.params == null ? null : JSON.stringify(input.params),
@@ -18581,11 +20145,11 @@ async function listReplayRows(sessionId) {
   });
   return res.rows;
 }
-var import_node_crypto3, _ready;
+var import_node_crypto4, _ready;
 var init_browser_agent_db = __esm({
   "src/api/browser-agent-db.ts"() {
     "use strict";
-    import_node_crypto3 = require("crypto");
+    import_node_crypto4 = require("crypto");
     init_db();
     _ready = false;
   }
@@ -18963,7 +20527,7 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new import_hono9.Hono();
+  const app2 = new import_hono10.Hono();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
@@ -19279,11 +20843,11 @@ function buildBrowserAgentRoutes() {
   });
   return app2;
 }
-var import_hono9, auth;
+var import_hono10, auth;
 var init_browser_agent_routes = __esm({
   "src/api/browser-agent-routes.ts"() {
     "use strict";
-    import_hono9 = require("hono");
+    import_hono10 = require("hono");
     init_api_auth();
     init_errors();
     init_db();
@@ -19496,16 +21060,16 @@ var init_browser_agent_console = __esm({
 });
 
 // src/api/stripe-routes.ts
-var import_stripe, import_hono10, stripe, stripeApp;
+var import_stripe, import_hono11, stripe, stripeApp;
 var init_stripe_routes = __esm({
   "src/api/stripe-routes.ts"() {
     "use strict";
     import_stripe = __toESM(require("stripe"), 1);
-    import_hono10 = require("hono");
+    import_hono11 = require("hono");
     init_db();
     init_rates();
     stripe = new import_stripe.default(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-    stripeApp = new import_hono10.Hono();
+    stripeApp = new import_hono11.Hono();
     stripeApp.post("/webhooks", async (c) => {
       const sig = c.req.header("stripe-signature");
       const body = await c.req.text();
@@ -19606,31 +21170,31 @@ var init_site_audit_worker = __esm({
 });
 
 // src/api/billing-schemas.ts
-var import_zod21, BillingCheckoutBodySchema, FreeCreditBreakdownSchema, BillingBalanceResponseSchema, MonthlyRefreshSweepResultSchema;
+var import_zod26, BillingCheckoutBodySchema, FreeCreditBreakdownSchema, BillingBalanceResponseSchema, MonthlyRefreshSweepResultSchema;
 var init_billing_schemas = __esm({
   "src/api/billing-schemas.ts"() {
     "use strict";
-    import_zod21 = require("zod");
-    BillingCheckoutBodySchema = import_zod21.z.object({
-      priceId: import_zod21.z.string().min(1)
+    import_zod26 = require("zod");
+    BillingCheckoutBodySchema = import_zod26.z.object({
+      priceId: import_zod26.z.string().min(1)
     });
-    FreeCreditBreakdownSchema = import_zod21.z.object({
-      signup_grant_mc: import_zod21.z.number().int().nonnegative(),
-      monthly_refresh_mc: import_zod21.z.number().int().nonnegative(),
-      total_free_mc: import_zod21.z.number().int().nonnegative(),
-      signup_grant_credits: import_zod21.z.number().nonnegative(),
-      monthly_refresh_credits: import_zod21.z.number().nonnegative(),
-      total_free_credits: import_zod21.z.number().nonnegative()
+    FreeCreditBreakdownSchema = import_zod26.z.object({
+      signup_grant_mc: import_zod26.z.number().int().nonnegative(),
+      monthly_refresh_mc: import_zod26.z.number().int().nonnegative(),
+      total_free_mc: import_zod26.z.number().int().nonnegative(),
+      signup_grant_credits: import_zod26.z.number().nonnegative(),
+      monthly_refresh_credits: import_zod26.z.number().nonnegative(),
+      total_free_credits: import_zod26.z.number().nonnegative()
     });
-    BillingBalanceResponseSchema = import_zod21.z.object({
-      balance_mc: import_zod21.z.number().int().nonnegative(),
-      balance_credits: import_zod21.z.number().nonnegative(),
+    BillingBalanceResponseSchema = import_zod26.z.object({
+      balance_mc: import_zod26.z.number().int().nonnegative(),
+      balance_credits: import_zod26.z.number().nonnegative(),
       free_credits: FreeCreditBreakdownSchema,
-      ledger: import_zod21.z.array(import_zod21.z.any())
+      ledger: import_zod26.z.array(import_zod26.z.any())
     });
-    MonthlyRefreshSweepResultSchema = import_zod21.z.object({
-      usersRefreshed: import_zod21.z.number().int().nonnegative(),
-      totalMcGranted: import_zod21.z.number().int().nonnegative()
+    MonthlyRefreshSweepResultSchema = import_zod26.z.object({
+      usersRefreshed: import_zod26.z.number().int().nonnegative(),
+      totalMcGranted: import_zod26.z.number().int().nonnegative()
     });
   }
 });
@@ -19792,14 +21356,14 @@ function getSessionSecret() {
 function safeEqualHex(a, b) {
   if (a.length !== b.length) return false;
   try {
-    return (0, import_node_crypto4.timingSafeEqual)(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+    return (0, import_node_crypto5.timingSafeEqual)(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
   } catch {
     return false;
   }
 }
 function signSession(userId) {
   const payload = String(userId);
-  const sig = (0, import_node_crypto4.createHmac)("sha256", secret()).update(payload).digest("hex");
+  const sig = (0, import_node_crypto5.createHmac)("sha256", secret()).update(payload).digest("hex");
   return `${payload}.${sig}`;
 }
 function verifySession(token) {
@@ -19807,16 +21371,16 @@ function verifySession(token) {
   if (dot === -1) return null;
   const payload = token.slice(0, dot);
   const sig = token.slice(dot + 1);
-  const expected = (0, import_node_crypto4.createHmac)("sha256", secret()).update(payload).digest("hex");
+  const expected = (0, import_node_crypto5.createHmac)("sha256", secret()).update(payload).digest("hex");
   if (!safeEqualHex(sig, expected)) return null;
   const id = parseInt(payload);
   return isNaN(id) ? null : id;
 }
-var import_node_crypto4, isProduction, secret;
+var import_node_crypto5, isProduction, secret;
 var init_session = __esm({
   "src/api/session.ts"() {
     "use strict";
-    import_node_crypto4 = require("crypto");
+    import_node_crypto5 = require("crypto");
     isProduction = () => process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
     secret = () => getSessionSecret();
   }
@@ -20032,7 +21596,7 @@ async function checkHarvestLimits(userId, email, extraSlots = 0) {
   if (active >= limit) return { error: `You have ${active} job${active !== 1 ? "s" : ""} running. Your account allows ${limit} concurrent job${limit !== 1 ? "s" : ""}. Wait for one to finish or add a concurrency slot at mcpscraper.dev/billing.` };
   return null;
 }
-var import_resend, import_hono11, import_hono12, import_factory6, import_cookie, import_stripe2, secureCookies, isProduction2, sessionCookieOptions, requireAllowedOrigin, auth2, adminAuth, sessionAuth, app, STRIPE_API_VERSION, BYPASS_EMAILS, SYNC_HARVEST_TIMEOUT_OVERRIDE_MS;
+var import_resend, import_hono12, import_hono13, import_factory6, import_cookie, import_stripe2, secureCookies, isProduction2, sessionCookieOptions, requireAllowedOrigin, auth2, adminAuth, sessionAuth, app, STRIPE_API_VERSION, BYPASS_EMAILS, SYNC_HARVEST_TIMEOUT_OVERRIDE_MS;
 var init_server = __esm({
   "src/api/server.ts"() {
     "use strict";
@@ -20049,8 +21613,8 @@ var init_server = __esm({
     init_media_extractor();
     init_site_mapper();
     init_site_extractor();
-    import_hono11 = require("hono");
-    import_hono12 = require("inngest/hono");
+    import_hono12 = require("hono");
+    import_hono13 = require("inngest/hono");
     init_client();
     init_site_audit();
     init_site_audit_routes();
@@ -20059,6 +21623,7 @@ var init_server = __esm({
     init_facebook_ad_routes();
     init_maps_routes();
     init_directory_routes();
+    init_workflow_routes();
     init_serp_intelligence_routes();
     init_mcp_routes();
     init_browser_agent_routes();
@@ -20121,7 +21686,7 @@ var init_server = __esm({
       c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
       return next();
     });
-    app = new import_hono11.Hono();
+    app = new import_hono12.Hono();
     STRIPE_API_VERSION = "2026-02-25.clover";
     app.use("*", async (c, next) => {
       await next();
@@ -20719,19 +22284,21 @@ var init_server = __esm({
       }
       const { drainQueue: drainQueue2 } = await Promise.resolve().then(() => (init_worker(), worker_exports));
       const budget = { maxJobs: 10, deadlineMs: Date.now() + 28e4 };
+      const workflowDispatchResult = await dispatchDueWorkflowSchedules(`${new URL(c.req.url).protocol}//${new URL(c.req.url).host}`);
       const [results, sweepResult] = await Promise.all([
         drainQueue2(budget),
         runMonthlyRefreshSweep()
       ]);
-      return c.json({ drained: results.length, results, sweepResult });
+      return c.json({ drained: results.length, results, sweepResult, workflowDispatch: workflowDispatchResult });
     });
-    app.on(["GET", "POST", "PUT"], "/api/inngest", (0, import_hono12.serve)({ client: inngest, functions: [siteAuditFn] }));
+    app.on(["GET", "POST", "PUT"], "/api/inngest", (0, import_hono13.serve)({ client: inngest, functions: [siteAuditFn] }));
     app.route("/api/internal/site-architecture-auditor", siteAuditApp);
     app.route("/youtube", youtubeApp);
     app.route("/screenshot", screenshotApp);
     app.route("/facebook", facebookAdApp);
     app.route("/maps", mapsApp);
     app.route("/directory", directoryApp);
+    app.route("/workflows", workflowApp);
     app.route("/serp-intelligence", serpIntelligenceApp);
     app.route("/mcp", mcpApp);
     app.route("/agent", buildBrowserAgentRoutes());
@@ -20844,10 +22411,10 @@ var init_server = __esm({
 });
 
 // bin/api-server.ts
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 function loadDotEnv() {
   try {
-    for (const line of (0, import_node_fs6.readFileSync)(".env", "utf8").split("\n")) {
+    for (const line of (0, import_node_fs7.readFileSync)(".env", "utf8").split("\n")) {
       const eq = line.indexOf("=");
       if (eq < 1 || line.trimStart().startsWith("#")) continue;
       const k = line.slice(0, eq).trim();