@rigstate/cli 0.7.25 → 0.7.29

package/dist/index.js

@@ -286,12 +286,12 @@ async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
       }
       const files = syncResponse.data.data.files;
       if (files && Array.isArray(files)) {
-        const fs24 = await import("fs/promises");
-        const path27 = await import("path");
+        const fs25 = await import("fs/promises");
+        const path28 = await import("path");
         for (const file of files) {
-          const filePath = path27.join(process.cwd(), file.path);
-          await fs24.mkdir(path27.dirname(filePath), { recursive: true });
-          await fs24.writeFile(filePath, file.content, "utf-8");
+          const filePath = path28.join(process.cwd(), file.path);
+          await fs25.mkdir(path28.dirname(filePath), { recursive: true });
+          await fs25.writeFile(filePath, file.content, "utf-8");
         }
         console.log(chalk3.dim(`      \u{1F4BE} Wrote ${files.length} rule files to local .cursor/rules/`));
       }
@@ -335,142 +335,12 @@ var init_sync_rules = __esm({
   }
 });
 
-// src/commands/hooks.ts
-var hooks_exports = {};
-__export(hooks_exports, {
-  createHooksCommand: () => createHooksCommand
-});
-import { Command as Command4 } from "commander";
-import chalk4 from "chalk";
-import fs2 from "fs/promises";
-import path3 from "path";
-function createHooksCommand() {
-  const hooks = new Command4("hooks").description("Manage git hooks for Guardian integration");
-  hooks.command("install").description("Install pre-commit hook to run Guardian checks").option("--strict [level]", 'Strict level: "all" or "critical" (default)', "critical").action(async (options) => {
-    try {
-      const gitDir = path3.join(process.cwd(), ".git");
-      try {
-        await fs2.access(gitDir);
-      } catch {
-        console.log(chalk4.red("\u274C Not a git repository."));
-        console.log(chalk4.dim('   Initialize with "git init" first.'));
-        process.exit(1);
-      }
-      const hooksDir = path3.join(gitDir, "hooks");
-      await fs2.mkdir(hooksDir, { recursive: true });
-      const preCommitPath = path3.join(hooksDir, "pre-commit");
-      let existingContent = "";
-      try {
-        existingContent = await fs2.readFile(preCommitPath, "utf-8");
-        if (existingContent.includes("rigstate")) {
-          console.log(chalk4.yellow("\u26A0 Rigstate pre-commit hook already installed."));
-          console.log(chalk4.dim('   Use "rigstate hooks uninstall" to remove first.'));
-          return;
-        }
-      } catch {
-      }
-      let script = PRE_COMMIT_SCRIPT;
-      if (options.strict === "all") {
-        script = script.replace("--strict=critical", "--strict");
-      }
-      if (existingContent && !existingContent.includes("rigstate")) {
-        const combinedScript = existingContent + "\n\n" + script.replace("#!/bin/sh\n", "");
-        await fs2.writeFile(preCommitPath, combinedScript, { mode: 493 });
-        console.log(chalk4.green("\u2705 Rigstate hook appended to existing pre-commit."));
-      } else {
-        await fs2.writeFile(preCommitPath, script, { mode: 493 });
-        console.log(chalk4.green("\u2705 Pre-commit hook installed!"));
-      }
-      console.log(chalk4.dim(`   Path: ${preCommitPath}`));
-      console.log(chalk4.dim(`   Strict level: ${options.strict}`));
-      console.log("");
-      console.log(chalk4.cyan("Guardian will now check your code before each commit."));
-      console.log(chalk4.dim('Use "rigstate hooks uninstall" to remove the hook.'));
-    } catch (error) {
-      console.error(chalk4.red("Failed to install hook:"), error.message);
-      process.exit(1);
-    }
-  });
-  hooks.command("uninstall").description("Remove Rigstate pre-commit hook").action(async () => {
-    try {
-      const preCommitPath = path3.join(process.cwd(), ".git", "hooks", "pre-commit");
-      try {
-        const content = await fs2.readFile(preCommitPath, "utf-8");
-        if (!content.includes("rigstate")) {
-          console.log(chalk4.yellow("\u26A0 No Rigstate hook found in pre-commit."));
-          return;
-        }
-        if (content.includes("# Rigstate Guardian Pre-commit Hook") && content.trim().split("\n").filter((l) => l && !l.startsWith("#")).length <= 4) {
-          await fs2.unlink(preCommitPath);
-          console.log(chalk4.green("\u2705 Pre-commit hook removed."));
-        } else {
-          const lines = content.split("\n");
-          const filteredLines = [];
-          let inRigstateSection = false;
-          for (const line of lines) {
-            if (line.includes("Rigstate Guardian Pre-commit Hook")) {
-              inRigstateSection = true;
-              continue;
-            }
-            if (inRigstateSection && line.includes("exit $?")) {
-              inRigstateSection = false;
-              continue;
-            }
-            if (!inRigstateSection && !line.includes("rigstate check")) {
-              filteredLines.push(line);
-            }
-          }
-          await fs2.writeFile(preCommitPath, filteredLines.join("\n"), { mode: 493 });
-          console.log(chalk4.green("\u2705 Rigstate section removed from pre-commit hook."));
-        }
-      } catch {
-        console.log(chalk4.yellow("\u26A0 No pre-commit hook found."));
-      }
-    } catch (error) {
-      console.error(chalk4.red("Failed to uninstall hook:"), error.message);
-      process.exit(1);
-    }
-  });
-  return hooks;
-}
-var PRE_COMMIT_SCRIPT;
-var init_hooks = __esm({
-  "src/commands/hooks.ts"() {
-    "use strict";
-    init_esm_shims();
-    PRE_COMMIT_SCRIPT = `#!/bin/sh
-# Rigstate Guardian Pre-commit Hook
-# Installed by: rigstate hooks install
-
-# 1. Silent Sentinel Check (Phase 5)
-if [ -f .rigstate/guardian.lock ]; then
-    echo "\u{1F6D1} INTERVENTION ACTIVE: Commit blocked by Silent Sentinel."
-    echo "   A critical violation ('HARD_LOCK') was detected by the Guardian Daemon."
-    echo "   Please fix the violation to unlock the repo."
-    echo ""
-    if grep -q "HARD_LOCK_ACTIVE" .rigstate/guardian.lock; then
-        cat .rigstate/guardian.lock
-    fi
-    exit 1
-fi
-
-echo "\u{1F6E1}\uFE0F  Running Guardian checks..."
-
-# Run check with strict mode for critical violations
-rigstate check --staged --strict=critical
-
-# Exit with the same code as rigstate check
-exit $?
-`;
-  }
-});
-
 // src/commands/suggest.ts
 var suggest_exports = {};
 __export(suggest_exports, {
   suggestNextMove: () => suggestNextMove
 });
-import chalk5 from "chalk";
+import chalk4 from "chalk";
 import axios3 from "axios";
 async function suggestNextMove(projectId, apiKey, apiUrl) {
   try {
@@ -490,18 +360,18 @@ async function suggestNextMove(projectId, apiKey, apiUrl) {
     if (tasks.length === 0) return;
     const nextTask = tasks[0];
     console.log("");
-    console.log(chalk5.bold("\u{1F3AF} TACTICAL INTELLIGENCE"));
-    console.log(chalk5.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    console.log(`${chalk5.bold("Active Phase:")}  Implementation`);
-    console.log(`${chalk5.bold("Next Mission:")}  ${chalk5.cyan(nextTask.title)}`);
+    console.log(chalk4.bold("\u{1F3AF} TACTICAL INTELLIGENCE"));
+    console.log(chalk4.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`${chalk4.bold("Active Phase:")}  Implementation`);
+    console.log(`${chalk4.bold("Next Mission:")}  ${chalk4.cyan(nextTask.title)}`);
     if (nextTask.role) {
-      console.log(`${chalk5.bold("Required Role:")} ${chalk5.magenta(nextTask.role)}`);
+      console.log(`${chalk4.bold("Required Role:")} ${chalk4.magenta(nextTask.role)}`);
     }
     console.log("");
-    console.log(chalk5.yellow("SUGGESTED NEXT MOVE:"));
-    console.log(chalk5.white(`> rigstate work start ${nextTask.id}   `) + chalk5.dim("(Start this task)"));
-    console.log(chalk5.white(`> rigstate chat "How do I solve T-${nextTask.step_number}?" `) + chalk5.dim("(Ask Architect)"));
-    console.log(chalk5.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk4.yellow("SUGGESTED NEXT MOVE:"));
+    console.log(chalk4.white(`> rigstate work start ${nextTask.id}   `) + chalk4.dim("(Start this task)"));
+    console.log(chalk4.white(`> rigstate chat "How do I solve T-${nextTask.step_number}?" `) + chalk4.dim("(Ask Architect)"));
+    console.log(chalk4.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     console.log("");
   } catch (e) {
   }
@@ -521,9 +391,9 @@ __export(skills_provisioner_exports, {
   provisionSkills: () => provisionSkills
 });
 import axios6 from "axios";
-import fs7 from "fs/promises";
-import path8 from "path";
-import chalk9 from "chalk";
+import fs6 from "fs/promises";
+import path7 from "path";
+import chalk8 from "chalk";
 async function provisionSkills(apiUrl, apiKey, projectId, rootDir) {
   const skills = [];
   try {
@@ -545,18 +415,18 @@ async function provisionSkills(apiUrl, apiKey, projectId, rootDir) {
     }
   } catch (e) {
     const msg = e.response?.data?.error || e.message;
-    console.log(chalk9.dim(`  (Skills API not available: ${msg}, using core library)`));
+    console.log(chalk8.dim(`  (Skills API not available: ${msg}, using core library)`));
   }
   if (skills.length === 0) {
     const { getRigstateStandardSkills } = await import("@rigstate/rules-engine");
     const coreSkills = getRigstateStandardSkills();
     skills.push(...coreSkills);
   }
-  const skillsDir = path8.join(rootDir, ".agent", "skills");
-  await fs7.mkdir(skillsDir, { recursive: true });
+  const skillsDir = path7.join(rootDir, ".agent", "skills");
+  await fs6.mkdir(skillsDir, { recursive: true });
   for (const skill of skills) {
-    const skillDir = path8.join(skillsDir, skill.name);
-    await fs7.mkdir(skillDir, { recursive: true });
+    const skillDir = path7.join(skillsDir, skill.name);
+    await fs6.mkdir(skillDir, { recursive: true });
     const skillContent = `---
 name: ${skill.name}
 description: ${skill.description}
@@ -569,10 +439,10 @@ ${skill.content}
 
 ---
 *Provisioned by Rigstate CLI. Do not modify manually.*`;
-    const skillPath = path8.join(skillDir, "SKILL.md");
-    await fs7.writeFile(skillPath, skillContent, "utf-8");
+    const skillPath = path7.join(skillDir, "SKILL.md");
+    await fs6.writeFile(skillPath, skillContent, "utf-8");
   }
-  console.log(chalk9.green(`  \u2705 Provisioned ${skills.length} skill(s) to .agent/skills/`));
+  console.log(chalk8.green(`  \u2705 Provisioned ${skills.length} skill(s) to .agent/skills/`));
   return skills;
 }
 function generateSkillsDiscoveryBlock(skills) {
@@ -587,16 +457,16 @@ ${skillBlocks}
 </available_skills>`;
 }
 async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
-  const rulesPath = path8.join(rootDir, ".cursorrules");
+  const rulesPath = path7.join(rootDir, ".cursorrules");
   let rulesContent = "";
   try {
-    rulesContent = await fs7.readFile(rulesPath, "utf-8");
+    rulesContent = await fs6.readFile(rulesPath, "utf-8");
   } catch (e) {
     return false;
   }
   const isProvisioned = rulesContent.includes(`<name>${skillId}</name>`) || rulesContent.includes(`.agent/skills/${skillId}`);
   if (isProvisioned) return false;
-  console.log(chalk9.yellow(`  \u26A1 JIT PROVISIONING: Injecting ${skillId}...`));
+  console.log(chalk8.yellow(`  \u26A1 JIT PROVISIONING: Injecting ${skillId}...`));
   try {
     const skills = await provisionSkills(apiUrl, apiKey, projectId, rootDir);
     const skillsBlock = generateSkillsDiscoveryBlock(skills);
@@ -611,10 +481,10 @@ async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
         rulesContent = rulesContent.slice(0, insertPoint + 3) + "\n\n" + skillsBlock + "\n" + rulesContent.slice(insertPoint + 3);
       }
     }
-    await fs7.writeFile(rulesPath, rulesContent, "utf-8");
+    await fs6.writeFile(rulesPath, rulesContent, "utf-8");
     return true;
   } catch (e) {
-    console.log(chalk9.red(`  Failed to provision skill: ${e.message}`));
+    console.log(chalk8.red(`  Failed to provision skill: ${e.message}`));
     return false;
   }
 }
@@ -635,13 +505,13 @@ __export(governance_exports, {
   performOverride: () => performOverride,
   setSoftLock: () => setSoftLock
 });
-import fs8 from "fs/promises";
-import path9 from "path";
-import chalk10 from "chalk";
+import fs7 from "fs/promises";
+import path8 from "path";
+import chalk9 from "chalk";
 async function getGovernanceConfig(rootDir = process.cwd()) {
   try {
-    const configPath = path9.join(rootDir, "rigstate.config.json");
-    const content = await fs8.readFile(configPath, "utf-8");
+    const configPath = path8.join(rootDir, "rigstate.config.json");
+    const content = await fs7.readFile(configPath, "utf-8");
     const userConfig = JSON.parse(content);
     return {
       governance: {
@@ -655,37 +525,37 @@ async function getGovernanceConfig(rootDir = process.cwd()) {
 }
 async function getSessionState(rootDir = process.cwd()) {
   try {
-    const sessionPath = path9.join(rootDir, ".rigstate", "session.json");
-    const content = await fs8.readFile(sessionPath, "utf-8");
+    const sessionPath = path8.join(rootDir, ".rigstate", "session.json");
+    const content = await fs7.readFile(sessionPath, "utf-8");
     return JSON.parse(content);
   } catch (e) {
     return DEFAULT_SESSION;
   }
 }
 async function setSoftLock(reason, violationId, rootDir = process.cwd()) {
-  const sessionPath = path9.join(rootDir, ".rigstate", "session.json");
+  const sessionPath = path8.join(rootDir, ".rigstate", "session.json");
   const state = {
     status: "SOFT_LOCK",
     active_violation: violationId,
     lock_reason: reason,
     last_updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs8.mkdir(path9.dirname(sessionPath), { recursive: true });
-  await fs8.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs7.mkdir(path8.dirname(sessionPath), { recursive: true });
+  await fs7.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
 }
 async function clearSoftLock(rootDir = process.cwd()) {
-  const sessionPath = path9.join(rootDir, ".rigstate", "session.json");
+  const sessionPath = path8.join(rootDir, ".rigstate", "session.json");
   const state = {
     ...DEFAULT_SESSION,
     last_updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs8.mkdir(path9.dirname(sessionPath), { recursive: true });
-  await fs8.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs7.mkdir(path8.dirname(sessionPath), { recursive: true });
+  await fs7.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
 }
 async function performOverride(violationId, reason, rootDir = process.cwd()) {
   const config2 = await getGovernanceConfig(rootDir);
   if (!config2.governance.allow_overrides) {
-    console.log(chalk10.red("\u274C Overrides are disabled for this project."));
+    console.log(chalk9.red("\u274C Overrides are disabled for this project."));
     return false;
   }
   await clearSoftLock(rootDir);
@@ -722,22 +592,22 @@ var watchdog_exports = {};
 __export(watchdog_exports, {
   runGuardianWatchdog: () => runGuardianWatchdog
 });
-import fs9 from "fs/promises";
-import path10 from "path";
-import chalk11 from "chalk";
+import fs8 from "fs/promises";
+import path9 from "path";
+import chalk10 from "chalk";
 import axios7 from "axios";
 async function countLines(filePath) {
   try {
-    const content = await fs9.readFile(filePath, "utf-8");
+    const content = await fs8.readFile(filePath, "utf-8");
     return content.split("\n").length;
   } catch (e) {
     return 0;
   }
 }
 async function getFiles(dir, extension) {
-  const entries = await fs9.readdir(dir, { withFileTypes: true });
+  const entries = await fs8.readdir(dir, { withFileTypes: true });
   const files = await Promise.all(entries.map(async (entry) => {
-    const res = path10.resolve(dir, entry.name);
+    const res = path9.resolve(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".next" || entry.name === "dist") return [];
       return getFiles(res, extension);
@@ -765,8 +635,8 @@ async function fetchRulesFromApi(projectId) {
     }
   } catch (error) {
     try {
-      const cachePath = path10.join(process.cwd(), CACHE_FILE);
-      const content = await fs9.readFile(cachePath, "utf-8");
+      const cachePath = path9.join(process.cwd(), CACHE_FILE);
+      const content = await fs8.readFile(cachePath, "utf-8");
       const cached = JSON.parse(content);
       if (cached.settings) {
         return {
@@ -785,7 +655,7 @@ async function fetchRulesFromApi(projectId) {
   };
 }
 async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
-  console.log(chalk11.bold("\n\u{1F6E1}\uFE0F  Active Guardian Watchdog Initiated..."));
+  console.log(chalk10.bold("\n\u{1F6E1}\uFE0F  Active Guardian Watchdog Initiated..."));
   let lmax = settings.lmax || DEFAULT_LMAX;
   let lmaxWarning = settings.lmax_warning || DEFAULT_LMAX_WARNING;
   let ruleSource = settings.lmax ? "Settings (Passed)" : "Default";
@@ -795,47 +665,47 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
     lmaxWarning = apiRules.lmaxWarning;
     ruleSource = apiRules.source;
   }
-  console.log(chalk11.dim(`Governance Rules: L_max=${lmax}, L_max_warning=${lmaxWarning}, Source: ${ruleSource}`));
+  console.log(chalk10.dim(`Governance Rules: L_max=${lmax}, L_max_warning=${lmaxWarning}, Source: ${ruleSource}`));
   const targetExtensions = [".ts", ".tsx"];
   let scanTarget = rootPath;
-  const webSrc = path10.join(rootPath, "apps", "web", "src");
+  const webSrc = path9.join(rootPath, "apps", "web", "src");
   try {
-    await fs9.access(webSrc);
+    await fs8.access(webSrc);
     scanTarget = webSrc;
   } catch {
   }
-  console.log(chalk11.dim(`Scanning target: ${path10.relative(process.cwd(), scanTarget)}`));
+  console.log(chalk10.dim(`Scanning target: ${path9.relative(process.cwd(), scanTarget)}`));
   const files = await getFiles(scanTarget, targetExtensions);
   let violations = 0;
   let warnings = 0;
   const results = [];
   for (const file of files) {
     const lines = await countLines(file);
-    const relPath = path10.relative(rootPath, file);
+    const relPath = path9.relative(rootPath, file);
     if (lines > lmax) {
       results.push({ file: relPath, lines, status: "VIOLATION" });
       violations++;
-      console.log(chalk11.red(`[VIOLATION] ${relPath}: ${lines} lines (Limit: ${lmax})`));
+      console.log(chalk10.red(`[VIOLATION] ${relPath}: ${lines} lines (Limit: ${lmax})`));
     } else if (lines > lmaxWarning) {
       results.push({ file: relPath, lines, status: "WARNING" });
       warnings++;
-      console.log(chalk11.yellow(`[WARNING]   ${relPath}: ${lines} lines (Threshold: ${lmaxWarning})`));
+      console.log(chalk10.yellow(`[WARNING]   ${relPath}: ${lines} lines (Threshold: ${lmaxWarning})`));
     }
   }
   if (violations === 0 && warnings === 0) {
-    console.log(chalk11.green(`\u2714 All ${files.length} files are within governance limits.`));
+    console.log(chalk10.green(`\u2714 All ${files.length} files are within governance limits.`));
   } else {
-    console.log("\n" + chalk11.bold("Summary:"));
-    console.log(chalk11.red(`Violations: ${violations}`));
-    console.log(chalk11.yellow(`Warnings:   ${warnings}`));
+    console.log("\n" + chalk10.bold("Summary:"));
+    console.log(chalk10.red(`Violations: ${violations}`));
+    console.log(chalk10.yellow(`Warnings:   ${warnings}`));
     const { getGovernanceConfig: getGovernanceConfig2, setSoftLock: setSoftLock2, InterventionLevel: InterventionLevel2 } = await Promise.resolve().then(() => (init_governance(), governance_exports));
     const { governance } = await getGovernanceConfig2(rootPath);
-    console.log(chalk11.dim(`Intervention Level: ${InterventionLevel2[governance.intervention_level] || "UNKNOWN"} (${governance.intervention_level})`));
+    console.log(chalk10.dim(`Intervention Level: ${InterventionLevel2[governance.intervention_level] || "UNKNOWN"} (${governance.intervention_level})`));
     if (violations > 0) {
-      console.log(chalk11.red.bold("\nCRITICAL: Governance violations detected. Immediate refactoring required."));
+      console.log(chalk10.red.bold("\nCRITICAL: Governance violations detected. Immediate refactoring required."));
       if (governance.intervention_level >= InterventionLevel2.SENTINEL) {
-        console.log(chalk11.red.bold("\u{1F6D1} SENTINEL MODE: Session SOFT_LOCKED until resolved."));
-        console.log(chalk11.red('   Run "rigstate override <id> --reason \\"...\\"" if this is an emergency.'));
+        console.log(chalk10.red.bold("\u{1F6D1} SENTINEL MODE: Session SOFT_LOCKED until resolved."));
+        console.log(chalk10.red('   Run "rigstate override <id> --reason \\"...\\"" if this is an emergency.'));
         await setSoftLock2("Sentinel Mode: Governance Violations Detected", "ARC-VIOLATION", rootPath);
       }
     }
@@ -858,9 +728,9 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
       }, {
         headers: { Authorization: `Bearer ${apiKey}` }
       });
-      console.log(chalk11.dim("\u2714 Violations synced to Rigstate Cloud."));
+      console.log(chalk10.dim("\u2714 Violations synced to Rigstate Cloud."));
     } catch (e) {
-      console.log(chalk11.dim("\u26A0 Cloud sync skipped: " + (e.message || "Unknown")));
+      console.log(chalk10.dim("\u26A0 Cloud sync skipped: " + (e.message || "Unknown")));
     }
   }
 }
@@ -1663,10 +1533,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path27, isFile, isDirectory) {
-      log(`checking %s`, path27);
+    function check(path28, isFile, isDirectory) {
+      log(`checking %s`, path28);
       try {
-        const stat = fs_1.statSync(path27);
+        const stat = fs_1.statSync(path28);
         if (stat.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -1686,8 +1556,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path27, type = exports.READABLE) {
-      return check(path27, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path28, type = exports.READABLE) {
+      return check(path28, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -1757,7 +1627,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@rigstate/cli",
-      version: "0.7.25",
+      version: "0.7.29",
       description: "Rigstate CLI - Code audit, sync and supervision tool",
       type: "module",
       main: "./dist/index.js",
@@ -1813,8 +1683,8 @@ var require_package = __commonJS({
 
 // src/index.ts
 init_esm_shims();
-import { Command as Command23 } from "commander";
-import chalk34 from "chalk";
+import { Command as Command24 } from "commander";
+import chalk35 from "chalk";
 
 // src/commands/login.ts
 init_esm_shims();
@@ -1867,30 +1737,68 @@ Your API key has been securely stored. You can now use "rigstate scan" to audit
 // src/commands/link.ts
 init_esm_shims();
 init_config();
-import { Command as Command5 } from "commander";
-import fs3 from "fs/promises";
-import path4 from "path";
-import chalk6 from "chalk";
+import { Command as Command4 } from "commander";
+import fs2 from "fs/promises";
+import path3 from "path";
+import chalk5 from "chalk";
 import os from "os";
 function createLinkCommand() {
-  return new Command5("link").description("Link current directory to a Rigstate project").argument("<projectId>", "Project ID to link").action(async (projectId) => {
+  return new Command4("link").description("Link current directory to a Rigstate project").argument("[projectId]", "Project ID to link").action(async (projectId) => {
     try {
-      const globalPath = path4.join(os.homedir(), ".rigstate", "config.json");
-      const globalData = await fs3.readFile(globalPath, "utf-8").catch(() => null);
+      const globalPath = path3.join(os.homedir(), ".rigstate", "config.json");
+      const globalData = await fs2.readFile(globalPath, "utf-8").catch(() => null);
       if (globalData) {
         const config2 = JSON.parse(globalData);
         const cwd = process.cwd();
         if (config2.overrides && config2.overrides[cwd]) {
           const overrideId = config2.overrides[cwd];
-          if (overrideId !== projectId) {
-            console.warn(chalk6.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
+          console.warn(chalk5.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
+          if (!projectId) projectId = overrideId;
+          else if (projectId !== overrideId) {
+            console.warn(chalk5.red(`Ignoring provided ID ${projectId}. Using override.`));
             projectId = overrideId;
           }
         }
       }
     } catch (e) {
     }
-    const manifestPath = path4.join(process.cwd(), ".rigstate");
+    if (!projectId) {
+      try {
+        const inquirer8 = (await import("inquirer")).default;
+        const { getApiKey: _getApiKey, getApiUrl: _getApiUrl } = await Promise.resolve().then(() => (init_config(), config_exports));
+        const apiKey = getApiKey();
+        const apiUrl = getApiUrl();
+        if (!apiKey) {
+          console.error(chalk5.red('Not authenticated. Please run "rigstate login" or provide a Project ID.'));
+          process.exit(1);
+        }
+        console.log(chalk5.dim("Fetching your projects..."));
+        const axios23 = (await import("axios")).default;
+        const response = await axios23.get(`${apiUrl}/api/v1/projects`, {
+          headers: { Authorization: `Bearer ${apiKey}` }
+        });
+        if (!response.data.success || !response.data.data.projects?.length) {
+          console.error(chalk5.yellow("No projects found. Create one at https://app.rigstate.com"));
+          process.exit(1);
+        }
+        const choices = response.data.data.projects.map((p) => ({
+          name: `${p.name} (${p.id})`,
+          value: p.id
+        }));
+        const answer = await inquirer8.prompt([{
+          type: "list",
+          name: "id",
+          message: "Select project to link:",
+          choices
+        }]);
+        projectId = answer.id;
+      } catch (e) {
+        console.error(chalk5.red(`Failed to fetch projects: ${e.message}`));
+        console.error("Please provide project ID manually: rigstate link <id>");
+        process.exit(1);
+      }
+    }
+    const manifestPath = path3.join(process.cwd(), ".rigstate");
     const content = {
       project_id: projectId,
       linked_at: (/* @__PURE__ */ new Date()).toISOString()
@@ -1900,60 +1808,96 @@ function createLinkCommand() {
       content.api_url = currentUrl;
     }
     try {
-      await fs3.writeFile(manifestPath, JSON.stringify(content, null, 2), "utf-8");
-      console.log(chalk6.green(`\u2714 Linked to project ID: ${projectId}`));
-      console.log(chalk6.dim(`Created local context manifest at .rigstate`));
+      await fs2.mkdir(path3.dirname(manifestPath), { recursive: true });
+      await fs2.writeFile(manifestPath, JSON.stringify(content, null, 2), "utf-8");
+      console.log(chalk5.green(`\u2714 Linked to project ID: ${projectId}`));
+      console.log(chalk5.dim(`Created local context manifest at .rigstate`));
       console.log("");
-      console.log(chalk6.bold("\u{1F916} Rigstate Automation Detected"));
+      console.log(chalk5.bold("\u{1F916} Rigstate Automation Detected"));
       console.log("");
       const { getApiKey: _getApiKey, getApiUrl: _getApiUrl } = await Promise.resolve().then(() => (init_config(), config_exports));
       const apiKey = getApiKey();
       const apiUrl = getApiUrl();
       if (apiKey) {
-        console.log(chalk6.blue("\u{1F510} Checking Vault for secrets..."));
+        console.log(chalk5.blue("\u{1F510} Checking Vault for secrets..."));
         const { syncEnv: syncEnv2 } = await Promise.resolve().then(() => (init_env(), env_exports));
         await syncEnv2(projectId, apiKey, apiUrl, true);
-        console.log(chalk6.blue("\u{1F9E0} Syncing neural instructions..."));
+        console.log(chalk5.blue("\u{1F9E0} Syncing neural instructions..."));
         const { syncProjectRules: syncProjectRules2 } = await Promise.resolve().then(() => (init_sync_rules(), sync_rules_exports));
         await syncProjectRules2(projectId, apiKey, apiUrl);
-        console.log(chalk6.blue("\u{1F6E1}\uFE0F  Injecting Guardian hooks..."));
-        const { createHooksCommand: createHooksCommand2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
+        console.log(chalk5.blue("\u{1F6E1}\uFE0F  Injecting Guardian hooks & Safety nets..."));
         await installHooks(process.cwd());
+        await hardenGitIgnore(process.cwd());
         console.log("");
-        console.log(chalk6.bold.green("\u{1F680} Link Complete! Your environment is ready."));
+        console.log(chalk5.bold.green("\u{1F680} Link Complete! Your environment is ready."));
         const { suggestNextMove: suggestNextMove2 } = await Promise.resolve().then(() => (init_suggest(), suggest_exports));
         await suggestNextMove2(projectId, apiKey, apiUrl);
       } else {
         console.log("");
-        console.log(chalk6.bold.green("\u{1F680} Link Complete!"));
+        console.log(chalk5.bold.green("\u{1F680} Link Complete!"));
       }
     } catch (error) {
-      if (error.message.includes("Not authenticated")) {
-        console.warn(chalk6.yellow('\u26A0\uFE0F  Not authenticated. Run "rigstate login" to enable automation features.'));
+      if (error.message?.includes("Not authenticated")) {
+        console.warn(chalk5.yellow('\u26A0\uFE0F  Not authenticated. Run "rigstate login" to enable automation features.'));
       } else {
-        console.error(chalk6.red(`Failed to link project: ${error.message}`));
+        console.error(chalk5.red(`Failed to link project: ${error.message}`));
       }
     }
   });
 }
+async function hardenGitIgnore(cwd) {
+  const fs25 = await import("fs/promises");
+  const path28 = await import("path");
+  const ignorePath = path28.join(cwd, ".gitignore");
+  const REQUIRED_IGNORES = [
+    "# Rigstate - Runtime Artifacts (Do not commit)",
+    ".rigstate/ACTIVE_VIOLATIONS.md",
+    ".rigstate/CURRENT_CONTEXT.md",
+    ".rigstate/daemon.pid",
+    ".rigstate/daemon.state.json",
+    ".rigstate/*.log",
+    ".rigstate/*.bak",
+    "# Keep identity tracked",
+    "!.rigstate/identity.json"
+  ];
+  try {
+    let content = "";
+    try {
+      content = await fs25.readFile(ignorePath, "utf-8");
+    } catch {
+      content = "";
+    }
+    const missing = REQUIRED_IGNORES.filter((line) => !content.includes(line) && !line.startsWith("#"));
+    if (missing.length > 0) {
+      console.log(chalk5.dim("   Configuring .gitignore for Rigstate safety..."));
+      const toAppend = "\n\n" + REQUIRED_IGNORES.join("\n") + "\n";
+      await fs25.writeFile(ignorePath, content + toAppend, "utf-8");
+      console.log(chalk5.green("   \u2714 .gitignore updated (Artifacts protected)"));
+    } else {
+      console.log(chalk5.green("   \u2714 .gitignore already hardened"));
+    }
+  } catch (e) {
+    console.warn(chalk5.yellow(`   Could not update .gitignore: ${e.message}`));
+  }
+}
 async function installHooks(cwd) {
-  const fs24 = await import("fs/promises");
-  const path27 = await import("path");
+  const fs25 = await import("fs/promises");
+  const path28 = await import("path");
   try {
-    await fs24.access(path27.join(cwd, ".git"));
+    await fs25.access(path28.join(cwd, ".git"));
   } catch {
-    console.log(chalk6.dim("   (Not a git repository, skipping hooks)"));
+    console.log(chalk5.dim("   (Not a git repository, skipping hooks)"));
     return;
   }
-  const hooksDir = path27.join(cwd, ".husky");
+  const hooksDir = path28.join(cwd, ".husky");
   try {
-    const preCommitPath = path27.join(cwd, ".git/hooks/pre-commit");
+    const preCommitPath = path28.join(cwd, ".git/hooks/pre-commit");
     let shouldInstall = false;
     try {
-      await fs24.access(preCommitPath);
-      const content = await fs24.readFile(preCommitPath, "utf-8");
+      await fs25.access(preCommitPath);
+      const content = await fs25.readFile(preCommitPath, "utf-8");
       if (content.includes("rigstate")) {
-        console.log(chalk6.green("   \u2714 Git hooks already active"));
+        console.log(chalk5.green("   \u2714 Git hooks already active"));
       } else {
         shouldInstall = true;
       }
@@ -1975,23 +1919,23 @@ echo "\u{1F6E1}\uFE0F  Running Guardian checks..."
 rigstate check --staged --strict=critical
 exit $?
 `;
-      await fs24.mkdir(path27.dirname(preCommitPath), { recursive: true });
+      await fs25.mkdir(path28.dirname(preCommitPath), { recursive: true });
       if (await fileExists(preCommitPath)) {
-        const existing = await fs24.readFile(preCommitPath, "utf-8");
-        await fs24.writeFile(preCommitPath, existing + "\n\n" + PRE_COMMIT_SCRIPT2.replace("#!/bin/sh\n", ""), { mode: 493 });
+        const existing = await fs25.readFile(preCommitPath, "utf-8");
+        await fs25.writeFile(preCommitPath, existing + "\n\n" + PRE_COMMIT_SCRIPT2.replace("#!/bin/sh\n", ""), { mode: 493 });
       } else {
-        await fs24.writeFile(preCommitPath, PRE_COMMIT_SCRIPT2, { mode: 493 });
+        await fs25.writeFile(preCommitPath, PRE_COMMIT_SCRIPT2, { mode: 493 });
       }
-      console.log(chalk6.green("   \u2714 Applied Guardian protection (git-hooks)"));
+      console.log(chalk5.green("   \u2714 Applied Guardian protection (git-hooks)"));
     }
   } catch (e) {
-    console.log(chalk6.dim("   (Skipped hooks: " + e.message + ")"));
+    console.log(chalk5.dim("   (Skipped hooks: " + e.message + ")"));
   }
 }
-async function fileExists(path27) {
-  const fs24 = await import("fs/promises");
+async function fileExists(path28) {
+  const fs25 = await import("fs/promises");
   try {
-    await fs24.access(path27);
+    await fs25.access(path28);
     return true;
   } catch {
     return false;
@@ -2001,22 +1945,22 @@ async function fileExists(path27) {
 // src/commands/scan.ts
 init_esm_shims();
 init_config();
-import { Command as Command6 } from "commander";
-import chalk7 from "chalk";
+import { Command as Command5 } from "commander";
+import chalk6 from "chalk";
 import ora3 from "ora";
 import axios4 from "axios";
 import { glob } from "glob";
-import fs5 from "fs/promises";
-import path6 from "path";
+import fs4 from "fs/promises";
+import path5 from "path";
 
 // src/utils/files.ts
 init_esm_shims();
-import fs4 from "fs/promises";
-import path5 from "path";
+import fs3 from "fs/promises";
+import path4 from "path";
 async function readGitignore(dir) {
-  const gitignorePath = path5.join(dir, ".gitignore");
+  const gitignorePath = path4.join(dir, ".gitignore");
   try {
-    const content = await fs4.readFile(gitignorePath, "utf-8");
+    const content = await fs3.readFile(gitignorePath, "utf-8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error) {
     return [];
@@ -2078,13 +2022,13 @@ function isCodeFile(filePath) {
     ".vue",
     ".svelte"
   ];
-  const ext = path5.extname(filePath).toLowerCase();
+  const ext = path4.extname(filePath).toLowerCase();
   return codeExtensions.includes(ext);
 }
 
 // src/commands/scan.ts
 function createScanCommand() {
-  return new Command6("scan").description("Scan code files for security and quality issues").argument("[path]", "Directory or file to scan", ".").option("--json", "Output results as JSON").option("--project <id>", "Project ID to associate with this scan").action(async (targetPath, options) => {
+  return new Command5("scan").description("Scan code files for security and quality issues").argument("[path]", "Directory or file to scan", ".").option("--json", "Output results as JSON").option("--project <id>", "Project ID to associate with this scan").action(async (targetPath, options) => {
     const spinner = ora3();
     try {
       const apiKey = getApiKey();
@@ -2092,26 +2036,26 @@ function createScanCommand() {
       const projectId = options.project || getProjectId();
       if (!projectId) {
         console.warn(
-          chalk7.yellow(
+          chalk6.yellow(
             "\u26A0\uFE0F  No project ID specified. Use --project <id> or set a default."
           )
         );
       }
-      const scanPath = path6.resolve(process.cwd(), targetPath);
-      spinner.start(`Scanning ${chalk7.cyan(scanPath)}...`);
+      const scanPath = path5.resolve(process.cwd(), targetPath);
+      spinner.start(`Scanning ${chalk6.cyan(scanPath)}...`);
       const gitignorePatterns = await readGitignore(scanPath);
-      const pattern = path6.join(scanPath, "**/*");
+      const pattern = path5.join(scanPath, "**/*");
       const allFiles = await glob(pattern, {
         nodir: true,
         dot: false,
         ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"]
       });
       const codeFiles = allFiles.filter((file) => {
-        const relativePath = path6.relative(scanPath, file);
+        const relativePath = path5.relative(scanPath, file);
         return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
       });
       if (codeFiles.length === 0) {
-        spinner.warn(chalk7.yellow("No code files found to scan."));
+        spinner.warn(chalk6.yellow("No code files found to scan."));
         return;
       }
       spinner.text = `Found ${codeFiles.length} files. Scanning...`;
@@ -2120,10 +2064,10 @@ function createScanCommand() {
       const severityCounts = {};
       for (let i = 0; i < codeFiles.length; i++) {
         const filePath = codeFiles[i];
-        const relativePath = path6.relative(scanPath, filePath);
+        const relativePath = path5.relative(scanPath, filePath);
         spinner.text = `Scanning ${i + 1}/${codeFiles.length}: ${relativePath}`;
         try {
-          const content = await fs5.readFile(filePath, "utf-8");
+          const content = await fs4.readFile(filePath, "utf-8");
           const response = await axios4.post(
             `${apiUrl}/api/v1/audit`,
             {
@@ -2159,15 +2103,15 @@ function createScanCommand() {
           }
         } catch (fileError) {
           if (axios4.isAxiosError(fileError)) {
-            console.warn(chalk7.yellow(`
+            console.warn(chalk6.yellow(`
 \u26A0\uFE0F  Skipping ${relativePath}: ${fileError.message}`));
           } else {
-            console.warn(chalk7.yellow(`
+            console.warn(chalk6.yellow(`
 \u26A0\uFE0F  Error reading ${relativePath}`));
           }
         }
       }
-      spinner.succeed(chalk7.green("\u2705 Scan completed!"));
+      spinner.succeed(chalk6.green("\u2705 Scan completed!"));
       const aggregatedResponse = {
         results,
         summary: {
@@ -2182,21 +2126,21 @@ function createScanCommand() {
         printPrettyResults(aggregatedResponse);
       }
     } catch (error) {
-      spinner.fail(chalk7.red("\u274C Scan failed"));
+      spinner.fail(chalk6.red("\u274C Scan failed"));
       if (axios4.isAxiosError(error)) {
         if (error.response) {
-          console.error(chalk7.red("API Error:"), error.response.data);
+          console.error(chalk6.red("API Error:"), error.response.data);
         } else if (error.request) {
           console.error(
-            chalk7.red("Network Error:"),
+            chalk6.red("Network Error:"),
             "Could not reach the API. Is the server running?"
           );
         } else {
-          console.error(chalk7.red("Error:"), error.message);
+          console.error(chalk6.red("Error:"), error.message);
         }
       } else {
         console.error(
-          chalk7.red("Error:"),
+          chalk6.red("Error:"),
           error instanceof Error ? error.message : "Unknown error"
         );
       }
@@ -2206,10 +2150,10 @@ function createScanCommand() {
 }
 function printPrettyResults(data) {
   const { results, summary } = data;
-  console.log("\n" + chalk7.bold("\u{1F4CA} Scan Summary"));
-  console.log(chalk7.dim("\u2500".repeat(60)));
-  console.log(`Total Files Scanned: ${chalk7.cyan(summary.total_files)}`);
-  console.log(`Total Issues Found: ${chalk7.yellow(summary.total_issues)}`);
+  console.log("\n" + chalk6.bold("\u{1F4CA} Scan Summary"));
+  console.log(chalk6.dim("\u2500".repeat(60)));
+  console.log(`Total Files Scanned: ${chalk6.cyan(summary.total_files)}`);
+  console.log(`Total Issues Found: ${chalk6.yellow(summary.total_issues)}`);
   if (summary.by_severity) {
     console.log("\nIssues by Severity:");
     Object.entries(summary.by_severity).forEach(([severity, count]) => {
@@ -2218,87 +2162,87 @@ function printPrettyResults(data) {
     });
   }
   if (results && results.length > 0) {
-    console.log("\n" + chalk7.bold("\u{1F50D} Detailed Results"));
-    console.log(chalk7.dim("\u2500".repeat(60)));
+    console.log("\n" + chalk6.bold("\u{1F50D} Detailed Results"));
+    console.log(chalk6.dim("\u2500".repeat(60)));
     results.forEach((result) => {
       if (result.issues && result.issues.length > 0) {
         console.log(`
-${chalk7.bold(result.file_path)}`);
+${chalk6.bold(result.file_path)}`);
         result.issues.forEach((issue) => {
           const severityColor = getSeverityColor(issue.severity);
-          const lineInfo = issue.line ? chalk7.dim(`:${issue.line}`) : "";
+          const lineInfo = issue.line ? chalk6.dim(`:${issue.line}`) : "";
           console.log(
             `  ${severityColor(`[${issue.severity.toUpperCase()}]`)} ${issue.type}${lineInfo}`
           );
-          console.log(`  ${chalk7.dim(issue.message)}`);
+          console.log(`  ${chalk6.dim(issue.message)}`);
         });
       }
     });
   }
-  console.log("\n" + chalk7.dim("\u2500".repeat(60)));
+  console.log("\n" + chalk6.dim("\u2500".repeat(60)));
 }
 function getSeverityColor(severity) {
   switch (severity.toLowerCase()) {
     case "critical":
-      return chalk7.red.bold;
+      return chalk6.red.bold;
     case "high":
-      return chalk7.red;
+      return chalk6.red;
     case "medium":
-      return chalk7.yellow;
+      return chalk6.yellow;
     case "low":
-      return chalk7.blue;
+      return chalk6.blue;
     case "info":
-      return chalk7.gray;
+      return chalk6.gray;
     default:
-      return chalk7.white;
+      return chalk6.white;
   }
 }
 
 // src/commands/fix.ts
 init_esm_shims();
 init_config();
-import { Command as Command7 } from "commander";
-import chalk8 from "chalk";
+import { Command as Command6 } from "commander";
+import chalk7 from "chalk";
 import ora4 from "ora";
 import axios5 from "axios";
 import { glob as glob2 } from "glob";
-import fs6 from "fs/promises";
-import path7 from "path";
+import fs5 from "fs/promises";
+import path6 from "path";
 import inquirer from "inquirer";
 import * as Diff from "diff";
 function createFixCommand() {
-  return new Command7("fix").description("Scan and interactively FIX detected issues using Rigstate AI").argument("[path]", "Directory or file to scan", ".").option("--project <id>", "Project ID to context-aware audit").action(async (targetPath, options) => {
+  return new Command6("fix").description("Scan and interactively FIX detected issues using Rigstate AI").argument("[path]", "Directory or file to scan", ".").option("--project <id>", "Project ID to context-aware audit").action(async (targetPath, options) => {
     const spinner = ora4();
     try {
       const apiKey = getApiKey();
       const apiUrl = getApiUrl();
       const projectId = options.project || getProjectId();
       if (!projectId) {
-        console.log(chalk8.yellow("\u26A0\uFE0F  Project ID is required for fixing. Using default or pass --project <id>"));
+        console.log(chalk7.yellow("\u26A0\uFE0F  Project ID is required for fixing. Using default or pass --project <id>"));
       }
-      const scanPath = path7.resolve(process.cwd(), targetPath);
+      const scanPath = path6.resolve(process.cwd(), targetPath);
       const gitignorePatterns = await readGitignore(scanPath);
-      const pattern = path7.join(scanPath, "**/*");
+      const pattern = path6.join(scanPath, "**/*");
       const allFiles = await glob2(pattern, { nodir: true, dot: false, ignore: ["**/node_modules/**", "**/.git/**"] });
       const codeFiles = allFiles.filter((file) => {
-        const relativePath = path7.relative(scanPath, file);
+        const relativePath = path6.relative(scanPath, file);
         return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
       });
       if (codeFiles.length === 0) {
-        console.log(chalk8.yellow("No code files found."));
+        console.log(chalk7.yellow("No code files found."));
         return;
       }
-      console.log(chalk8.bold(`
+      console.log(chalk7.bold(`
 \u{1F9E0} Rigstate Fix Mode`));
-      console.log(chalk8.dim(`Scanning ${codeFiles.length} files with Project Context...
+      console.log(chalk7.dim(`Scanning ${codeFiles.length} files with Project Context...
 `));
       let fixedCount = 0;
       for (let i = 0; i < codeFiles.length; i++) {
         const filePath = codeFiles[i];
-        const relativePath = path7.relative(scanPath, filePath);
+        const relativePath = path6.relative(scanPath, filePath);
         spinner.start(`Analyzing ${relativePath}...`);
         try {
-          const content = await fs6.readFile(filePath, "utf-8");
+          const content = await fs5.readFile(filePath, "utf-8");
           const response = await axios5.post(
             `${apiUrl}/api/v1/audit`,
             { content, file_path: relativePath, project_id: projectId },
@@ -2309,22 +2253,22 @@ function createFixCommand() {
           if (fixableIssues.length > 0) {
             spinner.stop();
             console.log(`
-${chalk8.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
+${chalk7.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
             for (const issue of fixableIssues) {
-              console.log(chalk8.red(`
+              console.log(chalk7.red(`
 [${issue.type}] ${issue.title}`));
-              console.log(chalk8.dim(issue.suggestion || issue.message));
+              console.log(chalk7.dim(issue.suggestion || issue.message));
               const diff = Diff.createTwoFilesPatch(relativePath, relativePath, content, issue.fixed_content, "Current", "Fixed");
               console.log("\n" + diff.split("\n").slice(0, 15).join("\n") + (diff.split("\n").length > 15 ? "\n..." : ""));
               const { apply } = await inquirer.prompt([{
                 type: "confirm",
                 name: "apply",
-                message: `Apply this fix to ${chalk8.cyan(relativePath)}?`,
+                message: `Apply this fix to ${chalk7.cyan(relativePath)}?`,
                 default: true
               }]);
               if (apply) {
-                await fs6.writeFile(filePath, issue.fixed_content);
-                console.log(chalk8.green(`\u2705 Fixed applied!`));
+                await fs5.writeFile(filePath, issue.fixed_content);
+                console.log(chalk7.green(`\u2705 Fixed applied!`));
                 fixedCount++;
                 if (issue.related_step_id) {
                   const { completeStep } = await inquirer.prompt([{
@@ -2340,15 +2284,15 @@ ${chalk8.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
                         { step_id: issue.related_step_id, status: "COMPLETED", project_id: projectId },
                         { headers: { "Authorization": `Bearer ${apiKey}` } }
                       );
-                      console.log(chalk8.green(`\u{1F680} Roadmap updated! Mission Control is in sync.`));
+                      console.log(chalk7.green(`\u{1F680} Roadmap updated! Mission Control is in sync.`));
                     } catch (err) {
-                      console.error(chalk8.yellow(`Failed to update roadmap: ${err.message}`));
+                      console.error(chalk7.yellow(`Failed to update roadmap: ${err.message}`));
                     }
                   }
                 }
                 break;
               } else {
-                console.log(chalk8.dim("Skipped."));
+                console.log(chalk7.dim("Skipped."));
               }
             }
           } else {
@@ -2358,11 +2302,11 @@ ${chalk8.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
         }
       }
       spinner.stop();
-      console.log(chalk8.bold.green(`
+      console.log(chalk7.bold.green(`
 
 \u{1F680} Fix session complete!`));
       console.log(`Frank fixed ${fixedCount} detected issues.`);
-      console.log(chalk8.dim(`Run 'rigstate scan' to verify remaining issues.`));
+      console.log(chalk7.dim(`Run 'rigstate scan' to verify remaining issues.`));
     } catch (error) {
       spinner.fail("Fix session failed");
       console.error(error.message);
@@ -2373,14 +2317,14 @@ ${chalk8.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
 // src/commands/sync.ts
 init_esm_shims();
 init_config();
-import { Command as Command8 } from "commander";
-import chalk12 from "chalk";
+import { Command as Command7 } from "commander";
+import chalk11 from "chalk";
 import ora5 from "ora";
 import axios8 from "axios";
-import fs10 from "fs/promises";
-import path11 from "path";
+import fs9 from "fs/promises";
+import path10 from "path";
 function createSyncCommand() {
-  const sync = new Command8("sync");
+  const sync = new Command7("sync");
   sync.description("Synchronize local state with Rigstate Cloud").option("-p, --project <id>", "Specify Project ID (saves to config automatically)").action(async (options) => {
     const spinner = ora5("Synchronizing project state...").start();
     try {
@@ -2394,8 +2338,8 @@ function createSyncCommand() {
       let projectId = options.project;
       if (!projectId) {
         try {
-          const manifestPath = path11.join(process.cwd(), ".rigstate");
-          const manifestContent = await fs10.readFile(manifestPath, "utf-8");
+          const manifestPath = path10.join(process.cwd(), ".rigstate");
+          const manifestContent = await fs9.readFile(manifestPath, "utf-8");
           const manifest = JSON.parse(manifestContent);
           if (manifest.project_id) projectId = manifest.project_id;
         } catch (e) {
@@ -2419,31 +2363,31 @@ function createSyncCommand() {
       }
       const { roadmap, project } = response.data.data;
       const timestamp = response.data.timestamp;
-      const targetPath = path11.join(process.cwd(), "roadmap.json");
+      const targetPath = path10.join(process.cwd(), "roadmap.json");
       const fileContent = JSON.stringify({
         project,
         last_synced: timestamp,
         roadmap
       }, null, 2);
-      await fs10.writeFile(targetPath, fileContent, "utf-8");
+      await fs9.writeFile(targetPath, fileContent, "utf-8");
       try {
-        const manifestPath = path11.join(process.cwd(), ".rigstate");
+        const manifestPath = path10.join(process.cwd(), ".rigstate");
         const manifestContent = {
           project_id: projectId,
           project_name: project,
           last_synced: timestamp,
           api_url: apiUrl
         };
-        await fs10.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
+        await fs9.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
       } catch (e) {
       }
-      console.log(chalk12.bold("\n\u{1F9E0} Agent Skills Provisioning..."));
+      console.log(chalk11.bold("\n\u{1F9E0} Agent Skills Provisioning..."));
       try {
         const { provisionSkills: provisionSkills2, generateSkillsDiscoveryBlock: generateSkillsDiscoveryBlock2 } = await Promise.resolve().then(() => (init_skills_provisioner(), skills_provisioner_exports));
         const skills = await provisionSkills2(apiUrl, apiKey, projectId, process.cwd());
-        const cursorRulesPath = path11.join(process.cwd(), ".cursorrules");
+        const cursorRulesPath = path10.join(process.cwd(), ".cursorrules");
         try {
-          let rulesContent = await fs10.readFile(cursorRulesPath, "utf-8");
+          let rulesContent = await fs9.readFile(cursorRulesPath, "utf-8");
           const skillsBlock = generateSkillsDiscoveryBlock2(skills);
           if (rulesContent.includes("<available_skills>")) {
             rulesContent = rulesContent.replace(
@@ -2456,17 +2400,17 @@ function createSyncCommand() {
               rulesContent = rulesContent.slice(0, insertPoint + 3) + "\n\n" + skillsBlock + "\n" + rulesContent.slice(insertPoint + 3);
             }
           }
-          await fs10.writeFile(cursorRulesPath, rulesContent, "utf-8");
-          console.log(chalk12.dim(`  Updated .cursorrules with skills discovery block`));
+          await fs9.writeFile(cursorRulesPath, rulesContent, "utf-8");
+          console.log(chalk11.dim(`  Updated .cursorrules with skills discovery block`));
         } catch (e) {
         }
       } catch (e) {
-        console.log(chalk12.yellow(`  \u26A0 Skills provisioning skipped: ${e.message}`));
+        console.log(chalk11.yellow(`  \u26A0 Skills provisioning skipped: ${e.message}`));
       }
       try {
-        const logPath = path11.join(process.cwd(), ".rigstate", "logs", "last_execution.json");
+        const logPath = path10.join(process.cwd(), ".rigstate", "logs", "last_execution.json");
         try {
-          const logContent = await fs10.readFile(logPath, "utf-8");
+          const logContent = await fs9.readFile(logPath, "utf-8");
           const logData = JSON.parse(logContent);
           if (logData.task_summary) {
             await axios8.post(`${apiUrl}/api/v1/execution-logs`, {
@@ -2476,8 +2420,8 @@ function createSyncCommand() {
             }, {
               headers: { Authorization: `Bearer ${apiKey}` }
             });
-            await fs10.unlink(logPath);
-            console.log(chalk12.dim(`\u2714 Mission Report uploaded.`));
+            await fs9.unlink(logPath);
+            console.log(chalk11.dim(`\u2714 Mission Report uploaded.`));
           }
         } catch (e) {
           if (e.code !== "ENOENT") {
@@ -2485,12 +2429,12 @@ function createSyncCommand() {
         }
       } catch (e) {
       }
-      spinner.succeed(chalk12.green(`Synced ${roadmap.length} roadmap steps for project "${project}"`));
-      console.log(chalk12.dim(`Local files updated: roadmap.json`));
+      spinner.succeed(chalk11.green(`Synced ${roadmap.length} roadmap steps for project "${project}"`));
+      console.log(chalk11.dim(`Local files updated: roadmap.json`));
       const { runGuardianWatchdog: runGuardianWatchdog2 } = await Promise.resolve().then(() => (init_watchdog(), watchdog_exports));
       const settings = response.data.data.settings || {};
       await runGuardianWatchdog2(process.cwd(), settings, projectId);
-      console.log(chalk12.bold("\n\u{1F4E1} Agent Bridge Heartbeat..."));
+      console.log(chalk11.bold("\n\u{1F4E1} Agent Bridge Heartbeat..."));
       try {
         const bridgeResponse = await axios8.get(`${apiUrl}/api/v1/agent/bridge`, {
           params: { project_id: projectId },
@@ -2501,10 +2445,10 @@ function createSyncCommand() {
           const pending = tasks.filter((t) => t.status === "PENDING");
           const approved = tasks.filter((t) => t.status === "APPROVED");
           if (pending.length > 0 || approved.length > 0) {
-            console.log(chalk12.yellow(`\u26A0 Bridge Alert: ${pending.length} pending, ${approved.length} approved tasks found.`));
-            console.log(chalk12.dim('Run "rigstate fix" to process these tasks or ensure your IDE MCP server is active.'));
+            console.log(chalk11.yellow(`\u26A0 Bridge Alert: ${pending.length} pending, ${approved.length} approved tasks found.`));
+            console.log(chalk11.dim('Run "rigstate fix" to process these tasks or ensure your IDE MCP server is active.'));
           } else {
-            console.log(chalk12.green("\u2714 Heartbeat healthy. No pending bridge tasks."));
+            console.log(chalk11.green("\u2714 Heartbeat healthy. No pending bridge tasks."));
           }
           const pings = pending.filter((t) => t.proposal?.startsWith("ping"));
           for (const ping of pings) {
@@ -2515,25 +2459,25 @@ function createSyncCommand() {
             }, {
               headers: { Authorization: `Bearer ${apiKey}` }
             });
-            console.log(chalk12.cyan(`\u{1F3D3} Pong! Acknowledged heartbeat signal [${ping.id}]`));
+            console.log(chalk11.cyan(`\u{1F3D3} Pong! Acknowledged heartbeat signal [${ping.id}]`));
           }
         }
       } catch (e) {
-        console.log(chalk12.yellow(`\u26A0 Could not verify Bridge status: ${e.message}`));
+        console.log(chalk11.yellow(`\u26A0 Could not verify Bridge status: ${e.message}`));
       }
       if (options.project) {
-        console.log(chalk12.blue(`Project context saved. Future commands will use this project.`));
+        console.log(chalk11.blue(`Project context saved. Future commands will use this project.`));
       }
       try {
-        const migrationDir = path11.join(process.cwd(), "supabase", "migrations");
-        const files = await fs10.readdir(migrationDir);
+        const migrationDir = path10.join(process.cwd(), "supabase", "migrations");
+        const files = await fs9.readdir(migrationDir);
         const sqlFiles = files.filter((f) => f.endsWith(".sql")).sort();
         if (sqlFiles.length > 0) {
           const latestMigration = sqlFiles[sqlFiles.length - 1];
-          console.log(chalk12.dim(`
+          console.log(chalk11.dim(`
 \u{1F6E1}  Migration Guard:`));
-          console.log(chalk12.dim(`   Latest Local: ${latestMigration}`));
-          console.log(chalk12.yellow(`   \u26A0  Ensure DB schema matches this version. CLI cannot verify Remote RLS policies directly.`));
+          console.log(chalk11.dim(`   Latest Local: ${latestMigration}`));
+          console.log(chalk11.yellow(`   \u26A0  Ensure DB schema matches this version. CLI cannot verify Remote RLS policies directly.`));
         }
       } catch (e) {
       }
@@ -2545,15 +2489,15 @@ function createSyncCommand() {
         );
         if (vaultResponse.data.success) {
           const vaultContent = vaultResponse.data.data.content || "";
-          const localEnvPath = path11.join(process.cwd(), ".env.local");
+          const localEnvPath = path10.join(process.cwd(), ".env.local");
           let localContent = "";
           try {
-            localContent = await fs10.readFile(localEnvPath, "utf-8");
+            localContent = await fs9.readFile(localEnvPath, "utf-8");
           } catch (e) {
           }
           if (vaultContent.trim() !== localContent.trim()) {
-            console.log(chalk12.bold("\n\u{1F510} Sovereign Foundation (Vault):"));
-            console.log(chalk12.yellow("   Status: Drift Detected / Update Available"));
+            console.log(chalk11.bold("\n\u{1F510} Sovereign Foundation (Vault):"));
+            console.log(chalk11.yellow("   Status: Drift Detected / Update Available"));
             const { syncVault } = await import("inquirer").then((m) => m.default.prompt([{
               type: "confirm",
               name: "syncVault",
@@ -2561,25 +2505,25 @@ function createSyncCommand() {
               default: false
             }]));
             if (syncVault) {
-              await fs10.writeFile(localEnvPath, vaultContent, "utf-8");
-              console.log(chalk12.green("   \u2705 .env.local synchronized with Vault."));
+              await fs9.writeFile(localEnvPath, vaultContent, "utf-8");
+              console.log(chalk11.green("   \u2705 .env.local synchronized with Vault."));
             } else {
-              console.log(chalk12.dim("   Skipped vault sync."));
+              console.log(chalk11.dim("   Skipped vault sync."));
             }
           } else {
-            console.log(chalk12.dim("\n\u{1F510} Sovereign Foundation: Synced."));
+            console.log(chalk11.dim("\n\u{1F510} Sovereign Foundation: Synced."));
           }
         }
       } catch (e) {
       }
-      console.log(chalk12.dim("\n\u{1F6E1}\uFE0F System Integrity Check..."));
+      console.log(chalk11.dim("\n\u{1F6E1}\uFE0F System Integrity Check..."));
       await checkSystemIntegrity(apiUrl, apiKey, projectId);
     } catch (error) {
       if (axios8.isAxiosError(error)) {
         const message = error.response?.data?.error || error.message;
-        spinner.fail(chalk12.red(`Sync failed: ${message}`));
+        spinner.fail(chalk11.red(`Sync failed: ${message}`));
       } else {
-        spinner.fail(chalk12.red("Sync failed: " + (error.message || "Unknown error")));
+        spinner.fail(chalk11.red("Sync failed: " + (error.message || "Unknown error")));
       }
     }
   });
@@ -2595,57 +2539,57 @@ async function checkSystemIntegrity(apiUrl, apiKey, projectId) {
       const { migrations, rls, guardian_violations } = response.data.data;
       if (migrations) {
         if (migrations.in_sync) {
-          console.log(chalk12.green(`   \u2705 Migrations synced (${migrations.count} versions)`));
+          console.log(chalk11.green(`   \u2705 Migrations synced (${migrations.count} versions)`));
         } else {
-          console.log(chalk12.red(`   \u{1F6D1} CRITICAL: DB Schema out of sync! ${migrations.missing?.length || 0} migrations not applied.`));
+          console.log(chalk11.red(`   \u{1F6D1} CRITICAL: DB Schema out of sync! ${migrations.missing?.length || 0} migrations not applied.`));
           if (migrations.missing?.length > 0) {
-            console.log(chalk12.dim(`      Missing: ${migrations.missing.slice(0, 3).join(", ")}${migrations.missing.length > 3 ? "..." : ""}`));
+            console.log(chalk11.dim(`      Missing: ${migrations.missing.slice(0, 3).join(", ")}${migrations.missing.length > 3 ? "..." : ""}`));
           }
-          console.log(chalk12.yellow(`      Run 'supabase db push' or apply migrations immediately.`));
+          console.log(chalk11.yellow(`      Run 'supabase db push' or apply migrations immediately.`));
         }
       }
       if (rls) {
         if (rls.all_secured) {
-          console.log(chalk12.green(`   \u2705 RLS Audit Passed (${rls.table_count} tables secured)`));
+          console.log(chalk11.green(`   \u2705 RLS Audit Passed (${rls.table_count} tables secured)`));
         } else {
-          console.log(chalk12.red(`   \u{1F6D1} CRITICAL: Security Vulnerability! ${rls.unsecured?.length || 0} tables have RLS disabled.`));
+          console.log(chalk11.red(`   \u{1F6D1} CRITICAL: Security Vulnerability! ${rls.unsecured?.length || 0} tables have RLS disabled.`));
           rls.unsecured?.forEach((table) => {
-            console.log(chalk12.red(`      - ${table}`));
+            console.log(chalk11.red(`      - ${table}`));
           });
-          console.log(chalk12.yellow('      Enable RLS immediately: ALTER TABLE "table" ENABLE ROW LEVEL SECURITY;'));
+          console.log(chalk11.yellow('      Enable RLS immediately: ALTER TABLE "table" ENABLE ROW LEVEL SECURITY;'));
         }
       }
       if (guardian_violations) {
         if (guardian_violations.count === 0) {
-          console.log(chalk12.green("   \u2705 Guardian: No active violations"));
+          console.log(chalk11.green("   \u2705 Guardian: No active violations"));
         } else {
-          console.log(chalk12.yellow(`   \u26A0\uFE0F Guardian: ${guardian_violations.count} active violations`));
-          console.log(chalk12.dim('      Run "rigstate check" for details.'));
+          console.log(chalk11.yellow(`   \u26A0\uFE0F Guardian: ${guardian_violations.count} active violations`));
+          console.log(chalk11.dim('      Run "rigstate check" for details.'));
         }
       }
     }
   } catch (e) {
-    console.log(chalk12.dim("   (System integrity check skipped - API endpoint not available)"));
+    console.log(chalk11.dim("   (System integrity check skipped - API endpoint not available)"));
   }
 }
 
 // src/commands/init.ts
 init_esm_shims();
-import { Command as Command9 } from "commander";
-import chalk13 from "chalk";
-import fs12 from "fs/promises";
-import path13 from "path";
+import { Command as Command8 } from "commander";
+import chalk12 from "chalk";
+import fs11 from "fs/promises";
+import path12 from "path";
 import ora6 from "ora";
 import { execSync } from "child_process";
 
 // src/utils/manifest.ts
 init_esm_shims();
-import fs11 from "fs/promises";
-import path12 from "path";
+import fs10 from "fs/promises";
+import path11 from "path";
 async function loadManifest() {
   try {
-    const manifestPath = path12.join(process.cwd(), ".rigstate");
-    const content = await fs11.readFile(manifestPath, "utf-8");
+    const manifestPath = path11.join(process.cwd(), ".rigstate");
+    const content = await fs10.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -2656,13 +2600,13 @@ async function loadManifest() {
 init_config();
 import axios9 from "axios";
 function createInitCommand() {
-  return new Command9("init").description("Initialize or link a Rigstate project (interactive mode available)").argument("[project-id]", "ID of the project to link (optional, prompts if not provided)").option("-f, --force", "Overwrite existing .cursorrules file").option("--rules-only", "Only regenerate .cursorrules without interactive setup").action(async (projectIdArg, options) => {
+  return new Command8("init").description("Initialize or link a Rigstate project (interactive mode available)").argument("[project-id]", "ID of the project to link (optional, prompts if not provided)").option("-f, --force", "Overwrite existing .cursorrules file").option("--rules-only", "Only regenerate .cursorrules without interactive setup").action(async (projectIdArg, options) => {
     const spinner = ora6("Initializing Rigstate project...").start();
     let apiKey;
     try {
       apiKey = getApiKey();
     } catch (e) {
-      spinner.fail(chalk13.red('Not authenticated. Run "rigstate login" first.'));
+      spinner.fail(chalk12.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -2680,7 +2624,7 @@ function createInitCommand() {
       }
       if (!projectId) {
         spinner.stop();
-        const inquirer7 = (await import("inquirer")).default;
+        const inquirer8 = (await import("inquirer")).default;
         spinner.start("Fetching your projects...");
         let projects = [];
         try {
@@ -2695,7 +2639,7 @@ function createInitCommand() {
         }
         spinner.stop();
         if (projects.length === 0) {
-          const { manualProjectId } = await inquirer7.prompt([
+          const { manualProjectId } = await inquirer8.prompt([
             {
               type: "input",
               name: "manualProjectId",
@@ -2707,7 +2651,7 @@ function createInitCommand() {
         } else {
           const choices = [
             { name: "\u2795 Create New Project", value: "NEW" },
-            new inquirer7.Separator()
+            new inquirer8.Separator()
           ];
           projects.forEach((p) => {
             choices.push({
@@ -2715,7 +2659,7 @@ function createInitCommand() {
               value: p.id
             });
           });
-          const { selectedId } = await inquirer7.prompt([
+          const { selectedId } = await inquirer8.prompt([
             {
               type: "list",
               name: "selectedId",
@@ -2725,7 +2669,7 @@ function createInitCommand() {
             }
           ]);
           if (selectedId === "NEW") {
-            const { newName } = await inquirer7.prompt([
+            const { newName } = await inquirer8.prompt([
               {
                 type: "input",
                 name: "newName",
@@ -2745,7 +2689,7 @@ function createInitCommand() {
             spinner.stop();
             let selectedOrgId = orgs[0]?.id;
             if (orgs.length > 1) {
-              const { orgId } = await inquirer7.prompt([
+              const { orgId } = await inquirer8.prompt([
                 {
                   type: "list",
                   name: "orgId",
@@ -2759,7 +2703,7 @@ function createInitCommand() {
               selectedOrgId = orgId;
             }
             if (!selectedOrgId) {
-              console.log(chalk13.yellow("No organization available. Please create the project via the Rigstate dashboard."));
+              console.log(chalk12.yellow("No organization available. Please create the project via the Rigstate dashboard."));
               return;
             }
             spinner.start("Creating new project...");
@@ -2771,13 +2715,13 @@ function createInitCommand() {
                 headers: { Authorization: `Bearer ${apiKey}` }
               });
               if (!createResponse.data.success) {
-                spinner.fail(chalk13.red("Failed to create project: " + createResponse.data.error));
+                spinner.fail(chalk12.red("Failed to create project: " + createResponse.data.error));
                 return;
               }
               projectId = createResponse.data.data.project.id;
-              spinner.succeed(chalk13.green(`Created new project: ${newName}`));
+              spinner.succeed(chalk12.green(`Created new project: ${newName}`));
             } catch (e) {
-              spinner.fail(chalk13.red("Project creation API not available. Please create via dashboard."));
+              spinner.fail(chalk12.red("Project creation API not available. Please create via dashboard."));
               return;
             }
           } else {
@@ -2787,28 +2731,28 @@ function createInitCommand() {
         spinner.start(`Linking to project ID: ${projectId}...`);
       }
       setProjectId(projectId);
-      const manifestPath = path13.join(process.cwd(), ".rigstate");
+      const manifestPath = path12.join(process.cwd(), ".rigstate");
       const manifestContent = {
         project_id: projectId,
         last_linked: (/* @__PURE__ */ new Date()).toISOString(),
         api_url: apiUrl
       };
-      await fs12.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
+      await fs11.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
       try {
-        await fs12.access(".git");
+        await fs11.access(".git");
       } catch {
         spinner.text = "Initializing git repository...";
         execSync("git init", { stdio: "ignore" });
       }
-      spinner.succeed(chalk13.green(`\u2705 Linked to project: ${projectId}`));
+      spinner.succeed(chalk12.green(`\u2705 Linked to project: ${projectId}`));
       await generateRules(apiUrl, apiKey, projectId, options.force, spinner);
       console.log("");
-      console.log(chalk13.blue("Next steps:"));
-      console.log(chalk13.dim("  rigstate sync     - Sync roadmap and context"));
-      console.log(chalk13.dim("  rigstate watch    - Start development loop"));
-      console.log(chalk13.dim("  rigstate focus    - Get current task"));
+      console.log(chalk12.blue("Next steps:"));
+      console.log(chalk12.dim("  rigstate sync     - Sync roadmap and context"));
+      console.log(chalk12.dim("  rigstate watch    - Start development loop"));
+      console.log(chalk12.dim("  rigstate focus    - Get current task"));
     } catch (e) {
-      spinner.fail(chalk13.red("Initialization failed: " + e.message));
+      spinner.fail(chalk12.red("Initialization failed: " + e.message));
     }
   });
 }
@@ -2823,67 +2767,67 @@ async function generateRules(apiUrl, apiKey, projectId, force, spinner) {
     if (response.data.success || response.data.files) {
       const files = response.data.files || [];
       if (files.length === 0 && response.data.rules) {
-        const rulesPath = path13.join(process.cwd(), ".cursorrules");
-        await fs12.writeFile(rulesPath, response.data.rules, "utf-8");
-        spinner.succeed(chalk13.green("\u2714 Generated .cursorrules (legacy mode)"));
+        const rulesPath = path12.join(process.cwd(), ".cursorrules");
+        await fs11.writeFile(rulesPath, response.data.rules, "utf-8");
+        spinner.succeed(chalk12.green("\u2714 Generated .cursorrules (legacy mode)"));
         return;
       }
       for (const file of files) {
-        const targetPath = path13.join(process.cwd(), file.path);
-        const targetDir = path13.dirname(targetPath);
-        await fs12.mkdir(targetDir, { recursive: true });
+        const targetPath = path12.join(process.cwd(), file.path);
+        const targetDir = path12.dirname(targetPath);
+        await fs11.mkdir(targetDir, { recursive: true });
         try {
-          await fs12.access(targetPath);
+          await fs11.access(targetPath);
           if (!force && !file.path.startsWith(".cursor/rules/")) {
-            console.log(chalk13.dim(`  ${file.path} already exists. Skipping.`));
+            console.log(chalk12.dim(`  ${file.path} already exists. Skipping.`));
             continue;
           }
         } catch {
         }
-        await fs12.writeFile(targetPath, file.content, "utf-8");
+        await fs11.writeFile(targetPath, file.content, "utf-8");
       }
       if (files.length > 0) {
-        const legacyPath = path13.join(process.cwd(), ".cursorrules");
+        const legacyPath = path12.join(process.cwd(), ".cursorrules");
         try {
-          const stats = await fs12.stat(legacyPath);
+          const stats = await fs11.stat(legacyPath);
           if (stats.isFile()) {
-            await fs12.rename(legacyPath, `${legacyPath}.bak`);
-            console.log(chalk13.dim("  Moved legacy .cursorrules to .cursorrules.bak"));
+            await fs11.rename(legacyPath, `${legacyPath}.bak`);
+            console.log(chalk12.dim("  Moved legacy .cursorrules to .cursorrules.bak"));
           }
         } catch (e) {
         }
       }
-      spinner.succeed(chalk13.green(`\u2714 Generated ${files.length} rule files (v${response.data.version || "3.0"})`));
+      spinner.succeed(chalk12.green(`\u2714 Generated ${files.length} rule files (v${response.data.version || "3.0"})`));
     } else {
-      spinner.info(chalk13.dim("  Rules generation skipped (API response invalid)"));
+      spinner.info(chalk12.dim("  Rules generation skipped (API response invalid)"));
     }
   } catch (e) {
-    spinner.info(chalk13.dim(`  Rules generation failed: ${e.message}`));
+    spinner.info(chalk12.dim(`  Rules generation failed: ${e.message}`));
   }
 }
 
 // src/commands/check.ts
 init_esm_shims();
 init_config();
-import { Command as Command10 } from "commander";
-import chalk15 from "chalk";
+import { Command as Command9 } from "commander";
+import chalk14 from "chalk";
 import ora7 from "ora";
 import axios10 from "axios";
 import { glob as glob3 } from "glob";
-import fs14 from "fs/promises";
-import path15 from "path";
+import fs13 from "fs/promises";
+import path14 from "path";
 import { execSync as execSync2 } from "child_process";
 
 // src/utils/rule-engine.ts
 init_esm_shims();
-import fs13 from "fs/promises";
-import path14 from "path";
-import chalk14 from "chalk";
+import fs12 from "fs/promises";
+import path13 from "path";
+import chalk13 from "chalk";
 async function checkFile(filePath, rules, rootPath) {
   const violations = [];
-  const relativePath = path14.relative(rootPath, filePath);
+  const relativePath = path13.relative(rootPath, filePath);
   try {
-    const content = await fs13.readFile(filePath, "utf-8");
+    const content = await fs12.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     for (const rule of rules) {
       const ruleViolations = await evaluateRule(rule, content, lines, relativePath);
@@ -2974,7 +2918,7 @@ async function evaluateRule(rule, content, lines, filePath) {
     case "NAMING_CONVENTION": {
       const value = rule.value;
       const pattern = new RegExp(value.pattern);
-      const fileName = path14.basename(filePath);
+      const fileName = path13.basename(filePath);
       if (filePath.includes(value.context) && !pattern.test(fileName)) {
         violations.push({
           file: filePath,
@@ -3033,12 +2977,12 @@ function checkFunctionLines(content, lines, filePath, rule, limit) {
 }
 function formatViolations(violations) {
   for (const v of violations) {
-    const severityColor = v.severity === "critical" ? chalk14.red : v.severity === "warning" ? chalk14.yellow : chalk14.blue;
-    const lineInfo = v.line ? chalk14.dim(`:${v.line}`) : "";
+    const severityColor = v.severity === "critical" ? chalk13.red : v.severity === "warning" ? chalk13.yellow : chalk13.blue;
+    const lineInfo = v.line ? chalk13.dim(`:${v.line}`) : "";
     console.log(`  ${severityColor(`[${v.severity.toUpperCase()}]`)} ${v.file}${lineInfo}`);
     console.log(`    ${v.message}`);
     if (v.details) {
-      console.log(`    ${chalk14.dim(v.details)}`);
+      console.log(`    ${chalk13.dim(v.details)}`);
     }
   }
 }
@@ -3067,7 +3011,7 @@ var CACHE_FILE2 = ".rigstate/rules-cache.json";
 var CACHE_TTL_MS = 5 * 60 * 1e3;
 var CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function createCheckCommand() {
-  return new Command10("check").description("Validate code against Guardian architectural rules").argument("[path]", "Directory or file to check", ".").option("--project <id>", "Project ID (or use .rigstate manifest)").option("--strict [level]", 'Exit 1 on violations. Level: "all" (default) or "critical"').option("--staged", "Only check git staged files (for pre-commit hooks)").option("--json", "Output results as JSON").option("--no-cache", "Skip rule cache and fetch fresh from API").action(async (targetPath, options) => {
+  return new Command9("check").description("Validate code against Guardian architectural rules").argument("[path]", "Directory or file to check", ".").option("--project <id>", "Project ID (or use .rigstate manifest)").option("--strict [level]", 'Exit 1 on violations. Level: "all" (default) or "critical"').option("--staged", "Only check git staged files (for pre-commit hooks)").option("--json", "Output results as JSON").option("--no-cache", "Skip rule cache and fetch fresh from API").action(async (targetPath, options) => {
     const spinner = ora7();
     try {
       let projectId = options.project;
@@ -3083,15 +3027,15 @@ function createCheckCommand() {
         projectId = getProjectId();
       }
       if (!projectId) {
-        console.log(chalk15.red("\u274C No project context found."));
-        console.log(chalk15.dim('   Run "rigstate link" or pass --project <id>'));
+        console.log(chalk14.red("\u274C No project context found."));
+        console.log(chalk14.dim('   Run "rigstate link" or pass --project <id>'));
         process.exit(2);
       }
       let apiKey;
       try {
         apiKey = getApiKey();
       } catch {
-        console.log(chalk15.red('\u274C Not authenticated. Run "rigstate login" first.'));
+        console.log(chalk14.red('\u274C Not authenticated. Run "rigstate login" first.'));
         process.exit(2);
       }
       spinner.start("Fetching Guardian rules...");
@@ -3119,17 +3063,17 @@ function createCheckCommand() {
       } catch (apiError) {
         const cached = await loadCachedRules(projectId);
         if (cached && !isStale(cached.timestamp, CACHE_MAX_AGE_MS)) {
-          spinner.warn(chalk15.yellow("Using cached rules (API unavailable)"));
+          spinner.warn(chalk14.yellow("Using cached rules (API unavailable)"));
           rules = cached.rules;
           settings = cached.settings;
         } else {
-          spinner.fail(chalk15.red("Failed to fetch rules and no valid cache"));
-          console.log(chalk15.dim(`   Error: ${apiError.message}`));
+          spinner.fail(chalk14.red("Failed to fetch rules and no valid cache"));
+          console.log(chalk14.dim(`   Error: ${apiError.message}`));
           process.exit(2);
         }
       }
       spinner.succeed(`Loaded ${rules.length} Guardian rules`);
-      const scanPath = path15.resolve(process.cwd(), targetPath);
+      const scanPath = path14.resolve(process.cwd(), targetPath);
       let filesToCheck;
       if (options.staged) {
         spinner.start("Getting staged files...");
@@ -3138,14 +3082,14 @@ function createCheckCommand() {
             encoding: "utf-8",
             cwd: process.cwd()
           });
-          filesToCheck = stagedOutput.split("\n").filter((f) => f.trim()).filter((f) => isCodeFile2(f)).map((f) => path15.resolve(process.cwd(), f));
+          filesToCheck = stagedOutput.split("\n").filter((f) => f.trim()).filter((f) => isCodeFile2(f)).map((f) => path14.resolve(process.cwd(), f));
         } catch {
           spinner.fail("Not a git repository or no staged files");
           process.exit(2);
         }
       } else {
-        spinner.start(`Scanning ${chalk15.cyan(targetPath)}...`);
-        const pattern = path15.join(scanPath, "**/*");
+        spinner.start(`Scanning ${chalk14.cyan(targetPath)}...`);
+        const pattern = path14.join(scanPath, "**/*");
         const allFiles = await glob3(pattern, {
           nodir: true,
           dot: false,
@@ -3161,7 +3105,7 @@ function createCheckCommand() {
         filesToCheck = allFiles.filter((f) => isCodeFile2(f));
       }
       if (filesToCheck.length === 0) {
-        spinner.warn(chalk15.yellow("No code files found to check."));
+        spinner.warn(chalk14.yellow("No code files found to check."));
         outputResults([], !!options.json);
         process.exit(0);
       }
@@ -3170,7 +3114,7 @@ function createCheckCommand() {
       const results = [];
       for (let i = 0; i < filesToCheck.length; i++) {
         const file = filesToCheck[i];
-        spinner.text = `Checking ${i + 1}/${filesToCheck.length}: ${path15.basename(file)}`;
+        spinner.text = `Checking ${i + 1}/${filesToCheck.length}: ${path14.basename(file)}`;
         const result = await checkFile(file, rules, process.cwd());
         results.push(result);
       }
@@ -3180,47 +3124,47 @@ function createCheckCommand() {
         outputResults(results, true);
       } else {
         outputResults(results, false);
-        console.log("\n" + chalk15.bold("\u{1F4CA} Summary"));
-        console.log(chalk15.dim("\u2500".repeat(50)));
-        console.log(`Files checked: ${chalk15.cyan(summary.totalFiles)}`);
-        console.log(`Total violations: ${summary.totalViolations > 0 ? chalk15.red(summary.totalViolations) : chalk15.green(0)}`);
+        console.log("\n" + chalk14.bold("\u{1F4CA} Summary"));
+        console.log(chalk14.dim("\u2500".repeat(50)));
+        console.log(`Files checked: ${chalk14.cyan(summary.totalFiles)}`);
+        console.log(`Total violations: ${summary.totalViolations > 0 ? chalk14.red(summary.totalViolations) : chalk14.green(0)}`);
         if (summary.totalViolations > 0) {
-          console.log(`  ${chalk15.red("Critical:")} ${summary.criticalCount}`);
-          console.log(`  ${chalk15.yellow("Warning:")} ${summary.warningCount}`);
-          console.log(`  ${chalk15.blue("Info:")} ${summary.infoCount}`);
+          console.log(`  ${chalk14.red("Critical:")} ${summary.criticalCount}`);
+          console.log(`  ${chalk14.yellow("Warning:")} ${summary.warningCount}`);
+          console.log(`  ${chalk14.blue("Info:")} ${summary.infoCount}`);
         }
-        console.log(chalk15.dim("\u2500".repeat(50)));
+        console.log(chalk14.dim("\u2500".repeat(50)));
       }
       if (options.strict !== void 0) {
         const strictLevel = typeof options.strict === "string" ? options.strict : "all";
         if (strictLevel === "critical" && summary.criticalCount > 0) {
-          console.log(chalk15.red("\n\u274C Check failed: Critical violations found"));
+          console.log(chalk14.red("\n\u274C Check failed: Critical violations found"));
           process.exit(1);
         } else if (strictLevel === "all" && summary.totalViolations > 0) {
-          console.log(chalk15.red("\n\u274C Check failed: Violations found"));
+          console.log(chalk14.red("\n\u274C Check failed: Violations found"));
           process.exit(1);
         }
       }
       if (summary.totalViolations === 0) {
-        console.log(chalk15.green("\n\u2705 All checks passed!"));
+        console.log(chalk14.green("\n\u2705 All checks passed!"));
       }
       process.exit(0);
     } catch (error) {
-      spinner.fail(chalk15.red("Check failed"));
-      console.error(chalk15.red("Error:"), error.message);
+      spinner.fail(chalk14.red("Check failed"));
+      console.error(chalk14.red("Error:"), error.message);
       process.exit(2);
     }
   });
 }
 function isCodeFile2(filePath) {
   const codeExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-  const ext = path15.extname(filePath).toLowerCase();
+  const ext = path14.extname(filePath).toLowerCase();
   return codeExtensions.includes(ext);
 }
 async function loadCachedRules(projectId) {
   try {
-    const cachePath = path15.join(process.cwd(), CACHE_FILE2);
-    const content = await fs14.readFile(cachePath, "utf-8");
+    const cachePath = path14.join(process.cwd(), CACHE_FILE2);
+    const content = await fs13.readFile(cachePath, "utf-8");
     const cached = JSON.parse(content);
     if (cached.projectId !== projectId) {
       return null;
@@ -3232,16 +3176,16 @@ async function loadCachedRules(projectId) {
 }
 async function saveCachedRules(projectId, rules, settings) {
   try {
-    const cacheDir = path15.join(process.cwd(), ".rigstate");
-    await fs14.mkdir(cacheDir, { recursive: true });
+    const cacheDir = path14.join(process.cwd(), ".rigstate");
+    await fs13.mkdir(cacheDir, { recursive: true });
     const cached = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       projectId,
       rules,
       settings
     };
-    await fs14.writeFile(
-      path15.join(cacheDir, "rules-cache.json"),
+    await fs13.writeFile(
+      path14.join(cacheDir, "rules-cache.json"),
       JSON.stringify(cached, null, 2)
     );
   } catch {
@@ -3263,8 +3207,8 @@ function outputResults(results, json) {
   if (!hasViolations) {
     return;
   }
-  console.log("\n" + chalk15.bold("\u{1F50D} Violations Found"));
-  console.log(chalk15.dim("\u2500".repeat(50)));
+  console.log("\n" + chalk14.bold("\u{1F50D} Violations Found"));
+  console.log(chalk14.dim("\u2500".repeat(50)));
   for (const result of results) {
     if (result.violations.length > 0) {
       formatViolations(result.violations);
@@ -3272,8 +3216,125 @@ function outputResults(results, json) {
   }
 }
 
-// src/index.ts
-init_hooks();
+// src/commands/hooks.ts
+init_esm_shims();
+import { Command as Command10 } from "commander";
+import chalk15 from "chalk";
+import fs14 from "fs/promises";
+import path15 from "path";
+var PRE_COMMIT_SCRIPT = `#!/bin/sh
+# Rigstate Guardian Pre-commit Hook
+# Installed by: rigstate hooks install
+
+# 1. Silent Sentinel Check (Phase 5)
+if [ -f .rigstate/guardian.lock ]; then
+    echo "\u{1F6D1} INTERVENTION ACTIVE: Commit blocked by Silent Sentinel."
+    echo "   A critical violation ('HARD_LOCK') was detected by the Guardian Daemon."
+    echo "   Please fix the violation to unlock the repo."
+    echo ""
+    if grep -q "HARD_LOCK_ACTIVE" .rigstate/guardian.lock; then
+        cat .rigstate/guardian.lock
+    fi
+    exit 1
+fi
+
+echo "\u{1F6E1}\uFE0F  Running Guardian checks..."
+
+# Run check with strict mode for critical violations
+rigstate check --staged --strict=critical
+
+# Exit with the same code as rigstate check
+exit $?
+`;
+function createHooksCommand() {
+  const hooks = new Command10("hooks").description("Manage git hooks for Guardian integration");
+  hooks.command("install").description("Install pre-commit hook to run Guardian checks").option("--strict [level]", 'Strict level: "all" or "critical" (default)', "critical").action(async (options) => {
+    try {
+      const gitDir = path15.join(process.cwd(), ".git");
+      try {
+        await fs14.access(gitDir);
+      } catch {
+        console.log(chalk15.red("\u274C Not a git repository."));
+        console.log(chalk15.dim('   Initialize with "git init" first.'));
+        process.exit(1);
+      }
+      const hooksDir = path15.join(gitDir, "hooks");
+      await fs14.mkdir(hooksDir, { recursive: true });
+      const preCommitPath = path15.join(hooksDir, "pre-commit");
+      let existingContent = "";
+      try {
+        existingContent = await fs14.readFile(preCommitPath, "utf-8");
+        if (existingContent.includes("rigstate")) {
+          console.log(chalk15.yellow("\u26A0 Rigstate pre-commit hook already installed."));
+          console.log(chalk15.dim('   Use "rigstate hooks uninstall" to remove first.'));
+          return;
+        }
+      } catch {
+      }
+      let script = PRE_COMMIT_SCRIPT;
+      if (options.strict === "all") {
+        script = script.replace("--strict=critical", "--strict");
+      }
+      if (existingContent && !existingContent.includes("rigstate")) {
+        const combinedScript = existingContent + "\n\n" + script.replace("#!/bin/sh\n", "");
+        await fs14.writeFile(preCommitPath, combinedScript, { mode: 493 });
+        console.log(chalk15.green("\u2705 Rigstate hook appended to existing pre-commit."));
+      } else {
+        await fs14.writeFile(preCommitPath, script, { mode: 493 });
+        console.log(chalk15.green("\u2705 Pre-commit hook installed!"));
+      }
+      console.log(chalk15.dim(`   Path: ${preCommitPath}`));
+      console.log(chalk15.dim(`   Strict level: ${options.strict}`));
+      console.log("");
+      console.log(chalk15.cyan("Guardian will now check your code before each commit."));
+      console.log(chalk15.dim('Use "rigstate hooks uninstall" to remove the hook.'));
+    } catch (error) {
+      console.error(chalk15.red("Failed to install hook:"), error.message);
+      process.exit(1);
+    }
+  });
+  hooks.command("uninstall").description("Remove Rigstate pre-commit hook").action(async () => {
+    try {
+      const preCommitPath = path15.join(process.cwd(), ".git", "hooks", "pre-commit");
+      try {
+        const content = await fs14.readFile(preCommitPath, "utf-8");
+        if (!content.includes("rigstate")) {
+          console.log(chalk15.yellow("\u26A0 No Rigstate hook found in pre-commit."));
+          return;
+        }
+        if (content.includes("# Rigstate Guardian Pre-commit Hook") && content.trim().split("\n").filter((l) => l && !l.startsWith("#")).length <= 4) {
+          await fs14.unlink(preCommitPath);
+          console.log(chalk15.green("\u2705 Pre-commit hook removed."));
+        } else {
+          const lines = content.split("\n");
+          const filteredLines = [];
+          let inRigstateSection = false;
+          for (const line of lines) {
+            if (line.includes("Rigstate Guardian Pre-commit Hook")) {
+              inRigstateSection = true;
+              continue;
+            }
+            if (inRigstateSection && line.includes("exit $?")) {
+              inRigstateSection = false;
+              continue;
+            }
+            if (!inRigstateSection && !line.includes("rigstate check")) {
+              filteredLines.push(line);
+            }
+          }
+          await fs14.writeFile(preCommitPath, filteredLines.join("\n"), { mode: 493 });
+          console.log(chalk15.green("\u2705 Rigstate section removed from pre-commit hook."));
+        }
+      } catch {
+        console.log(chalk15.yellow("\u26A0 No pre-commit hook found."));
+      }
+    } catch (error) {
+      console.error(chalk15.red("Failed to uninstall hook:"), error.message);
+      process.exit(1);
+    }
+  });
+  return hooks;
+}
 
 // src/commands/daemon.ts
 init_esm_shims();
@@ -3981,7 +4042,7 @@ var GuardianDaemon = class extends EventEmitter3 {
   setupFileWatcher() {
     Logger.info("Starting file watcher...");
     this.fileWatcher = createFileWatcher(this.config.watchPath);
-    this.fileWatcher.on("change", (path27) => this.handleFileChange(path27));
+    this.fileWatcher.on("change", (path28) => this.handleFileChange(path28));
     this.fileWatcher.start();
     Logger.info("File watcher active");
   }
@@ -4015,6 +4076,7 @@ var GuardianDaemon = class extends EventEmitter3 {
       this.emit("skill:suggestion", match);
     }
   }
+  violationsMap = /* @__PURE__ */ new Map();
   async runIntegrityCheck(filePath) {
     if (!this.guardianMonitor) return;
     if (this.interventionProtocol) this.interventionProtocol.clear(filePath);
@@ -4023,24 +4085,37 @@ var GuardianDaemon = class extends EventEmitter3 {
     if (result.violations.length > 0) {
       this.handleViolations(filePath, result.violations);
     } else {
-      await this.updateViolationReport([]);
+      if (this.violationsMap.has(filePath)) {
+        this.violationsMap.delete(filePath);
+        this.updateViolationReport();
+      }
     }
   }
   async updateViolationReport(violations) {
     const reportPath = path20.join(process.cwd(), ".rigstate", "ACTIVE_VIOLATIONS.md");
-    let content = `# \u{1F6E1}\uFE0F Guardian Status: ${violations.length > 0 ? "\u26A0\uFE0F ATTENTION" : "\u2705 PASS"}
+    const allViolations = Array.from(this.violationsMap.entries());
+    const totalCount = allViolations.reduce((acc, [, v]) => acc + v.length, 0);
+    let content = `# \u{1F6E1}\uFE0F Guardian Status: ${totalCount > 0 ? "\u26A0\uFE0F ATTENTION" : "\u2705 PASS"}
 
 `;
     content += `*Last check: ${(/* @__PURE__ */ new Date()).toLocaleString()}*
+`;
+    content += `*Files with issues: ${allViolations.length}*
 
 `;
-    if (violations.length === 0) {
+    if (totalCount === 0) {
       content += "All systems within architectural limits. Frank is satisfied. \u{1F92B}\n";
     } else {
       content += "### \u{1F6A8} Active Violations\n\n";
-      for (const v of violations) {
-        content += `- **[${v.severity.toUpperCase()}]**: ${v.message}
+      for (const [file, fileViolations] of allViolations) {
+        const relPath = path20.relative(process.cwd(), file);
+        content += `#### \u{1F4C4} ${relPath}
+`;
+        for (const v of fileViolations) {
+          content += `- **[${v.severity.toUpperCase()}]**: ${v.message}
 `;
+        }
+        content += "\n";
       }
       content += "\n---\n*Rigstate Daemon is watching. Fix violations to clear this report.*";
     }
@@ -4052,7 +4127,8 @@ var GuardianDaemon = class extends EventEmitter3 {
   handleViolations(filePath, violations) {
     this.state.violationsFound += violations.length;
     this.emit("violation", { file: filePath, violations });
-    this.updateViolationReport(violations);
+    this.violationsMap.set(filePath, violations);
+    this.updateViolationReport();
     for (const v of violations) {
       const level = v.severity === "critical" ? "error" : v.severity === "warning" ? "warn" : "info";
       Logger[level](`[${v.severity.toUpperCase()}] ${filePath}: ${v.message}`);
@@ -4365,13 +4441,147 @@ async function showStatus() {
 init_esm_shims();
 init_config();
 init_suggest();
+import { Command as Command13 } from "commander";
+import chalk23 from "chalk";
+import ora10 from "ora";
+import axios16 from "axios";
+import inquirer3 from "inquirer";
+
+// src/commands/plan.ts
+init_esm_shims();
+init_config();
 import { Command as Command12 } from "commander";
 import chalk22 from "chalk";
 import ora9 from "ora";
 import axios15 from "axios";
+import fs20 from "fs/promises";
+import path23 from "path";
 import inquirer2 from "inquirer";
+function createPlanCommand() {
+  const plan = new Command12("plan");
+  plan.description("Generate an implementation plan for a roadmap task").argument("[taskId]", "Task ID (e.g. T-10) or UUID").action(async (taskId) => {
+    await executePlan(taskId);
+  });
+  return plan;
+}
+async function executePlan(taskId) {
+  const spinner = ora9("Initializing Planning Mode...").start();
+  try {
+    const { projectId, apiKey, apiUrl } = getContext();
+    let realId = taskId;
+    let taskTitle = "";
+    let taskDescription = "";
+    if (!taskId) {
+      spinner.text = "Fetching actionable tasks...";
+      const response = await axios15.get(
+        `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
+        { headers: { "Authorization": `Bearer ${apiKey}` } }
+      );
+      if (!response.data.success) throw new Error("Failed to fetch roadmap");
+      const tasks = response.data.data.roadmap || [];
+      const choices = tasks.filter((t) => ["ACTIVE", "IN_PROGRESS", "PENDING"].includes(t.status)).map((t) => ({
+        name: `T-${t.step_number}: ${t.title}`,
+        value: t
+      }));
+      if (choices.length === 0) {
+        spinner.fail("No actionable tasks found in roadmap.");
+        return;
+      }
+      spinner.stop();
+      const answer = await inquirer2.prompt([{
+        type: "list",
+        name: "task",
+        message: "Select a task to plan:",
+        choices
+      }]);
+      realId = answer.task.id;
+      taskTitle = answer.task.title;
+      taskDescription = answer.task.description;
+      taskId = `T-${answer.task.step_number}`;
+    } else {
+      spinner.text = `Fetching details for ${taskId}...`;
+      const response = await axios15.get(
+        `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
+        { headers: { "Authorization": `Bearer ${apiKey}` } }
+      );
+      const task = response.data.data.roadmap.find(
+        (t) => t.id === taskId || `T-${t.step_number}` === taskId || t.step_number.toString() === taskId
+      );
+      if (!task) throw new Error(`Task ${taskId} not found.`);
+      realId = task.id;
+      taskTitle = task.title;
+      taskDescription = task.description;
+    }
+    spinner.start("Generating Context for Frank...");
+    const contextPath = path23.join(process.cwd(), ".rigstate", "CURRENT_CONTEXT.md");
+    const contextContent = `
+# \u{1F3AF} Active Mission: ${taskTitle}
+**ID:** ${taskId}
+
+## \u{1F4DD} Description
+${taskDescription}
+
+## \u{1F6E1}\uFE0F Architectural Constraints
+- Follow strictly the rules in .cursor/rules/
+- Ensure zero violations in ACTIVE_VIOLATIONS.md
+- Update IMPLEMENTATION_PLAN.md before writing code.
+
+*Generated by Rigstate CLI at ${(/* @__PURE__ */ new Date()).toLocaleString()}*
+`;
+    await fs20.mkdir(path23.dirname(contextPath), { recursive: true });
+    await fs20.writeFile(contextPath, contextContent.trim());
+    const planPath = path23.join(process.cwd(), "IMPLEMENTATION_PLAN.md");
+    const planExists = await fs20.stat(planPath).then(() => true).catch(() => false);
+    if (!planExists) {
+      const planTemplate = `
+# \u{1F4CB} Implementation Plan: ${taskTitle}
+
+## 1. \u{1F50D} Analysis
+- [ ] Understand the requirements in .rigstate/CURRENT_CONTEXT.md
+- [ ] Check for existing architectural patterns
+
+## 2. \u{1F3D7}\uFE0F Proposed Changes
+[Frank: List the files you intend to modify and the nature of the changes]
+
+## 3. \u2705 Verification
+- [ ] Run tests
+- [ ] Verification Step 1...
+
+## 4. \u{1F680} Execution
+[Frank: Log your progress here]
+`;
+      await fs20.writeFile(planPath, planTemplate.trim());
+      spinner.succeed(chalk22.green("Created new IMPLEMENTATION_PLAN.md"));
+    } else {
+      spinner.info(chalk22.yellow("IMPLEMENTATION_PLAN.md already exists. Preserving it."));
+    }
+    console.log("");
+    console.log(chalk22.bold.blue("\u{1F680} Planning Mode Activated"));
+    console.log(chalk22.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`1. Context loaded into: ${chalk22.bold(".rigstate/CURRENT_CONTEXT.md")}`);
+    console.log(`2. Plan template ready: ${chalk22.bold("IMPLEMENTATION_PLAN.md")}`);
+    console.log("");
+    console.log(chalk22.yellow("\u{1F449} NEXT STEP:"));
+    console.log(`   Open ${chalk22.bold("IMPLEMENTATION_PLAN.md")} in your IDE.`);
+    console.log(`   Tell Frank: ${chalk22.italic('"Read the context and draft the plan."')}`);
+    console.log("");
+  } catch (e) {
+    spinner.fail(chalk22.red(`Planning failed: ${e.message}`));
+  }
+}
+function getContext() {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  const projectId = getProjectId();
+  if (!projectId) {
+    throw new Error("Project ID missing. Run rigstate link.");
+  }
+  return { projectId, apiKey, apiUrl };
+}
+
+// src/commands/work.ts
 function createWorkCommand() {
-  const work = new Command12("work");
+  const work = new Command13("work");
   work.description("Manage development flow (Start, Finish, List)").action(() => {
     listInteractive();
   });
@@ -4384,10 +4594,10 @@ function createWorkCommand() {
   return work;
 }
 async function listInteractive() {
-  const spinner = ora9("Fetching roadmap...").start();
+  const spinner = ora10("Fetching roadmap...").start();
   try {
-    const { projectId, apiKey, apiUrl } = getContext();
-    const response = await axios15.get(
+    const { projectId, apiKey, apiUrl } = getContext2();
+    const response = await axios16.get(
       `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
       { headers: { "Authorization": `Bearer ${apiKey}` } }
     );
@@ -4401,7 +4611,7 @@ async function listInteractive() {
     });
     spinner.stop();
     if (actionableTasks.length === 0) {
-      console.log(chalk22.yellow("Roadmap clear. No actionable tasks found."));
+      console.log(chalk23.yellow("Roadmap clear. No actionable tasks found."));
       return;
     }
     const choices = actionableTasks.map((t) => {
@@ -4410,26 +4620,30 @@ async function listInteractive() {
       if (t.status === "IN_PROGRESS") icon = "\u{1F525}";
       if (t.status === "ACTIVE") icon = "\u25B6\uFE0F";
       return {
-        name: `${icon}  ${chalk22.bold(id)}: ${t.title} [${t.status}]`,
+        name: `${icon}  ${chalk23.bold(id)}: ${t.title} [${t.status}]`,
         value: t.id
       };
     });
-    const { taskId } = await inquirer2.prompt([{
+    const { taskId } = await inquirer3.prompt([{
       type: "list",
       name: "taskId",
       message: "Select a task to manage:",
       choices
     }]);
-    const { action } = await inquirer2.prompt([{
+    const { action } = await inquirer3.prompt([{
       type: "list",
       name: "action",
       message: "Action:",
       choices: [
+        { name: "Plan (Draft Blueprint - RECOMMENDED)", value: "plan" },
         { name: "Start (Set IN_PROGRESS)", value: "start" },
         { name: "Finish (Audit & Complete)", value: "finish" },
         { name: "Cancel", value: "cancel" }
       ]
     }]);
+    if (action === "plan") {
+      await executePlan(taskId);
+    }
     if (action === "start") await setTaskStatus(taskId, "IN_PROGRESS");
     if (action === "finish") await finishTask(taskId);
   } catch (e) {
@@ -4437,45 +4651,45 @@ async function listInteractive() {
   }
 }
 async function setTaskStatus(taskId, status) {
-  const spinner = ora9(`Setting task ${taskId} to ${status}...`).start();
+  const spinner = ora10(`Setting task ${taskId} to ${status}...`).start();
   try {
-    const { projectId, apiKey, apiUrl } = getContext();
+    const { projectId, apiKey, apiUrl } = getContext2();
     let realId = taskId;
     if (taskId.startsWith("T-") || taskId.length < 10) {
       spinner.text = "Resolving Task ID...";
-      const lookup = await axios15.get(`${apiUrl}/api/v1/roadmap?project_id=${projectId}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+      const lookup = await axios16.get(`${apiUrl}/api/v1/roadmap?project_id=${projectId}`, { headers: { Authorization: `Bearer ${apiKey}` } });
       const task = lookup.data.data.roadmap.find((t) => `T-${t.step_number}` === taskId || t.step_number.toString() === taskId);
       if (!task) throw new Error(`Task ${taskId} not found.`);
       realId = task.id;
     }
-    await axios15.post(
+    await axios16.post(
       `${apiUrl}/api/v1/roadmap/update-status`,
       { step_id: realId, status, project_id: projectId },
       { headers: { "Authorization": `Bearer ${apiKey}` } }
     );
-    spinner.succeed(chalk22.green(`Task updated to ${status}.`));
+    spinner.succeed(chalk23.green(`Task updated to ${status}.`));
     if (status === "IN_PROGRESS") {
-      console.log(chalk22.blue(`
+      console.log(chalk23.blue(`
 \u{1F4A1} Tip: Provide 'Frank' with context by mentioning @.cursorrules in your chat.`));
     }
   } catch (e) {
-    spinner.fail(chalk22.red(`Failed: ${e.message}`));
+    spinner.fail(chalk23.red(`Failed: ${e.message}`));
   }
 }
 async function finishTask(taskId) {
   console.log("");
-  console.log(chalk22.bold.yellow("\u{1F6E1}\uFE0F  FRANK'S QUALITY GATE"));
-  console.log(chalk22.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  const auditSpinner = ora9(" Analyzing architectural integrity...").start();
+  console.log(chalk23.bold.yellow("\u{1F6E1}\uFE0F  FRANK'S QUALITY GATE"));
+  console.log(chalk23.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  const auditSpinner = ora10(" Analyzing architectural integrity...").start();
   await new Promise((r) => setTimeout(r, 1500));
   auditSpinner.succeed("Architecture: VALIDATED (SEC-ARCH-01 Pass)");
   await setTaskStatus(taskId, "COMPLETED");
   console.log("");
-  console.log(chalk22.bold.green("\u{1F389} TASK COMPLETE! Momentum Preserved."));
-  const { projectId, apiKey, apiUrl } = getContext();
+  console.log(chalk23.bold.green("\u{1F389} TASK COMPLETE! Momentum Preserved."));
+  const { projectId, apiKey, apiUrl } = getContext2();
   await suggestNextMove(projectId, apiKey, apiUrl);
 }
-function getContext() {
+function getContext2() {
   const apiKey = getApiKey();
   const apiUrl = getApiUrl();
   const projectId = getProjectId();
@@ -4488,40 +4702,40 @@ function getContext() {
 // src/commands/watch.ts
 init_esm_shims();
 init_config();
-import { Command as Command13 } from "commander";
-import chalk23 from "chalk";
-import ora10 from "ora";
+import { Command as Command14 } from "commander";
+import chalk24 from "chalk";
+import ora11 from "ora";
 import chokidar2 from "chokidar";
-import fs20 from "fs/promises";
-import path23 from "path";
+import fs21 from "fs/promises";
+import path24 from "path";
 import { execSync as execSync4 } from "child_process";
-import axios16 from "axios";
+import axios17 from "axios";
 function createWatchCommand() {
-  const watch2 = new Command13("watch");
+  const watch2 = new Command14("watch");
   watch2.description("Watch for changes and auto-verify roadmap tasks").option("--no-auto-commit", "Disable auto-commit on verification").option("--no-auto-push", "Disable auto-push after commit").option("--run-tests", "Run tests before committing").option("--test-command <cmd>", "Custom test command (default: npm test)").action(async (options) => {
-    console.log(chalk23.bold.blue("\u{1F52D} Rigstate Watch Mode"));
-    console.log(chalk23.dim("Monitoring for task completion..."));
+    console.log(chalk24.bold.blue("\u{1F52D} Rigstate Watch Mode"));
+    console.log(chalk24.dim("Monitoring for task completion..."));
     console.log("");
     let apiKey;
     let projectId;
     try {
       apiKey = getApiKey();
     } catch (e) {
-      console.log(chalk23.red('Not authenticated. Run "rigstate login" first.'));
+      console.log(chalk24.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
       try {
-        const manifestPath = path23.join(process.cwd(), ".rigstate");
-        const content = await fs20.readFile(manifestPath, "utf-8");
+        const manifestPath = path24.join(process.cwd(), ".rigstate");
+        const content = await fs21.readFile(manifestPath, "utf-8");
         const manifest = JSON.parse(content);
         projectId = manifest.project_id;
       } catch (e) {
       }
     }
     if (!projectId) {
-      console.log(chalk23.red('No project context. Run "rigstate link" or "rigstate sync --project <id>" first.'));
+      console.log(chalk24.red('No project context. Run "rigstate link" or "rigstate sync --project <id>" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -4531,12 +4745,12 @@ function createWatchCommand() {
       runTests: options.runTests || false,
       testCommand: options.testCommand || "npm test"
     };
-    console.log(chalk23.dim(`Auto-commit: ${config2.autoCommit ? "ON" : "OFF"}`));
-    console.log(chalk23.dim(`Auto-push: ${config2.autoPush ? "ON" : "OFF"}`));
+    console.log(chalk24.dim(`Auto-commit: ${config2.autoCommit ? "ON" : "OFF"}`));
+    console.log(chalk24.dim(`Auto-push: ${config2.autoPush ? "ON" : "OFF"}`));
     console.log("");
     const fetchActiveTask = async () => {
       try {
-        const response = await axios16.get(`${apiUrl}/api/v1/roadmap`, {
+        const response = await axios17.get(`${apiUrl}/api/v1/roadmap`, {
           params: { project_id: projectId },
           headers: { Authorization: `Bearer ${apiKey}` }
         });
@@ -4560,17 +4774,17 @@ function createWatchCommand() {
     };
     const checkCriteria = async (criteria) => {
       try {
-        const fullPath = path23.resolve(process.cwd(), criteria.path);
+        const fullPath = path24.resolve(process.cwd(), criteria.path);
         switch (criteria.type) {
           case "file_exists":
-            await fs20.access(fullPath);
+            await fs21.access(fullPath);
             return true;
           case "file_content":
-            const content = await fs20.readFile(fullPath, "utf-8");
+            const content = await fs21.readFile(fullPath, "utf-8");
             return content.length > 0;
           case "content_match":
             if (!criteria.match) return false;
-            const fileContent = await fs20.readFile(fullPath, "utf-8");
+            const fileContent = await fs21.readFile(fullPath, "utf-8");
             return fileContent.includes(criteria.match);
           default:
             return false;
@@ -4580,7 +4794,7 @@ function createWatchCommand() {
       }
     };
     const completeTask = async (taskId, task) => {
-      const spinner = ora10("Completing task...").start();
+      const spinner = ora11("Completing task...").start();
       try {
         if (config2.runTests) {
           spinner.text = "Running tests...";
@@ -4592,14 +4806,14 @@ function createWatchCommand() {
             return;
           }
         }
-        await axios16.post(`${apiUrl}/api/v1/roadmap/update-status`, {
+        await axios17.post(`${apiUrl}/api/v1/roadmap/update-status`, {
           project_id: projectId,
           chunk_id: taskId,
           status: "COMPLETED"
         }, {
           headers: { Authorization: `Bearer ${apiKey}` }
         });
-        spinner.succeed(chalk23.green(`\u2705 Task #${task.step_number} completed: ${task.title}`));
+        spinner.succeed(chalk24.green(`\u2705 Task #${task.step_number} completed: ${task.title}`));
         if (config2.autoCommit) {
           spinner.start("Committing changes...");
           try {
@@ -4621,7 +4835,7 @@ function createWatchCommand() {
           }
         }
         console.log("");
-        console.log(chalk23.blue("Watching for next task..."));
+        console.log(chalk24.blue("Watching for next task..."));
       } catch (e) {
         spinner.fail(`Failed to complete task: ${e.message}`);
       }
@@ -4634,7 +4848,7 @@ function createWatchCommand() {
       const task = await fetchActiveTask();
       if (!task) {
         if (currentTask) {
-          console.log(chalk23.green("\u{1F389} All tasks completed! Watching for new tasks..."));
+          console.log(chalk24.green("\u{1F389} All tasks completed! Watching for new tasks..."));
           currentTask = null;
         }
         isProcessing = false;
@@ -4643,10 +4857,10 @@ function createWatchCommand() {
       if (!currentTask || currentTask.id !== task.id) {
         currentTask = task;
         console.log("");
-        console.log(chalk23.bold.yellow(`\u{1F4CC} Active Task #${task.step_number}: ${task.title}`));
-        console.log(chalk23.dim(`Status: ${task.status}`));
+        console.log(chalk24.bold.yellow(`\u{1F4CC} Active Task #${task.step_number}: ${task.title}`));
+        console.log(chalk24.dim(`Status: ${task.status}`));
         if (task.verification_criteria) {
-          console.log(chalk23.dim("Verification: Auto-checking criteria..."));
+          console.log(chalk24.dim("Verification: Auto-checking criteria..."));
         }
       }
       if (task.verification_criteria && Array.isArray(task.verification_criteria)) {
@@ -4659,7 +4873,7 @@ function createWatchCommand() {
           }
         }
         if (allPassed) {
-          console.log(chalk23.green("\u2713 All verification criteria passed!"));
+          console.log(chalk24.green("\u2713 All verification criteria passed!"));
           await completeTask(task.id, task);
           currentTask = null;
         }
@@ -4684,11 +4898,11 @@ function createWatchCommand() {
         setTimeout(() => processActiveTask(), 500);
       }
     });
-    console.log(chalk23.dim("Watching for file changes... (Ctrl+C to exit)"));
+    console.log(chalk24.dim("Watching for file changes... (Ctrl+C to exit)"));
     setInterval(() => processActiveTask(), 3e4);
     process.on("SIGINT", () => {
       console.log("");
-      console.log(chalk23.dim("Watch mode stopped."));
+      console.log(chalk24.dim("Watch mode stopped."));
       watcher.close();
       process.exit(0);
     });
@@ -4699,42 +4913,42 @@ function createWatchCommand() {
 // src/commands/focus.ts
 init_esm_shims();
 init_config();
-import { Command as Command14 } from "commander";
-import chalk24 from "chalk";
-import ora11 from "ora";
-import axios17 from "axios";
+import { Command as Command15 } from "commander";
+import chalk25 from "chalk";
+import ora12 from "ora";
+import axios18 from "axios";
 import { execSync as execSync5 } from "child_process";
-import fs21 from "fs/promises";
-import path24 from "path";
+import fs22 from "fs/promises";
+import path25 from "path";
 function createFocusCommand() {
-  const focus = new Command14("focus");
+  const focus = new Command15("focus");
   focus.alias("task").description("Get the next active roadmap task and copy its prompt to clipboard").option("--no-copy", "Do not copy to clipboard").action(async (options) => {
-    const spinner = ora11("Fetching next objective...").start();
+    const spinner = ora12("Fetching next objective...").start();
     let apiKey;
     let projectId;
     try {
       apiKey = getApiKey();
     } catch (e) {
-      spinner.fail(chalk24.red('Not authenticated. Run "rigstate login" first.'));
+      spinner.fail(chalk25.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
       try {
-        const manifestPath = path24.join(process.cwd(), ".rigstate");
-        const content = await fs21.readFile(manifestPath, "utf-8");
+        const manifestPath = path25.join(process.cwd(), ".rigstate");
+        const content = await fs22.readFile(manifestPath, "utf-8");
         const manifest = JSON.parse(content);
         projectId = manifest.project_id;
       } catch (e) {
       }
     }
     if (!projectId) {
-      spinner.fail(chalk24.red('No project context. Run "rigstate link" first.'));
+      spinner.fail(chalk25.red('No project context. Run "rigstate link" first.'));
       return;
     }
     const apiUrl = getApiUrl();
     try {
-      const response = await axios17.get(`${apiUrl}/api/v1/roadmap`, {
+      const response = await axios18.get(`${apiUrl}/api/v1/roadmap`, {
         params: { project_id: projectId },
         headers: { Authorization: `Bearer ${apiKey}` }
       });
@@ -4760,41 +4974,41 @@ function createFocusCommand() {
       const nextTask = activeTasks[0];
       spinner.stop();
       console.log("");
-      console.log(chalk24.bold.blue(`\u{1F4CC} Task #${nextTask.step_number || "?"}: ${nextTask.title}`));
-      const statusColor = nextTask.status === "IN_PROGRESS" ? chalk24.yellow : nextTask.status === "ACTIVE" ? chalk24.green : chalk24.dim;
-      console.log(chalk24.dim("Status: ") + statusColor(nextTask.status));
-      console.log(chalk24.dim("\u2500".repeat(60)));
+      console.log(chalk25.bold.blue(`\u{1F4CC} Task #${nextTask.step_number || "?"}: ${nextTask.title}`));
+      const statusColor = nextTask.status === "IN_PROGRESS" ? chalk25.yellow : nextTask.status === "ACTIVE" ? chalk25.green : chalk25.dim;
+      console.log(chalk25.dim("Status: ") + statusColor(nextTask.status));
+      console.log(chalk25.dim("\u2500".repeat(60)));
       if (nextTask.prompt_content) {
-        console.log(chalk24.white(nextTask.prompt_content));
-        console.log(chalk24.dim("\u2500".repeat(60)));
+        console.log(chalk25.white(nextTask.prompt_content));
+        console.log(chalk25.dim("\u2500".repeat(60)));
         if (options.copy !== false) {
           try {
             if (process.platform === "darwin") {
               execSync5("pbcopy", { input: nextTask.prompt_content });
-              console.log(chalk24.green("\u2705 Prompt copied to clipboard! Ready to paste (Cmd+V)."));
+              console.log(chalk25.green("\u2705 Prompt copied to clipboard! Ready to paste (Cmd+V)."));
             } else if (process.platform === "linux") {
               try {
                 execSync5("xclip -selection clipboard", { input: nextTask.prompt_content });
-                console.log(chalk24.green("\u2705 Prompt copied to clipboard!"));
+                console.log(chalk25.green("\u2705 Prompt copied to clipboard!"));
               } catch (e) {
-                console.log(chalk24.yellow("\u2139\uFE0F  Copy prompt manually (xclip not available)"));
+                console.log(chalk25.yellow("\u2139\uFE0F  Copy prompt manually (xclip not available)"));
               }
             } else {
-              console.log(chalk24.yellow("\u2139\uFE0F  Copy prompt manually (Auto-copy not supported on this OS)"));
+              console.log(chalk25.yellow("\u2139\uFE0F  Copy prompt manually (Auto-copy not supported on this OS)"));
             }
           } catch (e) {
           }
         }
       } else {
-        console.log(chalk24.yellow("No prompt instructions available."));
+        console.log(chalk25.yellow("No prompt instructions available."));
         if (nextTask.architectural_brief) {
-          console.log(chalk24.bold("Brief:"));
+          console.log(chalk25.bold("Brief:"));
           console.log(nextTask.architectural_brief);
         }
       }
       console.log("");
     } catch (e) {
-      spinner.fail(chalk24.red(`Failed to fetch task: ${e.message}`));
+      spinner.fail(chalk25.red(`Failed to fetch task: ${e.message}`));
     }
   });
   return focus;
@@ -4806,26 +5020,26 @@ init_env();
 // src/commands/config.ts
 init_esm_shims();
 init_config();
-import { Command as Command15 } from "commander";
-import chalk25 from "chalk";
+import { Command as Command16 } from "commander";
+import chalk26 from "chalk";
 function createConfigCommand() {
-  const config2 = new Command15("config");
+  const config2 = new Command16("config");
   config2.description("View or modify Rigstate configuration").argument("[key]", "Configuration key to view/set (api_key, project_id, api_url)").argument("[value]", "Value to set").action(async (key, value) => {
     if (!key) {
-      console.log(chalk25.bold("Rigstate Configuration"));
-      console.log(chalk25.dim("\u2500".repeat(40)));
+      console.log(chalk26.bold("Rigstate Configuration"));
+      console.log(chalk26.dim("\u2500".repeat(40)));
       try {
         const apiKey = getApiKey();
-        console.log(`${chalk25.cyan("api_key")}: ${apiKey.substring(0, 20)}...`);
+        console.log(`${chalk26.cyan("api_key")}: ${apiKey.substring(0, 20)}...`);
       } catch (e) {
-        console.log(`${chalk25.cyan("api_key")}: ${chalk25.dim("(not set)")}`);
+        console.log(`${chalk26.cyan("api_key")}: ${chalk26.dim("(not set)")}`);
       }
       const projectId = getProjectId();
-      console.log(`${chalk25.cyan("project_id")}: ${projectId || chalk25.dim("(not set)")}`);
+      console.log(`${chalk26.cyan("project_id")}: ${projectId || chalk26.dim("(not set)")}`);
       const apiUrl = getApiUrl();
-      console.log(`${chalk25.cyan("api_url")}: ${apiUrl}`);
+      console.log(`${chalk26.cyan("api_url")}: ${apiUrl}`);
       console.log("");
-      console.log(chalk25.dim('Use "rigstate config <key> <value>" to set a value.'));
+      console.log(chalk26.dim('Use "rigstate config <key> <value>" to set a value.'));
       return;
     }
     if (!value) {
@@ -4835,37 +5049,37 @@ function createConfigCommand() {
             const apiKey = getApiKey();
             console.log(apiKey);
           } catch (e) {
-            console.log(chalk25.dim("(not set)"));
+            console.log(chalk26.dim("(not set)"));
           }
           break;
         case "project_id":
-          console.log(getProjectId() || chalk25.dim("(not set)"));
+          console.log(getProjectId() || chalk26.dim("(not set)"));
           break;
         case "api_url":
           console.log(getApiUrl());
           break;
         default:
-          console.log(chalk25.red(`Unknown config key: ${key}`));
-          console.log(chalk25.dim("Valid keys: api_key, project_id, api_url"));
+          console.log(chalk26.red(`Unknown config key: ${key}`));
+          console.log(chalk26.dim("Valid keys: api_key, project_id, api_url"));
       }
       return;
     }
     switch (key) {
       case "api_key":
         setApiKey(value);
-        console.log(chalk25.green(`\u2705 api_key updated`));
+        console.log(chalk26.green(`\u2705 api_key updated`));
         break;
       case "project_id":
         setProjectId(value);
-        console.log(chalk25.green(`\u2705 project_id updated`));
+        console.log(chalk26.green(`\u2705 project_id updated`));
         break;
       case "api_url":
         setApiUrl(value);
-        console.log(chalk25.green(`\u2705 api_url updated`));
+        console.log(chalk26.green(`\u2705 api_url updated`));
         break;
       default:
-        console.log(chalk25.red(`Unknown config key: ${key}`));
-        console.log(chalk25.dim("Valid keys: api_key, project_id, api_url"));
+        console.log(chalk26.red(`Unknown config key: ${key}`));
+        console.log(chalk26.dim("Valid keys: api_key, project_id, api_url"));
     }
   });
   return config2;
@@ -4874,42 +5088,42 @@ function createConfigCommand() {
 // src/commands/mcp.ts
 init_esm_shims();
 init_config();
-import { Command as Command16 } from "commander";
-import chalk26 from "chalk";
+import { Command as Command17 } from "commander";
+import chalk27 from "chalk";
 import { spawn } from "child_process";
-import path25 from "path";
-import fs22 from "fs";
+import path26 from "path";
+import fs23 from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname2 = path25.dirname(__filename2);
+var __dirname2 = path26.dirname(__filename2);
 function createMcpCommand() {
-  const mcp = new Command16("mcp");
+  const mcp = new Command17("mcp");
   mcp.description("Run the Rigstate MCP server for AI editors").action(async () => {
     const possiblePaths = [
       // From packages/cli -> packages/mcp (sibling package)
-      path25.resolve(__dirname2, "../../mcp/dist/index.js"),
+      path26.resolve(__dirname2, "../../mcp/dist/index.js"),
       // If installed globally or via npm
-      path25.resolve(__dirname2, "../../../mcp/dist/index.js"),
+      path26.resolve(__dirname2, "../../../mcp/dist/index.js"),
       // Development path from packages/cli/dist
-      path25.resolve(__dirname2, "../../../packages/mcp/dist/index.js")
+      path26.resolve(__dirname2, "../../../packages/mcp/dist/index.js")
     ];
     let serverPath = "";
     for (const p of possiblePaths) {
-      if (fs22.existsSync(p)) {
+      if (fs23.existsSync(p)) {
         serverPath = p;
         break;
       }
     }
     if (!serverPath) {
-      console.error(chalk26.red("\u274C Error: Rigstate MCP Server binary not found."));
-      console.error(chalk26.yellow("Please ensure that the mcp package is built:"));
-      console.error(chalk26.white("   cd packages/mcp && npm run build"));
+      console.error(chalk27.red("\u274C Error: Rigstate MCP Server binary not found."));
+      console.error(chalk27.yellow("Please ensure that the mcp package is built:"));
+      console.error(chalk27.white("   cd packages/mcp && npm run build"));
       console.error("");
-      console.error(chalk26.dim("Or run directly with:"));
-      console.error(chalk26.white("   npx @rigstate/mcp"));
+      console.error(chalk27.dim("Or run directly with:"));
+      console.error(chalk27.white("   npx @rigstate/mcp"));
       process.exit(1);
     }
-    console.log(chalk26.dim(`Starting MCP server from: ${serverPath}`));
+    console.log(chalk27.dim(`Starting MCP server from: ${serverPath}`));
     const env = { ...process.env };
     try {
       const apiKey = getApiKey();
@@ -4928,7 +5142,7 @@ function createMcpCommand() {
       stdio: ["inherit", "inherit", "inherit"]
     });
     worker.on("error", (err) => {
-      console.error(chalk26.red(`\u274C Failed to start MCP server: ${err.message}`));
+      console.error(chalk27.red(`\u274C Failed to start MCP server: ${err.message}`));
       process.exit(1);
     });
     worker.on("exit", (code) => {
@@ -4942,8 +5156,8 @@ function createMcpCommand() {
 
 // src/commands/nexus.ts
 init_esm_shims();
-import { Command as Command17 } from "commander";
-import chalk28 from "chalk";
+import { Command as Command18 } from "commander";
+import chalk29 from "chalk";
 
 // src/nexus/dispatcher.ts
 init_esm_shims();
@@ -4952,7 +5166,7 @@ import { v4 as uuidv4 } from "uuid";
 
 // src/hive/gateway.ts
 init_esm_shims();
-import axios18 from "axios";
+import axios19 from "axios";
 
 // src/hive/scrubber.ts
 init_esm_shims();
@@ -5011,7 +5225,7 @@ var HiveScrubber = class {
 };
 
 // src/hive/gateway.ts
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 var HiveGateway = class {
   client;
   enabled;
@@ -5021,9 +5235,9 @@ var HiveGateway = class {
   constructor(baseUrl, token) {
     this.enabled = !!token;
     if (!this.enabled) {
-      console.log(chalk27.dim("\u26A0\uFE0F Hive Gateway disabled (No Token provided). Running in localized mode."));
+      console.log(chalk28.dim("\u26A0\uFE0F Hive Gateway disabled (No Token provided). Running in localized mode."));
     }
-    this.client = axios18.create({
+    this.client = axios19.create({
       baseURL: baseUrl,
       headers: {
         "Authorization": `Bearer ${token}`,
@@ -5041,23 +5255,23 @@ var HiveGateway = class {
     if (!this.enabled) return false;
     const now = Date.now();
     if (now - this.lastSignalTime < this.MIN_INTERVAL_MS) {
-      console.warn(chalk27.yellow("\u23F3 Hive Gateway Throttled. Signal dropped to preventing spam."));
+      console.warn(chalk28.yellow("\u23F3 Hive Gateway Throttled. Signal dropped to preventing spam."));
       return false;
     }
     const scrubResult = HiveScrubber.scrub(signal.ruleContent);
     if (scrubResult.riskScore > 20) {
-      console.error(chalk27.red(`\u{1F6D1} HIVE BLOCKED: Signal contains sensitive data (Risk: ${scrubResult.riskScore})`));
+      console.error(chalk28.red(`\u{1F6D1} HIVE BLOCKED: Signal contains sensitive data (Risk: ${scrubResult.riskScore})`));
       return false;
     }
     try {
-      console.log(chalk27.blue(`\u{1F4E1} Uplinking to Hive... [${signal.vector}]`));
+      console.log(chalk28.blue(`\u{1F4E1} Uplinking to Hive... [${signal.vector}]`));
       const payload = { ...signal, ruleContent: scrubResult.sanitizedContent };
       await this.client.post("/signal", payload);
       this.lastSignalTime = now;
-      console.log(chalk27.green("\u2705 Signal Received by Hive Core. Knowledge Shared."));
+      console.log(chalk28.green("\u2705 Signal Received by Hive Core. Knowledge Shared."));
       return true;
     } catch (error) {
-      console.error(chalk27.red(`\u274C Hive Transmission Failed: ${error.message}`));
+      console.error(chalk28.red(`\u274C Hive Transmission Failed: ${error.message}`));
       return false;
     }
   }
@@ -5155,15 +5369,15 @@ var NexusDispatcher = class extends EventEmitter4 {
 };
 
 // src/commands/nexus.ts
-import inquirer3 from "inquirer";
+import inquirer4 from "inquirer";
 function createNexusCommand() {
-  const command = new Command17("nexus");
+  const command = new Command18("nexus");
   command.description("Interact with The Multi-Agent Nexus (Phase 8)").argument("<intent>", "The natural language instruction for the swarm").option("--dry-run", "Enable Dry-Run mode (Kill-Switch Active)", true).option("--force", "Disable Dry-Run mode (DANGEROUS)", false).action(async (intent, options) => {
-    console.log(chalk28.bold.magenta("\n\u{1F981} Welcome to The Nexus (Phase 8)\n"));
+    console.log(chalk29.bold.magenta("\n\u{1F981} Welcome to The Nexus (Phase 8)\n"));
     const dryRun = !options.force;
     if (!dryRun) {
-      console.log(chalk28.black.bgYellow(" WARNING ") + chalk28.yellow(" Dry-Run disabled! Eitri is authorized to write code."));
-      const { confirm } = await inquirer3.prompt([{
+      console.log(chalk29.black.bgYellow(" WARNING ") + chalk29.yellow(" Dry-Run disabled! Eitri is authorized to write code."));
+      const { confirm } = await inquirer4.prompt([{
         type: "confirm",
         name: "confirm",
         message: "Are you absolutely sure you want to bypass the Kill-Switch?",
@@ -5183,26 +5397,26 @@ function createNexusCommand() {
     };
     const dispatcher = new NexusDispatcher(context);
     dispatcher.on("order:created", (o) => {
-      console.log(chalk28.blue(`\u{1F195} [${o.id.slice(0, 6)}] Order Created: `) + o.intent);
+      console.log(chalk29.blue(`\u{1F195} [${o.id.slice(0, 6)}] Order Created: `) + o.intent);
     });
     dispatcher.on("order:started", (o) => {
-      console.log(chalk28.yellow(`\u23F3 [${o.id.slice(0, 6)}] Processing...`));
+      console.log(chalk29.yellow(`\u23F3 [${o.id.slice(0, 6)}] Processing...`));
     });
     dispatcher.on("order:blocked", (o) => {
-      console.log(chalk28.red(`\u{1F6D1} [${o.id.slice(0, 6)}] BLOCKED by Kill-Switch`));
-      console.log(chalk28.dim(`   Target: ${o.targetAgent} | Action: ${o.action}`));
-      console.log(chalk28.dim("   Run with --force to execute automatically (NOT RECOMMENDED)."));
+      console.log(chalk29.red(`\u{1F6D1} [${o.id.slice(0, 6)}] BLOCKED by Kill-Switch`));
+      console.log(chalk29.dim(`   Target: ${o.targetAgent} | Action: ${o.action}`));
+      console.log(chalk29.dim("   Run with --force to execute automatically (NOT RECOMMENDED)."));
     });
-    dispatcher.on("agent:SINDRE", (o) => console.log(chalk28.cyan(`\u{1F916} Sindre (Vault): I'm on it! (${o.action})`)));
-    dispatcher.on("agent:EITRI", (o) => console.log(chalk28.green(`\u{1F477} Eitri (Smith): Ready to build! (${o.action})`)));
-    console.log(chalk28.dim("\u{1F9E0} Frank is analyzing your intent..."));
+    dispatcher.on("agent:SINDRE", (o) => console.log(chalk29.cyan(`\u{1F916} Sindre (Vault): I'm on it! (${o.action})`)));
+    dispatcher.on("agent:EITRI", (o) => console.log(chalk29.green(`\u{1F477} Eitri (Smith): Ready to build! (${o.action})`)));
+    console.log(chalk29.dim("\u{1F9E0} Frank is analyzing your intent..."));
     await new Promise((r) => setTimeout(r, 800));
     if (intent.toLowerCase().includes("db") || intent.toLowerCase().includes("database")) {
       await dispatcher.dispatch("FRANK", "SINDRE", intent, "db.analyze", { raw: intent });
     } else if (intent.toLowerCase().includes("create") || intent.toLowerCase().includes("code")) {
       await dispatcher.dispatch("FRANK", "EITRI", intent, "fs.write", { path: "src/demo.ts", content: "// demo" });
     } else {
-      console.log(chalk28.gray("Frank didn't understand. Try 'create file' or 'check database'."));
+      console.log(chalk29.gray("Frank didn't understand. Try 'create file' or 'check database'."));
     }
   });
   return command;
@@ -5215,32 +5429,32 @@ init_sync_rules();
 init_esm_shims();
 init_governance();
 init_config();
-import { Command as Command18 } from "commander";
-import chalk29 from "chalk";
-import axios19 from "axios";
+import { Command as Command19 } from "commander";
+import chalk30 from "chalk";
+import axios20 from "axios";
 function createOverrideCommand() {
-  const override = new Command18("override");
+  const override = new Command19("override");
   override.description("Emergency Override for Governance Soft Locks").argument("<violationId>", 'ID of the violation to override (or "all")').requiredOption("-r, --reason <reason>", "Description of why this override is necessary").action(async (violationId, options) => {
     const { reason } = options;
-    console.log(chalk29.bold(`
+    console.log(chalk30.bold(`
 \u{1F513} Initiating Governance Override Protocol...`));
     const session = await getSessionState(process.cwd());
     if (session.status !== "SOFT_LOCK") {
-      console.log(chalk29.yellow("   Info: Session is not currently locked."));
+      console.log(chalk30.yellow("   Info: Session is not currently locked."));
       return;
     }
-    console.log(chalk29.dim(`   Active Violation: ${session.active_violation}`));
-    console.log(chalk29.dim(`   Reason Provided:  "${reason}"`));
+    console.log(chalk30.dim(`   Active Violation: ${session.active_violation}`));
+    console.log(chalk30.dim(`   Reason Provided:  "${reason}"`));
     const success = await performOverride(violationId, reason, process.cwd());
     if (success) {
-      console.log(chalk29.green(`   \u2705 Session UNLOCKED.`));
-      console.log(chalk29.dim(`   This event has been logged to the Mission Report.`));
+      console.log(chalk30.green(`   \u2705 Session UNLOCKED.`));
+      console.log(chalk30.dim(`   This event has been logged to the Mission Report.`));
       try {
         const projectId = getProjectId();
         if (projectId) {
           const apiUrl = getApiUrl();
           const apiKey = getApiKey();
-          await axios19.post(`${apiUrl}/api/v1/execution-logs`, {
+          await axios20.post(`${apiUrl}/api/v1/execution-logs`, {
             project_id: projectId,
             task_id: "OVERRIDE-" + Date.now(),
             task_title: `Governance Override: ${violationId}`,
@@ -5251,13 +5465,13 @@ function createOverrideCommand() {
           }, {
             headers: { Authorization: `Bearer ${apiKey}` }
           });
-          console.log(chalk29.dim(`   \u2601 Audit log synced to Cloud.`));
+          console.log(chalk30.dim(`   \u2601 Audit log synced to Cloud.`));
         }
       } catch (e) {
-        console.log(chalk29.dim(`   (Cloud audit sync failed: ${e.message})`));
+        console.log(chalk30.dim(`   (Cloud audit sync failed: ${e.message})`));
       }
     } else {
-      console.log(chalk29.red(`   \u{1F6D1} Override Failed. Check project configuration.`));
+      console.log(chalk30.red(`   \u{1F6D1} Override Failed. Check project configuration.`));
     }
   });
   return override;
@@ -5266,26 +5480,26 @@ function createOverrideCommand() {
 // src/commands/idea.ts
 init_esm_shims();
 init_config();
-import { Command as Command19 } from "commander";
-import chalk30 from "chalk";
-import ora12 from "ora";
-import axios20 from "axios";
-import inquirer4 from "inquirer";
+import { Command as Command20 } from "commander";
+import chalk31 from "chalk";
+import ora13 from "ora";
+import axios21 from "axios";
+import inquirer5 from "inquirer";
 function createIdeaCommand() {
-  return new Command19("idea").description("Capture a new idea or feature request").argument("[title]", "Quick title of the idea").option("-d, --desc <text>", "Detailed description").option("-t, --tag <tags>", "Comma separated tags (e.g. ui,auth)").action(async (title, options) => {
+  return new Command20("idea").description("Capture a new idea or feature request").argument("[title]", "Quick title of the idea").option("-d, --desc <text>", "Detailed description").option("-t, --tag <tags>", "Comma separated tags (e.g. ui,auth)").action(async (title, options) => {
     try {
       const apiKey = getApiKey();
       const apiUrl = getApiUrl();
       const projectId = getProjectId();
       if (!projectId) {
-        console.error(chalk30.red("Project context missing. Run rigstate link."));
+        console.error(chalk31.red("Project context missing. Run rigstate link."));
         process.exit(1);
       }
       let ideaTitle = title;
       let ideaDesc = options.desc;
       let tags = options.tag ? options.tag.split(",") : [];
       if (!ideaTitle) {
-        const ans = await inquirer4.prompt([{
+        const ans = await inquirer5.prompt([{
           type: "input",
           name: "title",
           message: "Idea Title:"
@@ -5293,7 +5507,7 @@ function createIdeaCommand() {
         ideaTitle = ans.title;
       }
       if (!ideaDesc) {
-        const ans = await inquirer4.prompt([{
+        const ans = await inquirer5.prompt([{
           type: "input",
           name: "desc",
           message: "Description (Optional):"
@@ -5302,8 +5516,8 @@ function createIdeaCommand() {
       }
       if (tags.length === 0) {
       }
-      const spinner = ora12("Securing idea in the Lab...").start();
-      const response = await axios20.post(
+      const spinner = ora13("Securing idea in the Lab...").start();
+      const response = await axios21.post(
         `${apiUrl}/api/v1/ideas`,
         {
           project_id: projectId,
@@ -5314,14 +5528,14 @@ function createIdeaCommand() {
         { headers: { Authorization: `Bearer ${apiKey}` } }
       );
       if (response.data.success) {
-        spinner.succeed(chalk30.green("Idea Captured! \u{1F4A1}"));
-        console.log(chalk30.dim(`ID: ${response.data.data?.id || "Saved"}`));
+        spinner.succeed(chalk31.green("Idea Captured! \u{1F4A1}"));
+        console.log(chalk31.dim(`ID: ${response.data.data?.id || "Saved"}`));
       } else {
         throw new Error(response.data.error);
       }
     } catch (e) {
       const errorDetail = e.response?.data?.error || e.message;
-      console.error(chalk30.red(`
+      console.error(chalk31.red(`
 Failed to capture idea: ${errorDetail}`));
     }
   });
@@ -5330,12 +5544,12 @@ Failed to capture idea: ${errorDetail}`));
 // src/commands/release.ts
 init_esm_shims();
 init_config();
-import { Command as Command20 } from "commander";
-import chalk31 from "chalk";
-import ora13 from "ora";
-import inquirer5 from "inquirer";
-import fs23 from "fs/promises";
-import path26 from "path";
+import { Command as Command21 } from "commander";
+import chalk32 from "chalk";
+import ora14 from "ora";
+import inquirer6 from "inquirer";
+import fs24 from "fs/promises";
+import path27 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 init_esm_shims();
@@ -5375,8 +5589,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path27) {
-  return path27 instanceof String && cache.has(path27);
+function isPathSpec(path28) {
+  return path28 instanceof String && cache.has(path28);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -5465,8 +5679,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path27) {
-  return (0, import_file_exists.exists)(path27, import_file_exists.FOLDER);
+function folderExists(path28) {
+  return (0, import_file_exists.exists)(path28, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -5870,8 +6084,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path27) {
-      return /^\.(git)?$/.test(path27.trim());
+    parser(path28) {
+      return /^\.(git)?$/.test(path28.trim());
     }
   };
 }
@@ -6305,11 +6519,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path27, line, preview] = input.split(NULL);
-    paths.add(path27);
-    (results[path27] = results[path27] || []).push({
+    const [path28, line, preview] = input.split(NULL);
+    paths.add(path28);
+    (results[path28] = results[path28] || []).push({
       line: asNumber(line),
-      path: path27,
+      path: path28,
       preview
     });
   });
@@ -7074,14 +7288,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path27, text) {
+function parseInit(bare, path28, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path27, false, result[1]);
+    return new InitSummary(bare, path28, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path27, true, result[1]);
+    return new InitSummary(bare, path28, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -7092,7 +7306,7 @@ function parseInit(bare, path27, text) {
       break;
     }
   }
-  return new InitSummary(bare, path27, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path28, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -7101,9 +7315,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path27, existing, gitDir) {
+      constructor(bare, path28, existing, gitDir) {
         this.bare = bare;
-        this.path = path27;
+        this.path = path28;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -7115,7 +7329,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path27, customArgs) {
+function initTask(bare = false, path28, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -7124,7 +7338,7 @@ function initTask(bare = false, path27, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path27, text);
+      return parseInit(commands.includes("--bare"), path28, text);
     }
   };
 }
@@ -7940,12 +8154,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path27, index, working_dir) {
-        this.path = path27;
+      constructor(path28, index, working_dir) {
+        this.path = path28;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path27) || [null, path27, path27];
+          const detail = fromPathRegex.exec(path28) || [null, path28, path28];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -7976,14 +8190,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path27) {
+  function data(index, workingDir, path28) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path27);
+      handler(result, path28);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path27, index, workingDir));
+      result.files.push(new FileStatusSummary(path28, index, workingDir));
     }
   }
 }
@@ -8296,9 +8510,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path27, write) {
+      hashObject(path28, write) {
         return this._runTask(
-          hashObjectTask(path27, write === true),
+          hashObjectTask(path28, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -8651,8 +8865,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path27 = input.trim().replace(/^["']|["']$/g, "");
-  return path27 && normalize(path27);
+  const path28 = input.trim().replace(/^["']|["']$/g, "");
+  return path28 && normalize(path28);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -8966,8 +9180,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path27) {
-  return subModuleTask(["add", repo, path27]);
+function addSubModuleTask(repo, path28) {
+  return subModuleTask(["add", repo, path28]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -9297,8 +9511,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path27, then) {
-      return this._runTask(addSubModuleTask2(repo, path27), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path28, then) {
+      return this._runTask(addSubModuleTask2(repo, path28), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -9888,18 +10102,18 @@ var simpleGit = gitInstanceFactory;
 // src/commands/release.ts
 var git = simpleGit();
 function createReleaseCommand() {
-  return new Command20("release").description("Ship a new version (Changelog, Tag, Bump)").argument("[type]", "Release type (patch, minor, major)", "patch").action(async (type) => {
-    const spinner = ora13("Preparing release...").start();
+  return new Command21("release").description("Ship a new version (Changelog, Tag, Bump)").argument("[type]", "Release type (patch, minor, major)", "patch").action(async (type) => {
+    const spinner = ora14("Preparing release...").start();
     try {
-      const { projectId, apiKey, apiUrl } = getContext2();
+      const { projectId, apiKey, apiUrl } = getContext3();
       const status = await git.status();
       if (!status.isClean()) {
         spinner.fail("Git workspace is dirty. Commit or stash changes first.");
         return;
       }
       spinner.text = "Scanning completed tasks...";
-      const pkgPath = path26.resolve(process.cwd(), "package.json");
-      const pkgContent = await fs23.readFile(pkgPath, "utf-8");
+      const pkgPath = path27.resolve(process.cwd(), "package.json");
+      const pkgContent = await fs24.readFile(pkgPath, "utf-8");
       const pkg2 = JSON.parse(pkgContent);
       const currentVersion = pkg2.version;
       const [major, minor, patch] = currentVersion.split(".").map(Number);
@@ -9907,8 +10121,8 @@ function createReleaseCommand() {
       if (type === "major") newVersion = `${major + 1}.0.0`;
       if (type === "minor") newVersion = `${major}.${minor + 1}.0`;
       if (type === "patch") newVersion = `${major}.${minor}.${patch + 1}`;
-      spinner.succeed(`Bumping ${pkg2.name} from ${chalk31.dim(currentVersion)} to ${chalk31.green(newVersion)}`);
-      const { confirm } = await inquirer5.prompt([{
+      spinner.succeed(`Bumping ${pkg2.name} from ${chalk32.dim(currentVersion)} to ${chalk32.green(newVersion)}`);
+      const { confirm } = await inquirer6.prompt([{
         type: "confirm",
         name: "confirm",
         message: `Ship v${newVersion}? This will tag git and update changelog (if db ready).`,
@@ -9919,17 +10133,17 @@ function createReleaseCommand() {
         return;
       }
       pkg2.version = newVersion;
-      await fs23.writeFile(pkgPath, JSON.stringify(pkg2, null, 4));
-      const changelogPath = path26.resolve(process.cwd(), "CHANGELOG.md");
+      await fs24.writeFile(pkgPath, JSON.stringify(pkg2, null, 4));
+      const changelogPath = path27.resolve(process.cwd(), "CHANGELOG.md");
       const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       const entry = `
 ## [${newVersion}] - ${date}
 - Automated release via Rigstate.
 `;
       try {
-        await fs23.appendFile(changelogPath, entry);
+        await fs24.appendFile(changelogPath, entry);
       } catch {
-        await fs23.writeFile(changelogPath, "# Changelog\n" + entry);
+        await fs24.writeFile(changelogPath, "# Changelog\n" + entry);
       }
       spinner.start("Tagging and pushing...");
       await git.add(["package.json", "CHANGELOG.md"]);
@@ -9937,13 +10151,13 @@ function createReleaseCommand() {
       await git.addTag(`v${newVersion}`);
       await git.push();
       await git.pushTags();
-      spinner.succeed(chalk31.bold.green(`\u{1F680} Release v${newVersion} shipped!`));
+      spinner.succeed(chalk32.bold.green(`\u{1F680} Release v${newVersion} shipped!`));
     } catch (e) {
       spinner.fail(e.message);
     }
   });
 }
-function getContext2() {
+function getContext3() {
   const apiKey = getApiKey();
   const apiUrl = getApiUrl();
   const projectId = getProjectId();
@@ -9954,22 +10168,22 @@ function getContext2() {
 // src/commands/roadmap.ts
 init_esm_shims();
 init_config();
-import { Command as Command21 } from "commander";
-import chalk32 from "chalk";
-import ora14 from "ora";
-import axios21 from "axios";
+import { Command as Command22 } from "commander";
+import chalk33 from "chalk";
+import ora15 from "ora";
+import axios22 from "axios";
 function createRoadmapCommand() {
-  return new Command21("roadmap").alias("tactical").description("View project roadmap and task status (Tactical View)").action(async () => {
-    const spinner = ora14("Fetching tactical overview...").start();
+  return new Command22("roadmap").alias("tactical").description("View project roadmap and task status (Tactical View)").action(async () => {
+    const spinner = ora15("Fetching tactical overview...").start();
     try {
       const apiKey = getApiKey();
       const apiUrl = getApiUrl();
       const projectId = getProjectId();
       if (!projectId) {
-        spinner.fail(chalk32.red('Project context missing. Run "rigstate link".'));
+        spinner.fail(chalk33.red('Project context missing. Run "rigstate link".'));
         return;
       }
-      const response = await axios21.get(
+      const response = await axios22.get(
         `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
         { headers: { Authorization: `Bearer ${apiKey}` } }
       );
@@ -9979,11 +10193,11 @@ function createRoadmapCommand() {
       const tasks = response.data.data.roadmap || [];
       spinner.stop();
       if (tasks.length === 0) {
-        console.log(chalk32.yellow("\nRoadmap is empty. Use the web UI to define your journey."));
+        console.log(chalk33.yellow("\nRoadmap is empty. Use the web UI to define your journey."));
         return;
       }
-      console.log("\n" + chalk32.bold.underline("\u{1F6F0}\uFE0F  TACTICAL OVERVIEW: PROJECT ROADMAP"));
-      console.log(chalk32.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log("\n" + chalk33.bold.underline("\u{1F6F0}\uFE0F  TACTICAL OVERVIEW: PROJECT ROADMAP"));
+      console.log(chalk33.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
       const columns = {
         "IN_PROGRESS": [],
         "ACTIVE": [],
@@ -9995,14 +10209,14 @@ function createRoadmapCommand() {
           columns[t.status].push(t);
         }
       });
-      displayColumn("\u{1F525} IN PROGRESS", columns.IN_PROGRESS, chalk32.yellow);
-      displayColumn("\u25B6\uFE0F  ACTIVE / NEXT", columns.ACTIVE, chalk32.green);
-      displayColumn("\u{1F512} LOCKED", columns.LOCKED, chalk32.blue);
-      displayColumn("\u23F3 PENDING", columns.PENDING, chalk32.gray);
-      console.log(chalk32.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(chalk32.dim(`Total: ${tasks.length} tasks | Run "rigstate work" to start coding.`));
+      displayColumn("\u{1F525} IN PROGRESS", columns.IN_PROGRESS, chalk33.yellow);
+      displayColumn("\u25B6\uFE0F  ACTIVE / NEXT", columns.ACTIVE, chalk33.green);
+      displayColumn("\u{1F512} LOCKED", columns.LOCKED, chalk33.blue);
+      displayColumn("\u23F3 PENDING", columns.PENDING, chalk33.gray);
+      console.log(chalk33.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk33.dim(`Total: ${tasks.length} tasks | Run "rigstate work" to start coding.`));
     } catch (e) {
-      spinner.fail(chalk32.red(`
+      spinner.fail(chalk33.red(`
 Failed to fetch roadmap: ${e.message}`));
     }
   });
@@ -10013,57 +10227,57 @@ function displayColumn(title, items, color) {
 ${color.bold(title)}`);
   items.sort((a, b) => a.step_number - b.step_number).forEach((item) => {
     const id = `T-${item.step_number}`.padEnd(8);
-    const priority = item.priority === "MVP" ? chalk32.magenta(" [MVP]") : "";
-    console.log(` ${color("\u2022")} ${chalk32.bold(id)} ${item.title}${priority}`);
+    const priority = item.priority === "MVP" ? chalk33.magenta(" [MVP]") : "";
+    console.log(` ${color("\u2022")} ${chalk33.bold(id)} ${item.title}${priority}`);
   });
 }
 
 // src/commands/council.ts
 init_esm_shims();
 init_config();
-import { Command as Command22 } from "commander";
-import chalk33 from "chalk";
-import ora15 from "ora";
-import inquirer6 from "inquirer";
+import { Command as Command23 } from "commander";
+import chalk34 from "chalk";
+import ora16 from "ora";
+import inquirer7 from "inquirer";
 function createCouncilCommand() {
-  return new Command22("council").description("Trigger a multi-agent debate regarding a strategic decision").argument("[topic]", "The strategic topic or decision to debate").action(async (topic) => {
-    const spinner = ora15();
+  return new Command23("council").description("Trigger a multi-agent debate regarding a strategic decision").argument("[topic]", "The strategic topic or decision to debate").action(async (topic) => {
+    const spinner = ora16();
     try {
       const apiKey = getApiKey();
       const apiUrl = getApiUrl();
       const projectId = getProjectId();
       if (!projectId) {
-        console.error(chalk33.red('Project context missing. Run "rigstate link".'));
+        console.error(chalk34.red('Project context missing. Run "rigstate link".'));
         return;
       }
       let sessionTopic = topic;
       if (!sessionTopic) {
-        const ans = await inquirer6.prompt([{
+        const ans = await inquirer7.prompt([{
           type: "input",
           name: "topic",
           message: "What strategic decision shall the Council debate?"
         }]);
         sessionTopic = ans.topic;
       }
-      console.log(chalk33.bold.magenta("\n\u2696\uFE0F  CONVENING THE COUNCIL OF SOVEREIGNTY\n"));
-      console.log(chalk33.dim(`Topic: ${sessionTopic}`));
-      console.log(chalk33.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(chalk33.yellow("\n\u{1F9E0} Frank (Architect): Analyzing alignment with Project DNA..."));
+      console.log(chalk34.bold.magenta("\n\u2696\uFE0F  CONVENING THE COUNCIL OF SOVEREIGNTY\n"));
+      console.log(chalk34.dim(`Topic: ${sessionTopic}`));
+      console.log(chalk34.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk34.yellow("\n\u{1F9E0} Frank (Architect): Analyzing alignment with Project DNA..."));
       await sleep(1500);
-      console.log(chalk33.gray('  "This decision affects our backend scalability. I recommend caution."'));
-      console.log(chalk33.blue("\n\u{1F6E1}\uFE0F  Sigrid (Curator): Checking historical precedents..."));
+      console.log(chalk34.gray('  "This decision affects our backend scalability. I recommend caution."'));
+      console.log(chalk34.blue("\n\u{1F6E1}\uFE0F  Sigrid (Curator): Checking historical precedents..."));
       await sleep(1500);
-      console.log(chalk33.gray(`  "Similar patterns in other projects led to technical debt. Let's review RLS."`));
-      console.log(chalk33.green("\n\u{1F4D0} Einar (Analyst): Scanning dependency impact..."));
+      console.log(chalk34.gray(`  "Similar patterns in other projects led to technical debt. Let's review RLS."`));
+      console.log(chalk34.green("\n\u{1F4D0} Einar (Analyst): Scanning dependency impact..."));
       await sleep(1500);
-      console.log(chalk33.gray('  "Implementation will require updating 3 core services."'));
-      console.log(chalk33.bold.white("\n\u{1F4CB} [FINAL DECISION RECORD]"));
-      console.log(chalk33.white("  Status:    Approved with conditions"));
-      console.log(chalk33.white("  Rationale: Value outweighs migration cost. Ensure SEC-SQL-01 compliance."));
-      console.log(chalk33.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(chalk33.green("\u2705 Decision saved to Project Brain (ADR-102)"));
+      console.log(chalk34.gray('  "Implementation will require updating 3 core services."'));
+      console.log(chalk34.bold.white("\n\u{1F4CB} [FINAL DECISION RECORD]"));
+      console.log(chalk34.white("  Status:    Approved with conditions"));
+      console.log(chalk34.white("  Rationale: Value outweighs migration cost. Ensure SEC-SQL-01 compliance."));
+      console.log(chalk34.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk34.green("\u2705 Decision saved to Project Brain (ADR-102)"));
     } catch (e) {
-      console.error(chalk33.red(`
+      console.error(chalk34.red(`
 Council session aborted: ${e.message}`));
     }
   });
@@ -10081,7 +10295,7 @@ async function checkVersion() {
 import dotenv from "dotenv";
 var pkg = require_package();
 dotenv.config();
-var program = new Command23();
+var program = new Command24();
 program.name("rigstate").description("CLI for Rigstate - The AI-Native Dev Studio").version(pkg.version);
 program.addCommand(createLoginCommand());
 program.addCommand(createLinkCommand());
@@ -10104,25 +10318,27 @@ program.addCommand(createOverrideCommand());
 program.addCommand(createIdeaCommand());
 program.addCommand(createReleaseCommand());
 program.addCommand(createRoadmapCommand());
+program.addCommand(createRoadmapCommand());
 program.addCommand(createCouncilCommand());
+program.addCommand(createPlanCommand());
 program.hook("preAction", async () => {
   await checkVersion();
 });
 program.on("--help", () => {
   console.log("");
-  console.log(chalk34.bold("Examples:"));
+  console.log(chalk35.bold("Examples:"));
   console.log("");
-  console.log(chalk34.cyan("  $ rigstate login sk_rigstate_your_api_key"));
-  console.log(chalk34.dim("    Authenticate with your Rigstate API key"));
+  console.log(chalk35.cyan("  $ rigstate login sk_rigstate_your_api_key"));
+  console.log(chalk35.dim("    Authenticate with your Rigstate API key"));
   console.log("");
-  console.log(chalk34.cyan("  $ rigstate scan"));
-  console.log(chalk34.dim("    Scan the current directory"));
+  console.log(chalk35.cyan("  $ rigstate scan"));
+  console.log(chalk35.dim("    Scan the current directory"));
   console.log("");
-  console.log(chalk34.cyan("  $ rigstate scan ./src --project abc123"));
-  console.log(chalk34.dim("    Scan a specific directory with project ID"));
+  console.log(chalk35.cyan("  $ rigstate scan ./src --project abc123"));
+  console.log(chalk35.dim("    Scan a specific directory with project ID"));
   console.log("");
-  console.log(chalk34.cyan("  $ rigstate scan --json"));
-  console.log(chalk34.dim("    Output results in JSON format (useful for IDE extensions)"));
+  console.log(chalk35.cyan("  $ rigstate scan --json"));
+  console.log(chalk35.dim("    Output results in JSON format (useful for IDE extensions)"));
   console.log("");
 });
 program.parse(process.argv);