archondev 2.0.0 → 2.1.1

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   cloudLogs,
   cloudStatus,
   execute
-} from "./chunk-3WEJ3DXM.js";
+} from "./chunk-XRWIU3RD.js";
 import {
   list
 } from "./chunk-N73LAU7W.js";
@@ -71,6 +71,7 @@ import {
 import "./chunk-A7QU6JC6.js";
 import "./chunk-SMR7JQK6.js";
 import {
+  getAuthToken,
   loadConfig
 } from "./chunk-IVY5AHPS.js";
 import {
@@ -80,7 +81,7 @@ import "./chunk-QGM4M3NI.js";
 
 // src/cli/index.ts
 import { Command as Command4 } from "commander";
-import chalk12 from "chalk";
+import chalk14 from "chalk";
 import "dotenv/config";
 
 // src/cli/promote.ts
@@ -299,10 +300,10 @@ function formatDateTime(date) {
 }
 
 // src/cli/start.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import readline from "readline";
-import { existsSync as existsSync3, readFileSync, readdirSync, appendFileSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync, readdirSync as readdirSync2, appendFileSync } from "fs";
+import { join as join4 } from "path";
 
 // src/core/context/manager.ts
 import { existsSync as existsSync2 } from "fs";
@@ -399,44 +400,479 @@ var ContextManager = class _ContextManager {
   async clearPendingAtoms(cwd) {
     const filePath = join2(cwd, _ContextManager.PENDING_ATOMS_FILE);
     if (existsSync2(filePath)) {
-      const { unlink } = await import("fs/promises");
-      await unlink(filePath);
+      const { unlink: unlink2 } = await import("fs/promises");
+      await unlink2(filePath);
     }
   }
 };
 
+// src/cli/cleanup.ts
+import chalk3 from "chalk";
+import { existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2, unlink, readdir, stat } from "fs/promises";
+import { join as join3 } from "path";
+import yaml from "yaml";
+import { execSync } from "child_process";
+var CONFIG_PATH = ".archon/config.yaml";
+var PROGRESS_FILE = "progress.txt";
+var ARCHON_DIR = ".archon";
+var CACHE_DIR = ".archon/cache";
+var ARCHIVE_DIR = "docs/archive";
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function getDirSize(dirPath) {
+  if (!existsSync3(dirPath)) return 0;
+  let totalSize = 0;
+  try {
+    const files = readdirSync(dirPath, { withFileTypes: true });
+    for (const file of files) {
+      const filePath = join3(dirPath, file.name);
+      if (file.isDirectory()) {
+        totalSize += getDirSize(filePath);
+      } else {
+        try {
+          totalSize += statSync(filePath).size;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return totalSize;
+}
+async function loadCleanupConfig(cwd) {
+  const configPath = join3(cwd, CONFIG_PATH);
+  if (!existsSync3(configPath)) {
+    return void 0;
+  }
+  try {
+    const content = await readFile3(configPath, "utf-8");
+    const config = yaml.parse(content);
+    return config.cleanup;
+  } catch {
+    return void 0;
+  }
+}
+async function saveCleanupConfig(cwd, cleanup) {
+  const configPath = join3(cwd, CONFIG_PATH);
+  const archonDir = join3(cwd, ARCHON_DIR);
+  if (!existsSync3(archonDir)) {
+    await mkdir2(archonDir, { recursive: true });
+  }
+  let existing = {};
+  if (existsSync3(configPath)) {
+    try {
+      const content = await readFile3(configPath, "utf-8");
+      existing = yaml.parse(content);
+    } catch {
+    }
+  }
+  existing.cleanup = cleanup;
+  await writeFile3(configPath, yaml.stringify(existing), "utf-8");
+}
+function getOrphanedWorktrees(cwd) {
+  const orphaned = [];
+  try {
+    const output = execSync("git worktree list --porcelain", {
+      cwd,
+      encoding: "utf-8"
+    });
+    const lines = output.split("\n");
+    let currentWorktree = "";
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        currentWorktree = line.replace("worktree ", "");
+      } else if (line.startsWith("branch ")) {
+        if (currentWorktree.includes(".archon-worktree") || currentWorktree.includes("archon-parallel")) {
+          if (!existsSync3(join3(currentWorktree, ".git"))) {
+            orphaned.push(currentWorktree);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return orphaned;
+}
+async function getStaleFiles(dirPath, maxAgeDays) {
+  const staleFiles = [];
+  if (!existsSync3(dirPath)) return staleFiles;
+  const cutoffTime = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join3(dirPath, entry.name);
+      if (entry.isFile()) {
+        try {
+          const stats = await stat(fullPath);
+          if (stats.mtimeMs < cutoffTime) {
+            staleFiles.push({ path: fullPath, size: stats.size });
+          }
+        } catch {
+        }
+      } else if (entry.isDirectory()) {
+        const nested = await getStaleFiles(fullPath, maxAgeDays);
+        staleFiles.push(...nested);
+      }
+    }
+  } catch {
+  }
+  return staleFiles;
+}
+async function parseProgressEntries(content) {
+  const entries = [];
+  const lines = content.split("\n");
+  let currentEntry = "";
+  let currentDate = null;
+  const datePatterns = [
+    /^\[(\d{4}-\d{2}-\d{2})/,
+    /^## (\d{4}-\d{2}-\d{2})/,
+    /^### (\d{4}-\d{2}-\d{2})/,
+    /^(\d{4}-\d{2}-\d{2})/
+  ];
+  for (const line of lines) {
+    let dateMatch = null;
+    for (const pattern of datePatterns) {
+      const match = line.match(pattern);
+      if (match?.[1]) {
+        dateMatch = match[1];
+        break;
+      }
+    }
+    if (dateMatch) {
+      if (currentDate && currentEntry.trim()) {
+        entries.push({ date: currentDate, content: currentEntry.trim() });
+      }
+      currentDate = new Date(dateMatch);
+      currentEntry = line + "\n";
+    } else {
+      currentEntry += line + "\n";
+    }
+  }
+  if (currentDate && currentEntry.trim()) {
+    entries.push({ date: currentDate, content: currentEntry.trim() });
+  }
+  return entries;
+}
+async function cleanupCheck() {
+  const cwd = process.cwd();
+  const results = [];
+  console.log(chalk3.blue("\n\u{1F50D} Analyzing workspace for maintenance needs...\n"));
+  const progressPath = join3(cwd, PROGRESS_FILE);
+  if (existsSync3(progressPath)) {
+    const size = statSync(progressPath).size;
+    let status2 = "ok";
+    let recommendation;
+    if (size > 200 * 1024) {
+      status2 = "critical";
+      recommendation = "Archive old entries with: archon cleanup run";
+    } else if (size > 100 * 1024) {
+      status2 = "warn";
+      recommendation = "Consider archiving entries older than 30 days";
+    }
+    results.push({
+      name: "progress.txt",
+      size,
+      sizeFormatted: formatBytes(size),
+      status: status2,
+      recommendation
+    });
+  }
+  const archonPath = join3(cwd, ARCHON_DIR);
+  if (existsSync3(archonPath)) {
+    const size = getDirSize(archonPath);
+    let status2 = "ok";
+    let recommendation;
+    if (size > 10 * 1024 * 1024) {
+      status2 = "warn";
+      recommendation = "Clear stale cache files with: archon cleanup run";
+    }
+    results.push({
+      name: ".archon/",
+      size,
+      sizeFormatted: formatBytes(size),
+      status: status2,
+      recommendation
+    });
+  }
+  const nodeModulesPath = join3(cwd, "node_modules");
+  if (existsSync3(nodeModulesPath)) {
+    const size = getDirSize(nodeModulesPath);
+    results.push({
+      name: "node_modules/",
+      size,
+      sizeFormatted: formatBytes(size),
+      status: "ok",
+      recommendation: "Standard npm dependencies (informational)"
+    });
+  }
+  const orphanedWorktrees = getOrphanedWorktrees(cwd);
+  if (orphanedWorktrees.length > 0) {
+    results.push({
+      name: "Orphaned Worktrees",
+      size: orphanedWorktrees.length,
+      sizeFormatted: `${orphanedWorktrees.length} found`,
+      status: "warn",
+      recommendation: "Clean up with: archon cleanup run"
+    });
+  }
+  const cachePath = join3(cwd, CACHE_DIR);
+  if (existsSync3(cachePath)) {
+    const staleCache = await getStaleFiles(cachePath, 7);
+    if (staleCache.length > 0) {
+      const totalSize = staleCache.reduce((sum, f) => sum + f.size, 0);
+      results.push({
+        name: "Stale Cache Files",
+        size: totalSize,
+        sizeFormatted: `${staleCache.length} files (${formatBytes(totalSize)})`,
+        status: "warn",
+        recommendation: "Clean up with: archon cleanup run"
+      });
+    }
+  }
+  console.log(chalk3.bold("Workspace Analysis Summary\n"));
+  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+  console.log("\u2502 Item                    \u2502 Size           \u2502 Status   \u2502");
+  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+  for (const result of results) {
+    const statusIcon = result.status === "critical" ? chalk3.red("\u2717") : result.status === "warn" ? chalk3.yellow("!") : chalk3.green("\u2713");
+    const name = result.name.padEnd(23);
+    const size = result.sizeFormatted.padEnd(14);
+    console.log(`\u2502 ${name} \u2502 ${size} \u2502 ${statusIcon}        \u2502`);
+  }
+  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+  console.log();
+  const recommendations = results.filter((r) => r.recommendation && r.status !== "ok");
+  if (recommendations.length > 0) {
+    console.log(chalk3.yellow("Recommendations:\n"));
+    for (const rec of recommendations) {
+      console.log(`  ${chalk3.dim("\u2022")} ${rec.name}: ${rec.recommendation}`);
+    }
+    console.log();
+  } else {
+    console.log(chalk3.green("\u2713 Workspace is in good shape!\n"));
+  }
+}
+async function cleanupRun() {
+  const cwd = process.cwd();
+  const results = [];
+  let totalSaved = 0;
+  console.log(chalk3.blue("\n\u{1F9F9} Running workspace cleanup...\n"));
+  const progressPath = join3(cwd, PROGRESS_FILE);
+  if (existsSync3(progressPath)) {
+    const content = await readFile3(progressPath, "utf-8");
+    const entries = await parseProgressEntries(content);
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - 30);
+    const oldEntries = entries.filter((e) => e.date < cutoffDate);
+    const recentEntries = entries.filter((e) => e.date >= cutoffDate);
+    if (oldEntries.length > 0) {
+      const archiveDir = join3(cwd, ARCHIVE_DIR);
+      if (!existsSync3(archiveDir)) {
+        await mkdir2(archiveDir, { recursive: true });
+      }
+      const archiveFileName = `progress-archive-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.txt`;
+      const archivePath = join3(archiveDir, archiveFileName);
+      const archiveContent = oldEntries.map((e) => e.content).join("\n\n---\n\n");
+      await writeFile3(archivePath, archiveContent, "utf-8");
+      const originalSize = statSync(progressPath).size;
+      const newContent = recentEntries.map((e) => e.content).join("\n\n");
+      await writeFile3(progressPath, newContent, "utf-8");
+      const newSize = statSync(progressPath).size;
+      const saved = originalSize - newSize;
+      results.push({
+        name: "progress.txt",
+        action: `Archived ${oldEntries.length} entries to ${archiveFileName}`,
+        spaceSaved: saved,
+        spaceSavedFormatted: formatBytes(saved)
+      });
+      totalSaved += saved;
+    }
+  }
+  const orphanedWorktrees = getOrphanedWorktrees(cwd);
+  for (const worktree of orphanedWorktrees) {
+    try {
+      execSync(`git worktree remove --force "${worktree}"`, {
+        cwd,
+        encoding: "utf-8"
+      });
+      results.push({
+        name: "Worktree",
+        action: `Removed orphaned worktree: ${worktree}`,
+        spaceSaved: 0,
+        spaceSavedFormatted: "N/A"
+      });
+    } catch {
+      console.log(chalk3.yellow(`  Could not remove worktree: ${worktree}`));
+    }
+  }
+  const cachePath = join3(cwd, CACHE_DIR);
+  if (existsSync3(cachePath)) {
+    const staleCache = await getStaleFiles(cachePath, 7);
+    let cacheSaved = 0;
+    for (const file of staleCache) {
+      try {
+        await unlink(file.path);
+        cacheSaved += file.size;
+      } catch {
+      }
+    }
+    if (staleCache.length > 0) {
+      results.push({
+        name: "Cache",
+        action: `Removed ${staleCache.length} stale cache files`,
+        spaceSaved: cacheSaved,
+        spaceSavedFormatted: formatBytes(cacheSaved)
+      });
+      totalSaved += cacheSaved;
+    }
+  }
+  const cloudLogsPath = join3(cwd, ".archon", "cloud-logs");
+  if (existsSync3(cloudLogsPath)) {
+    const staleLogs = await getStaleFiles(cloudLogsPath, 30);
+    let logsSaved = 0;
+    for (const file of staleLogs) {
+      try {
+        await unlink(file.path);
+        logsSaved += file.size;
+      } catch {
+      }
+    }
+    if (staleLogs.length > 0) {
+      results.push({
+        name: "Cloud Logs",
+        action: `Removed ${staleLogs.length} stale log files`,
+        spaceSaved: logsSaved,
+        spaceSavedFormatted: formatBytes(logsSaved)
+      });
+      totalSaved += logsSaved;
+    }
+  }
+  if (results.length === 0) {
+    console.log(chalk3.green("\u2713 Nothing to clean up!\n"));
+    return;
+  }
+  console.log(chalk3.bold("Cleanup Results\n"));
+  for (const result of results) {
+    console.log(`  ${chalk3.green("\u2713")} ${result.name}: ${result.action}`);
+    if (result.spaceSaved > 0) {
+      console.log(chalk3.dim(`      Space saved: ${result.spaceSavedFormatted}`));
+    }
+  }
+  console.log();
+  console.log(chalk3.green(`\u2713 Total space saved: ${formatBytes(totalSaved)}
+`));
+}
+async function cleanupAuto(action) {
+  const cwd = process.cwd();
+  const config = await loadCleanupConfig(cwd);
+  if (action === "status") {
+    const enabled = config?.autoEnabled ?? false;
+    console.log(chalk3.blue("\n\u{1F527} Auto Cleanup Settings\n"));
+    console.log(
+      `  Status: ${enabled ? chalk3.green("Enabled") : chalk3.dim("Disabled")}`
+    );
+    console.log(
+      chalk3.dim(
+        `  Progress archive threshold: ${config?.progressArchiveDays ?? 30} days`
+      )
+    );
+    console.log(
+      chalk3.dim(`  Cache retention: ${config?.cacheRetentionDays ?? 7} days`)
+    );
+    console.log(
+      chalk3.dim(
+        `  Cloud log retention: ${config?.cloudLogRetentionDays ?? 30} days`
+      )
+    );
+    console.log();
+    return;
+  }
+  const newConfig = {
+    autoEnabled: action === "enable",
+    progressArchiveDays: config?.progressArchiveDays ?? 30,
+    cacheRetentionDays: config?.cacheRetentionDays ?? 7,
+    cloudLogRetentionDays: config?.cloudLogRetentionDays ?? 30
+  };
+  await saveCleanupConfig(cwd, newConfig);
+  if (action === "enable") {
+    console.log(chalk3.green("\n\u2713 Auto cleanup enabled"));
+    console.log(
+      chalk3.dim(
+        '  Cleanup check will run on "archon start" and warn if action needed\n'
+      )
+    );
+  } else {
+    console.log(chalk3.green("\n\u2713 Auto cleanup disabled\n"));
+  }
+}
+async function shouldRunAutoCleanup(cwd) {
+  const config = await loadCleanupConfig(cwd);
+  return config?.autoEnabled ?? false;
+}
+async function runAutoCleanupCheck(cwd) {
+  const progressPath = join3(cwd, PROGRESS_FILE);
+  const archonPath = join3(cwd, ARCHON_DIR);
+  let needsAttention = false;
+  if (existsSync3(progressPath)) {
+    const size = statSync(progressPath).size;
+    if (size > 100 * 1024) {
+      needsAttention = true;
+    }
+  }
+  if (existsSync3(archonPath)) {
+    const size = getDirSize(archonPath);
+    if (size > 10 * 1024 * 1024) {
+      needsAttention = true;
+    }
+  }
+  const orphaned = getOrphanedWorktrees(cwd);
+  if (orphaned.length > 0) {
+    needsAttention = true;
+  }
+  return needsAttention;
+}
+
 // src/cli/start.ts
 async function start() {
   const cwd = process.cwd();
-  console.log(chalk3.blue("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
-  console.log(chalk3.bold.white("  ArchonDev - AI-Powered Development Governance"));
-  console.log(chalk3.blue("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n"));
+  console.log(chalk4.blue("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+  console.log(chalk4.bold.white("  ArchonDev - AI-Powered Development Governance"));
+  console.log(chalk4.blue("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n"));
   const contextManager = new ContextManager();
   const pendingAtomsData = await contextManager.getPendingAtomsData(cwd);
   if (pendingAtomsData && pendingAtomsData.atoms.length > 0) {
-    console.log(chalk3.yellow("\u26A1 Previous session had pending atoms:\n"));
+    console.log(chalk4.yellow("\u26A1 Previous session had pending atoms:\n"));
     for (const atomId of pendingAtomsData.atoms) {
-      console.log(chalk3.dim(`   \u2022 ${atomId}`));
+      console.log(chalk4.dim(`   \u2022 ${atomId}`));
     }
     console.log();
-    console.log(chalk3.dim(`   Saved at: ${pendingAtomsData.savedAt}`));
-    console.log(chalk3.dim(`   Context usage was: ${(pendingAtomsData.contextState.usagePercent * 100).toFixed(0)}%`));
+    console.log(chalk4.dim(`   Saved at: ${pendingAtomsData.savedAt}`));
+    console.log(chalk4.dim(`   Context usage was: ${(pendingAtomsData.contextState.usagePercent * 100).toFixed(0)}%`));
     console.log();
     const resume = await promptYesNo("Resume with these atoms?", true);
     if (resume) {
-      console.log(chalk3.green("\n\u2713 Resuming with pending atoms...\n"));
+      console.log(chalk4.green("\n\u2713 Resuming with pending atoms...\n"));
       await contextManager.clearPendingAtoms(cwd);
     } else {
       const clear = await promptYesNo("Clear pending atoms?", false);
       if (clear) {
         await contextManager.clearPendingAtoms(cwd);
-        console.log(chalk3.dim("Cleared pending atoms.\n"));
+        console.log(chalk4.dim("Cleared pending atoms.\n"));
       }
     }
   }
   const projectState = detectProjectState(cwd);
   const governanceStatus = await gatherGovernanceStatus(cwd);
   displayGovernanceBanner(governanceStatus);
+  if (await shouldRunAutoCleanup(cwd)) {
+    await runAutoCleanupCheck(cwd);
+  }
   switch (projectState.scenario) {
     case "NEW_PROJECT":
       await handleNewProject(cwd, projectState);
@@ -454,14 +890,14 @@ function detectProjectState(cwd) {
   const sourceExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".rb", ".php"];
   let hasSourceFiles = false;
   for (const dir of sourceDirs) {
-    if (existsSync3(join3(cwd, dir))) {
+    if (existsSync4(join4(cwd, dir))) {
       hasSourceFiles = true;
       break;
     }
   }
   if (!hasSourceFiles) {
     try {
-      const files = readdirSync(cwd);
+      const files = readdirSync2(cwd);
       hasSourceFiles = files.some(
         (f) => sourceExtensions.some((ext) => f.endsWith(ext))
       );
@@ -470,16 +906,16 @@ function detectProjectState(cwd) {
   }
   const projectMarkers = ["package.json", "Cargo.toml", "pyproject.toml", "go.mod", "pom.xml", "build.gradle"];
   if (!hasSourceFiles) {
-    hasSourceFiles = projectMarkers.some((marker) => existsSync3(join3(cwd, marker)));
+    hasSourceFiles = projectMarkers.some((marker) => existsSync4(join4(cwd, marker)));
   }
-  const hasArchitecture = existsSync3(join3(cwd, "ARCHITECTURE.md"));
-  const hasProgress = existsSync3(join3(cwd, "progress.txt"));
-  const hasReviewDb = existsSync3(join3(cwd, "docs", "code-review", "review-tasks.db"));
+  const hasArchitecture = existsSync4(join4(cwd, "ARCHITECTURE.md"));
+  const hasProgress = existsSync4(join4(cwd, "progress.txt"));
+  const hasReviewDb = existsSync4(join4(cwd, "docs", "code-review", "review-tasks.db"));
   let hasProgressEntries = false;
   let lastProgressEntry;
   if (hasProgress) {
     try {
-      const progressContent = readFileSync(join3(cwd, "progress.txt"), "utf-8");
+      const progressContent = readFileSync(join4(cwd, "progress.txt"), "utf-8");
       const entries = progressContent.match(/^## \d{4}-\d{2}-\d{2}/gm);
       hasProgressEntries = entries !== null && entries.length > 0;
       if (hasProgressEntries) {
@@ -518,8 +954,8 @@ async function gatherGovernanceStatus(cwd) {
     dependencyRulesCount: 0,
     pendingAtomsCount: 0
   };
-  const archPath = join3(cwd, "ARCHITECTURE.md");
-  if (existsSync3(archPath)) {
+  const archPath = join4(cwd, "ARCHITECTURE.md");
+  if (existsSync4(archPath)) {
     const parser = new ArchitectureParser(archPath);
     const result = await parser.parse();
     if (result.success && result.schema) {
@@ -536,8 +972,8 @@ async function gatherGovernanceStatus(cwd) {
       status2.dependencyRulesCount = depResult.document.rules.length;
     }
   }
-  const progressPath = join3(cwd, "progress.txt");
-  if (existsSync3(progressPath)) {
+  const progressPath = join4(cwd, "progress.txt");
+  if (existsSync4(progressPath)) {
     try {
       const content = readFileSync(progressPath, "utf-8");
       const dateMatches = content.match(/^## (\d{4}-\d{2}-\d{2})/gm);
@@ -551,10 +987,10 @@ async function gatherGovernanceStatus(cwd) {
     } catch {
     }
   }
-  const atomsDir = join3(cwd, ".archon", "atoms");
-  if (existsSync3(atomsDir)) {
+  const atomsDir = join4(cwd, ".archon", "atoms");
+  if (existsSync4(atomsDir)) {
     try {
-      const files = readdirSync(atomsDir);
+      const files = readdirSync2(atomsDir);
       status2.pendingAtomsCount = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).length;
     } catch {
     }
@@ -562,35 +998,35 @@ async function gatherGovernanceStatus(cwd) {
   return status2;
 }
 function displayGovernanceBanner(status2) {
-  console.log(chalk3.blue("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
-  console.log(chalk3.bold.white("  ArchonDev Governance Active"));
-  console.log(chalk3.blue("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+  console.log(chalk4.blue("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+  console.log(chalk4.bold.white("  ArchonDev Governance Active"));
+  console.log(chalk4.blue("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
   if (status2.hasArchitecture) {
-    console.log(chalk3.green("  \u2713") + ` ARCHITECTURE.md loaded (${status2.posture} posture)`);
-    console.log(chalk3.green("  \u2713") + ` ${status2.invariantsCount} invariants enforced`);
-    console.log(chalk3.green("  \u2713") + ` ${status2.protectedPathsCount} protected paths defined`);
+    console.log(chalk4.green("  \u2713") + ` ARCHITECTURE.md loaded (${status2.posture} posture)`);
+    console.log(chalk4.green("  \u2713") + ` ${status2.invariantsCount} invariants enforced`);
+    console.log(chalk4.green("  \u2713") + ` ${status2.protectedPathsCount} protected paths defined`);
   } else {
-    console.log(chalk3.yellow("  \u26A0") + " ARCHITECTURE.md not found - run " + chalk3.cyan("archon init"));
+    console.log(chalk4.yellow("  \u26A0") + " ARCHITECTURE.md not found - run " + chalk4.cyan("archon init"));
   }
-  console.log(chalk3.green("  \u2713") + ` ${status2.dependencyRulesCount} dependency rules active`);
+  console.log(chalk4.green("  \u2713") + ` ${status2.dependencyRulesCount} dependency rules active`);
   if (status2.lastSessionDate) {
-    console.log(chalk3.green("  \u2713") + ` Last session: ${status2.lastSessionDate}`);
+    console.log(chalk4.green("  \u2713") + ` Last session: ${status2.lastSessionDate}`);
   }
   if (status2.pendingAtomsCount > 0) {
     console.log();
-    console.log(chalk3.cyan(`  Pending: ${status2.pendingAtomsCount} atoms ready for execution`));
+    console.log(chalk4.cyan(`  Pending: ${status2.pendingAtomsCount} atoms ready for execution`));
   }
-  console.log(chalk3.blue("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n"));
+  console.log(chalk4.blue("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n"));
 }
 async function handleNewProject(cwd, state) {
-  console.log(chalk3.yellow("\u{1F389}") + chalk3.bold(" Starting a new project? Great!\n"));
-  console.log(chalk3.dim("I'll ask you a few quick questions to set things up right."));
-  console.log(chalk3.dim("Answer as much or as little as you want \u2014 you can always refine later.\n"));
-  console.log(chalk3.bold("What would you like to do?\n"));
-  console.log(`  ${chalk3.cyan("1")}) ${chalk3.bold("Start interview")} \u2014 I'll ask questions to understand your project`);
-  console.log(`  ${chalk3.cyan("2")}) ${chalk3.bold("Quick start")} \u2014 Just create basic governance files`);
-  console.log(`  ${chalk3.cyan("3")}) ${chalk3.bold("Import from template")} \u2014 Use a predefined project template`);
-  console.log(`  ${chalk3.cyan("q")}) ${chalk3.dim("Quit")}`);
+  console.log(chalk4.yellow("\u{1F389}") + chalk4.bold(" Starting a new project? Great!\n"));
+  console.log(chalk4.dim("I'll ask you a few quick questions to set things up right."));
+  console.log(chalk4.dim("Answer as much or as little as you want \u2014 you can always refine later.\n"));
+  console.log(chalk4.bold("What would you like to do?\n"));
+  console.log(`  ${chalk4.cyan("1")}) ${chalk4.bold("Start interview")} \u2014 I'll ask questions to understand your project`);
+  console.log(`  ${chalk4.cyan("2")}) ${chalk4.bold("Quick start")} \u2014 Just create basic governance files`);
+  console.log(`  ${chalk4.cyan("3")}) ${chalk4.bold("Import from template")} \u2014 Use a predefined project template`);
+  console.log(`  ${chalk4.cyan("q")}) ${chalk4.dim("Quit")}`);
   console.log();
   const choice = await prompt("Enter choice");
   switch (choice.toLowerCase()) {
@@ -601,19 +1037,19 @@ async function handleNewProject(cwd, state) {
       await quickStart(cwd);
       break;
     case "3":
-      console.log(chalk3.yellow("\nTemplates coming soon! Using quick start for now.\n"));
+      console.log(chalk4.yellow("\nTemplates coming soon! Using quick start for now.\n"));
       await quickStart(cwd);
       break;
     case "q":
       process.exit(0);
     default:
-      console.log(chalk3.yellow("Invalid choice. Please try again."));
+      console.log(chalk4.yellow("Invalid choice. Please try again."));
       await handleNewProject(cwd, state);
   }
 }
 async function runNewProjectInterview(cwd) {
-  console.log(chalk3.blue("\n\u2501\u2501\u2501 Project Interview \u2501\u2501\u2501\n"));
-  console.log(chalk3.bold("Phase 1: The Vision\n"));
+  console.log(chalk4.blue("\n\u2501\u2501\u2501 Project Interview \u2501\u2501\u2501\n"));
+  console.log(chalk4.bold("Phase 1: The Vision\n"));
   const projectName = await prompt("What's the project name?");
   const projectDescription = await prompt("In one sentence, what does this project do?");
   const audience = await promptChoice("Who is it for?", [
@@ -626,7 +1062,7 @@ async function runNewProjectInterview(cwd) {
     { key: "2", label: "\u{1F7E1} Intermediate \u2014 I've done similar work" },
     { key: "3", label: "\u{1F534} Learning \u2014 This is new to me" }
   ]);
-  console.log(chalk3.bold("\nPhase 2: Tech Stack\n"));
+  console.log(chalk4.bold("\nPhase 2: Tech Stack\n"));
   const language = await promptChoice("Primary language/framework?", [
     { key: "1", label: "TypeScript / JavaScript" },
     { key: "2", label: "Python" },
@@ -640,10 +1076,10 @@ async function runNewProjectInterview(cwd) {
     { key: "3", label: "Full-stack (both)" },
     { key: "4", label: "Library/package" }
   ]);
-  console.log(chalk3.bold("\nPhase 3: Preferences ") + chalk3.dim("(press Enter to skip)\n"));
+  console.log(chalk4.bold("\nPhase 3: Preferences ") + chalk4.dim("(press Enter to skip)\n"));
   const protectedFiles = await prompt("Any files AI should NEVER modify without asking? (comma-separated)");
   const noNoPatterns = await prompt('Anything AI should NEVER do? (e.g., "no console.log")');
-  console.log(chalk3.blue("\n\u2501\u2501\u2501 Generating Project Files \u2501\u2501\u2501\n"));
+  console.log(chalk4.blue("\n\u2501\u2501\u2501 Generating Project Files \u2501\u2501\u2501\n"));
   const { init: init2 } = await import("./init-7EWVBX6O.js");
   await init2({ analyze: false, git: true });
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -669,16 +1105,16 @@ ${noNoPatterns ? `- **Forbidden patterns:** ${noNoPatterns}` : "- No forbidden p
 - .archon/config.yaml
 - progress.txt
 `;
-  const progressPath = join3(cwd, "progress.txt");
-  if (!existsSync3(progressPath)) {
+  const progressPath = join4(cwd, "progress.txt");
+  if (!existsSync4(progressPath)) {
     const { writeFileSync } = await import("fs");
     writeFileSync(progressPath, "# ArchonDev Progress Log\n\nThis file tracks learnings and decisions across sessions.\n");
   }
   appendFileSync(progressPath, progressEntry);
-  console.log(chalk3.green("\n\u2713 Project initialized!\n"));
-  console.log(chalk3.bold("Next steps:"));
-  console.log(`  1. ${chalk3.cyan("Review")} ARCHITECTURE.md and customize if needed`);
-  console.log(`  2. ${chalk3.cyan("Run")} ${chalk3.dim('archon plan "your first task"')} to create an atom`);
+  console.log(chalk4.green("\n\u2713 Project initialized!\n"));
+  console.log(chalk4.bold("Next steps:"));
+  console.log(`  1. ${chalk4.cyan("Review")} ARCHITECTURE.md and customize if needed`);
+  console.log(`  2. ${chalk4.cyan("Run")} ${chalk4.dim('archon plan "your first task"')} to create an atom`);
   console.log();
   const continueChoice = await promptYesNo("Would you like to plan your first task now?", true);
   if (continueChoice) {
@@ -690,12 +1126,12 @@ ${noNoPatterns ? `- **Forbidden patterns:** ${noNoPatterns}` : "- No forbidden p
   }
 }
 async function quickStart(cwd) {
-  console.log(chalk3.blue("\n\u2501\u2501\u2501 Quick Start \u2501\u2501\u2501\n"));
+  console.log(chalk4.blue("\n\u2501\u2501\u2501 Quick Start \u2501\u2501\u2501\n"));
   const { init: init2 } = await import("./init-7EWVBX6O.js");
   await init2({ analyze: false, git: true });
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const progressPath = join3(cwd, "progress.txt");
-  if (!existsSync3(progressPath)) {
+  const progressPath = join4(cwd, "progress.txt");
+  if (!existsSync4(progressPath)) {
     const { writeFileSync } = await import("fs");
     writeFileSync(progressPath, `# ArchonDev Progress Log
 
@@ -717,15 +1153,15 @@ This file tracks learnings and decisions across sessions.
   await showMainMenu();
 }
 async function handleAdaptExisting(cwd, state) {
-  console.log(chalk3.yellow("\u{1F4C1}") + chalk3.bold(" Existing project detected!\n"));
-  console.log(chalk3.dim("I can analyze your codebase and adapt the governance files to match your structure."));
-  console.log(chalk3.dim("This helps me understand your architecture without changing any code.\n"));
-  console.log(chalk3.bold("What would you like to do?\n"));
-  console.log(`  ${chalk3.cyan("1")}) ${chalk3.bold("Analyze and adapt")} \u2014 I'll scan your project and update ARCHITECTURE.md`);
-  console.log(`  ${chalk3.cyan("2")}) ${chalk3.bold("Code review first")} \u2014 Review code for issues before setting up governance`);
-  console.log(`  ${chalk3.cyan("3")}) ${chalk3.bold("Manual setup")} \u2014 Keep template files, customize manually`);
-  console.log(`  ${chalk3.cyan("4")}) ${chalk3.bold("Just start working")} \u2014 Skip setup, use defaults`);
-  console.log(`  ${chalk3.cyan("q")}) ${chalk3.dim("Quit")}`);
+  console.log(chalk4.yellow("\u{1F4C1}") + chalk4.bold(" Existing project detected!\n"));
+  console.log(chalk4.dim("I can analyze your codebase and adapt the governance files to match your structure."));
+  console.log(chalk4.dim("This helps me understand your architecture without changing any code.\n"));
+  console.log(chalk4.bold("What would you like to do?\n"));
+  console.log(`  ${chalk4.cyan("1")}) ${chalk4.bold("Analyze and adapt")} \u2014 I'll scan your project and update ARCHITECTURE.md`);
+  console.log(`  ${chalk4.cyan("2")}) ${chalk4.bold("Code review first")} \u2014 Review code for issues before setting up governance`);
+  console.log(`  ${chalk4.cyan("3")}) ${chalk4.bold("Manual setup")} \u2014 Keep template files, customize manually`);
+  console.log(`  ${chalk4.cyan("4")}) ${chalk4.bold("Just start working")} \u2014 Skip setup, use defaults`);
+  console.log(`  ${chalk4.cyan("q")}) ${chalk4.dim("Quit")}`);
   console.log();
   const choice = await prompt("Enter choice");
   switch (choice.toLowerCase()) {
@@ -744,17 +1180,17 @@ async function handleAdaptExisting(cwd, state) {
     case "q":
       process.exit(0);
     default:
-      console.log(chalk3.yellow("Invalid choice. Please try again."));
+      console.log(chalk4.yellow("Invalid choice. Please try again."));
       await handleAdaptExisting(cwd, state);
   }
 }
 async function analyzeAndAdapt(cwd) {
-  console.log(chalk3.blue("\n\u2501\u2501\u2501 Analyzing Project \u2501\u2501\u2501\n"));
+  console.log(chalk4.blue("\n\u2501\u2501\u2501 Analyzing Project \u2501\u2501\u2501\n"));
   const { init: init2 } = await import("./init-7EWVBX6O.js");
   await init2({ analyze: true, git: true });
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const progressPath = join3(cwd, "progress.txt");
-  if (!existsSync3(progressPath)) {
+  const progressPath = join4(cwd, "progress.txt");
+  if (!existsSync4(progressPath)) {
     const { writeFileSync } = await import("fs");
     writeFileSync(progressPath, "# ArchonDev Progress Log\n\nThis file tracks learnings and decisions across sessions.\n");
   }
@@ -771,15 +1207,15 @@ async function analyzeAndAdapt(cwd) {
 - .archon/config.yaml - Build commands configured
 - progress.txt - This file
 `);
-  console.log(chalk3.green("\n\u2713 Governance files adapted!\n"));
+  console.log(chalk4.green("\n\u2713 Governance files adapted!\n"));
   await showMainMenu();
 }
 async function codeReviewFirst(cwd) {
-  console.log(chalk3.blue("\n\u2501\u2501\u2501 Code Review Mode \u2501\u2501\u2501\n"));
-  console.log(chalk3.dim("I'll analyze your code for issues without making any changes.\n"));
+  console.log(chalk4.blue("\n\u2501\u2501\u2501 Code Review Mode \u2501\u2501\u2501\n"));
+  console.log(chalk4.dim("I'll analyze your code for issues without making any changes.\n"));
   const { reviewInit: reviewInit2, reviewAnalyze: reviewAnalyze2, reviewRun: reviewRun2 } = await import("./review-3R6QXAXQ.js");
-  const reviewDbPath = join3(cwd, "docs", "code-review", "review-tasks.db");
-  if (!existsSync3(reviewDbPath)) {
+  const reviewDbPath = join4(cwd, "docs", "code-review", "review-tasks.db");
+  if (!existsSync4(reviewDbPath)) {
     await reviewInit2();
   }
   await reviewAnalyze2();
@@ -787,27 +1223,27 @@ async function codeReviewFirst(cwd) {
   if (runReview) {
     await reviewRun2({ all: true });
   }
-  console.log(chalk3.dim("\nAfter reviewing, you can run ") + chalk3.cyan("archon") + chalk3.dim(" again to set up governance.\n"));
+  console.log(chalk4.dim("\nAfter reviewing, you can run ") + chalk4.cyan("archon") + chalk4.dim(" again to set up governance.\n"));
 }
 async function manualSetup(cwd) {
-  console.log(chalk3.blue("\n\u2501\u2501\u2501 Manual Setup \u2501\u2501\u2501\n"));
-  console.log(chalk3.dim("Creating template files. You can customize them manually.\n"));
+  console.log(chalk4.blue("\n\u2501\u2501\u2501 Manual Setup \u2501\u2501\u2501\n"));
+  console.log(chalk4.dim("Creating template files. You can customize them manually.\n"));
   const { init: init2 } = await import("./init-7EWVBX6O.js");
   await init2({ analyze: false, git: true });
-  console.log(chalk3.bold("\nWhat to customize:\n"));
-  console.log(`  ${chalk3.cyan("1. ARCHITECTURE.md")} \u2014 Update components to match your folders`);
-  console.log(`  ${chalk3.cyan("2. .archon/config.yaml")} \u2014 Change build/test/lint commands`);
-  console.log(`  ${chalk3.cyan("3. progress.txt")} \u2014 Add project-specific patterns`);
+  console.log(chalk4.bold("\nWhat to customize:\n"));
+  console.log(`  ${chalk4.cyan("1. ARCHITECTURE.md")} \u2014 Update components to match your folders`);
+  console.log(`  ${chalk4.cyan("2. .archon/config.yaml")} \u2014 Change build/test/lint commands`);
+  console.log(`  ${chalk4.cyan("3. progress.txt")} \u2014 Add project-specific patterns`);
   console.log();
   await showMainMenu();
 }
 async function quickAdapt(cwd) {
-  console.log(chalk3.blue("\n\u26A1 Using defaults \u2014 let's go!\n"));
+  console.log(chalk4.blue("\n\u26A1 Using defaults \u2014 let's go!\n"));
   const { init: init2 } = await import("./init-7EWVBX6O.js");
   await init2({ analyze: true, git: true });
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const progressPath = join3(cwd, "progress.txt");
-  if (!existsSync3(progressPath)) {
+  const progressPath = join4(cwd, "progress.txt");
+  if (!existsSync4(progressPath)) {
     const { writeFileSync } = await import("fs");
     writeFileSync(progressPath, "# ArchonDev Progress Log\n\nThis file tracks learnings and decisions across sessions.\n");
   }
@@ -821,20 +1257,20 @@ async function quickAdapt(cwd) {
   await showMainMenu();
 }
 async function handleContinueSession(cwd, state) {
-  console.log(chalk3.green("\u{1F44B}") + chalk3.bold(" Welcome back!\n"));
+  console.log(chalk4.green("\u{1F44B}") + chalk4.bold(" Welcome back!\n"));
   if (state.lastProgressEntry) {
-    console.log(chalk3.dim("Last activity:"));
-    console.log(chalk3.dim("  " + state.lastProgressEntry.split("\n")[0]));
+    console.log(chalk4.dim("Last activity:"));
+    console.log(chalk4.dim("  " + state.lastProgressEntry.split("\n")[0]));
     console.log();
   }
   const handoff = checkForHandoff(cwd);
   if (handoff) {
-    console.log(chalk3.yellow("\u{1F4CB} Found handoff from last session:\n"));
-    console.log(chalk3.dim(handoff.nextSteps));
+    console.log(chalk4.yellow("\u{1F4CB} Found handoff from last session:\n"));
+    console.log(chalk4.dim(handoff.nextSteps));
     console.log();
     const continueHandoff = await promptYesNo("Continue from handoff?", true);
     if (continueHandoff) {
-      console.log(chalk3.dim("\nPicking up where you left off...\n"));
+      console.log(chalk4.dim("\nPicking up where you left off...\n"));
     }
   }
   if (state.hasReviewDb) {
@@ -844,8 +1280,8 @@ async function handleContinueSession(cwd, state) {
 }
 function checkForHandoff(cwd) {
   try {
-    const progressPath = join3(cwd, "progress.txt");
-    if (!existsSync3(progressPath)) return null;
+    const progressPath = join4(cwd, "progress.txt");
+    if (!existsSync4(progressPath)) return null;
     const content = readFileSync(progressPath, "utf-8");
     const handoffMatch = content.match(/## Context Handoff[^\n]*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (handoffMatch && handoffMatch[1]) {
@@ -862,7 +1298,7 @@ function checkForHandoff(cwd) {
 async function showMainMenu() {
   const cwd = process.cwd();
   const state = detectProjectState(cwd);
-  console.log(chalk3.bold("What would you like to do?\n"));
+  console.log(chalk4.bold("What would you like to do?\n"));
   const choices = [
     { key: "1", label: "Plan a new task", action: () => planTask() },
     { key: "2", label: "List atoms", action: () => listAtoms() },
@@ -874,7 +1310,7 @@ async function showMainMenu() {
     { key: "q", label: "Quit", action: async () => process.exit(0) }
   ];
   for (const choice2 of choices) {
-    console.log(`  ${chalk3.cyan(choice2.key)}) ${choice2.label}`);
+    console.log(`  ${chalk4.cyan(choice2.key)}) ${choice2.label}`);
   }
   console.log();
   const selected = await prompt("Enter choice");
@@ -882,7 +1318,7 @@ async function showMainMenu() {
   if (choice) {
     await choice.action();
   } else {
-    console.log(chalk3.yellow("Invalid choice. Please try again."));
+    console.log(chalk4.yellow("Invalid choice. Please try again."));
     await showMainMenu();
   }
 }
@@ -898,7 +1334,7 @@ async function showReviewProgress(cwd) {
     const pending = stats.pending + stats.inReview;
     const needsFix = stats.needsFix;
     console.log(
-      chalk3.blue("\u{1F4CA} Review Progress:") + chalk3.dim(` ${completed}/${total} completed`) + (needsFix > 0 ? chalk3.red(` (${needsFix} need fixes)`) : "") + (pending > 0 ? chalk3.yellow(` (${pending} pending)`) : "")
+      chalk4.blue("\u{1F4CA} Review Progress:") + chalk4.dim(` ${completed}/${total} completed`) + (needsFix > 0 ? chalk4.red(` (${needsFix} need fixes)`) : "") + (pending > 0 ? chalk4.yellow(` (${pending} pending)`) : "")
     );
     console.log();
   } catch {
@@ -923,38 +1359,38 @@ async function executeNext() {
   const atoms = await listLocalAtoms2();
   const pendingAtoms = atoms.filter((a) => a.status === "READY" || a.status === "IN_PROGRESS");
   if (pendingAtoms.length === 0) {
-    console.log(chalk3.yellow('No pending atoms. Use "archon plan" to create one.'));
+    console.log(chalk4.yellow('No pending atoms. Use "archon plan" to create one.'));
     return;
   }
   if (pendingAtoms.length > 1) {
     const analysis = analyzeProject(pendingAtoms);
     const prefs = await loadExecutionPreferences(cwd);
-    console.log(chalk3.blue("\n\u2501\u2501\u2501 Project Analysis \u2501\u2501\u2501\n"));
-    console.log(`  ${chalk3.bold("Atoms:")}      ${analysis.atomCount}`);
-    console.log(`  ${chalk3.bold("Estimated:")}  ${analysis.estimatedMinutes} minutes`);
-    console.log(`  ${chalk3.bold("Complexity:")} ${analysis.complexity} - ${getComplexityDescription(analysis.complexity)}`);
-    console.log(`  ${chalk3.bold("Suggested:")}  ${analysis.suggestedMode} - ${getModeDescription(analysis.suggestedMode)}`);
+    console.log(chalk4.blue("\n\u2501\u2501\u2501 Project Analysis \u2501\u2501\u2501\n"));
+    console.log(`  ${chalk4.bold("Atoms:")}      ${analysis.atomCount}`);
+    console.log(`  ${chalk4.bold("Estimated:")}  ${analysis.estimatedMinutes} minutes`);
+    console.log(`  ${chalk4.bold("Complexity:")} ${analysis.complexity} - ${getComplexityDescription(analysis.complexity)}`);
+    console.log(`  ${chalk4.bold("Suggested:")}  ${analysis.suggestedMode} - ${getModeDescription(analysis.suggestedMode)}`);
     console.log();
     if (analysis.suggestedMode !== "sequential" && prefs.parallelMode === "ask") {
       const useParallel = await promptYesNo(`Use ${analysis.suggestedMode} execution?`, true);
       if (useParallel) {
-        console.log(chalk3.green(`
+        console.log(chalk4.green(`
 \u2713 ${analysis.suggestedMode} execution selected`));
-        console.log(chalk3.dim("(Parallel/cloud execution coming soon - running sequentially for now)\n"));
+        console.log(chalk4.dim("(Parallel/cloud execution coming soon - running sequentially for now)\n"));
       }
     } else if (prefs.parallelMode === "always" && analysis.suggestedMode !== "sequential") {
-      console.log(chalk3.green(`
+      console.log(chalk4.green(`
 \u2713 Auto-selected ${analysis.suggestedMode} execution (preference: always)`));
-      console.log(chalk3.dim("(Parallel/cloud execution coming soon - running sequentially for now)\n"));
+      console.log(chalk4.dim("(Parallel/cloud execution coming soon - running sequentially for now)\n"));
     }
   }
   const atomId = await prompt("Enter atom ID to execute (or press Enter for first pending)");
   const targetId = atomId.trim() || pendingAtoms[0]?.id;
   if (targetId) {
-    const { execute: execute2 } = await import("./execute-IMGKMUBS.js");
+    const { execute: execute2 } = await import("./execute-2S2UHTLN.js");
     await execute2(targetId, {});
   } else {
-    console.log(chalk3.yellow("No atom to execute."));
+    console.log(chalk4.yellow("No atom to execute."));
   }
 }
 async function reportBug() {
@@ -975,20 +1411,20 @@ async function settingsMenu() {
 }
 async function reviewCode() {
   const cwd = process.cwd();
-  const reviewDbPath = join3(cwd, "docs", "code-review", "review-tasks.db");
-  if (!existsSync3(reviewDbPath)) {
-    console.log(chalk3.dim("Code review not initialized. Starting setup...\n"));
+  const reviewDbPath = join4(cwd, "docs", "code-review", "review-tasks.db");
+  if (!existsSync4(reviewDbPath)) {
+    console.log(chalk4.dim("Code review not initialized. Starting setup...\n"));
     const { reviewInit: reviewInit2 } = await import("./review-3R6QXAXQ.js");
     await reviewInit2();
     console.log();
   }
-  console.log(chalk3.bold("\nCode Review Options:\n"));
-  console.log(`  ${chalk3.cyan("1")}) Analyze project`);
-  console.log(`  ${chalk3.cyan("2")}) Show review status`);
-  console.log(`  ${chalk3.cyan("3")}) Review next file`);
-  console.log(`  ${chalk3.cyan("4")}) List all tasks`);
-  console.log(`  ${chalk3.cyan("5")}) Run AI review on all pending`);
-  console.log(`  ${chalk3.cyan("b")}) Back to main menu`);
+  console.log(chalk4.bold("\nCode Review Options:\n"));
+  console.log(`  ${chalk4.cyan("1")}) Analyze project`);
+  console.log(`  ${chalk4.cyan("2")}) Show review status`);
+  console.log(`  ${chalk4.cyan("3")}) Review next file`);
+  console.log(`  ${chalk4.cyan("4")}) List all tasks`);
+  console.log(`  ${chalk4.cyan("5")}) Run AI review on all pending`);
+  console.log(`  ${chalk4.cyan("b")}) Back to main menu`);
   console.log();
   const choice = await prompt("Enter choice");
   switch (choice.toLowerCase()) {
@@ -1021,7 +1457,7 @@ async function reviewCode() {
       await showMainMenu();
       return;
     default:
-      console.log(chalk3.yellow("Invalid choice."));
+      console.log(chalk4.yellow("Invalid choice."));
   }
   await reviewCode();
 }
@@ -1031,7 +1467,7 @@ function prompt(question) {
       input: process.stdin,
       output: process.stdout
     });
-    rl.question(`${chalk3.cyan("?")} ${question}: `, (answer) => {
+    rl.question(`${chalk4.cyan("?")} ${question}: `, (answer) => {
       rl.close();
       resolve(answer);
     });
@@ -1044,7 +1480,7 @@ function promptYesNo(question, defaultValue) {
       output: process.stdout
     });
     const hint = defaultValue ? "(Y/n)" : "(y/N)";
-    rl.question(`${chalk3.cyan("?")} ${question} ${hint}: `, (answer) => {
+    rl.question(`${chalk4.cyan("?")} ${question} ${hint}: `, (answer) => {
       rl.close();
       if (answer.trim() === "") {
         resolve(defaultValue);
@@ -1056,15 +1492,15 @@ function promptYesNo(question, defaultValue) {
 }
 function promptChoice(question, options) {
   return new Promise((resolve) => {
-    console.log(`${chalk3.cyan("?")} ${question}`);
+    console.log(`${chalk4.cyan("?")} ${question}`);
     for (const opt of options) {
-      console.log(`    ${chalk3.dim(opt.key)}) ${opt.label}`);
+      console.log(`    ${chalk4.dim(opt.key)}) ${opt.label}`);
     }
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
     });
-    rl.question(`  ${chalk3.dim("Enter choice")}: `, (answer) => {
+    rl.question(`  ${chalk4.dim("Enter choice")}: `, (answer) => {
       rl.close();
       resolve(answer.trim() || "1");
     });
@@ -1072,7 +1508,7 @@ function promptChoice(question, options) {
 }
 
 // src/cli/credits.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import ora from "ora";
 import open from "open";
 import { createClient } from "@supabase/supabase-js";
@@ -1098,21 +1534,21 @@ async function showCredits() {
     const profile = data;
     spinner.stop();
     console.log();
-    console.log(chalk4.bold("\u{1F4B0} Credit Balance"));
+    console.log(chalk5.bold("\u{1F4B0} Credit Balance"));
     console.log();
     const balance = (profile.credit_balance_cents || 0) / 100;
     console.log(`  Tier:    ${formatTier(profile.tier)}`);
-    console.log(`  Balance: ${chalk4.green(`$${balance.toFixed(2)}`)}`);
+    console.log(`  Balance: ${chalk5.green(`$${balance.toFixed(2)}`)}`);
     if (profile.tier === "FREE") {
       console.log(`  Atoms:   ${profile.atoms_used_this_month}/10,000 this month`);
       console.log();
-      console.log(chalk4.dim("  Upgrade to Credits tier: archon credits add"));
+      console.log(chalk5.dim("  Upgrade to Credits tier: archon credits add"));
     } else if (profile.tier === "CREDITS") {
       console.log();
-      console.log(chalk4.dim("  Add more credits: archon credits add"));
+      console.log(chalk5.dim("  Add more credits: archon credits add"));
     } else if (profile.tier === "BYOK") {
       console.log();
-      console.log(chalk4.dim("  Using your own API keys - no credit charges"));
+      console.log(chalk5.dim("  Using your own API keys - no credit charges"));
     }
     console.log();
   } catch (err) {
@@ -1158,18 +1594,18 @@ async function addCredits(options = {}) {
     }
     spinner.succeed("Checkout ready");
     console.log();
-    console.log(chalk4.bold("\u{1F6D2} Add Credits"));
+    console.log(chalk5.bold("\u{1F6D2} Add Credits"));
     console.log();
-    console.log(`  Amount: ${chalk4.green(`$${amountDollars.toFixed(2)}`)}`);
+    console.log(`  Amount: ${chalk5.green(`$${amountDollars.toFixed(2)}`)}`);
     console.log();
     console.log("  Opening checkout in browser...");
     console.log();
-    console.log(chalk4.dim(`  Or visit: ${checkoutUrl}`));
+    console.log(chalk5.dim(`  Or visit: ${checkoutUrl}`));
     console.log();
     try {
       await open(checkoutUrl);
     } catch {
-      console.log(chalk4.yellow("  Could not open browser. Please visit the URL above."));
+      console.log(chalk5.yellow("  Could not open browser. Please visit the URL above."));
     }
   } catch (err) {
     spinner.fail("Error preparing checkout");
@@ -1194,15 +1630,15 @@ async function showHistory(options = {}) {
     const usage = data;
     spinner.stop();
     console.log();
-    console.log(chalk4.bold("\u{1F4CA} Usage History"));
+    console.log(chalk5.bold("\u{1F4CA} Usage History"));
     console.log();
     if (!usage || usage.length === 0) {
-      console.log(chalk4.dim("  No usage recorded yet."));
+      console.log(chalk5.dim("  No usage recorded yet."));
       console.log();
       return;
     }
-    console.log(chalk4.dim("  Model                          Tokens       Cost       Date"));
-    console.log(chalk4.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk5.dim("  Model                          Tokens       Cost       Date"));
+    console.log(chalk5.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     for (const row of usage) {
       const model = row.model.padEnd(30).slice(0, 30);
       const tokens = (row.input_tokens + row.output_tokens).toString().padStart(8);
@@ -1212,9 +1648,9 @@ async function showHistory(options = {}) {
     }
     const totalCost = usage.reduce((sum, r) => sum + r.base_cost, 0);
     const totalTokens = usage.reduce((sum, r) => sum + r.input_tokens + r.output_tokens, 0);
-    console.log(chalk4.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk5.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     console.log(
-      `  ${"Total".padEnd(30)} ${totalTokens.toString().padStart(8)} ${chalk4.green(`$${totalCost.toFixed(4)}`.padStart(10))}`
+      `  ${"Total".padEnd(30)} ${totalTokens.toString().padStart(8)} ${chalk5.green(`$${totalCost.toFixed(4)}`.padStart(10))}`
     );
     console.log();
   } catch (err) {
@@ -1280,24 +1716,24 @@ async function manageBudget(options = {}) {
     }
     spinner.stop();
     console.log();
-    console.log(chalk4.bold("\u{1F4CA} Monthly Budget"));
+    console.log(chalk5.bold("\u{1F4CA} Monthly Budget"));
     console.log();
     if (profile.monthly_budget_cents === null) {
-      console.log(`  Budget:    ${chalk4.dim("No limit set")}`);
+      console.log(`  Budget:    ${chalk5.dim("No limit set")}`);
     } else {
       const budget = profile.monthly_budget_cents / 100;
       const spend = (profile.monthly_spend_cents || 0) / 100;
       const remaining = budget - spend;
       const percent = budget > 0 ? Math.round(spend / budget * 100) : 0;
-      console.log(`  Budget:    ${chalk4.green(`$${budget.toFixed(2)}`)} / month`);
+      console.log(`  Budget:    ${chalk5.green(`$${budget.toFixed(2)}`)} / month`);
       console.log(`  Spent:     $${spend.toFixed(2)} (${percent}%)`);
-      console.log(`  Remaining: ${remaining >= 0 ? chalk4.green(`$${remaining.toFixed(2)}`) : chalk4.red(`-$${Math.abs(remaining).toFixed(2)}`)}`);
+      console.log(`  Remaining: ${remaining >= 0 ? chalk5.green(`$${remaining.toFixed(2)}`) : chalk5.red(`-$${Math.abs(remaining).toFixed(2)}`)}`);
     }
     console.log(`  Alert at:  ${profile.budget_alert_threshold_percent}% of budget`);
     console.log();
-    console.log(chalk4.dim("  Set budget:     archon credits budget --set 50"));
-    console.log(chalk4.dim("  Clear budget:   archon credits budget --clear"));
-    console.log(chalk4.dim("  Set alert:      archon credits budget --alert 80"));
+    console.log(chalk5.dim("  Set budget:     archon credits budget --set 50"));
+    console.log(chalk5.dim("  Clear budget:   archon credits budget --clear"));
+    console.log(chalk5.dim("  Set alert:      archon credits budget --alert 80"));
     console.log();
   } catch (err) {
     spinner.fail("Error managing budget");
@@ -1359,12 +1795,12 @@ async function manageAutoRecharge(options = {}) {
     }
     spinner.stop();
     console.log();
-    console.log(chalk4.bold("\u{1F504} Auto-Recharge"));
+    console.log(chalk5.bold("\u{1F504} Auto-Recharge"));
     console.log();
     if (!profile.auto_recharge_enabled) {
-      console.log(`  Status:    ${chalk4.dim("Disabled")}`);
+      console.log(`  Status:    ${chalk5.dim("Disabled")}`);
     } else {
-      console.log(`  Status:    ${chalk4.green("Enabled")}`);
+      console.log(`  Status:    ${chalk5.green("Enabled")}`);
       if (profile.auto_recharge_threshold_cents !== null) {
         console.log(`  When:      Balance drops below $${(profile.auto_recharge_threshold_cents / 100).toFixed(2)}`);
       }
@@ -1372,10 +1808,10 @@ async function manageAutoRecharge(options = {}) {
         console.log(`  Amount:    $${(profile.auto_recharge_amount_cents / 100).toFixed(2)}`);
       }
     }
-    console.log(`  Payment:   ${profile.stripe_payment_method_id ? chalk4.green("Card saved") : chalk4.dim("No card saved")}`);
+    console.log(`  Payment:   ${profile.stripe_payment_method_id ? chalk5.green("Card saved") : chalk5.dim("No card saved")}`);
     console.log();
-    console.log(chalk4.dim("  Enable:    archon credits auto-recharge --enable --threshold 5 --amount 20"));
-    console.log(chalk4.dim("  Disable:   archon credits auto-recharge --disable"));
+    console.log(chalk5.dim("  Enable:    archon credits auto-recharge --enable --threshold 5 --amount 20"));
+    console.log(chalk5.dim("  Disable:   archon credits auto-recharge --disable"));
     console.log();
   } catch (err) {
     spinner.fail("Error managing auto-recharge");
@@ -1385,11 +1821,11 @@ async function manageAutoRecharge(options = {}) {
 function formatTier(tier) {
   switch (tier) {
     case "FREE":
-      return chalk4.blue("Free (10k atoms/month)");
+      return chalk5.blue("Free (10k atoms/month)");
     case "CREDITS":
-      return chalk4.green("Credits (Pay-as-you-go)");
+      return chalk5.green("Credits (Pay-as-you-go)");
     case "BYOK":
-      return chalk4.magenta("BYOK (Bring Your Own Key)");
+      return chalk5.magenta("BYOK (Bring Your Own Key)");
     default:
       return tier;
   }
@@ -1666,9 +2102,9 @@ async function watch() {
 
 // src/cli/deps.ts
 import { Command } from "commander";
-import chalk5 from "chalk";
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import chalk6 from "chalk";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
 var DEPENDENCIES_FILENAME = "DEPENDENCIES.md";
 function createDepsCommand() {
   const deps = new Command("deps").description("Manage file-level dependencies (DEPENDENCIES.md)").addHelpText(
@@ -1684,30 +2120,30 @@ Examples:
   deps.command("list").description("List all dependency rules").option("-v, --verbose", "Show detailed information").action(async (options) => {
     const parser = new DependencyParser();
     if (!parser.exists()) {
-      console.log(chalk5.yellow("No DEPENDENCIES.md found."));
-      console.log(chalk5.dim("Create one with: archon deps add --source <path> --dependent <path>"));
+      console.log(chalk6.yellow("No DEPENDENCIES.md found."));
+      console.log(chalk6.dim("Create one with: archon deps add --source <path> --dependent <path>"));
       return;
     }
     const result = await parser.parse();
     if (!result.success) {
-      console.log(chalk5.red(`Parse error: ${result.error}`));
+      console.log(chalk6.red(`Parse error: ${result.error}`));
       return;
     }
     const rules = result.document?.rules ?? [];
     if (rules.length === 0) {
-      console.log(chalk5.dim("No dependency rules defined."));
+      console.log(chalk6.dim("No dependency rules defined."));
       return;
     }
-    console.log(chalk5.bold(`
+    console.log(chalk6.bold(`
 \u{1F4E6} Dependency Rules (${rules.length})
 `));
     for (const rule of rules) {
-      const severityColor = rule.severity === "BLOCKER" ? chalk5.red : rule.severity === "WARNING" ? chalk5.yellow : chalk5.blue;
-      console.log(`${severityColor(`[${rule.severity}]`)} ${chalk5.bold(rule.id)}`);
-      console.log(`  Source: ${chalk5.cyan(rule.source)}`);
-      console.log(`  Dependents: ${rule.dependents.map((d) => chalk5.dim(d)).join(", ")}`);
+      const severityColor = rule.severity === "BLOCKER" ? chalk6.red : rule.severity === "WARNING" ? chalk6.yellow : chalk6.blue;
+      console.log(`${severityColor(`[${rule.severity}]`)} ${chalk6.bold(rule.id)}`);
+      console.log(`  Source: ${chalk6.cyan(rule.source)}`);
+      console.log(`  Dependents: ${rule.dependents.map((d) => chalk6.dim(d)).join(", ")}`);
       if (rule.reason && options.verbose) {
-        console.log(`  Reason: ${chalk5.dim(rule.reason)}`);
+        console.log(`  Reason: ${chalk6.dim(rule.reason)}`);
       }
       if (rule.mustTest && options.verbose) {
         console.log(`  Must test: ${rule.mustTest.join(", ")}`);
@@ -1719,29 +2155,29 @@ Examples:
     const files = options.files.split(",").map((f) => f.trim());
     const parser = new DependencyParser();
     if (!parser.exists()) {
-      console.log(chalk5.dim("No DEPENDENCIES.md found. No dependency checks performed."));
+      console.log(chalk6.dim("No DEPENDENCIES.md found. No dependency checks performed."));
       process.exit(0);
     }
     const result = await parser.checkFiles(files);
     if (result.impacts.length === 0) {
-      console.log(chalk5.green("\u2705 No downstream dependency impacts found."));
+      console.log(chalk6.green("\u2705 No downstream dependency impacts found."));
       process.exit(0);
     }
-    console.log(chalk5.yellow(`
+    console.log(chalk6.yellow(`
 \u26A0\uFE0F  Found ${result.impacts.length} dependency impact(s):
 `));
     for (const impact of result.impacts) {
-      const severityColor = impact.rule.severity === "BLOCKER" ? chalk5.red : impact.rule.severity === "WARNING" ? chalk5.yellow : chalk5.blue;
+      const severityColor = impact.rule.severity === "BLOCKER" ? chalk6.red : impact.rule.severity === "WARNING" ? chalk6.yellow : chalk6.blue;
       console.log(severityColor(`[${impact.rule.severity}] ${impact.rule.id}`));
-      console.log(`  Changing: ${chalk5.cyan(impact.matchedSource)}`);
+      console.log(`  Changing: ${chalk6.cyan(impact.matchedSource)}`);
       console.log(`  May impact: ${impact.affectedDependents.join(", ")}`);
       if (impact.rule.reason) {
-        console.log(`  Reason: ${chalk5.dim(impact.rule.reason)}`);
+        console.log(`  Reason: ${chalk6.dim(impact.rule.reason)}`);
       }
       console.log("");
     }
     if (result.hasBlockers) {
-      console.log(chalk5.red("\u274C BLOCKER-level impacts found. Review before proceeding."));
+      console.log(chalk6.red("\u274C BLOCKER-level impacts found. Review before proceeding."));
       process.exit(1);
     }
     process.exit(0);
@@ -1755,7 +2191,7 @@ Examples:
     let existingRules = [];
     let markdownBody = "";
     if (parser.exists()) {
-      const content = await readFile3(DEPENDENCIES_FILENAME, "utf-8");
+      const content = await readFile4(DEPENDENCIES_FILENAME, "utf-8");
       const result = await parser.parse();
       if (result.success && result.document) {
         existingRules = result.document.rules;
@@ -1783,7 +2219,7 @@ Examples:
       (r) => r.source === source && r.dependents.includes(dependent)
     );
     if (existingRule) {
-      console.log(chalk5.yellow(`Rule already exists: ${existingRule.id}`));
+      console.log(chalk6.yellow(`Rule already exists: ${existingRule.id}`));
       return;
     }
     const newRule = {
@@ -1794,23 +2230,23 @@ Examples:
       reason
     };
     existingRules.push(newRule);
-    const yaml2 = generateYamlFrontmatter(existingRules);
-    await writeFile3(DEPENDENCIES_FILENAME, `---
-${yaml2}---${markdownBody}`, "utf-8");
-    console.log(chalk5.green(`\u2705 Added dependency rule: ${nextId}`));
-    console.log(`  Source: ${chalk5.cyan(source)}`);
-    console.log(`  Dependent: ${chalk5.dim(dependent)}`);
+    const yaml3 = generateYamlFrontmatter(existingRules);
+    await writeFile4(DEPENDENCIES_FILENAME, `---
+${yaml3}---${markdownBody}`, "utf-8");
+    console.log(chalk6.green(`\u2705 Added dependency rule: ${nextId}`));
+    console.log(`  Source: ${chalk6.cyan(source)}`);
+    console.log(`  Dependent: ${chalk6.dim(dependent)}`);
   });
   deps.command("graph").description("Generate Mermaid diagram of dependencies").option("--output <file>", "Write to file instead of stdout").action(async (options) => {
     const parser = new DependencyParser();
     if (!parser.exists()) {
-      console.log(chalk5.yellow("No DEPENDENCIES.md found."));
+      console.log(chalk6.yellow("No DEPENDENCIES.md found."));
       return;
     }
     const mermaid = await parser.generateGraph();
     if (options.output) {
-      await writeFile3(options.output, mermaid, "utf-8");
-      console.log(chalk5.green(`\u2705 Graph written to ${options.output}`));
+      await writeFile4(options.output, mermaid, "utf-8");
+      console.log(chalk6.green(`\u2705 Graph written to ${options.output}`));
     } else {
       console.log("\n```mermaid");
       console.log(mermaid);
@@ -1818,8 +2254,8 @@ ${yaml2}---${markdownBody}`, "utf-8");
     }
   });
   deps.command("init").description("Create a starter DEPENDENCIES.md file").action(async () => {
-    if (existsSync5(DEPENDENCIES_FILENAME)) {
-      console.log(chalk5.yellow("DEPENDENCIES.md already exists."));
+    if (existsSync6(DEPENDENCIES_FILENAME)) {
+      console.log(chalk6.yellow("DEPENDENCIES.md already exists."));
       return;
     }
     const template = `---
@@ -1865,9 +2301,9 @@ rules:
 
 *Powered by [ArchonDev](https://archondev.io)*
 `;
-    await writeFile3(DEPENDENCIES_FILENAME, template, "utf-8");
-    console.log(chalk5.green("\u2705 Created DEPENDENCIES.md"));
-    console.log(chalk5.dim("Add your first rule with: archon deps add --source <path> --dependent <path>"));
+    await writeFile4(DEPENDENCIES_FILENAME, template, "utf-8");
+    console.log(chalk6.green("\u2705 Created DEPENDENCIES.md"));
+    console.log(chalk6.dim("Add your first rule with: archon deps add --source <path> --dependent <path>"));
   });
   return deps;
 }
@@ -1904,10 +2340,10 @@ function generateYamlFrontmatter(rules) {
 }
 
 // src/cli/a11y.ts
-import chalk6 from "chalk";
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir2 } from "fs/promises";
-import { join as join5 } from "path";
+import chalk7 from "chalk";
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir3 } from "fs/promises";
+import { join as join6 } from "path";
 import { createInterface } from "readline";
 import { glob } from "glob";
 var ACCESSIBILITY_CHECKS = {
@@ -1980,7 +2416,7 @@ async function scanForIssues(files) {
   const issues = [];
   for (const file of files) {
     try {
-      const content = await readFile4(file, "utf-8");
+      const content = await readFile5(file, "utf-8");
       const lines = content.split("\n");
       for (const [checkId, check] of Object.entries(ACCESSIBILITY_CHECKS)) {
         for (const pattern of check.patterns) {
@@ -2007,8 +2443,8 @@ async function scanForIssues(files) {
   return issues;
 }
 async function a11yCheck(options) {
-  console.log(chalk6.blue("\n\u267F Pre-Deploy Accessibility Check\n"));
-  console.log(chalk6.dim("Scanning for WCAG 2.2 AA compliance issues...\n"));
+  console.log(chalk7.blue("\n\u267F Pre-Deploy Accessibility Check\n"));
+  console.log(chalk7.dim("Scanning for WCAG 2.2 AA compliance issues...\n"));
   const patterns = [
     "**/*.html",
     "**/*.htm",
@@ -2022,13 +2458,13 @@ async function a11yCheck(options) {
   let allFiles = [];
   for (const pattern of patterns) {
     const files = await glob(pattern, { cwd: process.cwd(), ignore: ignorePatterns });
-    allFiles = allFiles.concat(files.map((f) => join5(process.cwd(), f)));
+    allFiles = allFiles.concat(files.map((f) => join6(process.cwd(), f)));
   }
   if (allFiles.length === 0) {
-    console.log(chalk6.yellow("No web files found to check."));
+    console.log(chalk7.yellow("No web files found to check."));
     return;
   }
-  console.log(chalk6.dim(`Scanning ${allFiles.length} files...
+  console.log(chalk7.dim(`Scanning ${allFiles.length} files...
 `));
   const issues = await scanForIssues(allFiles);
   const report = {
@@ -2038,28 +2474,28 @@ async function a11yCheck(options) {
     issues,
     passed: issues.length === 0
   };
-  const archonDir = join5(process.cwd(), ".archon");
-  if (!existsSync6(archonDir)) {
-    await mkdir2(archonDir, { recursive: true });
+  const archonDir = join6(process.cwd(), ".archon");
+  if (!existsSync7(archonDir)) {
+    await mkdir3(archonDir, { recursive: true });
   }
-  await writeFile4(join5(archonDir, "a11y-report.json"), JSON.stringify(report, null, 2));
+  await writeFile5(join6(archonDir, "a11y-report.json"), JSON.stringify(report, null, 2));
   if (issues.length === 0) {
-    console.log(chalk6.green("\u2705 Accessibility Audit Passed\n"));
-    console.log(chalk6.dim("Your site meets WCAG 2.2 AA requirements based on static analysis."));
-    console.log(chalk6.dim("Note: Run manual testing with screen readers for full compliance.\n"));
+    console.log(chalk7.green("\u2705 Accessibility Audit Passed\n"));
+    console.log(chalk7.dim("Your site meets WCAG 2.2 AA requirements based on static analysis."));
+    console.log(chalk7.dim("Note: Run manual testing with screen readers for full compliance.\n"));
     return;
   }
-  console.log(chalk6.red(`\u26A0\uFE0F  ${issues.length} Accessibility Issues Found
+  console.log(chalk7.red(`\u26A0\uFE0F  ${issues.length} Accessibility Issues Found
 `));
   const criticalCount = issues.filter((i) => i.severity === "critical").length;
   const majorCount = issues.filter((i) => i.severity === "major").length;
   const minorCount = issues.filter((i) => i.severity === "minor").length;
-  console.log(chalk6.dim("Summary:"));
-  if (criticalCount > 0) console.log(chalk6.red(`  \u2022 ${criticalCount} critical`));
-  if (majorCount > 0) console.log(chalk6.yellow(`  \u2022 ${majorCount} major`));
-  if (minorCount > 0) console.log(chalk6.dim(`  \u2022 ${minorCount} minor`));
+  console.log(chalk7.dim("Summary:"));
+  if (criticalCount > 0) console.log(chalk7.red(`  \u2022 ${criticalCount} critical`));
+  if (majorCount > 0) console.log(chalk7.yellow(`  \u2022 ${majorCount} major`));
+  if (minorCount > 0) console.log(chalk7.dim(`  \u2022 ${minorCount} minor`));
   console.log();
-  console.log(chalk6.bold("Issues:\n"));
+  console.log(chalk7.bold("Issues:\n"));
   const issuesByFile = /* @__PURE__ */ new Map();
   for (const issue of issues) {
     const existing = issuesByFile.get(issue.file) || [];
@@ -2067,43 +2503,43 @@ async function a11yCheck(options) {
     issuesByFile.set(issue.file, existing);
   }
   for (const [file, fileIssues] of issuesByFile) {
-    console.log(chalk6.cyan(`  ${file}`));
+    console.log(chalk7.cyan(`  ${file}`));
     for (const issue of fileIssues.slice(0, 5)) {
-      const color = issue.severity === "critical" ? chalk6.red : issue.severity === "major" ? chalk6.yellow : chalk6.dim;
+      const color = issue.severity === "critical" ? chalk7.red : issue.severity === "major" ? chalk7.yellow : chalk7.dim;
       console.log(color(`    Line ${issue.line}: ${issue.message} (WCAG ${issue.wcag})`));
     }
     if (fileIssues.length > 5) {
-      console.log(chalk6.dim(`    ... and ${fileIssues.length - 5} more issues`));
+      console.log(chalk7.dim(`    ... and ${fileIssues.length - 5} more issues`));
     }
     console.log();
   }
-  console.log(chalk6.bold.yellow("\n\u2696\uFE0F  Legal Notice\n"));
-  console.log(chalk6.dim("Websites that don't meet accessibility standards may violate:"));
-  console.log(chalk6.dim("  \u2022 ADA (Americans with Disabilities Act) \u2014 US"));
-  console.log(chalk6.dim("  \u2022 EAA (European Accessibility Act) \u2014 EU, effective June 2025"));
-  console.log(chalk6.dim("  \u2022 Section 508 \u2014 US federal agencies and contractors"));
-  console.log(chalk6.dim("  \u2022 AODA (Accessibility for Ontarians) \u2014 Ontario, Canada"));
+  console.log(chalk7.bold.yellow("\n\u2696\uFE0F  Legal Notice\n"));
+  console.log(chalk7.dim("Websites that don't meet accessibility standards may violate:"));
+  console.log(chalk7.dim("  \u2022 ADA (Americans with Disabilities Act) \u2014 US"));
+  console.log(chalk7.dim("  \u2022 EAA (European Accessibility Act) \u2014 EU, effective June 2025"));
+  console.log(chalk7.dim("  \u2022 Section 508 \u2014 US federal agencies and contractors"));
+  console.log(chalk7.dim("  \u2022 AODA (Accessibility for Ontarians) \u2014 Ontario, Canada"));
   console.log();
-  console.log(chalk6.dim("Non-compliance can result in lawsuits, fines, and reputational damage."));
-  console.log(chalk6.dim("In 2023, over 4,600 ADA web accessibility lawsuits were filed in the US.\n"));
-  console.log(chalk6.dim(`Full report saved to: .archon/a11y-report.json`));
+  console.log(chalk7.dim("Non-compliance can result in lawsuits, fines, and reputational damage."));
+  console.log(chalk7.dim("In 2023, over 4,600 ADA web accessibility lawsuits were filed in the US.\n"));
+  console.log(chalk7.dim(`Full report saved to: .archon/a11y-report.json`));
 }
 async function a11yFix(options) {
   const prompt2 = createPrompt();
   try {
-    console.log(chalk6.blue("\n\u267F Accessibility Auto-Fix\n"));
-    const reportPath = join5(process.cwd(), ".archon/a11y-report.json");
-    if (!existsSync6(reportPath)) {
-      console.log(chalk6.yellow("No accessibility report found. Running check first...\n"));
+    console.log(chalk7.blue("\n\u267F Accessibility Auto-Fix\n"));
+    const reportPath = join6(process.cwd(), ".archon/a11y-report.json");
+    if (!existsSync7(reportPath)) {
+      console.log(chalk7.yellow("No accessibility report found. Running check first...\n"));
       await a11yCheck({});
     }
-    const reportContent = await readFile4(reportPath, "utf-8");
+    const reportContent = await readFile5(reportPath, "utf-8");
     const report = JSON.parse(reportContent);
     if (report.passed || report.issues.length === 0) {
-      console.log(chalk6.green("No issues to fix!"));
+      console.log(chalk7.green("No issues to fix!"));
       return;
     }
-    console.log(chalk6.dim(`Found ${report.issues.length} issues from last check.
+    console.log(chalk7.dim(`Found ${report.issues.length} issues from last check.
 `));
     const fixablePatterns = [
       {
@@ -2134,19 +2570,19 @@ async function a11yFix(options) {
       for (const pattern of patterns) {
         const files = await glob(pattern, { cwd: process.cwd(), ignore: ignorePatterns });
         for (const file of files) {
-          const filePath = join5(process.cwd(), file);
+          const filePath = join6(process.cwd(), file);
           try {
-            const content = await readFile4(filePath, "utf-8");
+            const content = await readFile5(filePath, "utf-8");
             if (fix.pattern.test(content)) {
               fix.pattern.lastIndex = 0;
               const matches = content.match(fix.pattern);
               const count = matches?.length || 0;
               if (count > 0) {
-                console.log(chalk6.cyan(`  ${file}: ${count} fixes (${fix.description})`));
+                console.log(chalk7.cyan(`  ${file}: ${count} fixes (${fix.description})`));
                 totalFixes += count;
                 if (!options.dryRun) {
                   const newContent = content.replace(fix.pattern, fix.replacement);
-                  await writeFile4(filePath, newContent);
+                  await writeFile5(filePath, newContent);
                 }
               }
             }
@@ -2156,21 +2592,21 @@ async function a11yFix(options) {
       }
     }
     if (totalFixes === 0) {
-      console.log(chalk6.dim("No auto-fixable issues found. Some issues require manual fixes."));
+      console.log(chalk7.dim("No auto-fixable issues found. Some issues require manual fixes."));
     } else if (options.dryRun) {
-      console.log(chalk6.yellow(`
+      console.log(chalk7.yellow(`
 ${totalFixes} fixes would be applied. Run without --dry-run to apply.`));
     } else {
-      console.log(chalk6.green(`
+      console.log(chalk7.green(`
 \u2705 Applied ${totalFixes} fixes.`));
-      console.log(chalk6.dim('Run "archon a11y check" to verify fixes.'));
+      console.log(chalk7.dim('Run "archon a11y check" to verify fixes.'));
     }
   } finally {
     prompt2.close();
   }
 }
 async function a11yBadge(options) {
-  console.log(chalk6.blue("\n\u267F Accessibility Badge\n"));
+  console.log(chalk7.blue("\n\u267F Accessibility Badge\n"));
   const badgeHtml = `<!-- WCAG 2.2 AA Compliance Badge -->
 <div class="flex items-center gap-2 text-xs text-text-muted dark:text-cream-300">
   <svg class="h-4 w-4" fill="currentColor" viewBox="0 0 20 20" aria-hidden="true">
@@ -2185,35 +2621,35 @@ async function a11yBadge(options) {
     footerFiles = footerFiles.concat(files);
   }
   if (footerFiles.length === 0) {
-    console.log(chalk6.yellow("No footer files found."));
-    console.log(chalk6.dim("\nManually add this badge to your footer:\n"));
+    console.log(chalk7.yellow("No footer files found."));
+    console.log(chalk7.dim("\nManually add this badge to your footer:\n"));
     console.log(badgeHtml);
     return;
   }
-  console.log(chalk6.dim(`Found ${footerFiles.length} footer file(s):
+  console.log(chalk7.dim(`Found ${footerFiles.length} footer file(s):
 `));
   for (const file of footerFiles) {
-    console.log(chalk6.cyan(`  ${file}`));
+    console.log(chalk7.cyan(`  ${file}`));
   }
   if (options.remove) {
-    console.log(chalk6.yellow("\nRemoving accessibility badge..."));
-    console.log(chalk6.dim("Badge removal not yet implemented. Manually remove the WCAG badge comment block."));
+    console.log(chalk7.yellow("\nRemoving accessibility badge..."));
+    console.log(chalk7.dim("Badge removal not yet implemented. Manually remove the WCAG badge comment block."));
   } else {
-    console.log(chalk6.dim("\nTo add the badge, insert this code before the closing </footer> tag:\n"));
-    console.log(chalk6.green(badgeHtml));
+    console.log(chalk7.dim("\nTo add the badge, insert this code before the closing </footer> tag:\n"));
+    console.log(chalk7.green(badgeHtml));
   }
 }
 async function a11yPreDeploy() {
   const prompt2 = createPrompt();
   try {
-    console.log(chalk6.blue("\n\u26A0\uFE0F  Pre-Deploy Accessibility Check\n"));
-    console.log(chalk6.dim("Before deploying a live website, accessibility compliance is required.\n"));
+    console.log(chalk7.blue("\n\u26A0\uFE0F  Pre-Deploy Accessibility Check\n"));
+    console.log(chalk7.dim("Before deploying a live website, accessibility compliance is required.\n"));
     await a11yCheck({});
-    const reportPath = join5(process.cwd(), ".archon/a11y-report.json");
-    if (!existsSync6(reportPath)) {
+    const reportPath = join6(process.cwd(), ".archon/a11y-report.json");
+    if (!existsSync7(reportPath)) {
       return false;
     }
-    const reportContent = await readFile4(reportPath, "utf-8");
+    const reportContent = await readFile5(reportPath, "utf-8");
     const report = JSON.parse(reportContent);
     if (report.passed) {
       const addBadge = await prompt2.ask("\nWould you like to add a WCAG 2.2 AA badge to your footer? (y/N): ");
@@ -2222,7 +2658,7 @@ async function a11yPreDeploy() {
       }
       return true;
     }
-    console.log(chalk6.bold("\nOptions:\n"));
+    console.log(chalk7.bold("\nOptions:\n"));
     console.log("  1) Fix issues now (recommended)");
     console.log("  2) Deploy anyway (not recommended)");
     console.log("  3) Cancel deployment\n");
@@ -2232,11 +2668,11 @@ async function a11yPreDeploy() {
       await a11yCheck({});
       return true;
     } else if (choice === "2") {
-      console.log(chalk6.yellow("\n\u26A0\uFE0F  Acknowledged. Proceeding without full accessibility compliance."));
-      console.log(chalk6.dim("Consider addressing these issues in a future session.\n"));
+      console.log(chalk7.yellow("\n\u26A0\uFE0F  Acknowledged. Proceeding without full accessibility compliance."));
+      console.log(chalk7.dim("Consider addressing these issues in a future session.\n"));
       return true;
     } else {
-      console.log(chalk6.dim("\nDeployment cancelled."));
+      console.log(chalk7.dim("\nDeployment cancelled."));
       return false;
     }
   } finally {
@@ -2246,14 +2682,14 @@ async function a11yPreDeploy() {
 
 // src/cli/geo.ts
 import { Command as Command2 } from "commander";
-import chalk7 from "chalk";
-import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import { join as join6 } from "path";
+import chalk8 from "chalk";
+import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir4 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { join as join7 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { glob as glob2 } from "glob";
-import * as yaml from "yaml";
-var CONFIG_PATH = ".archon/config.yaml";
+import * as yaml2 from "yaml";
+var CONFIG_PATH2 = ".archon/config.yaml";
 function createPrompt2() {
   const rl = createInterface2({
     input: process.stdin,
@@ -2267,33 +2703,33 @@ function createPrompt2() {
   };
 }
 async function loadGeoConfig(cwd) {
-  const configPath = join6(cwd, CONFIG_PATH);
-  if (!existsSync7(configPath)) {
+  const configPath = join7(cwd, CONFIG_PATH2);
+  if (!existsSync8(configPath)) {
     return {};
   }
   try {
-    const content = await readFile5(configPath, "utf-8");
-    return yaml.parse(content);
+    const content = await readFile6(configPath, "utf-8");
+    return yaml2.parse(content);
   } catch {
     return {};
   }
 }
 async function saveGeoConfig(cwd, config) {
-  const configPath = join6(cwd, CONFIG_PATH);
-  const archonDir = join6(cwd, ".archon");
-  if (!existsSync7(archonDir)) {
-    await mkdir3(archonDir, { recursive: true });
+  const configPath = join7(cwd, CONFIG_PATH2);
+  const archonDir = join7(cwd, ".archon");
+  if (!existsSync8(archonDir)) {
+    await mkdir4(archonDir, { recursive: true });
   }
   let existing = {};
-  if (existsSync7(configPath)) {
+  if (existsSync8(configPath)) {
     try {
-      const content = await readFile5(configPath, "utf-8");
-      existing = yaml.parse(content);
+      const content = await readFile6(configPath, "utf-8");
+      existing = yaml2.parse(content);
     } catch {
     }
   }
   const merged = { ...existing, ...config };
-  await writeFile5(configPath, yaml.stringify(merged), "utf-8");
+  await writeFile6(configPath, yaml2.stringify(merged), "utf-8");
 }
 async function readPageContent(patterns) {
   const cwd = process.cwd();
@@ -2302,7 +2738,7 @@ async function readPageContent(patterns) {
     const files = await glob2(pattern, { cwd, ignore: ["**/node_modules/**", "**/dist/**"] });
     for (const file of files.slice(0, 3)) {
       try {
-        const fileContent = await readFile5(join6(cwd, file), "utf-8");
+        const fileContent = await readFile6(join7(cwd, file), "utf-8");
         content += `
 --- File: ${file} ---
 ${fileContent.slice(0, 5e3)}
@@ -2370,13 +2806,13 @@ async function geoIdentity() {
   const cwd = process.cwd();
   const prompt2 = createPrompt2();
   try {
-    console.log(chalk7.blue("\n\u{1F3AF} GEO Identity Generator\n"));
+    console.log(chalk8.blue("\n\u{1F3AF} GEO Identity Generator\n"));
     const { allowed, tier } = await checkStrongModelAccess();
     if (!allowed) {
-      console.log(chalk7.yellow(`\u26A0\uFE0F  Your tier (${tier}) uses basic models.`));
-      console.log(chalk7.dim("For better results, add credits or use BYOK mode.\n"));
+      console.log(chalk8.yellow(`\u26A0\uFE0F  Your tier (${tier}) uses basic models.`));
+      console.log(chalk8.dim("For better results, add credits or use BYOK mode.\n"));
     }
-    console.log(chalk7.dim("Reading homepage and about page content...\n"));
+    console.log(chalk8.dim("Reading homepage and about page content...\n"));
     const pageContent = await readPageContent([
       "**/index.html",
       "**/index.{jsx,tsx,astro,svelte,vue}",
@@ -2387,44 +2823,44 @@ async function geoIdentity() {
       "README.md"
     ]);
     if (pageContent === "No content found.") {
-      console.log(chalk7.yellow("No homepage or about page content found."));
-      console.log(chalk7.dim("Create an index file or README.md first.\n"));
+      console.log(chalk8.yellow("No homepage or about page content found."));
+      console.log(chalk8.dim("Create an index file or README.md first.\n"));
       return;
     }
-    console.log(chalk7.dim("Generating identity candidates with AI...\n"));
+    console.log(chalk8.dim("Generating identity candidates with AI...\n"));
     const candidates = await generateIdentityCandidates(pageContent);
-    console.log(chalk7.bold("\u{1F4CC} 7-Word Brand Phrases:\n"));
+    console.log(chalk8.bold("\u{1F4CC} 7-Word Brand Phrases:\n"));
     candidates.phrases.forEach((p, i) => {
-      console.log(`  ${chalk7.cyan(`${i + 1})`)} ${chalk7.bold(p.phrase)}`);
-      console.log(`     ${chalk7.dim(p.rationale)}
+      console.log(`  ${chalk8.cyan(`${i + 1})`)} ${chalk8.bold(p.phrase)}`);
+      console.log(`     ${chalk8.dim(p.rationale)}
 `);
     });
     const phraseChoice = await prompt2.ask('Select a phrase (1-3) or "r" to regenerate: ');
     if (phraseChoice.toLowerCase() === "r") {
-      console.log(chalk7.dim("\nRegenerating... Run the command again.\n"));
+      console.log(chalk8.dim("\nRegenerating... Run the command again.\n"));
       return;
     }
     const phraseIndex = parseInt(phraseChoice, 10) - 1;
     const selectedPhrase = candidates.phrases[phraseIndex];
     if (isNaN(phraseIndex) || phraseIndex < 0 || phraseIndex >= candidates.phrases.length || !selectedPhrase) {
-      console.log(chalk7.red("Invalid selection."));
+      console.log(chalk8.red("Invalid selection."));
       return;
     }
-    console.log(chalk7.bold("\n\u{1F4DD} 50-Word Descriptions:\n"));
+    console.log(chalk8.bold("\n\u{1F4DD} 50-Word Descriptions:\n"));
     candidates.descriptions.forEach((d, i) => {
-      console.log(`  ${chalk7.cyan(`${i + 1})`)} ${d.description}`);
-      console.log(`     ${chalk7.dim(d.rationale)}
+      console.log(`  ${chalk8.cyan(`${i + 1})`)} ${d.description}`);
+      console.log(`     ${chalk8.dim(d.rationale)}
 `);
     });
     const descChoice = await prompt2.ask('Select a description (1-3) or "r" to regenerate: ');
     if (descChoice.toLowerCase() === "r") {
-      console.log(chalk7.dim("\nRegenerating... Run the command again.\n"));
+      console.log(chalk8.dim("\nRegenerating... Run the command again.\n"));
       return;
     }
     const descIndex = parseInt(descChoice, 10) - 1;
     const selectedDescription = candidates.descriptions[descIndex];
     if (isNaN(descIndex) || descIndex < 0 || descIndex >= candidates.descriptions.length || !selectedDescription) {
-      console.log(chalk7.red("Invalid selection."));
+      console.log(chalk8.red("Invalid selection."));
       return;
     }
     const geoConfig = {
@@ -2435,31 +2871,31 @@ async function geoIdentity() {
       }
     };
     await saveGeoConfig(cwd, geoConfig);
-    console.log(chalk7.green("\n\u2705 Identity saved!\n"));
-    console.log(chalk7.dim(`  Phrase: ${selectedPhrase.phrase}`));
-    console.log(chalk7.dim(`  Description: ${selectedDescription.description.slice(0, 60)}...`));
+    console.log(chalk8.green("\n\u2705 Identity saved!\n"));
+    console.log(chalk8.dim(`  Phrase: ${selectedPhrase.phrase}`));
+    console.log(chalk8.dim(`  Description: ${selectedDescription.description.slice(0, 60)}...`));
     console.log();
-    console.log(chalk7.cyan(`Use 'archon geo schema' to generate JSON-LD.`));
+    console.log(chalk8.cyan(`Use 'archon geo schema' to generate JSON-LD.`));
   } finally {
     prompt2.close();
   }
 }
 async function geoSchema(options) {
   const cwd = process.cwd();
-  console.log(chalk7.blue("\n\u{1F4E6} JSON-LD Schema Generator\n"));
+  console.log(chalk8.blue("\n\u{1F4E6} JSON-LD Schema Generator\n"));
   const config = await loadGeoConfig(cwd);
   if (!config.geo?.identityPhrase || !config.geo?.shortDescription) {
-    console.log(chalk7.yellow("No identity defined."));
-    console.log(chalk7.dim(`Run 'archon geo identity' first.
+    console.log(chalk8.yellow("No identity defined."));
+    console.log(chalk8.dim(`Run 'archon geo identity' first.
 `));
     return;
   }
   const { identityPhrase, shortDescription } = config.geo;
   let orgName = identityPhrase.split(" ").slice(0, 2).join(" ");
   try {
-    const pkgPath = join6(cwd, "package.json");
-    if (existsSync7(pkgPath)) {
-      const pkg = JSON.parse(await readFile5(pkgPath, "utf-8"));
+    const pkgPath = join7(cwd, "package.json");
+    if (existsSync8(pkgPath)) {
+      const pkg = JSON.parse(await readFile6(pkgPath, "utf-8"));
       if (pkg.name) {
         orgName = pkg.name.replace(/-/g, " ").replace(/^\w/, (c) => c.toUpperCase());
       }
@@ -2493,40 +2929,40 @@ async function geoSchema(options) {
   };
   const jsonLd = JSON.stringify(schema, null, 2);
   if (options.output) {
-    await writeFile5(options.output, jsonLd, "utf-8");
-    console.log(chalk7.green(`\u2705 Schema written to ${options.output}`));
+    await writeFile6(options.output, jsonLd, "utf-8");
+    console.log(chalk8.green(`\u2705 Schema written to ${options.output}`));
   } else {
-    console.log(chalk7.bold("Generated JSON-LD:\n"));
-    console.log(chalk7.cyan(jsonLd));
+    console.log(chalk8.bold("Generated JSON-LD:\n"));
+    console.log(chalk8.cyan(jsonLd));
   }
   if (options.apply) {
-    console.log(chalk7.dim("\nAttempting to insert into homepage <head>...\n"));
+    console.log(chalk8.dim("\nAttempting to insert into homepage <head>...\n"));
     const indexFiles = await glob2("**/index.html", { cwd, ignore: ["**/node_modules/**", "**/dist/**"] });
     if (indexFiles.length === 0) {
-      console.log(chalk7.yellow("No index.html found. Manually add to your HTML <head>:"));
-      console.log(chalk7.dim(`<script type="application/ld+json">
+      console.log(chalk8.yellow("No index.html found. Manually add to your HTML <head>:"));
+      console.log(chalk8.dim(`<script type="application/ld+json">
 ${jsonLd}
 </script>`));
       return;
     }
     const firstIndexFile = indexFiles[0];
     if (!firstIndexFile) {
-      console.log(chalk7.yellow("No index.html found."));
+      console.log(chalk8.yellow("No index.html found."));
       return;
     }
-    const indexPath = join6(cwd, firstIndexFile);
-    let indexContent = await readFile5(indexPath, "utf-8");
+    const indexPath = join7(cwd, firstIndexFile);
+    let indexContent = await readFile6(indexPath, "utf-8");
     const scriptTag = `<script type="application/ld+json">
 ${jsonLd}
 </script>`;
     if (indexContent.includes("application/ld+json")) {
-      console.log(chalk7.yellow("JSON-LD already exists in index.html. Remove it first or update manually."));
+      console.log(chalk8.yellow("JSON-LD already exists in index.html. Remove it first or update manually."));
       return;
     }
     indexContent = indexContent.replace("</head>", `${scriptTag}
 </head>`);
-    await writeFile5(indexPath, indexContent, "utf-8");
-    console.log(chalk7.green(`\u2705 JSON-LD inserted into ${firstIndexFile}`));
+    await writeFile6(indexPath, indexContent, "utf-8");
+    console.log(chalk8.green(`\u2705 JSON-LD inserted into ${firstIndexFile}`));
   }
   console.log();
 }
@@ -2542,21 +2978,21 @@ Guidelines:
 Output your response as valid JSON.`;
 async function geoFaq(options) {
   const cwd = process.cwd();
-  console.log(chalk7.blue("\n\u2753 FAQ Schema Generator\n"));
+  console.log(chalk8.blue("\n\u2753 FAQ Schema Generator\n"));
   const config = await loadGeoConfig(cwd);
   if (!config.geo?.identityPhrase || !config.geo?.shortDescription) {
-    console.log(chalk7.yellow("No identity defined."));
-    console.log(chalk7.dim(`Run 'archon geo identity' first.
+    console.log(chalk8.yellow("No identity defined."));
+    console.log(chalk8.dim(`Run 'archon geo identity' first.
 `));
     return;
   }
   const { identityPhrase, shortDescription } = config.geo;
   const { allowed, tier } = await checkStrongModelAccess();
   if (!allowed) {
-    console.log(chalk7.yellow(`\u26A0\uFE0F  Your tier (${tier}) uses basic models.`));
-    console.log(chalk7.dim("For better results, add credits or use BYOK mode.\n"));
+    console.log(chalk8.yellow(`\u26A0\uFE0F  Your tier (${tier}) uses basic models.`));
+    console.log(chalk8.dim("For better results, add credits or use BYOK mode.\n"));
   }
-  console.log(chalk7.dim("Generating FAQ content with AI...\n"));
+  console.log(chalk8.dim("Generating FAQ content with AI...\n"));
   const agent = new ArchitectAgent({ temperature: 0.7 });
   const prompt2 = `Generate FAQ content for a product/service with:
 - Brand phrase: "${identityPhrase}"
@@ -2576,7 +3012,7 @@ Generate 6-8 FAQs as JSON:
   );
   const jsonMatch = response.content.match(/\{[\s\S]*\}/);
   if (!jsonMatch) {
-    console.log(chalk7.red("Failed to generate FAQ content."));
+    console.log(chalk8.red("Failed to generate FAQ content."));
     return;
   }
   const parsed = JSON.parse(jsonMatch[0]);
@@ -2594,17 +3030,17 @@ Generate 6-8 FAQs as JSON:
   };
   const jsonLd = JSON.stringify(faqSchema, null, 2);
   if (options.output) {
-    await writeFile5(options.output, jsonLd, "utf-8");
-    console.log(chalk7.green(`\u2705 FAQ schema written to ${options.output}`));
+    await writeFile6(options.output, jsonLd, "utf-8");
+    console.log(chalk8.green(`\u2705 FAQ schema written to ${options.output}`));
   } else {
-    console.log(chalk7.bold("Generated FAQPage JSON-LD:\n"));
-    console.log(chalk7.cyan(jsonLd));
+    console.log(chalk8.bold("Generated FAQPage JSON-LD:\n"));
+    console.log(chalk8.cyan(jsonLd));
   }
   console.log();
 }
 async function geoAudit() {
   const cwd = process.cwd();
-  console.log(chalk7.blue("\n\u{1F50D} GEO Audit\n"));
+  console.log(chalk8.blue("\n\u{1F50D} GEO Audit\n"));
   const result = {
     identityDefined: false,
     phraseInH1: false,
@@ -2617,75 +3053,75 @@ async function geoAudit() {
   const config = await loadGeoConfig(cwd);
   if (config.geo?.identityPhrase && config.geo?.shortDescription) {
     result.identityDefined = true;
-    console.log(chalk7.green("\u2705 Identity defined"));
-    console.log(chalk7.dim(`   Phrase: ${config.geo.identityPhrase}`));
+    console.log(chalk8.green("\u2705 Identity defined"));
+    console.log(chalk8.dim(`   Phrase: ${config.geo.identityPhrase}`));
   } else {
     result.issues.push('Identity not defined. Run "archon geo identity"');
-    console.log(chalk7.red("\u274C Identity not defined"));
+    console.log(chalk8.red("\u274C Identity not defined"));
   }
   const htmlFiles = await glob2("**/index.html", { cwd, ignore: ["**/node_modules/**", "**/dist/**"] });
   const firstHtmlFile = htmlFiles[0];
   if (firstHtmlFile && config.geo?.identityPhrase) {
-    const indexPath = join6(cwd, firstHtmlFile);
-    const content = await readFile5(indexPath, "utf-8");
+    const indexPath = join7(cwd, firstHtmlFile);
+    const content = await readFile6(indexPath, "utf-8");
     const identityPhrase = config.geo.identityPhrase;
     const firstKeyword = identityPhrase.toLowerCase().split(" ")[0] ?? "";
     const h1Match = content.match(/<h1[^>]*>(.*?)<\/h1>/is);
     if (h1Match?.[1] && h1Match[1].toLowerCase().includes(firstKeyword)) {
       result.phraseInH1 = true;
-      console.log(chalk7.green("\u2705 Brand keyword in H1"));
+      console.log(chalk8.green("\u2705 Brand keyword in H1"));
     } else {
       result.issues.push("Brand phrase keyword not found in H1");
-      console.log(chalk7.yellow("\u26A0\uFE0F  Brand keyword not in H1"));
+      console.log(chalk8.yellow("\u26A0\uFE0F  Brand keyword not in H1"));
     }
     const metaMatch = content.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["']/i);
     if (metaMatch?.[1] && metaMatch[1].toLowerCase().includes(firstKeyword)) {
       result.phraseInMetaDescription = true;
-      console.log(chalk7.green("\u2705 Brand keyword in meta description"));
+      console.log(chalk8.green("\u2705 Brand keyword in meta description"));
     } else {
       result.issues.push("Brand phrase keyword not found in meta description");
-      console.log(chalk7.yellow("\u26A0\uFE0F  Brand keyword not in meta description"));
+      console.log(chalk8.yellow("\u26A0\uFE0F  Brand keyword not in meta description"));
     }
     if (content.includes("application/ld+json")) {
       if (content.includes('"@type":"Organization"') || content.includes('"@type": "Organization"')) {
         result.hasOrganizationSchema = true;
-        console.log(chalk7.green("\u2705 Organization schema present"));
+        console.log(chalk8.green("\u2705 Organization schema present"));
       } else {
         result.issues.push("Organization schema not found");
-        console.log(chalk7.yellow("\u26A0\uFE0F  Organization schema missing"));
+        console.log(chalk8.yellow("\u26A0\uFE0F  Organization schema missing"));
       }
       if (content.includes('"@type":"Service"') || content.includes('"@type": "Service"')) {
         result.hasServiceSchema = true;
-        console.log(chalk7.green("\u2705 Service schema present"));
+        console.log(chalk8.green("\u2705 Service schema present"));
       } else {
         result.issues.push("Service schema not found");
-        console.log(chalk7.yellow("\u26A0\uFE0F  Service schema missing"));
+        console.log(chalk8.yellow("\u26A0\uFE0F  Service schema missing"));
       }
       if (content.includes('"@type":"FAQPage"') || content.includes('"@type": "FAQPage"')) {
         result.hasFAQSchema = true;
-        console.log(chalk7.green("\u2705 FAQPage schema present"));
+        console.log(chalk8.green("\u2705 FAQPage schema present"));
       } else {
         result.issues.push("FAQPage schema not found");
-        console.log(chalk7.yellow("\u26A0\uFE0F  FAQPage schema missing"));
+        console.log(chalk8.yellow("\u26A0\uFE0F  FAQPage schema missing"));
       }
     } else {
       result.issues.push("No JSON-LD schemas found");
-      console.log(chalk7.red("\u274C No JSON-LD schemas found"));
+      console.log(chalk8.red("\u274C No JSON-LD schemas found"));
     }
   } else if (htmlFiles.length === 0) {
     result.issues.push("No index.html found");
-    console.log(chalk7.yellow("\u26A0\uFE0F  No index.html found to audit"));
+    console.log(chalk8.yellow("\u26A0\uFE0F  No index.html found to audit"));
   }
   console.log();
   const passed = result.issues.length === 0;
   if (passed) {
-    console.log(chalk7.green.bold("\u2705 GEO Audit Passed"));
+    console.log(chalk8.green.bold("\u2705 GEO Audit Passed"));
   } else {
-    console.log(chalk7.yellow.bold(`\u26A0\uFE0F  ${result.issues.length} issue(s) found`));
+    console.log(chalk8.yellow.bold(`\u26A0\uFE0F  ${result.issues.length} issue(s) found`));
     console.log();
-    console.log(chalk7.bold("Recommendations:"));
+    console.log(chalk8.bold("Recommendations:"));
     result.issues.forEach((issue, i) => {
-      console.log(chalk7.dim(`  ${i + 1}. ${issue}`));
+      console.log(chalk8.dim(`  ${i + 1}. ${issue}`));
     });
   }
   console.log();
@@ -2722,10 +3158,10 @@ Examples:
 
 // src/cli/seo.ts
 import { Command as Command3 } from "commander";
-import chalk8 from "chalk";
-import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir4 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import { join as join7 } from "path";
+import chalk9 from "chalk";
+import { readFile as readFile7, writeFile as writeFile7, mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import { join as join8 } from "path";
 import { createInterface as createInterface3 } from "readline";
 import { glob as glob3 } from "glob";
 var SEO_CHECKS = {
@@ -2834,7 +3270,7 @@ async function getWebFiles() {
   let allFiles = [];
   for (const pattern of patterns) {
     const files = await glob3(pattern, { cwd: process.cwd(), ignore: ignorePatterns });
-    allFiles = allFiles.concat(files.map((f) => join7(process.cwd(), f)));
+    allFiles = allFiles.concat(files.map((f) => join8(process.cwd(), f)));
   }
   return allFiles;
 }
@@ -2842,7 +3278,7 @@ async function scanForSeoIssues(files) {
   const issues = [];
   for (const file of files) {
     try {
-      const content = await readFile6(file, "utf-8");
+      const content = await readFile7(file, "utf-8");
       const relativePath = file.replace(process.cwd() + "/", "");
       for (const [checkId, check] of Object.entries(SEO_CHECKS)) {
         const hasTag = check.regex.test(content);
@@ -2872,19 +3308,19 @@ function findHeadInsertionPoint(content) {
   return null;
 }
 async function seoCheck(options) {
-  console.log(chalk8.blue("\n\u{1F50D} SEO Check\n"));
-  console.log(chalk8.dim("Scanning for SEO issues...\n"));
+  console.log(chalk9.blue("\n\u{1F50D} SEO Check\n"));
+  console.log(chalk9.dim("Scanning for SEO issues...\n"));
   const files = await getWebFiles();
   if (files.length === 0) {
-    console.log(chalk8.yellow("No web files found to check."));
+    console.log(chalk9.yellow("No web files found to check."));
     return;
   }
-  console.log(chalk8.dim(`Scanning ${files.length} files...
+  console.log(chalk9.dim(`Scanning ${files.length} files...
 `));
   const issues = await scanForSeoIssues(files);
-  const archonDir = join7(process.cwd(), ".archon");
-  if (!existsSync8(archonDir)) {
-    await mkdir4(archonDir, { recursive: true });
+  const archonDir = join8(process.cwd(), ".archon");
+  if (!existsSync9(archonDir)) {
+    await mkdir5(archonDir, { recursive: true });
   }
   const report = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2893,24 +3329,24 @@ async function seoCheck(options) {
     issues,
     passed: issues.length === 0
   };
-  await writeFile6(join7(archonDir, "seo-report.json"), JSON.stringify(report, null, 2));
+  await writeFile7(join8(archonDir, "seo-report.json"), JSON.stringify(report, null, 2));
   if (issues.length === 0) {
-    console.log(chalk8.green("\u2705 SEO Check Passed\n"));
-    console.log(chalk8.dim("All essential meta tags are present."));
+    console.log(chalk9.green("\u2705 SEO Check Passed\n"));
+    console.log(chalk9.dim("All essential meta tags are present."));
     return;
   }
-  console.log(chalk8.yellow(`\u26A0\uFE0F  ${issues.length} SEO Issues Found
+  console.log(chalk9.yellow(`\u26A0\uFE0F  ${issues.length} SEO Issues Found
 `));
   const criticalCount = issues.filter((i) => i.severity === "critical").length;
   const warningCount = issues.filter((i) => i.severity === "warning").length;
   const infoCount = issues.filter((i) => i.severity === "info").length;
-  console.log(chalk8.dim("Summary:"));
-  if (criticalCount > 0) console.log(chalk8.red(`  \u2022 ${criticalCount} critical`));
-  if (warningCount > 0) console.log(chalk8.yellow(`  \u2022 ${warningCount} warning`));
-  if (infoCount > 0) console.log(chalk8.dim(`  \u2022 ${infoCount} info`));
+  console.log(chalk9.dim("Summary:"));
+  if (criticalCount > 0) console.log(chalk9.red(`  \u2022 ${criticalCount} critical`));
+  if (warningCount > 0) console.log(chalk9.yellow(`  \u2022 ${warningCount} warning`));
+  if (infoCount > 0) console.log(chalk9.dim(`  \u2022 ${infoCount} info`));
   console.log();
-  console.log(chalk8.bold("File                           | Issue                    | Recommendation"));
-  console.log(chalk8.dim("\u2500".repeat(100)));
+  console.log(chalk9.bold("File                           | Issue                    | Recommendation"));
+  console.log(chalk9.dim("\u2500".repeat(100)));
   const issuesByFile = /* @__PURE__ */ new Map();
   for (const issue of issues) {
     const existing = issuesByFile.get(issue.file) || [];
@@ -2920,31 +3356,31 @@ async function seoCheck(options) {
   for (const [file, fileIssues] of issuesByFile) {
     const displayFile = file.length > 30 ? "..." + file.slice(-27) : file.padEnd(30);
     for (const issue of fileIssues.slice(0, options.verbose ? 20 : 5)) {
-      const color = issue.severity === "critical" ? chalk8.red : issue.severity === "warning" ? chalk8.yellow : chalk8.dim;
+      const color = issue.severity === "critical" ? chalk9.red : issue.severity === "warning" ? chalk9.yellow : chalk9.dim;
       const displayIssue = issue.issue.padEnd(24).slice(0, 24);
       const displayRec = issue.recommendation.slice(0, 50);
       console.log(color(`${displayFile} | ${displayIssue} | ${displayRec}`));
     }
     if (!options.verbose && fileIssues.length > 5) {
-      console.log(chalk8.dim(`${"".padEnd(30)} | ... and ${fileIssues.length - 5} more issues`));
+      console.log(chalk9.dim(`${"".padEnd(30)} | ... and ${fileIssues.length - 5} more issues`));
     }
   }
-  console.log(chalk8.dim(`
+  console.log(chalk9.dim(`
 Full report saved to: .archon/seo-report.json`));
 }
 async function seoFix(options) {
   const prompt2 = createPrompt3();
   try {
-    console.log(chalk8.blue("\n\u{1F527} SEO Auto-Fix\n"));
-    const reportPath = join7(process.cwd(), ".archon/seo-report.json");
-    if (!existsSync8(reportPath)) {
-      console.log(chalk8.yellow("No SEO report found. Running check first...\n"));
+    console.log(chalk9.blue("\n\u{1F527} SEO Auto-Fix\n"));
+    const reportPath = join8(process.cwd(), ".archon/seo-report.json");
+    if (!existsSync9(reportPath)) {
+      console.log(chalk9.yellow("No SEO report found. Running check first...\n"));
       await seoCheck({});
     }
-    const reportContent = await readFile6(reportPath, "utf-8");
+    const reportContent = await readFile7(reportPath, "utf-8");
     const report = JSON.parse(reportContent);
     if (report.passed || report.issues.length === 0) {
-      console.log(chalk8.green("No issues to fix!"));
+      console.log(chalk9.green("No issues to fix!"));
       return;
     }
     const issuesByFile = /* @__PURE__ */ new Map();
@@ -2955,16 +3391,16 @@ async function seoFix(options) {
     }
     let totalFixes = 0;
     for (const [file, fileIssues] of issuesByFile) {
-      const filePath = join7(process.cwd(), file);
+      const filePath = join8(process.cwd(), file);
       let content;
       try {
-        content = await readFile6(filePath, "utf-8");
+        content = await readFile7(filePath, "utf-8");
       } catch {
         continue;
       }
       const insertPoint = findHeadInsertionPoint(content);
       if (!insertPoint) {
-        console.log(chalk8.yellow(`  ${file}: No <head> tag found, skipping`));
+        console.log(chalk9.yellow(`  ${file}: No <head> tag found, skipping`));
         continue;
       }
       const tagsToAdd = [];
@@ -2983,33 +3419,33 @@ async function seoFix(options) {
       }
       if (tagsToAdd.length === 0) continue;
       const newContent = content.slice(0, insertPoint.index) + "\n" + tagsToAdd.map((tag) => insertPoint.indent + tag).join("\n") + content.slice(insertPoint.index);
-      console.log(chalk8.cyan(`
+      console.log(chalk9.cyan(`
   ${file}:`));
       for (const tag of tagsToAdd) {
-        console.log(chalk8.green(`    + ${tag.slice(0, 70)}${tag.length > 70 ? "..." : ""}`));
+        console.log(chalk9.green(`    + ${tag.slice(0, 70)}${tag.length > 70 ? "..." : ""}`));
       }
       if (!options.dryRun) {
-        const confirm = await prompt2.ask(chalk8.dim("    Apply these changes? (y/N): "));
+        const confirm = await prompt2.ask(chalk9.dim("    Apply these changes? (y/N): "));
         if (confirm.toLowerCase() === "y") {
-          await writeFile6(filePath, newContent);
+          await writeFile7(filePath, newContent);
           totalFixes += tagsToAdd.length;
-          console.log(chalk8.green("    \u2713 Applied"));
+          console.log(chalk9.green("    \u2713 Applied"));
         } else {
-          console.log(chalk8.dim("    Skipped"));
+          console.log(chalk9.dim("    Skipped"));
         }
       } else {
         totalFixes += tagsToAdd.length;
       }
     }
     if (totalFixes === 0) {
-      console.log(chalk8.dim("\nNo auto-fixable issues found. Some issues require manual configuration."));
+      console.log(chalk9.dim("\nNo auto-fixable issues found. Some issues require manual configuration."));
     } else if (options.dryRun) {
-      console.log(chalk8.yellow(`
+      console.log(chalk9.yellow(`
 ${totalFixes} fixes would be applied. Run without --dry-run to apply.`));
     } else {
-      console.log(chalk8.green(`
+      console.log(chalk9.green(`
 \u2705 Applied ${totalFixes} fixes.`));
-      console.log(chalk8.dim('Run "archon seo check" to verify fixes.'));
+      console.log(chalk9.dim('Run "archon seo check" to verify fixes.'));
     }
   } finally {
     prompt2.close();
@@ -3018,33 +3454,33 @@ ${totalFixes} fixes would be applied. Run without --dry-run to apply.`));
 async function seoOpenGraph(options) {
   const prompt2 = createPrompt3();
   try {
-    console.log(chalk8.blue("\n\u{1F4F1} Add Open Graph Tags\n"));
+    console.log(chalk9.blue("\n\u{1F4F1} Add Open Graph Tags\n"));
     let targetFile;
     if (options.file) {
-      targetFile = options.file.startsWith("/") ? options.file : join7(process.cwd(), options.file);
+      targetFile = options.file.startsWith("/") ? options.file : join8(process.cwd(), options.file);
     } else {
       const files = await getWebFiles();
       if (files.length === 0) {
-        console.log(chalk8.yellow("No web files found."));
+        console.log(chalk9.yellow("No web files found."));
         return;
       }
-      console.log(chalk8.dim("Available files:"));
+      console.log(chalk9.dim("Available files:"));
       files.slice(0, 10).forEach((f, i) => {
         console.log(`  ${i + 1}) ${f.replace(process.cwd() + "/", "")}`);
       });
       if (files.length > 10) {
-        console.log(chalk8.dim(`  ... and ${files.length - 10} more`));
+        console.log(chalk9.dim(`  ... and ${files.length - 10} more`));
       }
       const fileChoice = await prompt2.ask("\nEnter file path or number: ");
       const num = parseInt(fileChoice, 10);
       if (num > 0 && num <= files.length) {
         targetFile = files[num - 1] ?? "";
       } else {
-        targetFile = fileChoice.startsWith("/") ? fileChoice : join7(process.cwd(), fileChoice);
+        targetFile = fileChoice.startsWith("/") ? fileChoice : join8(process.cwd(), fileChoice);
       }
     }
-    if (!existsSync8(targetFile)) {
-      console.log(chalk8.red(`File not found: ${targetFile}`));
+    if (!existsSync9(targetFile)) {
+      console.log(chalk9.red(`File not found: ${targetFile}`));
       return;
     }
     const ogTitle = await prompt2.ask("og:title (page title for social): ");
@@ -3058,22 +3494,22 @@ async function seoOpenGraph(options) {
       `<meta property="og:image" content="${ogImage}">`,
       `<meta property="og:url" content="${ogUrl}">`
     ];
-    const content = await readFile6(targetFile, "utf-8");
+    const content = await readFile7(targetFile, "utf-8");
     const insertPoint = findHeadInsertionPoint(content);
     if (!insertPoint) {
-      console.log(chalk8.yellow("No <head> tag found. Add these tags manually:"));
-      tags.forEach((tag) => console.log(chalk8.cyan(`  ${tag}`)));
+      console.log(chalk9.yellow("No <head> tag found. Add these tags manually:"));
+      tags.forEach((tag) => console.log(chalk9.cyan(`  ${tag}`)));
       return;
     }
-    console.log(chalk8.dim("\nTags to add:"));
-    tags.forEach((tag) => console.log(chalk8.green(`  + ${tag}`)));
+    console.log(chalk9.dim("\nTags to add:"));
+    tags.forEach((tag) => console.log(chalk9.green(`  + ${tag}`)));
     const confirm = await prompt2.ask("\nApply changes? (y/N): ");
     if (confirm.toLowerCase() === "y") {
       const newContent = content.slice(0, insertPoint.index) + "\n" + tags.map((tag) => insertPoint.indent + tag).join("\n") + content.slice(insertPoint.index);
-      await writeFile6(targetFile, newContent);
-      console.log(chalk8.green("\n\u2705 Open Graph tags added."));
+      await writeFile7(targetFile, newContent);
+      console.log(chalk9.green("\n\u2705 Open Graph tags added."));
     } else {
-      console.log(chalk8.dim("Cancelled."));
+      console.log(chalk9.dim("Cancelled."));
     }
   } finally {
     prompt2.close();
@@ -3082,36 +3518,36 @@ async function seoOpenGraph(options) {
 async function seoTwitter(options) {
   const prompt2 = createPrompt3();
   try {
-    console.log(chalk8.blue("\n\u{1F426} Add Twitter Card Tags\n"));
+    console.log(chalk9.blue("\n\u{1F426} Add Twitter Card Tags\n"));
     let targetFile;
     if (options.file) {
-      targetFile = options.file.startsWith("/") ? options.file : join7(process.cwd(), options.file);
+      targetFile = options.file.startsWith("/") ? options.file : join8(process.cwd(), options.file);
     } else {
       const files = await getWebFiles();
       if (files.length === 0) {
-        console.log(chalk8.yellow("No web files found."));
+        console.log(chalk9.yellow("No web files found."));
         return;
       }
-      console.log(chalk8.dim("Available files:"));
+      console.log(chalk9.dim("Available files:"));
       files.slice(0, 10).forEach((f, i) => {
         console.log(`  ${i + 1}) ${f.replace(process.cwd() + "/", "")}`);
       });
       if (files.length > 10) {
-        console.log(chalk8.dim(`  ... and ${files.length - 10} more`));
+        console.log(chalk9.dim(`  ... and ${files.length - 10} more`));
       }
       const fileChoice = await prompt2.ask("\nEnter file path or number: ");
       const num = parseInt(fileChoice, 10);
       if (num > 0 && num <= files.length) {
         targetFile = files[num - 1] ?? "";
       } else {
-        targetFile = fileChoice.startsWith("/") ? fileChoice : join7(process.cwd(), fileChoice);
+        targetFile = fileChoice.startsWith("/") ? fileChoice : join8(process.cwd(), fileChoice);
       }
     }
-    if (!existsSync8(targetFile)) {
-      console.log(chalk8.red(`File not found: ${targetFile}`));
+    if (!existsSync9(targetFile)) {
+      console.log(chalk9.red(`File not found: ${targetFile}`));
       return;
     }
-    console.log(chalk8.dim("Card types: summary, summary_large_image, app, player"));
+    console.log(chalk9.dim("Card types: summary, summary_large_image, app, player"));
     const cardType = await prompt2.ask("twitter:card type (default: summary_large_image): ") || "summary_large_image";
     const twitterTitle = await prompt2.ask("twitter:title: ");
     const twitterDescription = await prompt2.ask("twitter:description: ");
@@ -3122,22 +3558,22 @@ async function seoTwitter(options) {
       `<meta name="twitter:description" content="${twitterDescription}">`,
       `<meta name="twitter:image" content="${twitterImage}">`
     ];
-    const content = await readFile6(targetFile, "utf-8");
+    const content = await readFile7(targetFile, "utf-8");
     const insertPoint = findHeadInsertionPoint(content);
     if (!insertPoint) {
-      console.log(chalk8.yellow("No <head> tag found. Add these tags manually:"));
-      tags.forEach((tag) => console.log(chalk8.cyan(`  ${tag}`)));
+      console.log(chalk9.yellow("No <head> tag found. Add these tags manually:"));
+      tags.forEach((tag) => console.log(chalk9.cyan(`  ${tag}`)));
       return;
     }
-    console.log(chalk8.dim("\nTags to add:"));
-    tags.forEach((tag) => console.log(chalk8.green(`  + ${tag}`)));
+    console.log(chalk9.dim("\nTags to add:"));
+    tags.forEach((tag) => console.log(chalk9.green(`  + ${tag}`)));
     const confirm = await prompt2.ask("\nApply changes? (y/N): ");
     if (confirm.toLowerCase() === "y") {
       const newContent = content.slice(0, insertPoint.index) + "\n" + tags.map((tag) => insertPoint.indent + tag).join("\n") + content.slice(insertPoint.index);
-      await writeFile6(targetFile, newContent);
-      console.log(chalk8.green("\n\u2705 Twitter Card tags added."));
+      await writeFile7(targetFile, newContent);
+      console.log(chalk9.green("\n\u2705 Twitter Card tags added."));
     } else {
-      console.log(chalk8.dim("Cancelled."));
+      console.log(chalk9.dim("Cancelled."));
     }
   } finally {
     prompt2.close();
@@ -3161,7 +3597,7 @@ Examples:
       await seoCheck(options);
       process.exit(0);
     } catch (error) {
-      console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+      console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
       process.exit(1);
     }
   });
@@ -3170,7 +3606,7 @@ Examples:
       await seoFix(options);
       process.exit(0);
     } catch (error) {
-      console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+      console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
       process.exit(1);
     }
   });
@@ -3179,7 +3615,7 @@ Examples:
       await seoOpenGraph(options);
       process.exit(0);
     } catch (error) {
-      console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+      console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
       process.exit(1);
     }
   });
@@ -3188,7 +3624,7 @@ Examples:
       await seoTwitter(options);
       process.exit(0);
     } catch (error) {
-      console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+      console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
       process.exit(1);
     }
   });
@@ -3196,12 +3632,12 @@ Examples:
 }
 
 // src/cli/session.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import ora2 from "ora";
 import os from "os";
-import { readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import { join as join8 } from "path";
+import { readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import { join as join9 } from "path";
 import { createClient as createClient2 } from "@supabase/supabase-js";
 function getSupabaseClient2(accessToken) {
   return createClient2(SUPABASE_URL, SUPABASE_ANON_KEY, {
@@ -3212,45 +3648,45 @@ function getDeviceName() {
   return `${os.hostname()}-${os.platform()}-${os.arch()}`;
 }
 async function getProjectInfo(cwd) {
-  const archonConfigPath = join8(cwd, ".archon", "config.yaml");
-  const packageJsonPath = join8(cwd, "package.json");
+  const archonConfigPath = join9(cwd, ".archon", "config.yaml");
+  const packageJsonPath = join9(cwd, "package.json");
   let projectName = "Unknown Project";
-  if (existsSync9(packageJsonPath)) {
+  if (existsSync10(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(await readFile7(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(await readFile8(packageJsonPath, "utf-8"));
       projectName = pkg.name || projectName;
     } catch {
     }
   }
-  if (!existsSync9(archonConfigPath)) {
+  if (!existsSync10(archonConfigPath)) {
     return null;
   }
   return { name: projectName, path: cwd };
 }
 async function getCurrentAtomId(cwd) {
-  const stateFile = join8(cwd, ".archon", "state.json");
-  if (!existsSync9(stateFile)) return null;
+  const stateFile = join9(cwd, ".archon", "state.json");
+  if (!existsSync10(stateFile)) return null;
   try {
-    const state = JSON.parse(await readFile7(stateFile, "utf-8"));
+    const state = JSON.parse(await readFile8(stateFile, "utf-8"));
     return state.currentAtomId || null;
   } catch {
     return null;
   }
 }
 async function getPendingAtoms(cwd) {
-  const stateFile = join8(cwd, ".archon", "state.json");
-  if (!existsSync9(stateFile)) return [];
+  const stateFile = join9(cwd, ".archon", "state.json");
+  if (!existsSync10(stateFile)) return [];
   try {
-    const state = JSON.parse(await readFile7(stateFile, "utf-8"));
+    const state = JSON.parse(await readFile8(stateFile, "utf-8"));
     return state.pendingAtoms || [];
   } catch {
     return [];
   }
 }
 async function getFileContent(path2) {
-  if (!existsSync9(path2)) return null;
+  if (!existsSync10(path2)) return null;
   try {
-    return await readFile7(path2, "utf-8");
+    return await readFile8(path2, "utf-8");
   } catch {
     return null;
   }
@@ -3277,8 +3713,8 @@ async function saveSession(name) {
     }
     const currentAtomId = await getCurrentAtomId(cwd);
     const pendingAtoms = await getPendingAtoms(cwd);
-    const progressSnapshot = await getFileContent(join8(cwd, "progress.txt"));
-    const architectureSnapshot = await getFileContent(join8(cwd, "ARCHITECTURE.md"));
+    const progressSnapshot = await getFileContent(join9(cwd, "progress.txt"));
+    const architectureSnapshot = await getFileContent(join9(cwd, "ARCHITECTURE.md"));
     const sessionData = {
       user_id: profile.id,
       project_name: name || projectInfo.name,
@@ -3295,13 +3731,13 @@ async function saveSession(name) {
       spinner.fail(`Failed to save session: ${error.message}`);
       return;
     }
-    spinner.succeed(chalk9.green("Session saved!"));
+    spinner.succeed(chalk10.green("Session saved!"));
     console.log();
-    console.log(`  ID:      ${chalk9.cyan(session.id)}`);
+    console.log(`  ID:      ${chalk10.cyan(session.id)}`);
     console.log(`  Project: ${session.project_name}`);
     console.log(`  Device:  ${session.last_device}`);
     console.log();
-    console.log(chalk9.dim("  Resume on another device: archon session resume " + session.id));
+    console.log(chalk10.dim("  Resume on another device: archon session resume " + session.id));
     console.log();
   } catch (err) {
     spinner.fail("Error saving session");
@@ -3329,23 +3765,23 @@ async function listSessions() {
     }
     spinner.stop();
     if (!sessions || sessions.length === 0) {
-      console.log(chalk9.yellow("\nNo saved sessions found.\n"));
-      console.log(chalk9.dim("  Save a session: archon session save [name]\n"));
+      console.log(chalk10.yellow("\nNo saved sessions found.\n"));
+      console.log(chalk10.dim("  Save a session: archon session save [name]\n"));
       return;
     }
     console.log();
-    console.log(chalk9.bold("\u{1F4C2} Saved Sessions"));
+    console.log(chalk10.bold("\u{1F4C2} Saved Sessions"));
     console.log();
     for (const session of sessions) {
       const date = new Date(session.updated_at).toLocaleDateString();
-      const atomInfo = session.current_atom_id ? chalk9.dim(` (atom: ${session.current_atom_id})`) : "";
+      const atomInfo = session.current_atom_id ? chalk10.dim(` (atom: ${session.current_atom_id})`) : "";
       console.log(
-        `  ${chalk9.cyan(session.id.slice(0, 8))}  ${session.project_name}${atomInfo}`
+        `  ${chalk10.cyan(session.id.slice(0, 8))}  ${session.project_name}${atomInfo}`
       );
-      console.log(chalk9.dim(`           ${date} from ${session.last_device || "unknown device"}`));
+      console.log(chalk10.dim(`           ${date} from ${session.last_device || "unknown device"}`));
       console.log();
     }
-    console.log(chalk9.dim("  Resume: archon session resume <id>\n"));
+    console.log(chalk10.dim("  Resume: archon session resume <id>\n"));
   } catch (err) {
     spinner.fail("Error fetching sessions");
     console.error(err);
@@ -3372,30 +3808,30 @@ async function resumeSession(sessionId) {
       return;
     }
     const session = sessions[0];
-    const stateFile = join8(cwd, ".archon", "state.json");
+    const stateFile = join9(cwd, ".archon", "state.json");
     const state = {
       currentAtomId: session.current_atom_id,
       pendingAtoms: session.pending_atoms,
       resumedFrom: session.id,
       resumedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await writeFile7(stateFile, JSON.stringify(state, null, 2));
+    await writeFile8(stateFile, JSON.stringify(state, null, 2));
     if (session.progress_snapshot) {
-      const progressPath = join8(cwd, "progress.txt");
-      await writeFile7(progressPath, session.progress_snapshot);
+      const progressPath = join9(cwd, "progress.txt");
+      await writeFile8(progressPath, session.progress_snapshot);
     }
     if (session.architecture_snapshot) {
-      const archPath = join8(cwd, "ARCHITECTURE.md");
-      await writeFile7(archPath, session.architecture_snapshot);
+      const archPath = join9(cwd, "ARCHITECTURE.md");
+      await writeFile8(archPath, session.architecture_snapshot);
     }
     await supabase.from("sessions").update({ last_device: getDeviceName(), updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", session.id);
-    spinner.succeed(chalk9.green("Session resumed!"));
+    spinner.succeed(chalk10.green("Session resumed!"));
     console.log();
     console.log(`  Project:      ${session.project_name}`);
     console.log(`  Current Atom: ${session.current_atom_id || "none"}`);
     console.log(`  Pending:      ${session.pending_atoms.length} atoms`);
     console.log();
-    console.log(chalk9.dim("  Continue working: archon start"));
+    console.log(chalk10.dim("  Continue working: archon start"));
     console.log();
   } catch (err) {
     spinner.fail("Error resuming session");
@@ -3411,12 +3847,12 @@ async function syncSession() {
       spinner.fail("Not logged in. Run: archon login");
       return;
     }
-    const stateFile = join8(cwd, ".archon", "state.json");
-    if (!existsSync9(stateFile)) {
+    const stateFile = join9(cwd, ".archon", "state.json");
+    if (!existsSync10(stateFile)) {
       spinner.info("No active session to sync");
       return;
     }
-    const state = JSON.parse(await readFile7(stateFile, "utf-8"));
+    const state = JSON.parse(await readFile8(stateFile, "utf-8"));
     if (!state.resumedFrom) {
       spinner.info('Session was not resumed from cloud - use "archon session save" to create one');
       return;
@@ -3424,8 +3860,8 @@ async function syncSession() {
     const supabase = getSupabaseClient2(config.accessToken);
     const currentAtomId = await getCurrentAtomId(cwd);
     const pendingAtoms = await getPendingAtoms(cwd);
-    const progressSnapshot = await getFileContent(join8(cwd, "progress.txt"));
-    const architectureSnapshot = await getFileContent(join8(cwd, "ARCHITECTURE.md"));
+    const progressSnapshot = await getFileContent(join9(cwd, "progress.txt"));
+    const architectureSnapshot = await getFileContent(join9(cwd, "ARCHITECTURE.md"));
     const { error } = await supabase.from("sessions").update({
       current_atom_id: currentAtomId,
       pending_atoms: pendingAtoms,
@@ -3438,7 +3874,7 @@ async function syncSession() {
       spinner.fail(`Failed to sync: ${error.message}`);
       return;
     }
-    spinner.succeed(chalk9.green("Session synced to cloud"));
+    spinner.succeed(chalk10.green("Session synced to cloud"));
   } catch (err) {
     spinner.fail("Error syncing session");
     console.error(err);
@@ -3446,66 +3882,66 @@ async function syncSession() {
 }
 
 // src/cli/deploy.ts
-import chalk10 from "chalk";
-import { existsSync as existsSync10 } from "fs";
-import { join as join9 } from "path";
-import { execSync } from "child_process";
+import chalk11 from "chalk";
+import { existsSync as existsSync11 } from "fs";
+import { join as join10 } from "path";
+import { execSync as execSync2 } from "child_process";
 function detectPlatform(cwd) {
-  if (existsSync10(join9(cwd, "fly.toml"))) return "fly";
-  if (existsSync10(join9(cwd, "vercel.json"))) return "vercel";
-  if (existsSync10(join9(cwd, "netlify.toml"))) return "netlify";
-  if (existsSync10(join9(cwd, "railway.json"))) return "railway";
-  if (existsSync10(join9(cwd, "render.yaml"))) return "render";
-  if (existsSync10(join9(cwd, "Dockerfile"))) return "fly";
+  if (existsSync11(join10(cwd, "fly.toml"))) return "fly";
+  if (existsSync11(join10(cwd, "vercel.json"))) return "vercel";
+  if (existsSync11(join10(cwd, "netlify.toml"))) return "netlify";
+  if (existsSync11(join10(cwd, "railway.json"))) return "railway";
+  if (existsSync11(join10(cwd, "render.yaml"))) return "render";
+  if (existsSync11(join10(cwd, "Dockerfile"))) return "fly";
   return "unknown";
 }
 async function deploy(options) {
   const cwd = process.cwd();
-  console.log(chalk10.blue("Running pre-deploy checks..."));
+  console.log(chalk11.blue("Running pre-deploy checks..."));
   const platform = options.platform ?? detectPlatform(cwd);
-  console.log(chalk10.dim(`Detected platform: ${platform}`));
+  console.log(chalk11.dim(`Detected platform: ${platform}`));
   if (options.dryRun) {
-    console.log(chalk10.dim("Dry run mode - would deploy to:"), platform);
+    console.log(chalk11.dim("Dry run mode - would deploy to:"), platform);
     return;
   }
   switch (platform) {
     case "fly":
-      console.log(chalk10.blue("Deploying to Fly.io..."));
-      execSync("fly deploy", { cwd, stdio: "inherit" });
+      console.log(chalk11.blue("Deploying to Fly.io..."));
+      execSync2("fly deploy", { cwd, stdio: "inherit" });
       break;
     case "vercel": {
-      console.log(chalk10.blue("Deploying to Vercel..."));
+      console.log(chalk11.blue("Deploying to Vercel..."));
       const cmd = options.preview ? "vercel" : "vercel --prod";
-      execSync(cmd, { cwd, stdio: "inherit" });
+      execSync2(cmd, { cwd, stdio: "inherit" });
       break;
     }
     case "netlify": {
-      console.log(chalk10.blue("Deploying to Netlify..."));
+      console.log(chalk11.blue("Deploying to Netlify..."));
       const netlifyCmd = options.preview ? "netlify deploy" : "netlify deploy --prod";
-      execSync(netlifyCmd, { cwd, stdio: "inherit" });
+      execSync2(netlifyCmd, { cwd, stdio: "inherit" });
       break;
     }
     case "railway":
-      console.log(chalk10.blue("Deploying to Railway..."));
-      execSync("railway up", { cwd, stdio: "inherit" });
+      console.log(chalk11.blue("Deploying to Railway..."));
+      execSync2("railway up", { cwd, stdio: "inherit" });
       break;
     case "render":
-      console.log(chalk10.blue("Deploying to Render..."));
-      console.log(chalk10.yellow("Render deploys via git push. Push to your connected branch."));
+      console.log(chalk11.blue("Deploying to Render..."));
+      console.log(chalk11.yellow("Render deploys via git push. Push to your connected branch."));
       break;
     default:
-      console.log(chalk10.yellow("Platform not detected. Please specify with --platform"));
-      console.log(chalk10.dim("Supported: fly, vercel, netlify, railway, render"));
+      console.log(chalk11.yellow("Platform not detected. Please specify with --platform"));
+      console.log(chalk11.dim("Supported: fly, vercel, netlify, railway, render"));
   }
 }
 
 // src/cli/index-cmd.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 
 // src/core/indexing/local.ts
-import { existsSync as existsSync11, mkdirSync } from "fs";
-import { readFile as readFile8 } from "fs/promises";
-import { join as join10, extname } from "path";
+import { existsSync as existsSync12, mkdirSync } from "fs";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join11, extname } from "path";
 import Database from "better-sqlite3";
 var CHUNK_SIZE = 1e3;
 var CHUNK_OVERLAP = 200;
@@ -3552,11 +3988,11 @@ var LocalIndexer = class {
     };
   }
   async init(cwd) {
-    const archonDir = join10(cwd, ".archon");
-    if (!existsSync11(archonDir)) {
+    const archonDir = join11(cwd, ".archon");
+    if (!existsSync12(archonDir)) {
       mkdirSync(archonDir, { recursive: true });
     }
-    this.db = new Database(join10(cwd, this.config.dbPath));
+    this.db = new Database(join11(cwd, this.config.dbPath));
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS embeddings (
         id INTEGER PRIMARY KEY,
@@ -3606,11 +4042,11 @@ var LocalIndexer = class {
     if (!this.isIndexableFile(filePath)) {
       return 0;
     }
-    const fullPath = join10(cwd, filePath);
-    if (!existsSync11(fullPath)) {
+    const fullPath = join11(cwd, filePath);
+    if (!existsSync12(fullPath)) {
       return 0;
     }
-    const content = await readFile8(fullPath, "utf-8");
+    const content = await readFile9(fullPath, "utf-8");
     const chunks = this.chunkText(content);
     const deleteStmt = this.db.prepare("DELETE FROM embeddings WHERE file_path = ?");
     deleteStmt.run(filePath);
@@ -3686,16 +4122,287 @@ var LocalIndexer = class {
   }
 };
 
+// src/core/indexing/cloud.ts
+import { createClient as createClient3 } from "@supabase/supabase-js";
+import { readFile as readFile10 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import { join as join12, extname as extname2 } from "path";
+import { createHash } from "crypto";
+var CHUNK_SIZE2 = 1e3;
+var CHUNK_OVERLAP2 = 200;
+var INDEXABLE_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".swift",
+  ".kt",
+  ".scala",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".html",
+  ".css",
+  ".scss",
+  ".less",
+  ".vue",
+  ".svelte"
+]);
+var CloudIndexer = class {
+  config;
+  client;
+  userId = null;
+  constructor(config) {
+    this.config = config;
+    this.client = createClient3(config.supabaseUrl, config.supabaseKey);
+  }
+  /**
+   * Set the authenticated user ID
+   */
+  setUserId(userId) {
+    this.userId = userId;
+  }
+  /**
+   * Generate embedding using OpenAI API
+   */
+  async embedText(text) {
+    if (this.config.embeddingProvider === "openai") {
+      return this.embedWithOpenAI(text);
+    }
+    throw new Error(`Unsupported embedding provider: ${this.config.embeddingProvider}`);
+  }
+  async embedWithOpenAI(text) {
+    const response = await fetch("https://api.openai.com/v1/embeddings", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.config.embeddingApiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "text-embedding-ada-002",
+        input: text.slice(0, 8e3)
+        // Limit input size
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`OpenAI embedding failed: ${error.error?.message ?? response.statusText}`);
+    }
+    const data = await response.json();
+    const embedding = data.data[0]?.embedding;
+    if (!embedding) {
+      throw new Error("No embedding returned from OpenAI");
+    }
+    return embedding;
+  }
+  /**
+   * Chunk text into smaller pieces for embedding
+   */
+  chunkText(text, filePath) {
+    const chunks = [];
+    const header = `File: ${filePath}
+
+`;
+    let start2 = 0;
+    let index = 0;
+    while (start2 < text.length) {
+      const end = Math.min(start2 + CHUNK_SIZE2, text.length);
+      const chunkText = index === 0 ? header + text.slice(start2, end) : text.slice(start2, end);
+      if (chunkText.trim().length > 0) {
+        chunks.push({ text: chunkText, index });
+        index++;
+      }
+      start2 += CHUNK_SIZE2 - CHUNK_OVERLAP2;
+    }
+    return chunks;
+  }
+  /**
+   * Check if file should be indexed
+   */
+  isIndexableFile(filePath) {
+    const ext = extname2(filePath).toLowerCase();
+    return INDEXABLE_EXTENSIONS2.has(ext);
+  }
+  /**
+   * Compute file hash for change detection
+   */
+  async computeFileHash(content) {
+    return createHash("sha256").update(content).digest("hex").slice(0, 16);
+  }
+  /**
+   * Index a single file
+   */
+  async indexFile(cwd, filePath) {
+    if (!this.userId) {
+      throw new Error("User ID not set. Call setUserId() first.");
+    }
+    if (!this.isIndexableFile(filePath)) {
+      return 0;
+    }
+    const fullPath = join12(cwd, filePath);
+    if (!existsSync13(fullPath)) {
+      return 0;
+    }
+    const content = await readFile10(fullPath, "utf-8");
+    const fileHash = await this.computeFileHash(content);
+    const { data: existing } = await this.client.from("code_embeddings").select("file_hash").eq("user_id", this.userId).eq("project_id", this.config.projectId).eq("file_path", filePath).eq("chunk_index", 0).single();
+    if (existing && existing.file_hash === fileHash) {
+      return 0;
+    }
+    await this.client.from("code_embeddings").delete().eq("user_id", this.userId).eq("project_id", this.config.projectId).eq("file_path", filePath);
+    const chunks = this.chunkText(content, filePath);
+    for (const chunk of chunks) {
+      const embedding = await this.embedText(chunk.text);
+      const embeddingStr = `[${embedding.join(",")}]`;
+      await this.client.from("code_embeddings").insert({
+        user_id: this.userId,
+        project_id: this.config.projectId,
+        file_path: filePath,
+        chunk_index: chunk.index,
+        chunk_text: chunk.text,
+        embedding: embeddingStr,
+        file_hash: fileHash
+      });
+    }
+    return chunks.length;
+  }
+  /**
+   * Search for similar code
+   */
+  async search(query, limit = 10) {
+    if (!this.userId) {
+      throw new Error("User ID not set. Call setUserId() first.");
+    }
+    const queryEmbedding = await this.embedText(query);
+    const embeddingStr = `[${queryEmbedding.join(",")}]`;
+    const { data, error } = await this.client.rpc("search_code_embeddings", {
+      p_user_id: this.userId,
+      p_project_id: this.config.projectId,
+      p_query_embedding: embeddingStr,
+      p_limit: limit
+    });
+    if (error) {
+      throw new Error(`Search failed: ${error.message}`);
+    }
+    return (data ?? []).map((row) => ({
+      file: row.file_path,
+      text: row.chunk_text,
+      score: row.similarity
+    }));
+  }
+  /**
+   * Get indexing status for project
+   */
+  async getStatus() {
+    if (!this.userId) {
+      throw new Error("User ID not set. Call setUserId() first.");
+    }
+    const { data: fileCount } = await this.client.from("code_embeddings").select("file_path", { count: "exact", head: true }).eq("user_id", this.userId).eq("project_id", this.config.projectId);
+    const { data: chunkCount } = await this.client.from("code_embeddings").select("id", { count: "exact", head: true }).eq("user_id", this.userId).eq("project_id", this.config.projectId);
+    const { data: lastUpdated } = await this.client.from("code_embeddings").select("updated_at").eq("user_id", this.userId).eq("project_id", this.config.projectId).order("updated_at", { ascending: false }).limit(1).single();
+    const { data: job } = await this.client.from("indexing_jobs").select("status").eq("user_id", this.userId).eq("project_id", this.config.projectId).order("created_at", { ascending: false }).limit(1).single();
+    return {
+      projectId: this.config.projectId,
+      fileCount: fileCount?.count ?? 0,
+      chunkCount: chunkCount?.count ?? 0,
+      lastUpdated: lastUpdated?.updated_at ?? null,
+      jobStatus: job?.status
+    };
+  }
+  /**
+   * Remove all embeddings for this project
+   */
+  async clearProject() {
+    if (!this.userId) {
+      throw new Error("User ID not set. Call setUserId() first.");
+    }
+    await this.client.from("code_embeddings").delete().eq("user_id", this.userId).eq("project_id", this.config.projectId);
+  }
+  /**
+   * Remove a single file from the index
+   */
+  async removeFile(filePath) {
+    if (!this.userId) {
+      throw new Error("User ID not set. Call setUserId() first.");
+    }
+    await this.client.from("code_embeddings").delete().eq("user_id", this.userId).eq("project_id", this.config.projectId).eq("file_path", filePath);
+  }
+};
+
 // src/cli/index-cmd.ts
 import { glob as glob4 } from "glob";
-import { join as join11 } from "path";
+import { join as join13, basename } from "path";
+async function getCloudIndexer(cwd) {
+  const config = await loadConfig();
+  const authToken = getAuthToken(config);
+  if (!authToken) {
+    console.error(chalk12.red('Not authenticated. Run "archon login" first.'));
+    return null;
+  }
+  const openaiKey = process.env["OPENAI_API_KEY"];
+  if (!openaiKey) {
+    console.error(chalk12.red("OPENAI_API_KEY environment variable not set."));
+    console.log(chalk12.dim("Cloud indexing requires an OpenAI API key for embeddings."));
+    console.log(chalk12.dim("Set it with: export OPENAI_API_KEY=sk-..."));
+    return null;
+  }
+  const projectId = basename(cwd);
+  const indexer = new CloudIndexer({
+    supabaseUrl: SUPABASE_URL,
+    supabaseKey: SUPABASE_ANON_KEY,
+    embeddingProvider: "openai",
+    embeddingApiKey: openaiKey,
+    projectId
+  });
+  const { createClient: createClient4 } = await import("@supabase/supabase-js");
+  const client = createClient4(SUPABASE_URL, SUPABASE_ANON_KEY, {
+    global: { headers: { Authorization: `Bearer ${authToken}` } }
+  });
+  const { data: { user } } = await client.auth.getUser();
+  if (!user) {
+    console.error(chalk12.red("Failed to get user. Try logging in again."));
+    return null;
+  }
+  const { data: profile } = await client.from("user_profiles").select("id").eq("auth_id", user.id).single();
+  if (!profile) {
+    console.error(chalk12.red("User profile not found."));
+    return null;
+  }
+  indexer.setUserId(profile.id);
+  return indexer;
+}
 async function indexInit(options) {
   const cwd = process.cwd();
   if (options.cloud) {
-    console.log(chalk11.yellow("Cloud indexing is not yet implemented. Use --local for Ollama-based indexing."));
+    console.log(chalk12.blue("Initializing cloud semantic index..."));
+    const indexer = await getCloudIndexer(cwd);
+    if (!indexer) return;
+    try {
+      const status2 = await indexer.getStatus();
+      console.log(chalk12.green("\u2713 Cloud indexing configured"));
+      console.log(chalk12.green(`\u2713 Project ID: ${status2.projectId}`));
+      console.log(chalk12.dim("\nRun `archon index update --cloud` to index your codebase."));
+    } catch (error) {
+      console.error(chalk12.red(`Failed to initialize cloud index: ${error instanceof Error ? error.message : String(error)}`));
+      process.exit(1);
+    }
     return;
   }
-  console.log(chalk11.blue("Initializing local semantic index..."));
+  console.log(chalk12.blue("Initializing local semantic index..."));
   try {
     const indexer = new LocalIndexer();
     await indexer.init(cwd);
@@ -3703,24 +4410,67 @@ async function indexInit(options) {
     if (!response.ok) {
       throw new Error("Ollama not responding");
     }
-    console.log(chalk11.green("\u2713 Ollama connection verified"));
-    console.log(chalk11.green("\u2713 Index database created at .archon/index.db"));
-    console.log(chalk11.dim("\nRun `archon index update` to index your codebase."));
+    console.log(chalk12.green("\u2713 Ollama connection verified"));
+    console.log(chalk12.green("\u2713 Index database created at .archon/index.db"));
+    console.log(chalk12.dim("\nRun `archon index update` to index your codebase."));
     indexer.close();
   } catch (error) {
     if (error instanceof Error && error.message.includes("Ollama")) {
-      console.log(chalk11.red("\n\u2717 Ollama is not running"));
-      console.log(chalk11.dim("Start Ollama with: ollama serve"));
-      console.log(chalk11.dim("Then pull the embedding model: ollama pull nomic-embed-text"));
+      console.log(chalk12.red("\n\u2717 Ollama is not running"));
+      console.log(chalk12.dim("Start Ollama with: ollama serve"));
+      console.log(chalk12.dim("Then pull the embedding model: ollama pull nomic-embed-text"));
+      console.log(chalk12.dim("\nOr use cloud indexing: archon index init --cloud"));
     } else {
-      console.error(chalk11.red(`Failed to initialize index: ${error instanceof Error ? error.message : String(error)}`));
+      console.error(chalk12.red(`Failed to initialize index: ${error instanceof Error ? error.message : String(error)}`));
     }
     process.exit(1);
   }
 }
-async function indexUpdate() {
+async function indexUpdate(options) {
   const cwd = process.cwd();
-  console.log(chalk11.blue("Updating semantic index..."));
+  if (options?.cloud) {
+    console.log(chalk12.blue("Updating cloud semantic index..."));
+    const indexer = await getCloudIndexer(cwd);
+    if (!indexer) return;
+    try {
+      const files = await glob4("**/*.{ts,tsx,js,jsx,py,rb,go,rs,java,md,json,yaml,yml}", {
+        cwd,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/build/**", "**/coverage/**"]
+      });
+      console.log(chalk12.dim(`Found ${files.length} files to index...`));
+      console.log(chalk12.dim("This may take a few minutes and will use OpenAI API credits.\n"));
+      let totalChunks = 0;
+      let indexedFiles = 0;
+      let skippedFiles = 0;
+      for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        if (!file) continue;
+        process.stdout.write(`\r${chalk12.dim(`[${i + 1}/${files.length}] ${file.slice(0, 45).padEnd(45)}`)}`);
+        try {
+          const chunks = await indexer.indexFile(cwd, file);
+          if (chunks > 0) {
+            totalChunks += chunks;
+            indexedFiles++;
+          } else {
+            skippedFiles++;
+          }
+        } catch (error) {
+          console.log(`
+${chalk12.yellow(`\u26A0 Skipped ${file}: ${error instanceof Error ? error.message : "Unknown error"}`)}`);
+        }
+      }
+      console.log("\r" + " ".repeat(70));
+      console.log(chalk12.green(`\u2713 Indexed ${indexedFiles} files (${totalChunks} chunks)`));
+      if (skippedFiles > 0) {
+        console.log(chalk12.dim(`  Skipped ${skippedFiles} unchanged files`));
+      }
+    } catch (error) {
+      console.error(chalk12.red(`Failed to update cloud index: ${error instanceof Error ? error.message : String(error)}`));
+      process.exit(1);
+    }
+    return;
+  }
+  console.log(chalk12.blue("Updating local semantic index..."));
   try {
     const indexer = new LocalIndexer();
     await indexer.init(cwd);
@@ -3728,11 +4478,12 @@ async function indexUpdate() {
       cwd,
       ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/build/**", "**/coverage/**"]
     });
-    console.log(chalk11.dim(`Found ${files.length} files to index...`));
+    console.log(chalk12.dim(`Found ${files.length} files to index...`));
     let totalChunks = 0;
     let indexedFiles = 0;
     for (const file of files) {
-      process.stdout.write(`\r${chalk11.dim(`Indexing: ${file.slice(0, 50).padEnd(50)}`)}`);
+      if (!file) continue;
+      process.stdout.write(`\r${chalk12.dim(`Indexing: ${file.slice(0, 50).padEnd(50)}`)}`);
       const chunks = await indexer.indexFile(cwd, file);
       if (chunks > 0) {
         totalChunks += chunks;
@@ -3740,54 +4491,211 @@ async function indexUpdate() {
       }
     }
     console.log("\r" + " ".repeat(60));
-    console.log(chalk11.green(`\u2713 Indexed ${indexedFiles} files (${totalChunks} chunks)`));
+    console.log(chalk12.green(`\u2713 Indexed ${indexedFiles} files (${totalChunks} chunks)`));
     indexer.close();
   } catch (error) {
-    console.error(chalk11.red(`Failed to update index: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk12.red(`Failed to update index: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
   }
 }
-async function indexSearch(query) {
+async function indexSearch(query, options) {
   const cwd = process.cwd();
+  if (options?.cloud) {
+    const indexer = await getCloudIndexer(cwd);
+    if (!indexer) return;
+    try {
+      console.log(chalk12.dim("Searching cloud index..."));
+      const results = await indexer.search(query, 10);
+      if (results.length === 0) {
+        console.log(chalk12.yellow("\nNo results found."));
+        console.log(chalk12.dim("Try running `archon index update --cloud` first."));
+      } else {
+        console.log(chalk12.blue(`
+Top ${results.length} results for: "${query}"
+`));
+        for (const result of results) {
+          const score = (result.score * 100).toFixed(1);
+          console.log(chalk12.green(`[${score}%] ${result.file}`));
+          const preview = result.text.slice(0, 200).replace(/\n/g, " ").trim();
+          console.log(chalk12.dim(`  ${preview}${result.text.length > 200 ? "..." : ""}`));
+          console.log();
+        }
+      }
+    } catch (error) {
+      console.error(chalk12.red(`Cloud search failed: ${error instanceof Error ? error.message : String(error)}`));
+      process.exit(1);
+    }
+    return;
+  }
   try {
     const indexer = new LocalIndexer();
     await indexer.init(cwd);
     const results = await indexer.search(query, 10);
     if (results.length === 0) {
-      console.log(chalk11.yellow("No results found."));
-      console.log(chalk11.dim("Try running `archon index update` first."));
+      console.log(chalk12.yellow("No results found."));
+      console.log(chalk12.dim("Try running `archon index update` first."));
     } else {
-      console.log(chalk11.blue(`
+      console.log(chalk12.blue(`
 Top ${results.length} results for: "${query}"
 `));
       for (const result of results) {
         const score = (result.score * 100).toFixed(1);
-        console.log(chalk11.green(`[${score}%] ${result.file}`));
+        console.log(chalk12.green(`[${score}%] ${result.file}`));
         const preview = result.text.slice(0, 200).replace(/\n/g, " ").trim();
-        console.log(chalk11.dim(`  ${preview}${result.text.length > 200 ? "..." : ""}`));
+        console.log(chalk12.dim(`  ${preview}${result.text.length > 200 ? "..." : ""}`));
         console.log();
       }
     }
     indexer.close();
   } catch (error) {
-    console.error(chalk11.red(`Search failed: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk12.red(`Search failed: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
   }
 }
-async function indexStatus() {
+async function indexStatus(options) {
   const cwd = process.cwd();
+  if (options?.cloud) {
+    const indexer = await getCloudIndexer(cwd);
+    if (!indexer) return;
+    try {
+      const status2 = await indexer.getStatus();
+      console.log(chalk12.blue("\nCloud Semantic Index Status\n"));
+      console.log(`  Project ID:     ${chalk12.green(status2.projectId)}`);
+      console.log(`  Files indexed:  ${chalk12.green(status2.fileCount)}`);
+      console.log(`  Total chunks:   ${chalk12.green(status2.chunkCount)}`);
+      console.log(`  Last updated:   ${status2.lastUpdated ? chalk12.dim(status2.lastUpdated) : chalk12.yellow("Never")}`);
+      if (status2.jobStatus) {
+        console.log(`  Job status:     ${chalk12.dim(status2.jobStatus)}`);
+      }
+      console.log(`  Storage:        ${chalk12.dim("Supabase pgvector")}`);
+    } catch (error) {
+      console.error(chalk12.red(`Failed to get cloud status: ${error instanceof Error ? error.message : String(error)}`));
+      process.exit(1);
+    }
+    return;
+  }
   try {
     const indexer = new LocalIndexer();
     await indexer.init(cwd);
     const status2 = await indexer.getStatus();
-    console.log(chalk11.blue("\nSemantic Index Status\n"));
-    console.log(`  Files indexed:  ${chalk11.green(status2.fileCount)}`);
-    console.log(`  Total chunks:   ${chalk11.green(status2.chunkCount)}`);
-    console.log(`  Last updated:   ${status2.lastUpdated ? chalk11.dim(status2.lastUpdated) : chalk11.yellow("Never")}`);
-    console.log(`  Database:       ${chalk11.dim(join11(cwd, ".archon/index.db"))}`);
+    console.log(chalk12.blue("\nLocal Semantic Index Status\n"));
+    console.log(`  Files indexed:  ${chalk12.green(status2.fileCount)}`);
+    console.log(`  Total chunks:   ${chalk12.green(status2.chunkCount)}`);
+    console.log(`  Last updated:   ${status2.lastUpdated ? chalk12.dim(status2.lastUpdated) : chalk12.yellow("Never")}`);
+    console.log(`  Database:       ${chalk12.dim(join13(cwd, ".archon/index.db"))}`);
     indexer.close();
   } catch (error) {
-    console.error(chalk11.red(`Failed to get status: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk12.red(`Failed to get status: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function indexClear(options) {
+  const cwd = process.cwd();
+  if (options?.cloud) {
+    const indexer = await getCloudIndexer(cwd);
+    if (!indexer) return;
+    try {
+      console.log(chalk12.yellow("Clearing cloud index..."));
+      await indexer.clearProject();
+      console.log(chalk12.green("\u2713 Cloud index cleared"));
+    } catch (error) {
+      console.error(chalk12.red(`Failed to clear cloud index: ${error instanceof Error ? error.message : String(error)}`));
+      process.exit(1);
+    }
+    return;
+  }
+  console.log(chalk12.yellow("To clear local index, delete .archon/index.db"));
+}
+
+// src/cli/github.ts
+import chalk13 from "chalk";
+import open2 from "open";
+var API_URL2 = process.env["ARCHONDEV_API_URL"] ?? "https://archondev-api.fly.dev";
+async function githubConnect() {
+  const config = await loadConfig();
+  const authToken = getAuthToken(config);
+  if (!authToken) {
+    console.error(chalk13.red('Not authenticated. Run "archon login" first.'));
+    process.exit(1);
+  }
+  console.log(chalk13.dim("Starting GitHub connection..."));
+  try {
+    const response = await fetch(`${API_URL2}/api/github/connect`, {
+      headers: {
+        "Authorization": `Bearer ${authToken}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      console.error(chalk13.red(error.error ?? "Failed to start GitHub connection"));
+      process.exit(1);
+    }
+    const data = await response.json();
+    console.log(chalk13.dim("\nOpening browser for GitHub authorization..."));
+    console.log(chalk13.dim("If browser does not open, visit:"));
+    console.log(chalk13.blue(data.url));
+    await open2(data.url);
+    console.log(chalk13.dim("\nComplete the authorization in your browser."));
+    console.log(chalk13.dim('Then run "archon github status" to verify connection.'));
+  } catch (error) {
+    console.error(chalk13.red(error instanceof Error ? error.message : "Failed to connect"));
+    process.exit(1);
+  }
+}
+async function githubStatus() {
+  const config = await loadConfig();
+  const authToken = getAuthToken(config);
+  if (!authToken) {
+    console.error(chalk13.red('Not authenticated. Run "archon login" first.'));
+    process.exit(1);
+  }
+  try {
+    const response = await fetch(`${API_URL2}/api/github/status`, {
+      headers: {
+        "Authorization": `Bearer ${authToken}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      console.error(chalk13.red(error.error ?? "Failed to get GitHub status"));
+      process.exit(1);
+    }
+    const data = await response.json();
+    if (data.connected) {
+      console.log(chalk13.green("\u2713 GitHub connected"));
+      console.log(chalk13.dim(`  Username: ${data.username}`));
+      console.log(chalk13.dim(`  Connected: ${data.connectedAt ? new Date(data.connectedAt).toLocaleDateString() : "Unknown"}`));
+    } else {
+      console.log(chalk13.yellow("GitHub not connected"));
+      console.log(chalk13.dim('Run "archon github connect" to connect your GitHub account.'));
+    }
+  } catch (error) {
+    console.error(chalk13.red(error instanceof Error ? error.message : "Failed to get status"));
+    process.exit(1);
+  }
+}
+async function githubDisconnect() {
+  const config = await loadConfig();
+  const authToken = getAuthToken(config);
+  if (!authToken) {
+    console.error(chalk13.red('Not authenticated. Run "archon login" first.'));
+    process.exit(1);
+  }
+  try {
+    const response = await fetch(`${API_URL2}/api/github/disconnect`, {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${authToken}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      console.error(chalk13.red(error.error ?? "Failed to disconnect GitHub"));
+      process.exit(1);
+    }
+    console.log(chalk13.green("\u2713 GitHub disconnected"));
+  } catch (error) {
+    console.error(chalk13.red(error instanceof Error ? error.message : "Failed to disconnect"));
     process.exit(1);
   }
 }
@@ -3797,7 +4705,7 @@ var program = new Command4();
 program.name("archon").description("Local-first AI-powered development governance").version("1.1.0").action(async () => {
   const cwd = process.cwd();
   if (!isInitialized(cwd)) {
-    console.log(chalk12.blue("\nArchonDev is not initialized in this folder.\n"));
+    console.log(chalk14.blue("\nArchonDev is not initialized in this folder.\n"));
     await init({ analyze: true, git: true });
   }
   await start();
@@ -3805,7 +4713,7 @@ program.name("archon").description("Local-first AI-powered development governanc
 program.command("login").description("Authenticate with ArchonDev").option("-p, --provider <provider>", "OAuth provider (github or google)", "github").action(async (options) => {
   const provider = options.provider;
   if (provider !== "github" && provider !== "google") {
-    console.error(chalk12.red('Invalid provider. Use "github" or "google"'));
+    console.error(chalk14.red('Invalid provider. Use "github" or "google"'));
     process.exit(1);
   }
   await login(provider);
@@ -3953,11 +4861,12 @@ a11yCommand.action(async () => {
 program.addCommand(createSeoCommand());
 program.addCommand(createGeoCommand());
 program.command("deploy").description("Deploy application (auto-detects platform)").option("-p, --platform <name>", "Specify platform (fly/vercel/netlify/railway/render)").option("--preview", "Deploy to preview/staging environment").option("--dry-run", "Show what would happen without deploying").action(deploy);
-var indexCmd = program.command("index").description("Semantic codebase indexing with local Ollama");
-indexCmd.command("init").description("Initialize semantic index").option("--local", "Use local Ollama for embeddings (default)").option("--cloud", "Use cloud embeddings (coming soon)").action(indexInit);
-indexCmd.command("update").description("Reindex changed files").action(indexUpdate);
-indexCmd.command("search <query>").description("Semantic search across codebase").action(indexSearch);
-indexCmd.command("status").description("Show index statistics").action(indexStatus);
+var indexCmd = program.command("index").description("Semantic codebase indexing (local Ollama or cloud pgvector)");
+indexCmd.command("init").description("Initialize semantic index").option("--local", "Use local Ollama for embeddings (default)").option("--cloud", "Use cloud pgvector with OpenAI embeddings").action(indexInit);
+indexCmd.command("update").description("Reindex changed files").option("--cloud", "Use cloud indexing").action(indexUpdate);
+indexCmd.command("search <query>").description("Semantic search across codebase").option("--cloud", "Search cloud index").action((query, options) => indexSearch(query, options));
+indexCmd.command("status").description("Show index statistics").option("--cloud", "Show cloud index status").action(indexStatus);
+indexCmd.command("clear").description("Clear the semantic index").option("--cloud", "Clear cloud index").action(indexClear);
 indexCmd.action(indexStatus);
 var sessionCmd = program.command("session").description("Cross-device session management");
 sessionCmd.command("save [name]").description("Save current session").action(saveSession);
@@ -3975,4 +4884,20 @@ parallelCmd.command("status").description("Show status of all parallel execution
 parallelCmd.command("merge [atomId]").description("Merge completed worktrees back to main").action(parallelMerge);
 parallelCmd.command("clean").description("Clean up all parallel execution state and worktrees").action(parallelClean);
 parallelCmd.action(parallelStatus);
+var githubCmd = program.command("github").description("GitHub integration for cloud execution");
+githubCmd.command("connect").description("Connect your GitHub account for cloud execution").action(githubConnect);
+githubCmd.command("status").description("Show GitHub connection status").action(githubStatus);
+githubCmd.command("disconnect").description("Disconnect your GitHub account").action(githubDisconnect);
+githubCmd.action(githubStatus);
+var cleanupCmd = program.command("cleanup").description("Workspace maintenance and file cleanup");
+cleanupCmd.command("check").description("Analyze workspace for bloat and maintenance needs").action(cleanupCheck);
+cleanupCmd.command("run").description("Execute cleanup (archive old entries, remove stale files)").action(cleanupRun);
+cleanupCmd.command("auto").description("Enable/disable automatic cleanup checks").argument("[action]", "enable, disable, or status", "status").action(async (action) => {
+  if (action !== "enable" && action !== "disable" && action !== "status") {
+    console.error(chalk14.red("Invalid action. Use: enable, disable, or status"));
+    process.exit(1);
+  }
+  await cleanupAuto(action);
+});
+cleanupCmd.action(cleanupCheck);
 program.parse();