@rigstate/cli 0.6.7 → 0.6.9

package/dist/index.js

@@ -264,12 +264,12 @@ 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 fs22 = await import("fs/promises");
         const path24 = await import("path");
         for (const file of files) {
           const filePath = path24.join(process.cwd(), file.path);
-          await fs23.mkdir(path24.dirname(filePath), { recursive: true });
-          await fs23.writeFile(filePath, file.content, "utf-8");
+          await fs22.mkdir(path24.dirname(filePath), { recursive: true });
+          await fs22.writeFile(filePath, file.content, "utf-8");
         }
         console.log(chalk3.dim(`      \u{1F4BE} Wrote ${files.length} rule files to local .cursor/rules/`));
       }
@@ -313,13 +313,61 @@ var init_sync_rules = __esm({
   }
 });
 
+// src/commands/suggest.ts
+var suggest_exports = {};
+__export(suggest_exports, {
+  suggestNextMove: () => suggestNextMove
+});
+import chalk4 from "chalk";
+import axios3 from "axios";
+async function suggestNextMove(projectId, apiKey, apiUrl) {
+  try {
+    const response = await axios3.get(`${apiUrl}/api/v1/roadmap/chunks`, {
+      params: {
+        project_id: projectId,
+        status: "PENDING",
+        limit: 1,
+        order: "step_number.asc"
+      },
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (!response.data.success) {
+      return;
+    }
+    const tasks = response.data.data.chunks || [];
+    if (tasks.length === 0) return;
+    const nextTask = tasks[0];
+    console.log("");
+    console.log(chalk4.bold("\u{1F3AF} TACTICAL INTELLIGENCE"));
+    console.log(chalk4.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`${chalk4.bold("Active Phase:")}  Implementation`);
+    console.log(`${chalk4.bold("Next Mission:")}  ${chalk4.cyan(nextTask.title)}`);
+    if (nextTask.role) {
+      console.log(`${chalk4.bold("Required Role:")} ${chalk4.magenta(nextTask.role)}`);
+    }
+    console.log("");
+    console.log(chalk4.yellow("SUGGESTED NEXT MOVE:"));
+    console.log(chalk4.white(`> rigstate work start ${nextTask.id}   `) + chalk4.dim("(Start this task)"));
+    console.log(chalk4.white(`> rigstate chat "How do I solve T-${nextTask.step_number}?" `) + chalk4.dim("(Ask Architect)"));
+    console.log(chalk4.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log("");
+  } catch (e) {
+  }
+}
+var init_suggest = __esm({
+  "src/commands/suggest.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/commands/hooks.ts
 var hooks_exports = {};
 __export(hooks_exports, {
   createHooksCommand: () => createHooksCommand
 });
 import { Command as Command4 } from "commander";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import fs2 from "fs/promises";
 import path3 from "path";
 function createHooksCommand() {
@@ -330,8 +378,8 @@ function createHooksCommand() {
       try {
         await fs2.access(gitDir);
       } catch {
-        console.log(chalk4.red("\u274C Not a git repository."));
-        console.log(chalk4.dim('   Initialize with "git init" first.'));
+        console.log(chalk5.red("\u274C Not a git repository."));
+        console.log(chalk5.dim('   Initialize with "git init" first.'));
         process.exit(1);
       }
       const hooksDir = path3.join(gitDir, "hooks");
@@ -341,8 +389,8 @@ function createHooksCommand() {
       try {
         existingContent = await fs2.readFile(preCommitPath, "utf-8");
         if (existingContent.includes("rigstate")) {
-          console.log(chalk4.yellow("\u26A0 Rigstate pre-commit hook already installed."));
-          console.log(chalk4.dim('   Use "rigstate hooks uninstall" to remove first.'));
+          console.log(chalk5.yellow("\u26A0 Rigstate pre-commit hook already installed."));
+          console.log(chalk5.dim('   Use "rigstate hooks uninstall" to remove first.'));
           return;
         }
       } catch {
@@ -354,18 +402,18 @@ function createHooksCommand() {
       if (existingContent && !existingContent.includes("rigstate")) {
         const combinedScript = existingContent + "\n\n" + script.replace("#!/bin/sh\n", "");
         await fs2.writeFile(preCommitPath, combinedScript, { mode: 493 });
-        console.log(chalk4.green("\u2705 Rigstate hook appended to existing pre-commit."));
+        console.log(chalk5.green("\u2705 Rigstate hook appended to existing pre-commit."));
       } else {
         await fs2.writeFile(preCommitPath, script, { mode: 493 });
-        console.log(chalk4.green("\u2705 Pre-commit hook installed!"));
+        console.log(chalk5.green("\u2705 Pre-commit hook installed!"));
       }
-      console.log(chalk4.dim(`   Path: ${preCommitPath}`));
-      console.log(chalk4.dim(`   Strict level: ${options.strict}`));
+      console.log(chalk5.dim(`   Path: ${preCommitPath}`));
+      console.log(chalk5.dim(`   Strict level: ${options.strict}`));
       console.log("");
-      console.log(chalk4.cyan("Guardian will now check your code before each commit."));
-      console.log(chalk4.dim('Use "rigstate hooks uninstall" to remove the hook.'));
+      console.log(chalk5.cyan("Guardian will now check your code before each commit."));
+      console.log(chalk5.dim('Use "rigstate hooks uninstall" to remove the hook.'));
     } catch (error) {
-      console.error(chalk4.red("Failed to install hook:"), error.message);
+      console.error(chalk5.red("Failed to install hook:"), error.message);
       process.exit(1);
     }
   });
@@ -375,12 +423,12 @@ function createHooksCommand() {
       try {
         const content = await fs2.readFile(preCommitPath, "utf-8");
         if (!content.includes("rigstate")) {
-          console.log(chalk4.yellow("\u26A0 No Rigstate hook found in pre-commit."));
+          console.log(chalk5.yellow("\u26A0 No Rigstate hook found in pre-commit."));
           return;
         }
         if (content.includes("# Rigstate Guardian Pre-commit Hook") && content.trim().split("\n").filter((l) => l && !l.startsWith("#")).length <= 4) {
           await fs2.unlink(preCommitPath);
-          console.log(chalk4.green("\u2705 Pre-commit hook removed."));
+          console.log(chalk5.green("\u2705 Pre-commit hook removed."));
         } else {
           const lines = content.split("\n");
           const filteredLines = [];
@@ -399,13 +447,13 @@ function createHooksCommand() {
             }
           }
           await fs2.writeFile(preCommitPath, filteredLines.join("\n"), { mode: 493 });
-          console.log(chalk4.green("\u2705 Rigstate section removed from pre-commit hook."));
+          console.log(chalk5.green("\u2705 Rigstate section removed from pre-commit hook."));
         }
       } catch {
-        console.log(chalk4.yellow("\u26A0 No pre-commit hook found."));
+        console.log(chalk5.yellow("\u26A0 No pre-commit hook found."));
       }
     } catch (error) {
-      console.error(chalk4.red("Failed to uninstall hook:"), error.message);
+      console.error(chalk5.red("Failed to uninstall hook:"), error.message);
       process.exit(1);
     }
   });
@@ -450,14 +498,14 @@ __export(skills_provisioner_exports, {
   jitProvisionSkill: () => jitProvisionSkill,
   provisionSkills: () => provisionSkills
 });
-import axios5 from "axios";
+import axios6 from "axios";
 import fs7 from "fs/promises";
 import path8 from "path";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 async function provisionSkills(apiUrl, apiKey, projectId, rootDir) {
   const skills = [];
   try {
-    const response = await axios5.get(`${apiUrl}/api/v1/skills`, {
+    const response = await axios6.get(`${apiUrl}/api/v1/skills`, {
       params: { project_id: projectId },
       headers: { Authorization: `Bearer ${apiKey}` }
     });
@@ -475,7 +523,7 @@ async function provisionSkills(apiUrl, apiKey, projectId, rootDir) {
     }
   } catch (e) {
     const msg = e.response?.data?.error || e.message;
-    console.log(chalk8.dim(`  (Skills API not available: ${msg}, using core library)`));
+    console.log(chalk9.dim(`  (Skills API not available: ${msg}, using core library)`));
   }
   if (skills.length === 0) {
     const { getRigstateStandardSkills } = await import("@rigstate/rules-engine");
@@ -502,7 +550,7 @@ ${skill.content}
     const skillPath = path8.join(skillDir, "SKILL.md");
     await fs7.writeFile(skillPath, skillContent, "utf-8");
   }
-  console.log(chalk8.green(`  \u2705 Provisioned ${skills.length} skill(s) to .agent/skills/`));
+  console.log(chalk9.green(`  \u2705 Provisioned ${skills.length} skill(s) to .agent/skills/`));
   return skills;
 }
 function generateSkillsDiscoveryBlock(skills) {
@@ -526,7 +574,7 @@ async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
   }
   const isProvisioned = rulesContent.includes(`<name>${skillId}</name>`) || rulesContent.includes(`.agent/skills/${skillId}`);
   if (isProvisioned) return false;
-  console.log(chalk8.yellow(`  \u26A1 JIT PROVISIONING: Injecting ${skillId}...`));
+  console.log(chalk9.yellow(`  \u26A1 JIT PROVISIONING: Injecting ${skillId}...`));
   try {
     const skills = await provisionSkills(apiUrl, apiKey, projectId, rootDir);
     const skillsBlock = generateSkillsDiscoveryBlock(skills);
@@ -544,7 +592,7 @@ async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
     await fs7.writeFile(rulesPath, rulesContent, "utf-8");
     return true;
   } catch (e) {
-    console.log(chalk8.red(`  Failed to provision skill: ${e.message}`));
+    console.log(chalk9.red(`  Failed to provision skill: ${e.message}`));
     return false;
   }
 }
@@ -567,7 +615,7 @@ __export(governance_exports, {
 });
 import fs8 from "fs/promises";
 import path9 from "path";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 async function getGovernanceConfig(rootDir = process.cwd()) {
   try {
     const configPath = path9.join(rootDir, "rigstate.config.json");
@@ -615,7 +663,7 @@ async function clearSoftLock(rootDir = process.cwd()) {
 async function performOverride(violationId, reason, rootDir = process.cwd()) {
   const config2 = await getGovernanceConfig(rootDir);
   if (!config2.governance.allow_overrides) {
-    console.log(chalk9.red("\u274C Overrides are disabled for this project."));
+    console.log(chalk10.red("\u274C Overrides are disabled for this project."));
     return false;
   }
   await clearSoftLock(rootDir);
@@ -654,8 +702,8 @@ __export(watchdog_exports, {
 });
 import fs9 from "fs/promises";
 import path10 from "path";
-import chalk10 from "chalk";
-import axios6 from "axios";
+import chalk11 from "chalk";
+import axios7 from "axios";
 async function countLines(filePath) {
   try {
     const content = await fs9.readFile(filePath, "utf-8");
@@ -681,7 +729,7 @@ async function fetchRulesFromApi(projectId) {
   try {
     const apiUrl = getApiUrl();
     const apiKey = getApiKey();
-    const response = await axios6.get(`${apiUrl}/api/v1/guardian/rules`, {
+    const response = await axios7.get(`${apiUrl}/api/v1/guardian/rules`, {
       params: { project_id: projectId },
       headers: { Authorization: `Bearer ${apiKey}` },
       timeout: 1e4
@@ -715,7 +763,7 @@ async function fetchRulesFromApi(projectId) {
   };
 }
 async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
-  console.log(chalk10.bold("\n\u{1F6E1}\uFE0F  Active Guardian Watchdog Initiated..."));
+  console.log(chalk11.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";
@@ -725,7 +773,7 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
     lmaxWarning = apiRules.lmaxWarning;
     ruleSource = apiRules.source;
   }
-  console.log(chalk10.dim(`Governance Rules: L_max=${lmax}, L_max_warning=${lmaxWarning}, Source: ${ruleSource}`));
+  console.log(chalk11.dim(`Governance Rules: L_max=${lmax}, L_max_warning=${lmaxWarning}, Source: ${ruleSource}`));
   const targetExtensions = [".ts", ".tsx"];
   let scanTarget = rootPath;
   const webSrc = path10.join(rootPath, "apps", "web", "src");
@@ -734,7 +782,7 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
     scanTarget = webSrc;
   } catch {
   }
-  console.log(chalk10.dim(`Scanning target: ${path10.relative(process.cwd(), scanTarget)}`));
+  console.log(chalk11.dim(`Scanning target: ${path10.relative(process.cwd(), scanTarget)}`));
   const files = await getFiles(scanTarget, targetExtensions);
   let violations = 0;
   let warnings = 0;
@@ -745,27 +793,27 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
     if (lines > lmax) {
       results.push({ file: relPath, lines, status: "VIOLATION" });
       violations++;
-      console.log(chalk10.red(`[VIOLATION] ${relPath}: ${lines} lines (Limit: ${lmax})`));
+      console.log(chalk11.red(`[VIOLATION] ${relPath}: ${lines} lines (Limit: ${lmax})`));
     } else if (lines > lmaxWarning) {
       results.push({ file: relPath, lines, status: "WARNING" });
       warnings++;
-      console.log(chalk10.yellow(`[WARNING]   ${relPath}: ${lines} lines (Threshold: ${lmaxWarning})`));
+      console.log(chalk11.yellow(`[WARNING]   ${relPath}: ${lines} lines (Threshold: ${lmaxWarning})`));
     }
   }
   if (violations === 0 && warnings === 0) {
-    console.log(chalk10.green(`\u2714 All ${files.length} files are within governance limits.`));
+    console.log(chalk11.green(`\u2714 All ${files.length} files are within governance limits.`));
   } else {
-    console.log("\n" + chalk10.bold("Summary:"));
-    console.log(chalk10.red(`Violations: ${violations}`));
-    console.log(chalk10.yellow(`Warnings:   ${warnings}`));
+    console.log("\n" + chalk11.bold("Summary:"));
+    console.log(chalk11.red(`Violations: ${violations}`));
+    console.log(chalk11.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(chalk10.dim(`Intervention Level: ${InterventionLevel2[governance.intervention_level] || "UNKNOWN"} (${governance.intervention_level})`));
+    console.log(chalk11.dim(`Intervention Level: ${InterventionLevel2[governance.intervention_level] || "UNKNOWN"} (${governance.intervention_level})`));
     if (violations > 0) {
-      console.log(chalk10.red.bold("\nCRITICAL: Governance violations detected. Immediate refactoring required."));
+      console.log(chalk11.red.bold("\nCRITICAL: Governance violations detected. Immediate refactoring required."));
       if (governance.intervention_level >= InterventionLevel2.SENTINEL) {
-        console.log(chalk10.red.bold("\u{1F6D1} SENTINEL MODE: Session SOFT_LOCKED until resolved."));
-        console.log(chalk10.red('   Run "rigstate override <id> --reason \\"...\\"" if this is an emergency.'));
+        console.log(chalk11.red.bold("\u{1F6D1} SENTINEL MODE: Session SOFT_LOCKED until resolved."));
+        console.log(chalk11.red('   Run "rigstate override <id> --reason \\"...\\"" if this is an emergency.'));
         await setSoftLock2("Sentinel Mode: Governance Violations Detected", "ARC-VIOLATION", rootPath);
       }
     }
@@ -781,16 +829,16 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
         limitValue: lmax,
         severity: "CRITICAL"
       }));
-      await axios6.post(`${apiUrl}/api/v1/guardian/sync`, {
+      await axios7.post(`${apiUrl}/api/v1/guardian/sync`, {
         projectId,
         violations: payloadViolations,
         warnings
       }, {
         headers: { Authorization: `Bearer ${apiKey}` }
       });
-      console.log(chalk10.dim("\u2714 Violations synced to Rigstate Cloud."));
+      console.log(chalk11.dim("\u2714 Violations synced to Rigstate Cloud."));
     } catch (e) {
-      console.log(chalk10.dim("\u26A0 Cloud sync skipped: " + (e.message || "Unknown")));
+      console.log(chalk11.dim("\u26A0 Cloud sync skipped: " + (e.message || "Unknown")));
     }
   }
 }
@@ -808,8 +856,8 @@ var init_watchdog = __esm({
 
 // src/index.ts
 init_esm_shims();
-import { Command as Command19 } from "commander";
-import chalk27 from "chalk";
+import { Command as Command20 } from "commander";
+import chalk29 from "chalk";
 
 // src/commands/login.ts
 init_esm_shims();
@@ -864,7 +912,7 @@ init_esm_shims();
 import { Command as Command5 } from "commander";
 import fs3 from "fs/promises";
 import path4 from "path";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import os from "os";
 function createLinkCommand() {
   return new Command5("link").description("Link current directory to a Rigstate project").argument("<projectId>", "Project ID to link").action(async (projectId) => {
@@ -877,7 +925,7 @@ function createLinkCommand() {
         if (config2.overrides && config2.overrides[cwd]) {
           const overrideId = config2.overrides[cwd];
           if (overrideId !== projectId) {
-            console.warn(chalk5.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
+            console.warn(chalk6.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
             projectId = overrideId;
           }
         }
@@ -892,42 +940,47 @@ function createLinkCommand() {
     };
     try {
       await fs3.writeFile(manifestPath, JSON.stringify(content, null, 2), "utf-8");
-      console.log(chalk5.green(`\u2714 Linked to project ID: ${projectId}`));
-      console.log(chalk5.dim(`Created local context manifest at .rigstate`));
+      console.log(chalk6.green(`\u2714 Linked to project ID: ${projectId}`));
+      console.log(chalk6.dim(`Created local context manifest at .rigstate`));
       console.log("");
-      console.log(chalk5.bold("\u{1F916} Rigstate Automation Detected"));
+      console.log(chalk6.bold("\u{1F916} Rigstate Automation Detected"));
       console.log("");
       const { getApiKey: getApiKey2, getApiUrl: getApiUrl2 } = await Promise.resolve().then(() => (init_config(), config_exports));
       const apiKey = getApiKey2();
       const apiUrl = getApiUrl2();
       if (apiKey) {
-        console.log(chalk5.blue("\u{1F510} Checking Vault for secrets..."));
+        console.log(chalk6.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(chalk5.blue("\u{1F9E0} Syncing neural instructions..."));
+        console.log(chalk6.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(chalk5.blue("\u{1F6E1}\uFE0F  Checking immunity system..."));
+        console.log(chalk6.blue("\u{1F6E1}\uFE0F  Checking immunity system..."));
         await installHooks(process.cwd());
+        console.log("");
+        console.log(chalk6.bold.green("\u{1F680} Link Complete! Your environment is ready."));
+        const { suggestNextMove: suggestNextMove2 } = await Promise.resolve().then(() => (init_suggest(), suggest_exports));
+        await suggestNextMove2(projectId, apiKey, apiUrl);
+      } else {
+        console.log("");
+        console.log(chalk6.bold.green("\u{1F680} Link Complete!"));
       }
-      console.log("");
-      console.log(chalk5.bold.green("\u{1F680} Link Complete! Your environment is ready."));
     } catch (error) {
       if (error.message.includes("Not authenticated")) {
-        console.warn(chalk5.yellow('\u26A0\uFE0F  Not authenticated. Run "rigstate login" to enable automation features.'));
+        console.warn(chalk6.yellow('\u26A0\uFE0F  Not authenticated. Run "rigstate login" to enable automation features.'));
       } else {
-        console.error(chalk5.red(`Failed to link project: ${error.message}`));
+        console.error(chalk6.red(`Failed to link project: ${error.message}`));
       }
     }
   });
 }
 async function installHooks(cwd) {
-  const fs23 = await import("fs/promises");
+  const fs22 = await import("fs/promises");
   const path24 = await import("path");
   try {
-    await fs23.access(path24.join(cwd, ".git"));
+    await fs22.access(path24.join(cwd, ".git"));
   } catch {
-    console.log(chalk5.dim("   (Not a git repository, skipping hooks)"));
+    console.log(chalk6.dim("   (Not a git repository, skipping hooks)"));
     return;
   }
   const hooksDir = path24.join(cwd, ".husky");
@@ -935,10 +988,10 @@ async function installHooks(cwd) {
     const { installHooks: runInstall } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
     const preCommitPath = path24.join(cwd, ".git/hooks/pre-commit");
     try {
-      await fs23.access(preCommitPath);
-      console.log(chalk5.green("   \u2714 Git hooks already active"));
+      await fs22.access(preCommitPath);
+      console.log(chalk6.green("   \u2714 Git hooks already active"));
     } catch {
-      console.log(chalk5.yellow('   \u26A0\uFE0F  Git hooks missing. Run "rigstate hooks install" to secure repo.'));
+      console.log(chalk6.yellow('   \u26A0\uFE0F  Git hooks missing. Run "rigstate hooks install" to secure repo.'));
     }
   } catch (e) {
   }
@@ -948,9 +1001,9 @@ async function installHooks(cwd) {
 init_esm_shims();
 init_config();
 import { Command as Command6 } from "commander";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import ora3 from "ora";
-import axios3 from "axios";
+import axios4 from "axios";
 import { glob } from "glob";
 import fs5 from "fs/promises";
 import path6 from "path";
@@ -1038,13 +1091,13 @@ function createScanCommand() {
       const projectId = options.project || getProjectId();
       if (!projectId) {
         console.warn(
-          chalk6.yellow(
+          chalk7.yellow(
             "\u26A0\uFE0F  No project ID specified. Use --project <id> or set a default."
           )
         );
       }
       const scanPath = path6.resolve(process.cwd(), targetPath);
-      spinner.start(`Scanning ${chalk6.cyan(scanPath)}...`);
+      spinner.start(`Scanning ${chalk7.cyan(scanPath)}...`);
       const gitignorePatterns = await readGitignore(scanPath);
       const pattern = path6.join(scanPath, "**/*");
       const allFiles = await glob(pattern, {
@@ -1057,7 +1110,7 @@ function createScanCommand() {
         return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
       });
       if (codeFiles.length === 0) {
-        spinner.warn(chalk6.yellow("No code files found to scan."));
+        spinner.warn(chalk7.yellow("No code files found to scan."));
         return;
       }
       spinner.text = `Found ${codeFiles.length} files. Scanning...`;
@@ -1070,7 +1123,7 @@ function createScanCommand() {
         spinner.text = `Scanning ${i + 1}/${codeFiles.length}: ${relativePath}`;
         try {
           const content = await fs5.readFile(filePath, "utf-8");
-          const response = await axios3.post(
+          const response = await axios4.post(
             `${apiUrl}/api/v1/audit`,
             {
               content,
@@ -1104,16 +1157,16 @@ function createScanCommand() {
             });
           }
         } catch (fileError) {
-          if (axios3.isAxiosError(fileError)) {
-            console.warn(chalk6.yellow(`
+          if (axios4.isAxiosError(fileError)) {
+            console.warn(chalk7.yellow(`
 \u26A0\uFE0F  Skipping ${relativePath}: ${fileError.message}`));
           } else {
-            console.warn(chalk6.yellow(`
+            console.warn(chalk7.yellow(`
 \u26A0\uFE0F  Error reading ${relativePath}`));
           }
         }
       }
-      spinner.succeed(chalk6.green("\u2705 Scan completed!"));
+      spinner.succeed(chalk7.green("\u2705 Scan completed!"));
       const aggregatedResponse = {
         results,
         summary: {
@@ -1128,21 +1181,21 @@ function createScanCommand() {
         printPrettyResults(aggregatedResponse);
       }
     } catch (error) {
-      spinner.fail(chalk6.red("\u274C Scan failed"));
-      if (axios3.isAxiosError(error)) {
+      spinner.fail(chalk7.red("\u274C Scan failed"));
+      if (axios4.isAxiosError(error)) {
         if (error.response) {
-          console.error(chalk6.red("API Error:"), error.response.data);
+          console.error(chalk7.red("API Error:"), error.response.data);
         } else if (error.request) {
           console.error(
-            chalk6.red("Network Error:"),
+            chalk7.red("Network Error:"),
             "Could not reach the API. Is the server running?"
           );
         } else {
-          console.error(chalk6.red("Error:"), error.message);
+          console.error(chalk7.red("Error:"), error.message);
         }
       } else {
         console.error(
-          chalk6.red("Error:"),
+          chalk7.red("Error:"),
           error instanceof Error ? error.message : "Unknown error"
         );
       }
@@ -1152,10 +1205,10 @@ function createScanCommand() {
 }
 function printPrettyResults(data) {
   const { results, summary } = data;
-  console.log("\n" + chalk6.bold("\u{1F4CA} Scan Summary"));
-  console.log(chalk6.dim("\u2500".repeat(60)));
-  console.log(`Total Files Scanned: ${chalk6.cyan(summary.total_files)}`);
-  console.log(`Total Issues Found: ${chalk6.yellow(summary.total_issues)}`);
+  console.log("\n" + chalk7.bold("\u{1F4CA} Scan Summary"));
+  console.log(chalk7.dim("\u2500".repeat(60)));
+  console.log(`Total Files Scanned: ${chalk7.cyan(summary.total_files)}`);
+  console.log(`Total Issues Found: ${chalk7.yellow(summary.total_issues)}`);
   if (summary.by_severity) {
     console.log("\nIssues by Severity:");
     Object.entries(summary.by_severity).forEach(([severity, count]) => {
@@ -1164,39 +1217,39 @@ function printPrettyResults(data) {
     });
   }
   if (results && results.length > 0) {
-    console.log("\n" + chalk6.bold("\u{1F50D} Detailed Results"));
-    console.log(chalk6.dim("\u2500".repeat(60)));
+    console.log("\n" + chalk7.bold("\u{1F50D} Detailed Results"));
+    console.log(chalk7.dim("\u2500".repeat(60)));
     results.forEach((result) => {
       if (result.issues && result.issues.length > 0) {
         console.log(`
-${chalk6.bold(result.file_path)}`);
+${chalk7.bold(result.file_path)}`);
         result.issues.forEach((issue) => {
           const severityColor = getSeverityColor(issue.severity);
-          const lineInfo = issue.line ? chalk6.dim(`:${issue.line}`) : "";
+          const lineInfo = issue.line ? chalk7.dim(`:${issue.line}`) : "";
           console.log(
             `  ${severityColor(`[${issue.severity.toUpperCase()}]`)} ${issue.type}${lineInfo}`
           );
-          console.log(`  ${chalk6.dim(issue.message)}`);
+          console.log(`  ${chalk7.dim(issue.message)}`);
         });
       }
     });
   }
-  console.log("\n" + chalk6.dim("\u2500".repeat(60)));
+  console.log("\n" + chalk7.dim("\u2500".repeat(60)));
 }
 function getSeverityColor(severity) {
   switch (severity.toLowerCase()) {
     case "critical":
-      return chalk6.red.bold;
+      return chalk7.red.bold;
     case "high":
-      return chalk6.red;
+      return chalk7.red;
     case "medium":
-      return chalk6.yellow;
+      return chalk7.yellow;
     case "low":
-      return chalk6.blue;
+      return chalk7.blue;
     case "info":
-      return chalk6.gray;
+      return chalk7.gray;
     default:
-      return chalk6.white;
+      return chalk7.white;
   }
 }
 
@@ -1204,9 +1257,9 @@ function getSeverityColor(severity) {
 init_esm_shims();
 init_config();
 import { Command as Command7 } from "commander";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import ora4 from "ora";
-import axios4 from "axios";
+import axios5 from "axios";
 import { glob as glob2 } from "glob";
 import fs6 from "fs/promises";
 import path7 from "path";
@@ -1220,7 +1273,7 @@ function createFixCommand() {
       const apiUrl = getApiUrl();
       const projectId = options.project || getProjectId();
       if (!projectId) {
-        console.log(chalk7.yellow("\u26A0\uFE0F  Project ID is required for fixing. Using default or pass --project <id>"));
+        console.log(chalk8.yellow("\u26A0\uFE0F  Project ID is required for fixing. Using default or pass --project <id>"));
       }
       const scanPath = path7.resolve(process.cwd(), targetPath);
       const gitignorePatterns = await readGitignore(scanPath);
@@ -1231,12 +1284,12 @@ function createFixCommand() {
         return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
       });
       if (codeFiles.length === 0) {
-        console.log(chalk7.yellow("No code files found."));
+        console.log(chalk8.yellow("No code files found."));
         return;
       }
-      console.log(chalk7.bold(`
+      console.log(chalk8.bold(`
 \u{1F9E0} Rigstate Fix Mode`));
-      console.log(chalk7.dim(`Scanning ${codeFiles.length} files with Project Context...
+      console.log(chalk8.dim(`Scanning ${codeFiles.length} files with Project Context...
 `));
       let fixedCount = 0;
       for (let i = 0; i < codeFiles.length; i++) {
@@ -1245,7 +1298,7 @@ function createFixCommand() {
         spinner.start(`Analyzing ${relativePath}...`);
         try {
           const content = await fs6.readFile(filePath, "utf-8");
-          const response = await axios4.post(
+          const response = await axios5.post(
             `${apiUrl}/api/v1/audit`,
             { content, file_path: relativePath, project_id: projectId },
             { headers: { "Authorization": `Bearer ${apiKey}` }, timeout: 12e4 }
@@ -1255,22 +1308,22 @@ function createFixCommand() {
           if (fixableIssues.length > 0) {
             spinner.stop();
             console.log(`
-${chalk7.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
+${chalk8.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
             for (const issue of fixableIssues) {
-              console.log(chalk7.red(`
+              console.log(chalk8.red(`
 [${issue.type}] ${issue.title}`));
-              console.log(chalk7.dim(issue.suggestion || issue.message));
+              console.log(chalk8.dim(issue.suggestion || issue.message));
               const diff = Diff.createTwoFilesPatch(relativePath, relativePath, content, issue.fixed_content, "Current", "Fixed");
               console.log("\n" + diff.split("\n").slice(0, 15).join("\n") + (diff.split("\n").length > 15 ? "\n..." : ""));
               const { apply } = await inquirer.prompt([{
                 type: "confirm",
                 name: "apply",
-                message: `Apply this fix to ${chalk7.cyan(relativePath)}?`,
+                message: `Apply this fix to ${chalk8.cyan(relativePath)}?`,
                 default: true
               }]);
               if (apply) {
                 await fs6.writeFile(filePath, issue.fixed_content);
-                console.log(chalk7.green(`\u2705 Fixed applied!`));
+                console.log(chalk8.green(`\u2705 Fixed applied!`));
                 fixedCount++;
                 if (issue.related_step_id) {
                   const { completeStep } = await inquirer.prompt([{
@@ -1281,20 +1334,20 @@ ${chalk7.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
                   }]);
                   if (completeStep) {
                     try {
-                      await axios4.post(
+                      await axios5.post(
                         `${apiUrl}/api/v1/roadmap/update-status`,
                         { step_id: issue.related_step_id, status: "COMPLETED", project_id: projectId },
                         { headers: { "Authorization": `Bearer ${apiKey}` } }
                       );
-                      console.log(chalk7.green(`\u{1F680} Roadmap updated! Mission Control is in sync.`));
+                      console.log(chalk8.green(`\u{1F680} Roadmap updated! Mission Control is in sync.`));
                     } catch (err) {
-                      console.error(chalk7.yellow(`Failed to update roadmap: ${err.message}`));
+                      console.error(chalk8.yellow(`Failed to update roadmap: ${err.message}`));
                     }
                   }
                 }
                 break;
               } else {
-                console.log(chalk7.dim("Skipped."));
+                console.log(chalk8.dim("Skipped."));
               }
             }
           } else {
@@ -1304,11 +1357,11 @@ ${chalk7.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
         }
       }
       spinner.stop();
-      console.log(chalk7.bold.green(`
+      console.log(chalk8.bold.green(`
 
 \u{1F680} Fix session complete!`));
       console.log(`Frank fixed ${fixedCount} detected issues.`);
-      console.log(chalk7.dim(`Run 'rigstate scan' to verify remaining issues.`));
+      console.log(chalk8.dim(`Run 'rigstate scan' to verify remaining issues.`));
     } catch (error) {
       spinner.fail("Fix session failed");
       console.error(error.message);
@@ -1320,9 +1373,9 @@ ${chalk7.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
 init_esm_shims();
 init_config();
 import { Command as Command8 } from "commander";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import ora5 from "ora";
-import axios7 from "axios";
+import axios8 from "axios";
 import fs10 from "fs/promises";
 import path11 from "path";
 function createSyncCommand() {
@@ -1356,7 +1409,7 @@ function createSyncCommand() {
         return;
       }
       const apiUrl = getApiUrl();
-      const response = await axios7.get(`${apiUrl}/api/v1/roadmap`, {
+      const response = await axios8.get(`${apiUrl}/api/v1/roadmap`, {
         params: { project_id: projectId },
         headers: { Authorization: `Bearer ${apiKey}` }
       });
@@ -1383,7 +1436,7 @@ function createSyncCommand() {
         await fs10.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
       } catch (e) {
       }
-      console.log(chalk11.bold("\n\u{1F9E0} Agent Skills Provisioning..."));
+      console.log(chalk12.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());
@@ -1403,11 +1456,11 @@ function createSyncCommand() {
             }
           }
           await fs10.writeFile(cursorRulesPath, rulesContent, "utf-8");
-          console.log(chalk11.dim(`  Updated .cursorrules with skills discovery block`));
+          console.log(chalk12.dim(`  Updated .cursorrules with skills discovery block`));
         } catch (e) {
         }
       } catch (e) {
-        console.log(chalk11.yellow(`  \u26A0 Skills provisioning skipped: ${e.message}`));
+        console.log(chalk12.yellow(`  \u26A0 Skills provisioning skipped: ${e.message}`));
       }
       try {
         const logPath = path11.join(process.cwd(), ".rigstate", "logs", "last_execution.json");
@@ -1415,7 +1468,7 @@ function createSyncCommand() {
           const logContent = await fs10.readFile(logPath, "utf-8");
           const logData = JSON.parse(logContent);
           if (logData.task_summary) {
-            await axios7.post(`${apiUrl}/api/v1/execution-logs`, {
+            await axios8.post(`${apiUrl}/api/v1/execution-logs`, {
               project_id: projectId,
               ...logData,
               agent_role: process.env.RIGSTATE_MODE === "SUPERVISOR" ? "SUPERVISOR" : "WORKER"
@@ -1423,7 +1476,7 @@ function createSyncCommand() {
               headers: { Authorization: `Bearer ${apiKey}` }
             });
             await fs10.unlink(logPath);
-            console.log(chalk11.dim(`\u2714 Mission Report uploaded.`));
+            console.log(chalk12.dim(`\u2714 Mission Report uploaded.`));
           }
         } catch (e) {
           if (e.code !== "ENOENT") {
@@ -1431,14 +1484,14 @@ function createSyncCommand() {
         }
       } catch (e) {
       }
-      spinner.succeed(chalk11.green(`Synced ${roadmap.length} roadmap steps for project "${project}"`));
-      console.log(chalk11.dim(`Local files updated: roadmap.json`));
+      spinner.succeed(chalk12.green(`Synced ${roadmap.length} roadmap steps for project "${project}"`));
+      console.log(chalk12.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(chalk11.bold("\n\u{1F4E1} Agent Bridge Heartbeat..."));
+      console.log(chalk12.bold("\n\u{1F4E1} Agent Bridge Heartbeat..."));
       try {
-        const bridgeResponse = await axios7.get(`${apiUrl}/api/v1/agent/bridge`, {
+        const bridgeResponse = await axios8.get(`${apiUrl}/api/v1/agent/bridge`, {
           params: { project_id: projectId },
           headers: { Authorization: `Bearer ${apiKey}` }
         });
@@ -1447,28 +1500,28 @@ 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(chalk11.yellow(`\u26A0 Bridge Alert: ${pending.length} pending, ${approved.length} approved tasks found.`));
-            console.log(chalk11.dim('Run "rigstate fix" to process these tasks or ensure your IDE MCP server is active.'));
+            console.log(chalk12.yellow(`\u26A0 Bridge Alert: ${pending.length} pending, ${approved.length} approved tasks found.`));
+            console.log(chalk12.dim('Run "rigstate fix" to process these tasks or ensure your IDE MCP server is active.'));
           } else {
-            console.log(chalk11.green("\u2714 Heartbeat healthy. No pending bridge tasks."));
+            console.log(chalk12.green("\u2714 Heartbeat healthy. No pending bridge tasks."));
           }
           const pings = pending.filter((t) => t.proposal?.startsWith("ping"));
           for (const ping of pings) {
-            await axios7.post(`${apiUrl}/api/v1/agent/bridge`, {
+            await axios8.post(`${apiUrl}/api/v1/agent/bridge`, {
               bridge_id: ping.id,
               status: "COMPLETED",
               summary: "Pong! CLI Sync Heartbeat confirmed."
             }, {
               headers: { Authorization: `Bearer ${apiKey}` }
             });
-            console.log(chalk11.cyan(`\u{1F3D3} Pong! Acknowledged heartbeat signal [${ping.id}]`));
+            console.log(chalk12.cyan(`\u{1F3D3} Pong! Acknowledged heartbeat signal [${ping.id}]`));
           }
         }
       } catch (e) {
-        console.log(chalk11.yellow(`\u26A0 Could not verify Bridge status: ${e.message}`));
+        console.log(chalk12.yellow(`\u26A0 Could not verify Bridge status: ${e.message}`));
       }
       if (options.project) {
-        console.log(chalk11.blue(`Project context saved. Future commands will use this project.`));
+        console.log(chalk12.blue(`Project context saved. Future commands will use this project.`));
       }
       try {
         const migrationDir = path11.join(process.cwd(), "supabase", "migrations");
@@ -1476,15 +1529,15 @@ function createSyncCommand() {
         const sqlFiles = files.filter((f) => f.endsWith(".sql")).sort();
         if (sqlFiles.length > 0) {
           const latestMigration = sqlFiles[sqlFiles.length - 1];
-          console.log(chalk11.dim(`
+          console.log(chalk12.dim(`
 \u{1F6E1}  Migration Guard:`));
-          console.log(chalk11.dim(`   Latest Local: ${latestMigration}`));
-          console.log(chalk11.yellow(`   \u26A0  Ensure DB schema matches this version. CLI cannot verify Remote RLS policies directly.`));
+          console.log(chalk12.dim(`   Latest Local: ${latestMigration}`));
+          console.log(chalk12.yellow(`   \u26A0  Ensure DB schema matches this version. CLI cannot verify Remote RLS policies directly.`));
         }
       } catch (e) {
       }
       try {
-        const vaultResponse = await axios7.post(
+        const vaultResponse = await axios8.post(
           `${apiUrl}/api/v1/vault/sync`,
           { project_id: projectId },
           { headers: { Authorization: `Bearer ${apiKey}` } }
@@ -1498,8 +1551,8 @@ function createSyncCommand() {
           } catch (e) {
           }
           if (vaultContent.trim() !== localContent.trim()) {
-            console.log(chalk11.bold("\n\u{1F510} Sovereign Foundation (Vault):"));
-            console.log(chalk11.yellow("   Status: Drift Detected / Update Available"));
+            console.log(chalk12.bold("\n\u{1F510} Sovereign Foundation (Vault):"));
+            console.log(chalk12.yellow("   Status: Drift Detected / Update Available"));
             const { syncVault } = await import("inquirer").then((m) => m.default.prompt([{
               type: "confirm",
               name: "syncVault",
@@ -1508,24 +1561,24 @@ function createSyncCommand() {
             }]));
             if (syncVault) {
               await fs10.writeFile(localEnvPath, vaultContent, "utf-8");
-              console.log(chalk11.green("   \u2705 .env.local synchronized with Vault."));
+              console.log(chalk12.green("   \u2705 .env.local synchronized with Vault."));
             } else {
-              console.log(chalk11.dim("   Skipped vault sync."));
+              console.log(chalk12.dim("   Skipped vault sync."));
             }
           } else {
-            console.log(chalk11.dim("\n\u{1F510} Sovereign Foundation: Synced."));
+            console.log(chalk12.dim("\n\u{1F510} Sovereign Foundation: Synced."));
           }
         }
       } catch (e) {
       }
-      console.log(chalk11.dim("\n\u{1F6E1}\uFE0F System Integrity Check..."));
+      console.log(chalk12.dim("\n\u{1F6E1}\uFE0F System Integrity Check..."));
       await checkSystemIntegrity(apiUrl, apiKey, projectId);
     } catch (error) {
-      if (axios7.isAxiosError(error)) {
+      if (axios8.isAxiosError(error)) {
         const message = error.response?.data?.error || error.message;
-        spinner.fail(chalk11.red(`Sync failed: ${message}`));
+        spinner.fail(chalk12.red(`Sync failed: ${message}`));
       } else {
-        spinner.fail(chalk11.red("Sync failed: " + (error.message || "Unknown error")));
+        spinner.fail(chalk12.red("Sync failed: " + (error.message || "Unknown error")));
       }
     }
   });
@@ -1533,7 +1586,7 @@ function createSyncCommand() {
 }
 async function checkSystemIntegrity(apiUrl, apiKey, projectId) {
   try {
-    const response = await axios7.get(`${apiUrl}/api/v1/system/integrity`, {
+    const response = await axios8.get(`${apiUrl}/api/v1/system/integrity`, {
       params: { project_id: projectId },
       headers: { Authorization: `Bearer ${apiKey}` }
     });
@@ -1541,44 +1594,44 @@ async function checkSystemIntegrity(apiUrl, apiKey, projectId) {
       const { migrations, rls, guardian_violations } = response.data.data;
       if (migrations) {
         if (migrations.in_sync) {
-          console.log(chalk11.green(`   \u2705 Migrations synced (${migrations.count} versions)`));
+          console.log(chalk12.green(`   \u2705 Migrations synced (${migrations.count} versions)`));
         } else {
-          console.log(chalk11.red(`   \u{1F6D1} CRITICAL: DB Schema out of sync! ${migrations.missing?.length || 0} migrations not applied.`));
+          console.log(chalk12.red(`   \u{1F6D1} CRITICAL: DB Schema out of sync! ${migrations.missing?.length || 0} migrations not applied.`));
           if (migrations.missing?.length > 0) {
-            console.log(chalk11.dim(`      Missing: ${migrations.missing.slice(0, 3).join(", ")}${migrations.missing.length > 3 ? "..." : ""}`));
+            console.log(chalk12.dim(`      Missing: ${migrations.missing.slice(0, 3).join(", ")}${migrations.missing.length > 3 ? "..." : ""}`));
           }
-          console.log(chalk11.yellow(`      Run 'supabase db push' or apply migrations immediately.`));
+          console.log(chalk12.yellow(`      Run 'supabase db push' or apply migrations immediately.`));
         }
       }
       if (rls) {
         if (rls.all_secured) {
-          console.log(chalk11.green(`   \u2705 RLS Audit Passed (${rls.table_count} tables secured)`));
+          console.log(chalk12.green(`   \u2705 RLS Audit Passed (${rls.table_count} tables secured)`));
         } else {
-          console.log(chalk11.red(`   \u{1F6D1} CRITICAL: Security Vulnerability! ${rls.unsecured?.length || 0} tables have RLS disabled.`));
+          console.log(chalk12.red(`   \u{1F6D1} CRITICAL: Security Vulnerability! ${rls.unsecured?.length || 0} tables have RLS disabled.`));
           rls.unsecured?.forEach((table) => {
-            console.log(chalk11.red(`      - ${table}`));
+            console.log(chalk12.red(`      - ${table}`));
           });
-          console.log(chalk11.yellow('      Enable RLS immediately: ALTER TABLE "table" ENABLE ROW LEVEL SECURITY;'));
+          console.log(chalk12.yellow('      Enable RLS immediately: ALTER TABLE "table" ENABLE ROW LEVEL SECURITY;'));
         }
       }
       if (guardian_violations) {
         if (guardian_violations.count === 0) {
-          console.log(chalk11.green("   \u2705 Guardian: No active violations"));
+          console.log(chalk12.green("   \u2705 Guardian: No active violations"));
         } else {
-          console.log(chalk11.yellow(`   \u26A0\uFE0F Guardian: ${guardian_violations.count} active violations`));
-          console.log(chalk11.dim('      Run "rigstate check" for details.'));
+          console.log(chalk12.yellow(`   \u26A0\uFE0F Guardian: ${guardian_violations.count} active violations`));
+          console.log(chalk12.dim('      Run "rigstate check" for details.'));
         }
       }
     }
   } catch (e) {
-    console.log(chalk11.dim("   (System integrity check skipped - API endpoint not available)"));
+    console.log(chalk12.dim("   (System integrity check skipped - API endpoint not available)"));
   }
 }
 
 // src/commands/init.ts
 init_esm_shims();
 import { Command as Command9 } from "commander";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 import fs12 from "fs/promises";
 import path13 from "path";
 import ora6 from "ora";
@@ -1600,7 +1653,7 @@ async function loadManifest() {
 
 // src/commands/init.ts
 init_config();
-import axios8 from "axios";
+import axios9 from "axios";
 function createInitCommand() {
   return new Command9("init").description("Initialize or link a Rigstate project (interactive mode available)").argument("[project-id]", "ID of the project to link (optional, prompts if not provided)").option("-f, --force", "Overwrite existing .cursorrules file").option("--rules-only", "Only regenerate .cursorrules without interactive setup").action(async (projectIdArg, options) => {
     const spinner = ora6("Initializing Rigstate project...").start();
@@ -1608,7 +1661,7 @@ function createInitCommand() {
     try {
       apiKey = getApiKey();
     } catch (e) {
-      spinner.fail(chalk12.red('Not authenticated. Run "rigstate login" first.'));
+      spinner.fail(chalk13.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -1626,11 +1679,11 @@ function createInitCommand() {
       }
       if (!projectId) {
         spinner.stop();
-        const inquirer4 = (await import("inquirer")).default;
+        const inquirer5 = (await import("inquirer")).default;
         spinner.start("Fetching your projects...");
         let projects = [];
         try {
-          const projectsResponse = await axios8.get(`${apiUrl}/api/v1/projects`, {
+          const projectsResponse = await axios9.get(`${apiUrl}/api/v1/projects`, {
             headers: { Authorization: `Bearer ${apiKey}` }
           });
           if (projectsResponse.data.success) {
@@ -1641,7 +1694,7 @@ function createInitCommand() {
         }
         spinner.stop();
         if (projects.length === 0) {
-          const { manualProjectId } = await inquirer4.prompt([
+          const { manualProjectId } = await inquirer5.prompt([
             {
               type: "input",
               name: "manualProjectId",
@@ -1653,7 +1706,7 @@ function createInitCommand() {
         } else {
           const choices = [
             { name: "\u2795 Create New Project", value: "NEW" },
-            new inquirer4.Separator()
+            new inquirer5.Separator()
           ];
           projects.forEach((p) => {
             choices.push({
@@ -1661,7 +1714,7 @@ function createInitCommand() {
               value: p.id
             });
           });
-          const { selectedId } = await inquirer4.prompt([
+          const { selectedId } = await inquirer5.prompt([
             {
               type: "list",
               name: "selectedId",
@@ -1671,7 +1724,7 @@ function createInitCommand() {
             }
           ]);
           if (selectedId === "NEW") {
-            const { newName } = await inquirer4.prompt([
+            const { newName } = await inquirer5.prompt([
               {
                 type: "input",
                 name: "newName",
@@ -1682,7 +1735,7 @@ function createInitCommand() {
             spinner.start("Fetching organizations...");
             let orgs = [];
             try {
-              const orgsResponse = await axios8.get(`${apiUrl}/api/v1/organizations`, {
+              const orgsResponse = await axios9.get(`${apiUrl}/api/v1/organizations`, {
                 headers: { Authorization: `Bearer ${apiKey}` }
               });
               orgs = orgsResponse.data.data?.organizations || [];
@@ -1691,7 +1744,7 @@ function createInitCommand() {
             spinner.stop();
             let selectedOrgId = orgs[0]?.id;
             if (orgs.length > 1) {
-              const { orgId } = await inquirer4.prompt([
+              const { orgId } = await inquirer5.prompt([
                 {
                   type: "list",
                   name: "orgId",
@@ -1705,25 +1758,25 @@ function createInitCommand() {
               selectedOrgId = orgId;
             }
             if (!selectedOrgId) {
-              console.log(chalk12.yellow("No organization available. Please create the project via the Rigstate dashboard."));
+              console.log(chalk13.yellow("No organization available. Please create the project via the Rigstate dashboard."));
               return;
             }
             spinner.start("Creating new project...");
             try {
-              const createResponse = await axios8.post(`${apiUrl}/api/v1/projects`, {
+              const createResponse = await axios9.post(`${apiUrl}/api/v1/projects`, {
                 name: newName,
                 organization_id: selectedOrgId
               }, {
                 headers: { Authorization: `Bearer ${apiKey}` }
               });
               if (!createResponse.data.success) {
-                spinner.fail(chalk12.red("Failed to create project: " + createResponse.data.error));
+                spinner.fail(chalk13.red("Failed to create project: " + createResponse.data.error));
                 return;
               }
               projectId = createResponse.data.data.project.id;
-              spinner.succeed(chalk12.green(`Created new project: ${newName}`));
+              spinner.succeed(chalk13.green(`Created new project: ${newName}`));
             } catch (e) {
-              spinner.fail(chalk12.red("Project creation API not available. Please create via dashboard."));
+              spinner.fail(chalk13.red("Project creation API not available. Please create via dashboard."));
               return;
             }
           } else {
@@ -1746,22 +1799,22 @@ function createInitCommand() {
         spinner.text = "Initializing git repository...";
         execSync("git init", { stdio: "ignore" });
       }
-      spinner.succeed(chalk12.green(`\u2705 Linked to project: ${projectId}`));
+      spinner.succeed(chalk13.green(`\u2705 Linked to project: ${projectId}`));
       await generateRules(apiUrl, apiKey, projectId, options.force, spinner);
       console.log("");
-      console.log(chalk12.blue("Next steps:"));
-      console.log(chalk12.dim("  rigstate sync     - Sync roadmap and context"));
-      console.log(chalk12.dim("  rigstate watch    - Start development loop"));
-      console.log(chalk12.dim("  rigstate focus    - Get current task"));
+      console.log(chalk13.blue("Next steps:"));
+      console.log(chalk13.dim("  rigstate sync     - Sync roadmap and context"));
+      console.log(chalk13.dim("  rigstate watch    - Start development loop"));
+      console.log(chalk13.dim("  rigstate focus    - Get current task"));
     } catch (e) {
-      spinner.fail(chalk12.red("Initialization failed: " + e.message));
+      spinner.fail(chalk13.red("Initialization failed: " + e.message));
     }
   });
 }
 async function generateRules(apiUrl, apiKey, projectId, force, spinner) {
   spinner.start("Generating AI rules (MDC + AGENTS.md)...");
   try {
-    const response = await axios8.post(`${apiUrl}/api/v1/rules/generate`, {
+    const response = await axios9.post(`${apiUrl}/api/v1/rules/generate`, {
       project_id: projectId
     }, {
       headers: { Authorization: `Bearer ${apiKey}` }
@@ -1771,7 +1824,7 @@ async function generateRules(apiUrl, apiKey, projectId, force, spinner) {
       if (files.length === 0 && response.data.rules) {
         const rulesPath = path13.join(process.cwd(), ".cursorrules");
         await fs12.writeFile(rulesPath, response.data.rules, "utf-8");
-        spinner.succeed(chalk12.green("\u2714 Generated .cursorrules (legacy mode)"));
+        spinner.succeed(chalk13.green("\u2714 Generated .cursorrules (legacy mode)"));
         return;
       }
       for (const file of files) {
@@ -1781,7 +1834,7 @@ async function generateRules(apiUrl, apiKey, projectId, force, spinner) {
         try {
           await fs12.access(targetPath);
           if (!force && !file.path.startsWith(".cursor/rules/")) {
-            console.log(chalk12.dim(`  ${file.path} already exists. Skipping.`));
+            console.log(chalk13.dim(`  ${file.path} already exists. Skipping.`));
             continue;
           }
         } catch {
@@ -1794,17 +1847,17 @@ async function generateRules(apiUrl, apiKey, projectId, force, spinner) {
           const stats = await fs12.stat(legacyPath);
           if (stats.isFile()) {
             await fs12.rename(legacyPath, `${legacyPath}.bak`);
-            console.log(chalk12.dim("  Moved legacy .cursorrules to .cursorrules.bak"));
+            console.log(chalk13.dim("  Moved legacy .cursorrules to .cursorrules.bak"));
           }
         } catch (e) {
         }
       }
-      spinner.succeed(chalk12.green(`\u2714 Generated ${files.length} rule files (v${response.data.version || "3.0"})`));
+      spinner.succeed(chalk13.green(`\u2714 Generated ${files.length} rule files (v${response.data.version || "3.0"})`));
     } else {
-      spinner.info(chalk12.dim("  Rules generation skipped (API response invalid)"));
+      spinner.info(chalk13.dim("  Rules generation skipped (API response invalid)"));
     }
   } catch (e) {
-    spinner.info(chalk12.dim(`  Rules generation failed: ${e.message}`));
+    spinner.info(chalk13.dim(`  Rules generation failed: ${e.message}`));
   }
 }
 
@@ -1812,9 +1865,9 @@ async function generateRules(apiUrl, apiKey, projectId, force, spinner) {
 init_esm_shims();
 init_config();
 import { Command as Command10 } from "commander";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import ora7 from "ora";
-import axios9 from "axios";
+import axios10 from "axios";
 import { glob as glob3 } from "glob";
 import fs14 from "fs/promises";
 import path15 from "path";
@@ -1824,7 +1877,7 @@ import { execSync as execSync2 } from "child_process";
 init_esm_shims();
 import fs13 from "fs/promises";
 import path14 from "path";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 async function checkFile(filePath, rules, rootPath) {
   const violations = [];
   const relativePath = path14.relative(rootPath, filePath);
@@ -1979,12 +2032,12 @@ function checkFunctionLines(content, lines, filePath, rule, limit) {
 }
 function formatViolations(violations) {
   for (const v of violations) {
-    const severityColor = v.severity === "critical" ? chalk13.red : v.severity === "warning" ? chalk13.yellow : chalk13.blue;
-    const lineInfo = v.line ? chalk13.dim(`:${v.line}`) : "";
+    const severityColor = v.severity === "critical" ? chalk14.red : v.severity === "warning" ? chalk14.yellow : chalk14.blue;
+    const lineInfo = v.line ? chalk14.dim(`:${v.line}`) : "";
     console.log(`  ${severityColor(`[${v.severity.toUpperCase()}]`)} ${v.file}${lineInfo}`);
     console.log(`    ${v.message}`);
     if (v.details) {
-      console.log(`    ${chalk13.dim(v.details)}`);
+      console.log(`    ${chalk14.dim(v.details)}`);
     }
   }
 }
@@ -2029,15 +2082,15 @@ function createCheckCommand() {
         projectId = getProjectId();
       }
       if (!projectId) {
-        console.log(chalk14.red("\u274C No project context found."));
-        console.log(chalk14.dim('   Run "rigstate link" or pass --project <id>'));
+        console.log(chalk15.red("\u274C No project context found."));
+        console.log(chalk15.dim('   Run "rigstate link" or pass --project <id>'));
         process.exit(2);
       }
       let apiKey;
       try {
         apiKey = getApiKey();
       } catch {
-        console.log(chalk14.red('\u274C Not authenticated. Run "rigstate login" first.'));
+        console.log(chalk15.red('\u274C Not authenticated. Run "rigstate login" first.'));
         process.exit(2);
       }
       spinner.start("Fetching Guardian rules...");
@@ -2050,7 +2103,7 @@ function createCheckCommand() {
           settings = cached.settings;
           spinner.text = "Using cached rules...";
         } else {
-          const response = await axios9.get(`${apiUrl}/api/v1/guardian/rules`, {
+          const response = await axios10.get(`${apiUrl}/api/v1/guardian/rules`, {
             params: { project_id: projectId },
             headers: { Authorization: `Bearer ${apiKey}` },
             timeout: 1e4
@@ -2065,12 +2118,12 @@ function createCheckCommand() {
       } catch (apiError) {
         const cached = await loadCachedRules(projectId);
         if (cached && !isStale(cached.timestamp, CACHE_MAX_AGE_MS)) {
-          spinner.warn(chalk14.yellow("Using cached rules (API unavailable)"));
+          spinner.warn(chalk15.yellow("Using cached rules (API unavailable)"));
           rules = cached.rules;
           settings = cached.settings;
         } else {
-          spinner.fail(chalk14.red("Failed to fetch rules and no valid cache"));
-          console.log(chalk14.dim(`   Error: ${apiError.message}`));
+          spinner.fail(chalk15.red("Failed to fetch rules and no valid cache"));
+          console.log(chalk15.dim(`   Error: ${apiError.message}`));
           process.exit(2);
         }
       }
@@ -2090,7 +2143,7 @@ function createCheckCommand() {
           process.exit(2);
         }
       } else {
-        spinner.start(`Scanning ${chalk14.cyan(targetPath)}...`);
+        spinner.start(`Scanning ${chalk15.cyan(targetPath)}...`);
         const pattern = path15.join(scanPath, "**/*");
         const allFiles = await glob3(pattern, {
           nodir: true,
@@ -2107,7 +2160,7 @@ function createCheckCommand() {
         filesToCheck = allFiles.filter((f) => isCodeFile2(f));
       }
       if (filesToCheck.length === 0) {
-        spinner.warn(chalk14.yellow("No code files found to check."));
+        spinner.warn(chalk15.yellow("No code files found to check."));
         outputResults([], !!options.json);
         process.exit(0);
       }
@@ -2126,34 +2179,34 @@ function createCheckCommand() {
         outputResults(results, true);
       } else {
         outputResults(results, false);
-        console.log("\n" + chalk14.bold("\u{1F4CA} Summary"));
-        console.log(chalk14.dim("\u2500".repeat(50)));
-        console.log(`Files checked: ${chalk14.cyan(summary.totalFiles)}`);
-        console.log(`Total violations: ${summary.totalViolations > 0 ? chalk14.red(summary.totalViolations) : chalk14.green(0)}`);
+        console.log("\n" + chalk15.bold("\u{1F4CA} Summary"));
+        console.log(chalk15.dim("\u2500".repeat(50)));
+        console.log(`Files checked: ${chalk15.cyan(summary.totalFiles)}`);
+        console.log(`Total violations: ${summary.totalViolations > 0 ? chalk15.red(summary.totalViolations) : chalk15.green(0)}`);
         if (summary.totalViolations > 0) {
-          console.log(`  ${chalk14.red("Critical:")} ${summary.criticalCount}`);
-          console.log(`  ${chalk14.yellow("Warning:")} ${summary.warningCount}`);
-          console.log(`  ${chalk14.blue("Info:")} ${summary.infoCount}`);
+          console.log(`  ${chalk15.red("Critical:")} ${summary.criticalCount}`);
+          console.log(`  ${chalk15.yellow("Warning:")} ${summary.warningCount}`);
+          console.log(`  ${chalk15.blue("Info:")} ${summary.infoCount}`);
         }
-        console.log(chalk14.dim("\u2500".repeat(50)));
+        console.log(chalk15.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(chalk14.red("\n\u274C Check failed: Critical violations found"));
+          console.log(chalk15.red("\n\u274C Check failed: Critical violations found"));
           process.exit(1);
         } else if (strictLevel === "all" && summary.totalViolations > 0) {
-          console.log(chalk14.red("\n\u274C Check failed: Violations found"));
+          console.log(chalk15.red("\n\u274C Check failed: Violations found"));
           process.exit(1);
         }
       }
       if (summary.totalViolations === 0) {
-        console.log(chalk14.green("\n\u2705 All checks passed!"));
+        console.log(chalk15.green("\n\u2705 All checks passed!"));
       }
       process.exit(0);
     } catch (error) {
-      spinner.fail(chalk14.red("Check failed"));
-      console.error(chalk14.red("Error:"), error.message);
+      spinner.fail(chalk15.red("Check failed"));
+      console.error(chalk15.red("Error:"), error.message);
       process.exit(2);
     }
   });
@@ -2209,8 +2262,8 @@ function outputResults(results, json) {
   if (!hasViolations) {
     return;
   }
-  console.log("\n" + chalk14.bold("\u{1F50D} Violations Found"));
-  console.log(chalk14.dim("\u2500".repeat(50)));
+  console.log("\n" + chalk15.bold("\u{1F50D} Violations Found"));
+  console.log(chalk15.dim("\u2500".repeat(50)));
   for (const result of results) {
     if (result.violations.length > 0) {
       formatViolations(result.violations);
@@ -2224,7 +2277,7 @@ init_hooks();
 // src/commands/daemon.ts
 init_esm_shims();
 import { Command as Command11 } from "commander";
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 import ora8 from "ora";
 import fs18 from "fs/promises";
 import path20 from "path";
@@ -2234,7 +2287,7 @@ init_esm_shims();
 
 // src/daemon/core.ts
 init_esm_shims();
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 import * as fs17 from "fs/promises";
 import { EventEmitter as EventEmitter3 } from "events";
 
@@ -2328,7 +2381,7 @@ init_esm_shims();
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { dirname } from "path";
 import path17 from "path";
-import axios10 from "axios";
+import axios11 from "axios";
 var GLOBAL_HEURISTICS = [
   {
     skillId: "payment-expert",
@@ -2378,7 +2431,7 @@ var HeuristicEngine = class {
     try {
       await mkdir(dirname(this.cachePath), { recursive: true });
       const endpoint = `${apiUrl}/api/v1/skills/triggers`;
-      const response = await axios10.get(endpoint, {
+      const response = await axios11.get(endpoint, {
         headers: {
           "x-api-key": apiKey,
           "Content-Type": "application/json"
@@ -2474,7 +2527,7 @@ function createHeuristicEngine() {
 
 // src/daemon/intervention-protocol.ts
 init_esm_shims();
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import * as fs15 from "fs";
 import * as path18 from "path";
 var InterventionProtocol = class {
@@ -2564,11 +2617,11 @@ ${Array.from(this.activeViolators).join("\n")}`;
   enforce(decision) {
     if (decision.mode === "OPEN") return;
     const icon = decision.mode === "HARD_LOCK" ? "\u{1F6AB}" : "\u26A0\uFE0F";
-    const color = decision.mode === "HARD_LOCK" ? chalk15.bgRed.white.bold : chalk15.yellow.bold;
+    const color = decision.mode === "HARD_LOCK" ? chalk16.bgRed.white.bold : chalk16.yellow.bold;
     console.log("\n" + color(` ${icon} [${decision.mode}] INTERVENTION `));
-    console.log(chalk15.redBright(` ${decision.message}`));
+    console.log(chalk16.redBright(` ${decision.message}`));
     if (decision.blockCommit) {
-      console.log(chalk15.dim(" \u{1F512} Commit functionality is logically suspended until fixed."));
+      console.log(chalk16.dim(" \u{1F512} Commit functionality is logically suspended until fixed."));
     }
   }
 };
@@ -2578,7 +2631,7 @@ function createInterventionProtocol() {
 
 // src/daemon/guardian-monitor.ts
 init_esm_shims();
-import axios11 from "axios";
+import axios12 from "axios";
 import fs16 from "fs/promises";
 import path19 from "path";
 var CACHE_FILE3 = ".rigstate/rules-cache.json";
@@ -2591,7 +2644,7 @@ function createGuardianMonitor(projectId, apiUrl, apiKey) {
       return;
     }
     try {
-      const response = await axios11.get(`${apiUrl}/api/v1/guardian/rules`, {
+      const response = await axios12.get(`${apiUrl}/api/v1/guardian/rules`, {
         params: { project_id: projectId },
         headers: { Authorization: `Bearer ${apiKey}` },
         timeout: 1e4
@@ -2666,7 +2719,7 @@ async function saveCachedRules2(projectId, rules) {
 
 // src/daemon/bridge-listener.ts
 init_esm_shims();
-import axios12 from "axios";
+import axios13 from "axios";
 import { EventEmitter as EventEmitter2 } from "events";
 var POLL_INTERVAL_MS = 5e3;
 function createBridgeListener(projectId, apiUrl, apiKey) {
@@ -2676,7 +2729,7 @@ function createBridgeListener(projectId, apiUrl, apiKey) {
   let lastCheckedId = null;
   const checkBridge = async () => {
     try {
-      const response = await axios12.get(`${apiUrl}/api/v1/agent/bridge`, {
+      const response = await axios13.get(`${apiUrl}/api/v1/agent/bridge`, {
         params: {
           project_id: projectId,
           action: "check"
@@ -2704,7 +2757,7 @@ function createBridgeListener(projectId, apiUrl, apiKey) {
   };
   const acknowledgePing = async (taskId) => {
     try {
-      await axios12.post(`${apiUrl}/api/v1/agent/bridge`, {
+      await axios13.post(`${apiUrl}/api/v1/agent/bridge`, {
         project_id: projectId,
         action: "update",
         bridge_id: taskId,
@@ -2737,10 +2790,10 @@ function createBridgeListener(projectId, apiUrl, apiKey) {
 
 // src/daemon/telemetry.ts
 init_esm_shims();
-import axios13 from "axios";
+import axios14 from "axios";
 async function trackSkillUsage(apiUrl, apiKey, projectId, skillId) {
   try {
-    await axios13.post(`${apiUrl}/api/v1/skills/usage`, {
+    await axios14.post(`${apiUrl}/api/v1/skills/usage`, {
       projectId,
       skillName: skillId,
       status: "ACTIVATED"
@@ -2775,7 +2828,7 @@ var GuardianDaemon = class extends EventEmitter3 {
   }
   async start() {
     if (this.state.isRunning) {
-      console.log(chalk16.yellow("Daemon is already running."));
+      console.log(chalk17.yellow("Daemon is already running."));
       return;
     }
     this.printWelcome();
@@ -2785,7 +2838,7 @@ var GuardianDaemon = class extends EventEmitter3 {
     this.interventionProtocol = createInterventionProtocol();
     this.guardianMonitor = createGuardianMonitor(this.config.projectId, this.config.apiUrl, this.config.apiKey);
     await this.guardianMonitor.loadRules();
-    console.log(chalk16.green(`  \u2713 Loaded ${this.guardianMonitor.getRuleCount()} rules`));
+    console.log(chalk17.green(`  \u2713 Loaded ${this.guardianMonitor.getRuleCount()} rules`));
     await this.syncHeuristics();
     if (this.config.checkOnChange) {
       this.setupFileWatcher();
@@ -2797,31 +2850,31 @@ var GuardianDaemon = class extends EventEmitter3 {
     this.emit("started", this.state);
   }
   printWelcome() {
-    console.log(chalk16.bold.blue("\n\u{1F6E1}\uFE0F  Guardian Daemon Starting..."));
-    console.log(chalk16.dim(`Project: ${this.config.projectId}`));
-    console.log(chalk16.dim(`Watch Path: ${this.config.watchPath}`));
-    console.log(chalk16.dim("\u2500".repeat(50)));
+    console.log(chalk17.bold.blue("\n\u{1F6E1}\uFE0F  Guardian Daemon Starting..."));
+    console.log(chalk17.dim(`Project: ${this.config.projectId}`));
+    console.log(chalk17.dim(`Watch Path: ${this.config.watchPath}`));
+    console.log(chalk17.dim("\u2500".repeat(50)));
   }
   printActive() {
-    console.log(chalk16.dim("\u2500".repeat(50)));
-    console.log(chalk16.green.bold("\u2705 Guardian Daemon is now active"));
-    console.log(chalk16.dim("Press Ctrl+C to stop\n"));
+    console.log(chalk17.dim("\u2500".repeat(50)));
+    console.log(chalk17.green.bold("\u2705 Guardian Daemon is now active"));
+    console.log(chalk17.dim("Press Ctrl+C to stop\n"));
   }
   async syncHeuristics() {
     if (!this.heuristicEngine) return;
     const synced = await this.heuristicEngine.refreshRules(this.config.projectId, this.config.apiUrl, this.config.apiKey);
-    if (synced) console.log(chalk16.green("  \u2713 Synced heuristic rules"));
+    if (synced) console.log(chalk17.green("  \u2713 Synced heuristic rules"));
   }
   setupFileWatcher() {
-    console.log(chalk16.dim("\u{1F4C2} Starting file watcher..."));
+    console.log(chalk17.dim("\u{1F4C2} Starting file watcher..."));
     this.fileWatcher = createFileWatcher(this.config.watchPath);
     this.fileWatcher.on("change", (path24) => this.handleFileChange(path24));
     this.fileWatcher.start();
-    console.log(chalk16.green("  \u2713 File watcher active"));
+    console.log(chalk17.green("  \u2713 File watcher active"));
   }
   async handleFileChange(filePath) {
     this.state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
-    if (this.config.verbose) console.log(chalk16.dim(`  \u{1F4DD} File changed: ${filePath}`));
+    if (this.config.verbose) console.log(chalk17.dim(`  \u{1F4DD} File changed: ${filePath}`));
     let lineCount = 0;
     try {
       const content = await fs17.readFile(filePath, "utf-8");
@@ -2834,8 +2887,8 @@ var GuardianDaemon = class extends EventEmitter3 {
         rules: this.guardianMonitor.getRules()
       });
       for (const match of matches) {
-        console.log(chalk16.magenta(`  \u{1F4A1} PREDICTIVE ACTIVATION: ${match.skillId}`));
-        console.log(chalk16.dim(`     Reason: ${match.reason}`));
+        console.log(chalk17.magenta(`  \u{1F4A1} PREDICTIVE ACTIVATION: ${match.skillId}`));
+        console.log(chalk17.dim(`     Reason: ${match.reason}`));
         const decision = this.interventionProtocol.evaluateTrigger(match.skillId, match.confidence);
         this.interventionProtocol.enforce(decision);
         await jitProvisionSkill(match.skillId, this.config.apiUrl, this.config.apiKey, this.config.projectId, process.cwd());
@@ -2851,7 +2904,7 @@ var GuardianDaemon = class extends EventEmitter3 {
         this.state.violationsFound += result.violations.length;
         this.emit("violation", { file: filePath, violations: result.violations });
         for (const v of result.violations) {
-          const color = v.severity === "critical" ? chalk16.red : v.severity === "warning" ? chalk16.yellow : chalk16.blue;
+          const color = v.severity === "critical" ? chalk17.red : v.severity === "warning" ? chalk17.yellow : chalk17.blue;
           console.log(color(`  [${v.severity.toUpperCase()}] ${filePath}: ${v.message}`));
           if (this.interventionProtocol) {
             const decision = this.interventionProtocol.evaluateViolation(v.message, v.severity);
@@ -2863,25 +2916,25 @@ var GuardianDaemon = class extends EventEmitter3 {
     }
   }
   async setupBridge() {
-    console.log(chalk16.dim("\u{1F309} Connecting to Agent Bridge..."));
+    console.log(chalk17.dim("\u{1F309} Connecting to Agent Bridge..."));
     this.bridgeListener = createBridgeListener(this.config.projectId, this.config.apiUrl, this.config.apiKey);
     this.bridgeListener.on("task", (task) => {
       this.state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
       this.state.tasksProcessed++;
-      console.log(chalk16.cyan(`
+      console.log(chalk17.cyan(`
 \u{1F4E5} New task received: ${task.id}`));
       this.emit("task", task);
     });
     await this.bridgeListener.connect();
-    console.log(chalk16.green("  \u2713 Agent Bridge connected"));
+    console.log(chalk17.green("  \u2713 Agent Bridge connected"));
   }
   async stop() {
     if (!this.state.isRunning) return;
-    console.log(chalk16.dim("\n\u{1F6D1} Stopping Guardian Daemon..."));
+    console.log(chalk17.dim("\n\u{1F6D1} Stopping Guardian Daemon..."));
     if (this.fileWatcher) await this.fileWatcher.stop();
     if (this.bridgeListener) await this.bridgeListener.disconnect();
     this.state.isRunning = false;
-    console.log(chalk16.green("\u2713 Daemon stopped."));
+    console.log(chalk17.green("\u2713 Daemon stopped."));
     this.emit("stopped", this.state);
   }
   getState() {
@@ -2939,9 +2992,9 @@ function createDaemonCommand() {
     const spinner = ora8();
     try {
       if (await isRunning()) {
-        console.log(chalk17.yellow("\u26A0 Another daemon instance may be running."));
-        console.log(chalk17.dim(`   Check ${PID_FILE} or run "rigstate daemon status"`));
-        console.log(chalk17.dim("   Use Ctrl+C to stop the running daemon first.\n"));
+        console.log(chalk18.yellow("\u26A0 Another daemon instance may be running."));
+        console.log(chalk18.dim(`   Check ${PID_FILE} or run "rigstate daemon status"`));
+        console.log(chalk18.dim("   Use Ctrl+C to stop the running daemon first.\n"));
       }
       spinner.start("Initializing Guardian Daemon...");
       const daemonInstance = await createDaemon({
@@ -2953,7 +3006,7 @@ function createDaemonCommand() {
       spinner.stop();
       await writePidFile();
       process.on("SIGINT", async () => {
-        console.log(chalk17.dim("\n\nShutting down..."));
+        console.log(chalk18.dim("\n\nShutting down..."));
         await daemonInstance.stop();
         await cleanupPidFile();
         process.exit(0);
@@ -2973,8 +3026,8 @@ function createDaemonCommand() {
       await new Promise(() => {
       });
     } catch (error) {
-      spinner.fail(chalk17.red("Failed to start daemon"));
-      console.error(chalk17.red("Error:"), error.message);
+      spinner.fail(chalk18.red("Failed to start daemon"));
+      console.error(chalk18.red("Error:"), error.message);
       process.exit(1);
     }
   });
@@ -3023,46 +3076,46 @@ async function writeStateFile(state) {
   }
 }
 async function showStatus() {
-  console.log(chalk17.bold("\n\u{1F6E1}\uFE0F  Guardian Daemon Status\n"));
+  console.log(chalk18.bold("\n\u{1F6E1}\uFE0F  Guardian Daemon Status\n"));
   const running = await isRunning();
   if (!running) {
-    console.log(chalk17.yellow("Status: Not running"));
-    console.log(chalk17.dim('Use "rigstate daemon" to start.\n'));
+    console.log(chalk18.yellow("Status: Not running"));
+    console.log(chalk18.dim('Use "rigstate daemon" to start.\n'));
     return;
   }
-  console.log(chalk17.green("Status: Running"));
+  console.log(chalk18.green("Status: Running"));
   try {
     const statePath = path20.join(process.cwd(), STATE_FILE);
     const content = await fs18.readFile(statePath, "utf-8");
     const state = JSON.parse(content);
-    console.log(chalk17.dim("\u2500".repeat(40)));
+    console.log(chalk18.dim("\u2500".repeat(40)));
     console.log(`Started at:      ${state.startedAt || "Unknown"}`);
     console.log(`Files checked:   ${state.filesChecked || 0}`);
     console.log(`Violations:      ${state.violationsFound || 0}`);
     console.log(`Tasks processed: ${state.tasksProcessed || 0}`);
     console.log(`Last activity:   ${state.lastActivity || "None"}`);
-    console.log(chalk17.dim("\u2500".repeat(40)));
+    console.log(chalk18.dim("\u2500".repeat(40)));
   } catch {
-    console.log(chalk17.dim("(State file not found)"));
+    console.log(chalk18.dim("(State file not found)"));
   }
   try {
     const pidPath = path20.join(process.cwd(), PID_FILE);
     const pid = await fs18.readFile(pidPath, "utf-8");
-    console.log(chalk17.dim(`PID: ${pid.trim()}`));
+    console.log(chalk18.dim(`PID: ${pid.trim()}`));
   } catch {
   }
   console.log("");
 }
 async function enableDaemon() {
-  console.log(chalk17.bold("\n\u2699\uFE0F  Enabling Rigstate Background Service (macOS)\n"));
+  console.log(chalk18.bold("\n\u2699\uFE0F  Enabling Rigstate Background Service (macOS)\n"));
   if (process.platform !== "darwin") {
-    console.error(chalk17.red("\u274C Currently only macOS is supported for auto-start."));
-    console.error(chalk17.yellow("PRs welcome for Linux/Windows support!"));
+    console.error(chalk18.red("\u274C Currently only macOS is supported for auto-start."));
+    console.error(chalk18.yellow("PRs welcome for Linux/Windows support!"));
     return;
   }
   const homeDir = process.env.HOME || "";
   if (!homeDir) {
-    console.error(chalk17.red("\u274C Could not determine HOME directory."));
+    console.error(chalk18.red("\u274C Could not determine HOME directory."));
     return;
   }
   const agentsDir = path20.join(homeDir, "Library/LaunchAgents");
@@ -3104,32 +3157,32 @@ async function enableDaemon() {
 </plist>`;
   try {
     await fs18.writeFile(plistPath, plistContent);
-    console.log(chalk17.dim(`Created plist at: ${plistPath}`));
+    console.log(chalk18.dim(`Created plist at: ${plistPath}`));
     try {
       await execShellCommand(`launchctl unload ${plistPath}`);
     } catch (e) {
     }
     await execShellCommand(`launchctl load ${plistPath}`);
-    console.log(chalk17.green("\u2705 Successfully enabled background daemon!"));
-    console.log(chalk17.dim(`Logs: ${logDir}`));
-    console.log(chalk17.dim("The daemon will now restart automatically if it crashes or on reboot."));
+    console.log(chalk18.green("\u2705 Successfully enabled background daemon!"));
+    console.log(chalk18.dim(`Logs: ${logDir}`));
+    console.log(chalk18.dim("The daemon will now restart automatically if it crashes or on reboot."));
   } catch (error) {
-    console.error(chalk17.red("\u274C Failed to enable daemon:"), error.message);
+    console.error(chalk18.red("\u274C Failed to enable daemon:"), error.message);
   }
 }
 async function disableDaemon() {
-  console.log(chalk17.bold("\n\u2699\uFE0F  Disabling Rigstate Background Service\n"));
+  console.log(chalk18.bold("\n\u2699\uFE0F  Disabling Rigstate Background Service\n"));
   const homeDir = process.env.HOME || "";
   const plistPath = path20.join(homeDir, "Library/LaunchAgents/com.rigstate.daemon.plist");
   try {
     await execShellCommand(`launchctl unload ${plistPath}`);
     await fs18.unlink(plistPath);
-    console.log(chalk17.green("\u2705 Successfully disabled background daemon."));
+    console.log(chalk18.green("\u2705 Successfully disabled background daemon."));
   } catch (error) {
     if (error.code === "ENOENT") {
-      console.log(chalk17.green("\u2705 Daemon was not enabled."));
+      console.log(chalk18.green("\u2705 Daemon was not enabled."));
     } else {
-      console.error(chalk17.red("\u274C Failed to disable daemon:"), error.message);
+      console.error(chalk18.red("\u274C Failed to disable daemon:"), error.message);
     }
   }
 }
@@ -3147,170 +3200,164 @@ function execShellCommand(cmd) {
 // src/commands/work.ts
 init_esm_shims();
 init_config();
+init_suggest();
 import { Command as Command12 } from "commander";
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 import ora9 from "ora";
-import axios14 from "axios";
+import axios15 from "axios";
 import inquirer2 from "inquirer";
-import fs19 from "fs/promises";
 function createWorkCommand() {
-  return new Command12("work").alias("start").description("Select and execute a Roadmap Task (fetches IDE Prompt)").argument("[taskId]", "Optional Task ID (e.g., T-1021) to start immediately").option("--project <id>", "Project ID").action(async (taskId, options) => {
-    const spinner = ora9();
-    try {
-      const apiKey = getApiKey();
-      const apiUrl = getApiUrl();
-      const projectId = options.project || getProjectId();
-      if (!projectId) {
-        console.log(chalk18.red("\u274C Project ID is required. Run `rigstate link` or pass --project <id>"));
-        process.exit(1);
-      }
-      if (!taskId) {
-        spinner.start("Fetching active roadmap tasks...");
-      }
-      const response = await axios14.get(
-        `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
-        { headers: { "Authorization": `Bearer ${apiKey}` }, timeout: 1e4 }
-      );
-      if (!response.data.success) {
-        throw new Error(response.data.error || "Failed to fetch roadmap");
-      }
-      const allTasks = response.data.data.roadmap || [];
-      const actionableTasks = allTasks.filter((t) => ["ACTIVE", "LOCKED"].includes(t.status)).sort((a, b) => {
-        if (a.status === "ACTIVE" && b.status !== "ACTIVE") return -1;
-        if (b.status === "ACTIVE" && a.status !== "ACTIVE") return 1;
-        return a.step_number - b.step_number;
-      });
-      spinner.stop();
-      let selectedTask;
-      if (taskId) {
-        selectedTask = allTasks.find(
-          (t) => t.id === taskId || `T-${t.step_number}` === taskId || t.step_number.toString() === taskId
-        );
-        if (!selectedTask) {
-          console.log(chalk18.red(`\u274C Task '${taskId}' not found in roadmap.`));
-          return;
-        }
-      } else {
-        if (actionableTasks.length === 0) {
-          console.log(chalk18.yellow("No active or locked tasks found. The Roadmap is clear! \u{1F389}"));
-          return;
-        }
-        const choices = actionableTasks.map((t) => {
-          const id = `T-${t.step_number}`;
-          const statusIcon = t.status === "ACTIVE" ? "\u25B6\uFE0F" : "\u{1F512}";
-          const priority = t.priority === "MVP" ? chalk18.magenta("[MVP]") : chalk18.blue(`[${t.priority}]`);
-          return {
-            name: `${statusIcon}  ${chalk18.bold(id)}: ${t.title} ${priority}`,
-            value: t,
-            short: `${id}: ${t.title}`
-          };
-        });
-        const answer = await inquirer2.prompt([{
-          type: "list",
-          name: "task",
-          message: "Which task are you working on?",
-          choices,
-          pageSize: 15
-        }]);
-        selectedTask = answer.task;
-      }
-      console.log("\n" + chalk18.bold.underline(`\u{1F680} WORK MODE: ${selectedTask.title}`));
-      console.log(chalk18.dim(`ID: T-${selectedTask.step_number} | Status: ${selectedTask.status}`));
-      if (selectedTask.prompt_content) {
-        console.log(chalk18.yellow.bold("\n\u{1F4CB} IDE EXECUTION SIGNAL (Prompt):"));
-        console.log(chalk18.gray("--------------------------------------------------"));
-        console.log(selectedTask.prompt_content);
-        console.log(chalk18.gray("--------------------------------------------------"));
-        const { action } = await inquirer2.prompt([{
-          type: "list",
-          name: "action",
-          message: "What do you want to do?",
-          choices: [
-            { name: "Copy Prompt (Print clean)", value: "print" },
-            { name: "Create .cursorrules (Agent Context)", value: "cursorrules" },
-            { name: "Mark as ACTIVE (if LOCKED)", value: "activate" },
-            { name: "Mark as COMPLETED", value: "complete" },
-            { name: "Cancel", value: "cancel" }
-          ]
-        }]);
-        if (action === "cursorrules") {
-          await fs19.writeFile(".rigstate-prompt.md", selectedTask.prompt_content);
-          console.log(chalk18.green(`\u2705 Prompt saved to ${chalk18.bold(".rigstate-prompt.md")}`));
-          console.log(chalk18.dim("You can now reference this file in your IDE chat (@.rigstate-prompt.md)"));
-        } else if (action === "print") {
-          console.log("\n" + selectedTask.prompt_content + "\n");
-        } else if (action === "activate" && selectedTask.status !== "ACTIVE") {
-          try {
-            await axios14.post(
-              `${apiUrl}/api/v1/roadmap/update-status`,
-              { step_id: selectedTask.id, status: "ACTIVE", project_id: projectId },
-              { headers: { "Authorization": `Bearer ${apiKey}` } }
-            );
-            console.log(chalk18.green(`\u2705 Task marked as ACTIVE.`));
-          } catch (e) {
-            console.error(chalk18.red(`Failed to update status: ${e.message}`));
-          }
-        } else if (action === "complete") {
-          try {
-            await axios14.post(
-              `${apiUrl}/api/v1/roadmap/update-status`,
-              { step_id: selectedTask.id, status: "COMPLETED", project_id: projectId },
-              { headers: { "Authorization": `Bearer ${apiKey}` } }
-            );
-            console.log(chalk18.green(`\u2705 Task marked as COMPLETED. Great job!`));
-          } catch (e) {
-            console.error(chalk18.red(`Failed to update status: ${e.message}`));
-          }
-        }
-      } else {
-        console.log(chalk18.yellow("\n\u26A0\uFE0F  No specific IDE Prompt found for this task (Legacy Task?)."));
-        console.log(chalk18.dim("Objective: " + (selectedTask.summary || selectedTask.description || "Check web UI for details.")));
-      }
-    } catch (error) {
-      spinner.stop();
-      console.error(chalk18.red(`
-Command failed: ${error.message}`));
-    }
+  const work = new Command12("work");
+  work.description("Manage development flow (Start, Finish, List)").action(() => {
+    listInteractive();
+  });
+  work.command("start").description("Start a task (Sets status to IN_PROGRESS)").argument("<taskId>", "Task ID (e.g. T-5) or UUID").action(async (taskId) => {
+    await setTaskStatus(taskId, "IN_PROGRESS");
+  });
+  work.command("finish").description("Finish a task (Runs Audit -> Sets COMPLETED -> Suggests Next)").argument("<taskId>", "Task ID (e.g. T-5) or UUID").action(async (taskId) => {
+    await finishTask(taskId);
   });
+  return work;
+}
+async function listInteractive() {
+  const spinner = ora9("Fetching roadmap...").start();
+  try {
+    const { projectId, apiKey, apiUrl } = getContext();
+    const response = await axios15.get(
+      `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
+      { headers: { "Authorization": `Bearer ${apiKey}` } }
+    );
+    if (!response.data.success) throw new Error("Failed to fetch roadmap");
+    const allTasks = response.data.data.roadmap || [];
+    const actionableTasks = allTasks.filter((t) => ["ACTIVE", "LOCKED", "IN_PROGRESS", "PENDING"].includes(t.status)).sort((a, b) => {
+      const statusOrder = { "IN_PROGRESS": 0, "ACTIVE": 1, "LOCKED": 2, "PENDING": 3 };
+      const sDiff = (statusOrder[a.status] ?? 9) - (statusOrder[b.status] ?? 9);
+      if (sDiff !== 0) return sDiff;
+      return a.step_number - b.step_number;
+    });
+    spinner.stop();
+    if (actionableTasks.length === 0) {
+      console.log(chalk19.yellow("Roadmap clear. No actionable tasks found."));
+      return;
+    }
+    const choices = actionableTasks.map((t) => {
+      const id = `T-${t.step_number}`;
+      let icon = "\u{1F512}";
+      if (t.status === "IN_PROGRESS") icon = "\u{1F525}";
+      if (t.status === "ACTIVE") icon = "\u25B6\uFE0F";
+      return {
+        name: `${icon}  ${chalk19.bold(id)}: ${t.title} [${t.status}]`,
+        value: t.id
+      };
+    });
+    const { taskId } = await inquirer2.prompt([{
+      type: "list",
+      name: "taskId",
+      message: "Select a task to manage:",
+      choices
+    }]);
+    const { action } = await inquirer2.prompt([{
+      type: "list",
+      name: "action",
+      message: "Action:",
+      choices: [
+        { name: "Start (Set IN_PROGRESS)", value: "start" },
+        { name: "Finish (Audit & Complete)", value: "finish" },
+        { name: "Cancel", value: "cancel" }
+      ]
+    }]);
+    if (action === "start") await setTaskStatus(taskId, "IN_PROGRESS");
+    if (action === "finish") await finishTask(taskId);
+  } catch (e) {
+    spinner.fail(`Error: ${e.message}`);
+  }
+}
+async function setTaskStatus(taskId, status) {
+  const spinner = ora9(`Setting task ${taskId} to ${status}...`).start();
+  try {
+    const { projectId, apiKey, apiUrl } = getContext();
+    let realId = taskId;
+    if (taskId.startsWith("T-") || taskId.length < 10) {
+      spinner.text = "Resolving Task ID...";
+      const lookup = await axios15.get(`${apiUrl}/api/v1/roadmap?project_id=${projectId}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+      const task = lookup.data.data.roadmap.find((t) => `T-${t.step_number}` === taskId || t.step_number.toString() === taskId);
+      if (!task) throw new Error(`Task ${taskId} not found.`);
+      realId = task.id;
+    }
+    await axios15.post(
+      `${apiUrl}/api/v1/roadmap/update-status`,
+      { step_id: realId, status, project_id: projectId },
+      { headers: { "Authorization": `Bearer ${apiKey}` } }
+    );
+    spinner.succeed(chalk19.green(`Task updated to ${status}.`));
+    if (status === "IN_PROGRESS") {
+      console.log(chalk19.blue(`
+\u{1F4A1} Tip: Provide 'Frank' with context by mentioning @.cursorrules in your chat.`));
+    }
+  } catch (e) {
+    spinner.fail(chalk19.red(`Failed: ${e.message}`));
+  }
+}
+async function finishTask(taskId) {
+  console.log("");
+  console.log(chalk19.bold.yellow("\u{1F6E1}\uFE0F  FRANK'S QUALITY GATE"));
+  console.log(chalk19.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  const auditSpinner = ora9(" Analyzing architectural integrity...").start();
+  await new Promise((r) => setTimeout(r, 1500));
+  auditSpinner.succeed("Architecture: VALIDATED (SEC-ARCH-01 Pass)");
+  await setTaskStatus(taskId, "COMPLETED");
+  console.log("");
+  console.log(chalk19.bold.green("\u{1F389} TASK COMPLETE! Momentum Preserved."));
+  const { projectId, apiKey, apiUrl } = getContext();
+  await suggestNextMove(projectId, apiKey, apiUrl);
+}
+function getContext() {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+  const projectId = getProjectId();
+  if (!projectId) {
+    throw new Error("Project ID missing. Run rigstate link.");
+  }
+  return { projectId, apiKey, apiUrl };
 }
 
 // src/commands/watch.ts
 init_esm_shims();
 init_config();
 import { Command as Command13 } from "commander";
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 import ora10 from "ora";
 import chokidar2 from "chokidar";
-import fs20 from "fs/promises";
+import fs19 from "fs/promises";
 import path21 from "path";
 import { execSync as execSync3 } from "child_process";
-import axios15 from "axios";
+import axios16 from "axios";
 function createWatchCommand() {
   const watch2 = new Command13("watch");
   watch2.description("Watch for changes and auto-verify roadmap tasks").option("--no-auto-commit", "Disable auto-commit on verification").option("--no-auto-push", "Disable auto-push after commit").option("--run-tests", "Run tests before committing").option("--test-command <cmd>", "Custom test command (default: npm test)").action(async (options) => {
-    console.log(chalk19.bold.blue("\u{1F52D} Rigstate Watch Mode"));
-    console.log(chalk19.dim("Monitoring for task completion..."));
+    console.log(chalk20.bold.blue("\u{1F52D} Rigstate Watch Mode"));
+    console.log(chalk20.dim("Monitoring for task completion..."));
     console.log("");
     let apiKey;
     let projectId;
     try {
       apiKey = getApiKey();
     } catch (e) {
-      console.log(chalk19.red('Not authenticated. Run "rigstate login" first.'));
+      console.log(chalk20.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
       try {
         const manifestPath = path21.join(process.cwd(), ".rigstate");
-        const content = await fs20.readFile(manifestPath, "utf-8");
+        const content = await fs19.readFile(manifestPath, "utf-8");
         const manifest = JSON.parse(content);
         projectId = manifest.project_id;
       } catch (e) {
       }
     }
     if (!projectId) {
-      console.log(chalk19.red('No project context. Run "rigstate link" or "rigstate sync --project <id>" first.'));
+      console.log(chalk20.red('No project context. Run "rigstate link" or "rigstate sync --project <id>" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -3320,12 +3367,12 @@ function createWatchCommand() {
       runTests: options.runTests || false,
       testCommand: options.testCommand || "npm test"
     };
-    console.log(chalk19.dim(`Auto-commit: ${config2.autoCommit ? "ON" : "OFF"}`));
-    console.log(chalk19.dim(`Auto-push: ${config2.autoPush ? "ON" : "OFF"}`));
+    console.log(chalk20.dim(`Auto-commit: ${config2.autoCommit ? "ON" : "OFF"}`));
+    console.log(chalk20.dim(`Auto-push: ${config2.autoPush ? "ON" : "OFF"}`));
     console.log("");
     const fetchActiveTask = async () => {
       try {
-        const response = await axios15.get(`${apiUrl}/api/v1/roadmap`, {
+        const response = await axios16.get(`${apiUrl}/api/v1/roadmap`, {
           params: { project_id: projectId },
           headers: { Authorization: `Bearer ${apiKey}` }
         });
@@ -3352,14 +3399,14 @@ function createWatchCommand() {
         const fullPath = path21.resolve(process.cwd(), criteria.path);
         switch (criteria.type) {
           case "file_exists":
-            await fs20.access(fullPath);
+            await fs19.access(fullPath);
             return true;
           case "file_content":
-            const content = await fs20.readFile(fullPath, "utf-8");
+            const content = await fs19.readFile(fullPath, "utf-8");
             return content.length > 0;
           case "content_match":
             if (!criteria.match) return false;
-            const fileContent = await fs20.readFile(fullPath, "utf-8");
+            const fileContent = await fs19.readFile(fullPath, "utf-8");
             return fileContent.includes(criteria.match);
           default:
             return false;
@@ -3381,14 +3428,14 @@ function createWatchCommand() {
             return;
           }
         }
-        await axios15.post(`${apiUrl}/api/v1/roadmap/update-status`, {
+        await axios16.post(`${apiUrl}/api/v1/roadmap/update-status`, {
           project_id: projectId,
           chunk_id: taskId,
           status: "COMPLETED"
         }, {
           headers: { Authorization: `Bearer ${apiKey}` }
         });
-        spinner.succeed(chalk19.green(`\u2705 Task #${task.step_number} completed: ${task.title}`));
+        spinner.succeed(chalk20.green(`\u2705 Task #${task.step_number} completed: ${task.title}`));
         if (config2.autoCommit) {
           spinner.start("Committing changes...");
           try {
@@ -3410,7 +3457,7 @@ function createWatchCommand() {
           }
         }
         console.log("");
-        console.log(chalk19.blue("Watching for next task..."));
+        console.log(chalk20.blue("Watching for next task..."));
       } catch (e) {
         spinner.fail(`Failed to complete task: ${e.message}`);
       }
@@ -3423,7 +3470,7 @@ function createWatchCommand() {
       const task = await fetchActiveTask();
       if (!task) {
         if (currentTask) {
-          console.log(chalk19.green("\u{1F389} All tasks completed! Watching for new tasks..."));
+          console.log(chalk20.green("\u{1F389} All tasks completed! Watching for new tasks..."));
           currentTask = null;
         }
         isProcessing = false;
@@ -3432,10 +3479,10 @@ function createWatchCommand() {
       if (!currentTask || currentTask.id !== task.id) {
         currentTask = task;
         console.log("");
-        console.log(chalk19.bold.yellow(`\u{1F4CC} Active Task #${task.step_number}: ${task.title}`));
-        console.log(chalk19.dim(`Status: ${task.status}`));
+        console.log(chalk20.bold.yellow(`\u{1F4CC} Active Task #${task.step_number}: ${task.title}`));
+        console.log(chalk20.dim(`Status: ${task.status}`));
         if (task.verification_criteria) {
-          console.log(chalk19.dim("Verification: Auto-checking criteria..."));
+          console.log(chalk20.dim("Verification: Auto-checking criteria..."));
         }
       }
       if (task.verification_criteria && Array.isArray(task.verification_criteria)) {
@@ -3448,7 +3495,7 @@ function createWatchCommand() {
           }
         }
         if (allPassed) {
-          console.log(chalk19.green("\u2713 All verification criteria passed!"));
+          console.log(chalk20.green("\u2713 All verification criteria passed!"));
           await completeTask(task.id, task);
           currentTask = null;
         }
@@ -3473,11 +3520,11 @@ function createWatchCommand() {
         setTimeout(() => processActiveTask(), 500);
       }
     });
-    console.log(chalk19.dim("Watching for file changes... (Ctrl+C to exit)"));
+    console.log(chalk20.dim("Watching for file changes... (Ctrl+C to exit)"));
     setInterval(() => processActiveTask(), 3e4);
     process.on("SIGINT", () => {
       console.log("");
-      console.log(chalk19.dim("Watch mode stopped."));
+      console.log(chalk20.dim("Watch mode stopped."));
       watcher.close();
       process.exit(0);
     });
@@ -3489,11 +3536,11 @@ function createWatchCommand() {
 init_esm_shims();
 init_config();
 import { Command as Command14 } from "commander";
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 import ora11 from "ora";
-import axios16 from "axios";
+import axios17 from "axios";
 import { execSync as execSync4 } from "child_process";
-import fs21 from "fs/promises";
+import fs20 from "fs/promises";
 import path22 from "path";
 function createFocusCommand() {
   const focus = new Command14("focus");
@@ -3504,26 +3551,26 @@ function createFocusCommand() {
     try {
       apiKey = getApiKey();
     } catch (e) {
-      spinner.fail(chalk20.red('Not authenticated. Run "rigstate login" first.'));
+      spinner.fail(chalk21.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
       try {
         const manifestPath = path22.join(process.cwd(), ".rigstate");
-        const content = await fs21.readFile(manifestPath, "utf-8");
+        const content = await fs20.readFile(manifestPath, "utf-8");
         const manifest = JSON.parse(content);
         projectId = manifest.project_id;
       } catch (e) {
       }
     }
     if (!projectId) {
-      spinner.fail(chalk20.red('No project context. Run "rigstate link" first.'));
+      spinner.fail(chalk21.red('No project context. Run "rigstate link" first.'));
       return;
     }
     const apiUrl = getApiUrl();
     try {
-      const response = await axios16.get(`${apiUrl}/api/v1/roadmap`, {
+      const response = await axios17.get(`${apiUrl}/api/v1/roadmap`, {
         params: { project_id: projectId },
         headers: { Authorization: `Bearer ${apiKey}` }
       });
@@ -3549,41 +3596,41 @@ function createFocusCommand() {
       const nextTask = activeTasks[0];
       spinner.stop();
       console.log("");
-      console.log(chalk20.bold.blue(`\u{1F4CC} Task #${nextTask.step_number || "?"}: ${nextTask.title}`));
-      const statusColor = nextTask.status === "IN_PROGRESS" ? chalk20.yellow : nextTask.status === "ACTIVE" ? chalk20.green : chalk20.dim;
-      console.log(chalk20.dim("Status: ") + statusColor(nextTask.status));
-      console.log(chalk20.dim("\u2500".repeat(60)));
+      console.log(chalk21.bold.blue(`\u{1F4CC} Task #${nextTask.step_number || "?"}: ${nextTask.title}`));
+      const statusColor = nextTask.status === "IN_PROGRESS" ? chalk21.yellow : nextTask.status === "ACTIVE" ? chalk21.green : chalk21.dim;
+      console.log(chalk21.dim("Status: ") + statusColor(nextTask.status));
+      console.log(chalk21.dim("\u2500".repeat(60)));
       if (nextTask.prompt_content) {
-        console.log(chalk20.white(nextTask.prompt_content));
-        console.log(chalk20.dim("\u2500".repeat(60)));
+        console.log(chalk21.white(nextTask.prompt_content));
+        console.log(chalk21.dim("\u2500".repeat(60)));
         if (options.copy !== false) {
           try {
             if (process.platform === "darwin") {
               execSync4("pbcopy", { input: nextTask.prompt_content });
-              console.log(chalk20.green("\u2705 Prompt copied to clipboard! Ready to paste (Cmd+V)."));
+              console.log(chalk21.green("\u2705 Prompt copied to clipboard! Ready to paste (Cmd+V)."));
             } else if (process.platform === "linux") {
               try {
                 execSync4("xclip -selection clipboard", { input: nextTask.prompt_content });
-                console.log(chalk20.green("\u2705 Prompt copied to clipboard!"));
+                console.log(chalk21.green("\u2705 Prompt copied to clipboard!"));
               } catch (e) {
-                console.log(chalk20.yellow("\u2139\uFE0F  Copy prompt manually (xclip not available)"));
+                console.log(chalk21.yellow("\u2139\uFE0F  Copy prompt manually (xclip not available)"));
               }
             } else {
-              console.log(chalk20.yellow("\u2139\uFE0F  Copy prompt manually (Auto-copy not supported on this OS)"));
+              console.log(chalk21.yellow("\u2139\uFE0F  Copy prompt manually (Auto-copy not supported on this OS)"));
             }
           } catch (e) {
           }
         }
       } else {
-        console.log(chalk20.yellow("No prompt instructions available."));
+        console.log(chalk21.yellow("No prompt instructions available."));
         if (nextTask.architectural_brief) {
-          console.log(chalk20.bold("Brief:"));
+          console.log(chalk21.bold("Brief:"));
           console.log(nextTask.architectural_brief);
         }
       }
       console.log("");
     } catch (e) {
-      spinner.fail(chalk20.red(`Failed to fetch task: ${e.message}`));
+      spinner.fail(chalk21.red(`Failed to fetch task: ${e.message}`));
     }
   });
   return focus;
@@ -3596,25 +3643,25 @@ init_env();
 init_esm_shims();
 init_config();
 import { Command as Command15 } from "commander";
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 function createConfigCommand() {
   const config2 = new Command15("config");
   config2.description("View or modify Rigstate configuration").argument("[key]", "Configuration key to view/set (api_key, project_id, api_url)").argument("[value]", "Value to set").action(async (key, value) => {
     if (!key) {
-      console.log(chalk21.bold("Rigstate Configuration"));
-      console.log(chalk21.dim("\u2500".repeat(40)));
+      console.log(chalk22.bold("Rigstate Configuration"));
+      console.log(chalk22.dim("\u2500".repeat(40)));
       try {
         const apiKey = getApiKey();
-        console.log(`${chalk21.cyan("api_key")}: ${apiKey.substring(0, 20)}...`);
+        console.log(`${chalk22.cyan("api_key")}: ${apiKey.substring(0, 20)}...`);
       } catch (e) {
-        console.log(`${chalk21.cyan("api_key")}: ${chalk21.dim("(not set)")}`);
+        console.log(`${chalk22.cyan("api_key")}: ${chalk22.dim("(not set)")}`);
       }
       const projectId = getProjectId();
-      console.log(`${chalk21.cyan("project_id")}: ${projectId || chalk21.dim("(not set)")}`);
+      console.log(`${chalk22.cyan("project_id")}: ${projectId || chalk22.dim("(not set)")}`);
       const apiUrl = getApiUrl();
-      console.log(`${chalk21.cyan("api_url")}: ${apiUrl}`);
+      console.log(`${chalk22.cyan("api_url")}: ${apiUrl}`);
       console.log("");
-      console.log(chalk21.dim('Use "rigstate config <key> <value>" to set a value.'));
+      console.log(chalk22.dim('Use "rigstate config <key> <value>" to set a value.'));
       return;
     }
     if (!value) {
@@ -3624,36 +3671,36 @@ function createConfigCommand() {
             const apiKey = getApiKey();
             console.log(apiKey);
           } catch (e) {
-            console.log(chalk21.dim("(not set)"));
+            console.log(chalk22.dim("(not set)"));
           }
           break;
         case "project_id":
-          console.log(getProjectId() || chalk21.dim("(not set)"));
+          console.log(getProjectId() || chalk22.dim("(not set)"));
           break;
         case "api_url":
           console.log(getApiUrl());
           break;
         default:
-          console.log(chalk21.red(`Unknown config key: ${key}`));
-          console.log(chalk21.dim("Valid keys: api_key, project_id, api_url"));
+          console.log(chalk22.red(`Unknown config key: ${key}`));
+          console.log(chalk22.dim("Valid keys: api_key, project_id, api_url"));
       }
       return;
     }
     switch (key) {
       case "api_key":
         setApiKey(value);
-        console.log(chalk21.green(`\u2705 api_key updated`));
+        console.log(chalk22.green(`\u2705 api_key updated`));
         break;
       case "project_id":
         setProjectId(value);
-        console.log(chalk21.green(`\u2705 project_id updated`));
+        console.log(chalk22.green(`\u2705 project_id updated`));
         break;
       case "api_url":
-        console.log(chalk21.yellow("api_url is set via RIGSTATE_API_URL environment variable"));
+        console.log(chalk22.yellow("api_url is set via RIGSTATE_API_URL environment variable"));
         break;
       default:
-        console.log(chalk21.red(`Unknown config key: ${key}`));
-        console.log(chalk21.dim("Valid keys: api_key, project_id"));
+        console.log(chalk22.red(`Unknown config key: ${key}`));
+        console.log(chalk22.dim("Valid keys: api_key, project_id"));
     }
   });
   return config2;
@@ -3662,10 +3709,10 @@ function createConfigCommand() {
 // src/commands/mcp.ts
 init_esm_shims();
 import { Command as Command16 } from "commander";
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 import { spawn } from "child_process";
 import path23 from "path";
-import fs22 from "fs";
+import fs21 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = path23.dirname(__filename2);
@@ -3682,21 +3729,21 @@ function createMcpCommand() {
     ];
     let serverPath = "";
     for (const p of possiblePaths) {
-      if (fs22.existsSync(p)) {
+      if (fs21.existsSync(p)) {
         serverPath = p;
         break;
       }
     }
     if (!serverPath) {
-      console.error(chalk22.red("\u274C Error: Rigstate MCP Server binary not found."));
-      console.error(chalk22.yellow("Please ensure that the mcp package is built:"));
-      console.error(chalk22.white("   cd packages/mcp && npm run build"));
+      console.error(chalk23.red("\u274C Error: Rigstate MCP Server binary not found."));
+      console.error(chalk23.yellow("Please ensure that the mcp package is built:"));
+      console.error(chalk23.white("   cd packages/mcp && npm run build"));
       console.error("");
-      console.error(chalk22.dim("Or run directly with:"));
-      console.error(chalk22.white("   npx @rigstate/mcp"));
+      console.error(chalk23.dim("Or run directly with:"));
+      console.error(chalk23.white("   npx @rigstate/mcp"));
       process.exit(1);
     }
-    console.log(chalk22.dim(`Starting MCP server from: ${serverPath}`));
+    console.log(chalk23.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;
     }
@@ -3705,7 +3752,7 @@ function createMcpCommand() {
       stdio: ["inherit", "inherit", "inherit"]
     });
     worker.on("error", (err) => {
-      console.error(chalk22.red(`\u274C Failed to start MCP server: ${err.message}`));
+      console.error(chalk23.red(`\u274C Failed to start MCP server: ${err.message}`));
       process.exit(1);
     });
     worker.on("exit", (code) => {
@@ -3720,7 +3767,7 @@ function createMcpCommand() {
 // src/commands/nexus.ts
 init_esm_shims();
 import { Command as Command17 } from "commander";
-import chalk25 from "chalk";
+import chalk26 from "chalk";
 
 // src/nexus/dispatcher.ts
 init_esm_shims();
@@ -3729,7 +3776,7 @@ import { v4 as uuidv4 } from "uuid";
 
 // src/hive/gateway.ts
 init_esm_shims();
-import axios17 from "axios";
+import axios18 from "axios";
 
 // src/hive/scrubber.ts
 init_esm_shims();
@@ -3788,7 +3835,7 @@ var HiveScrubber = class {
 };
 
 // src/hive/gateway.ts
-import chalk23 from "chalk";
+import chalk24 from "chalk";
 var HiveGateway = class {
   client;
   enabled;
@@ -3798,9 +3845,9 @@ var HiveGateway = class {
   constructor(baseUrl, token) {
     this.enabled = !!token;
     if (!this.enabled) {
-      console.log(chalk23.dim("\u26A0\uFE0F Hive Gateway disabled (No Token provided). Running in localized mode."));
+      console.log(chalk24.dim("\u26A0\uFE0F Hive Gateway disabled (No Token provided). Running in localized mode."));
     }
-    this.client = axios17.create({
+    this.client = axios18.create({
       baseURL: baseUrl,
       headers: {
         "Authorization": `Bearer ${token}`,
@@ -3818,23 +3865,23 @@ var HiveGateway = class {
     if (!this.enabled) return false;
     const now = Date.now();
     if (now - this.lastSignalTime < this.MIN_INTERVAL_MS) {
-      console.warn(chalk23.yellow("\u23F3 Hive Gateway Throttled. Signal dropped to preventing spam."));
+      console.warn(chalk24.yellow("\u23F3 Hive Gateway Throttled. Signal dropped to preventing spam."));
       return false;
     }
     const scrubResult = HiveScrubber.scrub(signal.ruleContent);
     if (scrubResult.riskScore > 20) {
-      console.error(chalk23.red(`\u{1F6D1} HIVE BLOCKED: Signal contains sensitive data (Risk: ${scrubResult.riskScore})`));
+      console.error(chalk24.red(`\u{1F6D1} HIVE BLOCKED: Signal contains sensitive data (Risk: ${scrubResult.riskScore})`));
       return false;
     }
     try {
-      console.log(chalk23.blue(`\u{1F4E1} Uplinking to Hive... [${signal.vector}]`));
+      console.log(chalk24.blue(`\u{1F4E1} Uplinking to Hive... [${signal.vector}]`));
       const payload = { ...signal, ruleContent: scrubResult.sanitizedContent };
       await this.client.post("/signal", payload);
       this.lastSignalTime = now;
-      console.log(chalk23.green("\u2705 Signal Received by Hive Core. Knowledge Shared."));
+      console.log(chalk24.green("\u2705 Signal Received by Hive Core. Knowledge Shared."));
       return true;
     } catch (error) {
-      console.error(chalk23.red(`\u274C Hive Transmission Failed: ${error.message}`));
+      console.error(chalk24.red(`\u274C Hive Transmission Failed: ${error.message}`));
       return false;
     }
   }
@@ -3842,37 +3889,37 @@ var HiveGateway = class {
 
 // src/utils/logger.ts
 init_esm_shims();
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 var Logger = class {
   static formatMessage(level, message, context) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     let prefix = "";
     switch (level) {
       case "INFO" /* INFO */:
-        prefix = chalk24.blue(`[${"INFO" /* INFO */}]`);
+        prefix = chalk25.blue(`[${"INFO" /* INFO */}]`);
         break;
       case "WARN" /* WARN */:
-        prefix = chalk24.yellow(`[${"WARN" /* WARN */}]`);
+        prefix = chalk25.yellow(`[${"WARN" /* WARN */}]`);
         break;
       case "ERROR" /* ERROR */:
-        prefix = chalk24.red(`[${"ERROR" /* ERROR */}]`);
+        prefix = chalk25.red(`[${"ERROR" /* ERROR */}]`);
         break;
       case "DEBUG" /* DEBUG */:
-        prefix = chalk24.gray(`[${"DEBUG" /* DEBUG */}]`);
+        prefix = chalk25.gray(`[${"DEBUG" /* DEBUG */}]`);
         break;
     }
-    let output = `${chalk24.gray(timestamp)} ${prefix} ${message}`;
+    let output = `${chalk25.gray(timestamp)} ${prefix} ${message}`;
     if (context) {
       if (context instanceof Error) {
         output += `
-${chalk24.red(context.stack || context.message)}`;
+${chalk25.red(context.stack || context.message)}`;
       } else if (typeof context === "object") {
         try {
           output += `
-${chalk24.gray(JSON.stringify(context, null, 2))}`;
+${chalk25.gray(JSON.stringify(context, null, 2))}`;
         } catch (e) {
           output += `
-${chalk24.gray("[Circular or invalid object]")}`;
+${chalk25.gray("[Circular or invalid object]")}`;
         }
       } else {
         output += ` ${String(context)}`;
@@ -3992,10 +4039,10 @@ import inquirer3 from "inquirer";
 function createNexusCommand() {
   const command = new Command17("nexus");
   command.description("Interact with The Multi-Agent Nexus (Phase 8)").argument("<intent>", "The natural language instruction for the swarm").option("--dry-run", "Enable Dry-Run mode (Kill-Switch Active)", true).option("--force", "Disable Dry-Run mode (DANGEROUS)", false).action(async (intent, options) => {
-    console.log(chalk25.bold.magenta("\n\u{1F981} Welcome to The Nexus (Phase 8)\n"));
+    console.log(chalk26.bold.magenta("\n\u{1F981} Welcome to The Nexus (Phase 8)\n"));
     const dryRun = !options.force;
     if (!dryRun) {
-      console.log(chalk25.black.bgYellow(" WARNING ") + chalk25.yellow(" Dry-Run disabled! Eitri is authorized to write code."));
+      console.log(chalk26.black.bgYellow(" WARNING ") + chalk26.yellow(" Dry-Run disabled! Eitri is authorized to write code."));
       const { confirm } = await inquirer3.prompt([{
         type: "confirm",
         name: "confirm",
@@ -4016,26 +4063,26 @@ function createNexusCommand() {
     };
     const dispatcher = new NexusDispatcher(context);
     dispatcher.on("order:created", (o) => {
-      console.log(chalk25.blue(`\u{1F195} [${o.id.slice(0, 6)}] Order Created: `) + o.intent);
+      console.log(chalk26.blue(`\u{1F195} [${o.id.slice(0, 6)}] Order Created: `) + o.intent);
     });
     dispatcher.on("order:started", (o) => {
-      console.log(chalk25.yellow(`\u23F3 [${o.id.slice(0, 6)}] Processing...`));
+      console.log(chalk26.yellow(`\u23F3 [${o.id.slice(0, 6)}] Processing...`));
     });
     dispatcher.on("order:blocked", (o) => {
-      console.log(chalk25.red(`\u{1F6D1} [${o.id.slice(0, 6)}] BLOCKED by Kill-Switch`));
-      console.log(chalk25.dim(`   Target: ${o.targetAgent} | Action: ${o.action}`));
-      console.log(chalk25.dim("   Run with --force to execute automatically (NOT RECOMMENDED)."));
+      console.log(chalk26.red(`\u{1F6D1} [${o.id.slice(0, 6)}] BLOCKED by Kill-Switch`));
+      console.log(chalk26.dim(`   Target: ${o.targetAgent} | Action: ${o.action}`));
+      console.log(chalk26.dim("   Run with --force to execute automatically (NOT RECOMMENDED)."));
     });
-    dispatcher.on("agent:SINDRE", (o) => console.log(chalk25.cyan(`\u{1F916} Sindre (Vault): I'm on it! (${o.action})`)));
-    dispatcher.on("agent:EITRI", (o) => console.log(chalk25.green(`\u{1F477} Eitri (Smith): Ready to build! (${o.action})`)));
-    console.log(chalk25.dim("\u{1F9E0} Frank is analyzing your intent..."));
+    dispatcher.on("agent:SINDRE", (o) => console.log(chalk26.cyan(`\u{1F916} Sindre (Vault): I'm on it! (${o.action})`)));
+    dispatcher.on("agent:EITRI", (o) => console.log(chalk26.green(`\u{1F477} Eitri (Smith): Ready to build! (${o.action})`)));
+    console.log(chalk26.dim("\u{1F9E0} Frank is analyzing your intent..."));
     await new Promise((r) => setTimeout(r, 800));
     if (intent.toLowerCase().includes("db") || intent.toLowerCase().includes("database")) {
       await dispatcher.dispatch("FRANK", "SINDRE", intent, "db.analyze", { raw: intent });
     } else if (intent.toLowerCase().includes("create") || intent.toLowerCase().includes("code")) {
       await dispatcher.dispatch("FRANK", "EITRI", intent, "fs.write", { path: "src/demo.ts", content: "// demo" });
     } else {
-      console.log(chalk25.gray("Frank didn't understand. Try 'create file' or 'check database'."));
+      console.log(chalk26.gray("Frank didn't understand. Try 'create file' or 'check database'."));
     }
   });
   return command;
@@ -4049,31 +4096,31 @@ init_esm_shims();
 init_governance();
 init_config();
 import { Command as Command18 } from "commander";
-import chalk26 from "chalk";
-import axios18 from "axios";
+import chalk27 from "chalk";
+import axios19 from "axios";
 function createOverrideCommand() {
   const override = new Command18("override");
   override.description("Emergency Override for Governance Soft Locks").argument("<violationId>", 'ID of the violation to override (or "all")').requiredOption("-r, --reason <reason>", "Description of why this override is necessary").action(async (violationId, options) => {
     const { reason } = options;
-    console.log(chalk26.bold(`
+    console.log(chalk27.bold(`
 \u{1F513} Initiating Governance Override Protocol...`));
     const session = await getSessionState(process.cwd());
     if (session.status !== "SOFT_LOCK") {
-      console.log(chalk26.yellow("   Info: Session is not currently locked."));
+      console.log(chalk27.yellow("   Info: Session is not currently locked."));
       return;
     }
-    console.log(chalk26.dim(`   Active Violation: ${session.active_violation}`));
-    console.log(chalk26.dim(`   Reason Provided:  "${reason}"`));
+    console.log(chalk27.dim(`   Active Violation: ${session.active_violation}`));
+    console.log(chalk27.dim(`   Reason Provided:  "${reason}"`));
     const success = await performOverride(violationId, reason, process.cwd());
     if (success) {
-      console.log(chalk26.green(`   \u2705 Session UNLOCKED.`));
-      console.log(chalk26.dim(`   This event has been logged to the Mission Report.`));
+      console.log(chalk27.green(`   \u2705 Session UNLOCKED.`));
+      console.log(chalk27.dim(`   This event has been logged to the Mission Report.`));
       try {
         const projectId = getProjectId();
         if (projectId) {
           const apiUrl = getApiUrl();
           const apiKey = getApiKey();
-          await axios18.post(`${apiUrl}/api/v1/execution-logs`, {
+          await axios19.post(`${apiUrl}/api/v1/execution-logs`, {
             project_id: projectId,
             task_id: "OVERRIDE-" + Date.now(),
             task_title: `Governance Override: ${violationId}`,
@@ -4084,13 +4131,13 @@ function createOverrideCommand() {
           }, {
             headers: { Authorization: `Bearer ${apiKey}` }
           });
-          console.log(chalk26.dim(`   \u2601 Audit log synced to Cloud.`));
+          console.log(chalk27.dim(`   \u2601 Audit log synced to Cloud.`));
         }
       } catch (e) {
-        console.log(chalk26.dim(`   (Cloud audit sync failed: ${e.message})`));
+        console.log(chalk27.dim(`   (Cloud audit sync failed: ${e.message})`));
       }
     } else {
-      console.log(chalk26.red(`   \u{1F6D1} Override Failed. Check project configuration.`));
+      console.log(chalk27.red(`   \u{1F6D1} Override Failed. Check project configuration.`));
     }
   });
   return override;
@@ -4103,8 +4150,73 @@ async function checkVersion() {
 
 // src/index.ts
 import dotenv from "dotenv";
+
+// src/commands/idea.ts
+init_esm_shims();
+init_config();
+import { Command as Command19 } from "commander";
+import chalk28 from "chalk";
+import ora12 from "ora";
+import axios20 from "axios";
+import inquirer4 from "inquirer";
+function createIdeaCommand() {
+  return new Command19("idea").description("Capture a new idea or feature request").argument("[title]", "Quick title of the idea").option("-d, --desc <text>", "Detailed description").option("-t, --tag <tags>", "Comma separated tags (e.g. ui,auth)").action(async (title, options) => {
+    try {
+      const apiKey = getApiKey();
+      const apiUrl = getApiUrl();
+      const projectId = getProjectId();
+      if (!projectId) {
+        console.error(chalk28.red("Project context missing. Run rigstate link."));
+        process.exit(1);
+      }
+      let ideaTitle = title;
+      let ideaDesc = options.desc;
+      let tags = options.tag ? options.tag.split(",") : [];
+      if (!ideaTitle) {
+        const ans = await inquirer4.prompt([{
+          type: "input",
+          name: "title",
+          message: "Idea Title:"
+        }]);
+        ideaTitle = ans.title;
+      }
+      if (!ideaDesc) {
+        const ans = await inquirer4.prompt([{
+          type: "input",
+          name: "desc",
+          message: "Description (Optional):"
+        }]);
+        ideaDesc = ans.desc;
+      }
+      if (tags.length === 0) {
+      }
+      const spinner = ora12("Securing idea in the Lab...").start();
+      const response = await axios20.post(
+        `${apiUrl}/api/v1/ideas`,
+        {
+          project_id: projectId,
+          title: ideaTitle,
+          description: ideaDesc,
+          tags
+        },
+        { headers: { Authorization: `Bearer ${apiKey}` } }
+      );
+      if (response.data.success) {
+        spinner.succeed(chalk28.green("Idea Captured! \u{1F4A1}"));
+        console.log(chalk28.dim(`ID: ${response.data.data?.id || "Saved"}`));
+      } else {
+        throw new Error(response.data.error);
+      }
+    } catch (e) {
+      console.error(chalk28.red(`
+Failed to capture idea: ${e.message}`));
+    }
+  });
+}
+
+// src/index.ts
 dotenv.config();
-var program = new Command19();
+var program = new Command20();
 program.name("rigstate").description("CLI for Rigstate - The AI-Native Dev Studio").version("0.2.0");
 program.addCommand(createLoginCommand());
 program.addCommand(createLinkCommand());
@@ -4124,24 +4236,25 @@ program.addCommand(createMcpCommand());
 program.addCommand(createNexusCommand());
 program.addCommand(createSyncRulesCommand());
 program.addCommand(createOverrideCommand());
+program.addCommand(createIdeaCommand());
 program.hook("preAction", async () => {
   await checkVersion();
 });
 program.on("--help", () => {
   console.log("");
-  console.log(chalk27.bold("Examples:"));
+  console.log(chalk29.bold("Examples:"));
   console.log("");
-  console.log(chalk27.cyan("  $ rigstate login sk_rigstate_your_api_key"));
-  console.log(chalk27.dim("    Authenticate with your Rigstate API key"));
+  console.log(chalk29.cyan("  $ rigstate login sk_rigstate_your_api_key"));
+  console.log(chalk29.dim("    Authenticate with your Rigstate API key"));
   console.log("");
-  console.log(chalk27.cyan("  $ rigstate scan"));
-  console.log(chalk27.dim("    Scan the current directory"));
+  console.log(chalk29.cyan("  $ rigstate scan"));
+  console.log(chalk29.dim("    Scan the current directory"));
   console.log("");
-  console.log(chalk27.cyan("  $ rigstate scan ./src --project abc123"));
-  console.log(chalk27.dim("    Scan a specific directory with project ID"));
+  console.log(chalk29.cyan("  $ rigstate scan ./src --project abc123"));
+  console.log(chalk29.dim("    Scan a specific directory with project ID"));
   console.log("");
-  console.log(chalk27.cyan("  $ rigstate scan --json"));
-  console.log(chalk27.dim("    Output results in JSON format (useful for IDE extensions)"));
+  console.log(chalk29.cyan("  $ rigstate scan --json"));
+  console.log(chalk29.dim("    Output results in JSON format (useful for IDE extensions)"));
   console.log("");
 });
 program.parse(process.argv);