@rigstate/cli 0.7.22 → 0.7.24

package/dist/index.cjs

@@ -280,10 +280,10 @@ async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
       const files = syncResponse.data.data.files;
       if (files && Array.isArray(files)) {
         const fs23 = await import("fs/promises");
-        const path24 = await import("path");
+        const path25 = await import("path");
         for (const file of files) {
-          const filePath = path24.join(process.cwd(), file.path);
-          await fs23.mkdir(path24.dirname(filePath), { recursive: true });
+          const filePath = path25.join(process.cwd(), file.path);
+          await fs23.mkdir(path25.dirname(filePath), { recursive: true });
           await fs23.writeFile(filePath, file.content, "utf-8");
         }
         console.log(import_chalk3.default.dim(`      \u{1F4BE} Wrote ${files.length} rule files to local .cursor/rules/`));
@@ -382,136 +382,6 @@ var init_suggest = __esm({
   }
 });
 
-// src/commands/hooks.ts
-var hooks_exports = {};
-__export(hooks_exports, {
-  createHooksCommand: () => createHooksCommand
-});
-function createHooksCommand() {
-  const hooks = new import_commander4.Command("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 = import_path2.default.join(process.cwd(), ".git");
-      try {
-        await import_promises2.default.access(gitDir);
-      } catch {
-        console.log(import_chalk5.default.red("\u274C Not a git repository."));
-        console.log(import_chalk5.default.dim('   Initialize with "git init" first.'));
-        process.exit(1);
-      }
-      const hooksDir = import_path2.default.join(gitDir, "hooks");
-      await import_promises2.default.mkdir(hooksDir, { recursive: true });
-      const preCommitPath = import_path2.default.join(hooksDir, "pre-commit");
-      let existingContent = "";
-      try {
-        existingContent = await import_promises2.default.readFile(preCommitPath, "utf-8");
-        if (existingContent.includes("rigstate")) {
-          console.log(import_chalk5.default.yellow("\u26A0 Rigstate pre-commit hook already installed."));
-          console.log(import_chalk5.default.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 import_promises2.default.writeFile(preCommitPath, combinedScript, { mode: 493 });
-        console.log(import_chalk5.default.green("\u2705 Rigstate hook appended to existing pre-commit."));
-      } else {
-        await import_promises2.default.writeFile(preCommitPath, script, { mode: 493 });
-        console.log(import_chalk5.default.green("\u2705 Pre-commit hook installed!"));
-      }
-      console.log(import_chalk5.default.dim(`   Path: ${preCommitPath}`));
-      console.log(import_chalk5.default.dim(`   Strict level: ${options.strict}`));
-      console.log("");
-      console.log(import_chalk5.default.cyan("Guardian will now check your code before each commit."));
-      console.log(import_chalk5.default.dim('Use "rigstate hooks uninstall" to remove the hook.'));
-    } catch (error) {
-      console.error(import_chalk5.default.red("Failed to install hook:"), error.message);
-      process.exit(1);
-    }
-  });
-  hooks.command("uninstall").description("Remove Rigstate pre-commit hook").action(async () => {
-    try {
-      const preCommitPath = import_path2.default.join(process.cwd(), ".git", "hooks", "pre-commit");
-      try {
-        const content = await import_promises2.default.readFile(preCommitPath, "utf-8");
-        if (!content.includes("rigstate")) {
-          console.log(import_chalk5.default.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 import_promises2.default.unlink(preCommitPath);
-          console.log(import_chalk5.default.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 import_promises2.default.writeFile(preCommitPath, filteredLines.join("\n"), { mode: 493 });
-          console.log(import_chalk5.default.green("\u2705 Rigstate section removed from pre-commit hook."));
-        }
-      } catch {
-        console.log(import_chalk5.default.yellow("\u26A0 No pre-commit hook found."));
-      }
-    } catch (error) {
-      console.error(import_chalk5.default.red("Failed to uninstall hook:"), error.message);
-      process.exit(1);
-    }
-  });
-  return hooks;
-}
-var import_commander4, import_chalk5, import_promises2, import_path2, PRE_COMMIT_SCRIPT;
-var init_hooks = __esm({
-  "src/commands/hooks.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_commander4 = require("commander");
-    import_chalk5 = __toESM(require("chalk"), 1);
-    import_promises2 = __toESM(require("fs/promises"), 1);
-    import_path2 = __toESM(require("path"), 1);
-    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/utils/skills-provisioner.ts
 var skills_provisioner_exports = {};
 __export(skills_provisioner_exports, {
@@ -540,18 +410,18 @@ async function provisionSkills(apiUrl, apiKey, projectId, rootDir) {
     }
   } catch (e) {
     const msg = e.response?.data?.error || e.message;
-    console.log(import_chalk9.default.dim(`  (Skills API not available: ${msg}, using core library)`));
+    console.log(import_chalk8.default.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 = import_path7.default.join(rootDir, ".agent", "skills");
-  await import_promises7.default.mkdir(skillsDir, { recursive: true });
+  const skillsDir = import_path6.default.join(rootDir, ".agent", "skills");
+  await import_promises6.default.mkdir(skillsDir, { recursive: true });
   for (const skill of skills) {
-    const skillDir = import_path7.default.join(skillsDir, skill.name);
-    await import_promises7.default.mkdir(skillDir, { recursive: true });
+    const skillDir = import_path6.default.join(skillsDir, skill.name);
+    await import_promises6.default.mkdir(skillDir, { recursive: true });
     const skillContent = `---
 name: ${skill.name}
 description: ${skill.description}
@@ -564,10 +434,10 @@ ${skill.content}
 
 ---
 *Provisioned by Rigstate CLI. Do not modify manually.*`;
-    const skillPath = import_path7.default.join(skillDir, "SKILL.md");
-    await import_promises7.default.writeFile(skillPath, skillContent, "utf-8");
+    const skillPath = import_path6.default.join(skillDir, "SKILL.md");
+    await import_promises6.default.writeFile(skillPath, skillContent, "utf-8");
   }
-  console.log(import_chalk9.default.green(`  \u2705 Provisioned ${skills.length} skill(s) to .agent/skills/`));
+  console.log(import_chalk8.default.green(`  \u2705 Provisioned ${skills.length} skill(s) to .agent/skills/`));
   return skills;
 }
 function generateSkillsDiscoveryBlock(skills) {
@@ -582,16 +452,16 @@ ${skillBlocks}
 </available_skills>`;
 }
 async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
-  const rulesPath = import_path7.default.join(rootDir, ".cursorrules");
+  const rulesPath = import_path6.default.join(rootDir, ".cursorrules");
   let rulesContent = "";
   try {
-    rulesContent = await import_promises7.default.readFile(rulesPath, "utf-8");
+    rulesContent = await import_promises6.default.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(import_chalk9.default.yellow(`  \u26A1 JIT PROVISIONING: Injecting ${skillId}...`));
+  console.log(import_chalk8.default.yellow(`  \u26A1 JIT PROVISIONING: Injecting ${skillId}...`));
   try {
     const skills = await provisionSkills(apiUrl, apiKey, projectId, rootDir);
     const skillsBlock = generateSkillsDiscoveryBlock(skills);
@@ -606,22 +476,22 @@ async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
         rulesContent = rulesContent.slice(0, insertPoint + 3) + "\n\n" + skillsBlock + "\n" + rulesContent.slice(insertPoint + 3);
       }
     }
-    await import_promises7.default.writeFile(rulesPath, rulesContent, "utf-8");
+    await import_promises6.default.writeFile(rulesPath, rulesContent, "utf-8");
     return true;
   } catch (e) {
-    console.log(import_chalk9.default.red(`  Failed to provision skill: ${e.message}`));
+    console.log(import_chalk8.default.red(`  Failed to provision skill: ${e.message}`));
     return false;
   }
 }
-var import_axios6, import_promises7, import_path7, import_chalk9;
+var import_axios6, import_promises6, import_path6, import_chalk8;
 var init_skills_provisioner = __esm({
   "src/utils/skills-provisioner.ts"() {
     "use strict";
     init_cjs_shims();
     import_axios6 = __toESM(require("axios"), 1);
-    import_promises7 = __toESM(require("fs/promises"), 1);
-    import_path7 = __toESM(require("path"), 1);
-    import_chalk9 = __toESM(require("chalk"), 1);
+    import_promises6 = __toESM(require("fs/promises"), 1);
+    import_path6 = __toESM(require("path"), 1);
+    import_chalk8 = __toESM(require("chalk"), 1);
   }
 });
 
@@ -637,8 +507,8 @@ __export(governance_exports, {
 });
 async function getGovernanceConfig(rootDir = process.cwd()) {
   try {
-    const configPath = import_path8.default.join(rootDir, "rigstate.config.json");
-    const content = await import_promises8.default.readFile(configPath, "utf-8");
+    const configPath = import_path7.default.join(rootDir, "rigstate.config.json");
+    const content = await import_promises7.default.readFile(configPath, "utf-8");
     const userConfig = JSON.parse(content);
     return {
       governance: {
@@ -652,50 +522,50 @@ async function getGovernanceConfig(rootDir = process.cwd()) {
 }
 async function getSessionState(rootDir = process.cwd()) {
   try {
-    const sessionPath = import_path8.default.join(rootDir, ".rigstate", "session.json");
-    const content = await import_promises8.default.readFile(sessionPath, "utf-8");
+    const sessionPath = import_path7.default.join(rootDir, ".rigstate", "session.json");
+    const content = await import_promises7.default.readFile(sessionPath, "utf-8");
     return JSON.parse(content);
   } catch (e) {
     return DEFAULT_SESSION;
   }
 }
 async function setSoftLock(reason, violationId, rootDir = process.cwd()) {
-  const sessionPath = import_path8.default.join(rootDir, ".rigstate", "session.json");
+  const sessionPath = import_path7.default.join(rootDir, ".rigstate", "session.json");
   const state = {
     status: "SOFT_LOCK",
     active_violation: violationId,
     lock_reason: reason,
     last_updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await import_promises8.default.mkdir(import_path8.default.dirname(sessionPath), { recursive: true });
-  await import_promises8.default.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
+  await import_promises7.default.mkdir(import_path7.default.dirname(sessionPath), { recursive: true });
+  await import_promises7.default.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
 }
 async function clearSoftLock(rootDir = process.cwd()) {
-  const sessionPath = import_path8.default.join(rootDir, ".rigstate", "session.json");
+  const sessionPath = import_path7.default.join(rootDir, ".rigstate", "session.json");
   const state = {
     ...DEFAULT_SESSION,
     last_updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await import_promises8.default.mkdir(import_path8.default.dirname(sessionPath), { recursive: true });
-  await import_promises8.default.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
+  await import_promises7.default.mkdir(import_path7.default.dirname(sessionPath), { recursive: true });
+  await import_promises7.default.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(import_chalk10.default.red("\u274C Overrides are disabled for this project."));
+    console.log(import_chalk9.default.red("\u274C Overrides are disabled for this project."));
     return false;
   }
   await clearSoftLock(rootDir);
   return true;
 }
-var import_promises8, import_path8, import_chalk10, InterventionLevel, DEFAULT_CONFIG, DEFAULT_SESSION;
+var import_promises7, import_path7, import_chalk9, InterventionLevel, DEFAULT_CONFIG, DEFAULT_SESSION;
 var init_governance = __esm({
   "src/utils/governance.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises8 = __toESM(require("fs/promises"), 1);
-    import_path8 = __toESM(require("path"), 1);
-    import_chalk10 = __toESM(require("chalk"), 1);
+    import_promises7 = __toESM(require("fs/promises"), 1);
+    import_path7 = __toESM(require("path"), 1);
+    import_chalk9 = __toESM(require("chalk"), 1);
     InterventionLevel = /* @__PURE__ */ ((InterventionLevel2) => {
       InterventionLevel2[InterventionLevel2["GHOST"] = 0] = "GHOST";
       InterventionLevel2[InterventionLevel2["NUDGE"] = 1] = "NUDGE";
@@ -724,16 +594,16 @@ __export(watchdog_exports, {
 });
 async function countLines(filePath) {
   try {
-    const content = await import_promises9.default.readFile(filePath, "utf-8");
+    const content = await import_promises8.default.readFile(filePath, "utf-8");
     return content.split("\n").length;
   } catch (e) {
     return 0;
   }
 }
 async function getFiles(dir, extension) {
-  const entries = await import_promises9.default.readdir(dir, { withFileTypes: true });
+  const entries = await import_promises8.default.readdir(dir, { withFileTypes: true });
   const files = await Promise.all(entries.map(async (entry) => {
-    const res = import_path9.default.resolve(dir, entry.name);
+    const res = import_path8.default.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);
@@ -761,8 +631,8 @@ async function fetchRulesFromApi(projectId) {
     }
   } catch (error) {
     try {
-      const cachePath = import_path9.default.join(process.cwd(), CACHE_FILE);
-      const content = await import_promises9.default.readFile(cachePath, "utf-8");
+      const cachePath = import_path8.default.join(process.cwd(), CACHE_FILE);
+      const content = await import_promises8.default.readFile(cachePath, "utf-8");
       const cached = JSON.parse(content);
       if (cached.settings) {
         return {
@@ -781,7 +651,7 @@ async function fetchRulesFromApi(projectId) {
   };
 }
 async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
-  console.log(import_chalk11.default.bold("\n\u{1F6E1}\uFE0F  Active Guardian Watchdog Initiated..."));
+  console.log(import_chalk10.default.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";
@@ -791,47 +661,47 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
     lmaxWarning = apiRules.lmaxWarning;
     ruleSource = apiRules.source;
   }
-  console.log(import_chalk11.default.dim(`Governance Rules: L_max=${lmax}, L_max_warning=${lmaxWarning}, Source: ${ruleSource}`));
+  console.log(import_chalk10.default.dim(`Governance Rules: L_max=${lmax}, L_max_warning=${lmaxWarning}, Source: ${ruleSource}`));
   const targetExtensions = [".ts", ".tsx"];
   let scanTarget = rootPath;
-  const webSrc = import_path9.default.join(rootPath, "apps", "web", "src");
+  const webSrc = import_path8.default.join(rootPath, "apps", "web", "src");
   try {
-    await import_promises9.default.access(webSrc);
+    await import_promises8.default.access(webSrc);
     scanTarget = webSrc;
   } catch {
   }
-  console.log(import_chalk11.default.dim(`Scanning target: ${import_path9.default.relative(process.cwd(), scanTarget)}`));
+  console.log(import_chalk10.default.dim(`Scanning target: ${import_path8.default.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 = import_path9.default.relative(rootPath, file);
+    const relPath = import_path8.default.relative(rootPath, file);
     if (lines > lmax) {
       results.push({ file: relPath, lines, status: "VIOLATION" });
       violations++;
-      console.log(import_chalk11.default.red(`[VIOLATION] ${relPath}: ${lines} lines (Limit: ${lmax})`));
+      console.log(import_chalk10.default.red(`[VIOLATION] ${relPath}: ${lines} lines (Limit: ${lmax})`));
     } else if (lines > lmaxWarning) {
       results.push({ file: relPath, lines, status: "WARNING" });
       warnings++;
-      console.log(import_chalk11.default.yellow(`[WARNING]   ${relPath}: ${lines} lines (Threshold: ${lmaxWarning})`));
+      console.log(import_chalk10.default.yellow(`[WARNING]   ${relPath}: ${lines} lines (Threshold: ${lmaxWarning})`));
     }
   }
   if (violations === 0 && warnings === 0) {
-    console.log(import_chalk11.default.green(`\u2714 All ${files.length} files are within governance limits.`));
+    console.log(import_chalk10.default.green(`\u2714 All ${files.length} files are within governance limits.`));
   } else {
-    console.log("\n" + import_chalk11.default.bold("Summary:"));
-    console.log(import_chalk11.default.red(`Violations: ${violations}`));
-    console.log(import_chalk11.default.yellow(`Warnings:   ${warnings}`));
+    console.log("\n" + import_chalk10.default.bold("Summary:"));
+    console.log(import_chalk10.default.red(`Violations: ${violations}`));
+    console.log(import_chalk10.default.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(import_chalk11.default.dim(`Intervention Level: ${InterventionLevel2[governance.intervention_level] || "UNKNOWN"} (${governance.intervention_level})`));
+    console.log(import_chalk10.default.dim(`Intervention Level: ${InterventionLevel2[governance.intervention_level] || "UNKNOWN"} (${governance.intervention_level})`));
     if (violations > 0) {
-      console.log(import_chalk11.default.red.bold("\nCRITICAL: Governance violations detected. Immediate refactoring required."));
+      console.log(import_chalk10.default.red.bold("\nCRITICAL: Governance violations detected. Immediate refactoring required."));
       if (governance.intervention_level >= InterventionLevel2.SENTINEL) {
-        console.log(import_chalk11.default.red.bold("\u{1F6D1} SENTINEL MODE: Session SOFT_LOCKED until resolved."));
-        console.log(import_chalk11.default.red('   Run "rigstate override <id> --reason \\"...\\"" if this is an emergency.'));
+        console.log(import_chalk10.default.red.bold("\u{1F6D1} SENTINEL MODE: Session SOFT_LOCKED until resolved."));
+        console.log(import_chalk10.default.red('   Run "rigstate override <id> --reason \\"...\\"" if this is an emergency.'));
         await setSoftLock2("Sentinel Mode: Governance Violations Detected", "ARC-VIOLATION", rootPath);
       }
     }
@@ -854,20 +724,20 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
       }, {
         headers: { Authorization: `Bearer ${apiKey}` }
       });
-      console.log(import_chalk11.default.dim("\u2714 Violations synced to Rigstate Cloud."));
+      console.log(import_chalk10.default.dim("\u2714 Violations synced to Rigstate Cloud."));
     } catch (e) {
-      console.log(import_chalk11.default.dim("\u26A0 Cloud sync skipped: " + (e.message || "Unknown")));
+      console.log(import_chalk10.default.dim("\u26A0 Cloud sync skipped: " + (e.message || "Unknown")));
     }
   }
 }
-var import_promises9, import_path9, import_chalk11, import_axios7, DEFAULT_LMAX, DEFAULT_LMAX_WARNING, CACHE_FILE;
+var import_promises8, import_path8, import_chalk10, import_axios7, DEFAULT_LMAX, DEFAULT_LMAX_WARNING, CACHE_FILE;
 var init_watchdog = __esm({
   "src/utils/watchdog.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises9 = __toESM(require("fs/promises"), 1);
-    import_path9 = __toESM(require("path"), 1);
-    import_chalk11 = __toESM(require("chalk"), 1);
+    import_promises8 = __toESM(require("fs/promises"), 1);
+    import_path8 = __toESM(require("path"), 1);
+    import_chalk10 = __toESM(require("chalk"), 1);
     import_axios7 = __toESM(require("axios"), 1);
     init_config();
     DEFAULT_LMAX = 400;
@@ -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(path24, isFile, isDirectory) {
-      log(`checking %s`, path24);
+    function check(path25, isFile, isDirectory) {
+      log(`checking %s`, path25);
       try {
-        const stat = fs_1.statSync(path24);
+        const stat = fs_1.statSync(path25);
         if (stat.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -1686,8 +1556,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path24, type = exports2.READABLE) {
-      return check(path24, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
+    function exists2(path25, type = exports2.READABLE) {
+      return check(path25, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
     }
     exports2.exists = exists2;
     exports2.FILE = 1;
@@ -1757,7 +1627,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@rigstate/cli",
-      version: "0.7.22",
+      version: "0.7.24",
       description: "Rigstate CLI - Code audit, sync and supervision tool",
       type: "module",
       main: "./dist/index.js",
@@ -1866,90 +1736,92 @@ Your API key has been securely stored. You can now use "rigstate scan" to audit
 
 // src/commands/link.ts
 init_cjs_shims();
-var import_commander5 = require("commander");
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_path3 = __toESM(require("path"), 1);
-var import_chalk6 = __toESM(require("chalk"), 1);
+var import_commander4 = require("commander");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_chalk5 = __toESM(require("chalk"), 1);
 var import_os = __toESM(require("os"), 1);
 init_config();
 function createLinkCommand() {
-  return new import_commander5.Command("link").description("Link current directory to a Rigstate project").argument("<projectId>", "Project ID to link").action(async (projectId) => {
+  return new import_commander4.Command("link").description("Link current directory to a Rigstate project").argument("<projectId>", "Project ID to link").action(async (projectId) => {
     try {
-      const globalPath = import_path3.default.join(import_os.default.homedir(), ".rigstate", "config.json");
-      const globalData = await import_promises3.default.readFile(globalPath, "utf-8").catch(() => null);
+      const globalPath = import_path2.default.join(import_os.default.homedir(), ".rigstate", "config.json");
+      const globalData = await import_promises2.default.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(import_chalk6.default.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
+            console.warn(import_chalk5.default.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
             projectId = overrideId;
           }
         }
       }
     } catch (e) {
     }
-    const manifestPath = import_path3.default.join(process.cwd(), ".rigstate");
+    const manifestPath = import_path2.default.join(process.cwd(), ".rigstate");
     const content = {
       project_id: projectId,
-      api_url: getApiUrl(),
       linked_at: (/* @__PURE__ */ new Date()).toISOString()
     };
+    const currentUrl = getApiUrl();
+    if (currentUrl !== "https://app.rigstate.com") {
+      content.api_url = currentUrl;
+    }
     try {
-      await import_promises3.default.writeFile(manifestPath, JSON.stringify(content, null, 2), "utf-8");
-      console.log(import_chalk6.default.green(`\u2714 Linked to project ID: ${projectId}`));
-      console.log(import_chalk6.default.dim(`Created local context manifest at .rigstate`));
+      await import_promises2.default.writeFile(manifestPath, JSON.stringify(content, null, 2), "utf-8");
+      console.log(import_chalk5.default.green(`\u2714 Linked to project ID: ${projectId}`));
+      console.log(import_chalk5.default.dim(`Created local context manifest at .rigstate`));
       console.log("");
-      console.log(import_chalk6.default.bold("\u{1F916} Rigstate Automation Detected"));
+      console.log(import_chalk5.default.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(import_chalk6.default.blue("\u{1F510} Checking Vault for secrets..."));
+        console.log(import_chalk5.default.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(import_chalk6.default.blue("\u{1F9E0} Syncing neural instructions..."));
+        console.log(import_chalk5.default.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(import_chalk6.default.blue("\u{1F6E1}\uFE0F  Checking immunity system..."));
+        console.log(import_chalk5.default.blue("\u{1F6E1}\uFE0F  Checking immunity system..."));
         await installHooks(process.cwd());
         console.log("");
-        console.log(import_chalk6.default.bold.green("\u{1F680} Link Complete! Your environment is ready."));
+        console.log(import_chalk5.default.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(import_chalk6.default.bold.green("\u{1F680} Link Complete!"));
+        console.log(import_chalk5.default.bold.green("\u{1F680} Link Complete!"));
       }
     } catch (error) {
       if (error.message.includes("Not authenticated")) {
-        console.warn(import_chalk6.default.yellow('\u26A0\uFE0F  Not authenticated. Run "rigstate login" to enable automation features.'));
+        console.warn(import_chalk5.default.yellow('\u26A0\uFE0F  Not authenticated. Run "rigstate login" to enable automation features.'));
       } else {
-        console.error(import_chalk6.default.red(`Failed to link project: ${error.message}`));
+        console.error(import_chalk5.default.red(`Failed to link project: ${error.message}`));
       }
     }
   });
 }
 async function installHooks(cwd) {
   const fs23 = await import("fs/promises");
-  const path24 = await import("path");
+  const path25 = await import("path");
   try {
-    await fs23.access(path24.join(cwd, ".git"));
+    await fs23.access(path25.join(cwd, ".git"));
   } catch {
-    console.log(import_chalk6.default.dim("   (Not a git repository, skipping hooks)"));
+    console.log(import_chalk5.default.dim("   (Not a git repository, skipping hooks)"));
     return;
   }
-  const hooksDir = path24.join(cwd, ".husky");
+  const hooksDir = path25.join(cwd, ".husky");
   try {
-    const { installHooks: runInstall } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
-    const preCommitPath = path24.join(cwd, ".git/hooks/pre-commit");
+    const preCommitPath = path25.join(cwd, ".git/hooks/pre-commit");
     try {
       await fs23.access(preCommitPath);
-      console.log(import_chalk6.default.green("   \u2714 Git hooks already active"));
+      console.log(import_chalk5.default.green("   \u2714 Git hooks already active"));
     } catch {
-      console.log(import_chalk6.default.yellow('   \u26A0\uFE0F  Git hooks missing. Run "rigstate hooks install" to secure repo.'));
+      console.log(import_chalk5.default.yellow('   \u26A0\uFE0F  Git hooks missing. Run "rigstate hooks install" to secure repo.'));
     }
   } catch (e) {
   }
@@ -1957,23 +1829,23 @@ async function installHooks(cwd) {
 
 // src/commands/scan.ts
 init_cjs_shims();
-var import_commander6 = require("commander");
-var import_chalk7 = __toESM(require("chalk"), 1);
+var import_commander5 = require("commander");
+var import_chalk6 = __toESM(require("chalk"), 1);
 var import_ora3 = __toESM(require("ora"), 1);
 var import_axios4 = __toESM(require("axios"), 1);
 var import_glob = require("glob");
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_path5 = __toESM(require("path"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_path4 = __toESM(require("path"), 1);
 init_config();
 
 // src/utils/files.ts
 init_cjs_shims();
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_path4 = __toESM(require("path"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_path3 = __toESM(require("path"), 1);
 async function readGitignore(dir) {
-  const gitignorePath = import_path4.default.join(dir, ".gitignore");
+  const gitignorePath = import_path3.default.join(dir, ".gitignore");
   try {
-    const content = await import_promises4.default.readFile(gitignorePath, "utf-8");
+    const content = await import_promises3.default.readFile(gitignorePath, "utf-8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error) {
     return [];
@@ -2035,13 +1907,13 @@ function isCodeFile(filePath) {
     ".vue",
     ".svelte"
   ];
-  const ext = import_path4.default.extname(filePath).toLowerCase();
+  const ext = import_path3.default.extname(filePath).toLowerCase();
   return codeExtensions.includes(ext);
 }
 
 // src/commands/scan.ts
 function createScanCommand() {
-  return new import_commander6.Command("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 import_commander5.Command("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 = (0, import_ora3.default)();
     try {
       const apiKey = getApiKey();
@@ -2049,26 +1921,26 @@ function createScanCommand() {
       const projectId = options.project || getProjectId();
       if (!projectId) {
         console.warn(
-          import_chalk7.default.yellow(
+          import_chalk6.default.yellow(
             "\u26A0\uFE0F  No project ID specified. Use --project <id> or set a default."
           )
         );
       }
-      const scanPath = import_path5.default.resolve(process.cwd(), targetPath);
-      spinner.start(`Scanning ${import_chalk7.default.cyan(scanPath)}...`);
+      const scanPath = import_path4.default.resolve(process.cwd(), targetPath);
+      spinner.start(`Scanning ${import_chalk6.default.cyan(scanPath)}...`);
       const gitignorePatterns = await readGitignore(scanPath);
-      const pattern = import_path5.default.join(scanPath, "**/*");
+      const pattern = import_path4.default.join(scanPath, "**/*");
       const allFiles = await (0, import_glob.glob)(pattern, {
         nodir: true,
         dot: false,
         ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"]
       });
       const codeFiles = allFiles.filter((file) => {
-        const relativePath = import_path5.default.relative(scanPath, file);
+        const relativePath = import_path4.default.relative(scanPath, file);
         return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
       });
       if (codeFiles.length === 0) {
-        spinner.warn(import_chalk7.default.yellow("No code files found to scan."));
+        spinner.warn(import_chalk6.default.yellow("No code files found to scan."));
         return;
       }
       spinner.text = `Found ${codeFiles.length} files. Scanning...`;
@@ -2077,10 +1949,10 @@ function createScanCommand() {
       const severityCounts = {};
       for (let i = 0; i < codeFiles.length; i++) {
         const filePath = codeFiles[i];
-        const relativePath = import_path5.default.relative(scanPath, filePath);
+        const relativePath = import_path4.default.relative(scanPath, filePath);
         spinner.text = `Scanning ${i + 1}/${codeFiles.length}: ${relativePath}`;
         try {
-          const content = await import_promises5.default.readFile(filePath, "utf-8");
+          const content = await import_promises4.default.readFile(filePath, "utf-8");
           const response = await import_axios4.default.post(
             `${apiUrl}/api/v1/audit`,
             {
@@ -2116,15 +1988,15 @@ function createScanCommand() {
           }
         } catch (fileError) {
           if (import_axios4.default.isAxiosError(fileError)) {
-            console.warn(import_chalk7.default.yellow(`
+            console.warn(import_chalk6.default.yellow(`
 \u26A0\uFE0F  Skipping ${relativePath}: ${fileError.message}`));
           } else {
-            console.warn(import_chalk7.default.yellow(`
+            console.warn(import_chalk6.default.yellow(`
 \u26A0\uFE0F  Error reading ${relativePath}`));
           }
         }
       }
-      spinner.succeed(import_chalk7.default.green("\u2705 Scan completed!"));
+      spinner.succeed(import_chalk6.default.green("\u2705 Scan completed!"));
       const aggregatedResponse = {
         results,
         summary: {
@@ -2139,21 +2011,21 @@ function createScanCommand() {
         printPrettyResults(aggregatedResponse);
       }
     } catch (error) {
-      spinner.fail(import_chalk7.default.red("\u274C Scan failed"));
+      spinner.fail(import_chalk6.default.red("\u274C Scan failed"));
       if (import_axios4.default.isAxiosError(error)) {
         if (error.response) {
-          console.error(import_chalk7.default.red("API Error:"), error.response.data);
+          console.error(import_chalk6.default.red("API Error:"), error.response.data);
         } else if (error.request) {
           console.error(
-            import_chalk7.default.red("Network Error:"),
+            import_chalk6.default.red("Network Error:"),
             "Could not reach the API. Is the server running?"
           );
         } else {
-          console.error(import_chalk7.default.red("Error:"), error.message);
+          console.error(import_chalk6.default.red("Error:"), error.message);
         }
       } else {
         console.error(
-          import_chalk7.default.red("Error:"),
+          import_chalk6.default.red("Error:"),
           error instanceof Error ? error.message : "Unknown error"
         );
       }
@@ -2163,10 +2035,10 @@ function createScanCommand() {
 }
 function printPrettyResults(data) {
   const { results, summary } = data;
-  console.log("\n" + import_chalk7.default.bold("\u{1F4CA} Scan Summary"));
-  console.log(import_chalk7.default.dim("\u2500".repeat(60)));
-  console.log(`Total Files Scanned: ${import_chalk7.default.cyan(summary.total_files)}`);
-  console.log(`Total Issues Found: ${import_chalk7.default.yellow(summary.total_issues)}`);
+  console.log("\n" + import_chalk6.default.bold("\u{1F4CA} Scan Summary"));
+  console.log(import_chalk6.default.dim("\u2500".repeat(60)));
+  console.log(`Total Files Scanned: ${import_chalk6.default.cyan(summary.total_files)}`);
+  console.log(`Total Issues Found: ${import_chalk6.default.yellow(summary.total_issues)}`);
   if (summary.by_severity) {
     console.log("\nIssues by Severity:");
     Object.entries(summary.by_severity).forEach(([severity, count]) => {
@@ -2175,87 +2047,87 @@ function printPrettyResults(data) {
     });
   }
   if (results && results.length > 0) {
-    console.log("\n" + import_chalk7.default.bold("\u{1F50D} Detailed Results"));
-    console.log(import_chalk7.default.dim("\u2500".repeat(60)));
+    console.log("\n" + import_chalk6.default.bold("\u{1F50D} Detailed Results"));
+    console.log(import_chalk6.default.dim("\u2500".repeat(60)));
     results.forEach((result) => {
       if (result.issues && result.issues.length > 0) {
         console.log(`
-${import_chalk7.default.bold(result.file_path)}`);
+${import_chalk6.default.bold(result.file_path)}`);
         result.issues.forEach((issue) => {
           const severityColor = getSeverityColor(issue.severity);
-          const lineInfo = issue.line ? import_chalk7.default.dim(`:${issue.line}`) : "";
+          const lineInfo = issue.line ? import_chalk6.default.dim(`:${issue.line}`) : "";
           console.log(
             `  ${severityColor(`[${issue.severity.toUpperCase()}]`)} ${issue.type}${lineInfo}`
           );
-          console.log(`  ${import_chalk7.default.dim(issue.message)}`);
+          console.log(`  ${import_chalk6.default.dim(issue.message)}`);
         });
       }
     });
   }
-  console.log("\n" + import_chalk7.default.dim("\u2500".repeat(60)));
+  console.log("\n" + import_chalk6.default.dim("\u2500".repeat(60)));
 }
 function getSeverityColor(severity) {
   switch (severity.toLowerCase()) {
     case "critical":
-      return import_chalk7.default.red.bold;
+      return import_chalk6.default.red.bold;
     case "high":
-      return import_chalk7.default.red;
+      return import_chalk6.default.red;
     case "medium":
-      return import_chalk7.default.yellow;
+      return import_chalk6.default.yellow;
     case "low":
-      return import_chalk7.default.blue;
+      return import_chalk6.default.blue;
     case "info":
-      return import_chalk7.default.gray;
+      return import_chalk6.default.gray;
     default:
-      return import_chalk7.default.white;
+      return import_chalk6.default.white;
   }
 }
 
 // src/commands/fix.ts
 init_cjs_shims();
-var import_commander7 = require("commander");
-var import_chalk8 = __toESM(require("chalk"), 1);
+var import_commander6 = require("commander");
+var import_chalk7 = __toESM(require("chalk"), 1);
 var import_ora4 = __toESM(require("ora"), 1);
 var import_axios5 = __toESM(require("axios"), 1);
 var import_glob2 = require("glob");
-var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_path6 = __toESM(require("path"), 1);
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_path5 = __toESM(require("path"), 1);
 var import_inquirer = __toESM(require("inquirer"), 1);
 var Diff = __toESM(require("diff"), 1);
 init_config();
 function createFixCommand() {
-  return new import_commander7.Command("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 import_commander6.Command("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 = (0, import_ora4.default)();
     try {
       const apiKey = getApiKey();
       const apiUrl = getApiUrl();
       const projectId = options.project || getProjectId();
       if (!projectId) {
-        console.log(import_chalk8.default.yellow("\u26A0\uFE0F  Project ID is required for fixing. Using default or pass --project <id>"));
+        console.log(import_chalk7.default.yellow("\u26A0\uFE0F  Project ID is required for fixing. Using default or pass --project <id>"));
       }
-      const scanPath = import_path6.default.resolve(process.cwd(), targetPath);
+      const scanPath = import_path5.default.resolve(process.cwd(), targetPath);
       const gitignorePatterns = await readGitignore(scanPath);
-      const pattern = import_path6.default.join(scanPath, "**/*");
+      const pattern = import_path5.default.join(scanPath, "**/*");
       const allFiles = await (0, import_glob2.glob)(pattern, { nodir: true, dot: false, ignore: ["**/node_modules/**", "**/.git/**"] });
       const codeFiles = allFiles.filter((file) => {
-        const relativePath = import_path6.default.relative(scanPath, file);
+        const relativePath = import_path5.default.relative(scanPath, file);
         return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
       });
       if (codeFiles.length === 0) {
-        console.log(import_chalk8.default.yellow("No code files found."));
+        console.log(import_chalk7.default.yellow("No code files found."));
         return;
       }
-      console.log(import_chalk8.default.bold(`
+      console.log(import_chalk7.default.bold(`
 \u{1F9E0} Rigstate Fix Mode`));
-      console.log(import_chalk8.default.dim(`Scanning ${codeFiles.length} files with Project Context...
+      console.log(import_chalk7.default.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 = import_path6.default.relative(scanPath, filePath);
+        const relativePath = import_path5.default.relative(scanPath, filePath);
         spinner.start(`Analyzing ${relativePath}...`);
         try {
-          const content = await import_promises6.default.readFile(filePath, "utf-8");
+          const content = await import_promises5.default.readFile(filePath, "utf-8");
           const response = await import_axios5.default.post(
             `${apiUrl}/api/v1/audit`,
             { content, file_path: relativePath, project_id: projectId },
@@ -2266,22 +2138,22 @@ function createFixCommand() {
           if (fixableIssues.length > 0) {
             spinner.stop();
             console.log(`
-${import_chalk8.default.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
+${import_chalk7.default.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
             for (const issue of fixableIssues) {
-              console.log(import_chalk8.default.red(`
+              console.log(import_chalk7.default.red(`
 [${issue.type}] ${issue.title}`));
-              console.log(import_chalk8.default.dim(issue.suggestion || issue.message));
+              console.log(import_chalk7.default.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 import_inquirer.default.prompt([{
                 type: "confirm",
                 name: "apply",
-                message: `Apply this fix to ${import_chalk8.default.cyan(relativePath)}?`,
+                message: `Apply this fix to ${import_chalk7.default.cyan(relativePath)}?`,
                 default: true
               }]);
               if (apply) {
-                await import_promises6.default.writeFile(filePath, issue.fixed_content);
-                console.log(import_chalk8.default.green(`\u2705 Fixed applied!`));
+                await import_promises5.default.writeFile(filePath, issue.fixed_content);
+                console.log(import_chalk7.default.green(`\u2705 Fixed applied!`));
                 fixedCount++;
                 if (issue.related_step_id) {
                   const { completeStep } = await import_inquirer.default.prompt([{
@@ -2297,15 +2169,15 @@ ${import_chalk8.default.bold(relativePath)}: Found ${fixableIssues.length} fixab
                         { step_id: issue.related_step_id, status: "COMPLETED", project_id: projectId },
                         { headers: { "Authorization": `Bearer ${apiKey}` } }
                       );
-                      console.log(import_chalk8.default.green(`\u{1F680} Roadmap updated! Mission Control is in sync.`));
+                      console.log(import_chalk7.default.green(`\u{1F680} Roadmap updated! Mission Control is in sync.`));
                     } catch (err) {
-                      console.error(import_chalk8.default.yellow(`Failed to update roadmap: ${err.message}`));
+                      console.error(import_chalk7.default.yellow(`Failed to update roadmap: ${err.message}`));
                     }
                   }
                 }
                 break;
               } else {
-                console.log(import_chalk8.default.dim("Skipped."));
+                console.log(import_chalk7.default.dim("Skipped."));
               }
             }
           } else {
@@ -2315,11 +2187,11 @@ ${import_chalk8.default.bold(relativePath)}: Found ${fixableIssues.length} fixab
         }
       }
       spinner.stop();
-      console.log(import_chalk8.default.bold.green(`
+      console.log(import_chalk7.default.bold.green(`
 
 \u{1F680} Fix session complete!`));
       console.log(`Frank fixed ${fixedCount} detected issues.`);
-      console.log(import_chalk8.default.dim(`Run 'rigstate scan' to verify remaining issues.`));
+      console.log(import_chalk7.default.dim(`Run 'rigstate scan' to verify remaining issues.`));
     } catch (error) {
       spinner.fail("Fix session failed");
       console.error(error.message);
@@ -2329,15 +2201,15 @@ ${import_chalk8.default.bold(relativePath)}: Found ${fixableIssues.length} fixab
 
 // src/commands/sync.ts
 init_cjs_shims();
-var import_commander8 = require("commander");
-var import_chalk12 = __toESM(require("chalk"), 1);
+var import_commander7 = require("commander");
+var import_chalk11 = __toESM(require("chalk"), 1);
 var import_ora5 = __toESM(require("ora"), 1);
 init_config();
 var import_axios8 = __toESM(require("axios"), 1);
-var import_promises10 = __toESM(require("fs/promises"), 1);
-var import_path10 = __toESM(require("path"), 1);
+var import_promises9 = __toESM(require("fs/promises"), 1);
+var import_path9 = __toESM(require("path"), 1);
 function createSyncCommand() {
-  const sync = new import_commander8.Command("sync");
+  const sync = new import_commander7.Command("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 = (0, import_ora5.default)("Synchronizing project state...").start();
     try {
@@ -2351,8 +2223,8 @@ function createSyncCommand() {
       let projectId = options.project;
       if (!projectId) {
         try {
-          const manifestPath = import_path10.default.join(process.cwd(), ".rigstate");
-          const manifestContent = await import_promises10.default.readFile(manifestPath, "utf-8");
+          const manifestPath = import_path9.default.join(process.cwd(), ".rigstate");
+          const manifestContent = await import_promises9.default.readFile(manifestPath, "utf-8");
           const manifest = JSON.parse(manifestContent);
           if (manifest.project_id) projectId = manifest.project_id;
         } catch (e) {
@@ -2376,31 +2248,31 @@ function createSyncCommand() {
       }
       const { roadmap, project } = response.data.data;
       const timestamp = response.data.timestamp;
-      const targetPath = import_path10.default.join(process.cwd(), "roadmap.json");
+      const targetPath = import_path9.default.join(process.cwd(), "roadmap.json");
       const fileContent = JSON.stringify({
         project,
         last_synced: timestamp,
         roadmap
       }, null, 2);
-      await import_promises10.default.writeFile(targetPath, fileContent, "utf-8");
+      await import_promises9.default.writeFile(targetPath, fileContent, "utf-8");
       try {
-        const manifestPath = import_path10.default.join(process.cwd(), ".rigstate");
+        const manifestPath = import_path9.default.join(process.cwd(), ".rigstate");
         const manifestContent = {
           project_id: projectId,
           project_name: project,
           last_synced: timestamp,
           api_url: apiUrl
         };
-        await import_promises10.default.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
+        await import_promises9.default.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
       } catch (e) {
       }
-      console.log(import_chalk12.default.bold("\n\u{1F9E0} Agent Skills Provisioning..."));
+      console.log(import_chalk11.default.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 = import_path10.default.join(process.cwd(), ".cursorrules");
+        const cursorRulesPath = import_path9.default.join(process.cwd(), ".cursorrules");
         try {
-          let rulesContent = await import_promises10.default.readFile(cursorRulesPath, "utf-8");
+          let rulesContent = await import_promises9.default.readFile(cursorRulesPath, "utf-8");
           const skillsBlock = generateSkillsDiscoveryBlock2(skills);
           if (rulesContent.includes("<available_skills>")) {
             rulesContent = rulesContent.replace(
@@ -2413,17 +2285,17 @@ function createSyncCommand() {
               rulesContent = rulesContent.slice(0, insertPoint + 3) + "\n\n" + skillsBlock + "\n" + rulesContent.slice(insertPoint + 3);
             }
           }
-          await import_promises10.default.writeFile(cursorRulesPath, rulesContent, "utf-8");
-          console.log(import_chalk12.default.dim(`  Updated .cursorrules with skills discovery block`));
+          await import_promises9.default.writeFile(cursorRulesPath, rulesContent, "utf-8");
+          console.log(import_chalk11.default.dim(`  Updated .cursorrules with skills discovery block`));
         } catch (e) {
         }
       } catch (e) {
-        console.log(import_chalk12.default.yellow(`  \u26A0 Skills provisioning skipped: ${e.message}`));
+        console.log(import_chalk11.default.yellow(`  \u26A0 Skills provisioning skipped: ${e.message}`));
       }
       try {
-        const logPath = import_path10.default.join(process.cwd(), ".rigstate", "logs", "last_execution.json");
+        const logPath = import_path9.default.join(process.cwd(), ".rigstate", "logs", "last_execution.json");
         try {
-          const logContent = await import_promises10.default.readFile(logPath, "utf-8");
+          const logContent = await import_promises9.default.readFile(logPath, "utf-8");
           const logData = JSON.parse(logContent);
           if (logData.task_summary) {
             await import_axios8.default.post(`${apiUrl}/api/v1/execution-logs`, {
@@ -2433,8 +2305,8 @@ function createSyncCommand() {
             }, {
               headers: { Authorization: `Bearer ${apiKey}` }
             });
-            await import_promises10.default.unlink(logPath);
-            console.log(import_chalk12.default.dim(`\u2714 Mission Report uploaded.`));
+            await import_promises9.default.unlink(logPath);
+            console.log(import_chalk11.default.dim(`\u2714 Mission Report uploaded.`));
           }
         } catch (e) {
           if (e.code !== "ENOENT") {
@@ -2442,12 +2314,12 @@ function createSyncCommand() {
         }
       } catch (e) {
       }
-      spinner.succeed(import_chalk12.default.green(`Synced ${roadmap.length} roadmap steps for project "${project}"`));
-      console.log(import_chalk12.default.dim(`Local files updated: roadmap.json`));
+      spinner.succeed(import_chalk11.default.green(`Synced ${roadmap.length} roadmap steps for project "${project}"`));
+      console.log(import_chalk11.default.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(import_chalk12.default.bold("\n\u{1F4E1} Agent Bridge Heartbeat..."));
+      console.log(import_chalk11.default.bold("\n\u{1F4E1} Agent Bridge Heartbeat..."));
       try {
         const bridgeResponse = await import_axios8.default.get(`${apiUrl}/api/v1/agent/bridge`, {
           params: { project_id: projectId },
@@ -2458,10 +2330,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(import_chalk12.default.yellow(`\u26A0 Bridge Alert: ${pending.length} pending, ${approved.length} approved tasks found.`));
-            console.log(import_chalk12.default.dim('Run "rigstate fix" to process these tasks or ensure your IDE MCP server is active.'));
+            console.log(import_chalk11.default.yellow(`\u26A0 Bridge Alert: ${pending.length} pending, ${approved.length} approved tasks found.`));
+            console.log(import_chalk11.default.dim('Run "rigstate fix" to process these tasks or ensure your IDE MCP server is active.'));
           } else {
-            console.log(import_chalk12.default.green("\u2714 Heartbeat healthy. No pending bridge tasks."));
+            console.log(import_chalk11.default.green("\u2714 Heartbeat healthy. No pending bridge tasks."));
           }
           const pings = pending.filter((t) => t.proposal?.startsWith("ping"));
           for (const ping of pings) {
@@ -2472,25 +2344,25 @@ function createSyncCommand() {
             }, {
               headers: { Authorization: `Bearer ${apiKey}` }
             });
-            console.log(import_chalk12.default.cyan(`\u{1F3D3} Pong! Acknowledged heartbeat signal [${ping.id}]`));
+            console.log(import_chalk11.default.cyan(`\u{1F3D3} Pong! Acknowledged heartbeat signal [${ping.id}]`));
           }
         }
       } catch (e) {
-        console.log(import_chalk12.default.yellow(`\u26A0 Could not verify Bridge status: ${e.message}`));
+        console.log(import_chalk11.default.yellow(`\u26A0 Could not verify Bridge status: ${e.message}`));
       }
       if (options.project) {
-        console.log(import_chalk12.default.blue(`Project context saved. Future commands will use this project.`));
+        console.log(import_chalk11.default.blue(`Project context saved. Future commands will use this project.`));
       }
       try {
-        const migrationDir = import_path10.default.join(process.cwd(), "supabase", "migrations");
-        const files = await import_promises10.default.readdir(migrationDir);
+        const migrationDir = import_path9.default.join(process.cwd(), "supabase", "migrations");
+        const files = await import_promises9.default.readdir(migrationDir);
         const sqlFiles = files.filter((f) => f.endsWith(".sql")).sort();
         if (sqlFiles.length > 0) {
           const latestMigration = sqlFiles[sqlFiles.length - 1];
-          console.log(import_chalk12.default.dim(`
+          console.log(import_chalk11.default.dim(`
 \u{1F6E1}  Migration Guard:`));
-          console.log(import_chalk12.default.dim(`   Latest Local: ${latestMigration}`));
-          console.log(import_chalk12.default.yellow(`   \u26A0  Ensure DB schema matches this version. CLI cannot verify Remote RLS policies directly.`));
+          console.log(import_chalk11.default.dim(`   Latest Local: ${latestMigration}`));
+          console.log(import_chalk11.default.yellow(`   \u26A0  Ensure DB schema matches this version. CLI cannot verify Remote RLS policies directly.`));
         }
       } catch (e) {
       }
@@ -2502,15 +2374,15 @@ function createSyncCommand() {
         );
         if (vaultResponse.data.success) {
           const vaultContent = vaultResponse.data.data.content || "";
-          const localEnvPath = import_path10.default.join(process.cwd(), ".env.local");
+          const localEnvPath = import_path9.default.join(process.cwd(), ".env.local");
           let localContent = "";
           try {
-            localContent = await import_promises10.default.readFile(localEnvPath, "utf-8");
+            localContent = await import_promises9.default.readFile(localEnvPath, "utf-8");
           } catch (e) {
           }
           if (vaultContent.trim() !== localContent.trim()) {
-            console.log(import_chalk12.default.bold("\n\u{1F510} Sovereign Foundation (Vault):"));
-            console.log(import_chalk12.default.yellow("   Status: Drift Detected / Update Available"));
+            console.log(import_chalk11.default.bold("\n\u{1F510} Sovereign Foundation (Vault):"));
+            console.log(import_chalk11.default.yellow("   Status: Drift Detected / Update Available"));
             const { syncVault } = await import("inquirer").then((m) => m.default.prompt([{
               type: "confirm",
               name: "syncVault",
@@ -2518,25 +2390,25 @@ function createSyncCommand() {
               default: false
             }]));
             if (syncVault) {
-              await import_promises10.default.writeFile(localEnvPath, vaultContent, "utf-8");
-              console.log(import_chalk12.default.green("   \u2705 .env.local synchronized with Vault."));
+              await import_promises9.default.writeFile(localEnvPath, vaultContent, "utf-8");
+              console.log(import_chalk11.default.green("   \u2705 .env.local synchronized with Vault."));
             } else {
-              console.log(import_chalk12.default.dim("   Skipped vault sync."));
+              console.log(import_chalk11.default.dim("   Skipped vault sync."));
             }
           } else {
-            console.log(import_chalk12.default.dim("\n\u{1F510} Sovereign Foundation: Synced."));
+            console.log(import_chalk11.default.dim("\n\u{1F510} Sovereign Foundation: Synced."));
           }
         }
       } catch (e) {
       }
-      console.log(import_chalk12.default.dim("\n\u{1F6E1}\uFE0F System Integrity Check..."));
+      console.log(import_chalk11.default.dim("\n\u{1F6E1}\uFE0F System Integrity Check..."));
       await checkSystemIntegrity(apiUrl, apiKey, projectId);
     } catch (error) {
       if (import_axios8.default.isAxiosError(error)) {
         const message = error.response?.data?.error || error.message;
-        spinner.fail(import_chalk12.default.red(`Sync failed: ${message}`));
+        spinner.fail(import_chalk11.default.red(`Sync failed: ${message}`));
       } else {
-        spinner.fail(import_chalk12.default.red("Sync failed: " + (error.message || "Unknown error")));
+        spinner.fail(import_chalk11.default.red("Sync failed: " + (error.message || "Unknown error")));
       }
     }
   });
@@ -2552,57 +2424,57 @@ async function checkSystemIntegrity(apiUrl, apiKey, projectId) {
       const { migrations, rls, guardian_violations } = response.data.data;
       if (migrations) {
         if (migrations.in_sync) {
-          console.log(import_chalk12.default.green(`   \u2705 Migrations synced (${migrations.count} versions)`));
+          console.log(import_chalk11.default.green(`   \u2705 Migrations synced (${migrations.count} versions)`));
         } else {
-          console.log(import_chalk12.default.red(`   \u{1F6D1} CRITICAL: DB Schema out of sync! ${migrations.missing?.length || 0} migrations not applied.`));
+          console.log(import_chalk11.default.red(`   \u{1F6D1} CRITICAL: DB Schema out of sync! ${migrations.missing?.length || 0} migrations not applied.`));
           if (migrations.missing?.length > 0) {
-            console.log(import_chalk12.default.dim(`      Missing: ${migrations.missing.slice(0, 3).join(", ")}${migrations.missing.length > 3 ? "..." : ""}`));
+            console.log(import_chalk11.default.dim(`      Missing: ${migrations.missing.slice(0, 3).join(", ")}${migrations.missing.length > 3 ? "..." : ""}`));
           }
-          console.log(import_chalk12.default.yellow(`      Run 'supabase db push' or apply migrations immediately.`));
+          console.log(import_chalk11.default.yellow(`      Run 'supabase db push' or apply migrations immediately.`));
         }
       }
       if (rls) {
         if (rls.all_secured) {
-          console.log(import_chalk12.default.green(`   \u2705 RLS Audit Passed (${rls.table_count} tables secured)`));
+          console.log(import_chalk11.default.green(`   \u2705 RLS Audit Passed (${rls.table_count} tables secured)`));
         } else {
-          console.log(import_chalk12.default.red(`   \u{1F6D1} CRITICAL: Security Vulnerability! ${rls.unsecured?.length || 0} tables have RLS disabled.`));
+          console.log(import_chalk11.default.red(`   \u{1F6D1} CRITICAL: Security Vulnerability! ${rls.unsecured?.length || 0} tables have RLS disabled.`));
           rls.unsecured?.forEach((table) => {
-            console.log(import_chalk12.default.red(`      - ${table}`));
+            console.log(import_chalk11.default.red(`      - ${table}`));
           });
-          console.log(import_chalk12.default.yellow('      Enable RLS immediately: ALTER TABLE "table" ENABLE ROW LEVEL SECURITY;'));
+          console.log(import_chalk11.default.yellow('      Enable RLS immediately: ALTER TABLE "table" ENABLE ROW LEVEL SECURITY;'));
         }
       }
       if (guardian_violations) {
         if (guardian_violations.count === 0) {
-          console.log(import_chalk12.default.green("   \u2705 Guardian: No active violations"));
+          console.log(import_chalk11.default.green("   \u2705 Guardian: No active violations"));
         } else {
-          console.log(import_chalk12.default.yellow(`   \u26A0\uFE0F Guardian: ${guardian_violations.count} active violations`));
-          console.log(import_chalk12.default.dim('      Run "rigstate check" for details.'));
+          console.log(import_chalk11.default.yellow(`   \u26A0\uFE0F Guardian: ${guardian_violations.count} active violations`));
+          console.log(import_chalk11.default.dim('      Run "rigstate check" for details.'));
         }
       }
     }
   } catch (e) {
-    console.log(import_chalk12.default.dim("   (System integrity check skipped - API endpoint not available)"));
+    console.log(import_chalk11.default.dim("   (System integrity check skipped - API endpoint not available)"));
   }
 }
 
 // src/commands/init.ts
 init_cjs_shims();
-var import_commander9 = require("commander");
-var import_chalk13 = __toESM(require("chalk"), 1);
-var import_promises12 = __toESM(require("fs/promises"), 1);
-var import_path12 = __toESM(require("path"), 1);
+var import_commander8 = require("commander");
+var import_chalk12 = __toESM(require("chalk"), 1);
+var import_promises11 = __toESM(require("fs/promises"), 1);
+var import_path11 = __toESM(require("path"), 1);
 var import_ora6 = __toESM(require("ora"), 1);
 var import_child_process = require("child_process");
 
 // src/utils/manifest.ts
 init_cjs_shims();
-var import_promises11 = __toESM(require("fs/promises"), 1);
-var import_path11 = __toESM(require("path"), 1);
+var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_path10 = __toESM(require("path"), 1);
 async function loadManifest() {
   try {
-    const manifestPath = import_path11.default.join(process.cwd(), ".rigstate");
-    const content = await import_promises11.default.readFile(manifestPath, "utf-8");
+    const manifestPath = import_path10.default.join(process.cwd(), ".rigstate");
+    const content = await import_promises10.default.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -2613,13 +2485,13 @@ async function loadManifest() {
 init_config();
 var import_axios9 = __toESM(require("axios"), 1);
 function createInitCommand() {
-  return new import_commander9.Command("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 import_commander8.Command("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 = (0, import_ora6.default)("Initializing Rigstate project...").start();
     let apiKey;
     try {
       apiKey = getApiKey();
     } catch (e) {
-      spinner.fail(import_chalk13.default.red('Not authenticated. Run "rigstate login" first.'));
+      spinner.fail(import_chalk12.default.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -2716,7 +2588,7 @@ function createInitCommand() {
               selectedOrgId = orgId;
             }
             if (!selectedOrgId) {
-              console.log(import_chalk13.default.yellow("No organization available. Please create the project via the Rigstate dashboard."));
+              console.log(import_chalk12.default.yellow("No organization available. Please create the project via the Rigstate dashboard."));
               return;
             }
             spinner.start("Creating new project...");
@@ -2728,13 +2600,13 @@ function createInitCommand() {
                 headers: { Authorization: `Bearer ${apiKey}` }
               });
               if (!createResponse.data.success) {
-                spinner.fail(import_chalk13.default.red("Failed to create project: " + createResponse.data.error));
+                spinner.fail(import_chalk12.default.red("Failed to create project: " + createResponse.data.error));
                 return;
               }
               projectId = createResponse.data.data.project.id;
-              spinner.succeed(import_chalk13.default.green(`Created new project: ${newName}`));
+              spinner.succeed(import_chalk12.default.green(`Created new project: ${newName}`));
             } catch (e) {
-              spinner.fail(import_chalk13.default.red("Project creation API not available. Please create via dashboard."));
+              spinner.fail(import_chalk12.default.red("Project creation API not available. Please create via dashboard."));
               return;
             }
           } else {
@@ -2744,28 +2616,28 @@ function createInitCommand() {
         spinner.start(`Linking to project ID: ${projectId}...`);
       }
       setProjectId(projectId);
-      const manifestPath = import_path12.default.join(process.cwd(), ".rigstate");
+      const manifestPath = import_path11.default.join(process.cwd(), ".rigstate");
       const manifestContent = {
         project_id: projectId,
         last_linked: (/* @__PURE__ */ new Date()).toISOString(),
         api_url: apiUrl
       };
-      await import_promises12.default.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
+      await import_promises11.default.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
       try {
-        await import_promises12.default.access(".git");
+        await import_promises11.default.access(".git");
       } catch {
         spinner.text = "Initializing git repository...";
         (0, import_child_process.execSync)("git init", { stdio: "ignore" });
       }
-      spinner.succeed(import_chalk13.default.green(`\u2705 Linked to project: ${projectId}`));
+      spinner.succeed(import_chalk12.default.green(`\u2705 Linked to project: ${projectId}`));
       await generateRules(apiUrl, apiKey, projectId, options.force, spinner);
       console.log("");
-      console.log(import_chalk13.default.blue("Next steps:"));
-      console.log(import_chalk13.default.dim("  rigstate sync     - Sync roadmap and context"));
-      console.log(import_chalk13.default.dim("  rigstate watch    - Start development loop"));
-      console.log(import_chalk13.default.dim("  rigstate focus    - Get current task"));
+      console.log(import_chalk12.default.blue("Next steps:"));
+      console.log(import_chalk12.default.dim("  rigstate sync     - Sync roadmap and context"));
+      console.log(import_chalk12.default.dim("  rigstate watch    - Start development loop"));
+      console.log(import_chalk12.default.dim("  rigstate focus    - Get current task"));
     } catch (e) {
-      spinner.fail(import_chalk13.default.red("Initialization failed: " + e.message));
+      spinner.fail(import_chalk12.default.red("Initialization failed: " + e.message));
     }
   });
 }
@@ -2780,67 +2652,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 = import_path12.default.join(process.cwd(), ".cursorrules");
-        await import_promises12.default.writeFile(rulesPath, response.data.rules, "utf-8");
-        spinner.succeed(import_chalk13.default.green("\u2714 Generated .cursorrules (legacy mode)"));
+        const rulesPath = import_path11.default.join(process.cwd(), ".cursorrules");
+        await import_promises11.default.writeFile(rulesPath, response.data.rules, "utf-8");
+        spinner.succeed(import_chalk12.default.green("\u2714 Generated .cursorrules (legacy mode)"));
         return;
       }
       for (const file of files) {
-        const targetPath = import_path12.default.join(process.cwd(), file.path);
-        const targetDir = import_path12.default.dirname(targetPath);
-        await import_promises12.default.mkdir(targetDir, { recursive: true });
+        const targetPath = import_path11.default.join(process.cwd(), file.path);
+        const targetDir = import_path11.default.dirname(targetPath);
+        await import_promises11.default.mkdir(targetDir, { recursive: true });
         try {
-          await import_promises12.default.access(targetPath);
+          await import_promises11.default.access(targetPath);
           if (!force && !file.path.startsWith(".cursor/rules/")) {
-            console.log(import_chalk13.default.dim(`  ${file.path} already exists. Skipping.`));
+            console.log(import_chalk12.default.dim(`  ${file.path} already exists. Skipping.`));
             continue;
           }
         } catch {
         }
-        await import_promises12.default.writeFile(targetPath, file.content, "utf-8");
+        await import_promises11.default.writeFile(targetPath, file.content, "utf-8");
       }
       if (files.length > 0) {
-        const legacyPath = import_path12.default.join(process.cwd(), ".cursorrules");
+        const legacyPath = import_path11.default.join(process.cwd(), ".cursorrules");
         try {
-          const stats = await import_promises12.default.stat(legacyPath);
+          const stats = await import_promises11.default.stat(legacyPath);
           if (stats.isFile()) {
-            await import_promises12.default.rename(legacyPath, `${legacyPath}.bak`);
-            console.log(import_chalk13.default.dim("  Moved legacy .cursorrules to .cursorrules.bak"));
+            await import_promises11.default.rename(legacyPath, `${legacyPath}.bak`);
+            console.log(import_chalk12.default.dim("  Moved legacy .cursorrules to .cursorrules.bak"));
           }
         } catch (e) {
         }
       }
-      spinner.succeed(import_chalk13.default.green(`\u2714 Generated ${files.length} rule files (v${response.data.version || "3.0"})`));
+      spinner.succeed(import_chalk12.default.green(`\u2714 Generated ${files.length} rule files (v${response.data.version || "3.0"})`));
     } else {
-      spinner.info(import_chalk13.default.dim("  Rules generation skipped (API response invalid)"));
+      spinner.info(import_chalk12.default.dim("  Rules generation skipped (API response invalid)"));
     }
   } catch (e) {
-    spinner.info(import_chalk13.default.dim(`  Rules generation failed: ${e.message}`));
+    spinner.info(import_chalk12.default.dim(`  Rules generation failed: ${e.message}`));
   }
 }
 
 // src/commands/check.ts
 init_cjs_shims();
-var import_commander10 = require("commander");
-var import_chalk15 = __toESM(require("chalk"), 1);
+var import_commander9 = require("commander");
+var import_chalk14 = __toESM(require("chalk"), 1);
 var import_ora7 = __toESM(require("ora"), 1);
 var import_axios10 = __toESM(require("axios"), 1);
 var import_glob3 = require("glob");
-var import_promises14 = __toESM(require("fs/promises"), 1);
-var import_path14 = __toESM(require("path"), 1);
+var import_promises13 = __toESM(require("fs/promises"), 1);
+var import_path13 = __toESM(require("path"), 1);
 var import_child_process2 = require("child_process");
 init_config();
 
 // src/utils/rule-engine.ts
 init_cjs_shims();
-var import_promises13 = __toESM(require("fs/promises"), 1);
-var import_path13 = __toESM(require("path"), 1);
-var import_chalk14 = __toESM(require("chalk"), 1);
+var import_promises12 = __toESM(require("fs/promises"), 1);
+var import_path12 = __toESM(require("path"), 1);
+var import_chalk13 = __toESM(require("chalk"), 1);
 async function checkFile(filePath, rules, rootPath) {
   const violations = [];
-  const relativePath = import_path13.default.relative(rootPath, filePath);
+  const relativePath = import_path12.default.relative(rootPath, filePath);
   try {
-    const content = await import_promises13.default.readFile(filePath, "utf-8");
+    const content = await import_promises12.default.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     for (const rule of rules) {
       const ruleViolations = await evaluateRule(rule, content, lines, relativePath);
@@ -2931,7 +2803,7 @@ async function evaluateRule(rule, content, lines, filePath) {
     case "NAMING_CONVENTION": {
       const value = rule.value;
       const pattern = new RegExp(value.pattern);
-      const fileName = import_path13.default.basename(filePath);
+      const fileName = import_path12.default.basename(filePath);
       if (filePath.includes(value.context) && !pattern.test(fileName)) {
         violations.push({
           file: filePath,
@@ -2990,12 +2862,12 @@ function checkFunctionLines(content, lines, filePath, rule, limit) {
 }
 function formatViolations(violations) {
   for (const v of violations) {
-    const severityColor = v.severity === "critical" ? import_chalk14.default.red : v.severity === "warning" ? import_chalk14.default.yellow : import_chalk14.default.blue;
-    const lineInfo = v.line ? import_chalk14.default.dim(`:${v.line}`) : "";
+    const severityColor = v.severity === "critical" ? import_chalk13.default.red : v.severity === "warning" ? import_chalk13.default.yellow : import_chalk13.default.blue;
+    const lineInfo = v.line ? import_chalk13.default.dim(`:${v.line}`) : "";
     console.log(`  ${severityColor(`[${v.severity.toUpperCase()}]`)} ${v.file}${lineInfo}`);
     console.log(`    ${v.message}`);
     if (v.details) {
-      console.log(`    ${import_chalk14.default.dim(v.details)}`);
+      console.log(`    ${import_chalk13.default.dim(v.details)}`);
     }
   }
 }
@@ -3024,7 +2896,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 import_commander10.Command("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 import_commander9.Command("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 = (0, import_ora7.default)();
     try {
       let projectId = options.project;
@@ -3040,15 +2912,15 @@ function createCheckCommand() {
         projectId = getProjectId();
       }
       if (!projectId) {
-        console.log(import_chalk15.default.red("\u274C No project context found."));
-        console.log(import_chalk15.default.dim('   Run "rigstate link" or pass --project <id>'));
+        console.log(import_chalk14.default.red("\u274C No project context found."));
+        console.log(import_chalk14.default.dim('   Run "rigstate link" or pass --project <id>'));
         process.exit(2);
       }
       let apiKey;
       try {
         apiKey = getApiKey();
       } catch {
-        console.log(import_chalk15.default.red('\u274C Not authenticated. Run "rigstate login" first.'));
+        console.log(import_chalk14.default.red('\u274C Not authenticated. Run "rigstate login" first.'));
         process.exit(2);
       }
       spinner.start("Fetching Guardian rules...");
@@ -3076,17 +2948,17 @@ function createCheckCommand() {
       } catch (apiError) {
         const cached = await loadCachedRules(projectId);
         if (cached && !isStale(cached.timestamp, CACHE_MAX_AGE_MS)) {
-          spinner.warn(import_chalk15.default.yellow("Using cached rules (API unavailable)"));
+          spinner.warn(import_chalk14.default.yellow("Using cached rules (API unavailable)"));
           rules = cached.rules;
           settings = cached.settings;
         } else {
-          spinner.fail(import_chalk15.default.red("Failed to fetch rules and no valid cache"));
-          console.log(import_chalk15.default.dim(`   Error: ${apiError.message}`));
+          spinner.fail(import_chalk14.default.red("Failed to fetch rules and no valid cache"));
+          console.log(import_chalk14.default.dim(`   Error: ${apiError.message}`));
           process.exit(2);
         }
       }
       spinner.succeed(`Loaded ${rules.length} Guardian rules`);
-      const scanPath = import_path14.default.resolve(process.cwd(), targetPath);
+      const scanPath = import_path13.default.resolve(process.cwd(), targetPath);
       let filesToCheck;
       if (options.staged) {
         spinner.start("Getting staged files...");
@@ -3095,14 +2967,14 @@ function createCheckCommand() {
             encoding: "utf-8",
             cwd: process.cwd()
           });
-          filesToCheck = stagedOutput.split("\n").filter((f) => f.trim()).filter((f) => isCodeFile2(f)).map((f) => import_path14.default.resolve(process.cwd(), f));
+          filesToCheck = stagedOutput.split("\n").filter((f) => f.trim()).filter((f) => isCodeFile2(f)).map((f) => import_path13.default.resolve(process.cwd(), f));
         } catch {
           spinner.fail("Not a git repository or no staged files");
           process.exit(2);
         }
       } else {
-        spinner.start(`Scanning ${import_chalk15.default.cyan(targetPath)}...`);
-        const pattern = import_path14.default.join(scanPath, "**/*");
+        spinner.start(`Scanning ${import_chalk14.default.cyan(targetPath)}...`);
+        const pattern = import_path13.default.join(scanPath, "**/*");
         const allFiles = await (0, import_glob3.glob)(pattern, {
           nodir: true,
           dot: false,
@@ -3118,7 +2990,7 @@ function createCheckCommand() {
         filesToCheck = allFiles.filter((f) => isCodeFile2(f));
       }
       if (filesToCheck.length === 0) {
-        spinner.warn(import_chalk15.default.yellow("No code files found to check."));
+        spinner.warn(import_chalk14.default.yellow("No code files found to check."));
         outputResults([], !!options.json);
         process.exit(0);
       }
@@ -3127,7 +2999,7 @@ function createCheckCommand() {
       const results = [];
       for (let i = 0; i < filesToCheck.length; i++) {
         const file = filesToCheck[i];
-        spinner.text = `Checking ${i + 1}/${filesToCheck.length}: ${import_path14.default.basename(file)}`;
+        spinner.text = `Checking ${i + 1}/${filesToCheck.length}: ${import_path13.default.basename(file)}`;
         const result = await checkFile(file, rules, process.cwd());
         results.push(result);
       }
@@ -3137,47 +3009,47 @@ function createCheckCommand() {
         outputResults(results, true);
       } else {
         outputResults(results, false);
-        console.log("\n" + import_chalk15.default.bold("\u{1F4CA} Summary"));
-        console.log(import_chalk15.default.dim("\u2500".repeat(50)));
-        console.log(`Files checked: ${import_chalk15.default.cyan(summary.totalFiles)}`);
-        console.log(`Total violations: ${summary.totalViolations > 0 ? import_chalk15.default.red(summary.totalViolations) : import_chalk15.default.green(0)}`);
+        console.log("\n" + import_chalk14.default.bold("\u{1F4CA} Summary"));
+        console.log(import_chalk14.default.dim("\u2500".repeat(50)));
+        console.log(`Files checked: ${import_chalk14.default.cyan(summary.totalFiles)}`);
+        console.log(`Total violations: ${summary.totalViolations > 0 ? import_chalk14.default.red(summary.totalViolations) : import_chalk14.default.green(0)}`);
         if (summary.totalViolations > 0) {
-          console.log(`  ${import_chalk15.default.red("Critical:")} ${summary.criticalCount}`);
-          console.log(`  ${import_chalk15.default.yellow("Warning:")} ${summary.warningCount}`);
-          console.log(`  ${import_chalk15.default.blue("Info:")} ${summary.infoCount}`);
+          console.log(`  ${import_chalk14.default.red("Critical:")} ${summary.criticalCount}`);
+          console.log(`  ${import_chalk14.default.yellow("Warning:")} ${summary.warningCount}`);
+          console.log(`  ${import_chalk14.default.blue("Info:")} ${summary.infoCount}`);
         }
-        console.log(import_chalk15.default.dim("\u2500".repeat(50)));
+        console.log(import_chalk14.default.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(import_chalk15.default.red("\n\u274C Check failed: Critical violations found"));
+          console.log(import_chalk14.default.red("\n\u274C Check failed: Critical violations found"));
           process.exit(1);
         } else if (strictLevel === "all" && summary.totalViolations > 0) {
-          console.log(import_chalk15.default.red("\n\u274C Check failed: Violations found"));
+          console.log(import_chalk14.default.red("\n\u274C Check failed: Violations found"));
           process.exit(1);
         }
       }
       if (summary.totalViolations === 0) {
-        console.log(import_chalk15.default.green("\n\u2705 All checks passed!"));
+        console.log(import_chalk14.default.green("\n\u2705 All checks passed!"));
       }
       process.exit(0);
     } catch (error) {
-      spinner.fail(import_chalk15.default.red("Check failed"));
-      console.error(import_chalk15.default.red("Error:"), error.message);
+      spinner.fail(import_chalk14.default.red("Check failed"));
+      console.error(import_chalk14.default.red("Error:"), error.message);
       process.exit(2);
     }
   });
 }
 function isCodeFile2(filePath) {
   const codeExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-  const ext = import_path14.default.extname(filePath).toLowerCase();
+  const ext = import_path13.default.extname(filePath).toLowerCase();
   return codeExtensions.includes(ext);
 }
 async function loadCachedRules(projectId) {
   try {
-    const cachePath = import_path14.default.join(process.cwd(), CACHE_FILE2);
-    const content = await import_promises14.default.readFile(cachePath, "utf-8");
+    const cachePath = import_path13.default.join(process.cwd(), CACHE_FILE2);
+    const content = await import_promises13.default.readFile(cachePath, "utf-8");
     const cached = JSON.parse(content);
     if (cached.projectId !== projectId) {
       return null;
@@ -3189,16 +3061,16 @@ async function loadCachedRules(projectId) {
 }
 async function saveCachedRules(projectId, rules, settings) {
   try {
-    const cacheDir = import_path14.default.join(process.cwd(), ".rigstate");
-    await import_promises14.default.mkdir(cacheDir, { recursive: true });
+    const cacheDir = import_path13.default.join(process.cwd(), ".rigstate");
+    await import_promises13.default.mkdir(cacheDir, { recursive: true });
     const cached = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       projectId,
       rules,
       settings
     };
-    await import_promises14.default.writeFile(
-      import_path14.default.join(cacheDir, "rules-cache.json"),
+    await import_promises13.default.writeFile(
+      import_path13.default.join(cacheDir, "rules-cache.json"),
       JSON.stringify(cached, null, 2)
     );
   } catch {
@@ -3220,8 +3092,8 @@ function outputResults(results, json) {
   if (!hasViolations) {
     return;
   }
-  console.log("\n" + import_chalk15.default.bold("\u{1F50D} Violations Found"));
-  console.log(import_chalk15.default.dim("\u2500".repeat(50)));
+  console.log("\n" + import_chalk14.default.bold("\u{1F50D} Violations Found"));
+  console.log(import_chalk14.default.dim("\u2500".repeat(50)));
   for (const result of results) {
     if (result.violations.length > 0) {
       formatViolations(result.violations);
@@ -3229,8 +3101,125 @@ function outputResults(results, json) {
   }
 }
 
-// src/index.ts
-init_hooks();
+// src/commands/hooks.ts
+init_cjs_shims();
+var import_commander10 = require("commander");
+var import_chalk15 = __toESM(require("chalk"), 1);
+var import_promises14 = __toESM(require("fs/promises"), 1);
+var import_path14 = __toESM(require("path"), 1);
+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 import_commander10.Command("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 = import_path14.default.join(process.cwd(), ".git");
+      try {
+        await import_promises14.default.access(gitDir);
+      } catch {
+        console.log(import_chalk15.default.red("\u274C Not a git repository."));
+        console.log(import_chalk15.default.dim('   Initialize with "git init" first.'));
+        process.exit(1);
+      }
+      const hooksDir = import_path14.default.join(gitDir, "hooks");
+      await import_promises14.default.mkdir(hooksDir, { recursive: true });
+      const preCommitPath = import_path14.default.join(hooksDir, "pre-commit");
+      let existingContent = "";
+      try {
+        existingContent = await import_promises14.default.readFile(preCommitPath, "utf-8");
+        if (existingContent.includes("rigstate")) {
+          console.log(import_chalk15.default.yellow("\u26A0 Rigstate pre-commit hook already installed."));
+          console.log(import_chalk15.default.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 import_promises14.default.writeFile(preCommitPath, combinedScript, { mode: 493 });
+        console.log(import_chalk15.default.green("\u2705 Rigstate hook appended to existing pre-commit."));
+      } else {
+        await import_promises14.default.writeFile(preCommitPath, script, { mode: 493 });
+        console.log(import_chalk15.default.green("\u2705 Pre-commit hook installed!"));
+      }
+      console.log(import_chalk15.default.dim(`   Path: ${preCommitPath}`));
+      console.log(import_chalk15.default.dim(`   Strict level: ${options.strict}`));
+      console.log("");
+      console.log(import_chalk15.default.cyan("Guardian will now check your code before each commit."));
+      console.log(import_chalk15.default.dim('Use "rigstate hooks uninstall" to remove the hook.'));
+    } catch (error) {
+      console.error(import_chalk15.default.red("Failed to install hook:"), error.message);
+      process.exit(1);
+    }
+  });
+  hooks.command("uninstall").description("Remove Rigstate pre-commit hook").action(async () => {
+    try {
+      const preCommitPath = import_path14.default.join(process.cwd(), ".git", "hooks", "pre-commit");
+      try {
+        const content = await import_promises14.default.readFile(preCommitPath, "utf-8");
+        if (!content.includes("rigstate")) {
+          console.log(import_chalk15.default.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 import_promises14.default.unlink(preCommitPath);
+          console.log(import_chalk15.default.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 import_promises14.default.writeFile(preCommitPath, filteredLines.join("\n"), { mode: 493 });
+          console.log(import_chalk15.default.green("\u2705 Rigstate section removed from pre-commit hook."));
+        }
+      } catch {
+        console.log(import_chalk15.default.yellow("\u26A0 No pre-commit hook found."));
+      }
+    } catch (error) {
+      console.error(import_chalk15.default.red("Failed to uninstall hook:"), error.message);
+      process.exit(1);
+    }
+  });
+  return hooks;
+}
 
 // src/commands/daemon.ts
 init_cjs_shims();
@@ -3238,7 +3227,7 @@ var import_commander11 = require("commander");
 var import_chalk20 = __toESM(require("chalk"), 1);
 var import_ora8 = __toESM(require("ora"), 1);
 var import_promises17 = __toESM(require("fs/promises"), 1);
-var import_path19 = __toESM(require("path"), 1);
+var import_path20 = __toESM(require("path"), 1);
 var import_child_process3 = require("child_process");
 var import_url = require("url");
 
@@ -3249,6 +3238,7 @@ init_cjs_shims();
 init_cjs_shims();
 var import_chalk19 = __toESM(require("chalk"), 1);
 var fs17 = __toESM(require("fs/promises"), 1);
+var import_path19 = __toESM(require("path"), 1);
 var import_events3 = require("events");
 
 // src/daemon/file-watcher.ts
@@ -3916,6 +3906,7 @@ var GuardianDaemon = class extends import_events3.EventEmitter {
       }
     }
     this.printActive();
+    await this.updateViolationReport([]);
     this.emit("started", this.state);
   }
   printWelcome() {
@@ -3938,7 +3929,7 @@ var GuardianDaemon = class extends import_events3.EventEmitter {
   setupFileWatcher() {
     Logger.info("Starting file watcher...");
     this.fileWatcher = createFileWatcher(this.config.watchPath);
-    this.fileWatcher.on("change", (path24) => this.handleFileChange(path24));
+    this.fileWatcher.on("change", (path25) => this.handleFileChange(path25));
     this.fileWatcher.start();
     Logger.info("File watcher active");
   }
@@ -3979,11 +3970,37 @@ var GuardianDaemon = class extends import_events3.EventEmitter {
     this.state.filesChecked++;
     if (result.violations.length > 0) {
       this.handleViolations(filePath, result.violations);
+    } else {
+      await this.updateViolationReport([]);
+    }
+  }
+  async updateViolationReport(violations) {
+    const reportPath = import_path19.default.join(process.cwd(), ".rigstate", "ACTIVE_VIOLATIONS.md");
+    let content = `# \u{1F6E1}\uFE0F Guardian Status: ${violations.length > 0 ? "\u26A0\uFE0F ATTENTION" : "\u2705 PASS"}
+
+`;
+    content += `*Last check: ${(/* @__PURE__ */ new Date()).toLocaleString()}*
+
+`;
+    if (violations.length === 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}
+`;
+      }
+      content += "\n---\n*Rigstate Daemon is watching. Fix violations to clear this report.*";
+    }
+    try {
+      await fs17.writeFile(reportPath, content, "utf-8");
+    } catch (e) {
     }
   }
   handleViolations(filePath, violations) {
     this.state.violationsFound += violations.length;
     this.emit("violation", { file: filePath, violations });
+    this.updateViolationReport(violations);
     for (const v of violations) {
       const level = v.severity === "critical" ? "error" : v.severity === "warning" ? "warn" : "info";
       Logger[level](`[${v.severity.toUpperCase()}] ${filePath}: ${v.message}`);
@@ -4070,7 +4087,7 @@ function createDaemonCommand() {
     }
     const spinner = (0, import_ora8.default)();
     try {
-      const pidPath = import_path19.default.join(process.cwd(), PID_FILE);
+      const pidPath = import_path20.default.join(process.cwd(), PID_FILE);
       try {
         const content = await import_promises17.default.readFile(pidPath, "utf-8");
         const pid = parseInt(content.trim(), 10);
@@ -4124,7 +4141,7 @@ function createDaemonCommand() {
 }
 async function isRunning() {
   try {
-    const pidPath = import_path19.default.join(process.cwd(), PID_FILE);
+    const pidPath = import_path20.default.join(process.cwd(), PID_FILE);
     const content = await import_promises17.default.readFile(pidPath, "utf-8");
     const pid = parseInt(content.trim(), 10);
     try {
@@ -4140,25 +4157,25 @@ async function isRunning() {
 }
 async function writePidFile() {
   try {
-    const dir = import_path19.default.join(process.cwd(), ".rigstate");
+    const dir = import_path20.default.join(process.cwd(), ".rigstate");
     await import_promises17.default.mkdir(dir, { recursive: true });
-    await import_promises17.default.writeFile(import_path19.default.join(dir, "daemon.pid"), process.pid.toString());
+    await import_promises17.default.writeFile(import_path20.default.join(dir, "daemon.pid"), process.pid.toString());
   } catch {
   }
 }
 async function cleanupPidFile() {
   try {
-    await import_promises17.default.unlink(import_path19.default.join(process.cwd(), PID_FILE));
-    await import_promises17.default.unlink(import_path19.default.join(process.cwd(), STATE_FILE));
+    await import_promises17.default.unlink(import_path20.default.join(process.cwd(), PID_FILE));
+    await import_promises17.default.unlink(import_path20.default.join(process.cwd(), STATE_FILE));
   } catch {
   }
 }
 async function writeStateFile(state) {
   try {
-    const dir = import_path19.default.join(process.cwd(), ".rigstate");
+    const dir = import_path20.default.join(process.cwd(), ".rigstate");
     await import_promises17.default.mkdir(dir, { recursive: true });
     await import_promises17.default.writeFile(
-      import_path19.default.join(dir, "daemon.state.json"),
+      import_path20.default.join(dir, "daemon.state.json"),
       JSON.stringify(state, null, 2)
     );
   } catch {
@@ -4174,7 +4191,7 @@ async function showStatus() {
   }
   console.log(import_chalk20.default.green("Status: Running"));
   try {
-    const statePath = import_path19.default.join(process.cwd(), STATE_FILE);
+    const statePath = import_path20.default.join(process.cwd(), STATE_FILE);
     const content = await import_promises17.default.readFile(statePath, "utf-8");
     const state = JSON.parse(content);
     console.log(import_chalk20.default.dim("\u2500".repeat(40)));
@@ -4188,7 +4205,7 @@ async function showStatus() {
     console.log(import_chalk20.default.dim("(State file not found)"));
   }
   try {
-    const pidPath = import_path19.default.join(process.cwd(), PID_FILE);
+    const pidPath = import_path20.default.join(process.cwd(), PID_FILE);
     const pid = await import_promises17.default.readFile(pidPath, "utf-8");
     console.log(import_chalk20.default.dim(`PID: ${pid.trim()}`));
   } catch {
@@ -4207,9 +4224,9 @@ async function enableDaemon() {
     console.error(import_chalk20.default.red("\u274C Could not determine HOME directory."));
     return;
   }
-  const agentsDir = import_path19.default.join(homeDir, "Library/LaunchAgents");
-  const logDir = import_path19.default.join(homeDir, ".rigstate/logs");
-  const plistPath = import_path19.default.join(agentsDir, "com.rigstate.daemon.plist");
+  const agentsDir = import_path20.default.join(homeDir, "Library/LaunchAgents");
+  const logDir = import_path20.default.join(homeDir, ".rigstate/logs");
+  const plistPath = import_path20.default.join(agentsDir, "com.rigstate.daemon.plist");
   await import_promises17.default.mkdir(agentsDir, { recursive: true });
   await import_promises17.default.mkdir(logDir, { recursive: true });
   const scriptPath = (0, import_url.fileURLToPath)(importMetaUrl);
@@ -4230,9 +4247,9 @@ async function enableDaemon() {
     <key>WorkingDirectory</key>
     <string>${process.cwd()}</string>
     <key>StandardOutPath</key>
-    <string>${import_path19.default.join(logDir, "daemon.out.log")}</string>
+    <string>${import_path20.default.join(logDir, "daemon.out.log")}</string>
     <key>StandardErrorPath</key>
-    <string>${import_path19.default.join(logDir, "daemon.err.log")}</string>
+    <string>${import_path20.default.join(logDir, "daemon.err.log")}</string>
     <key>RunAtLoad</key>
     <true/>
     <key>KeepAlive</key>
@@ -4262,7 +4279,7 @@ async function enableDaemon() {
 async function disableDaemon() {
   console.log(import_chalk20.default.bold("\n\u2699\uFE0F  Disabling Rigstate Background Service\n"));
   const homeDir = process.env.HOME || "";
-  const plistPath = import_path19.default.join(homeDir, "Library/LaunchAgents/com.rigstate.daemon.plist");
+  const plistPath = import_path20.default.join(homeDir, "Library/LaunchAgents/com.rigstate.daemon.plist");
   try {
     await execShellCommand(`launchctl unload ${plistPath}`);
     await import_promises17.default.unlink(plistPath);
@@ -4415,7 +4432,7 @@ var import_chalk22 = __toESM(require("chalk"), 1);
 var import_ora10 = __toESM(require("ora"), 1);
 var import_chokidar = __toESM(require("chokidar"), 1);
 var import_promises18 = __toESM(require("fs/promises"), 1);
-var import_path20 = __toESM(require("path"), 1);
+var import_path21 = __toESM(require("path"), 1);
 var import_child_process4 = require("child_process");
 init_config();
 var import_axios16 = __toESM(require("axios"), 1);
@@ -4436,7 +4453,7 @@ function createWatchCommand() {
     projectId = getProjectId();
     if (!projectId) {
       try {
-        const manifestPath = import_path20.default.join(process.cwd(), ".rigstate");
+        const manifestPath = import_path21.default.join(process.cwd(), ".rigstate");
         const content = await import_promises18.default.readFile(manifestPath, "utf-8");
         const manifest = JSON.parse(content);
         projectId = manifest.project_id;
@@ -4483,7 +4500,7 @@ function createWatchCommand() {
     };
     const checkCriteria = async (criteria) => {
       try {
-        const fullPath = import_path20.default.resolve(process.cwd(), criteria.path);
+        const fullPath = import_path21.default.resolve(process.cwd(), criteria.path);
         switch (criteria.type) {
           case "file_exists":
             await import_promises18.default.access(fullPath);
@@ -4628,7 +4645,7 @@ init_config();
 var import_axios17 = __toESM(require("axios"), 1);
 var import_child_process5 = require("child_process");
 var import_promises19 = __toESM(require("fs/promises"), 1);
-var import_path21 = __toESM(require("path"), 1);
+var import_path22 = __toESM(require("path"), 1);
 function createFocusCommand() {
   const focus = new import_commander14.Command("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) => {
@@ -4644,7 +4661,7 @@ function createFocusCommand() {
     projectId = getProjectId();
     if (!projectId) {
       try {
-        const manifestPath = import_path21.default.join(process.cwd(), ".rigstate");
+        const manifestPath = import_path22.default.join(process.cwd(), ".rigstate");
         const content = await import_promises19.default.readFile(manifestPath, "utf-8");
         const manifest = JSON.parse(content);
         projectId = manifest.project_id;
@@ -4799,21 +4816,22 @@ init_cjs_shims();
 var import_commander16 = require("commander");
 var import_chalk25 = __toESM(require("chalk"), 1);
 var import_child_process6 = require("child_process");
-var import_path22 = __toESM(require("path"), 1);
+var import_path23 = __toESM(require("path"), 1);
 var import_fs = __toESM(require("fs"), 1);
 var import_url2 = require("url");
+init_config();
 var __filename2 = (0, import_url2.fileURLToPath)(importMetaUrl);
-var __dirname = import_path22.default.dirname(__filename2);
+var __dirname = import_path23.default.dirname(__filename2);
 function createMcpCommand() {
   const mcp = new import_commander16.Command("mcp");
   mcp.description("Run the Rigstate MCP server for AI editors").action(async () => {
     const possiblePaths = [
       // From packages/cli -> packages/mcp (sibling package)
-      import_path22.default.resolve(__dirname, "../../mcp/dist/index.js"),
+      import_path23.default.resolve(__dirname, "../../mcp/dist/index.js"),
       // If installed globally or via npm
-      import_path22.default.resolve(__dirname, "../../../mcp/dist/index.js"),
+      import_path23.default.resolve(__dirname, "../../../mcp/dist/index.js"),
       // Development path from packages/cli/dist
-      import_path22.default.resolve(__dirname, "../../../packages/mcp/dist/index.js")
+      import_path23.default.resolve(__dirname, "../../../packages/mcp/dist/index.js")
     ];
     let serverPath = "";
     for (const p of possiblePaths) {
@@ -4832,11 +4850,21 @@ function createMcpCommand() {
       process.exit(1);
     }
     console.log(import_chalk25.default.dim(`Starting MCP server from: ${serverPath}`));
-    if (process.env.VIBE_API_KEY && !process.env.RIGSTATE_API_KEY) {
-      process.env.RIGSTATE_API_KEY = process.env.VIBE_API_KEY;
+    const env = { ...process.env };
+    try {
+      const apiKey = getApiKey();
+      if (apiKey) {
+        env.RIGSTATE_API_KEY = apiKey;
+        env.RIGSTATE_APP_URL = getApiUrl();
+        env.RIGSTATE_API_URL = getApiUrl();
+      }
+    } catch (e) {
+    }
+    if (env.VIBE_API_KEY && !env.RIGSTATE_API_KEY) {
+      env.RIGSTATE_API_KEY = env.VIBE_API_KEY;
     }
     const worker = (0, import_child_process6.spawn)("node", [serverPath], {
-      env: process.env,
+      env,
       stdio: ["inherit", "inherit", "inherit"]
     });
     worker.on("error", (err) => {
@@ -5246,7 +5274,7 @@ var import_chalk30 = __toESM(require("chalk"), 1);
 var import_ora13 = __toESM(require("ora"), 1);
 var import_inquirer5 = __toESM(require("inquirer"), 1);
 var import_promises20 = __toESM(require("fs/promises"), 1);
-var import_path23 = __toESM(require("path"), 1);
+var import_path24 = __toESM(require("path"), 1);
 init_config();
 
 // ../../node_modules/simple-git/dist/esm/index.js
@@ -5287,8 +5315,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path24) {
-  return path24 instanceof String && cache.has(path24);
+function isPathSpec(path25) {
+  return path25 instanceof String && cache.has(path25);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -5377,8 +5405,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path24) {
-  return (0, import_file_exists.exists)(path24, import_file_exists.FOLDER);
+function folderExists(path25) {
+  return (0, import_file_exists.exists)(path25, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -5782,8 +5810,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path24) {
-      return /^\.(git)?$/.test(path24.trim());
+    parser(path25) {
+      return /^\.(git)?$/.test(path25.trim());
     }
   };
 }
@@ -6217,11 +6245,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path24, line, preview] = input.split(NULL);
-    paths.add(path24);
-    (results[path24] = results[path24] || []).push({
+    const [path25, line, preview] = input.split(NULL);
+    paths.add(path25);
+    (results[path25] = results[path25] || []).push({
       line: asNumber(line),
-      path: path24,
+      path: path25,
       preview
     });
   });
@@ -6986,14 +7014,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path24, text) {
+function parseInit(bare, path25, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path24, false, result[1]);
+    return new InitSummary(bare, path25, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path24, true, result[1]);
+    return new InitSummary(bare, path25, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -7004,7 +7032,7 @@ function parseInit(bare, path24, text) {
       break;
     }
   }
-  return new InitSummary(bare, path24, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path25, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -7013,9 +7041,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path24, existing, gitDir) {
+      constructor(bare, path25, existing, gitDir) {
         this.bare = bare;
-        this.path = path24;
+        this.path = path25;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -7027,7 +7055,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path24, customArgs) {
+function initTask(bare = false, path25, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -7036,7 +7064,7 @@ function initTask(bare = false, path24, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path24, text);
+      return parseInit(commands.includes("--bare"), path25, text);
     }
   };
 }
@@ -7852,12 +7880,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path24, index, working_dir) {
-        this.path = path24;
+      constructor(path25, index, working_dir) {
+        this.path = path25;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path24) || [null, path24, path24];
+          const detail = fromPathRegex.exec(path25) || [null, path25, path25];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -7888,14 +7916,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path24) {
+  function data(index, workingDir, path25) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path24);
+      handler(result, path25);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path24, index, workingDir));
+      result.files.push(new FileStatusSummary(path25, index, workingDir));
     }
   }
 }
@@ -8208,9 +8236,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path24, write) {
+      hashObject(path25, write) {
         return this._runTask(
-          hashObjectTask(path24, write === true),
+          hashObjectTask(path25, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -8563,8 +8591,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path24 = input.trim().replace(/^["']|["']$/g, "");
-  return path24 && (0, import_node_path.normalize)(path24);
+  const path25 = input.trim().replace(/^["']|["']$/g, "");
+  return path25 && (0, import_node_path.normalize)(path25);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -8878,8 +8906,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path24) {
-  return subModuleTask(["add", repo, path24]);
+function addSubModuleTask(repo, path25) {
+  return subModuleTask(["add", repo, path25]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -9209,8 +9237,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path24, then) {
-      return this._runTask(addSubModuleTask2(repo, path24), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path25, then) {
+      return this._runTask(addSubModuleTask2(repo, path25), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -9810,7 +9838,7 @@ function createReleaseCommand() {
         return;
       }
       spinner.text = "Scanning completed tasks...";
-      const pkgPath = import_path23.default.resolve(process.cwd(), "package.json");
+      const pkgPath = import_path24.default.resolve(process.cwd(), "package.json");
       const pkgContent = await import_promises20.default.readFile(pkgPath, "utf-8");
       const pkg2 = JSON.parse(pkgContent);
       const currentVersion = pkg2.version;
@@ -9832,7 +9860,7 @@ function createReleaseCommand() {
       }
       pkg2.version = newVersion;
       await import_promises20.default.writeFile(pkgPath, JSON.stringify(pkg2, null, 4));
-      const changelogPath = import_path23.default.resolve(process.cwd(), "CHANGELOG.md");
+      const changelogPath = import_path24.default.resolve(process.cwd(), "CHANGELOG.md");
       const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       const entry = `
 ## [${newVersion}] - ${date}