archondev 2.18.8 → 2.19.1

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-BPYTLJOS.js";
+} from "./chunk-QTBRLNZQ.js";
 import {
   DependencyParser,
   EnvironmentConfigLoader,
   EnvironmentValidator,
   execute
-} from "./chunk-SLUOXPMX.js";
+} from "./chunk-OREGEFTF.js";
 import {
   cloudCancel,
   cloudLogs,
@@ -60,15 +60,19 @@ import {
 } from "./chunk-EBHHIUCB.js";
 import {
   list
-} from "./chunk-HANCO7VL.js";
+} from "./chunk-YA562WHL.js";
 import {
   listLocalAtoms,
   loadAtom,
   plan
-} from "./chunk-AFC2XMZS.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);
     }
   }
 };
@@ -2738,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();
@@ -3030,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"];
@@ -3053,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;
@@ -3102,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;
@@ -3168,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-6AZ3U2DA.js");
+    const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
     await plan2(initialResponse, {});
     return;
   }
@@ -3192,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-6AZ3U2DA.js");
+        const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
         await plan2(initialResponse, {});
         break;
       case "3":
@@ -3220,9 +3236,9 @@ async function showNewProjectMenu(cwd) {
       await quickStart(cwd);
       break;
     case "3": {
-      const description = await prompt("Describe what you want to do");
+      const description = await promptWithCommands("Describe what you want to do", { allowMultiline: true });
       if (description.trim()) {
-        const { plan: plan2 } = await import("./plan-6AZ3U2DA.js");
+        const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
         await plan2(description, {});
       }
       break;
@@ -3286,9 +3302,9 @@ async function runExploreFlow(cwd) {
   const choice = await promptWithCommands("Enter choice");
   switch (choice.toLowerCase()) {
     case "1": {
-      const description = await prompt("Describe what you want to do");
+      const description = await promptWithCommands("Describe what you want to do", { allowMultiline: true });
       if (description.trim()) {
-        const { plan: plan2 } = await import("./plan-6AZ3U2DA.js");
+        const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
         await plan2(description, {});
       }
       break;
@@ -3381,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;
@@ -3396,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);
@@ -3545,9 +3564,9 @@ ${state.forbiddenPatterns?.length ? `- **Forbidden patterns:** ${state.forbidden
   console.log();
   const continueChoice = await promptYesNo("Would you like to plan your first task now?", true);
   if (continueChoice) {
-    const description = await prompt("Describe what you want to build first");
+    const description = await promptWithCommands("Describe what you want to build first", { allowMultiline: true });
     if (description.trim()) {
-      const { plan: plan2 } = await import("./plan-6AZ3U2DA.js");
+      const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
       await plan2(description, {});
     }
   }
@@ -3601,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-6AZ3U2DA.js");
+    const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
     await plan2(response, {});
     return;
   }
@@ -3630,9 +3649,9 @@ async function showAdaptExistingMenu(cwd, state) {
       await runExploreFlow(cwd);
       break;
     case "2": {
-      const description = await prompt("Describe what you want to do");
+      const description = await promptWithCommands("Describe what you want to do", { allowMultiline: true });
       if (description.trim()) {
-        const { plan: plan2 } = await import("./plan-6AZ3U2DA.js");
+        const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
         await plan2(description, {});
       }
       break;
@@ -3684,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();
@@ -3720,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");
@@ -3783,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();
@@ -3800,18 +3827,18 @@ async function showReviewProgress(cwd) {
   }
 }
 async function planTask() {
-  const { plan: plan2 } = await import("./plan-6AZ3U2DA.js");
-  const description = await prompt("Describe what you want to build");
+  const { plan: plan2 } = await import("./plan-HCYXLSSD.js");
+  const description = await promptWithCommands("Describe what you want to build", { allowMultiline: true });
   if (description.trim()) {
     await plan2(description, {});
   }
 }
 async function listAtoms() {
-  const { list: list2 } = await import("./list-QWQ4QBKM.js");
+  const { list: list2 } = await import("./list-REPLUXJF.js");
   await list2({});
 }
 async function executeNext() {
-  const { listLocalAtoms: listLocalAtoms2 } = await import("./plan-6AZ3U2DA.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();
@@ -3882,11 +3909,11 @@ async function executeNext() {
         }
       }
       if (selectedMode === "parallel-cloud") {
-        const { parallelExecuteCloud: parallelExecuteCloud2 } = await import("./parallel-NXSICGS5.js");
+        const { parallelExecuteCloud: parallelExecuteCloud2 } = await import("./parallel-23VQYK7H.js");
         await parallelExecuteCloud2(runIds);
         return;
       }
-      const { parallelExecute } = await import("./parallel-NXSICGS5.js");
+      const { parallelExecute } = await import("./parallel-23VQYK7H.js");
       await parallelExecute(runIds);
       return;
     }
@@ -3894,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-VGBCOD5W.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, {});
@@ -3921,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();
   }
@@ -3936,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;
     }
@@ -4014,32 +4041,28 @@ function prompt(question) {
     });
   });
 }
-function promptMultiline(question, idleMs = 250) {
+function promptMultiline(question) {
   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) => {
+      if (line.trim() === ".") {
+        rl.close();
+        return;
+      }
       lines.push(line);
-      scheduleFinish();
     });
     rl.on("SIGINT", () => {
       rl.close();
       process.exit(0);
     });
-    rl.setPrompt(`${chalk6.cyan("?")} ${question}: `);
+    rl.on("close", () => {
+      resolve(lines.join("\n").trimEnd());
+    });
+    rl.setPrompt(`${chalk6.cyan("?")} ${question} (multi-line: end with a single '.' line or Ctrl+D): `);
     rl.prompt();
   });
 }
@@ -4059,7 +4082,7 @@ async function promptWithCommands(question, options = {}) {
 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({});
@@ -4099,17 +4122,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;
     }
@@ -4245,9 +4268,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 = {}) {
@@ -4301,9 +4324,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 = {}) {
@@ -4347,9 +4370,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 = {}) {
@@ -4429,9 +4452,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 = {}) {
@@ -4507,9 +4530,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 = {}) {
@@ -4562,9 +4585,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) {
@@ -5222,9 +5245,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() {
@@ -5265,9 +5288,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) {
@@ -5316,9 +5339,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() {
@@ -5358,9 +5381,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);
   }
 }
 
@@ -6394,9 +6417,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) {
@@ -7075,13 +7098,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() {
@@ -7108,13 +7131,1031 @@ async function modelsList() {
   console.log();
 }
 
+// src/cli/governance.ts
+import { Command as Command2 } from "commander";
+import chalk17 from "chalk";
+import { existsSync as existsSync19, readFileSync as readFileSync7 } 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 { existsSync as existsSync18, mkdirSync as mkdirSync5, readFileSync as readFileSync6 } from "fs";
+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");
+var GovernanceSqliteView = class {
+  db = null;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  init(cwd) {
+    const archonDir = join18(cwd, ".archon");
+    if (!existsSync18(archonDir)) {
+      mkdirSync5(archonDir, { recursive: true });
+    }
+    const dbPath = this.config.inMemory ? ":memory:" : join18(cwd, this.config.dbPath ?? ".archon/governance.db");
+    this.db = new Database2(dbPath);
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      CREATE TABLE IF NOT EXISTS architecture (
+        id TEXT PRIMARY KEY,
+        version REAL,
+        last_updated TEXT,
+        updated_by TEXT,
+        change_reason TEXT,
+        content TEXT
+      );
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        description TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT,
+        notes TEXT
+      );
+      CREATE TABLE IF NOT EXISTS completed_tasks (
+        id TEXT PRIMARY KEY,
+        description TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT,
+        notes TEXT
+      );
+      CREATE TABLE IF NOT EXISTS handoffs (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        from_agent TEXT,
+        reason TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        next_actions TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS decisions (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        category TEXT NOT NULL,
+        change_reason TEXT NOT NULL,
+        updated_by TEXT,
+        diff_summary TEXT
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS governance_fts USING fts5(
+        source,
+        record_id,
+        text,
+        timestamp
+      );
+    `);
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  async loadFromDisk(cwd) {
+    if (!this.db) {
+      throw new Error("GovernanceSqliteView not initialized. Call init() first.");
+    }
+    const stats = {
+      tasks: 0,
+      completedTasks: 0,
+      handoffs: 0,
+      decisions: 0,
+      architecture: false
+    };
+    this.db.exec("DELETE FROM governance_fts; DELETE FROM architecture; DELETE FROM tasks; DELETE FROM completed_tasks; DELETE FROM handoffs; DELETE FROM decisions;");
+    const archPath = join18(cwd, ARCH_PATH);
+    if (existsSync18(archPath)) {
+      const raw = readFileSync6(archPath, "utf-8");
+      const parsed = matter3(raw);
+      const data = parsed.data;
+      const versionRaw = data["version"];
+      const version = typeof versionRaw === "number" ? versionRaw : typeof versionRaw === "string" ? Number.parseFloat(versionRaw) : null;
+      const archId = "architecture";
+      const content = parsed.content.trim();
+      this.db.prepare(
+        `INSERT OR REPLACE INTO architecture (id, version, last_updated, updated_by, change_reason, content)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(
+        archId,
+        Number.isFinite(version) ? version : null,
+        typeof data["last_updated"] === "string" ? data["last_updated"] : null,
+        typeof data["updated_by"] === "string" ? data["updated_by"] : null,
+        typeof data["change_reason"] === "string" ? data["change_reason"] : null,
+        content
+      );
+      this.db.prepare(
+        `INSERT INTO governance_fts (source, record_id, text, timestamp)
+         VALUES (?, ?, ?, ?)`
+      ).run("architecture", archId, content, typeof data["last_updated"] === "string" ? data["last_updated"] : null);
+      stats.architecture = true;
+    }
+    const tasksPath = join18(cwd, TASKS_PATH);
+    if (existsSync18(tasksPath)) {
+      const raw = readFileSync6(tasksPath, "utf-8");
+      const tasks = JSON.parse(raw);
+      const insertTask = this.db.prepare(
+        `INSERT OR REPLACE INTO tasks (id, description, status, created_at, updated_at, notes)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      );
+      const insertFts = this.db.prepare(
+        `INSERT INTO governance_fts (source, record_id, text, timestamp)
+         VALUES (?, ?, ?, ?)`
+      );
+      for (const task of tasks) {
+        insertTask.run(task.id, task.description, task.status, task.created_at, task.updated_at ?? null, task.notes ?? null);
+        insertFts.run("task", task.id, task.description + (task.notes ? `
+${task.notes}` : ""), task.updated_at ?? task.created_at);
+        stats.tasks += 1;
+      }
+    }
+    const completedPath = join18(cwd, COMPLETED_PATH);
+    if (existsSync18(completedPath)) {
+      const lines = readFileSync6(completedPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+      const insertCompleted = this.db.prepare(
+        `INSERT OR REPLACE INTO completed_tasks (id, description, status, created_at, updated_at, notes)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      );
+      const insertFts = this.db.prepare(
+        `INSERT INTO governance_fts (source, record_id, text, timestamp)
+         VALUES (?, ?, ?, ?)`
+      );
+      for (const line of lines) {
+        const task = JSON.parse(line);
+        insertCompleted.run(task.id, task.description, task.status, task.created_at, task.updated_at ?? null, task.notes ?? null);
+        insertFts.run("completed_task", task.id, task.description + (task.notes ? `
+${task.notes}` : ""), task.updated_at ?? task.created_at);
+        stats.completedTasks += 1;
+      }
+    }
+    const handoffsPath = join18(cwd, HANDOFFS_PATH);
+    if (existsSync18(handoffsPath)) {
+      const lines = readFileSync6(handoffsPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+      const insertHandoff = this.db.prepare(
+        `INSERT OR REPLACE INTO handoffs (id, timestamp, from_agent, reason, summary, next_actions)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      );
+      const insertFts = this.db.prepare(
+        `INSERT INTO governance_fts (source, record_id, text, timestamp)
+         VALUES (?, ?, ?, ?)`
+      );
+      for (const line of lines) {
+        const entry = JSON.parse(line);
+        const id = `${entry.timestamp}-${entry.from_agent ?? "unknown"}`;
+        const nextActions = entry.next_actions.join("\n");
+        insertHandoff.run(id, entry.timestamp, entry.from_agent ?? null, entry.reason, entry.summary, nextActions);
+        insertFts.run("handoff", id, `${entry.summary}
+${nextActions}`, entry.timestamp);
+        stats.handoffs += 1;
+      }
+    }
+    const decisionsPath = join18(cwd, DECISIONS_PATH);
+    if (existsSync18(decisionsPath)) {
+      const lines = readFileSync6(decisionsPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+      const insertDecision = this.db.prepare(
+        `INSERT OR REPLACE INTO decisions (id, timestamp, category, change_reason, updated_by, diff_summary)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      );
+      const insertFts = this.db.prepare(
+        `INSERT INTO governance_fts (source, record_id, text, timestamp)
+         VALUES (?, ?, ?, ?)`
+      );
+      for (const line of lines) {
+        const entry = JSON.parse(line);
+        const id = `${entry.timestamp}-${entry.category}`;
+        insertDecision.run(
+          id,
+          entry.timestamp,
+          entry.category,
+          entry.change_reason,
+          entry.updated_by ?? null,
+          entry.diff_summary ?? null
+        );
+        insertFts.run("decision", id, `${entry.change_reason}${entry.diff_summary ? `
+${entry.diff_summary}` : ""}`, entry.timestamp);
+        stats.decisions += 1;
+      }
+    }
+    return stats;
+  }
+  search(query, limit = 10) {
+    if (!this.db) {
+      throw new Error("GovernanceSqliteView not initialized. Call init() first.");
+    }
+    const rows = this.db.prepare(
+      `SELECT source, record_id as recordId, text, timestamp, rank
+       FROM governance_fts
+       WHERE governance_fts MATCH ?
+       ORDER BY rank
+       LIMIT ?`
+    ).all(query, limit);
+    return rows;
+  }
+  listTasks(status2) {
+    if (!this.db) {
+      throw new Error("GovernanceSqliteView not initialized. Call init() first.");
+    }
+    if (status2) {
+      return this.db.prepare(
+        "SELECT id, description, status, created_at, updated_at, notes FROM tasks WHERE status = ? ORDER BY created_at"
+      ).all(status2);
+    }
+    return this.db.prepare(
+      "SELECT id, description, status, created_at, updated_at, notes FROM tasks ORDER BY created_at"
+    ).all();
+  }
+  getLatestHandoff() {
+    if (!this.db) {
+      throw new Error("GovernanceSqliteView not initialized. Call init() first.");
+    }
+    const row = this.db.prepare(
+      "SELECT timestamp, from_agent as fromAgent, reason, summary, next_actions as nextActions FROM handoffs ORDER BY timestamp DESC LIMIT 1"
+    ).get();
+    if (!row) return null;
+    return {
+      timestamp: row.timestamp,
+      from_agent: row.fromAgent ?? void 0,
+      reason: row.reason,
+      summary: row.summary,
+      next_actions: row.nextActions.split("\n").filter((item) => item.trim().length > 0)
+    };
+  }
+  getArchitecture() {
+    if (!this.db) {
+      throw new Error("GovernanceSqliteView not initialized. Call init() first.");
+    }
+    const row = this.db.prepare(
+      "SELECT version, last_updated, updated_by, change_reason, content FROM architecture LIMIT 1"
+    ).get();
+    if (!row) return null;
+    return {
+      content: row.content,
+      meta: {
+        version: row.version,
+        last_updated: row.last_updated,
+        updated_by: row.updated_by,
+        change_reason: row.change_reason
+      }
+    };
+  }
+};
+
+// 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 (existsSync19(agdPath)) {
+    return { path: agdPath, source: "agd" };
+  }
+  const legacyPath = join19(cwd, "ARCHITECTURE.md");
+  if (existsSync19(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 (existsSync19(tasksPath)) {
+      try {
+        const tasksRaw = JSON.parse(readFileSync7(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 (existsSync19(contextPath)) {
+      const content = readFileSync7(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 (existsSync19(handoffHistoryPath)) {
+      const count = lineCount(readFileSync7(handoffHistoryPath, "utf-8"));
+      if (count > 0) {
+        console.log(chalk17.dim(`  Handoff entries: ${count}`));
+      }
+    }
+    const completedPath = join19(cwd, COMPLETED_TASKS_PATH);
+    if (existsSync19(completedPath)) {
+      const count = lineCount(readFileSync7(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 = readFileSync7(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 = readFileSync7(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 (!existsSync19(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("");
+  });
+  governance.command("sqlite-init").description("Initialize or refresh local governance SQLite DB").option("--db <path>", "Override DB path (default: .archon/governance.db)").action(async (options) => {
+    const cwd = process.cwd();
+    const view = new GovernanceSqliteView({ dbPath: options.db ?? ".archon/governance.db" });
+    view.init(cwd);
+    await view.loadFromDisk(cwd);
+    view.close();
+    console.log(chalk17.green("\u2713 Governance SQLite DB initialized"));
+  });
+  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 });
@@ -7122,7 +8163,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);
@@ -7256,6 +8297,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);
@@ -7316,7 +8358,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);