mcp-scraper 0.2.11 → 0.2.13

package/dist/chunk-AYTOCZBS.js

@@ -0,0 +1,1572 @@
+// src/workflows/artifact-writer.ts
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { dirname, join } from "path";
+import { execFile } from "child_process";
+
+// src/directory/csv.ts
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (quoted) {
+      if (ch === '"' && next === '"') {
+        field += '"';
+        i += 1;
+      } else if (ch === '"') {
+        quoted = false;
+      } else {
+        field += ch;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      quoted = true;
+    } else if (ch === ",") {
+      row.push(field);
+      field = "";
+    } else if (ch === "\n") {
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else if (ch !== "\r") {
+      field += ch;
+    }
+  }
+  if (field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+function csvRecords(text) {
+  const rows = parseCsv(text).filter((row) => row.some((cell) => cell.trim() !== ""));
+  const header = rows[0]?.map((cell) => cell.trim()) ?? [];
+  return rows.slice(1).map((row) => {
+    const record = {};
+    for (let i = 0; i < header.length; i += 1) {
+      record[header[i]] = row[i] ?? "";
+    }
+    return record;
+  });
+}
+function csvCell(value) {
+  if (value === null || value === void 0) return "";
+  const text = String(value);
+  return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function rowsToCsv(headers, rows) {
+  return [
+    headers.join(","),
+    ...rows.map((row) => headers.map((header) => csvCell(row[header])).join(","))
+  ].join("\n") + "\n";
+}
+
+// src/lib/slugify.ts
+function slugify(s) {
+  return s.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+
+// src/workflows/artifact-writer.ts
+function workflowOutputBaseDir(outputDir) {
+  return outputDir?.trim() || process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || join(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";
+}
+var 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 = join(baseDir, "workflows", workflowId, `${timestamp()}-${safeSlug(nameSource)}-${safeSlug(runId).slice(0, 20)}`);
+    await mkdir(runDir, { recursive: true });
+    return new _ArtifactWriter(workflowId, title, runId, baseDir, runDir, startedAt, input);
+  }
+  async remember(kind, label, path, rows) {
+    const size = await stat(path).then((s) => s.size).catch(() => void 0);
+    this.artifacts.push({ kind, label, path, bytes: size, rows });
+    return path;
+  }
+  async writeJson(label, relativePath, data) {
+    const path = join(this.runDir, relativePath);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(data, null, 2), "utf8");
+    return this.remember("json", label, path);
+  }
+  async writeText(label, relativePath, text, kind = "markdown") {
+    const path = join(this.runDir, relativePath);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, text, "utf8");
+    return this.remember(kind, label, path);
+  }
+  async writeCsv(label, relativePath, headers, rows) {
+    const path = join(this.runDir, relativePath);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, rowsToCsv(headers, rows), "utf8");
+    return this.remember("csv", label, path, 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 path = join(this.runDir, "manifest.json");
+    await writeFile(path, JSON.stringify(manifest, null, 2), "utf8");
+    await updateWorkflowIndex(manifest, path, this.baseDir);
+    return path;
+  }
+};
+function indexPath(baseDir = workflowOutputBaseDir()) {
+  return join(baseDir, "workflows", "index.json");
+}
+async function readIndex(baseDir) {
+  const path = indexPath(baseDir);
+  if (!existsSync(path)) return { runs: [] };
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return { runs: [] };
+  }
+}
+async function updateWorkflowIndex(manifest, manifestPath, baseDir) {
+  if (manifest.status === "running") return;
+  const path = 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 mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(index, null, 2), "utf8");
+}
+async function listWorkflowReports(outputDir) {
+  return (await readIndex(workflowOutputBaseDir(outputDir))).runs;
+}
+async function findWorkflowReport(id, outputDir) {
+  const runs = await listWorkflowReports(outputDir);
+  if (id === "last") return runs[0] ?? null;
+  return runs.find((run) => run.runId === id) ?? null;
+}
+async function openWorkflowReport(id, outputDir) {
+  const run = await findWorkflowReport(id, outputDir);
+  if (!run?.reportPath) throw new Error(`No report found for "${id}"`);
+  if (platform() === "darwin") {
+    await new Promise((resolve, reject) => {
+      execFile("open", [run.reportPath], (err) => err ? reject(err) : resolve());
+    });
+  }
+  return run.reportPath;
+}
+
+// src/workflows/registry.ts
+import { z as z5 } from "zod";
+
+// src/workflows/http-client.ts
+var WorkflowHttpClient = class {
+  constructor(apiUrl, apiKey, fetchImpl = fetch) {
+    this.apiUrl = apiUrl;
+    this.apiKey = apiKey;
+    this.fetchImpl = fetchImpl;
+  }
+  apiUrl;
+  apiKey;
+  fetchImpl;
+  async post(path, body, timeoutMs = 18e4) {
+    const res = await this.fetchImpl(`${this.apiUrl.replace(/\/$/, "")}${path}`, {
+      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 ${path} failed with ${res.status}`;
+      throw new Error(message);
+    }
+    return data;
+  }
+};
+
+// src/workflows/workflows/agent-packet.ts
+import { z } from "zod";
+
+// 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");
+}
+
+// src/workflows/workflows/agent-packet.ts
+var AgentPacketInputSchema = z.object({
+  keyword: z.string().min(1),
+  domain: z.string().optional(),
+  location: z.string().optional(),
+  maxQuestions: z.number().int().min(1).max(200).default(40),
+  includeSerp: z.boolean().default(true),
+  includePaa: z.boolean().default(true),
+  includeAiOverview: z.boolean().default(true),
+  returnPartial: z.boolean().default(true)
+});
+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 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
+import { z as z2 } from "zod";
+var DirectoryWorkflowCliInputSchema = z2.object({
+  query: z2.string().min(1),
+  state: z2.string().min(2).default("TN"),
+  minPopulation: z2.number().int().min(0).default(1e5),
+  maxCities: z2.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z2.number().int().min(1).max(50).default(20),
+  concurrency: z2.number().int().min(1).max(5).default(5),
+  proxyMode: z2.enum(["location", "configured", "none"]).default("location"),
+  saveCsv: z2.boolean().default(true)
+});
+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 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"
+];
+var 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
+import { z as z3 } from "zod";
+var LocalCompetitiveAuditInputSchema = z3.object({
+  query: z3.string().min(1),
+  state: z3.string().min(2).default("TN"),
+  minPopulation: z3.number().int().min(0).default(1e5),
+  maxCities: z3.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z3.number().int().min(1).max(50).default(20),
+  hydrateTop: z3.number().int().min(0).max(10).default(5),
+  maxReviews: z3.number().int().min(0).max(500).default(50),
+  concurrency: z3.number().int().min(1).max(5).default(5),
+  proxyMode: z3.enum(["location", "configured", "none"]).default("location"),
+  returnPartial: z3.boolean().default(true)
+});
+async function mapLimit(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 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 mapLimit(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/workflows/comparison-briefs.ts
+import { z as z4 } from "zod";
+
+// src/workflows/workflows/seo-workflow-utils.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "about",
+  "after",
+  "also",
+  "because",
+  "been",
+  "best",
+  "both",
+  "from",
+  "have",
+  "into",
+  "more",
+  "most",
+  "near",
+  "only",
+  "over",
+  "than",
+  "that",
+  "their",
+  "them",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "what",
+  "when",
+  "where",
+  "which",
+  "while",
+  "with",
+  "your",
+  "will",
+  "would",
+  "should",
+  "could",
+  "does",
+  "were",
+  "cost",
+  "costs"
+]);
+function normalizeDomain2(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 domainFromUrl2(url) {
+  return normalizeDomain2(url) ?? "";
+}
+function numberFrom2(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 median2(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 textTerms(text, limit = 12) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/)) {
+    if (token.length < 4 || STOP_WORDS.has(token)) continue;
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([term, count]) => `${term} (${count})`).join("; ");
+}
+function classifyQuestion(question) {
+  const q = question.toLowerCase();
+  if (/\b(cost|price|pricing|charge|expensive|cheap)\b/.test(q)) return "cost";
+  if (/\b(best|top|recommended|reviews?|compare|versus|vs)\b/.test(q)) return "comparison";
+  if (/\b(how|steps?|process|way to)\b/.test(q)) return "process";
+  if (/\b(why|worth|important|benefit)\b/.test(q)) return "why";
+  if (/\b(near me|city|local|nearby)\b/.test(q)) return "local";
+  if (/\b(can|does|do|is|are|should|will)\b/.test(q)) return "decision";
+  return "definition";
+}
+function questionRows(paa) {
+  return (paa?.flat ?? []).filter((row) => row.question).map((row, index) => {
+    const url = row.source_cite ?? "";
+    const domain = normalizeDomain2(row.source_site ?? "") ?? domainFromUrl2(url);
+    return {
+      position: index + 1,
+      intent: classifyQuestion(row.question ?? ""),
+      question: row.question ?? "",
+      answer_excerpt: (row.answer ?? "").slice(0, 320),
+      source_title: row.source_title ?? "",
+      source_domain: domain,
+      source_url: url
+    };
+  });
+}
+function sourceDomainRows(rows) {
+  const byDomain = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const domain = String(row.source_domain ?? row.domain ?? "");
+    if (!domain) continue;
+    const entry = byDomain.get(domain) ?? { questions: 0, urls: /* @__PURE__ */ new Set(), intents: /* @__PURE__ */ new Map() };
+    entry.questions += row.question ? 1 : 0;
+    if (row.source_url || row.url) entry.urls.add(String(row.source_url ?? row.url));
+    if (row.intent) entry.intents.set(String(row.intent), (entry.intents.get(String(row.intent)) ?? 0) + 1);
+    byDomain.set(domain, entry);
+  }
+  return [...byDomain.entries()].map(([domain, entry]) => ({
+    domain,
+    question_mentions: entry.questions,
+    source_url_count: entry.urls.size,
+    top_intents: [...entry.intents.entries()].sort((a, b) => b[1] - a[1]).map(([intent, count]) => `${intent} (${count})`).join("; ")
+  })).sort((a, b) => Number(b.question_mentions) - Number(a.question_mentions) || String(a.domain).localeCompare(String(b.domain)));
+}
+function splitSentences(text) {
+  return (text ?? "").replace(/\s+/g, " ").split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter((sentence) => sentence.length > 20).slice(0, 20);
+}
+function classifySentence(sentence) {
+  const s = sentence.toLowerCase();
+  if (/\bis\b|\bare\b|\bmeans\b|\brefers to\b/.test(s)) return "definition";
+  if (/\binclude\b|\bconsider\b|\bfactors?\b|\bcriteria\b/.test(s)) return "criteria";
+  if (/\bfirst\b|\bthen\b|\bsteps?\b|\bprocess\b/.test(s)) return "process";
+  if (/\bvs\b|\bthan\b|\bcompare\b|\bdifference\b/.test(s)) return "comparison";
+  if (/\bcost\b|\bprice\b|\baverage\b|\brange\b/.test(s)) return "cost";
+  return "claim";
+}
+function pageSummaryRow(page, source) {
+  return {
+    position: source.position ?? "",
+    domain: source.domain,
+    url: source.url,
+    serp_title: source.title ?? "",
+    page_title: page.title ?? "",
+    h1: page.h1 ?? "",
+    meta_description: page.metaDescription ?? "",
+    word_count: page.wordCount ?? "",
+    heading_count: page.headings?.length ?? 0,
+    schema_types: (page.schemaTypes ?? []).join("; ")
+  };
+}
+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(Math.max(1, limit), items.length) }, () => worker()));
+  return out;
+}
+
+// src/workflows/workflows/comparison-briefs.ts
+var ProxyModeSchema = z4.enum(["location", "configured", "none"]);
+var MapComparisonInputSchema = z4.object({
+  query: z4.string().min(1),
+  location: z4.string().optional(),
+  state: z4.string().optional(),
+  minPopulation: z4.number().int().min(0).default(1e5),
+  maxCities: z4.number().int().min(1).max(100).default(5),
+  maxResultsPerCity: z4.number().int().min(1).max(50).default(20),
+  hydrateTop: z4.number().int().min(0).max(10).default(5),
+  maxReviews: z4.number().int().min(0).max(500).default(25),
+  concurrency: z4.number().int().min(1).max(5).default(5),
+  proxyMode: ProxyModeSchema.default("location"),
+  returnPartial: z4.boolean().default(true)
+}).refine((input) => input.location || input.state, {
+  message: "Either location or state is required for map-comparison"
+});
+var SerpComparisonInputSchema = z4.object({
+  keyword: z4.string().min(1),
+  domain: z4.string().optional(),
+  url: z4.string().url().optional(),
+  location: z4.string().optional(),
+  maxResults: z4.number().int().min(1).max(20).default(10),
+  maxQuestions: z4.number().int().min(1).max(200).default(40),
+  extractTop: z4.number().int().min(0).max(10).default(5),
+  includePaa: z4.boolean().default(true),
+  includeAiOverview: z4.boolean().default(true),
+  returnPartial: z4.boolean().default(true)
+});
+var PaaExpansionBriefInputSchema = z4.object({
+  keyword: z4.string().min(1),
+  location: z4.string().optional(),
+  maxQuestions: z4.number().int().min(1).max(300).default(80),
+  depth: z4.number().int().min(1).max(6).default(3),
+  returnPartial: z4.boolean().default(true)
+});
+var AiOverviewLanguageInputSchema = z4.object({
+  keyword: z4.string().min(1),
+  domain: z4.string().optional(),
+  url: z4.string().url().optional(),
+  location: z4.string().optional(),
+  maxQuestions: z4.number().int().min(1).max(200).default(40),
+  extractTop: z4.number().int().min(0).max(8).default(3),
+  returnPartial: z4.boolean().default(true)
+});
+function businessRowsFromMaps(location, query, results) {
+  return results.map((result) => ({
+    source_query: query,
+    source_location: location,
+    city: location.split(",")[0]?.trim() ?? location,
+    state: location.split(",")[1]?.trim() ?? "",
+    population: "",
+    result_position: result.position,
+    business_name: result.name,
+    review_stars: result.rating ?? "",
+    review_count: result.reviewCount ?? "",
+    category: result.category ?? "",
+    address: result.address ?? "",
+    phone: result.phone ?? "",
+    website_url: result.websiteUrl ?? "",
+    place_url: result.placeUrl ?? "",
+    cid: result.cid ?? "",
+    cid_decimal: result.cidDecimal ?? "",
+    result_status: "ok",
+    error: ""
+  }));
+}
+function marketRows(rows) {
+  const byLocation = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = String(row.source_location ?? row.location ?? "");
+    if (!key) continue;
+    const list = byLocation.get(key) ?? [];
+    list.push(row);
+    byLocation.set(key, list);
+  }
+  return [...byLocation.entries()].map(([location, list]) => {
+    const counts = list.map((row) => numberFrom2(row.review_count));
+    const ratings = list.map((row) => numberFrom2(row.review_stars));
+    const topThree = list.slice(0, 3).map((row) => numberFrom2(row.review_count)).filter((v) => v !== null);
+    const categories = /* @__PURE__ */ new Map();
+    for (const row of list) {
+      const category = String(row.category ?? "");
+      if (category) categories.set(category, (categories.get(category) ?? 0) + 1);
+    }
+    return {
+      source_location: location,
+      result_count: list.filter((row) => row.business_name).length,
+      median_review_count: median2(counts) ?? "",
+      median_rating: median2(ratings) ?? "",
+      top_three_average_review_count: topThree.length ? Math.round(topThree.reduce((a, b) => a + b, 0) / topThree.length) : "",
+      top_categories: [...categories.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([cat, count]) => `${cat} (${count})`).join("; "),
+      websites_present: list.filter((row) => row.website_url).length
+    };
+  });
+}
+function comparisonRows(rows) {
+  const benchmarkByLocation = /* @__PURE__ */ new Map();
+  for (const market of marketRows(rows)) {
+    benchmarkByLocation.set(String(market.source_location), numberFrom2(market.top_three_average_review_count) ?? 0);
+  }
+  return rows.filter((row) => row.business_name).map((row) => {
+    const reviews = numberFrom2(row.review_count) ?? 0;
+    const benchmark = benchmarkByLocation.get(String(row.source_location)) ?? 0;
+    const websiteMissing = !row.website_url;
+    const rank = numberFrom2(row.result_position) ?? 999;
+    return {
+      source_location: row.source_location,
+      result_position: row.result_position,
+      business_name: row.business_name,
+      category: row.category,
+      review_stars: row.review_stars,
+      review_count: row.review_count,
+      review_gap_to_top3_average: benchmark ? Math.max(0, benchmark - reviews) : "",
+      website_url: row.website_url,
+      place_url: row.place_url,
+      comparison_note: rank <= 3 ? "visible leader" : websiteMissing ? "ranking without website" : reviews < benchmark ? "review-light competitor" : "visible competitor"
+    };
+  });
+}
+function organicRows(serp, targetDomain) {
+  return (serp?.organicResults ?? []).map((result) => {
+    const url = result.url ?? "";
+    const domain = normalizeDomain2(result.domain ?? "") ?? domainFromUrl2(url);
+    return {
+      position: result.position ?? "",
+      title: result.title ?? "",
+      url,
+      domain,
+      snippet: result.snippet ?? "",
+      is_target: targetDomain ? domain === targetDomain : false
+    };
+  });
+}
+function pageGapRows(targetPage, competitorPages) {
+  const targetHeadingText = new Set((targetPage?.headings ?? []).map((h) => h.text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").trim()));
+  const targetTerms = new Set((targetPage?.headings ?? []).flatMap((h) => h.text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean)));
+  const rows = [];
+  for (const { source, page } of competitorPages) {
+    for (const heading of page.headings ?? []) {
+      if (heading.level > 3 || !heading.text) continue;
+      const normalized = heading.text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").trim();
+      const terms = normalized.split(/\s+/).filter((term) => term.length > 3);
+      const overlap = terms.filter((term) => targetTerms.has(term)).length;
+      const covered = targetHeadingText.has(normalized) || overlap >= Math.max(2, Math.ceil(terms.length / 2));
+      if (covered && targetPage) continue;
+      rows.push({
+        source_position: source.position ?? "",
+        source_domain: normalizeDomain2(source.domain ?? "") ?? domainFromUrl2(source.url),
+        source_url: source.url ?? "",
+        heading_level: heading.level,
+        competitor_heading: heading.text,
+        target_coverage: targetPage ? "not found in target headings" : "no target page extracted",
+        terms: textTerms(heading.text, 6)
+      });
+    }
+  }
+  return rows.slice(0, 150);
+}
+async function extractPages(ctx, sources, warnings, labelPrefix) {
+  return mapLimit2(sources.filter((source) => source.url), 2, async (source, index) => {
+    try {
+      const page = await ctx.client.post("/extract-url", { url: source.url }, 18e4);
+      await ctx.artifacts.writeJson(`${labelPrefix} ${index + 1}`, `raw/extract-url/${labelPrefix.toLowerCase()}-${index + 1}.json`, page);
+      return { source, page };
+    } catch (err) {
+      warnings.push(`Page extraction failed for ${source.url}: ${err instanceof Error ? err.message : String(err)}`);
+      return null;
+    }
+  }).then((items) => items.filter((item) => item !== null));
+}
+var mapComparisonWorkflowDefinition = {
+  id: "map-comparison",
+  title: "Maps Comparison",
+  description: "Compare Google Maps competitors by rank, reviews, stars, categories, websites, and profile/review signals.",
+  inputSchema: MapComparisonInputSchema,
+  async run(input, ctx) {
+    await ctx.artifacts.writeManifest("running", {}, [], []);
+    const warnings = [];
+    let rows;
+    let directory = null;
+    let mapsSearch = null;
+    if (input.location) {
+      mapsSearch = await ctx.client.post("/maps/search", {
+        query: input.query,
+        location: input.location,
+        maxResults: input.maxResultsPerCity,
+        proxyMode: input.proxyMode
+      }, 24e4);
+      rows = businessRowsFromMaps(input.location, input.query, mapsSearch.results);
+      await ctx.artifacts.writeJson("Maps search raw JSON", "raw/maps-search.json", mapsSearch);
+    } else {
+      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);
+      rows = directoryRows(directory);
+      await ctx.artifacts.writeJson("Directory raw JSON", "raw/directory-workflow.json", directory);
+      await ctx.artifacts.writeCsv("Directory CSV", "exports/directory.csv", DIRECTORY_CSV_HEADERS, rows);
+      warnings.push(...directory.warnings);
+    }
+    const compareRows = comparisonRows(rows);
+    const selected = compareRows.slice(0, input.hydrateTop * Math.max(1, input.location ? 1 : input.maxCities));
+    const hydrated = await mapLimit2(selected, 3, async (row, index) => {
+      try {
+        const detail = await ctx.client.post("/maps/place", {
+          businessName: row.business_name,
+          location: row.source_location,
+          includeReviews: input.maxReviews > 0,
+          maxReviews: Math.max(1, input.maxReviews)
+        }, 18e4);
+        await ctx.artifacts.writeJson(`${row.business_name} profile`, `raw/maps-place-intel/${index + 1}-${String(row.business_name).toLowerCase().replace(/[^a-z0-9]+/g, "-")}.json`, detail);
+        return { row, detail, error: "" };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        warnings.push(`Profile hydration failed for ${row.business_name}: ${message}`);
+        return { row, detail: null, error: message };
+      }
+    });
+    const profileRows = hydrated.map(({ row, detail, error }) => ({
+      source_location: row.source_location,
+      result_position: row.result_position,
+      business_name: row.business_name,
+      category: detail?.category ?? row.category,
+      review_stars: detail?.rating ?? row.review_stars,
+      review_count: detail?.reviewCount ?? row.review_count,
+      website_url: detail?.website ?? row.website_url,
+      review_topics: (detail?.reviewTopics ?? []).map((t) => `${t.label} (${t.count})`).join("; "),
+      about_attributes: (detail?.aboutAttributes ?? []).map((a) => `${a.section}: ${a.attribute}`).join("; "),
+      reviews_status: detail?.reviewsStatus ?? "",
+      error
+    }));
+    const markets = marketRows(rows);
+    await ctx.artifacts.writeCsv("Maps results CSV", "maps-results.csv", ["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"], rows);
+    await ctx.artifacts.writeCsv("Comparison CSV", "map-comparison.csv", ["source_location", "result_position", "business_name", "category", "review_stars", "review_count", "review_gap_to_top3_average", "website_url", "place_url", "comparison_note"], compareRows);
+    await ctx.artifacts.writeCsv("Profile insights CSV", "profile-insights.csv", ["source_location", "result_position", "business_name", "category", "review_stars", "review_count", "website_url", "review_topics", "about_attributes", "reviews_status", "error"], profileRows);
+    await ctx.artifacts.writeJson("Maps comparison evidence", "evidence.json", { input, directory, mapsSearch, rows, compareRows, profileRows, markets, warnings });
+    await ctx.artifacts.writeText("Brief", "brief.md", [
+      `# Maps Comparison: ${input.query}`,
+      "",
+      `Markets: ${markets.map((row) => row.source_location).join(", ")}`,
+      "",
+      "## How to Use",
+      "- Compare rank position against review count and category patterns.",
+      "- Treat review gaps and missing websites as opportunity signals, not guarantees.",
+      "- Use profile topics and attributes as evidence for local content and GBP improvements."
+    ].join("\n"));
+    const summary = `${compareRows.length} Maps competitors compared across ${markets.length} market(s); ${profileRows.filter((row) => !row.error).length} profiles hydrated.`;
+    const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+      title: "Maps Comparison",
+      subtitle: `${input.query}${input.location ? ` \xB7 ${input.location}` : input.state ? ` \xB7 ${input.state}` : ""}`,
+      summary,
+      warnings,
+      tables: [
+        { title: "Market Benchmarks", columns: ["source_location", "result_count", "median_review_count", "median_rating", "top_three_average_review_count", "top_categories", "websites_present"], rows: markets },
+        { title: "Competitor Comparison", columns: ["source_location", "result_position", "business_name", "category", "review_stars", "review_count", "review_gap_to_top3_average", "comparison_note"], rows: compareRows.slice(0, 120) },
+        { title: "Profile Insights", columns: ["source_location", "business_name", "review_topics", "about_attributes", "error"], rows: profileRows }
+      ]
+    }));
+    const status = warnings.length ? "partial" : "succeeded";
+    const counts = { markets: markets.length, competitors: compareRows.length, hydratedProfiles: profileRows.filter((row) => !row.error).length };
+    await ctx.artifacts.writeManifest(status, counts, warnings, []);
+    return { title: "Maps Comparison", summary, status, counts, warnings, errors: [], reportPath };
+  }
+};
+var serpComparisonWorkflowDefinition = {
+  id: "serp-comparison",
+  title: "SERP Comparison",
+  description: "Compare ranking pages, SERP features, PAA evidence, AI Overview citations, and page-level content gaps.",
+  inputSchema: SerpComparisonInputSchema,
+  async run(input, ctx) {
+    await ctx.artifacts.writeManifest("running", {}, [], []);
+    const warnings = [];
+    const targetDomain = normalizeDomain2(input.domain ?? input.url ?? null);
+    const serp = await ctx.client.post("/harvest/sync", {
+      query: input.keyword,
+      location: input.location,
+      serpOnly: true,
+      maxQuestions: 1,
+      format: "json"
+    }, 18e4);
+    await ctx.artifacts.writeJson("SERP raw JSON", "raw/serp.json", serp);
+    let paa = null;
+    if (input.includePaa) {
+      try {
+        paa = await ctx.client.post("/harvest/sync", {
+          query: input.keyword,
+          location: input.location,
+          maxQuestions: input.maxQuestions,
+          format: "json"
+        }, 28e4);
+        await ctx.artifacts.writeJson("PAA raw JSON", "raw/paa.json", paa);
+      } catch (err) {
+        warnings.push(`PAA evidence unavailable: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const organic = organicRows(serp, targetDomain).slice(0, input.maxResults);
+    const organicSources = (serp.organicResults ?? []).slice(0, input.maxResults);
+    const targetSource = input.url ? { position: 0, title: "Target page", url: input.url, domain: domainFromUrl2(input.url) } : organicSources.find((result) => targetDomain && (normalizeDomain2(result.domain ?? "") ?? domainFromUrl2(result.url)) === targetDomain);
+    const competitorSources = organicSources.filter((result) => result.url && result.url !== targetSource?.url).filter((result) => !targetDomain || (normalizeDomain2(result.domain ?? "") ?? domainFromUrl2(result.url)) !== targetDomain).slice(0, input.extractTop);
+    const targetPages = targetSource ? await extractPages(ctx, [targetSource], warnings, "Target") : [];
+    const competitorPages = input.extractTop > 0 ? await extractPages(ctx, competitorSources, warnings, "Competitor") : [];
+    const targetPage = targetPages[0]?.page ?? null;
+    const pageRows = [
+      ...targetPages.map(({ source, page }) => pageSummaryRow(page, { url: source.url ?? "", domain: normalizeDomain2(source.domain ?? "") ?? domainFromUrl2(source.url), position: source.position, title: source.title })),
+      ...competitorPages.map(({ source, page }) => pageSummaryRow(page, { url: source.url ?? "", domain: normalizeDomain2(source.domain ?? "") ?? domainFromUrl2(source.url), position: source.position, title: source.title }))
+    ];
+    const gaps = pageGapRows(targetPage, competitorPages);
+    const questions = questionRows(paa);
+    const aiRows = (serp.aiOverview?.citations ?? []).map((citation, index) => ({
+      citation_position: index + 1,
+      citation_text: citation.text ?? "",
+      url: citation.href ?? "",
+      domain: domainFromUrl2(citation.href ?? ""),
+      is_target: targetDomain ? domainFromUrl2(citation.href ?? "") === targetDomain : false
+    }));
+    await ctx.artifacts.writeCsv("Organic results CSV", "organic-results.csv", ["position", "title", "url", "domain", "snippet", "is_target"], organic);
+    await ctx.artifacts.writeCsv("Page comparison CSV", "page-comparison.csv", ["position", "domain", "url", "serp_title", "page_title", "h1", "meta_description", "word_count", "heading_count", "schema_types"], pageRows);
+    await ctx.artifacts.writeCsv("Content gaps CSV", "content-gaps.csv", ["source_position", "source_domain", "source_url", "heading_level", "competitor_heading", "target_coverage", "terms"], gaps);
+    await ctx.artifacts.writeCsv("PAA questions CSV", "paa-questions.csv", ["position", "intent", "question", "answer_excerpt", "source_title", "source_domain", "source_url"], questions);
+    await ctx.artifacts.writeCsv("AI Overview citations CSV", "ai-overview-citations.csv", ["citation_position", "citation_text", "url", "domain", "is_target"], aiRows);
+    await ctx.artifacts.writeJson("SERP comparison evidence", "evidence.json", { input, serp, paa, organic, pageRows, gaps, questions, aiRows, warnings });
+    await ctx.artifacts.writeText("Writer brief", "brief.md", [
+      `# SERP Comparison Brief: ${input.keyword}`,
+      "",
+      `Target: ${targetDomain ?? input.url ?? "not specified"}`,
+      `Location: ${input.location ?? "not specified"}`,
+      "",
+      "## Recommended Actions",
+      "- Use `content-gaps.csv` to decide which missing sections deserve coverage.",
+      "- Use `paa-questions.csv` for FAQ and answer-block candidates.",
+      "- Use `ai-overview-citations.csv` to see whether the target is cited in AI Overview evidence.",
+      "- Treat extracted page headings as evidence, not a complete semantic analysis."
+    ].join("\n"));
+    const summary = `${organic.length} organic results, ${pageRows.length} extracted pages, ${gaps.length} heading gaps, ${questions.length} PAA questions.`;
+    const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+      title: "SERP Comparison",
+      subtitle: `${input.keyword}${input.location ? ` \xB7 ${input.location}` : ""}`,
+      summary,
+      warnings,
+      tables: [
+        { title: "Organic Results", columns: ["position", "title", "domain", "is_target"], rows: organic },
+        { title: "Page Comparison", columns: ["position", "domain", "h1", "word_count", "heading_count", "schema_types"], rows: pageRows },
+        { title: "Content Gaps", columns: ["source_position", "source_domain", "competitor_heading", "target_coverage", "terms"], rows: gaps.slice(0, 80) },
+        { title: "PAA Questions", columns: ["position", "intent", "question", "source_domain"], rows: questions.slice(0, 80) }
+      ]
+    }));
+    const status = warnings.length ? "partial" : "succeeded";
+    const counts = { organic: organic.length, pages: pageRows.length, gaps: gaps.length, questions: questions.length, aiCitations: aiRows.length };
+    await ctx.artifacts.writeManifest(status, counts, warnings, []);
+    return { title: "SERP Comparison", summary, status, counts, warnings, errors: [], reportPath };
+  }
+};
+var paaExpansionBriefWorkflowDefinition = {
+  id: "paa-expansion-brief",
+  title: "PAA Expansion Brief",
+  description: "Expand People Also Ask questions into an evidence-backed writer brief, section map, and source table.",
+  inputSchema: PaaExpansionBriefInputSchema,
+  async run(input, ctx) {
+    await ctx.artifacts.writeManifest("running", {}, [], []);
+    const warnings = [];
+    const paa = await ctx.client.post("/harvest/sync", {
+      query: input.keyword,
+      location: input.location,
+      maxQuestions: input.maxQuestions,
+      depth: input.depth,
+      format: "json"
+    }, 3e5);
+    await ctx.artifacts.writeJson("PAA raw JSON", "raw/paa.json", paa);
+    const questions = questionRows(paa);
+    const sourceRows2 = sourceDomainRows(questions);
+    const byIntent = /* @__PURE__ */ new Map();
+    for (const row of questions) {
+      const list = byIntent.get(String(row.intent)) ?? [];
+      list.push(row);
+      byIntent.set(String(row.intent), list);
+    }
+    const sectionRows = [...byIntent.entries()].map(([intent, rows]) => ({
+      recommended_section: intent,
+      question_count: rows.length,
+      sample_questions: rows.slice(0, 5).map((row) => row.question).join(" | "),
+      source_domains: [...new Set(rows.map((row) => row.source_domain).filter(Boolean))].slice(0, 5).join("; "),
+      terms: textTerms(rows.map((row) => `${row.question} ${row.answer_excerpt}`).join(" "), 10)
+    })).sort((a, b) => Number(b.question_count) - Number(a.question_count));
+    await ctx.artifacts.writeCsv("PAA questions CSV", "paa-questions.csv", ["position", "intent", "question", "answer_excerpt", "source_title", "source_domain", "source_url"], questions);
+    await ctx.artifacts.writeCsv("Source domains CSV", "source-domains.csv", ["domain", "question_mentions", "source_url_count", "top_intents"], sourceRows2);
+    await ctx.artifacts.writeCsv("Section map CSV", "section-map.csv", ["recommended_section", "question_count", "sample_questions", "source_domains", "terms"], sectionRows);
+    await ctx.artifacts.writeJson("PAA brief evidence", "evidence.json", { input, paa, questions, sourceRows: sourceRows2, sectionRows });
+    await ctx.artifacts.writeText("Writer brief", "writer-brief.md", [
+      `# PAA Expansion Brief: ${input.keyword}`,
+      "",
+      `Location: ${input.location ?? "not specified"}`,
+      "",
+      "## Suggested Page Structure",
+      ...sectionRows.map((row) => `- ${row.recommended_section}: answer ${row.question_count} related question(s). Sample: ${row.sample_questions}`),
+      "",
+      "## Writing Rules",
+      "- Answer the highest-frequency question in the first 60 words of each section.",
+      "- Use exact customer question language from `paa-questions.csv` for H2/H3 candidates.",
+      "- Use `source-domains.csv` to identify which source types Google is already rewarding.",
+      "- Do not invent citations; cite only rows that have a source URL."
+    ].join("\n"));
+    const summary = `${questions.length} PAA questions grouped into ${sectionRows.length} writing sections.`;
+    const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+      title: "PAA Expansion Brief",
+      subtitle: `${input.keyword}${input.location ? ` \xB7 ${input.location}` : ""}`,
+      summary,
+      warnings,
+      tables: [
+        { title: "Section Map", columns: ["recommended_section", "question_count", "sample_questions", "source_domains", "terms"], rows: sectionRows },
+        { title: "Questions", columns: ["position", "intent", "question", "source_domain"], rows: questions.slice(0, 120) },
+        { title: "Source Domains", columns: ["domain", "question_mentions", "source_url_count", "top_intents"], rows: sourceRows2 }
+      ]
+    }));
+    const counts = { questions: questions.length, sections: sectionRows.length, sourceDomains: sourceRows2.length };
+    await ctx.artifacts.writeManifest("succeeded", counts, warnings, []);
+    return { title: "PAA Expansion Brief", summary, status: "succeeded", counts, warnings, errors: [], reportPath };
+  }
+};
+var aiOverviewLanguageWorkflowDefinition = {
+  id: "ai-overview-language",
+  title: "AI Overview Language Brief",
+  description: "Turn AI Overview, citation, PAA, and ranking-page evidence into answer-block and citation-hook guidance.",
+  inputSchema: AiOverviewLanguageInputSchema,
+  async run(input, ctx) {
+    await ctx.artifacts.writeManifest("running", {}, [], []);
+    const warnings = [];
+    const targetDomain = normalizeDomain2(input.domain ?? input.url ?? null);
+    const serp = await ctx.client.post("/harvest/sync", {
+      query: input.keyword,
+      location: input.location,
+      serpOnly: true,
+      maxQuestions: 1,
+      format: "json"
+    }, 18e4);
+    await ctx.artifacts.writeJson("SERP raw JSON", "raw/serp.json", serp);
+    let paa = null;
+    try {
+      paa = await ctx.client.post("/harvest/sync", {
+        query: input.keyword,
+        location: input.location,
+        maxQuestions: input.maxQuestions,
+        format: "json"
+      }, 28e4);
+      await ctx.artifacts.writeJson("PAA raw JSON", "raw/paa.json", paa);
+    } catch (err) {
+      warnings.push(`PAA evidence unavailable: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const citations = (serp.aiOverview?.citations ?? []).map((citation, index) => {
+      const domain = domainFromUrl2(citation.href ?? "");
+      return {
+        citation_position: index + 1,
+        citation_text: citation.text ?? "",
+        url: citation.href ?? "",
+        domain,
+        is_target: targetDomain ? domain === targetDomain : false
+      };
+    });
+    const aioSentences = splitSentences(serp.aiOverview?.text);
+    const claimRows = aioSentences.map((sentence, index) => ({
+      position: index + 1,
+      claim_type: classifySentence(sentence),
+      sentence,
+      reusable_pattern: sentence.length > 140 ? `${sentence.slice(0, 140)}...` : sentence
+    }));
+    const questions = questionRows(paa);
+    const citationSources = (serp.aiOverview?.citations ?? []).filter((citation) => citation.href).map((citation, index) => ({ position: index + 1, title: citation.text, url: citation.href, domain: domainFromUrl2(citation.href) })).slice(0, input.extractTop);
+    const extractedCitations = input.extractTop > 0 ? await extractPages(ctx, citationSources, warnings, "Citation") : [];
+    const extractedRows = extractedCitations.map(({ source, page }) => pageSummaryRow(page, { url: source.url ?? "", domain: normalizeDomain2(source.domain ?? "") ?? domainFromUrl2(source.url), position: source.position, title: source.title }));
+    const languageRows = [
+      {
+        block: "direct_answer",
+        guidance: "Open with a 40-70 word answer that directly resolves the query before adding context.",
+        evidence_basis: questions[0]?.question ?? input.keyword
+      },
+      {
+        block: "criteria_or_steps",
+        guidance: "List the criteria, steps, or decision factors Google is already compressing into AI Overview language.",
+        evidence_basis: claimRows.filter((row) => ["criteria", "process"].includes(String(row.claim_type))).map((row) => row.sentence).slice(0, 3).join(" | ")
+      },
+      {
+        block: "citation_hook",
+        guidance: "Add source-worthy details competitors can cite: definitions, numbers, examples, process details, and named entity relationships.",
+        evidence_basis: citations.map((row) => `${row.domain}: ${row.citation_text}`).slice(0, 5).join(" | ")
+      },
+      {
+        block: "faq_followups",
+        guidance: "Use PAA phrasing for follow-up sections so the page answers adjacent questions in Google language.",
+        evidence_basis: questions.slice(0, 5).map((row) => row.question).join(" | ")
+      }
+    ];
+    await ctx.artifacts.writeCsv("AI Overview citations CSV", "ai-overview-citations.csv", ["citation_position", "citation_text", "url", "domain", "is_target"], citations);
+    await ctx.artifacts.writeCsv("AI Overview claim patterns CSV", "claim-patterns.csv", ["position", "claim_type", "sentence", "reusable_pattern"], claimRows);
+    await ctx.artifacts.writeCsv("Language guidance CSV", "language-guidance.csv", ["block", "guidance", "evidence_basis"], languageRows);
+    await ctx.artifacts.writeCsv("PAA questions CSV", "paa-questions.csv", ["position", "intent", "question", "answer_excerpt", "source_title", "source_domain", "source_url"], questions);
+    await ctx.artifacts.writeCsv("Extracted citation pages CSV", "citation-pages.csv", ["position", "domain", "url", "serp_title", "page_title", "h1", "meta_description", "word_count", "heading_count", "schema_types"], extractedRows);
+    await ctx.artifacts.writeJson("AI Overview language evidence", "evidence.json", { input, serp, paa, citations, claimRows, languageRows, extractedRows, warnings });
+    await ctx.artifacts.writeText("Answer block template", "answer-block-template.md", [
+      `# AI Overview Language Brief: ${input.keyword}`,
+      "",
+      `AI Overview detected: ${serp.aiOverview?.detected ? "yes" : "no"}`,
+      `Target cited: ${targetDomain ? citations.some((row) => row.is_target) ? "yes" : "no" : "target not specified"}`,
+      "",
+      "## Direct Answer Block",
+      "Write one compact answer block that starts with the answer, not background. Keep it clear enough that Google could lift it as a standalone summary.",
+      "",
+      "## Suggested Follow-Up Blocks",
+      ...languageRows.map((row) => `- ${row.block}: ${row.guidance}`),
+      "",
+      "## Evidence to Mirror",
+      ...claimRows.slice(0, 8).map((row) => `- ${row.claim_type}: ${row.sentence}`),
+      "",
+      "## Citation Hooks",
+      ...citations.slice(0, 8).map((row) => `- ${row.domain}: ${row.citation_text}`)
+    ].join("\n"));
+    const summary = `${citations.length} AI Overview citations, ${claimRows.length} claim patterns, ${questions.length} PAA questions, ${extractedRows.length} citation pages extracted.`;
+    const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+      title: "AI Overview Language Brief",
+      subtitle: `${input.keyword}${input.location ? ` \xB7 ${input.location}` : ""}`,
+      summary,
+      warnings,
+      tables: [
+        { title: "Language Guidance", columns: ["block", "guidance", "evidence_basis"], rows: languageRows },
+        { title: "AI Overview Citations", columns: ["citation_position", "citation_text", "domain", "is_target"], rows: citations },
+        { title: "Claim Patterns", columns: ["position", "claim_type", "sentence"], rows: claimRows },
+        { title: "PAA Follow-Ups", columns: ["position", "intent", "question", "source_domain"], rows: questions.slice(0, 60) }
+      ]
+    }));
+    const status = warnings.length || !serp.aiOverview?.detected ? "partial" : "succeeded";
+    const counts = { citations: citations.length, claimPatterns: claimRows.length, questions: questions.length, extractedCitationPages: extractedRows.length };
+    await ctx.artifacts.writeManifest(status, counts, warnings, []);
+    return { title: "AI Overview Language Brief", summary, status, counts, warnings, errors: [], reportPath };
+  }
+};
+
+// src/workflows/registry.ts
+var DEFINITIONS = [
+  directoryWorkflowDefinition,
+  agentPacketWorkflowDefinition,
+  localCompetitiveAuditWorkflowDefinition,
+  mapComparisonWorkflowDefinition,
+  serpComparisonWorkflowDefinition,
+  paaExpansionBriefWorkflowDefinition,
+  aiOverviewLanguageWorkflowDefinition
+];
+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 client = new WorkflowHttpClient(apiUrl, apiKey, options.fetchImpl);
+  try {
+    return await definition.run(input, {
+      runId: artifacts.runId,
+      startedAt: artifacts.startedAt,
+      client,
+      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;
+  }
+}
+
+export {
+  csvRecords,
+  rowsToCsv,
+  workflowOutputBaseDir,
+  listWorkflowReports,
+  findWorkflowReport,
+  openWorkflowReport,
+  listWorkflowDefinitions,
+  workflowDefinition,
+  runWorkflow
+};
+//# sourceMappingURL=chunk-AYTOCZBS.js.map