archondev 2.18.7 → 2.19.0

package/dist/index.js

@@ -4,10 +4,10 @@ import {
 } from "./chunk-JF7JCK6H.js";
 import {
   createGeoCommand
-} from "./chunk-OAHFRSDS.js";
+} from "./chunk-O3B6BE5D.js";
 import {
   bugReport
-} from "./chunk-2BCITFWP.js";
+} from "./chunk-DCIIYVJW.js";
 import {
   reviewAnalyze,
   reviewExport,
@@ -19,8 +19,8 @@ import {
   reviewShow,
   reviewStatus,
   reviewUpdate
-} from "./chunk-BFPWDOMA.js";
-import "./chunk-HGLPIM7J.js";
+} from "./chunk-M6GNIN64.js";
+import "./chunk-KG35EHZY.js";
 import {
   resetPreferences,
   setExecutionPreference,
@@ -46,13 +46,13 @@ import {
   parallelRunWaves,
   parallelSchedule,
   parallelStatus
-} from "./chunk-ICSHS6BW.js";
+} from "./chunk-QTBRLNZQ.js";
 import {
   DependencyParser,
   EnvironmentConfigLoader,
   EnvironmentValidator,
   execute
-} from "./chunk-MRRA3QDP.js";
+} from "./chunk-OREGEFTF.js";
 import {
   cloudCancel,
   cloudLogs,
@@ -60,15 +60,19 @@ import {
 } from "./chunk-EBHHIUCB.js";
 import {
   list
-} from "./chunk-YFCC6QEY.js";
+} from "./chunk-YA562WHL.js";
 import {
   listLocalAtoms,
   loadAtom,
   plan
-} from "./chunk-ESSNYHC7.js";
-import "./chunk-5CFGPXQ3.js";
-import "./chunk-5BYCJAFM.js";
-import "./chunk-HJARQDQR.js";
+} from "./chunk-ACFMKTDL.js";
+import "./chunk-PCTP3LKJ.js";
+import "./chunk-PJRQI5UN.js";
+import {
+  err,
+  ok,
+  sleep
+} from "./chunk-EIEU3IIY.js";
 import {
   createAuthedSupabaseClient
 } from "./chunk-Q3GIFHIQ.js";
@@ -107,8 +111,8 @@ import {
 import "./chunk-4VNS5WPM.js";
 
 // src/cli/index.ts
-import { Command as Command2 } from "commander";
-import chalk17 from "chalk";
+import { Command as Command3 } from "commander";
+import chalk18 from "chalk";
 import "dotenv/config";
 
 // src/cli/promote.ts
@@ -427,8 +431,8 @@ var ContextManager = class _ContextManager {
   async clearPendingAtoms(cwd) {
     const filePath = join2(cwd, _ContextManager.PENDING_ATOMS_FILE);
     if (existsSync2(filePath)) {
-      const { unlink: unlink2 } = await import("fs/promises");
-      await unlink2(filePath);
+      const { unlink: unlink4 } = await import("fs/promises");
+      await unlink4(filePath);
     }
   }
 };
@@ -1199,8 +1203,12 @@ function extractTechStackHints(message) {
   if (/typescript|\.ts\b/i.test(message)) hints.language = "typescript";
   else if (/javascript|\.js\b/i.test(message)) hints.language = "javascript";
   else if (/python|\.py\b/i.test(message)) hints.language = "python";
-  else if (/go(lang)?|\.go\b/i.test(message)) hints.language = "go";
-  else if (/rust|\.rs\b/i.test(message)) hints.language = "rust";
+  else if (/\bgolang\b|\.go\b/i.test(message)) hints.language = "go";
+  else if (/\bgo\b/i.test(message)) {
+    if (/\bgo (lang|language|backend|server|api|service|cli)\b/i.test(message) || /\bin go\b/i.test(message)) {
+      hints.language = "go";
+    }
+  } else if (/rust|\.rs\b/i.test(message)) hints.language = "rust";
   if (/next\.?js|next/i.test(message)) hints.framework = "nextjs";
   else if (/react/i.test(message)) hints.framework = "react";
   else if (/vue/i.test(message)) hints.framework = "vue";
@@ -2734,7 +2742,7 @@ async function start(options = {}) {
     }
   }
   if (!config.tier || config.tier === "FREE") {
-    const isFirstRun = !existsSync6(join6(cwd, ".archon")) && !existsSync6(join6(cwd, "ARCHITECTURE.md"));
+    const isFirstRun = !existsSync6(join6(cwd, ".archon")) && resolveArchitecturePath(cwd).path === null;
     if (isFirstRun && !config.tierConfirmed) {
       console.log(chalk6.bold("How would you like to use ArchonDev?\n"));
       const selection = await promptTierSelection();
@@ -2771,7 +2779,22 @@ async function start(options = {}) {
   }
   if (currentTier === "CREDITS" && config.accessToken) {
     try {
-      const usageStats = config.userId ? await fetchCreditsUsageStats(config.accessToken, config.userId) : null;
+      const resolvedAuthId = await resolveAuthIdFromToken(config.accessToken, config.userId);
+      if (resolvedAuthId && !config.userId) {
+        await saveConfig({ ...config, userId: resolvedAuthId });
+      }
+      let usageStats = resolvedAuthId ? await fetchCreditsUsageStats(config.accessToken, resolvedAuthId) : null;
+      const usageStatsUnavailable = !usageStats;
+      if (!usageStats) {
+        usageStats = {
+          balance: 0,
+          usedThisPeriod: 0,
+          byModel: [],
+          periodStart: void 0,
+          periodSource: void 0,
+          lastCreditPurchaseAt: null
+        };
+      }
       if (usageStats) {
         console.log();
         console.log(chalk6.bold("\u{1F4B0} Credits Balance"));
@@ -2789,15 +2812,20 @@ async function start(options = {}) {
         } else {
           console.log(chalk6.dim("  No usage recorded since last top-up."));
         }
+        console.log();
+        console.log(chalk6.dim("  Model Usage:"));
         if (usageStats.byModel && usageStats.byModel.length > 0) {
-          console.log();
-          console.log(chalk6.dim("  Model Usage:"));
           for (const model of usageStats.byModel) {
             const modelName = model.model.length > 32 ? model.model.slice(0, 29) + "..." : model.model;
             console.log(chalk6.dim(`    ${modelName.padEnd(34)} $${model.cost.toFixed(4)}`));
           }
+        } else {
+          console.log(chalk6.dim(`    ${"No usage yet".padEnd(34)} $0.0000`));
         }
         console.log(chalk6.dim("\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 (usageStatsUnavailable) {
+          console.log(chalk6.dim("Usage details may be delayed. Run `archon credits` to refresh."));
+        }
         if (usageStats.balance < 5) {
           console.log(chalk6.yellow(`\u26A0\uFE0F  Low balance! Add credits: `) + chalk6.bold(`archon credits add`));
         } else {
@@ -2819,7 +2847,7 @@ async function start(options = {}) {
       console.log(`  ${chalk6.cyan("2")}) Switch to Managed Plan (no keys needed)`);
       console.log(`  ${chalk6.cyan("3")}) Continue on Free tier`);
       console.log();
-      const choice = await promptWithCommands("What would you like to do?");
+      const choice = await promptWithCommands("What would you like to do?", { allowMultiline: true });
       switch (choice) {
         case "1":
           const { handleTierSetup: handleTierSetup2 } = await import("./tier-selection-426HA765.js");
@@ -2915,6 +2943,20 @@ function formatTierName(tier) {
       return tier;
   }
 }
+async function resolveAuthIdFromToken(accessToken, existingAuthId) {
+  if (existingAuthId) return existingAuthId;
+  try {
+    const { SUPABASE_URL: SUPABASE_URL2, SUPABASE_ANON_KEY: SUPABASE_ANON_KEY2 } = await import("./constants-XDIWFFPN.js");
+    const { createClient: createClient2 } = await import("@supabase/supabase-js");
+    const client = createClient2(SUPABASE_URL2, SUPABASE_ANON_KEY2, {
+      global: { headers: { Authorization: `Bearer ${accessToken}` } }
+    });
+    const { data: { user } } = await client.auth.getUser();
+    return user?.id ?? null;
+  } catch {
+    return null;
+  }
+}
 async function fetchCreditsUsageStats(accessToken, authId) {
   try {
     const { API_URL: API_URL3 } = await import("./constants-XDIWFFPN.js");
@@ -2943,16 +2985,19 @@ async function fetchCreditsUsageStatsFromSupabase(accessToken, authId) {
     const { SUPABASE_URL: SUPABASE_URL2, SUPABASE_ANON_KEY: SUPABASE_ANON_KEY2 } = await import("./constants-XDIWFFPN.js");
     const { createAuthedSupabaseClient: createAuthedSupabaseClient2 } = await import("./client-PHW2C2HB.js");
     const supabase = createAuthedSupabaseClient2(SUPABASE_URL2, SUPABASE_ANON_KEY2, accessToken);
-    const { data: profile, error: profileError } = await supabase.from("user_profiles").select("id, credit_balance_cents").eq("auth_id", authId).single();
+    const { data: rawProfile, error: profileError } = await supabase.from("user_profiles").select("id, credit_balance_cents").eq("auth_id", authId).single();
+    const profile = rawProfile;
     if (profileError || !profile?.id) {
       return null;
     }
-    const { data: lastPurchase } = await supabase.from("credit_purchases").select("created_at").eq("user_id", profile.id).eq("status", "completed").order("created_at", { ascending: false }).limit(1).maybeSingle();
+    const { data: rawLastPurchase } = await supabase.from("credit_purchases").select("created_at").eq("user_id", profile.id).eq("status", "completed").order("created_at", { ascending: false }).limit(1).maybeSingle();
+    const lastPurchase = rawLastPurchase;
     const now = /* @__PURE__ */ new Date();
     const defaultStart = new Date(now.getFullYear(), now.getMonth(), 1).toISOString();
     const periodStart = lastPurchase?.created_at ?? defaultStart;
     const periodSource = lastPurchase?.created_at ? "credit_purchase" : "month";
-    const { data: usageRows } = await supabase.from("token_usage").select("model, marked_up_cost, total_cents, created_at").eq("user_id", profile.id).gte("created_at", periodStart);
+    const { data: rawUsageRows } = await supabase.from("token_usage").select("model, marked_up_cost, total_cents, created_at").eq("user_id", profile.id).gte("created_at", periodStart);
+    const usageRows = rawUsageRows;
     const byModelMap = /* @__PURE__ */ new Map();
     let usedThisPeriod = 0;
     for (const row of usageRows ?? []) {
@@ -2989,6 +3034,18 @@ function displayGovernanceStatus(status2) {
   }
   console.log();
 }
+var ACTIVE_ARCH_PATH = join6(".archon", "active", "architecture.md");
+function resolveArchitecturePath(cwd) {
+  const agdPath = join6(cwd, ACTIVE_ARCH_PATH);
+  if (existsSync6(agdPath)) {
+    return { path: agdPath, source: "agd" };
+  }
+  const legacyPath = join6(cwd, "ARCHITECTURE.md");
+  if (existsSync6(legacyPath)) {
+    return { path: legacyPath, source: "legacy" };
+  }
+  return { path: null, source: null };
+}
 function detectProjectState(cwd) {
   const sourceDirs = ["src", "lib", "app", "packages", "components", "pages", "api"];
   const sourceExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".rb", ".php"];
@@ -3012,7 +3069,7 @@ function detectProjectState(cwd) {
   if (!hasSourceFiles) {
     hasSourceFiles = projectMarkers.some((marker) => existsSync6(join6(cwd, marker)));
   }
-  const hasArchitecture = existsSync6(join6(cwd, "ARCHITECTURE.md"));
+  const hasArchitecture = resolveArchitecturePath(cwd).path !== null;
   const hasProgress = existsSync6(join6(cwd, "progress.txt"));
   const hasReviewDb = existsSync6(join6(cwd, "docs", "code-review", "review-tasks.db"));
   let hasProgressEntries = false;
@@ -3061,9 +3118,9 @@ async function gatherGovernanceStatus(cwd) {
     dependencyRulesCount: 0,
     pendingAtomsCount: 0
   };
-  const archPath = join6(cwd, "ARCHITECTURE.md");
-  if (existsSync6(archPath)) {
-    const parser = new ArchitectureParser(archPath);
+  const archInfo = resolveArchitecturePath(cwd);
+  if (archInfo.path) {
+    const parser = new ArchitectureParser(archInfo.path);
     const result = await parser.parse();
     if (result.success && result.schema) {
       status2.hasArchitecture = true;
@@ -3108,7 +3165,7 @@ async function handleNewProject(cwd, _state) {
   console.log(chalk6.bold("\u{1F389} Starting a new project? Great!\n"));
   console.log(chalk6.dim("Answer as much or as little as you want \u2014 you can always refine later."));
   console.log(chalk6.dim('Type "just start" or "skip" to use defaults.\n'));
-  const initialResponse = await promptWithCommands("What do you want to do?");
+  const initialResponse = await promptWithCommands("What do you want to do?", { allowMultiline: true });
   if (!initialResponse.trim()) {
     console.log(chalk6.yellow("\nNo response provided. Showing options...\n"));
     await showNewProjectMenu(cwd);
@@ -3127,7 +3184,7 @@ async function handleNewProject(cwd, _state) {
   }
   if (intent.mode === "ad_hoc" && intent.confidence >= 0.7) {
     console.log(chalk6.dim("\n> Got it! Creating a task for this...\n"));
-    const { plan: plan2 } = await import("./plan-4RIHWWZG.js");
+    const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
     await plan2(initialResponse, {});
     return;
   }
@@ -3151,7 +3208,7 @@ async function handleNewProject(cwd, _state) {
         break;
       case "2":
         console.log(chalk6.dim("\n> Creating a task for this...\n"));
-        const { plan: plan2 } = await import("./plan-4RIHWWZG.js");
+        const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
         await plan2(initialResponse, {});
         break;
       case "3":
@@ -3181,7 +3238,7 @@ async function showNewProjectMenu(cwd) {
     case "3": {
       const description = await prompt("Describe what you want to do");
       if (description.trim()) {
-        const { plan: plan2 } = await import("./plan-4RIHWWZG.js");
+        const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
         await plan2(description, {});
       }
       break;
@@ -3247,7 +3304,7 @@ async function runExploreFlow(cwd) {
     case "1": {
       const description = await prompt("Describe what you want to do");
       if (description.trim()) {
-        const { plan: plan2 } = await import("./plan-4RIHWWZG.js");
+        const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
         await plan2(description, {});
       }
       break;
@@ -3340,11 +3397,14 @@ async function gatherProjectInfo(cwd) {
     }
   } catch {
   }
-  info.hasArchitecture = existsSync6(join6(cwd, "ARCHITECTURE.md"));
+  info.hasArchitecture = resolveArchitecturePath(cwd).path !== null;
   info.hasProgress = existsSync6(join6(cwd, "progress.txt"));
   if (info.hasArchitecture) {
-    const archPath = join6(cwd, "ARCHITECTURE.md");
-    const parser = new ArchitectureParser(archPath);
+    const archInfo = resolveArchitecturePath(cwd);
+    if (!archInfo.path) {
+      return info;
+    }
+    const parser = new ArchitectureParser(archInfo.path);
     const result = await parser.parse();
     if (result.success && result.schema) {
       info.posture = result.schema.qualityLevel?.posture;
@@ -3355,7 +3415,7 @@ async function gatherProjectInfo(cwd) {
   return info;
 }
 async function runConversationalInterview(cwd, initialMessage) {
-  const { InterviewerAgent, createInterviewerAgent } = await import("./interviewer-NQHNMVH4.js");
+  const { InterviewerAgent, createInterviewerAgent } = await import("./interviewer-BWM5SNOE.js");
   const agent = await createInterviewerAgent();
   if (agent && agent.isAvailable()) {
     await runAIInterview(cwd, initialMessage, agent);
@@ -3506,7 +3566,7 @@ ${state.forbiddenPatterns?.length ? `- **Forbidden patterns:** ${state.forbidden
   if (continueChoice) {
     const description = await prompt("Describe what you want to build first");
     if (description.trim()) {
-      const { plan: plan2 } = await import("./plan-4RIHWWZG.js");
+      const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
       await plan2(description, {});
     }
   }
@@ -3544,7 +3604,7 @@ async function handleAdaptExisting(cwd, state) {
     console.log(chalk6.dim("I can analyze your codebase and adapt the governance files to match your structure."));
     console.log(chalk6.dim("This helps me understand your architecture without changing any code.\n"));
   }
-  const response = await promptWithCommands("What would you like to do?");
+  const response = await promptWithCommands("What would you like to do?", { allowMultiline: true });
   if (response.toLowerCase() === "q" || response.toLowerCase() === "quit") {
     process.exit(0);
   }
@@ -3560,7 +3620,7 @@ async function handleAdaptExisting(cwd, state) {
   }
   if (intent.mode === "ad_hoc" && intent.confidence >= 0.7) {
     console.log(chalk6.dim("\n> Got it! Creating a task for this...\n"));
-    const { plan: plan2 } = await import("./plan-4RIHWWZG.js");
+    const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
     await plan2(response, {});
     return;
   }
@@ -3591,7 +3651,7 @@ async function showAdaptExistingMenu(cwd, state) {
     case "2": {
       const description = await prompt("Describe what you want to do");
       if (description.trim()) {
-        const { plan: plan2 } = await import("./plan-4RIHWWZG.js");
+        const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
         await plan2(description, {});
       }
       break;
@@ -3643,7 +3703,7 @@ async function analyzeAndAdapt(cwd) {
 async function codeReviewFirst(cwd) {
   console.log(chalk6.blue("\n-- Code Review Mode --\n"));
   console.log(chalk6.dim("I'll analyze your code for issues without making any changes.\n"));
-  const { reviewInit: reviewInit2, reviewAnalyze: reviewAnalyze2, reviewRun: reviewRun2 } = await import("./review-AUG6GIL6.js");
+  const { reviewInit: reviewInit2, reviewAnalyze: reviewAnalyze2, reviewRun: reviewRun2 } = await import("./review-F6DHAGDF.js");
   const reviewDbPath = join6(cwd, "docs", "code-review", "review-tasks.db");
   if (!existsSync6(reviewDbPath)) {
     await reviewInit2();
@@ -3679,6 +3739,14 @@ async function handleContinueSession(cwd, state) {
 }
 function checkForHandoff(cwd) {
   try {
+    const currentContextPath = join6(cwd, ".archon", "current_context.md");
+    if (existsSync6(currentContextPath)) {
+      const content2 = readFileSync3(currentContextPath, "utf-8");
+      const nextStepsMatch = content2.match(/## Next Actions[^\n]*\n([\s\S]*?)(?=\n## |\n*$)/);
+      if (nextStepsMatch && nextStepsMatch[1]) {
+        return { nextSteps: nextStepsMatch[1].trim() };
+      }
+    }
     const progressPath = join6(cwd, "progress.txt");
     if (!existsSync6(progressPath)) return null;
     const content = readFileSync3(progressPath, "utf-8");
@@ -3742,7 +3810,7 @@ async function showMainMenu() {
 }
 async function showReviewProgress(cwd) {
   try {
-    const { ReviewDatabase } = await import("./code-review-6MU4UE5M.js");
+    const { ReviewDatabase } = await import("./code-review-ODLXGXNZ.js");
     const db = new ReviewDatabase(cwd);
     db.open();
     const stats = db.getStats();
@@ -3759,18 +3827,18 @@ async function showReviewProgress(cwd) {
   }
 }
 async function planTask() {
-  const { plan: plan2 } = await import("./plan-4RIHWWZG.js");
+  const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
   const description = await prompt("Describe what you want to build");
   if (description.trim()) {
     await plan2(description, {});
   }
 }
 async function listAtoms() {
-  const { list: list2 } = await import("./list-BJCKDRG4.js");
+  const { list: list2 } = await import("./list-REPLUXJF.js");
   await list2({});
 }
 async function executeNext() {
-  const { listLocalAtoms: listLocalAtoms2 } = await import("./plan-4RIHWWZG.js");
+  const { listLocalAtoms: listLocalAtoms2 } = await import("./plan-HCYXLSSD.js");
   const { analyzeProject, getComplexityDescription, getModeDescription } = await import("./orchestration-HIF3KP25.js");
   const { loadExecutionPreferences } = await import("./preferences-I6WETXOI.js");
   const cwd = process.cwd();
@@ -3841,11 +3909,11 @@ async function executeNext() {
         }
       }
       if (selectedMode === "parallel-cloud") {
-        const { parallelExecuteCloud: parallelExecuteCloud2 } = await import("./parallel-U3COBCHB.js");
+        const { parallelExecuteCloud: parallelExecuteCloud2 } = await import("./parallel-23VQYK7H.js");
         await parallelExecuteCloud2(runIds);
         return;
       }
-      const { parallelExecute } = await import("./parallel-U3COBCHB.js");
+      const { parallelExecute } = await import("./parallel-23VQYK7H.js");
       await parallelExecute(runIds);
       return;
     }
@@ -3853,14 +3921,14 @@ async function executeNext() {
   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-OTW55P2Q.js");
+    const { execute: execute2 } = await import("./execute-ZTJGSRBW.js");
     await execute2(targetId, {});
   } else {
     console.log(chalk6.yellow("No atom to execute."));
   }
 }
 async function reportBug() {
-  const { bugReport: bugReport2 } = await import("./bug-DCFTT2AF.js");
+  const { bugReport: bugReport2 } = await import("./bug-IJCK43FK.js");
   const title = await prompt("Bug title");
   if (title.trim()) {
     await bugReport2(title, {});
@@ -3880,7 +3948,7 @@ async function reviewCode() {
   const reviewDbPath = join6(cwd, "docs", "code-review", "review-tasks.db");
   if (!existsSync6(reviewDbPath)) {
     console.log(chalk6.dim("Code review not initialized. Starting setup...\n"));
-    const { reviewInit: reviewInit2 } = await import("./review-AUG6GIL6.js");
+    const { reviewInit: reviewInit2 } = await import("./review-F6DHAGDF.js");
     await reviewInit2();
     console.log();
   }
@@ -3895,27 +3963,27 @@ async function reviewCode() {
   const choice = await prompt("Enter choice");
   switch (choice.toLowerCase()) {
     case "1": {
-      const { reviewAnalyze: reviewAnalyze2 } = await import("./review-AUG6GIL6.js");
+      const { reviewAnalyze: reviewAnalyze2 } = await import("./review-F6DHAGDF.js");
       await reviewAnalyze2();
       break;
     }
     case "2": {
-      const { reviewStatus: reviewStatus2 } = await import("./review-AUG6GIL6.js");
+      const { reviewStatus: reviewStatus2 } = await import("./review-F6DHAGDF.js");
       await reviewStatus2();
       break;
     }
     case "3": {
-      const { reviewNext: reviewNext2 } = await import("./review-AUG6GIL6.js");
+      const { reviewNext: reviewNext2 } = await import("./review-F6DHAGDF.js");
       await reviewNext2();
       break;
     }
     case "4": {
-      const { reviewList: reviewList2 } = await import("./review-AUG6GIL6.js");
+      const { reviewList: reviewList2 } = await import("./review-F6DHAGDF.js");
       await reviewList2({});
       break;
     }
     case "5": {
-      const { reviewRun: reviewRun2 } = await import("./review-AUG6GIL6.js");
+      const { reviewRun: reviewRun2 } = await import("./review-F6DHAGDF.js");
       await reviewRun2({ all: true });
       break;
     }
@@ -3973,9 +4041,41 @@ function prompt(question) {
     });
   });
 }
-async function promptWithCommands(question) {
+function promptMultiline(question, idleMs = 250) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const lines = [];
+    let timer = null;
+    const finish = () => {
+      if (timer) clearTimeout(timer);
+      rl.close();
+      resolve(lines.join("\n").trimEnd());
+    };
+    const scheduleFinish = () => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(finish, idleMs);
+    };
+    rl.on("line", (line) => {
+      lines.push(line);
+      scheduleFinish();
+    });
+    rl.on("SIGINT", () => {
+      rl.close();
+      process.exit(0);
+    });
+    rl.setPrompt(`${chalk6.cyan("?")} ${question}: `);
+    rl.prompt();
+  });
+}
+async function promptWithCommands(question, options = {}) {
   while (true) {
-    const answer = await prompt(question);
+    const answer = options.allowMultiline ? await promptMultiline(question) : await prompt(question);
+    if (options.allowMultiline && answer.includes("\n")) {
+      return answer;
+    }
     const handled = await handleInSessionCommand(answer);
     if (!handled) {
       return answer;
@@ -3986,7 +4086,7 @@ async function promptWithCommands(question) {
 async function runWebChecksSuite() {
   const { a11yCheck: a11yCheck2 } = await import("./a11y-O35BAA25.js");
   const { seoCheck } = await import("./seo-PMI42KRZ.js");
-  const { geoAudit } = await import("./geo-GEWH777F.js");
+  const { geoAudit } = await import("./geo-HRG7M7YX.js");
   console.log(chalk6.blue("\nRunning web checks (A11y, SEO, GEO)...\n"));
   await a11yCheck2({});
   await seoCheck({});
@@ -4026,17 +4126,17 @@ async function showWebChecksMenu() {
       break;
     }
     case "4": {
-      const { geoAudit } = await import("./geo-GEWH777F.js");
+      const { geoAudit } = await import("./geo-HRG7M7YX.js");
       await geoAudit();
       break;
     }
     case "5": {
-      const { geoIdentity } = await import("./geo-GEWH777F.js");
+      const { geoIdentity } = await import("./geo-HRG7M7YX.js");
       await geoIdentity();
       break;
     }
     case "6": {
-      const { geoSchema } = await import("./geo-GEWH777F.js");
+      const { geoSchema } = await import("./geo-HRG7M7YX.js");
       await geoSchema({});
       break;
     }
@@ -4172,9 +4272,9 @@ async function showCredits() {
       console.log(chalk7.dim("  Using your own API keys - no credit charges"));
     }
     console.log();
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error fetching credits");
-    console.error(err);
+    console.error(err2);
   }
 }
 async function addCredits(options = {}) {
@@ -4228,9 +4328,9 @@ async function addCredits(options = {}) {
     } catch {
       console.log(chalk7.yellow("  Could not open browser. Please visit the URL above."));
     }
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error preparing checkout");
-    console.error(err);
+    console.error(err2);
   }
 }
 async function showHistory(options = {}) {
@@ -4274,9 +4374,9 @@ async function showHistory(options = {}) {
       `  ${"Total".padEnd(30)} ${totalTokens.toString().padStart(8)} ${chalk7.green(`$${totalCost.toFixed(4)}`.padStart(10))}`
     );
     console.log();
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error fetching history");
-    console.error(err);
+    console.error(err2);
   }
 }
 async function manageBudget(options = {}) {
@@ -4356,9 +4456,9 @@ async function manageBudget(options = {}) {
     console.log(chalk7.dim("  Clear budget:   archon credits budget --clear"));
     console.log(chalk7.dim("  Set alert:      archon credits budget --alert 80"));
     console.log();
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error managing budget");
-    console.error(err);
+    console.error(err2);
   }
 }
 async function manageAutoRecharge(options = {}) {
@@ -4434,9 +4534,9 @@ async function manageAutoRecharge(options = {}) {
     console.log(chalk7.dim("  Enable:    archon credits auto-recharge --enable --threshold 5 --amount 20"));
     console.log(chalk7.dim("  Disable:   archon credits auto-recharge --disable"));
     console.log();
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error managing auto-recharge");
-    console.error(err);
+    console.error(err2);
   }
 }
 async function showAuditHistory(options = {}) {
@@ -4489,9 +4589,9 @@ async function showAuditHistory(options = {}) {
     console.log(chalk7.dim(`  Showing ${history.length} most recent events`));
     console.log(chalk7.dim("  Use --limit N to show more"));
     console.log();
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error fetching audit history");
-    console.error(err);
+    console.error(err2);
   }
 }
 function formatEventType(eventType) {
@@ -5149,9 +5249,9 @@ async function saveSession(name) {
     console.log();
     console.log(chalk9.dim("  Resume on another device: archon session resume " + session.id));
     console.log();
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error saving session");
-    console.error(err);
+    console.error(err2);
   }
 }
 async function listSessions() {
@@ -5192,9 +5292,9 @@ async function listSessions() {
       console.log();
     }
     console.log(chalk9.dim("  Resume: archon session resume <id>\n"));
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error fetching sessions");
-    console.error(err);
+    console.error(err2);
   }
 }
 async function resumeSession(sessionId) {
@@ -5243,9 +5343,9 @@ async function resumeSession(sessionId) {
     console.log();
     console.log(chalk9.dim("  Continue working: archon start"));
     console.log();
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error resuming session");
-    console.error(err);
+    console.error(err2);
   }
 }
 async function syncSession() {
@@ -5285,9 +5385,9 @@ async function syncSession() {
       return;
     }
     spinner.succeed(chalk9.green("Session synced to cloud"));
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Error syncing session");
-    console.error(err);
+    console.error(err2);
   }
 }
 
@@ -6321,9 +6421,9 @@ async function interview(options = {}) {
     console.log(`  ${chalk13.cyan("2.")} Run ${chalk13.bold("archon list")} to see generated atoms`);
     console.log(`  ${chalk13.cyan("3.")} Run ${chalk13.bold("archon execute <atom-id>")} to start building`);
     console.log();
-  } catch (err) {
+  } catch (err2) {
     spinner.fail("Failed to freeze Constitution");
-    console.error(err);
+    console.error(err2);
   }
 }
 async function runPhase(phase, constitution, cwd) {
@@ -7002,13 +7102,13 @@ async function modelsSync(options) {
     if (result.parseErrors.length > 0) {
       console.log();
       console.log(chalk16.red(`\u26A0\uFE0F  Warnings/Errors (${result.parseErrors.length}):`));
-      for (const err of result.parseErrors) {
-        console.log(chalk16.red(`  - ${err}`));
+      for (const err2 of result.parseErrors) {
+        console.log(chalk16.red(`  - ${err2}`));
       }
     }
     console.log();
-  } catch (err) {
-    console.log(chalk16.red(`Failed to run sync: ${err}`));
+  } catch (err2) {
+    console.log(chalk16.red(`Failed to run sync: ${err2}`));
   }
 }
 async function modelsList() {
@@ -7035,13 +7135,766 @@ async function modelsList() {
   console.log();
 }
 
+// src/cli/governance.ts
+import { Command as Command2 } from "commander";
+import chalk17 from "chalk";
+import { existsSync as existsSync18, readFileSync as readFileSync6 } from "fs";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join19 } from "path";
+import matter4 from "gray-matter";
+
+// src/core/governance/store.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync3 } from "fs";
+import { readFile as readFile10, writeFile as writeFile8, appendFile, unlink as unlink2, stat as stat2, rename } from "fs/promises";
+import { join as join16 } from "path";
+import matter from "gray-matter";
+var ARCHON_DIR2 = ".archon";
+var ACTIVE_DIR = join16(ARCHON_DIR2, "active");
+var HISTORY_DIR = join16(ARCHON_DIR2, "history");
+var ARCHIVE_DIR2 = join16(ARCHON_DIR2, "archive");
+var LOCK_FILE = join16(ARCHON_DIR2, "governance.lock");
+var CURRENT_CONTEXT = join16(ARCHON_DIR2, "current_context.md");
+var ARCHITECTURE_FILE = join16(ACTIVE_DIR, "architecture.md");
+var TASKS_FILE = join16(ACTIVE_DIR, "tasks.json");
+var HANDOFFS_FILE = join16(HISTORY_DIR, "handoffs.jsonl");
+var DECISION_LOG_FILE = join16(HISTORY_DIR, "decision_log.jsonl");
+var COMPLETED_TASKS_FILE = join16(ARCHIVE_DIR2, "completed_tasks.jsonl");
+var DEFAULT_LOCK_TIMEOUT_MS = 5e3;
+var DEFAULT_LOCK_RETRY_MS = 100;
+var DEFAULT_STALE_LOCK_MS = 2 * 60 * 1e3;
+var GovernanceStore = class {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  /**
+   * Ensure governance directories exist
+   */
+  ensureStructure() {
+    this.ensureDir(join16(this.cwd, ARCHON_DIR2));
+    this.ensureDir(join16(this.cwd, ACTIVE_DIR));
+    this.ensureDir(join16(this.cwd, HISTORY_DIR));
+    this.ensureDir(join16(this.cwd, ARCHIVE_DIR2));
+  }
+  /**
+   * Read current architecture content (without frontmatter)
+   */
+  async readArchitecture() {
+    const filePath = join16(this.cwd, ARCHITECTURE_FILE);
+    if (!existsSync16(filePath)) {
+      return ok("");
+    }
+    try {
+      const raw = await readFile10(filePath, "utf-8");
+      const parsed = matter(raw);
+      return ok(parsed.content.trim());
+    } catch (error) {
+      return err(error instanceof Error ? error.message : "Failed to read architecture");
+    }
+  }
+  /**
+   * Update architecture with required change_reason and optional updated_by
+   */
+  async updateArchitecture(content, changeReason, updatedBy) {
+    if (!changeReason.trim()) {
+      return err("change_reason is required for architecture updates");
+    }
+    this.ensureStructure();
+    const release = await this.acquireLock();
+    if (!release.ok) return release;
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const filePath = join16(this.cwd, ARCHITECTURE_FILE);
+      const current = await this.readArchitectureFrontmatter(filePath);
+      const nextVersion = this.nextVersion(current?.version);
+      const frontmatter = {
+        version: nextVersion,
+        last_updated: now,
+        change_reason: changeReason
+      };
+      if (updatedBy) {
+        frontmatter.updated_by = updatedBy;
+      }
+      const output = matter.stringify(content.trim() + "\n", frontmatter);
+      await this.writeFileAtomic(filePath, output);
+      const decision = {
+        timestamp: now,
+        category: "architecture",
+        change_reason: changeReason,
+        updated_by: updatedBy
+      };
+      await this.appendJsonLine(join16(this.cwd, DECISION_LOG_FILE), decision);
+      return ok(void 0);
+    } catch (error) {
+      return err(error instanceof Error ? error.message : "Failed to update architecture");
+    } finally {
+      await release.value();
+    }
+  }
+  /**
+   * Update a task's status and optional notes. Moves to archive when done.
+   */
+  async updateTask(taskId, status2, notes) {
+    this.ensureStructure();
+    const release = await this.acquireLock();
+    if (!release.ok) return release;
+    try {
+      const tasksPath = join16(this.cwd, TASKS_FILE);
+      const tasks = await this.loadTasks(tasksPath);
+      if (!tasks.ok) return tasks;
+      const index = tasks.value.findIndex((task2) => task2.id === taskId);
+      if (index === -1) {
+        return err(`Task not found: ${taskId}`);
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const task = { ...tasks.value[index] };
+      task.status = status2;
+      task.notes = notes ?? task.notes;
+      task.updated_at = now;
+      if (status2 === "done") {
+        tasks.value.splice(index, 1);
+        await this.appendJsonLine(join16(this.cwd, COMPLETED_TASKS_FILE), task);
+      } else {
+        tasks.value[index] = task;
+      }
+      await this.writeJson(tasksPath, tasks.value);
+      return ok(void 0);
+    } catch (error) {
+      return err(error instanceof Error ? error.message : "Failed to update task");
+    } finally {
+      await release.value();
+    }
+  }
+  /**
+   * Append handoff entry and update current_context.md
+   */
+  async logHandoff(entry) {
+    if (!entry.reason.trim()) {
+      return err("reason is required for handoff");
+    }
+    if (!entry.summary.trim()) {
+      return err("summary is required for handoff");
+    }
+    if (!entry.next_actions || entry.next_actions.length === 0) {
+      return err("next_actions are required for handoff");
+    }
+    this.ensureStructure();
+    const release = await this.acquireLock();
+    if (!release.ok) return release;
+    try {
+      await this.appendJsonLine(join16(this.cwd, HANDOFFS_FILE), entry);
+      const contextLines = [
+        "# Current Context",
+        "",
+        `Timestamp: ${entry.timestamp}`,
+        entry.from_agent ? `From: ${entry.from_agent}` : void 0,
+        `Reason: ${entry.reason}`,
+        "",
+        "## Summary",
+        entry.summary.trim(),
+        "",
+        "## Next Actions",
+        ...entry.next_actions.map((action) => `- ${action}`),
+        ""
+      ].filter((line) => typeof line === "string");
+      await this.writeFileAtomic(join16(this.cwd, CURRENT_CONTEXT), contextLines.join("\n"));
+      return ok(void 0);
+    } catch (error) {
+      return err(error instanceof Error ? error.message : "Failed to log handoff");
+    } finally {
+      await release.value();
+    }
+  }
+  ensureDir(path2) {
+    if (!existsSync16(path2)) {
+      mkdirSync3(path2, { recursive: true });
+    }
+  }
+  async acquireLock(timeoutMs = DEFAULT_LOCK_TIMEOUT_MS, retryMs = DEFAULT_LOCK_RETRY_MS, staleMs = DEFAULT_STALE_LOCK_MS) {
+    const lockPath = join16(this.cwd, LOCK_FILE);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      try {
+        await this.tryCreateLock(lockPath);
+        return ok(async () => {
+          await this.safeUnlink(lockPath);
+        });
+      } catch (error) {
+        if (error instanceof Error && error.message === "LOCK_EXISTS") {
+          const staleCleared = await this.clearStaleLock(lockPath, staleMs);
+          if (staleCleared) {
+            continue;
+          }
+          await sleep(retryMs);
+          continue;
+        }
+        return err("Failed to acquire governance lock");
+      }
+    }
+    return err("Timed out waiting for governance lock");
+  }
+  async tryCreateLock(lockPath) {
+    if (existsSync16(lockPath)) {
+      throw new Error("LOCK_EXISTS");
+    }
+    const payload = JSON.stringify({ pid: process.pid, created_at: (/* @__PURE__ */ new Date()).toISOString() });
+    await writeFile8(lockPath, payload, { flag: "wx" });
+  }
+  async clearStaleLock(lockPath, staleMs) {
+    try {
+      const info = await stat2(lockPath);
+      const ageByMtime = Date.now() - info.mtimeMs;
+      let ageByCreatedAt = null;
+      try {
+        const raw = await readFile10(lockPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.created_at) {
+          const createdAt = Date.parse(parsed.created_at);
+          if (!Number.isNaN(createdAt)) {
+            ageByCreatedAt = Date.now() - createdAt;
+          }
+        }
+      } catch {
+      }
+      const ageMs = Math.max(ageByMtime, ageByCreatedAt ?? -Infinity);
+      if (ageMs > staleMs) {
+        await this.safeUnlink(lockPath);
+        return true;
+      }
+    } catch {
+      return false;
+    }
+    return false;
+  }
+  async safeUnlink(path2) {
+    try {
+      await unlink2(path2);
+    } catch {
+    }
+  }
+  async readArchitectureFrontmatter(filePath) {
+    if (!existsSync16(filePath)) return null;
+    const raw = await readFile10(filePath, "utf-8");
+    const parsed = matter(raw);
+    const data = parsed.data;
+    const versionRaw = data["version"];
+    const version = typeof versionRaw === "number" ? versionRaw : typeof versionRaw === "string" ? Number.parseFloat(versionRaw) : 1;
+    return {
+      version: Number.isFinite(version) ? version : 1,
+      last_updated: typeof data["last_updated"] === "string" ? data["last_updated"] : "",
+      updated_by: typeof data["updated_by"] === "string" ? data["updated_by"] : void 0,
+      change_reason: typeof data["change_reason"] === "string" ? data["change_reason"] : ""
+    };
+  }
+  nextVersion(current) {
+    if (!current || !Number.isFinite(current)) return 1;
+    return Math.round((current + 0.1) * 10) / 10;
+  }
+  async loadTasks(path2) {
+    if (!existsSync16(path2)) return ok([]);
+    try {
+      const raw = await readFile10(path2, "utf-8");
+      const data = JSON.parse(raw);
+      if (!Array.isArray(data)) {
+        return err("tasks.json must be an array");
+      }
+      const parsed = [];
+      for (const item of data) {
+        const task = this.parseTask(item);
+        if (!task) {
+          return err("tasks.json contains invalid entries");
+        }
+        parsed.push(task);
+      }
+      return ok(parsed);
+    } catch (error) {
+      return err(error instanceof Error ? error.message : "Failed to parse tasks.json");
+    }
+  }
+  parseTask(value) {
+    if (typeof value !== "object" || value === null) return null;
+    const raw = value;
+    const id = typeof raw["id"] === "string" ? raw["id"] : null;
+    const description = typeof raw["description"] === "string" ? raw["description"] : null;
+    const status2 = this.parseStatus(raw["status"]);
+    const createdAt = typeof raw["created_at"] === "string" ? raw["created_at"] : null;
+    if (!id || !description || !status2 || !createdAt) return null;
+    return {
+      id,
+      parent_id: typeof raw["parent_id"] === "string" ? raw["parent_id"] : void 0,
+      description,
+      status: status2,
+      assigned_to: typeof raw["assigned_to"] === "string" ? raw["assigned_to"] : void 0,
+      created_at: createdAt,
+      updated_at: typeof raw["updated_at"] === "string" ? raw["updated_at"] : void 0,
+      notes: typeof raw["notes"] === "string" ? raw["notes"] : void 0
+    };
+  }
+  parseStatus(value) {
+    if (value === "pending" || value === "in_progress" || value === "verification" || value === "done") {
+      return value;
+    }
+    return null;
+  }
+  async writeJson(path2, payload) {
+    const content = JSON.stringify(payload, null, 2) + "\n";
+    await this.writeFileAtomic(path2, content);
+  }
+  async writeFileAtomic(path2, content) {
+    const tmpPath = `${path2}.tmp`;
+    await writeFile8(tmpPath, content, "utf-8");
+    try {
+      await rename(tmpPath, path2);
+    } catch {
+      await this.safeUnlink(path2);
+      await rename(tmpPath, path2);
+    }
+  }
+  async appendJsonLine(path2, payload) {
+    const line = JSON.stringify(payload) + "\n";
+    await appendFile(path2, line, "utf-8");
+  }
+};
+
+// src/core/governance/migrate.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync4 } from "fs";
+import { readFile as readFile11, writeFile as writeFile9, unlink as unlink3 } from "fs/promises";
+import { join as join17 } from "path";
+import matter2 from "gray-matter";
+var LEGACY_ARCH_PATH = "ARCHITECTURE.md";
+var LEGACY_TASKS_PATH = join17(".archon", "current-tasks.md");
+var ACTIVE_ARCH_PATH2 = join17(".archon", "active", "architecture.md");
+var ACTIVE_TASKS_PATH = join17(".archon", "active", "tasks.json");
+var ARCHIVE_COMPLETED_PATH = join17(".archon", "archive", "completed_tasks.jsonl");
+var HISTORY_LEGACY_DIR = join17(".archon", "history", "legacy");
+function parseLegacyTasks(content) {
+  const result = { active: [], paused: [] };
+  const activeHeaderMatch = content.match(/##\s+Active\s*\((\d{4}-\d{2}-\d{2})\)/i);
+  if (activeHeaderMatch?.[1]) {
+    result.referenceDate = activeHeaderMatch[1];
+  }
+  const sections = content.split(/\n##\s+/).map((block) => block.trim());
+  for (const section of sections) {
+    const normalized = section.toLowerCase();
+    const lines = section.split("\n").slice(1);
+    if (normalized.startsWith("active")) {
+      for (const line of lines) {
+        const match = line.match(/^\d+\.\s+(.*)$/);
+        if (!match?.[1]) continue;
+        const raw = match[1].trim();
+        if (!raw) continue;
+        const done = /\(done\)\s*$/i.test(raw);
+        const cleaned = raw.replace(/\s*\(done\)\s*$/i, "").trim();
+        result.active.push({ description: cleaned, done });
+      }
+    }
+    if (normalized.startsWith("paused")) {
+      for (const line of lines) {
+        const match = line.match(/^\d+\.\s+(.*)$/);
+        if (!match?.[1]) continue;
+        const raw = match[1].trim();
+        if (!raw) continue;
+        result.paused.push(raw);
+      }
+    }
+  }
+  return result;
+}
+function buildTaskEntries(parsed, nowIso) {
+  const active = [];
+  const completed = [];
+  let counter = 1;
+  const referenceDate = parsed.referenceDate ? `${parsed.referenceDate}T00:00:00.000Z` : nowIso;
+  const makeTask = (description, status2, notes) => {
+    const task = {
+      id: `TASK-${String(counter).padStart(3, "0")}`,
+      description,
+      status: status2,
+      created_at: referenceDate,
+      updated_at: nowIso,
+      notes
+    };
+    counter += 1;
+    return task;
+  };
+  for (const item of parsed.active) {
+    if (item.done) {
+      completed.push(makeTask(item.description, "done", "Migrated from current-tasks.md (done)"));
+    } else {
+      active.push(makeTask(item.description, "pending"));
+    }
+  }
+  for (const paused of parsed.paused) {
+    active.push(makeTask(paused, "pending", "Migrated from current-tasks.md (paused)"));
+  }
+  return { active, completed };
+}
+async function writeJson(path2, payload, dryRun) {
+  if (dryRun) return;
+  const content = JSON.stringify(payload, null, 2) + "\n";
+  await writeFile9(path2, content, "utf-8");
+}
+async function appendJsonLines(path2, items, dryRun) {
+  if (dryRun || items.length === 0) return;
+  const lines = items.map((item) => JSON.stringify(item)).join("\n") + "\n";
+  await writeFile9(path2, lines, { encoding: "utf-8", flag: "a" });
+}
+async function archiveLegacyFile(source, destDir, dryRun) {
+  const fileName = source.split("/").pop() ?? source.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const target = join17(destDir, fileName);
+  if (dryRun) return target;
+  if (!existsSync17(destDir)) {
+    mkdirSync4(destDir, { recursive: true });
+  }
+  const content = await readFile11(source, "utf-8");
+  await writeFile9(target, content, "utf-8");
+  return target;
+}
+async function migrateLegacyGovernance(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const nowIso = now.toISOString();
+  const result = {
+    migratedArchitecture: false,
+    migratedTasks: false,
+    archivedLegacyFiles: [],
+    warnings: []
+  };
+  const store = new GovernanceStore(cwd);
+  store.ensureStructure();
+  const archPath = join17(cwd, LEGACY_ARCH_PATH);
+  const activeArchPath = join17(cwd, ACTIVE_ARCH_PATH2);
+  if (existsSync17(archPath) && !existsSync17(activeArchPath)) {
+    const raw = await readFile11(archPath, "utf-8");
+    const parsed = matter2(raw);
+    const content = parsed.content.trim();
+    if (!content) {
+      result.warnings.push("Legacy ARCHITECTURE.md was empty; skipping architecture migration.");
+    } else if (!options.dryRun) {
+      const update = await store.updateArchitecture(
+        content,
+        "Migrated from legacy ARCHITECTURE.md",
+        options.updatedBy ?? "archon migration"
+      );
+      if (!update.ok) {
+        result.warnings.push(`Failed to migrate architecture: ${update.error}`);
+      } else {
+        result.migratedArchitecture = true;
+      }
+    } else {
+      result.migratedArchitecture = true;
+    }
+    if (options.removeLegacy) {
+      const archived = await archiveLegacyFile(archPath, join17(cwd, HISTORY_LEGACY_DIR), !!options.dryRun);
+      result.archivedLegacyFiles.push(archived);
+      if (!options.dryRun) {
+        await unlink3(archPath);
+      }
+    }
+  }
+  const legacyTasksPath = join17(cwd, LEGACY_TASKS_PATH);
+  const activeTasksPath = join17(cwd, ACTIVE_TASKS_PATH);
+  if (existsSync17(legacyTasksPath) && !existsSync17(activeTasksPath)) {
+    const rawTasks = await readFile11(legacyTasksPath, "utf-8");
+    const parsedTasks = parseLegacyTasks(rawTasks);
+    const { active, completed } = buildTaskEntries(parsedTasks, nowIso);
+    if (active.length === 0 && completed.length === 0) {
+      result.warnings.push("Legacy current-tasks.md did not contain actionable items.");
+    } else {
+      await writeJson(activeTasksPath, active, !!options.dryRun);
+      await appendJsonLines(join17(cwd, ARCHIVE_COMPLETED_PATH), completed, !!options.dryRun);
+      result.migratedTasks = true;
+    }
+    if (options.removeLegacy) {
+      const archived = await archiveLegacyFile(legacyTasksPath, join17(cwd, HISTORY_LEGACY_DIR), !!options.dryRun);
+      result.archivedLegacyFiles.push(archived);
+      if (!options.dryRun) {
+        await unlink3(legacyTasksPath);
+      }
+    }
+  }
+  if (existsSync17(join17(cwd, ACTIVE_ARCH_PATH2)) && existsSync17(join17(cwd, LEGACY_ARCH_PATH))) {
+    result.warnings.push("Active architecture already exists; legacy ARCHITECTURE.md left untouched.");
+  }
+  if (existsSync17(join17(cwd, ACTIVE_TASKS_PATH)) && existsSync17(join17(cwd, LEGACY_TASKS_PATH))) {
+    result.warnings.push("Active tasks already exist; legacy current-tasks.md left untouched.");
+  }
+  return result;
+}
+
+// src/core/governance/sqlite.ts
+import { join as join18 } from "path";
+import matter3 from "gray-matter";
+import Database2 from "better-sqlite3";
+var ARCH_PATH = join18(".archon", "active", "architecture.md");
+var TASKS_PATH = join18(".archon", "active", "tasks.json");
+var HANDOFFS_PATH = join18(".archon", "history", "handoffs.jsonl");
+var DECISIONS_PATH = join18(".archon", "history", "decision_log.jsonl");
+var COMPLETED_PATH = join18(".archon", "archive", "completed_tasks.jsonl");
+
+// src/cli/governance.ts
+var ACTIVE_ARCH_PATH3 = join19(".archon", "active", "architecture.md");
+var ACTIVE_TASKS_PATH2 = join19(".archon", "active", "tasks.json");
+var CURRENT_CONTEXT_PATH = join19(".archon", "current_context.md");
+var HANDOFF_HISTORY_PATH = join19(".archon", "history", "handoffs.jsonl");
+var COMPLETED_TASKS_PATH = join19(".archon", "archive", "completed_tasks.jsonl");
+var TASK_STATUSES = ["pending", "in_progress", "verification", "done"];
+function isTaskStatus(value) {
+  return typeof value === "string" && TASK_STATUSES.includes(value);
+}
+function resolveArchitecturePath2(cwd) {
+  const agdPath = join19(cwd, ACTIVE_ARCH_PATH3);
+  if (existsSync18(agdPath)) {
+    return { path: agdPath, source: "agd" };
+  }
+  const legacyPath = join19(cwd, "ARCHITECTURE.md");
+  if (existsSync18(legacyPath)) {
+    return { path: legacyPath, source: "legacy" };
+  }
+  return { path: null, source: null };
+}
+function parseTasks(raw) {
+  if (!Array.isArray(raw)) return null;
+  const tasks = [];
+  for (const item of raw) {
+    if (typeof item !== "object" || item === null) return null;
+    const entry = item;
+    if (typeof entry["id"] !== "string") return null;
+    if (typeof entry["description"] !== "string") return null;
+    if (!isTaskStatus(entry["status"])) return null;
+    if (typeof entry["created_at"] !== "string") return null;
+    tasks.push({
+      id: entry["id"],
+      description: entry["description"],
+      status: entry["status"],
+      created_at: entry["created_at"],
+      parent_id: typeof entry["parent_id"] === "string" ? entry["parent_id"] : void 0,
+      assigned_to: typeof entry["assigned_to"] === "string" ? entry["assigned_to"] : void 0,
+      updated_at: typeof entry["updated_at"] === "string" ? entry["updated_at"] : void 0,
+      notes: typeof entry["notes"] === "string" ? entry["notes"] : void 0
+    });
+  }
+  return tasks;
+}
+function countTaskStatuses(tasks) {
+  const counts = {
+    pending: 0,
+    in_progress: 0,
+    verification: 0,
+    done: 0
+  };
+  for (const task of tasks) {
+    if (counts[task.status] === void 0) continue;
+    counts[task.status] += 1;
+  }
+  return counts;
+}
+function parseContextMeta(content) {
+  const timestampMatch = content.match(/^Timestamp:\s*(.+)$/m);
+  const reasonMatch = content.match(/^Reason:\s*(.+)$/m);
+  return {
+    timestamp: timestampMatch?.[1]?.trim(),
+    reason: reasonMatch?.[1]?.trim()
+  };
+}
+function renderStatusCounts(counts) {
+  const total = Object.values(counts).reduce((sum, value) => sum + value, 0);
+  if (total === 0) return;
+  console.log(chalk17.dim(`  Tasks: ${total} total`));
+  console.log(
+    chalk17.dim(
+      `    pending: ${counts.pending} | in_progress: ${counts.in_progress} | verification: ${counts.verification} | done: ${counts.done}`
+    )
+  );
+}
+function lineCount(content) {
+  const trimmed = content.trim();
+  if (!trimmed) return 0;
+  return trimmed.split("\n").length;
+}
+function createGovernanceCommand() {
+  const governance = new Command2("governance").alias("gov").description("Manage governance store (AGD)");
+  governance.command("status").description("Show governance status from AGD store").action(async () => {
+    const cwd = process.cwd();
+    const store = new GovernanceStore(cwd);
+    store.ensureStructure();
+    console.log(chalk17.bold("\nGovernance Status\n"));
+    const archInfo = resolveArchitecturePath2(cwd);
+    if (archInfo.path) {
+      const parser = new ArchitectureParser(archInfo.path);
+      const parsed = await parser.parse();
+      if (parsed.success && parsed.schema) {
+        const posture = parsed.schema.qualityLevel?.posture ?? "unknown";
+        console.log(chalk17.green("  \u2713") + ` Architecture (${archInfo.source})`);
+        console.log(chalk17.dim(`    posture: ${posture}`));
+        console.log(chalk17.dim(`    invariants: ${parsed.schema.invariants.length}`));
+        console.log(chalk17.dim(`    protected paths: ${parsed.schema.protectedPaths.length}`));
+      } else {
+        console.log(chalk17.yellow("  ! Architecture present but failed to parse"));
+      }
+    } else {
+      console.log(chalk17.yellow("  \u25CB No architecture file found"));
+    }
+    const tasksPath = join19(cwd, ACTIVE_TASKS_PATH2);
+    if (existsSync18(tasksPath)) {
+      try {
+        const tasksRaw = JSON.parse(readFileSync6(tasksPath, "utf-8"));
+        const tasks2 = parseTasks(tasksRaw);
+        if (tasks2) {
+          renderStatusCounts(countTaskStatuses(tasks2));
+        } else {
+          console.log(chalk17.yellow("  ! tasks.json present but invalid"));
+        }
+      } catch {
+        console.log(chalk17.yellow("  ! tasks.json present but unreadable"));
+      }
+    }
+    const contextPath = join19(cwd, CURRENT_CONTEXT_PATH);
+    if (existsSync18(contextPath)) {
+      const content = readFileSync6(contextPath, "utf-8");
+      const meta = parseContextMeta(content);
+      console.log(chalk17.dim(`  Handoff: ${meta.timestamp ?? "present"}`));
+      if (meta.reason) {
+        console.log(chalk17.dim(`    reason: ${meta.reason}`));
+      }
+    }
+    const handoffHistoryPath = join19(cwd, HANDOFF_HISTORY_PATH);
+    if (existsSync18(handoffHistoryPath)) {
+      const count = lineCount(readFileSync6(handoffHistoryPath, "utf-8"));
+      if (count > 0) {
+        console.log(chalk17.dim(`  Handoff entries: ${count}`));
+      }
+    }
+    const completedPath = join19(cwd, COMPLETED_TASKS_PATH);
+    if (existsSync18(completedPath)) {
+      const count = lineCount(readFileSync6(completedPath, "utf-8"));
+      if (count > 0) {
+        console.log(chalk17.dim(`  Completed tasks archived: ${count}`));
+      }
+    }
+    console.log("");
+  });
+  const architecture = governance.command("architecture").description("Read or update governance architecture");
+  architecture.command("show").description("Show active architecture content").option("--raw", "Show full file including frontmatter").action(async (options) => {
+    const cwd = process.cwd();
+    const store = new GovernanceStore(cwd);
+    const archInfo = resolveArchitecturePath2(cwd);
+    if (!archInfo.path) {
+      console.log(chalk17.yellow("No architecture file found."));
+      return;
+    }
+    if (options.raw) {
+      const raw = readFileSync6(archInfo.path, "utf-8");
+      console.log(raw.trimEnd());
+      return;
+    }
+    if (archInfo.source === "agd") {
+      const result = await store.readArchitecture();
+      if (!result.ok) {
+        console.log(chalk17.red(`Failed to read architecture: ${result.error}`));
+        return;
+      }
+      if (!result.value) {
+        console.log(chalk17.yellow("Architecture file is empty."));
+        return;
+      }
+      console.log(result.value);
+      return;
+    }
+    const legacyRaw = readFileSync6(archInfo.path, "utf-8");
+    const legacyParsed = matter4(legacyRaw);
+    const legacyContent = legacyParsed.content.trim();
+    if (!legacyContent) {
+      console.log(chalk17.yellow("Architecture file is empty."));
+      return;
+    }
+    console.log(legacyContent);
+  });
+  architecture.command("update").description("Update active architecture with change reason").requiredOption("-f, --file <path>", "Path to new architecture content").requiredOption("-r, --reason <text>", "Reason for the change (required)").option("-b, --by <name>", "Updated by (optional)").action(async (options) => {
+    const cwd = process.cwd();
+    const filePath = options.file;
+    if (!existsSync18(filePath)) {
+      console.log(chalk17.red(`File not found: ${filePath}`));
+      process.exit(1);
+    }
+    const content = await readFile12(filePath, "utf-8");
+    const store = new GovernanceStore(cwd);
+    const result = await store.updateArchitecture(content, options.reason, options.by);
+    if (!result.ok) {
+      console.log(chalk17.red(`Failed to update architecture: ${result.error}`));
+      process.exit(1);
+    }
+    console.log(chalk17.green("\u2713 Architecture updated"));
+  });
+  const tasks = governance.command("task").description("Update tasks in governance store");
+  tasks.command("update <taskId>").description("Update task status and notes").requiredOption("-s, --status <status>", "Status: pending, in_progress, verification, done").option("-n, --notes <text>", "Optional notes").action(async (taskId, options) => {
+    const status2 = options.status;
+    if (!isTaskStatus(status2)) {
+      console.log(chalk17.red(`Invalid status: ${options.status}`));
+      process.exit(1);
+    }
+    const store = new GovernanceStore(process.cwd());
+    const result = await store.updateTask(taskId, status2, options.notes);
+    if (!result.ok) {
+      console.log(chalk17.red(`Failed to update task: ${result.error}`));
+      process.exit(1);
+    }
+    console.log(chalk17.green(`\u2713 Task ${taskId} updated to ${status2}`));
+  });
+  governance.command("handoff").description("Log a handoff entry and update current context").requiredOption("-r, --reason <text>", "Reason for handoff").requiredOption("-s, --summary <text>", "Summary (single paragraph)").requiredOption("-n, --next <actions...>", "Next actions (space-separated)").option("-f, --from <agent>", "Agent or source name").option("-t, --timestamp <iso>", "Timestamp override (ISO 8601)").action(async (options) => {
+    const store = new GovernanceStore(process.cwd());
+    const entry = {
+      timestamp: options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      from_agent: options.from,
+      reason: options.reason,
+      summary: options.summary,
+      next_actions: options.next
+    };
+    const result = await store.logHandoff(entry);
+    if (!result.ok) {
+      console.log(chalk17.red(`Failed to log handoff: ${result.error}`));
+      process.exit(1);
+    }
+    console.log(chalk17.green("\u2713 Handoff logged"));
+  });
+  governance.command("migrate").description("Migrate legacy governance files into AGD structure").option("--remove-legacy", "Archive legacy files after migration").option("--dry-run", "Show what would change without writing files").option("-b, --by <name>", "Updated by label for architecture migration").action(async (options) => {
+    const result = await migrateLegacyGovernance({
+      cwd: process.cwd(),
+      removeLegacy: options.removeLegacy,
+      dryRun: options.dryRun,
+      updatedBy: options.by
+    });
+    console.log(chalk17.bold("\nMigration Summary"));
+    console.log(
+      result.migratedArchitecture ? chalk17.green("  \u2713 Architecture migrated") : chalk17.dim("  \u25CB Architecture migration skipped")
+    );
+    console.log(
+      result.migratedTasks ? chalk17.green("  \u2713 Tasks migrated") : chalk17.dim("  \u25CB Tasks migration skipped")
+    );
+    if (result.archivedLegacyFiles.length > 0) {
+      console.log(chalk17.dim("  Archived legacy files:"));
+      for (const file of result.archivedLegacyFiles) {
+        console.log(chalk17.dim(`    - ${file}`));
+      }
+    }
+    if (result.warnings.length > 0) {
+      console.log(chalk17.yellow("\nWarnings:"));
+      for (const warning of result.warnings) {
+        console.log(chalk17.yellow(`  - ${warning}`));
+      }
+    }
+    console.log("");
+  });
+  return governance;
+}
+
 // src/cli/index.ts
-var program = new Command2();
+var program = new Command3();
 program.name("archon").description("Local-first AI-powered development governance").version(getCurrentVersion()).action(async () => {
   const cwd = process.cwd();
   const wasInitialized = isInitialized(cwd);
   if (!wasInitialized) {
-    console.log(chalk17.blue("\nArchonDev is not initialized in this folder.\n"));
+    console.log(chalk18.blue("\nArchonDev is not initialized in this folder.\n"));
     await init({ analyze: true, git: true });
   }
   await start({ skipGovernanceBanner: !wasInitialized });
@@ -7049,7 +7902,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(chalk17.red('Invalid provider. Use "github" or "google"'));
+    console.error(chalk18.red('Invalid provider. Use "github" or "google"'));
     process.exit(1);
   }
   await login(provider);
@@ -7183,6 +8036,7 @@ reviewCommand.action(async () => {
   await reviewStatus();
 });
 program.addCommand(createDepsCommand());
+program.addCommand(createGovernanceCommand());
 var a11yCommand = program.command("a11y").description("Accessibility checking and compliance for web deployments");
 a11yCommand.command("check").description("Run WCAG 2.2 AA accessibility audit").option("-v, --verbose", "Show all issues including minor ones").option("-f, --format <format>", "Output format (text or json)", "text").action(async (options) => {
   await a11yCheck(options);
@@ -7243,7 +8097,7 @@ cleanupCmd.command("check").description("Analyze workspace for bloat and mainten
 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(chalk17.red("Invalid action. Use: enable, disable, or status"));
+    console.error(chalk18.red("Invalid action. Use: enable, disable, or status"));
     process.exit(1);
   }
   await cleanupAuto(action);