archondev 3.0.0 → 3.1.0

package/dist/chunk-EF66S6ZQ.js

@@ -0,0 +1,1189 @@
+import {
+  recordWebCheckResult
+} from "./chunk-3ASILTFB.js";
+import {
+  ArchitectAgent
+} from "./chunk-D3TVDCJA.js";
+import {
+  loadConfig
+} from "./chunk-NQBS7L2F.js";
+
+// src/cli/geo.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { createInterface } from "readline";
+import { glob } from "glob";
+import * as yaml from "yaml";
+var BANNED_WORDS_GENERIC = [
+  "comprehensive",
+  "leveraging",
+  "leverage",
+  "synergy",
+  "cutting-edge",
+  "cutting edge",
+  "innovative",
+  "leading provider",
+  "world-class",
+  "world class",
+  "best-in-class",
+  "best in class",
+  "next-generation",
+  "next generation",
+  "revolutionary",
+  "transformative",
+  "disruptive",
+  "game-changing",
+  "game changing",
+  "seamless",
+  "robust",
+  "scalable",
+  "enterprise-grade",
+  "enterprise grade",
+  "end-to-end",
+  "end to end",
+  "holistic",
+  "one-stop-shop",
+  "one stop shop",
+  "empowering",
+  "unlocking"
+];
+var BANNED_WORDS_AI_WASHING = [
+  "AI-native",
+  "AI native",
+  "AI-powered",
+  "AI powered",
+  "AI-first",
+  "AI first",
+  "AI-driven",
+  "AI driven",
+  "agentic",
+  "autonomous AI",
+  "intelligent automation",
+  "smart AI"
+];
+var BANNED_WORDS_ALL = [...BANNED_WORDS_GENERIC, ...BANNED_WORDS_AI_WASHING];
+function approxTokenCount(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return 0;
+  const byChars = Math.ceil(trimmed.length / 4);
+  const byWords = trimmed.split(/\s+/).length;
+  return Math.max(byChars, byWords);
+}
+function findBannedWords(text, list = BANNED_WORDS_ALL) {
+  const lower = text.toLowerCase();
+  return list.filter((word) => lower.includes(word.toLowerCase()));
+}
+function wordCount(text) {
+  return text.trim().split(/\s+/).filter(Boolean).length;
+}
+function splitSentences(text) {
+  return text.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+}
+function validateSevenWordPhrase(phrase) {
+  const issues = [];
+  const wc = wordCount(phrase);
+  if (wc !== 7) {
+    issues.push({ level: "warn", message: `Phrase has ${wc} words, expected 7: "${phrase}"` });
+  }
+  const tokens = approxTokenCount(phrase);
+  if (tokens > 18) {
+    issues.push({ level: "error", message: `Phrase exceeds 18 tokens (got ${tokens}): "${phrase}"` });
+  }
+  const banned = findBannedWords(phrase);
+  if (banned.length > 0) {
+    issues.push({ level: "error", message: `Banned words in phrase: ${banned.join(", ")}` });
+  }
+  return issues;
+}
+function validateFiftyWordDescription(description) {
+  const issues = [];
+  const wc = wordCount(description);
+  if (wc < 40 || wc > 60) {
+    issues.push({ level: "warn", message: `Description has ${wc} words, expected ~50` });
+  }
+  const banned = findBannedWords(description);
+  if (banned.length > 0) {
+    issues.push({ level: "error", message: `Banned words in description: ${banned.join(", ")}` });
+  }
+  for (const sentence of splitSentences(description)) {
+    const tokens = approxTokenCount(sentence);
+    if (tokens > 22) {
+      issues.push({
+        level: "warn",
+        message: `Sentence exceeds 18-token citation budget (got ~${tokens}): "${sentence.slice(0, 60)}..."`
+      });
+    }
+  }
+  return issues;
+}
+function validateFaqAnswer(answer) {
+  const issues = [];
+  const banned = findBannedWords(answer);
+  if (banned.length > 0) {
+    issues.push({ level: "warn", message: `Banned words in answer: ${banned.join(", ")}` });
+  }
+  for (const sentence of splitSentences(answer)) {
+    const tokens = approxTokenCount(sentence);
+    if (tokens > 22) {
+      issues.push({
+        level: "warn",
+        message: `FAQ sentence exceeds 18-token citation budget (~${tokens} tokens)`
+      });
+    }
+  }
+  return issues;
+}
+var CONFIG_PATH = ".archon/config.yaml";
+function createPrompt() {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return {
+    ask: (question) => new Promise((resolve) => {
+      rl.question(question, resolve);
+    }),
+    close: () => rl.close()
+  };
+}
+async function loadGeoConfig(cwd) {
+  const configPath = join(cwd, CONFIG_PATH);
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const content = await readFile(configPath, "utf-8");
+    return yaml.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function saveGeoConfig(cwd, config) {
+  const configPath = join(cwd, CONFIG_PATH);
+  const archonDir = join(cwd, ".archon");
+  if (!existsSync(archonDir)) {
+    await mkdir(archonDir, { recursive: true });
+  }
+  let existing = {};
+  if (existsSync(configPath)) {
+    try {
+      const content = await readFile(configPath, "utf-8");
+      existing = yaml.parse(content);
+    } catch {
+    }
+  }
+  const merged = { ...existing, ...config };
+  await writeFile(configPath, yaml.stringify(merged), "utf-8");
+}
+async function readPageContent(patterns) {
+  const cwd = process.cwd();
+  let content = "";
+  for (const pattern of patterns) {
+    const files = await glob(pattern, { cwd, ignore: ["**/node_modules/**", "**/dist/**"] });
+    for (const file of files.slice(0, 3)) {
+      try {
+        const fileContent = await readFile(join(cwd, file), "utf-8");
+        content += `
+--- File: ${file} ---
+${fileContent.slice(0, 5e3)}
+`;
+      } catch {
+      }
+    }
+  }
+  return content || "No content found.";
+}
+async function checkStrongModelAccess() {
+  const config = await loadConfig();
+  const tier = config.tier ?? "FREE";
+  if (tier === "BYOK") {
+    return { allowed: true, tier };
+  }
+  return { allowed: false, tier };
+}
+var IDENTITY_SYSTEM_PROMPT = `You are an Expert Direct-Response Copywriter and GEO/AEO Specialist. You produce brand identity artifacts for two audiences simultaneously:
+
+  1. HUMANS \u2014 who must remember the company (memory, preference, trust)
+  2. AI AGENTS \u2014 who must understand the company (clarity, structure, evidence)
+
+Both audiences are non-negotiable. If a candidate works for only one, reject it.
+
+7-WORD IDENTITY PHRASE \u2014 strict rules:
+  - EXACTLY 7 words. Not 6, not 8.
+  - <=18 tokens total (each phrase must survive AI citation compression).
+  - Formula: [Action Verb] + [Target Audience or Problem] + [Unique Benefit or Result].
+  - No passive voice.
+  - No vague corporate filler.
+  - Must be a claim ONLY this company can honestly make. Competitor test: if any
+    competitor could write the same phrase after one brainstorm, REJECT IT.
+
+50-WORD DESCRIPTION \u2014 strict rules:
+  - Approximately 50 words (between 40 and 60). One cohesive paragraph.
+  - Structure:
+      a) Audience pain or problem (~15 words)
+      b) Solution and differentiator (~20 words)
+      c) Proof or mechanism (~10 words)
+      d) Final promise (~5 words)
+  - Each sentence should aim for <=18 tokens so AI agents can quote whole sentences.
+  - Contain at least one specific, citable fact (number, named outcome, named integration).
+  - No hedging language ("we believe," "we strive to," "designed to").
+
+BANNED WORDS (do not use unless you can cite specific evidence in the rationale):
+  ${BANNED_WORDS_GENERIC.join(", ")},
+  ${BANNED_WORDS_AI_WASHING.join(", ")}
+
+QUALITY GATE \u2014 only emit candidates that are:
+  - CEO-worthy (no candidate the founder would be embarrassed to read aloud)
+  - Differentiated (fails the competitor test? reject)
+  - Outcome-focused (not feature-focused)
+  - Specific (no abstract benefit language)
+
+Output your response as valid JSON exactly matching the requested schema.`;
+var BUSINESS_CONTEXT_PROMPT = `Analyze the source material below as an expert business analyst. Produce a comprehensive business context covering:
+  1. What the business does \u2014 specific products, services, offerings.
+  2. Mission and value proposition \u2014 what makes them distinctive.
+  3. Target audience \u2014 who they serve.
+  4. Market positioning \u2014 how they differentiate.
+
+Be concrete. Avoid generic claims. Cite specific evidence found in the source.
+
+Output as JSON: { "businessContext": "multi-paragraph prose..." }`;
+var AUDIENCE_CONTEXT_PROMPT = `Analyze the source material plus the prior businessContext. Produce an audience-centric context covering:
+  1. What kind of public surface this is (marketing site, product platform, service, e-commerce, docs).
+  2. Specific industry or vertical.
+  3. Audience needs, pain points, and what problems get solved.
+
+Output as JSON: { "audienceContext": "multi-paragraph prose..." }`;
+async function generateContextArtifacts(pageContent) {
+  const agent = new ArchitectAgent({ temperature: 0.5 });
+  const bizResponse = await agent.client.chat(
+    BUSINESS_CONTEXT_PROMPT,
+    `Source material:
+
+${pageContent}`,
+    { temperature: 0.5, maxTokens: 1500 }
+  );
+  const bizMatch = bizResponse.content.match(/\{[\s\S]*\}/);
+  const businessContext = bizMatch ? JSON.parse(bizMatch[0]).businessContext : bizResponse.content;
+  const audResponse = await agent.client.chat(
+    AUDIENCE_CONTEXT_PROMPT,
+    `Prior businessContext:
+${businessContext}
+
+Source material:
+${pageContent}`,
+    { temperature: 0.5, maxTokens: 1500 }
+  );
+  const audMatch = audResponse.content.match(/\{[\s\S]*\}/);
+  const audienceContext = audMatch ? JSON.parse(audMatch[0]).audienceContext : audResponse.content;
+  return { businessContext, audienceContext };
+}
+async function generateIdentityCandidates(businessContext, audienceContext) {
+  const agent = new ArchitectAgent({ temperature: 0.8 });
+  const prompt = `INPUTS:
+
+businessContext:
+${businessContext}
+
+audienceContext:
+${audienceContext}
+
+TASK: Generate EXACTLY 3 candidate 7-word brand phrases and 3 candidate 50-word descriptions. Each candidate must pass the competitor test and the specificity test as defined in the system prompt.
+
+Output as JSON:
+{
+  "phrases": [
+    { "phrase": "exactly seven words go right here", "rationale": "what evidence supports this and why a competitor could not honestly claim it" },
+    { "phrase": "another seven word phrase goes here", "rationale": "..." },
+    { "phrase": "third seven word phrase goes here", "rationale": "..." }
+  ],
+  "descriptions": [
+    { "description": "approximately 50-word description following the pain/solution/proof/promise structure...", "rationale": "..." },
+    { "description": "second variant...", "rationale": "..." },
+    { "description": "third variant...", "rationale": "..." }
+  ]
+}`;
+  const response = await agent.client.chat(
+    IDENTITY_SYSTEM_PROMPT,
+    prompt,
+    { temperature: 0.8, maxTokens: 2500 }
+  );
+  const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Failed to parse AI response");
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  parsed.phrases = parsed.phrases.filter((p) => {
+    const issues = validateSevenWordPhrase(p.phrase);
+    const blocking = issues.filter((i) => i.level === "error");
+    if (blocking.length > 0) {
+      console.log(chalk.yellow(`[!] Dropping phrase: ${blocking.map((i) => i.message).join("; ")}`));
+      return false;
+    }
+    for (const issue of issues) {
+      console.log(chalk.dim(`    warn: ${issue.message}`));
+    }
+    return true;
+  });
+  parsed.descriptions = parsed.descriptions.filter((d) => {
+    const issues = validateFiftyWordDescription(d.description);
+    const blocking = issues.filter((i) => i.level === "error");
+    if (blocking.length > 0) {
+      console.log(chalk.yellow(`[!] Dropping description: ${blocking.map((i) => i.message).join("; ")}`));
+      return false;
+    }
+    for (const issue of issues) {
+      console.log(chalk.dim(`    warn: ${issue.message}`));
+    }
+    return true;
+  });
+  if (parsed.phrases.length === 0 || parsed.descriptions.length === 0) {
+    throw new Error("All generated candidates failed validation. Try again, or refine business/audience context.");
+  }
+  return parsed;
+}
+async function geoIdentity() {
+  const cwd = process.cwd();
+  const prompt = createPrompt();
+  try {
+    console.log(chalk.blue("\n\u{1F3AF} GEO Identity Generator\n"));
+    const { allowed, tier } = await checkStrongModelAccess();
+    if (!allowed) {
+      console.log(chalk.yellow(`[!] Your tier (${tier}) uses basic models.`));
+      console.log(chalk.dim("For better results, use BYOK mode with your own provider key.\n"));
+    }
+    console.log(chalk.dim("Reading homepage and about page content...\n"));
+    const pageContent = await readPageContent([
+      "**/index.html",
+      "**/index.{jsx,tsx,astro,svelte,vue}",
+      "**/about.{html,jsx,tsx,astro,svelte,vue,md}",
+      "**/about/index.{jsx,tsx,astro,svelte,vue}",
+      "**/pages/index.{jsx,tsx,astro,svelte,vue}",
+      "**/app/page.{jsx,tsx}",
+      "README.md"
+    ]);
+    if (pageContent === "No content found.") {
+      console.log(chalk.yellow("No homepage or about page content found."));
+      console.log(chalk.dim("Create an index file or README.md first.\n"));
+      return;
+    }
+    console.log(chalk.dim("Step 1/3 \u2014 Generating businessContext and audienceContext artifacts...\n"));
+    const { businessContext, audienceContext } = await generateContextArtifacts(pageContent);
+    const geoDir = join(cwd, ".archon", "geo");
+    if (!existsSync(geoDir)) {
+      await mkdir(geoDir, { recursive: true });
+    }
+    const contextPath = join(geoDir, "context.md");
+    const contextDoc = `# GEO Context Artifacts
+
+Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## businessContext
+${businessContext}
+
+## audienceContext
+${audienceContext}
+`;
+    await writeFile(contextPath, contextDoc, "utf-8");
+    console.log(chalk.green(`  Saved to .archon/geo/context.md
+`));
+    console.log(chalk.dim("Step 2/3 \u2014 Generating identity candidates with AI (with 18-token + competitor-test gates)...\n"));
+    const candidates = await generateIdentityCandidates(businessContext, audienceContext);
+    console.log(chalk.bold("\u{1F4CC} 7-Word Brand Phrases:\n"));
+    candidates.phrases.forEach((p, i) => {
+      console.log(`  ${chalk.cyan(`${i + 1})`)} ${chalk.bold(p.phrase)}`);
+      console.log(`     ${chalk.dim(p.rationale)}
+`);
+    });
+    const phraseChoice = await prompt.ask('Select a phrase (1-3) or "r" to regenerate: ');
+    if (phraseChoice.toLowerCase() === "r") {
+      console.log(chalk.dim("\nRegenerating... Run the command again.\n"));
+      return;
+    }
+    const phraseIndex = parseInt(phraseChoice, 10) - 1;
+    const selectedPhrase = candidates.phrases[phraseIndex];
+    if (isNaN(phraseIndex) || phraseIndex < 0 || phraseIndex >= candidates.phrases.length || !selectedPhrase) {
+      console.log(chalk.red("Invalid selection."));
+      return;
+    }
+    console.log(chalk.bold("\n\u{1F4DD} 50-Word Descriptions:\n"));
+    candidates.descriptions.forEach((d, i) => {
+      console.log(`  ${chalk.cyan(`${i + 1})`)} ${d.description}`);
+      console.log(`     ${chalk.dim(d.rationale)}
+`);
+    });
+    const descChoice = await prompt.ask('Select a description (1-3) or "r" to regenerate: ');
+    if (descChoice.toLowerCase() === "r") {
+      console.log(chalk.dim("\nRegenerating... Run the command again.\n"));
+      return;
+    }
+    const descIndex = parseInt(descChoice, 10) - 1;
+    const selectedDescription = candidates.descriptions[descIndex];
+    if (isNaN(descIndex) || descIndex < 0 || descIndex >= candidates.descriptions.length || !selectedDescription) {
+      console.log(chalk.red("Invalid selection."));
+      return;
+    }
+    console.log(chalk.dim("\nStep 3/3 \u2014 Saving identity + context artifacts.\n"));
+    const geoConfig = {
+      geo: {
+        identityPhrase: selectedPhrase.phrase,
+        shortDescription: selectedDescription.description,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        businessContext,
+        audienceContext
+      }
+    };
+    await saveGeoConfig(cwd, geoConfig);
+    console.log(chalk.green("\u2705 Identity saved!\n"));
+    console.log(chalk.dim(`  Phrase: ${selectedPhrase.phrase}`));
+    console.log(chalk.dim(`  Description: ${selectedDescription.description.slice(0, 60)}...`));
+    console.log(chalk.dim(`  Context artifacts: .archon/geo/context.md`));
+    console.log();
+    console.log(chalk.cyan(`Next steps:`));
+    console.log(chalk.dim(`  archon geo schema           Generate Organization + Service JSON-LD`));
+    console.log(chalk.dim(`  archon geo faq              Generate FAQPage schema`));
+    console.log(chalk.dim(`  archon geo claims           Generate atomic claims (<=18 tokens each)`));
+    console.log(chalk.dim(`  archon truth-layer init     Build a living truth-layer artifact`));
+    console.log(chalk.dim(`  archon brand memory-map     Pressure-test what humans actually remember`));
+    console.log(chalk.dim(`  archon geo washing-audit    Scan existing copy for AI-washing claims`));
+  } finally {
+    prompt.close();
+  }
+}
+async function geoSchema(options) {
+  const cwd = process.cwd();
+  console.log(chalk.blue("\n\u{1F4E6} JSON-LD Schema Generator\n"));
+  const config = await loadGeoConfig(cwd);
+  if (!config.geo?.identityPhrase || !config.geo?.shortDescription) {
+    console.log(chalk.yellow("No identity defined."));
+    console.log(chalk.dim(`Run 'archon geo identity' first.
+`));
+    return;
+  }
+  const { identityPhrase, shortDescription } = config.geo;
+  let orgName = identityPhrase.split(" ").slice(0, 2).join(" ");
+  try {
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+      if (pkg.name) {
+        orgName = pkg.name.replace(/-/g, " ").replace(/^\w/, (c) => c.toUpperCase());
+      }
+    }
+  } catch {
+  }
+  const schema = {
+    "@context": "https://schema.org",
+    "@graph": [
+      {
+        "@type": "Organization",
+        "@id": "#organization",
+        name: orgName,
+        description: shortDescription,
+        slogan: identityPhrase
+      },
+      {
+        "@type": "WebSite",
+        "@id": "#website",
+        name: orgName,
+        description: shortDescription,
+        publisher: { "@id": "#organization" }
+      },
+      {
+        "@type": "Service",
+        name: orgName,
+        description: shortDescription,
+        provider: { "@id": "#organization" }
+      }
+    ]
+  };
+  const jsonLd = JSON.stringify(schema, null, 2);
+  if (options.output) {
+    await writeFile(options.output, jsonLd, "utf-8");
+    console.log(chalk.green(`\u2705 Schema written to ${options.output}`));
+  } else {
+    console.log(chalk.bold("Generated JSON-LD:\n"));
+    console.log(chalk.cyan(jsonLd));
+  }
+  if (options.apply) {
+    console.log(chalk.dim("\nAttempting to insert into homepage <head>...\n"));
+    const indexFiles = await glob("**/index.html", { cwd, ignore: ["**/node_modules/**", "**/dist/**"] });
+    if (indexFiles.length === 0) {
+      console.log(chalk.yellow("No index.html found. Manually add to your HTML <head>:"));
+      console.log(chalk.dim(`<script type="application/ld+json">
+${jsonLd}
+</script>`));
+      return;
+    }
+    const firstIndexFile = indexFiles[0];
+    if (!firstIndexFile) {
+      console.log(chalk.yellow("No index.html found."));
+      return;
+    }
+    const indexPath = join(cwd, firstIndexFile);
+    let indexContent = await readFile(indexPath, "utf-8");
+    const scriptTag = `<script type="application/ld+json">
+${jsonLd}
+</script>`;
+    if (indexContent.includes("application/ld+json")) {
+      console.log(chalk.yellow("JSON-LD already exists in index.html. Remove it first or update manually."));
+      return;
+    }
+    indexContent = indexContent.replace("</head>", `${scriptTag}
+</head>`);
+    await writeFile(indexPath, indexContent, "utf-8");
+    console.log(chalk.green(`\u2705 JSON-LD inserted into ${firstIndexFile}`));
+  }
+  console.log();
+}
+var FAQ_SYSTEM_PROMPT = `You are a GEO/AEO Specialist generating FAQ content for FAQPage schema markup.
+
+Your job is NOT to make the company sound impressive. Your job is to write Q&As that:
+  1. Match what real prospects actually ask (not marketing-team wishful questions)
+  2. Are citable by AI agents in a single quoted sentence
+  3. Contain specific, verifiable facts (numbers, named outcomes, named integrations)
+
+QUESTION RULES:
+  - 6-8 questions.
+  - Always include "What is [brand]?" and "How does [brand] work?"
+  - Each question maps to a real buyer search intent (not "Why is your product the best?")
+
+ANSWER RULES:
+  - 2-3 sentences per answer.
+  - Each sentence aims for <=18 tokens (AI citation budget).
+  - First sentence must contain the most citable fact in the answer.
+  - No unsupported claims. No banned language.
+  - No "we are committed to" / "we strive to" / "we believe" hedging.
+
+BANNED WORDS (do not use):
+  ${BANNED_WORDS_GENERIC.slice(0, 12).join(", ")},
+  ${BANNED_WORDS_AI_WASHING.join(", ")}
+
+Output your response as valid JSON exactly matching the requested schema.`;
+async function geoFaq(options) {
+  const cwd = process.cwd();
+  console.log(chalk.blue("\n\u2753 FAQ Schema Generator\n"));
+  const config = await loadGeoConfig(cwd);
+  if (!config.geo?.identityPhrase || !config.geo?.shortDescription) {
+    console.log(chalk.yellow("No identity defined."));
+    console.log(chalk.dim(`Run 'archon geo identity' first.
+`));
+    return;
+  }
+  const { identityPhrase, shortDescription } = config.geo;
+  const { allowed, tier } = await checkStrongModelAccess();
+  if (!allowed) {
+    console.log(chalk.yellow(`[!] Your tier (${tier}) uses basic models.`));
+    console.log(chalk.dim("For better results, use BYOK mode with your own provider key.\n"));
+  }
+  console.log(chalk.dim("Generating FAQ content with AI...\n"));
+  const agent = new ArchitectAgent({ temperature: 0.7 });
+  const prompt = `Generate FAQ content for a product/service with:
+- Brand phrase: "${identityPhrase}"
+- Description: "${shortDescription}"
+
+Generate 6-8 FAQs as JSON:
+{
+  "faqs": [
+    { "question": "What is...?", "answer": "..." },
+    ...
+  ]
+}`;
+  const response = await agent.client.chat(
+    FAQ_SYSTEM_PROMPT,
+    prompt,
+    { temperature: 0.7, maxTokens: 2e3 }
+  );
+  const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    console.log(chalk.red("Failed to generate FAQ content."));
+    return;
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  for (const faq of parsed.faqs) {
+    const issues = validateFaqAnswer(faq.answer);
+    for (const issue of issues) {
+      console.log(chalk.yellow(`[!] FAQ "${faq.question.slice(0, 40)}...": ${issue.message}`));
+    }
+  }
+  const faqSchema = {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    mainEntity: parsed.faqs.map((faq) => ({
+      "@type": "Question",
+      name: faq.question,
+      acceptedAnswer: {
+        "@type": "Answer",
+        text: faq.answer
+      }
+    }))
+  };
+  const jsonLd = JSON.stringify(faqSchema, null, 2);
+  if (options.output) {
+    await writeFile(options.output, jsonLd, "utf-8");
+    console.log(chalk.green(`\u2705 FAQ schema written to ${options.output}`));
+  } else {
+    console.log(chalk.bold("Generated FAQPage JSON-LD:\n"));
+    console.log(chalk.cyan(jsonLd));
+  }
+  console.log();
+}
+var ATOMIC_CLAIMS_SYSTEM_PROMPT = `You are a GEO/AEO Specialist producing "atomic claims" \u2014 short, citable sentences AI agents can quote whole.
+
+ATOMIC CLAIM RULES (each one):
+  - <=18 tokens.
+  - Self-contained: makes sense without surrounding context.
+  - Specific: one verifiable idea per sentence.
+  - Outcome-focused: prefer "We cut scheduling time 60% for healthcare teams" over "We help teams be more productive".
+  - No banned language. No hedging. No corporate filler.
+
+BANNED WORDS (do not use):
+  ${BANNED_WORDS_GENERIC.join(", ")},
+  ${BANNED_WORDS_AI_WASHING.join(", ")}
+
+Output strict JSON.`;
+async function geoClaims(options) {
+  const cwd = process.cwd();
+  const count = options.count ?? 12;
+  console.log(chalk.blue("\n\u{1F9F1} Atomic Claims Generator\n"));
+  const config = await loadGeoConfig(cwd);
+  if (!config.geo?.identityPhrase || !config.geo?.shortDescription) {
+    console.log(chalk.yellow("No identity defined."));
+    console.log(chalk.dim(`Run 'archon geo identity' first.
+`));
+    return;
+  }
+  const { identityPhrase, shortDescription, businessContext, audienceContext } = config.geo;
+  console.log(chalk.dim(`Generating ${count} atomic claims with AI...
+`));
+  const agent = new ArchitectAgent({ temperature: 0.7 });
+  const prompt = `INPUTS:
+  identityPhrase: "${identityPhrase}"
+  shortDescription: "${shortDescription}"
+  businessContext: ${businessContext ?? "(not provided)"}
+  audienceContext: ${audienceContext ?? "(not provided)"}
+
+TASK: Generate ${count} atomic claim sentences. Each <=18 tokens, self-contained, specific, outcome-focused.
+
+Output JSON: { "claims": ["sentence one.", "sentence two.", ...] }`;
+  const response = await agent.client.chat(
+    ATOMIC_CLAIMS_SYSTEM_PROMPT,
+    prompt,
+    { temperature: 0.7, maxTokens: 1500 }
+  );
+  const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    console.log(chalk.red("Failed to parse claims response."));
+    return;
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  const validated = [];
+  for (const claim of parsed.claims) {
+    const tokens = approxTokenCount(claim);
+    const banned = findBannedWords(claim);
+    const warnings = [];
+    if (tokens > 22) warnings.push(`~${tokens} tokens (over budget)`);
+    if (banned.length > 0) warnings.push(`banned: ${banned.join(", ")}`);
+    validated.push({ text: claim, tokens, warnings });
+  }
+  console.log(chalk.bold("Generated atomic claims:\n"));
+  validated.forEach((c, i) => {
+    const flag = c.warnings.length > 0 ? chalk.yellow(" [!]") : chalk.green(" \u2713");
+    console.log(`  ${i + 1}.${flag} ${c.text} ${chalk.dim(`(~${c.tokens} tokens)`)}`);
+    for (const w of c.warnings) console.log(chalk.dim(`        ${w}`));
+  });
+  const geoDir = join(cwd, ".archon", "geo");
+  if (!existsSync(geoDir)) await mkdir(geoDir, { recursive: true });
+  const outputPath = options.output ?? join(geoDir, "ai-claims.json");
+  await writeFile(outputPath, JSON.stringify({
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    identityPhrase,
+    claims: validated.map((c) => c.text)
+  }, null, 2), "utf-8");
+  console.log();
+  console.log(chalk.green(`\u2705 Saved to ${outputPath}`));
+  console.log(chalk.dim(`Place these in the first 15% of relevant pages. Aim for 3+ atomic claims above the fold.`));
+}
+var WASHING_AUDIT_SYSTEM_PROMPT = `You are an AI-washing auditor. Your job is to find claims in public-facing copy that:
+  1. Use AI-washing language (AI-native, AI-powered, AI-driven, agentic, etc.) without specific evidence.
+  2. Use generic category furniture (innovative, world-class, end-to-end, etc.).
+  3. Make capability claims that cannot be cited to specific product behavior.
+
+You are NOT a stylistic editor. You are looking for trust-debt \u2014 claims that will catch up with the company.
+
+For each problematic claim, produce:
+  - The exact phrase
+  - Severity: critical | high | medium | low
+  - Why this is a problem (one sentence)
+  - What evidence the company would need to defend it
+  - A rewrite candidate that is defensible (specific, narrow, true)
+
+Be direct. Do not soften findings. If a claim is fine, do not list it.
+
+Output strict JSON.`;
+async function geoWashingAudit(options) {
+  const cwd = process.cwd();
+  console.log(chalk.blue("\n\u{1F6A8} AI-Washing Risk Register\n"));
+  const surfaces = await detectSurfaces(cwd);
+  if (surfaces.length === 0) {
+    console.log(chalk.yellow("No public surfaces detected."));
+    return [];
+  }
+  const corpus = surfaces.map((s) => `--- ${s.label} (${s.path}) ---
+${s.content.slice(0, 4e3)}`).join("\n\n");
+  console.log(chalk.dim(`Scanning ${surfaces.length} surface(s)...
+`));
+  const agent = new ArchitectAgent({ temperature: 0.3 });
+  const prompt = `Audit this public copy for AI-washing and unsupported claims.
+
+${corpus}
+
+Output JSON:
+{
+  "findings": [
+    {
+      "phrase": "exact phrase from copy",
+      "source": "surface label",
+      "severity": "critical|high|medium|low",
+      "problem": "one sentence",
+      "evidenceRequired": "what would justify this claim",
+      "rewriteCandidate": "defensible alternative"
+    }
+  ]
+}`;
+  const response = await agent.client.chat(
+    WASHING_AUDIT_SYSTEM_PROMPT,
+    prompt,
+    { temperature: 0.3, maxTokens: 3e3 }
+  );
+  const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    console.log(chalk.red("Failed to parse audit response."));
+    return [];
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  const findings = parsed.findings ?? [];
+  for (const surface of surfaces) {
+    for (const ban of BANNED_WORDS_AI_WASHING) {
+      if (surface.content.toLowerCase().includes(ban.toLowerCase())) {
+        if (!findings.some((f) => f.phrase.toLowerCase().includes(ban.toLowerCase()) && f.source === surface.label)) {
+          findings.push({
+            phrase: ban,
+            source: surface.label,
+            severity: "high",
+            problem: `AI-washing tell appears in copy without inline evidence.`,
+            evidenceRequired: `Cite the specific product behavior or capability that backs "${ban}".`,
+            rewriteCandidate: `Replace with the narrow, true description of what the product actually does.`
+          });
+        }
+      }
+    }
+  }
+  if (findings.length === 0) {
+    console.log(chalk.green("\u2705 No AI-washing findings."));
+  } else {
+    const bySeverity = { critical: [], high: [], medium: [], low: [] };
+    for (const f of findings) bySeverity[f.severity]?.push(f);
+    for (const sev of ["critical", "high", "medium", "low"]) {
+      const list = bySeverity[sev] ?? [];
+      if (list.length === 0) continue;
+      const color = sev === "critical" ? chalk.red : sev === "high" ? chalk.yellow : chalk.dim;
+      console.log(color.bold(`
+${sev.toUpperCase()} (${list.length})`));
+      list.forEach((f, i) => {
+        console.log(color(`  ${i + 1}. "${f.phrase}" \u2014 ${f.source}`));
+        console.log(chalk.dim(`     Problem: ${f.problem}`));
+        console.log(chalk.dim(`     Evidence required: ${f.evidenceRequired}`));
+        console.log(chalk.dim(`     Rewrite: ${f.rewriteCandidate}`));
+      });
+    }
+  }
+  const geoDir = join(cwd, ".archon", "geo");
+  if (!existsSync(geoDir)) await mkdir(geoDir, { recursive: true });
+  const outputPath = options.output ?? join(geoDir, "ai-washing-risk-register.md");
+  const md = renderWashingRegister(findings);
+  await writeFile(outputPath, md, "utf-8");
+  console.log();
+  console.log(chalk.green(`\u2705 Risk register saved to ${outputPath}`));
+  return findings;
+}
+function renderWashingRegister(findings) {
+  const lines = [];
+  lines.push(`# AI-Washing Risk Register`);
+  lines.push(``);
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(``);
+  lines.push(`Each finding = a public claim that creates trust-debt unless backed by evidence.`);
+  lines.push(``);
+  for (const sev of ["critical", "high", "medium", "low"]) {
+    const list = findings.filter((f) => f.severity === sev);
+    if (list.length === 0) continue;
+    lines.push(`## ${sev.toUpperCase()} (${list.length})`);
+    lines.push(``);
+    for (const f of list) {
+      lines.push(`### "${f.phrase}"`);
+      lines.push(`- **Source:** ${f.source}`);
+      lines.push(`- **Problem:** ${f.problem}`);
+      lines.push(`- **Evidence required:** ${f.evidenceRequired}`);
+      lines.push(`- **Rewrite candidate:** ${f.rewriteCandidate}`);
+      lines.push(``);
+    }
+  }
+  return lines.join("\n");
+}
+async function readFileSafe(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function findFirstFile(cwd, patterns) {
+  for (const pattern of patterns) {
+    const files = await glob(pattern, { cwd, ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/build/**"] });
+    if (files.length > 0) {
+      const first = files[0];
+      if (!first) continue;
+      const fullPath = join(cwd, first);
+      const content = await readFileSafe(fullPath);
+      if (content.trim()) {
+        return { path: first, content };
+      }
+    }
+  }
+  return null;
+}
+async function detectSurfaces(cwd) {
+  const surfaces = [];
+  const candidates = [
+    { label: "Homepage", category: "core", patterns: ["**/index.html", "**/src/pages/index.astro", "**/pages/index.{tsx,jsx}", "**/app/page.{tsx,jsx}", "**/src/pages/index.{tsx,jsx,svelte,vue}"] },
+    { label: "Pricing", category: "core", patterns: ["**/pricing.{html,astro,tsx,jsx,svelte,vue,md}", "**/pricing/index.*", "**/src/pages/pricing.*"] },
+    { label: "Product/Features", category: "core", patterns: ["**/features.*", "**/product.*", "**/src/pages/features.*"] },
+    { label: "Customer Stories", category: "evidence", patterns: ["**/customers.*", "**/case-studies/**/*.md", "**/testimonials.*", "**/src/pages/customers.*"] },
+    { label: "Comparison", category: "evidence", patterns: ["**/compare.*", "**/vs/**/*.md", "**/alternatives.*", "**/src/pages/compare.*"] },
+    { label: "Integrations", category: "technical", patterns: ["**/integrations.*", "**/integrations/**/*.md", "**/src/pages/integrations.*"] },
+    { label: "Docs", category: "technical", patterns: ["**/docs.*", "**/docs/index.*", "**/documentation.*", "**/docs/**/README.md"] },
+    { label: "Changelog", category: "technical", patterns: ["**/CHANGELOG.md", "**/changelog.*"] },
+    { label: "README", category: "narrative", patterns: ["README.md"] },
+    { label: "Help Center", category: "technical", patterns: ["**/help.*", "**/support.*", "**/faq.*"] },
+    { label: "Blog", category: "narrative", patterns: ["**/blog/**/*.{md,mdx}", "**/posts/**/*.{md,mdx}"] }
+  ];
+  for (const c of candidates) {
+    const found = await findFirstFile(cwd, c.patterns);
+    if (found) {
+      surfaces.push({ label: c.label, category: c.category, path: found.path, content: found.content });
+    }
+  }
+  return surfaces;
+}
+async function geoQuickAudit() {
+  const cwd = process.cwd();
+  console.log(chalk.blue("\n\u{1F50D} GEO Audit\n"));
+  const result = {
+    identityDefined: false,
+    phraseInH1: false,
+    phraseInMetaDescription: false,
+    hasOrganizationSchema: false,
+    hasServiceSchema: false,
+    hasFAQSchema: false,
+    issues: []
+  };
+  const config = await loadGeoConfig(cwd);
+  if (config.geo?.identityPhrase && config.geo?.shortDescription) {
+    result.identityDefined = true;
+    console.log(chalk.green("\u2705 Identity defined"));
+    console.log(chalk.dim(`   Phrase: ${config.geo.identityPhrase}`));
+  } else {
+    result.issues.push('Identity not defined. Run "archon geo identity"');
+    console.log(chalk.red("\u274C Identity not defined"));
+  }
+  const htmlFiles = await glob("**/index.html", { cwd, ignore: ["**/node_modules/**", "**/dist/**"] });
+  const firstHtmlFile = htmlFiles[0];
+  if (firstHtmlFile && config.geo?.identityPhrase) {
+    const indexPath = join(cwd, firstHtmlFile);
+    const content = await readFile(indexPath, "utf-8");
+    const identityPhrase = config.geo.identityPhrase;
+    const firstKeyword = identityPhrase.toLowerCase().split(" ")[0] ?? "";
+    const h1Match = content.match(/<h1[^>]*>(.*?)<\/h1>/is);
+    if (h1Match?.[1] && h1Match[1].toLowerCase().includes(firstKeyword)) {
+      result.phraseInH1 = true;
+      console.log(chalk.green("\u2705 Brand keyword in H1"));
+    } else {
+      result.issues.push("Brand phrase keyword not found in H1");
+      console.log(chalk.yellow("[!] Brand keyword not in H1"));
+    }
+    const metaMatch = content.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["']/i);
+    if (metaMatch?.[1] && metaMatch[1].toLowerCase().includes(firstKeyword)) {
+      result.phraseInMetaDescription = true;
+      console.log(chalk.green("\u2705 Brand keyword in meta description"));
+    } else {
+      result.issues.push("Brand phrase keyword not found in meta description");
+      console.log(chalk.yellow("[!] Brand keyword not in meta description"));
+    }
+    if (content.includes("application/ld+json")) {
+      if (content.includes('"@type":"Organization"') || content.includes('"@type": "Organization"')) {
+        result.hasOrganizationSchema = true;
+        console.log(chalk.green("\u2705 Organization schema present"));
+      } else {
+        result.issues.push("Organization schema not found");
+        console.log(chalk.yellow("[!] Organization schema missing"));
+      }
+      if (content.includes('"@type":"Service"') || content.includes('"@type": "Service"')) {
+        result.hasServiceSchema = true;
+        console.log(chalk.green("\u2705 Service schema present"));
+      } else {
+        result.issues.push("Service schema not found");
+        console.log(chalk.yellow("[!] Service schema missing"));
+      }
+      if (content.includes('"@type":"FAQPage"') || content.includes('"@type": "FAQPage"')) {
+        result.hasFAQSchema = true;
+        console.log(chalk.green("\u2705 FAQPage schema present"));
+      } else {
+        result.issues.push("FAQPage schema not found");
+        console.log(chalk.yellow("[!] FAQPage schema missing"));
+      }
+    } else {
+      result.issues.push("No JSON-LD schemas found");
+      console.log(chalk.red("\u274C No JSON-LD schemas found"));
+    }
+  } else if (htmlFiles.length === 0) {
+    result.issues.push("No index.html found");
+    console.log(chalk.yellow("[!] No index.html found to audit"));
+  }
+  console.log();
+  const passed = result.issues.length === 0;
+  if (passed) {
+    console.log(chalk.green.bold("\u2705 GEO Audit Passed"));
+  } else {
+    console.log(chalk.yellow.bold(`[!] ${result.issues.length} issue(s) found`));
+    console.log();
+    console.log(chalk.bold("Recommendations:"));
+    result.issues.forEach((issue, i) => {
+      console.log(chalk.dim(`  ${i + 1}. ${issue}`));
+    });
+  }
+  console.log();
+  await recordWebCheckResult(cwd, "geo", passed);
+  return result;
+}
+var SURFACE_AUDIT_SYSTEM_PROMPT = `You are an Agent Clarity Auditor. You read public surfaces from the perspective of an AI agent that must shortlist, summarize, compare, or categorize this company on behalf of a buyer.
+
+You are literal. Evidence-driven. Intolerant of vagueness. You build a model of the company from whatever you can find.
+
+For EACH surface, produce:
+  - inference: 1-3 sentences. What model would an AI build from this surface alone?
+  - missing: specific gaps. Not "could be clearer" \u2014 name what is absent.
+  - contradictionRisk: where this conflicts with other surfaces. If none, say so.
+  - fixPriority: high | medium | low with one-sentence rationale.
+
+After per-surface analysis:
+  - aggregateCoherence: 2-3 paragraphs. When an agent reads ALL surfaces, what company emerges? Is it one story or several? Be specific about which surfaces pull in different directions.
+  - invisibleLossScenarios: 3-5 concrete scenarios. Format: "A buyer asks an AI to [task]. The agent [what happens]. Result: [what the company loses and why]."
+  - rankedFixes: top 5 fixes ordered by impact. Name the surface, the current problem, what the improved version looks like.
+
+Be direct. Do not soften findings. If a surface is incoherent, say so.
+
+Output strict JSON.`;
+async function geoSurfaceAudit(options = {}) {
+  const cwd = process.cwd();
+  console.log(chalk.blue("\n\u{1F6F0}  Agent Clarity Audit (surface walk)\n"));
+  const surfaces = await detectSurfaces(cwd);
+  const allLabels = ["Homepage", "Pricing", "Product/Features", "Customer Stories", "Comparison", "Integrations", "Docs", "Changelog", "README", "Help Center", "Blog"];
+  const detectedLabels = surfaces.map((s) => s.label);
+  const blindSpots = allLabels.filter((l) => !detectedLabels.includes(l));
+  if (surfaces.length === 0) {
+    console.log(chalk.yellow("No public surfaces detected \u2014 nothing to audit."));
+    return null;
+  }
+  console.log(chalk.dim(`Detected ${surfaces.length} surface(s): ${detectedLabels.join(", ")}`));
+  if (blindSpots.length > 0) {
+    console.log(chalk.yellow(`Blind spots (not found): ${blindSpots.join(", ")}`));
+  }
+  console.log();
+  console.log(chalk.dim("Running agent-perspective audit...\n"));
+  const corpus = surfaces.map((s) => `--- ${s.label} (${s.path}) ---
+${s.content.slice(0, 5e3)}`).join("\n\n");
+  const agent = new ArchitectAgent({ temperature: 0.4 });
+  const prompt = `Audit these public surfaces from an AI agent's perspective.
+
+${corpus}
+
+Detected surfaces: ${detectedLabels.join(", ")}
+Blind spots (surfaces that do not exist): ${blindSpots.join(", ") || "(none)"}
+
+For blind spots, add entries with surface label "[Surface] \u2014 BLIND SPOT" explaining what an agent would look for and what the absence implies.
+
+Output JSON:
+{
+  "findings": [
+    { "surface": "...", "inference": "...", "missing": "...", "contradictionRisk": "...", "fixPriority": "high|medium|low", "rationale": "..." }
+  ],
+  "aggregateCoherence": "2-3 paragraphs",
+  "invisibleLossScenarios": ["scenario 1", "scenario 2", "scenario 3"],
+  "rankedFixes": [
+    { "surface": "...", "problem": "...", "improvedVersion": "..." }
+  ]
+}`;
+  const response = await agent.client.chat(
+    SURFACE_AUDIT_SYSTEM_PROMPT,
+    prompt,
+    { temperature: 0.4, maxTokens: 4e3 }
+  );
+  const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    console.log(chalk.red("Failed to parse audit response."));
+    return null;
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  const report = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    surfacesAudited: detectedLabels,
+    blindSpots,
+    ...parsed
+  };
+  console.log(chalk.bold("Per-surface findings:\n"));
+  for (const f of report.findings) {
+    const color = f.fixPriority === "high" ? chalk.red : f.fixPriority === "medium" ? chalk.yellow : chalk.dim;
+    console.log(color.bold(`  ${f.surface}  [${f.fixPriority.toUpperCase()}]`));
+    console.log(chalk.dim(`    inference:           ${f.inference}`));
+    console.log(chalk.dim(`    missing:             ${f.missing}`));
+    console.log(chalk.dim(`    contradiction risk:  ${f.contradictionRisk}`));
+    console.log(chalk.dim(`    rationale:           ${f.rationale}`));
+    console.log();
+  }
+  console.log(chalk.bold("Aggregate coherence:\n"));
+  console.log(chalk.dim(`  ${report.aggregateCoherence}`));
+  console.log();
+  console.log(chalk.bold("Invisible loss scenarios:\n"));
+  report.invisibleLossScenarios.forEach((s, i) => console.log(chalk.dim(`  ${i + 1}. ${s}`)));
+  console.log();
+  console.log(chalk.bold("Ranked fixes:\n"));
+  report.rankedFixes.forEach((f, i) => {
+    console.log(`  ${i + 1}. ${chalk.cyan(f.surface)}`);
+    console.log(chalk.dim(`     Problem: ${f.problem}`));
+    console.log(chalk.dim(`     Improved: ${f.improvedVersion}`));
+  });
+  console.log();
+  const geoDir = join(cwd, ".archon", "geo");
+  if (!existsSync(geoDir)) await mkdir(geoDir, { recursive: true });
+  const outputPath = options.output ?? join(geoDir, "surface-audit.md");
+  await writeFile(outputPath, renderSurfaceAudit(report), "utf-8");
+  console.log(chalk.green(`\u2705 Report saved to ${outputPath}`));
+  await recordWebCheckResult(cwd, "geo", report.findings.every((f) => f.fixPriority !== "high"));
+  return report;
+}
+function renderSurfaceAudit(report) {
+  const lines = [];
+  lines.push(`# Agent Clarity Audit`);
+  lines.push(``);
+  lines.push(`Generated: ${report.generatedAt}`);
+  lines.push(``);
+  lines.push(`Surfaces audited: ${report.surfacesAudited.join(", ")}`);
+  if (report.blindSpots.length > 0) {
+    lines.push(`Blind spots: ${report.blindSpots.join(", ")}`);
+  }
+  lines.push(``);
+  lines.push(`## Per-Surface Findings`);
+  lines.push(``);
+  for (const f of report.findings) {
+    lines.push(`### ${f.surface} \u2014 ${f.fixPriority.toUpperCase()}`);
+    lines.push(``);
+    lines.push(`- **Inference:** ${f.inference}`);
+    lines.push(`- **Missing:** ${f.missing}`);
+    lines.push(`- **Contradiction risk:** ${f.contradictionRisk}`);
+    lines.push(`- **Rationale:** ${f.rationale}`);
+    lines.push(``);
+  }
+  lines.push(`## Aggregate Coherence`);
+  lines.push(``);
+  lines.push(report.aggregateCoherence);
+  lines.push(``);
+  lines.push(`## Invisible Loss Scenarios`);
+  lines.push(``);
+  report.invisibleLossScenarios.forEach((s, i) => lines.push(`${i + 1}. ${s}`));
+  lines.push(``);
+  lines.push(`## Ranked Fixes`);
+  lines.push(``);
+  report.rankedFixes.forEach((f, i) => {
+    lines.push(`### ${i + 1}. ${f.surface}`);
+    lines.push(`- **Problem:** ${f.problem}`);
+    lines.push(`- **Improved:** ${f.improvedVersion}`);
+    lines.push(``);
+  });
+  return lines.join("\n");
+}
+async function geoAudit(options = {}) {
+  if (options.quick) {
+    return geoQuickAudit();
+  }
+  const report = await geoSurfaceAudit();
+  if (!report) {
+    console.log(chalk.dim("Falling back to quick audit (index.html-only)...\n"));
+    return geoQuickAudit();
+  }
+  return report;
+}
+function createGeoCommand() {
+  const geo = new Command("geo").description("GEO (Generative Engine Optimization) \u2014 memory for humans, clarity for agents").addHelpText(
+    "after",
+    `
+Examples:
+  archon geo identity              Generate brand identity (7-word + 50-word + context artifacts)
+  archon geo schema                Generate Organization + Service JSON-LD
+  archon geo schema --apply        Insert JSON-LD into homepage
+  archon geo faq                   Generate FAQPage schema (with 18-token sentence validation)
+  archon geo claims                Generate atomic claims (<=18 tokens each)
+  archon geo audit                 Full surface walk (homepage, pricing, docs, comparison, etc.)
+  archon geo audit --quick         Legacy per-file check (index.html only)
+  archon geo washing-audit         Scan public copy for AI-washing claims
+`
+  );
+  geo.command("identity").description("Generate brand identity + businessContext + audienceContext artifacts").action(async () => {
+    await geoIdentity();
+  });
+  geo.command("schema").description("Generate JSON-LD Organization and Service schemas").option("-o, --output <file>", "Write schema to file").option("-a, --apply", "Insert schema into homepage <head>").action(async (options) => {
+    await geoSchema(options);
+  });
+  geo.command("faq").description("Generate FAQPage JSON-LD schema (sentence-budget validated)").option("-o, --output <file>", "Write FAQ schema to file").action(async (options) => {
+    await geoFaq(options);
+  });
+  geo.command("claims").description("Generate atomic claims (<=18 tokens each) for agent citation").option("-c, --count <n>", "Number of claims to generate", (v) => parseInt(v, 10), 12).option("-o, --output <file>", "Write claims to file (default .archon/geo/ai-claims.json)").action(async (options) => {
+    await geoClaims(options);
+  });
+  geo.command("audit").description("Agent Clarity Audit \u2014 multi-surface walk (default) or per-file quick check").option("--quick", "Run legacy per-file check (index.html only)").action(async (options) => {
+    await geoAudit(options);
+  });
+  geo.command("washing-audit").description("AI-washing risk register \u2014 find unsupported claims in public copy").option("-o, --output <file>", "Write register to file (default .archon/geo/ai-washing-risk-register.md)").action(async (options) => {
+    await geoWashingAudit(options);
+  });
+  geo.action(async () => {
+    await geoAudit();
+  });
+  return geo;
+}
+
+export {
+  BANNED_WORDS_GENERIC,
+  BANNED_WORDS_AI_WASHING,
+  BANNED_WORDS_ALL,
+  approxTokenCount,
+  findBannedWords,
+  wordCount,
+  splitSentences,
+  validateSevenWordPhrase,
+  validateFiftyWordDescription,
+  validateFaqAnswer,
+  geoIdentity,
+  geoSchema,
+  geoFaq,
+  geoClaims,
+  geoWashingAudit,
+  detectSurfaces,
+  geoQuickAudit,
+  geoSurfaceAudit,
+  geoAudit,
+  createGeoCommand
+};