cc-codeconductor 0.2.7 → 0.2.9

package/dist/index.js

@@ -7044,7 +7044,7 @@ function getExitCode(error) {
 // package.json
 var package_default = {
   name: "cc-codeconductor",
-  version: "0.2.7",
+  version: "0.2.9",
   description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
   keywords: [
     "ai",
@@ -7132,6 +7132,13 @@ async function detectProject(rootDir) {
     runtimes.push("python");
     frameworks.push("django");
   }
+  const phpSignals = await detectPhp(rootDir);
+  if (phpSignals.length > 0) {
+    signals.push(...phpSignals);
+    languages.push("php");
+    runtimes.push("php");
+    packageManagers.push("composer");
+  }
   const astroSignals = await detectAstro(rootDir);
   if (astroSignals.length > 0) {
     signals.push(...astroSignals);
@@ -7218,6 +7225,22 @@ async function detectAstro(rootDir) {
   }
   return signals;
 }
+async function detectPhp(rootDir) {
+  const { fileExists: fileExists2 } = await Promise.resolve().then(() => (init_safety(), exports_safety));
+  const signals = [];
+  if (await fileExists2(rootDir, "composer.json")) {
+    signals.push("composer.json");
+  }
+  try {
+    const { readdir } = await import("node:fs/promises");
+    const entries = await readdir(rootDir, { withFileTypes: true });
+    const hasPhpFiles = entries.some((entry) => entry.isFile() && entry.name.endsWith(".php"));
+    if (hasPhpFiles) {
+      signals.push("*.php");
+    }
+  } catch {}
+  return signals;
+}
 
 // src/commands/detect.command.ts
 async function detectCommand(options) {
@@ -11347,7 +11370,7 @@ var CodeConductorConfigSchema = exports_external.object({
     profile: exports_external.string().optional()
   }),
   defaults: exports_external.object({
-    target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor"]),
+    target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]),
     overwrite: exports_external.boolean()
   }),
   presets: exports_external.object({
@@ -11367,6 +11390,7 @@ var RunnerTargetSchema = exports_external.enum([
   "codex",
   "gemini",
   "cursor",
+  "agy",
   "all"
 ]);
 var InstallStrategySchema = exports_external.enum([
@@ -11384,20 +11408,23 @@ var ManifestEntrySchema = exports_external.object({
   template: exports_external.boolean().optional()
 });
 var InstallManifestSchema = exports_external.object({
-  target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor"]),
+  target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]),
   entries: exports_external.array(ManifestEntrySchema)
 });
 var ToolProviderNamesSchema = exports_external.record(exports_external.string(), exports_external.string());
+var PermissionProviderNamesSchema = exports_external.record(exports_external.string(), exports_external.string());
 var ModelConfigSchema = exports_external.object({
-  target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor"]),
+  target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]),
   agents: exports_external.record(exports_external.string(), exports_external.object({
     claude: exports_external.string().optional(),
     opencode: exports_external.string().optional(),
     codex: exports_external.string().optional(),
     gemini: exports_external.string().optional(),
-    cursor: exports_external.string().optional()
+    cursor: exports_external.string().optional(),
+    agy: exports_external.string().optional()
   })),
-  tools: exports_external.record(exports_external.string(), ToolProviderNamesSchema).optional()
+  tools: exports_external.record(exports_external.string(), ToolProviderNamesSchema).optional(),
+  permissions: PermissionProviderNamesSchema.optional()
 });
 function validateCouncilSpec(data) {
   return CouncilSpecSchema.parse(data);
@@ -11721,6 +11748,8 @@ function resolveAssets(target) {
       return ["agents", "prompts/v0.2.0"];
     case "cursor":
       return ["agents", "prompts/v0.2.0"];
+    case "agy":
+      return ["agents", "prompts/v0.2.0"];
   }
 }
 
@@ -11904,7 +11933,27 @@ function getResponsibilities(agentId) {
     devil: `- Challenge assumptions
 - Find edge cases
 - Identify failure modes
-- Stress test solutions`
+- Stress test solutions`,
+    "seo-auditor": `- Audit technical SEO
+- Check meta tags and headings
+- Validate crawl directives
+- Assess page speed signals`,
+    "schema-validator": `- Validate Schema.org markup
+- Check JSON-LD syntax
+- Verify required properties
+- Suggest structured data fixes`,
+    "geo-specialist": `- Assess AI-search readiness
+- Validate llms.txt
+- Check citable content
+- Review GEO optimization`,
+    "content-strategist": `- Plan content marketing
+- Guide off-page SEO
+- Suggest backlink strategy
+- Review hotel copywriting`,
+    "astro-specialist": `- Validate Astro SEO patterns
+- Check static generation
+- Review Islands Architecture
+- Optimize image handling`
   };
   return responsibilities[agentId] || "- Provide critical review";
 }
@@ -12082,7 +12131,7 @@ function createCodexInstaller(spec) {
 function generateOpenCodeFiles(spec) {
   const files = [];
   files.push({
-    path: ".opencode/commands/council.md",
+    path: ".opencode/commands/cc-council.md",
     content: generateCouncilCommand(spec),
     overwrite: false
   });
@@ -12094,17 +12143,20 @@ function generateOpenCodeFiles(spec) {
   for (const agent of spec.agents) {
     files.push({
       path: `.opencode/agents/council-${agent.id}.md`,
-      content: generateAgentContent(agent),
+      content: generateOpenCodeAgentContent(agent),
       overwrite: false
     });
   }
   return files;
 }
 function generateCouncilCommand(spec) {
-  return `# Council Command
+  return `---
+description: ${yamlString(spec.description)}
+agent: council-lead
+subtask: true
+---
 
-## Description
-${spec.description}
+Run the CodeConductor council for multi-perspective analysis.
 
 ## Version
 ${spec.version}
@@ -12113,12 +12165,25 @@ ${spec.version}
 ${spec.agents.map((a) => `- ${a.role} (${a.id})`).join(`
 `)}
 
-## Usage
-Invoke this command to get multi-perspective analysis from the council.
+## Instructions
+Coordinate with the council agents and synthesize their perspectives into the configured output contract.
 `;
 }
 function generateCouncilLead(spec) {
-  return `# Council Lead Agent
+  return `---
+description: ${yamlString(`${spec.description} Council lead. Coordinates council members and synthesizes recommendations.`)}
+mode: subagent
+permission:
+  read: allow
+  edit: deny
+  bash: deny
+  glob: allow
+  grep: allow
+  webfetch: deny
+  websearch: deny
+---
+
+# Council Lead Agent
 
 ## Role
 Coordinates the council and synthesizes perspectives
@@ -12137,6 +12202,37 @@ ${spec.agents.map((a) => `- ${a.role}: ${a.focus.join(", ")}`).join(`
 - Provide final recommendation
 `;
 }
+function generateOpenCodeAgentContent(agent) {
+  return `---
+description: ${yamlString(`${agent.role} council agent. Focus: ${agent.focus.join(", ")}. Context: ${agent.context}. Model hint: ${agent.modelHint}.`)}
+mode: subagent
+permission:
+${generatePermissionBlock(agent.context)}
+---
+
+${generateAgentContent(agent)}`;
+}
+function generatePermissionBlock(context) {
+  if (context === "repo-readonly") {
+    return `  read: allow
+  edit: deny
+  bash: deny
+  glob: allow
+  grep: allow
+  webfetch: deny
+  websearch: deny`;
+  }
+  return `  read: deny
+  edit: deny
+  bash: deny
+  glob: deny
+  grep: deny
+  webfetch: deny
+  websearch: deny`;
+}
+function yamlString(value) {
+  return JSON.stringify(value);
+}
 
 // src/adapters/opencode/opencode-installer.ts
 class OpenCodeInstaller {
@@ -12320,7 +12416,7 @@ function renderTemplate(content, modelConfig, filePath) {
     const agentModels = modelConfig.agents[agentRole];
     const targetModel = agentModels[modelConfig.target];
     let result2 = content.replace(/\{\{MODEL\}\}/g, targetModel ?? "").replace(/\{\{MODEL_CLAUDE\}\}/g, agentModels.claude ?? "").replace(/\{\{MODEL_OPENCODE\}\}/g, agentModels.opencode ?? "").replace(/\{\{MODEL_CODEX\}\}/g, agentModels.codex ?? "").replace(/\{\{MODEL_GEMINI\}\}/g, agentModels.gemini ?? "").replace(/\{\{MODEL_CURSOR\}\}/g, agentModels.cursor ?? "");
-    if (modelConfig.tools) {
+    if (modelConfig.tools || modelConfig.permissions) {
       result2 = substituteToolNames(result2, modelConfig);
     }
     return result2;
@@ -12349,19 +12445,27 @@ function renderTemplate(content, modelConfig, filePath) {
       }
     }
   }
-  if (modelConfig.tools) {
+  if (modelConfig.tools || modelConfig.permissions) {
     result = substituteToolNames(result, modelConfig);
   }
   return result;
 }
 function substituteToolNames(content, modelConfig) {
-  if (!modelConfig.tools)
+  if (!modelConfig.tools && !modelConfig.permissions)
     return content;
   const target = modelConfig.target;
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch)
     return content;
   const frontmatter = fmMatch[1];
+  if (target === "opencode" && modelConfig.permissions) {
+    const updatedFrontmatter2 = frontmatter.replace(/^tools:\s*(.+)\n?/m, "");
+    return content.replace(fmMatch[0], `---
+${updatedFrontmatter2}
+---`);
+  }
+  if (!modelConfig.tools)
+    return content;
   const updatedFrontmatter = frontmatter.replace(/^tools:\s*(.+)$/m, (_match, toolsLine) => {
     const baseNames = toolsLine.split(",").map((t) => t.trim());
     const mappedNames = baseNames.map((baseName) => {
@@ -12390,7 +12494,7 @@ async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTem
   const incomingContent = isTemplate && modelConfig ? renderTemplate(content, modelConfig, srcPath) : content;
   let finalContent = incomingContent;
   let action = "written";
-  if (strategy === "append" && !force) {
+  if (strategy === "append") {
     let existing = "";
     try {
       existing = await readFile4(destPath, "utf-8");
@@ -12403,7 +12507,7 @@ async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTem
 ` + incomingContent;
     }
     action = "appended";
-  } else if (strategy === "merge-json" && !force) {
+  } else if (strategy === "merge-json") {
     let existing = {};
     try {
       existing = JSON.parse(await readFile4(destPath, "utf-8"));
@@ -12504,8 +12608,8 @@ async function loadCouncilPreset(projectRoot) {
 }
 
 // src/core/runner/runner-target.ts
-var RUNNER_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "all"];
-var INDIVIDUAL_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor"];
+var RUNNER_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "agy", "all"];
+var INDIVIDUAL_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "agy"];
 function isRunnerTarget(value) {
   return RUNNER_TARGETS.includes(value);
 }
@@ -12661,202 +12765,2335 @@ async function installPresetCommand(options) {
   }
 }
 
-// src/commands/update.command.ts
-async function updateCommand(options) {
-  const { dryRun, force, output, projectRoot } = options;
-  try {
-    const configResult = await loadConfig(projectRoot);
-    if (!configResult.success) {
-      return {
-        code: 1,
-        data: {
-          success: false,
-          command: "update",
-          errors: ["No config found. Run `codeconductor init` first."]
-        }
-      };
-    }
-    const config = configResult.data;
-    if (!config.presets.council.enabled) {
-      return {
-        code: 4,
-        data: {
-          success: false,
-          command: "update",
-          errors: ["Council preset is not enabled"]
-        }
-      };
+// src/commands/install-lsp.command.ts
+import { homedir as homedir4 } from "node:os";
+import { resolve as resolve8 } from "node:path";
+
+// src/core/lsp/lsp-config-utils.ts
+function getLanguageServerConfig(lspIds) {
+  const languageServers = {};
+  for (const lspId of lspIds) {
+    const config = getLspCommand(lspId);
+    if (config) {
+      languageServers[lspId] = { command: config.command, args: [...config.args] };
     }
-    const presetResult = await loadCouncilPreset(projectRoot);
-    if (!presetResult.success) {
-      return {
-        code: 1,
-        data: {
-          success: false,
-          command: "update",
-          errors: ["Failed to load preset"]
-        }
-      };
+  }
+  return languageServers;
+}
+function getLspCommand(lspId) {
+  switch (lspId) {
+    case "typescript":
+      return { command: "typescript-language-server", args: ["--stdio"] };
+    case "php":
+      return { command: "intelephense", args: ["--stdio"] };
+    case "python":
+      return { command: "pyright-langserver", args: ["--stdio"] };
+    case "kotlin":
+      return { command: "kotlin-language-server", args: [] };
+    default:
+      return;
+  }
+}
+
+// src/adapters/agy/agy-lsp-generator.ts
+class AgyLspGenerator {
+  name = "agy-lsp";
+  target = "agy";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
     }
-    const spec = presetResult.data;
-    const currentVersion = config.presets.council.version;
-    const newVersion = spec.version;
-    if (currentVersion === newVersion) {
-      return {
-        code: 0,
-        data: {
-          success: true,
-          command: "update",
-          message: "Already up to date",
-          currentVersion,
-          newVersion
+    const sections = [
+      "# Agy LSP Configuration (experimental)",
+      "# NOTE: Agy config format may change as the tool evolves",
+      ""
+    ];
+    for (const lsp of successfulLsps) {
+      const config = getLspCommand(lsp.lspId);
+      if (config) {
+        sections.push(`${lsp.lspId}:`);
+        sections.push(`  command: ${config.command}`);
+        if (config.args.length > 0) {
+          sections.push(`  args: [${config.args.join(", ")}]`);
         }
-      };
+        sections.push("");
+      }
     }
-    if (dryRun) {
-      return {
-        code: 0,
-        data: {
-          success: true,
-          command: "update",
-          message: "Dry run - would update",
-          currentVersion,
-          newVersion,
-          wouldUpdate: ["council preset files"]
-        }
-      };
+    return [
+      {
+        path: ".agy/tools.yaml",
+        content: sections.join(`
+`),
+        overwrite: false
+      }
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+function createAgyLspGenerator() {
+  return new AgyLspGenerator;
+}
+
+// src/adapters/claude/claude-lsp-generator.ts
+class ClaudeLspGenerator {
+  name = "claude-lsp";
+  target = "claude";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
     }
-    const writeOptions = { dryRun: false, force };
-    const target = config.defaults.target;
-    let installer;
-    switch (target) {
-      case "opencode":
-        installer = createOpenCodeInstaller(spec);
-        break;
-      case "claude":
-        installer = createClaudeInstaller(spec);
-        break;
-      case "codex":
-        installer = createCodexInstaller(spec);
-        break;
-      default:
-        return {
-          code: 1,
-          data: {
-            success: false,
-            command: "update",
-            errors: [`Unknown target: ${target}`]
-          }
-        };
+    const languageServers = getLanguageServerConfig(successfulLsps.map((lsp) => lsp.lspId));
+    const content = JSON.stringify(languageServers, null, 2);
+    return [
+      {
+        path: ".claude/plugins/codeconductor-lsp/.lsp.json",
+        content,
+        overwrite: false
+      }
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+function createClaudeLspGenerator() {
+  return new ClaudeLspGenerator;
+}
+
+// src/adapters/codex/codex-lsp-generator.ts
+class CodexLspGenerator {
+  name = "codex-lsp";
+  target = "codex";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
     }
-    const files = await installer.generate();
-    const results = await writeGeneratedFiles(files, writeOptions);
-    const updated = results.filter((r) => r.success).map((r) => r.path);
-    const errors3 = results.filter((r) => !r.success).map((r) => `${r.path}: ${r.error}`);
-    if (errors3.length > 0) {
-      return {
-        code: 2,
-        data: {
-          success: false,
-          command: "update",
-          errors: errors3
+    const sections = ["# Codex LSP Configuration", ""];
+    for (const lsp of successfulLsps) {
+      const config = getLspCommand(lsp.lspId);
+      if (config) {
+        sections.push(`[language_servers.${lsp.lspId}]`);
+        sections.push(`command = "${config.command}"`);
+        if (config.args.length > 0) {
+          sections.push(`args = [${config.args.map((a) => `"${a}"`).join(", ")}]`);
         }
-      };
-    }
-    return {
-      code: 0,
-      data: {
-        success: true,
-        command: "update",
-        message: "Updated successfully",
-        currentVersion,
-        newVersion,
-        updated
+        sections.push("");
       }
-    };
-  } catch (error) {
-    return {
-      code: 1,
-      data: {
-        success: false,
-        command: "update",
-        errors: [String(error)]
+    }
+    return [
+      {
+        path: ".codex/config.toml",
+        content: sections.join(`
+`),
+        overwrite: false
       }
-    };
+    ];
+  }
+  async isAvailable() {
+    return true;
   }
 }
+function createCodexLspGenerator() {
+  return new CodexLspGenerator;
+}
 
-// src/cli/router.ts
-function parseArgs(args) {
-  const flags = {
-    help: false,
-    version: false,
-    dryRun: false,
-    force: false,
-    output: "human"
-  };
-  const options = {};
-  const remaining = [];
-  for (const arg of args) {
-    if (arg === "--help" || arg === "-h") {
-      flags.help = true;
-    } else if (arg === "--version" || arg === "-v") {
-      flags.version = true;
-    } else if (arg === "--dry-run") {
-      flags.dryRun = true;
-    } else if (arg === "--force") {
-      flags.force = true;
-    } else if (arg === "--output" || arg === "-o") {
-      remaining.push(arg);
-    } else if (arg.startsWith("--output=") || arg.startsWith("-o=")) {
-      const value = arg.split("=")[1];
-      if (value === "json" || value === "human") {
-        flags.output = value;
-      }
-    } else {
-      remaining.push(arg);
+// src/adapters/cursor/cursor-lsp-generator.ts
+class CursorLspGenerator {
+  name = "cursor-lsp";
+  target = "cursor";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
     }
-  }
-  for (let i = 0;i < remaining.length; i++) {
-    if ((remaining[i] === "--output" || remaining[i] === "-o") && remaining[i + 1]) {
-      const value = remaining[i + 1];
-      if (value === "json" || value === "human") {
-        flags.output = value;
-        remaining.splice(i, 2);
-        i--;
+    const languageServers = getLanguageServerConfig(successfulLsps.map((lsp) => lsp.lspId));
+    const content = JSON.stringify({
+      languageServers
+    }, null, 2);
+    return [
+      {
+        path: ".cursor/settings.json",
+        content,
+        overwrite: false
       }
-    }
+    ];
   }
-  const command = remaining[0] || "help";
-  const subcommand = remaining[1] && !remaining[1].startsWith("-") ? remaining[1] : undefined;
-  for (let i = 1;i < remaining.length; i++) {
-    const arg = remaining[i];
-    if (arg.startsWith("--")) {
-      const [key, value] = arg.slice(2).split("=");
-      if (value !== undefined) {
-        options[key] = value;
-      } else if (remaining[i + 1] && !remaining[i + 1].startsWith("-")) {
-        options[key] = remaining[++i];
-      } else {
-        options[key] = true;
-      }
+  async isAvailable() {
+    return true;
+  }
+}
+function createCursorLspGenerator() {
+  return new CursorLspGenerator;
+}
+
+// src/adapters/gemini/gemini-lsp-generator.ts
+class GeminiLspGenerator {
+  name = "gemini-lsp";
+  target = "gemini";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
     }
+    const languageServers = getLanguageServerConfig(successfulLsps.map((lsp) => lsp.lspId));
+    const content = JSON.stringify({
+      languageServers
+    }, null, 2);
+    return [
+      {
+        path: ".gemini/settings.json",
+        content,
+        overwrite: false
+      }
+    ];
+  }
+  async isAvailable() {
+    return true;
   }
-  return { command, subcommand, options, flags };
 }
-function getVersion() {
-  return `${package_default.name} v${package_default.version}`;
+function createGeminiLspGenerator() {
+  return new GeminiLspGenerator;
 }
-function getHelp() {
-  return `CodeConductor CLI v${package_default.version}
 
-Usage: npx cc-codeconductor <command> [options]
+// src/adapters/opencode/opencode-lsp-generator.ts
+var OPENCODE_LSP_EXTENSIONS = {
+  typescript: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+  php: [".php"],
+  python: [".py", ".pyi"],
+  kotlin: [".kt", ".kts"]
+};
 
-Commands:
-  init                    Initialize CodeConductor in a project
-  detect                 Detect project stack and recommended presets
+class OpenCodeLspGenerator {
+  name = "opencode-lsp";
+  target = "opencode";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp2) => lsp2.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
+    }
+    const languageServers = getLanguageServerConfig(successfulLsps.map((lsp2) => lsp2.lspId));
+    const lsp = this.toOpenCodeLspConfig(languageServers);
+    const content = JSON.stringify({
+      $schema: "https://opencode.ai/config.json",
+      lsp
+    }, null, 2);
+    return [
+      {
+        path: ".opencode/opencode.json",
+        content: `${content}
+`,
+        overwrite: false
+      }
+    ];
+  }
+  toOpenCodeLspConfig(languageServers) {
+    return Object.fromEntries(Object.entries(languageServers).map(([name, config]) => [
+      name,
+      {
+        command: [config.command, ...config.args],
+        extensions: OPENCODE_LSP_EXTENSIONS[name] ?? []
+      }
+    ]));
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+function createOpenCodeLspGenerator() {
+  return new OpenCodeLspGenerator;
+}
+
+// src/core/lsp/lsp-installer.ts
+import { execFile } from "node:child_process";
+import { access as access5, mkdir as mkdir5 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+
+class LspInstaller {
+  lspBinDir;
+  constructor() {
+    this.lspBinDir = join4(homedir3(), ".codeconductor", "lsp", "bin");
+  }
+  async checkInstalled(def) {
+    try {
+      const { stdout } = await execFileAsync("which", [def.binaryName], { timeout: 5000 });
+      const path = stdout.trim();
+      if (path) {
+        const version = await this.getVersion(def);
+        return { installed: true, version, path };
+      }
+    } catch {}
+    if (def.packageManager === "npm" && def.npmDetect) {
+      try {
+        const { stdout } = await execFileAsync("npm", ["list", "-g", def.npmDetect, "--depth=0"], { timeout: 1e4 });
+        if (stdout.includes(def.npmDetect)) {
+          const version = this.parseVersionFromNpmList(stdout, def.npmDetect);
+          return { installed: true, version };
+        }
+      } catch {}
+    }
+    if (def.packageManager === "pip" && def.pipDetect) {
+      try {
+        const { stdout } = await execFileAsync("pip", ["show", def.pipDetect], { timeout: 1e4 });
+        if (stdout.includes("Version:")) {
+          const version = this.parseVersionFromPipShow(stdout);
+          return { installed: true, version };
+        }
+      } catch {}
+    }
+    return { installed: false };
+  }
+  async installLsp(def) {
+    const status = await this.checkInstalled(def);
+    if (status.installed) {
+      return {
+        lspId: def.id,
+        status: "already-installed",
+        version: status.version
+      };
+    }
+    try {
+      switch (def.packageManager) {
+        case "npm":
+          await this.installNpm(def);
+          break;
+        case "pip":
+          await this.installPip(def);
+          break;
+        case "binary":
+          await this.installBinary(def);
+          break;
+      }
+      const newStatus = await this.checkInstalled(def);
+      return {
+        lspId: def.id,
+        status: "installed",
+        version: newStatus.version
+      };
+    } catch (error) {
+      return {
+        lspId: def.id,
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async installAll(lsps, options) {
+    const results = [];
+    for (const lsp of lsps) {
+      if (options.dryRun) {
+        const status = await this.checkInstalled(lsp);
+        results.push({
+          lspId: lsp.id,
+          status: status.installed ? "already-installed" : "installed",
+          version: status.version
+        });
+      } else {
+        const result = await this.installLsp(lsp);
+        results.push(result);
+      }
+    }
+    return {
+      results,
+      allSucceeded: results.every((r) => r.status !== "failed")
+    };
+  }
+  async getVersion(def) {
+    try {
+      const { stdout } = await execFileAsync(def.binaryName, [def.versionFlag], { timeout: 5000 });
+      return stdout.trim().split(`
+`)[0];
+    } catch {
+      return;
+    }
+  }
+  parseVersionFromNpmList(output, packageName) {
+    const match = output.match(new RegExp(`${packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}@([\\d.]+)`));
+    return match?.[1];
+  }
+  parseVersionFromPipShow(output) {
+    const match = output.match(/Version:\s*([\d.]+)/);
+    return match?.[1];
+  }
+  async installNpm(def) {
+    try {
+      await execFileAsync("npm", ["install", "-g", def.package], { timeout: 120000 });
+    } catch (error) {
+      throw new Error(`Failed to install ${def.serverName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async installPip(def) {
+    try {
+      await execFileAsync("pip", ["install", "--user", def.package], { timeout: 120000 });
+    } catch (error) {
+      throw new Error(`Failed to install ${def.serverName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async installBinary(def) {
+    if (!def.binaryPlatforms) {
+      throw new Error(`No binary platforms defined for ${def.serverName}`);
+    }
+    const platformKey = `${process.platform}-${process.arch}`;
+    const binary = def.binaryPlatforms[platformKey];
+    if (!binary) {
+      throw new Error(`No binary available for platform: ${platformKey}`);
+    }
+    await mkdir5(this.lspBinDir, { recursive: true });
+    const destPath = join4(this.lspBinDir, def.binaryName);
+    try {
+      await access5(destPath);
+      return;
+    } catch {}
+    const { execSync } = await import("node:child_process");
+    const isWindows = process.platform === "win32";
+    const extractCmd = binary.url.endsWith(".zip") ? `curl -L "${binary.url}" | tar -xz -C "${this.lspBinDir}"` : `curl -L "${binary.url}" | tar -xz -C "${this.lspBinDir}"`;
+    try {
+      execSync(extractCmd, { timeout: 120000, stdio: "pipe" });
+      if (!isWindows) {
+        execSync(`chmod +x "${destPath}"`, { stdio: "pipe" });
+      }
+    } catch (error) {
+      throw new Error(`Failed to download ${def.serverName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+function createLspInstaller() {
+  return new LspInstaller;
+}
+
+// src/core/lsp/lsp-registry.ts
+var LSP_DEFINITIONS = [
+  {
+    id: "typescript",
+    language: "typescript",
+    serverName: "TypeScript Language Server",
+    packageManager: "npm",
+    package: "typescript-language-server",
+    binaryName: "typescript-language-server",
+    installCmd: "npm install -g typescript-language-server",
+    versionFlag: "--version",
+    npmDetect: "typescript-language-server"
+  },
+  {
+    id: "php",
+    language: "php",
+    serverName: "Intelephense",
+    packageManager: "npm",
+    package: "@bmewburn/vscode-intelephense-client",
+    binaryName: "intelephense",
+    installCmd: "npm install -g @bmewburn/vscode-intelephense-client",
+    versionFlag: "--version",
+    npmDetect: "@bmewburn/vscode-intelephense-client"
+  },
+  {
+    id: "python",
+    language: "python",
+    serverName: "Pyright",
+    packageManager: "npm",
+    package: "pyright",
+    binaryName: "pyright-langserver",
+    installCmd: "npm install -g pyright",
+    versionFlag: "--version",
+    npmDetect: "pyright"
+  },
+  {
+    id: "kotlin",
+    language: "kotlin",
+    serverName: "Kotlin Language Server",
+    packageManager: "binary",
+    package: "kotlin-language-server",
+    binaryName: "kotlin-language-server",
+    installCmd: "Download from GitHub releases",
+    versionFlag: "--version",
+    binaryPlatforms: {
+      "linux-x64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-linux-x64.tar.gz"
+      },
+      "linux-arm64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-linux-arm64.tar.gz"
+      },
+      "darwin-x64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-macos-x64.tar.gz"
+      },
+      "darwin-arm64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-macos-arm64.tar.gz"
+      },
+      "win32-x64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-windows-x64.zip"
+      }
+    }
+  }
+];
+function resolveLsps(languages) {
+  const languageToLspId = {
+    typescript: "typescript",
+    javascript: "typescript",
+    php: "php",
+    python: "python",
+    java: "kotlin",
+    kotlin: "kotlin"
+  };
+  const resolvedIds = new Set;
+  for (const lang of languages) {
+    const lspId = languageToLspId[lang.toLowerCase()];
+    if (lspId) {
+      resolvedIds.add(lspId);
+    }
+  }
+  return LSP_DEFINITIONS.filter((def) => resolvedIds.has(def.id));
+}
+
+// src/commands/install-lsp.command.ts
+async function installLspCommand(options) {
+  const { target, lang, dryRun, force, global: isGlobal, output, projectRoot } = options;
+  const baseDir = isGlobal ? homedir4() : projectRoot;
+  try {
+    const runnerTarget = parseRunnerTarget(target);
+    const targets = getIndividualTargets(runnerTarget);
+    let languages;
+    if (lang && lang.length > 0) {
+      languages = lang;
+    } else {
+      const profile = await detectProject(projectRoot);
+      languages = profile.languages;
+    }
+    if (languages.length === 0) {
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "install",
+          subcommand: "lsp",
+          errors: ["No languages detected. Use --lang to specify languages manually."]
+        }
+      };
+    }
+    const lsps = resolveLsps(languages);
+    if (lsps.length === 0) {
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "install",
+          subcommand: "lsp",
+          errors: [`No LSP servers available for languages: ${languages.join(", ")}`]
+        }
+      };
+    }
+    const installer = createLspInstaller();
+    const installReport = await installer.installAll(lsps, { dryRun });
+    const writeOptions = { dryRun, force };
+    const allConfigResults = [];
+    for (const t of targets) {
+      const generator = getLspConfigGenerator(t);
+      if (!generator) {
+        continue;
+      }
+      const generatedFiles = generator.generate(installReport.results);
+      const resolvedFiles = generatedFiles.map((f) => ({
+        ...f,
+        path: resolve8(baseDir, f.path)
+      }));
+      const results = await writeGeneratedFiles(resolvedFiles, writeOptions);
+      for (const result of results) {
+        allConfigResults.push({
+          target: t,
+          path: result.path,
+          success: result.success,
+          error: result.error
+        });
+      }
+    }
+    const errors3 = allConfigResults.filter((r) => !r.success).map((r) => `${r.path}: ${r.error}`);
+    if (output === "json") {
+      return {
+        code: errors3.length > 0 ? 2 : 0,
+        data: {
+          success: errors3.length === 0,
+          command: "install",
+          subcommand: "lsp",
+          targets,
+          languages: [...languages],
+          global: isGlobal,
+          dryRun,
+          lspResults: installReport.results,
+          configResults: allConfigResults
+        }
+      };
+    }
+    console.log(`
+LSP Installation:`);
+    for (const result of installReport.results) {
+      const icon = result.status === "already-installed" ? "✓" : result.status === "installed" ? "+" : "✗";
+      const version = result.version ? ` (${result.version})` : "";
+      const error = result.error ? `: ${result.error}` : "";
+      console.log(`  ${icon} ${result.lspId}${version}${error}`);
+    }
+    console.log(`
+Config Files:`);
+    for (const result of allConfigResults) {
+      const icon = result.success ? "✓" : "✗";
+      const error = result.error ? `: ${result.error}` : "";
+      console.log(`  ${icon} ${result.target}: ${result.path}${error}`);
+    }
+    const note = dryRun ? " (dry-run)" : "";
+    console.log(`
+${installReport.results.length} LSPs processed, ${allConfigResults.length} config files${note}`);
+    return {
+      code: errors3.length > 0 ? 2 : 0,
+      data: {
+        success: errors3.length === 0,
+        command: "install",
+        subcommand: "lsp",
+        targets,
+        languages: [...languages],
+        global: isGlobal,
+        dryRun,
+        lspResults: installReport.results,
+        configResults: allConfigResults
+      }
+    };
+  } catch (error) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "install",
+        subcommand: "lsp",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+function getLspConfigGenerator(target) {
+  switch (target) {
+    case "opencode":
+      return createOpenCodeLspGenerator();
+    case "claude":
+      return createClaudeLspGenerator();
+    case "codex":
+      return createCodexLspGenerator();
+    case "gemini":
+      return createGeminiLspGenerator();
+    case "cursor":
+      return createCursorLspGenerator();
+    case "agy":
+      return createAgyLspGenerator();
+    default:
+      return;
+  }
+}
+
+// src/commands/seo-audit.command.ts
+import { writeFile as writeFile5, mkdir as mkdir6 } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve9 } from "node:path";
+
+// src/infrastructure/http/safe-fetch.ts
+import { lookup } from "node:dns/promises";
+var PRIVATE_IP_RANGES = [
+  /^10\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^192\.168\./,
+  /^127\./,
+  /^0\./,
+  /^169\.254\./,
+  /^::1$/,
+  /^fc00:/i,
+  /^fe80:/i
+];
+function isPrivateIp(ip) {
+  return PRIVATE_IP_RANGES.some((range) => range.test(ip));
+}
+async function validateUrl(urlString) {
+  let parsed;
+  try {
+    parsed = new URL(urlString);
+  } catch {
+    throw new Error(`Invalid URL: ${urlString}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Blocked scheme: ${parsed.protocol}. Only http and https are allowed.`);
+  }
+  const hostname = parsed.hostname;
+  if (hostname === "localhost" || hostname.endsWith(".localhost")) {
+    throw new Error(`Blocked hostname: ${hostname}`);
+  }
+  try {
+    const addresses = await lookup(hostname, { all: true });
+    const addrList = Array.isArray(addresses) ? addresses : [addresses];
+    for (const addr of addrList) {
+      if (isPrivateIp(addr.address)) {
+        throw new Error(`SSRF blocked: ${hostname} resolves to private IP ${addr.address}`);
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("SSRF blocked")) {
+      throw error;
+    }
+    throw new Error(`DNS resolution failed for ${hostname}: ${String(error)}`);
+  }
+}
+async function safeFetch(urlString, options = {}) {
+  const { timeout = 1e4, followRedirects = false } = options;
+  await validateUrl(urlString);
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeout);
+  const start = Date.now();
+  try {
+    const response = await fetch(urlString, {
+      method: "GET",
+      signal: controller.signal,
+      redirect: followRedirects ? "follow" : "manual",
+      headers: {
+        "User-Agent": "CodeConductor-SEO/0.3.0",
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+      }
+    });
+    const responseTime = Date.now() - start;
+    const body = await response.text();
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      status: response.status,
+      headers,
+      body,
+      responseTime,
+      url: urlString
+    };
+  } catch (error) {
+    const responseTime = Date.now() - start;
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeout}ms: ${urlString}`);
+    }
+    throw new Error(`Fetch failed (${responseTime}ms): ${urlString} — ${String(error)}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function delay(ms) {
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
+}
+
+// src/infrastructure/parsers/sitemap-parser.ts
+function extractTag(xml, tag) {
+  const match = xml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "i"));
+  return match ? match[1].trim() : undefined;
+}
+function extractAllBlocks(xml, tag) {
+  const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "gi");
+  const blocks = [];
+  let match;
+  while ((match = regex.exec(xml)) !== null) {
+    blocks.push(match[1]);
+  }
+  return blocks;
+}
+function parseUrlEntries(xml) {
+  const urlBlocks = extractAllBlocks(xml, "url");
+  return urlBlocks.map((block) => ({
+    url: extractTag(block, "loc") ?? "",
+    lastmod: extractTag(block, "lastmod"),
+    changefreq: extractTag(block, "changefreq"),
+    priority: extractTag(block, "priority")
+  })).filter((entry) => entry.url.length > 0);
+}
+function parseSitemapLocs(xml) {
+  const sitemapBlocks = extractAllBlocks(xml, "sitemap");
+  return sitemapBlocks.map((block) => extractTag(block, "loc")).filter((loc) => loc !== undefined && loc.length > 0);
+}
+function getDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+function deduplicateEntries(entries) {
+  const seen = new Set;
+  return entries.filter((entry) => {
+    if (seen.has(entry.url))
+      return false;
+    seen.add(entry.url);
+    return true;
+  });
+}
+function filterSameDomain(entries, domain) {
+  return entries.filter((entry) => {
+    try {
+      return new URL(entry.url).hostname === domain;
+    } catch {
+      return false;
+    }
+  });
+}
+async function parseSitemap(sitemapUrl, options = {}) {
+  const { maxDepth = 2, delay: requestDelay = 0 } = options;
+  return parseSitemapRecursive(sitemapUrl, 0, maxDepth, requestDelay);
+}
+async function parseSitemapRecursive(sitemapUrl, depth, maxDepth, requestDelay) {
+  const response = await safeFetch(sitemapUrl);
+  const xml = response.body;
+  const domain = getDomain(sitemapUrl);
+  const isIndex = /<sitemapindex[\s>]/i.test(xml);
+  if (isIndex) {
+    const childUrls = parseSitemapLocs(xml);
+    if (depth >= maxDepth) {
+      return {
+        entries: [],
+        type: "sitemapindex",
+        childSitemaps: childUrls
+      };
+    }
+    const allEntries = [];
+    const allChildSitemaps = [...childUrls];
+    for (let i = 0;i < childUrls.length; i++) {
+      if (i > 0 && requestDelay > 0) {
+        await delay(requestDelay);
+      }
+      try {
+        const childResult = await parseSitemapRecursive(childUrls[i], depth + 1, maxDepth, requestDelay);
+        allEntries.push(...childResult.entries);
+        allChildSitemaps.push(...childResult.childSitemaps);
+      } catch {}
+    }
+    const deduped2 = deduplicateEntries(allEntries);
+    const filtered2 = domain ? filterSameDomain(deduped2, domain) : deduped2;
+    return {
+      entries: filtered2,
+      type: "sitemapindex",
+      childSitemaps: allChildSitemaps
+    };
+  }
+  const entries = parseUrlEntries(xml);
+  const deduped = deduplicateEntries(entries);
+  const filtered = domain ? filterSameDomain(deduped, domain) : deduped;
+  return {
+    entries: filtered,
+    type: "urlset",
+    childSitemaps: []
+  };
+}
+
+// src/domain/seo/meta-validator.ts
+function extractMetaContent(html, name) {
+  const patterns = [
+    new RegExp(`<meta[^>]*name=["']${name}["'][^>]*content=["']([^"']*)["']`, "i"),
+    new RegExp(`<meta[^>]*content=["']([^"']*)["'][^>]*name=["']${name}["']`, "i")
+  ];
+  for (const pattern of patterns) {
+    const match = html.match(pattern);
+    if (match)
+      return match[1].trim();
+  }
+  return;
+}
+function extractPropertyContent(html, property) {
+  const patterns = [
+    new RegExp(`<meta[^>]*property=["']${property}["'][^>]*content=["']([^"']*)["']`, "i"),
+    new RegExp(`<meta[^>]*content=["']([^"']*)["'][^>]*property=["']${property}["']`, "i")
+  ];
+  for (const pattern of patterns) {
+    const match = html.match(pattern);
+    if (match)
+      return match[1].trim();
+  }
+  return;
+}
+function extractTitle(html) {
+  const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return match ? match[1].trim() : undefined;
+}
+function extractCanonical(html) {
+  const match = html.match(/<link[^>]*rel=["']canonical["'][^>]*href=["']([^"']*)["']/i);
+  return match ? match[1].trim() : undefined;
+}
+function extractH1Tags(html) {
+  const regex = /<h1[^>]*>([\s\S]*?)<\/h1>/gi;
+  const results = [];
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    results.push(match[1].trim());
+  }
+  return results;
+}
+function extractHeadingHierarchy(html) {
+  const regex = /<(h[1-6])[^>]*>([\s\S]*?)<\/\1>/gi;
+  const results = [];
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    results.push({ tag: match[1].toLowerCase(), text: match[2].trim() });
+  }
+  return results;
+}
+function extractImgWithoutAlt(html) {
+  const imgRegex = /<img[^>]*>/gi;
+  let count = 0;
+  let match;
+  while ((match = imgRegex.exec(html)) !== null) {
+    if (!/alt=["'][^"']+["']/i.test(match[0])) {
+      count++;
+    }
+  }
+  return count;
+}
+function extractHtmlLang(html) {
+  const match = html.match(/<html[^>]*lang=["']([^"']*)["']/i);
+  return match ? match[1].trim() : undefined;
+}
+function extractViewport(html) {
+  return extractMetaContent(html, "viewport");
+}
+function extractInternalLinks(html, baseUrl) {
+  let domain;
+  try {
+    domain = new URL(baseUrl).hostname;
+  } catch {
+    return 0;
+  }
+  const linkRegex = /href=["']([^"']*)["']/gi;
+  let count = 0;
+  let match;
+  while ((match = linkRegex.exec(html)) !== null) {
+    const href = match[1];
+    if (href.startsWith("#") || href.startsWith("mailto:") || href.startsWith("tel:"))
+      continue;
+    try {
+      const resolved = new URL(href, baseUrl);
+      if (resolved.hostname === domain)
+        count++;
+    } catch {
+      if (href.startsWith("/"))
+        count++;
+    }
+  }
+  return count;
+}
+function validateMeta(html, url, responseTime) {
+  const checks = [];
+  const title = extractTitle(html);
+  if (!title) {
+    checks.push({
+      name: "title-tag",
+      category: "meta",
+      severity: "error",
+      message: "Missing <title> tag",
+      remediation: "Add a <title> tag with 30-60 characters describing the page content."
+    });
+  } else if (title.length < 30) {
+    checks.push({
+      name: "title-tag",
+      category: "meta",
+      severity: "warning",
+      message: `Title too short (${title.length} chars): "${title}"`,
+      remediation: "Expand title to 30-60 characters."
+    });
+  } else if (title.length > 60) {
+    checks.push({
+      name: "title-tag",
+      category: "meta",
+      severity: "warning",
+      message: `Title too long (${title.length} chars): "${title}"`,
+      remediation: "Shorten title to 30-60 characters to avoid truncation in SERPs."
+    });
+  } else {
+    checks.push({
+      name: "title-tag",
+      category: "meta",
+      severity: "pass",
+      message: `Title OK (${title.length} chars): "${title}"`
+    });
+  }
+  const description = extractMetaContent(html, "description");
+  if (!description) {
+    checks.push({
+      name: "meta-description",
+      category: "meta",
+      severity: "error",
+      message: 'Missing <meta name="description">',
+      remediation: "Add a meta description with 120-160 characters summarizing the page."
+    });
+  } else if (description.length < 120) {
+    checks.push({
+      name: "meta-description",
+      category: "meta",
+      severity: "warning",
+      message: `Description too short (${description.length} chars)`,
+      remediation: "Expand description to 120-160 characters."
+    });
+  } else if (description.length > 160) {
+    checks.push({
+      name: "meta-description",
+      category: "meta",
+      severity: "warning",
+      message: `Description too long (${description.length} chars)`,
+      remediation: "Shorten description to 120-160 characters."
+    });
+  } else {
+    checks.push({
+      name: "meta-description",
+      category: "meta",
+      severity: "pass",
+      message: `Description OK (${description.length} chars)`
+    });
+  }
+  const canonical = extractCanonical(html);
+  if (!canonical) {
+    checks.push({
+      name: "canonical",
+      category: "meta",
+      severity: "warning",
+      message: 'Missing <link rel="canonical">',
+      remediation: "Add a canonical URL to prevent duplicate content issues."
+    });
+  } else if (canonical !== url) {
+    checks.push({
+      name: "canonical",
+      category: "meta",
+      severity: "info",
+      message: `Canonical (${canonical}) differs from current URL (${url})`
+    });
+  } else {
+    checks.push({
+      name: "canonical",
+      category: "meta",
+      severity: "pass",
+      message: `Canonical matches URL`
+    });
+  }
+  const robots = extractMetaContent(html, "robots");
+  if (robots) {
+    if (/noindex/i.test(robots)) {
+      checks.push({
+        name: "robots-noindex",
+        category: "crawl",
+        severity: "warning",
+        message: `Page has noindex directive: "${robots}"`,
+        remediation: "Remove noindex if this page should appear in search results."
+      });
+    }
+    if (/nofollow/i.test(robots)) {
+      checks.push({
+        name: "robots-nofollow",
+        category: "crawl",
+        severity: "warning",
+        message: `Page has nofollow directive: "${robots}"`
+      });
+    }
+  } else {
+    checks.push({
+      name: "robots-directive",
+      category: "crawl",
+      severity: "pass",
+      message: "No restrictive robots directive"
+    });
+  }
+  const hreflangRegex = /hreflang=["']([^"']*)["']/gi;
+  const hreflangs = [];
+  let hreflangMatch;
+  while ((hreflangMatch = hreflangRegex.exec(html)) !== null) {
+    hreflangs.push(hreflangMatch[1]);
+  }
+  if (hreflangs.length > 0) {
+    checks.push({
+      name: "hreflang",
+      category: "meta",
+      severity: "pass",
+      message: `Found ${hreflangs.length} hreflang tags: ${hreflangs.join(", ")}`
+    });
+  }
+  const ogTitle = extractPropertyContent(html, "og:title");
+  const ogDescription = extractPropertyContent(html, "og:description");
+  const ogImage = extractPropertyContent(html, "og:image");
+  const ogUrl = extractPropertyContent(html, "og:url");
+  if (!ogTitle) {
+    checks.push({
+      name: "og-title",
+      category: "social",
+      severity: "warning",
+      message: "Missing og:title",
+      remediation: 'Add <meta property="og:title" content="..."> for social sharing.'
+    });
+  } else {
+    checks.push({ name: "og-title", category: "social", severity: "pass", message: "og:title present" });
+  }
+  if (!ogDescription) {
+    checks.push({
+      name: "og-description",
+      category: "social",
+      severity: "warning",
+      message: "Missing og:description",
+      remediation: 'Add <meta property="og:description" content="...">.'
+    });
+  } else {
+    checks.push({ name: "og-description", category: "social", severity: "pass", message: "og:description present" });
+  }
+  if (!ogImage) {
+    checks.push({
+      name: "og-image",
+      category: "social",
+      severity: "warning",
+      message: "Missing og:image",
+      remediation: 'Add <meta property="og:image" content="..."> with a 1200x630px image.'
+    });
+  } else {
+    checks.push({ name: "og-image", category: "social", severity: "pass", message: "og:image present" });
+  }
+  if (!ogUrl) {
+    checks.push({
+      name: "og-url",
+      category: "social",
+      severity: "info",
+      message: "Missing og:url"
+    });
+  }
+  const twitterCard = extractMetaContent(html, "twitter:card");
+  if (!twitterCard) {
+    checks.push({
+      name: "twitter-card",
+      category: "social",
+      severity: "info",
+      message: "Missing twitter:card",
+      remediation: 'Add <meta name="twitter:card" content="summary_large_image">.'
+    });
+  } else {
+    checks.push({ name: "twitter-card", category: "social", severity: "pass", message: `twitter:card: ${twitterCard}` });
+  }
+  const h1Tags = extractH1Tags(html);
+  if (h1Tags.length === 0) {
+    checks.push({
+      name: "h1-tag",
+      category: "content",
+      severity: "error",
+      message: "Missing <h1> tag",
+      remediation: "Add exactly one <h1> tag with the main page heading."
+    });
+  } else if (h1Tags.length > 1) {
+    checks.push({
+      name: "h1-tag",
+      category: "content",
+      severity: "warning",
+      message: `Multiple <h1> tags found (${h1Tags.length}): "${h1Tags.join('", "')}"`,
+      remediation: "Use only one <h1> per page. Convert extras to <h2>."
+    });
+  } else {
+    checks.push({
+      name: "h1-tag",
+      category: "content",
+      severity: "pass",
+      message: `H1 OK: "${h1Tags[0]}"`
+    });
+  }
+  const headings = extractHeadingHierarchy(html);
+  if (headings.length > 1) {
+    let hasSkips = false;
+    for (let i = 1;i < headings.length; i++) {
+      const prev = parseInt(headings[i - 1].tag[1]);
+      const curr = parseInt(headings[i].tag[1]);
+      if (curr > prev + 1) {
+        hasSkips = true;
+        break;
+      }
+    }
+    if (hasSkips) {
+      checks.push({
+        name: "heading-hierarchy",
+        category: "content",
+        severity: "warning",
+        message: "Heading hierarchy has skipped levels (e.g., h2 → h4)",
+        remediation: "Ensure headings follow sequential order: h1 → h2 → h3."
+      });
+    } else {
+      checks.push({
+        name: "heading-hierarchy",
+        category: "content",
+        severity: "pass",
+        message: `Heading hierarchy OK (${headings.length} headings)`
+      });
+    }
+  }
+  const imgsWithoutAlt = extractImgWithoutAlt(html);
+  if (imgsWithoutAlt > 0) {
+    checks.push({
+      name: "img-alt-text",
+      category: "content",
+      severity: "warning",
+      message: `${imgsWithoutAlt} image(s) missing alt text`,
+      remediation: "Add descriptive alt text to all images for accessibility and SEO."
+    });
+  } else {
+    checks.push({
+      name: "img-alt-text",
+      category: "content",
+      severity: "pass",
+      message: "All images have alt text"
+    });
+  }
+  const internalLinks = extractInternalLinks(html, url);
+  checks.push({
+    name: "internal-links",
+    category: "content",
+    severity: internalLinks > 0 ? "pass" : "warning",
+    message: `${internalLinks} internal links found`,
+    remediation: internalLinks === 0 ? "Add internal links to improve crawlability and page authority." : undefined
+  });
+  const lang = extractHtmlLang(html);
+  if (!lang) {
+    checks.push({
+      name: "html-lang",
+      category: "technical",
+      severity: "warning",
+      message: 'Missing <html lang="..."> attribute',
+      remediation: 'Add lang attribute to <html> tag (e.g., lang="en").'
+    });
+  } else {
+    checks.push({
+      name: "html-lang",
+      category: "technical",
+      severity: "pass",
+      message: `HTML lang: ${lang}`
+    });
+  }
+  const viewport = extractViewport(html);
+  if (!viewport) {
+    checks.push({
+      name: "viewport",
+      category: "technical",
+      severity: "error",
+      message: 'Missing <meta name="viewport">',
+      remediation: 'Add <meta name="viewport" content="width=device-width, initial-scale=1">.'
+    });
+  } else {
+    checks.push({
+      name: "viewport",
+      category: "technical",
+      severity: "pass",
+      message: "Viewport meta tag present"
+    });
+  }
+  const isHttps = url.startsWith("https://");
+  checks.push({
+    name: "https",
+    category: "technical",
+    severity: isHttps ? "pass" : "error",
+    message: isHttps ? "HTTPS enabled" : "Site is not using HTTPS",
+    remediation: isHttps ? undefined : "Migrate to HTTPS for security and SEO ranking."
+  });
+  if (responseTime < 3000) {
+    checks.push({
+      name: "response-time",
+      category: "technical",
+      severity: "pass",
+      message: `Response time: ${responseTime}ms`
+    });
+  } else if (responseTime < 5000) {
+    checks.push({
+      name: "response-time",
+      category: "technical",
+      severity: "warning",
+      message: `Slow response time: ${responseTime}ms`,
+      remediation: "Optimize server response time to under 3 seconds."
+    });
+  } else {
+    checks.push({
+      name: "response-time",
+      category: "technical",
+      severity: "error",
+      message: `Very slow response time: ${responseTime}ms`,
+      remediation: "Server response time exceeds 5 seconds. Investigate server performance."
+    });
+  }
+  return checks;
+}
+
+// src/domain/seo/schema-validator.ts
+var HOTEL_TYPES = [
+  "Hotel",
+  "LodgingBusiness",
+  "HotelRoom",
+  "LocalBusiness",
+  "Resort",
+  "Motel",
+  "Hostel",
+  "BedAndBreakfast",
+  "Campground",
+  "RV Park"
+];
+var SUPPORTING_TYPES = [
+  "BreadcrumbList",
+  "FAQPage",
+  "Review",
+  "AggregateRating",
+  "Organization",
+  "WebSite",
+  "ImageObject",
+  "Event",
+  "TouristAttraction",
+  "HowTo",
+  "WebPage",
+  "Person"
+];
+var REQUIRED_HOTEL_PROPERTIES = ["name", "address", "telephone", "image"];
+var RECOMMENDED_HOTEL_PROPERTIES = ["priceRange", "description", "url", "geo"];
+function extractJsonLdBlocks(html) {
+  const regex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  const blocks = [];
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      const items = Array.isArray(parsed) ? parsed : [parsed];
+      for (const item of items) {
+        if (item && typeof item === "object" && "@type" in item) {
+          blocks.push({
+            type: String(item["@type"]),
+            properties: item,
+            raw: match[1].trim()
+          });
+        }
+      }
+    } catch {}
+  }
+  return blocks;
+}
+function validateHotelSchema(block) {
+  const errors3 = [];
+  const warnings = [];
+  for (const prop of REQUIRED_HOTEL_PROPERTIES) {
+    if (!(prop in block.properties)) {
+      errors3.push(`Missing required property: ${prop}`);
+    }
+  }
+  for (const prop of RECOMMENDED_HOTEL_PROPERTIES) {
+    if (!(prop in block.properties)) {
+      warnings.push(`Missing recommended property: ${prop}`);
+    }
+  }
+  if ("address" in block.properties) {
+    const address = block.properties.address;
+    if (typeof address === "object" && address !== null) {
+      const addrObj = address;
+      if (!("streetAddress" in addrObj) && !("addressLocality" in addrObj)) {
+        errors3.push("Address missing streetAddress or addressLocality");
+      }
+    }
+  }
+  if ("image" in block.properties) {
+    const image = block.properties.image;
+    if (typeof image === "string" && !image.startsWith("http")) {
+      warnings.push("Image URL should be absolute");
+    }
+  }
+  return {
+    valid: errors3.length === 0,
+    type: block.type,
+    errors: errors3,
+    warnings
+  };
+}
+function validateSupportingSchema(block) {
+  const errors3 = [];
+  const warnings = [];
+  if (block.type === "BreadcrumbList") {
+    if (!("itemListElement" in block.properties)) {
+      errors3.push("BreadcrumbList missing itemListElement");
+    }
+  }
+  if (block.type === "FAQPage") {
+    if (!("mainEntity" in block.properties)) {
+      errors3.push("FAQPage missing mainEntity");
+    }
+  }
+  if (block.type === "AggregateRating") {
+    if (!("ratingValue" in block.properties)) {
+      errors3.push("AggregateRating missing ratingValue");
+    }
+    if (!("reviewCount" in block.properties) && !("ratingCount" in block.properties)) {
+      warnings.push("AggregateRating missing reviewCount or ratingCount");
+    }
+  }
+  if (block.type === "Organization") {
+    if (!("name" in block.properties)) {
+      errors3.push("Organization missing name");
+    }
+    if (!("url" in block.properties)) {
+      warnings.push("Organization missing url");
+    }
+  }
+  return {
+    valid: errors3.length === 0,
+    type: block.type,
+    errors: errors3,
+    warnings
+  };
+}
+function validateSchema(html) {
+  const checks = [];
+  const blocks = extractJsonLdBlocks(html);
+  if (blocks.length === 0) {
+    checks.push({
+      name: "json-ld-presence",
+      category: "schema",
+      severity: "error",
+      message: "No JSON-LD structured data found",
+      remediation: 'Add <script type="application/ld+json"> with Hotel or LodgingBusiness schema.'
+    });
+    return checks;
+  }
+  checks.push({
+    name: "json-ld-presence",
+    category: "schema",
+    severity: "pass",
+    message: `Found ${blocks.length} JSON-LD block(s)`
+  });
+  const hotelBlocks = blocks.filter((b) => HOTEL_TYPES.includes(b.type));
+  const supportingBlocks = blocks.filter((b) => SUPPORTING_TYPES.includes(b.type));
+  const unknownBlocks = blocks.filter((b) => !HOTEL_TYPES.includes(b.type) && !SUPPORTING_TYPES.includes(b.type));
+  if (hotelBlocks.length === 0) {
+    checks.push({
+      name: "hotel-schema",
+      category: "schema",
+      severity: "error",
+      message: `No Hotel/Hospitality schema found. Types found: ${blocks.map((b) => b.type).join(", ")}`,
+      remediation: "Add a Hotel, LodgingBusiness, or Resort schema with required properties."
+    });
+  }
+  for (const block of hotelBlocks) {
+    const result = validateHotelSchema(block);
+    if (result.valid) {
+      checks.push({
+        name: `schema-${block.type}`,
+        category: "schema",
+        severity: "pass",
+        message: `${block.type} schema valid`
+      });
+    } else {
+      checks.push({
+        name: `schema-${block.type}`,
+        category: "schema",
+        severity: "error",
+        message: `${block.type} schema invalid: ${result.errors.join("; ")}`,
+        remediation: `Fix the following properties: ${result.errors.join(", ")}`
+      });
+    }
+    if (result.warnings.length > 0) {
+      checks.push({
+        name: `schema-${block.type}-warnings`,
+        category: "schema",
+        severity: "warning",
+        message: `${block.type} recommendations: ${result.warnings.join("; ")}`
+      });
+    }
+  }
+  for (const block of supportingBlocks) {
+    const result = validateSupportingSchema(block);
+    checks.push({
+      name: `schema-${block.type}`,
+      category: "schema",
+      severity: result.valid ? "pass" : "warning",
+      message: result.valid ? `${block.type} schema valid` : `${block.type} schema issues: ${result.errors.join("; ")}`
+    });
+  }
+  for (const block of unknownBlocks) {
+    checks.push({
+      name: `schema-${block.type}`,
+      category: "schema",
+      severity: "info",
+      message: `Unknown schema type: ${block.type}`
+    });
+  }
+  return checks;
+}
+
+// src/domain/seo/geo-validator.ts
+function hasFactualStatements(html) {
+  const bodyText = html.replace(/<[^>]*>/g, " ");
+  const numberPattern = /\d{2,}/g;
+  const datePattern = /\b(20\d{2}|19\d{2})\b/g;
+  const properNounPattern = /\b[A-Z][a-z]{2,}\b/g;
+  const numbers = bodyText.match(numberPattern) ?? [];
+  const dates = bodyText.match(datePattern) ?? [];
+  const properNouns = bodyText.match(properNounPattern) ?? [];
+  return numbers.length >= 3 || dates.length >= 1 || properNouns.length >= 5;
+}
+function countStructuredLists(html) {
+  const ulMatches = html.match(/<ul[^>]*>/gi) ?? [];
+  const olMatches = html.match(/<ol[^>]*>/gi) ?? [];
+  const dlMatches = html.match(/<dl[^>]*>/gi) ?? [];
+  return ulMatches.length + olMatches.length + dlMatches.length;
+}
+function hasFaqSection(html) {
+  const patterns = [
+    /faqpage/i,
+    /<details[^>]*>/i,
+    /id=["'][^"']*faq[^"']*["']/i,
+    /class=["'][^"']*faq[^"']*["']/i,
+    /<h[2-4][^>]*>.*(?:faq|frequently asked)/i
+  ];
+  return patterns.some((p) => p.test(html));
+}
+function hasContentDates(html) {
+  const timeRegex2 = /<time[^>]*datetime=["']([^"']*)["']/gi;
+  let match;
+  while ((match = timeRegex2.exec(html)) !== null) {
+    return true;
+  }
+  const datePattern = /\b(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4}\b/i;
+  return datePattern.test(html);
+}
+function validateGeo(html, url) {
+  const checks = [];
+  if (hasFactualStatements(html)) {
+    checks.push({
+      name: "citable-content",
+      category: "geo",
+      severity: "pass",
+      message: "Page contains factual statements suitable for AI citation"
+    });
+  } else {
+    checks.push({
+      name: "citable-content",
+      category: "geo",
+      severity: "warning",
+      message: "Page lacks factual statements (numbers, dates, proper nouns) for AI citation",
+      remediation: "Add specific facts, numbers, and named entities that AI assistants can cite."
+    });
+  }
+  const listCount = countStructuredLists(html);
+  if (listCount > 0) {
+    checks.push({
+      name: "structured-lists",
+      category: "geo",
+      severity: "pass",
+      message: `Found ${listCount} structured list(s) (ul/ol/dl)`
+    });
+  } else {
+    checks.push({
+      name: "structured-lists",
+      category: "geo",
+      severity: "warning",
+      message: "No structured lists found",
+      remediation: "Add <ul> or <ol> lists for amenities, features, and services. AI tools extract structured lists for citations."
+    });
+  }
+  if (hasFaqSection(html)) {
+    checks.push({
+      name: "faq-section",
+      category: "geo",
+      severity: "pass",
+      message: "FAQ section detected"
+    });
+  } else {
+    checks.push({
+      name: "faq-section",
+      category: "geo",
+      severity: "warning",
+      message: "No FAQ section found",
+      remediation: "Add an FAQ section with FAQPage schema. AI search tools prioritize Q&A formatted content."
+    });
+  }
+  if (hasContentDates(html)) {
+    checks.push({
+      name: "content-freshness",
+      category: "geo",
+      severity: "pass",
+      message: "Content has date signals"
+    });
+  } else {
+    checks.push({
+      name: "content-freshness",
+      category: "geo",
+      severity: "info",
+      message: "No date signals found in content",
+      remediation: "Add <time> elements or visible dates to signal content freshness."
+    });
+  }
+  return checks;
+}
+async function checkLlmsTxt(baseUrl) {
+  const checks = [];
+  let root;
+  try {
+    const parsed = new URL(baseUrl);
+    root = `${parsed.protocol}//${parsed.host}`;
+  } catch {
+    return [{
+      name: "llms-txt",
+      category: "geo",
+      severity: "error",
+      message: `Invalid base URL: ${baseUrl}`
+    }];
+  }
+  try {
+    const response = await safeFetch(`${root}/llms.txt`);
+    if (response.status === 200 && response.body.length > 0) {
+      checks.push({
+        name: "llms-txt",
+        category: "geo",
+        severity: "pass",
+        message: `llms.txt found (${response.body.length} bytes)`
+      });
+      if (!response.body.startsWith("#")) {
+        checks.push({
+          name: "llms-txt-format",
+          category: "geo",
+          severity: "warning",
+          message: "llms.txt should start with a # heading",
+          remediation: "Format: # Site Name\\n> Description\\n\\n## Pages\\n- [Title](url): description"
+        });
+      } else {
+        checks.push({
+          name: "llms-txt-format",
+          category: "geo",
+          severity: "pass",
+          message: "llms.txt format looks correct"
+        });
+      }
+    } else {
+      checks.push({
+        name: "llms-txt",
+        category: "geo",
+        severity: "error",
+        message: `llms.txt returned status ${response.status}`,
+        remediation: "Create a llms.txt file at the site root following the llms.txt specification."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "llms-txt",
+      category: "geo",
+      severity: "error",
+      message: "llms.txt not found or unreachable",
+      remediation: "Create a llms.txt file at the site root. Use `codeconductor seo llms` to generate one."
+    });
+  }
+  try {
+    const response = await safeFetch(`${root}/llms-full.txt`);
+    if (response.status === 200 && response.body.length > 0) {
+      checks.push({
+        name: "llms-full-txt",
+        category: "geo",
+        severity: "pass",
+        message: `llms-full.txt found (${response.body.length} bytes)`
+      });
+    }
+  } catch {
+    checks.push({
+      name: "llms-full-txt",
+      category: "geo",
+      severity: "info",
+      message: "llms-full.txt not found (optional)",
+      remediation: "Consider creating llms-full.txt with extended content for AI tools."
+    });
+  }
+  return checks;
+}
+
+// src/domain/seo/seo-auditor.ts
+function computeSummary(pages) {
+  let passed = 0;
+  let warnings = 0;
+  let errors3 = 0;
+  let total = 0;
+  for (const page of pages) {
+    for (const check of page.checks) {
+      total++;
+      if (check.severity === "pass")
+        passed++;
+      else if (check.severity === "warning" || check.severity === "info")
+        warnings++;
+      else if (check.severity === "error")
+        errors3++;
+    }
+  }
+  const score = total > 0 ? Math.round(passed / total * 100) : 0;
+  return { total, passed, warnings, errors: errors3, score };
+}
+async function auditSingleUrl(url, options = {}) {
+  const response = await safeFetch(url, {
+    followRedirects: options.followRedirects ?? false
+  });
+  const html = response.body;
+  const checks = [];
+  checks.push(...validateMeta(html, url, response.responseTime));
+  checks.push(...validateSchema(html));
+  checks.push(...validateGeo(html, url));
+  return {
+    url,
+    checks,
+    responseTime: response.responseTime
+  };
+}
+async function auditSitemap(sitemapUrl, options = {}) {
+  const { delay: requestDelay = 500, followRedirects = false, maxUrls, onProgress } = options;
+  const sitemapResult = await parseSitemap(sitemapUrl, { delay: requestDelay });
+  let entries = sitemapResult.entries;
+  if (maxUrls && entries.length > maxUrls) {
+    entries = entries.slice(0, maxUrls);
+  }
+  const pages = [];
+  for (let i = 0;i < entries.length; i++) {
+    const entry = entries[i];
+    if (onProgress) {
+      onProgress(i + 1, entries.length, entry.url);
+    }
+    if (i > 0 && requestDelay > 0) {
+      await delay(requestDelay);
+    }
+    try {
+      const result = await auditSingleUrl(entry.url, { followRedirects });
+      pages.push(result);
+    } catch (error) {
+      pages.push({
+        url: entry.url,
+        checks: [{
+          name: "fetch-error",
+          category: "technical",
+          severity: "error",
+          message: `Failed to fetch: ${String(error)}`
+        }],
+        responseTime: 0
+      });
+    }
+  }
+  try {
+    let siteRoot;
+    try {
+      const parsed = new URL(sitemapUrl);
+      siteRoot = `${parsed.protocol}//${parsed.host}`;
+    } catch {
+      siteRoot = sitemapUrl;
+    }
+    const llmsChecks = await checkLlmsTxt(siteRoot);
+    if (pages.length > 0) {
+      pages[0] = {
+        ...pages[0],
+        checks: [...pages[0].checks, ...llmsChecks]
+      };
+    }
+  } catch {}
+  const summary = computeSummary(pages);
+  return {
+    target: sitemapUrl,
+    timestamp: new Date().toISOString(),
+    pages,
+    summary
+  };
+}
+async function auditUrl(url, options = {}) {
+  const page = await auditSingleUrl(url, options);
+  try {
+    const llmsChecks = await checkLlmsTxt(url);
+    page.checks.push(...llmsChecks);
+  } catch {}
+  const summary = computeSummary([page]);
+  return {
+    target: url,
+    timestamp: new Date().toISOString(),
+    pages: [page],
+    summary
+  };
+}
+
+// src/domain/seo/report-formatter.ts
+var SEVERITY_ICONS = {
+  pass: "✓",
+  warning: "⚠",
+  error: "✗",
+  info: "ℹ"
+};
+var SEVERITY_COLORS = {
+  pass: "\x1B[32m",
+  warning: "\x1B[33m",
+  error: "\x1B[31m",
+  info: "\x1B[36m"
+};
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+function formatCli(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(`${BOLD}SEO Audit Report${RESET}`);
+  lines.push(`${DIM}Target: ${report.target}${RESET}`);
+  lines.push(`${DIM}Time: ${report.timestamp}${RESET}`);
+  lines.push(`${DIM}Pages: ${report.pages.length}${RESET}`);
+  lines.push("");
+  for (const page of report.pages) {
+    lines.push(`${BOLD}── ${page.url} (${page.responseTime}ms) ──${RESET}`);
+    const grouped = groupByCategory(page.checks);
+    for (const [category, checks] of grouped) {
+      lines.push(`  ${DIM}${category}${RESET}`);
+      for (const check of checks) {
+        const icon = SEVERITY_ICONS[check.severity];
+        const color = SEVERITY_COLORS[check.severity];
+        lines.push(`    ${color}${icon}${RESET} ${check.name}: ${check.message}`);
+        if (check.remediation && check.severity !== "pass") {
+          lines.push(`      ${DIM}→ ${check.remediation}${RESET}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  const { summary } = report;
+  lines.push(`${BOLD}Summary${RESET}`);
+  lines.push(`  Score: ${summary.score}%`);
+  lines.push(`  ${SEVERITY_COLORS.pass}✓ ${summary.passed} passed${RESET}`);
+  lines.push(`  ${SEVERITY_COLORS.warning}⚠ ${summary.warnings} warnings${RESET}`);
+  lines.push(`  ${SEVERITY_COLORS.error}✗ ${summary.errors} errors${RESET}`);
+  lines.push(`  Total checks: ${summary.total}`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+function formatJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+function formatMarkdown(report) {
+  const lines = [];
+  lines.push("# SEO Audit Report");
+  lines.push("");
+  lines.push(`- **Target:** ${report.target}`);
+  lines.push(`- **Date:** ${report.timestamp}`);
+  lines.push(`- **Pages audited:** ${report.pages.length}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Score | ${report.summary.score}% |`);
+  lines.push(`| Passed | ${report.summary.passed} |`);
+  lines.push(`| Warnings | ${report.summary.warnings} |`);
+  lines.push(`| Errors | ${report.summary.errors} |`);
+  lines.push(`| Total checks | ${report.summary.total} |`);
+  lines.push("");
+  for (const page of report.pages) {
+    lines.push(`## ${page.url}`);
+    lines.push("");
+    lines.push(`Response time: ${page.responseTime}ms`);
+    lines.push("");
+    const errors3 = page.checks.filter((c) => c.severity === "error");
+    const warnings = page.checks.filter((c) => c.severity === "warning");
+    const passed = page.checks.filter((c) => c.severity === "pass");
+    const info = page.checks.filter((c) => c.severity === "info");
+    if (errors3.length > 0) {
+      lines.push("### Errors");
+      lines.push("");
+      for (const check of errors3) {
+        lines.push(`- **${check.name}** (${check.category}): ${check.message}`);
+        if (check.remediation) {
+          lines.push(`  - Fix: ${check.remediation}`);
+        }
+      }
+      lines.push("");
+    }
+    if (warnings.length > 0) {
+      lines.push("### Warnings");
+      lines.push("");
+      for (const check of warnings) {
+        lines.push(`- **${check.name}** (${check.category}): ${check.message}`);
+        if (check.remediation) {
+          lines.push(`  - Fix: ${check.remediation}`);
+        }
+      }
+      lines.push("");
+    }
+    if (passed.length > 0) {
+      lines.push("### Passed");
+      lines.push("");
+      for (const check of passed) {
+        lines.push(`- ${check.name}: ${check.message}`);
+      }
+      lines.push("");
+    }
+    if (info.length > 0) {
+      lines.push("### Info");
+      lines.push("");
+      for (const check of info) {
+        lines.push(`- ${check.name}: ${check.message}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push(`*Generated by CodeConductor SEO Audit on ${report.timestamp.split("T")[0]}*`);
+  return lines.join(`
+`);
+}
+function groupByCategory(checks) {
+  const groups = new Map;
+  for (const check of checks) {
+    if (!groups.has(check.category)) {
+      groups.set(check.category, []);
+    }
+    groups.get(check.category).push(check);
+  }
+  return groups;
+}
+function computeExitCode(report, failOn) {
+  if (report.summary.errors > 0)
+    return 1;
+  if (failOn === "warning" && report.summary.warnings > 0)
+    return 2;
+  if (report.summary.warnings > 0)
+    return 0;
+  return 0;
+}
+
+// src/commands/seo-audit.command.ts
+async function seoAuditCommand(options) {
+  const { url, sitemap, format, failOn, delay: delay2, output, followRedirects } = options;
+  if (!url && !sitemap) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "seo audit",
+        errors: ["Either --url or --sitemap is required"]
+      }
+    };
+  }
+  try {
+    const report = sitemap ? await auditSitemap(sitemap, {
+      delay: delay2,
+      followRedirects,
+      onProgress: format === "cli" ? (current, total, pageUrl) => {
+        process.stderr.write(`\r  Auditing ${current}/${total}: ${pageUrl}`);
+      } : undefined
+    }) : await auditUrl(url, { followRedirects });
+    if (format === "cli") {
+      process.stderr.write("\r" + " ".repeat(80) + "\r");
+    }
+    let formattedOutput;
+    switch (format) {
+      case "json":
+        formattedOutput = formatJson(report);
+        break;
+      case "markdown":
+        formattedOutput = formatMarkdown(report);
+        break;
+      default:
+        formattedOutput = formatCli(report);
+    }
+    if (output) {
+      const outputPath = resolve9(options.projectRoot, output);
+      await mkdir6(dirname4(outputPath), { recursive: true });
+      await writeFile5(outputPath, formattedOutput, "utf-8");
+    } else if (format === "markdown") {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const defaultPath = resolve9(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
+      await mkdir6(dirname4(defaultPath), { recursive: true });
+      await writeFile5(defaultPath, formattedOutput, "utf-8");
+      process.stderr.write(`Report saved to: ${defaultPath}
+`);
+    }
+    const exitCode = computeExitCode(report, failOn);
+    return {
+      code: exitCode,
+      data: {
+        success: true,
+        command: "seo audit",
+        report,
+        output: formattedOutput,
+        outputFile: output ? resolve9(options.projectRoot, output) : format === "markdown" ? resolve9(options.projectRoot, "seo-reports") : undefined
+      }
+    };
+  } catch (error) {
+    return {
+      code: 3,
+      data: {
+        success: false,
+        command: "seo audit",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+
+// src/commands/seo-llms.command.ts
+import { writeFile as writeFile6, mkdir as mkdir7 } from "node:fs/promises";
+import { dirname as dirname5, resolve as resolve10 } from "node:path";
+
+// src/domain/seo/llms-generator.ts
+function extractTitle2(html) {
+  const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return match ? match[1].trim() : "";
+}
+function extractDescription(html) {
+  const patterns = [
+    /<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["']/i,
+    /<meta[^>]*content=["']([^"']*)["'][^>]*name=["']description["']/i,
+    /<meta[^>]*property=["']og:description["'][^>]*content=["']([^"']*)["']/i
+  ];
+  for (const pattern of patterns) {
+    const match = html.match(pattern);
+    if (match)
+      return match[1].trim();
+  }
+  return "";
+}
+function extractFirstParagraph(html) {
+  const bodyHtml = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<nav[\s\S]*?<\/nav>/gi, "").replace(/<header[\s\S]*?<\/header>/gi, "").replace(/<footer[\s\S]*?<\/footer>/gi, "");
+  const match = bodyHtml.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
+  if (!match)
+    return "";
+  return match[1].replace(/<[^>]*>/g, "").trim().slice(0, 200);
+}
+function groupByPathSegment(entries) {
+  const groups = new Map;
+  for (const entry of entries) {
+    try {
+      const parsed = new URL(entry.url);
+      const segments = parsed.pathname.split("/").filter(Boolean);
+      const group = segments.length > 0 ? `/${segments[0]}/` : "/";
+      if (!groups.has(group)) {
+        groups.set(group, []);
+      }
+      groups.get(group).push(entry);
+    } catch {
+      if (!groups.has("/")) {
+        groups.set("/", []);
+      }
+      groups.get("/").push(entry);
+    }
+  }
+  return groups;
+}
+function formatLlmsTxt(siteName, siteDescription, entries) {
+  const lines = [];
+  lines.push(`# ${siteName}`);
+  if (siteDescription) {
+    lines.push(`> ${siteDescription}`);
+  }
+  lines.push("");
+  const groups = groupByPathSegment(entries);
+  for (const [group, groupEntries] of groups) {
+    const groupName = group === "/" ? "Main Pages" : group.replace(/\//g, "").replace(/-/g, " ");
+    lines.push(`## ${groupName.charAt(0).toUpperCase() + groupName.slice(1)}`);
+    lines.push("");
+    for (const entry of groupEntries) {
+      const desc = entry.description ? `: ${entry.description}` : "";
+      lines.push(`- [${entry.title}](${entry.url})${desc}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push(`Generated by CodeConductor SEO on ${new Date().toISOString().split("T")[0]}`);
+  return lines.join(`
+`);
+}
+async function generateLlmsTxtFromSitemap(sitemapUrl, options = {}) {
+  const { delay: requestDelay = 500, maxUrls, onProgress } = options;
+  const sitemapResult = await parseSitemap(sitemapUrl, { delay: requestDelay });
+  let urls = sitemapResult.entries.map((e) => e.url);
+  if (maxUrls && urls.length > maxUrls) {
+    urls = urls.slice(0, maxUrls);
+  }
+  const entries = [];
+  let siteName = "";
+  let siteDescription = "";
+  for (let i = 0;i < urls.length; i++) {
+    const url = urls[i];
+    if (onProgress) {
+      onProgress(i + 1, urls.length, url);
+    }
+    if (i > 0 && requestDelay > 0) {
+      await delay(requestDelay);
+    }
+    try {
+      const response = await safeFetch(url);
+      const html = response.body;
+      const title = extractTitle2(html) || url;
+      const description = extractDescription(html) || extractFirstParagraph(html);
+      if (i === 0) {
+        siteName = title;
+        siteDescription = extractDescription(html);
+      }
+      entries.push({ title, url, description });
+    } catch {
+      entries.push({ title: url, url, description: "" });
+    }
+  }
+  if (!siteName) {
+    try {
+      siteName = new URL(sitemapUrl).hostname;
+    } catch {
+      siteName = "Site";
+    }
+  }
+  const content = formatLlmsTxt(siteName, siteDescription, entries);
+  return { content, entries };
+}
+async function generateLlmsTxtFromUrl(url) {
+  const response = await safeFetch(url);
+  const html = response.body;
+  const title = extractTitle2(html) || url;
+  const description = extractDescription(html) || extractFirstParagraph(html);
+  const entries = [{ title, url, description }];
+  const content = formatLlmsTxt(title, description, entries);
+  return { content, entries };
+}
+
+// src/commands/seo-llms.command.ts
+async function seoLlmsCommand(options) {
+  const { url, sitemap, output, delay: delay2 } = options;
+  if (!url && !sitemap) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "seo llms",
+        errors: ["Either --url or --sitemap is required"]
+      }
+    };
+  }
+  try {
+    const result = sitemap ? await generateLlmsTxtFromSitemap(sitemap, {
+      delay: delay2,
+      onProgress: (current, total, pageUrl) => {
+        process.stderr.write(`\r  Processing ${current}/${total}: ${pageUrl}`);
+      }
+    }) : await generateLlmsTxtFromUrl(url);
+    process.stderr.write("\r" + " ".repeat(80) + "\r");
+    const outputPath = output ? resolve10(options.projectRoot, output) : resolve10(options.projectRoot, "llms.txt");
+    await mkdir7(dirname5(outputPath), { recursive: true });
+    await writeFile6(outputPath, result.content, "utf-8");
+    process.stderr.write(`Generated: ${outputPath} (${result.entries.length} entries)
+`);
+    return {
+      code: 0,
+      data: {
+        success: true,
+        command: "seo llms",
+        outputFile: outputPath,
+        entries: result.entries.length,
+        content: result.content
+      }
+    };
+  } catch (error) {
+    return {
+      code: 3,
+      data: {
+        success: false,
+        command: "seo llms",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+
+// src/commands/update.command.ts
+async function updateCommand(options) {
+  const { dryRun, force, output, projectRoot } = options;
+  try {
+    const configResult = await loadConfig(projectRoot);
+    if (!configResult.success) {
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "update",
+          errors: ["No config found. Run `codeconductor init` first."]
+        }
+      };
+    }
+    const config = configResult.data;
+    if (!config.presets.council.enabled) {
+      return {
+        code: 4,
+        data: {
+          success: false,
+          command: "update",
+          errors: ["Council preset is not enabled"]
+        }
+      };
+    }
+    const presetResult = await loadCouncilPreset(projectRoot);
+    if (!presetResult.success) {
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "update",
+          errors: ["Failed to load preset"]
+        }
+      };
+    }
+    const spec = presetResult.data;
+    const currentVersion = config.presets.council.version;
+    const newVersion = spec.version;
+    if (currentVersion === newVersion) {
+      return {
+        code: 0,
+        data: {
+          success: true,
+          command: "update",
+          message: "Already up to date",
+          currentVersion,
+          newVersion
+        }
+      };
+    }
+    if (dryRun) {
+      return {
+        code: 0,
+        data: {
+          success: true,
+          command: "update",
+          message: "Dry run - would update",
+          currentVersion,
+          newVersion,
+          wouldUpdate: ["council preset files"]
+        }
+      };
+    }
+    const writeOptions = { dryRun: false, force };
+    const target = config.defaults.target;
+    let installer;
+    switch (target) {
+      case "opencode":
+        installer = createOpenCodeInstaller(spec);
+        break;
+      case "claude":
+        installer = createClaudeInstaller(spec);
+        break;
+      case "codex":
+        installer = createCodexInstaller(spec);
+        break;
+      default:
+        return {
+          code: 1,
+          data: {
+            success: false,
+            command: "update",
+            errors: [`Unknown target: ${target}`]
+          }
+        };
+    }
+    const files = await installer.generate();
+    const results = await writeGeneratedFiles(files, writeOptions);
+    const updated = results.filter((r) => r.success).map((r) => r.path);
+    const errors3 = results.filter((r) => !r.success).map((r) => `${r.path}: ${r.error}`);
+    if (errors3.length > 0) {
+      return {
+        code: 2,
+        data: {
+          success: false,
+          command: "update",
+          errors: errors3
+        }
+      };
+    }
+    return {
+      code: 0,
+      data: {
+        success: true,
+        command: "update",
+        message: "Updated successfully",
+        currentVersion,
+        newVersion,
+        updated
+      }
+    };
+  } catch (error) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "update",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+
+// src/cli/router.ts
+function parseArgs(args) {
+  const flags = {
+    help: false,
+    version: false,
+    dryRun: false,
+    force: false,
+    output: "human"
+  };
+  const options = {};
+  const remaining = [];
+  for (const arg of args) {
+    if (arg === "--help" || arg === "-h") {
+      flags.help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      flags.version = true;
+    } else if (arg === "--dry-run") {
+      flags.dryRun = true;
+    } else if (arg === "--force") {
+      flags.force = true;
+    } else if (arg === "--output" || arg === "-o") {
+      remaining.push(arg);
+    } else if (arg.startsWith("--output=") || arg.startsWith("-o=")) {
+      const value = arg.split("=")[1];
+      if (value === "json" || value === "human") {
+        flags.output = value;
+      }
+    } else {
+      remaining.push(arg);
+    }
+  }
+  for (let i = 0;i < remaining.length; i++) {
+    if ((remaining[i] === "--output" || remaining[i] === "-o") && remaining[i + 1]) {
+      const value = remaining[i + 1];
+      if (value === "json" || value === "human") {
+        flags.output = value;
+        remaining.splice(i, 2);
+        i--;
+      }
+    }
+  }
+  const command = remaining[0] || "help";
+  const subcommand = remaining[1] && !remaining[1].startsWith("-") ? remaining[1] : undefined;
+  for (let i = 1;i < remaining.length; i++) {
+    const arg = remaining[i];
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.slice(2).split("=");
+      if (key === "lang") {
+        const langValue = value !== undefined ? value : remaining[++i];
+        if (langValue && typeof langValue === "string") {
+          options[key] = langValue.split(",").map((s) => s.trim());
+        }
+      } else if (value !== undefined) {
+        options[key] = value;
+      } else if (remaining[i + 1] && !remaining[i + 1].startsWith("-")) {
+        options[key] = remaining[++i];
+      } else {
+        options[key] = true;
+      }
+    }
+  }
+  return { command, subcommand, options, flags };
+}
+function getVersion() {
+  return `${package_default.name} v${package_default.version}`;
+}
+function getHelp() {
+  return `CodeConductor CLI v${package_default.version}
+
+Usage: npx cc-codeconductor <command> [options]
+
+Commands:
+  init                    Initialize CodeConductor in a project
+  detect                 Detect project stack and recommended presets
   install council        Install generated council spec files to runner targets
   install preset         Install full preset (agents, prompts, skills, commands)
+  install lsp            Install and configure LSP servers for AI coding tools
+  seo audit              Run SEO audit on a URL or sitemap
+  seo llms               Generate llms.txt from a URL or sitemap
   doctor                 Validate configuration and generated files
   update                 Update installed presets
 
@@ -12867,6 +15104,7 @@ Options:
   --force                Allow overwriting existing files
   --global               Install to home directory (~/.claude, ~/.opencode, etc.)
   --output, -o           Output mode: human or json
+  --lang                 Comma-separated list of languages (e.g., typescript,php,python)
 
 Examples:
   npx cc-codeconductor init
@@ -12881,8 +15119,16 @@ Examples:
   npx cc-codeconductor install council --target claude
   npx cc-codeconductor install council --target codex
   npx cc-codeconductor install council --target all
+  npx cc-codeconductor install lsp --target opencode
+  npx cc-codeconductor install lsp --target all --lang typescript,python
+  npx cc-codeconductor install lsp --target claude --dry-run
   npx cc-codeconductor doctor
   npx cc-codeconductor update --dry-run
+  npx cc-codeconductor seo audit --url https://example.com
+  npx cc-codeconductor seo audit --sitemap https://example.com/sitemap.xml
+  npx cc-codeconductor seo audit --sitemap https://example.com/sitemap.xml --format markdown
+  npx cc-codeconductor seo llms --sitemap https://example.com/sitemap.xml
+  npx cc-codeconductor seo llms --url https://example.com --output llms.txt
 `;
 }
 async function routeCommand(args, projectRoot) {
@@ -12905,7 +15151,7 @@ async function routeCommand(args, projectRoot) {
       });
     case "install": {
       const isGlobal = options.global === true || options.global === "true";
-      const VALID_TARGETS = ["opencode", "claude", "codex", "all"];
+      const VALID_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "agy", "all"];
       let resolvedSubcommand = subcommand;
       let target = options.target;
       if (!target && subcommand && VALID_TARGETS.includes(subcommand)) {
@@ -12913,6 +15159,17 @@ async function routeCommand(args, projectRoot) {
         resolvedSubcommand = undefined;
       }
       target = target || "opencode";
+      if (resolvedSubcommand === "lsp") {
+        return installLspCommand({
+          projectRoot,
+          target,
+          lang: options.lang,
+          dryRun: flags.dryRun,
+          force: flags.force,
+          global: isGlobal,
+          output: flags.output
+        });
+      }
       if (resolvedSubcommand === "preset") {
         return installPresetCommand({
           projectRoot,
@@ -12944,6 +15201,37 @@ async function routeCommand(args, projectRoot) {
         force: flags.force,
         output: flags.output
       });
+    case "seo": {
+      if (subcommand === "audit") {
+        return seoAuditCommand({
+          url: options.url,
+          sitemap: options.sitemap,
+          format: options.format ?? (flags.output === "json" ? "json" : "cli"),
+          failOn: options["fail-on"] ?? "error",
+          delay: options.delay ? parseInt(String(options.delay), 10) : 500,
+          output: options.output,
+          followRedirects: options["follow-redirects"] === true,
+          projectRoot
+        });
+      }
+      if (subcommand === "llms") {
+        return seoLlmsCommand({
+          url: options.url,
+          sitemap: options.sitemap,
+          output: options.output,
+          delay: options.delay ? parseInt(String(options.delay), 10) : 500,
+          projectRoot
+        });
+      }
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "seo",
+          errors: ["Usage: seo audit|llms. Run `codeconductor seo audit --help` for details."]
+        }
+      };
+    }
     default:
       return {
         code: 1,
@@ -13035,6 +15323,8 @@ ${count} files processed${errCount > 0 ? `, ${errCount} errors` : ""}${note}`);
                 console.log(`  - ${key}: ${value}`);
               }
             });
+          } else if ("output" in data && typeof data.output === "string") {
+            console.log(data.output);
           }
         }
       }