npm - @rigstate/cli - Versions diffs - 0.7.32 → 0.7.35 - Mend

@rigstate/cli 0.7.32 → 0.7.35

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/dist/index.cjs +831 -724
package/dist/index.cjs.map +1 -1
package/dist/index.js +870 -765
package/dist/index.js.map +1 -1
package/package.json +2 -2
package/src/commands/env.ts +3 -6
package/src/commands/focus.ts +3 -6
package/src/commands/init.ts +4 -5
package/src/commands/link.ts +8 -18
package/src/commands/plan.ts +20 -3
package/src/commands/sync-rules.ts +3 -4
package/src/commands/sync.ts +7 -12
package/src/commands/watch.ts +3 -7
package/src/utils/config.ts +79 -4
package/src/utils/manifest.ts +56 -5
package/src/utils/version.ts +6 -1

package/dist/index.js CHANGED Viewed

@@ -63,7 +63,28 @@ __export(config_exports, {
   setProjectId: () => setProjectId
 });
 import Conf from "conf";
+import chalk from "chalk";
+import fs from "fs";
+import path2 from "path";
 function getApiKey() {
+  try {
+    const cwd = process.cwd();
+    const manifestPaths = [
+      path2.join(cwd, ".rigstate", "identity.json"),
+      path2.join(cwd, ".rigstate")
+    ];
+    for (const manifestPath of manifestPaths) {
+      if (fs.existsSync(manifestPath) && fs.statSync(manifestPath).isFile()) {
+        const content = fs.readFileSync(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        if (manifest.api_key) return manifest.api_key;
+      }
+    }
+  } catch (e) {
+  }
+  if (process.env.RIGSTATE_API_KEY) {
+    return process.env.RIGSTATE_API_KEY;
+  }
   const apiKey = config.get("apiKey");
   if (!apiKey) {
     throw new Error(
@@ -76,12 +97,54 @@ function setApiKey(key) {
   config.set("apiKey", key);
 }
 function getProjectId() {
-  return config.get("projectId");
+  try {
+    const cwd = process.cwd();
+    const manifestPaths = [
+      path2.join(cwd, ".rigstate", "identity.json"),
+      path2.join(cwd, ".rigstate")
+    ];
+    for (const manifestPath of manifestPaths) {
+      if (fs.existsSync(manifestPath) && fs.statSync(manifestPath).isFile()) {
+        const content = fs.readFileSync(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        if (manifest.project_id) {
+          console.log(chalk.dim(`   [Auth] Context: Project ID ${manifest.project_id.substring(0, 8)}... (from ${path2.basename(manifestPath)})`));
+          return manifest.project_id;
+        }
+      }
+    }
+  } catch (e) {
+    console.log(chalk.red(`   [Error] Failed to read context: ${e.message}`));
+  }
+  if (process.env.RIGSTATE_PROJECT_ID) {
+    console.log(chalk.dim(`   [Auth] Context: Project ID ${process.env.RIGSTATE_PROJECT_ID.substring(0, 8)}... (from ENV)`));
+    return process.env.RIGSTATE_PROJECT_ID;
+  }
+  const globalId = config.get("projectId");
+  if (globalId) {
+    console.log(chalk.dim(`   [Auth] Context: Project ID ${globalId.substring(0, 8)}... (from GLOBAL CONFIG)`));
+  }
+  return globalId;
 }
 function setProjectId(projectId) {
   config.set("projectId", projectId);
 }
 function getApiUrl() {
+  try {
+    const cwd = process.cwd();
+    const manifestPaths = [
+      path2.join(cwd, ".rigstate", "identity.json"),
+      path2.join(cwd, ".rigstate")
+    ];
+    for (const manifestPath of manifestPaths) {
+      if (fs.existsSync(manifestPath) && fs.statSync(manifestPath).isFile()) {
+        const content = fs.readFileSync(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        if (manifest.api_url) return manifest.api_url;
+      }
+    }
+  } catch (e) {
+  }
   if (process.env.RIGSTATE_API_URL) {
     return process.env.RIGSTATE_API_URL;
   }
@@ -111,6 +174,65 @@ var init_config = __esm({
   }
 });
+// src/utils/manifest.ts
+var manifest_exports = {};
+__export(manifest_exports, {
+  loadManifest: () => loadManifest,
+  saveManifest: () => saveManifest
+});
+import fs2 from "fs/promises";
+import fsSync from "fs";
+import path3 from "path";
+async function loadManifest() {
+  const cwd = process.cwd();
+  const manifestPaths = [
+    path3.join(cwd, ".rigstate", "identity.json"),
+    path3.join(cwd, ".rigstate")
+  ];
+  for (const p of manifestPaths) {
+    try {
+      if (fsSync.existsSync(p) && fsSync.statSync(p).isFile()) {
+        const content = await fs2.readFile(p, "utf-8");
+        const data = JSON.parse(content);
+        return {
+          project_id: data.project?.id || data.project_id,
+          api_url: data.api_url,
+          linked_at: data.linked_at || data.project?.created_at,
+          api_key: data.api_key
+        };
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  return null;
+}
+async function saveManifest(data) {
+  const cwd = process.cwd();
+  const rigstatePath = path3.join(cwd, ".rigstate");
+  let targetFile = rigstatePath;
+  try {
+    const stats = await fs2.stat(rigstatePath);
+    if (stats.isDirectory()) {
+      targetFile = path3.join(rigstatePath, "identity.json");
+    }
+  } catch (e) {
+  }
+  const existing = await loadManifest() || {};
+  const merged = { ...existing, ...data };
+  if (targetFile.endsWith("identity.json")) {
+    await fs2.mkdir(rigstatePath, { recursive: true });
+  }
+  await fs2.writeFile(targetFile, JSON.stringify(merged, null, 2), "utf-8");
+  return targetFile;
+}
+var init_manifest = __esm({
+  "src/utils/manifest.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 // src/commands/env.ts
 var env_exports = {};
 __export(env_exports, {
@@ -118,17 +240,17 @@ __export(env_exports, {
   syncEnv: () => syncEnv
 });
 import { Command as Command2 } from "commander";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import ora from "ora";
-import fs from "fs/promises";
-import path2 from "path";
+import fs3 from "fs/promises";
+import path4 from "path";
 import axios from "axios";
 async function syncEnv(projectId, apiKey, apiUrl, silent = false) {
   if (!silent) {
     console.log("");
-    console.log(chalk2.bold.yellow("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
-    console.log(chalk2.bold.yellow("\u2551") + chalk2.bold.white("  \u{1F6E1}\uFE0F  RIGSTATE SOVEREIGN VAULT SYNC  \u{1F6E1}\uFE0F   ") + chalk2.bold.yellow("\u2551"));
-    console.log(chalk2.bold.yellow("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+    console.log(chalk3.bold.yellow("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+    console.log(chalk3.bold.yellow("\u2551") + chalk3.bold.white("  \u{1F6E1}\uFE0F  RIGSTATE SOVEREIGN VAULT SYNC  \u{1F6E1}\uFE0F   ") + chalk3.bold.yellow("\u2551"));
+    console.log(chalk3.bold.yellow("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
     console.log("");
   }
   const spinner = ora("Fetching secrets from Vault...").start();
@@ -145,15 +267,15 @@ async function syncEnv(projectId, apiKey, apiUrl, silent = false) {
     const secretCount = response.data.data.count || 0;
     if (secretCount === 0) {
       spinner.info("No secrets found in Vault for this project.");
-      if (!silent) console.log(chalk2.dim("  Add secrets via the Rigstate web interface."));
+      if (!silent) console.log(chalk3.dim("  Add secrets via the Rigstate web interface."));
       return true;
     }
-    spinner.succeed(`Retrieved ${chalk2.bold(secretCount)} secret(s)`);
-    const envFile = path2.resolve(process.cwd(), ".env.local");
+    spinner.succeed(`Retrieved ${chalk3.bold(secretCount)} secret(s)`);
+    const envFile = path4.resolve(process.cwd(), ".env.local");
     let existingContent = "";
     let existingKeys = /* @__PURE__ */ new Set();
     try {
-      existingContent = await fs.readFile(envFile, "utf-8");
+      existingContent = await fs3.readFile(envFile, "utf-8");
       existingContent.split("\n").forEach((line) => {
         const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
         if (match) existingKeys.add(match[1]);
@@ -185,25 +307,25 @@ async function syncEnv(projectId, apiKey, apiUrl, silent = false) {
       "# ==========================================",
       ""
     ].join("\n");
-    await fs.writeFile(envFile, header + vaultContent + "\n");
+    await fs3.writeFile(envFile, header + vaultContent + "\n");
     spinner.succeed("Written to .env.local");
     if (!silent) {
       console.log("");
-      console.log(chalk2.bold.green("\u2705 Environment synchronized successfully"));
+      console.log(chalk3.bold.green("\u2705 Environment synchronized successfully"));
       console.log("");
-      console.log(chalk2.dim("   Summary:"));
-      console.log(chalk2.green(`   + ${newCount} new`));
-      console.log(chalk2.yellow(`   ~ ${updatedCount} updated`));
-      console.log(chalk2.dim(`   = ${unchangedCount} unchanged`));
+      console.log(chalk3.dim("   Summary:"));
+      console.log(chalk3.green(`   + ${newCount} new`));
+      console.log(chalk3.yellow(`   ~ ${updatedCount} updated`));
+      console.log(chalk3.dim(`   = ${unchangedCount} unchanged`));
       console.log("");
-      console.log(chalk2.bold.yellow("\u26A0\uFE0F  Security Reminder:"));
-      console.log(chalk2.dim("   - Never commit .env.local to version control."));
-      console.log(chalk2.dim("   - Ensure .gitignore includes .env.local"));
+      console.log(chalk3.bold.yellow("\u26A0\uFE0F  Security Reminder:"));
+      console.log(chalk3.dim("   - Never commit .env.local to version control."));
+      console.log(chalk3.dim("   - Ensure .gitignore includes .env.local"));
       console.log("");
     }
     return true;
   } catch (e) {
-    spinner.fail(chalk2.red(`Failed to fetch secrets: ${e.message}`));
+    spinner.fail(chalk3.red(`Failed to fetch secrets: ${e.message}`));
     return false;
   }
 }
@@ -215,21 +337,17 @@ function createEnvPullCommand() {
     try {
       apiKey = getApiKey();
     } catch (e) {
-      console.error(chalk2.red('Not authenticated. Run "rigstate login" first.'));
+      console.error(chalk3.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
-      try {
-        const manifestPath = path2.join(process.cwd(), ".rigstate");
-        const content = await fs.readFile(manifestPath, "utf-8");
-        const manifest = JSON.parse(content);
-        projectId = manifest.project_id;
-      } catch (e) {
-      }
+      const { loadManifest: loadManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+      const manifest = await loadManifest2();
+      if (manifest?.project_id) projectId = manifest.project_id;
     }
     if (!projectId) {
-      console.error(chalk2.red('No project context. Run "rigstate link" first.'));
+      console.error(chalk3.red('No project context. Run "rigstate link" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -245,6 +363,18 @@ var init_env = __esm({
   }
 });
+// src/utils/version.ts
+async function checkVersion() {
+}
+var CLI_VERSION;
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+    init_esm_shims();
+    CLI_VERSION = "0.7.34";
+  }
+});
 // src/commands/sync-rules.ts
 var sync_rules_exports = {};
 __export(sync_rules_exports, {
@@ -252,11 +382,10 @@ __export(sync_rules_exports, {
   syncProjectRules: () => syncProjectRules
 });
 import { Command as Command3 } from "commander";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import ora2 from "ora";
 import axios2 from "axios";
-import { createRequire } from "module";
-async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
+async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false, version = CLI_VERSION) {
   const spinner = ora2("\u{1F6E1}\uFE0F Frank Protocol: Initializing retroactive sync...").start();
   let success = true;
   try {
@@ -271,7 +400,7 @@ async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
     const project = projectRes.data.data.projects[0];
     spinner.text = `Syncing rules for ${project.name}...`;
     if (dryRun) {
-      spinner.succeed(chalk3.yellow(`  [DRY-RUN] Would sync: ${project.name}`));
+      spinner.succeed(chalk4.yellow(`  [DRY-RUN] Would sync: ${project.name}`));
       return true;
     }
     const syncResponse = await axios2.post(`${apiUrl}/api/v1/rules/sync`, {
@@ -281,9 +410,9 @@ async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
     });
     if (syncResponse.data.success) {
       if (syncResponse.data.data.github_synced) {
-        spinner.succeed(chalk3.green(`  \u2705 ${project.name} [${project.id}] \u2192 GitHub synced`));
+        spinner.succeed(chalk4.green(`  \u2705 ${project.name} [${project.id}] \u2192 GitHub synced`));
       } else {
-        spinner.info(chalk3.blue(`  \u2139\uFE0F ${project.name} [${project.id}] \u2192 Rules generated (no GitHub)`));
+        spinner.info(chalk4.blue(`  \u2139\uFE0F ${project.name} [${project.id}] \u2192 Rules generated (no GitHub)`));
       }
       const files = syncResponse.data.data.files;
       if (files && Array.isArray(files)) {
@@ -294,7 +423,7 @@ async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
           await fs26.mkdir(path29.dirname(filePath), { recursive: true });
           await fs26.writeFile(filePath, file.content, "utf-8");
         }
-        console.log(chalk3.dim(`      \u{1F4BE} Wrote ${files.length} rule files to local .cursor/rules/`));
+        console.log(chalk4.dim(`      \u{1F4BE} Wrote ${files.length} rule files to local .cursor/rules/`));
         try {
           const masterPath = path29.join(process.cwd(), ".cursorrules");
           let masterContent = "";
@@ -308,7 +437,7 @@ async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
           const ruleList = files.map((f) => f.path).filter((p) => p.endsWith(".mdc")).map((p) => `- ${p}`).join("\n");
           const governanceBlock = `${START_MARKER}
 # \u{1F6E1}\uFE0F Rigstate Governance (Do not edit this block manually)
-# The following rules are enforced by the Rigstate Daemon (v${require2("../../package.json").version}).
+# The following rules are enforced by the Rigstate Daemon (v${version}).
 # Failure to adhere to these rules will be flagged during the 'work' cycle.
 # YOU MUST ADHERE TO THESE PROACTIVE RULES:
@@ -329,20 +458,20 @@ ${END_MARKER}`;
 ${governanceBlock}` : governanceBlock;
           }
           await fs26.writeFile(masterPath, newContent, "utf-8");
-          console.log(chalk3.dim("      \u{1F4DC} Updated master .cursorrules (Constitution enforced)"));
+          console.log(chalk4.dim("      \u{1F4DC} Updated master .cursorrules (Constitution enforced)"));
         } catch (e) {
-          console.warn(chalk3.yellow(`      \u26A0\uFE0F  Could not update .cursorrules: ${e.message}`));
+          console.warn(chalk4.yellow(`      \u26A0\uFE0F  Could not update .cursorrules: ${e.message}`));
         }
       }
       console.log("");
-      console.log(chalk3.cyan("\u{1F6E1}\uFE0F Frank Protocol v1.0 has been injected into the rules engine."));
-      console.log(chalk3.dim("   All new chats will now boot with mandatory governance checks."));
+      console.log(chalk4.cyan("\u{1F6E1}\uFE0F Frank Protocol v1.0 has been injected into the rules engine."));
+      console.log(chalk4.dim("   All new chats will now boot with mandatory governance checks."));
     } else {
-      spinner.warn(chalk3.yellow(`  \u26A0\uFE0F ${project.name} \u2192 ${syncResponse.data.error || "Unknown error"}`));
+      spinner.warn(chalk4.yellow(`  \u26A0\uFE0F ${project.name} \u2192 ${syncResponse.data.error || "Unknown error"}`));
       success = false;
     }
   } catch (e) {
-    spinner.fail(chalk3.red(`Sync failed: ${e.message}`));
+    spinner.fail(chalk4.red(`Sync failed: ${e.message}`));
     success = false;
   }
   return success;
@@ -354,25 +483,24 @@ function createSyncRulesCommand() {
     try {
       apiKey = getApiKey();
     } catch (e) {
-      console.error(chalk3.red('Not authenticated. Run "rigstate login" first.'));
+      console.error(chalk4.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     const apiUrl = getApiUrl();
     if (options.project) {
       await syncProjectRules(options.project, apiKey, apiUrl, options.dryRun);
     } else {
-      console.log(chalk3.yellow("Use --project <id> for now. (Mass sync logic awaiting migration)"));
+      console.log(chalk4.yellow("Use --project <id> for now. (Mass sync logic awaiting migration)"));
     }
   });
   return syncRules;
 }
-var require2;
 var init_sync_rules = __esm({
   "src/commands/sync-rules.ts"() {
     "use strict";
     init_esm_shims();
     init_config();
-    require2 = createRequire(import.meta.url);
+    init_version();
   }
 });
@@ -381,7 +509,7 @@ var suggest_exports = {};
 __export(suggest_exports, {
   suggestNextMove: () => suggestNextMove
 });
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import axios3 from "axios";
 async function suggestNextMove(projectId, apiKey, apiUrl) {
   try {
@@ -401,18 +529,18 @@ async function suggestNextMove(projectId, apiKey, apiUrl) {
     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)}`);
+    console.log(chalk5.bold("\u{1F3AF} TACTICAL INTELLIGENCE"));
+    console.log(chalk5.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`${chalk5.bold("Active Phase:")}  Implementation`);
+    console.log(`${chalk5.bold("Next Mission:")}  ${chalk5.cyan(nextTask.title)}`);
     if (nextTask.role) {
-      console.log(`${chalk4.bold("Required Role:")} ${chalk4.magenta(nextTask.role)}`);
+      console.log(`${chalk5.bold("Required Role:")} ${chalk5.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(chalk5.yellow("SUGGESTED NEXT MOVE:"));
+    console.log(chalk5.white(`> rigstate work start ${nextTask.id}   `) + chalk5.dim("(Start this task)"));
+    console.log(chalk5.white(`> rigstate chat "How do I solve T-${nextTask.step_number}?" `) + chalk5.dim("(Ask Architect)"));
+    console.log(chalk5.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     console.log("");
   } catch (e) {
   }
@@ -432,9 +560,9 @@ __export(skills_provisioner_exports, {
   provisionSkills: () => provisionSkills
 });
 import axios6 from "axios";
-import fs6 from "fs/promises";
-import path7 from "path";
-import chalk8 from "chalk";
+import fs8 from "fs/promises";
+import path9 from "path";
+import chalk9 from "chalk";
 async function provisionSkills(apiUrl, apiKey, projectId, rootDir) {
   const skills = [];
   try {
@@ -456,18 +584,18 @@ 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");
     const coreSkills = getRigstateStandardSkills();
     skills.push(...coreSkills);
   }
-  const skillsDir = path7.join(rootDir, ".agent", "skills");
-  await fs6.mkdir(skillsDir, { recursive: true });
+  const skillsDir = path9.join(rootDir, ".agent", "skills");
+  await fs8.mkdir(skillsDir, { recursive: true });
   for (const skill of skills) {
-    const skillDir = path7.join(skillsDir, skill.name);
-    await fs6.mkdir(skillDir, { recursive: true });
+    const skillDir = path9.join(skillsDir, skill.name);
+    await fs8.mkdir(skillDir, { recursive: true });
     const skillContent = `---
 name: ${skill.name}
 description: ${skill.description}
@@ -480,10 +608,10 @@ ${skill.content}
 ---
 *Provisioned by Rigstate CLI. Do not modify manually.*`;
-    const skillPath = path7.join(skillDir, "SKILL.md");
-    await fs6.writeFile(skillPath, skillContent, "utf-8");
+    const skillPath = path9.join(skillDir, "SKILL.md");
+    await fs8.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) {
@@ -498,16 +626,16 @@ ${skillBlocks}
 </available_skills>`;
 }
 async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
-  const rulesPath = path7.join(rootDir, ".cursorrules");
+  const rulesPath = path9.join(rootDir, ".cursorrules");
   let rulesContent = "";
   try {
-    rulesContent = await fs6.readFile(rulesPath, "utf-8");
+    rulesContent = await fs8.readFile(rulesPath, "utf-8");
   } catch (e) {
     return false;
   }
   const isProvisioned = rulesContent.includes(`<name>${skillId}</name>`) || rulesContent.includes(`.agent/skills/${skillId}`);
   if (isProvisioned) return false;
-  console.log(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);
@@ -522,10 +650,10 @@ async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
         rulesContent = rulesContent.slice(0, insertPoint + 3) + "\n\n" + skillsBlock + "\n" + rulesContent.slice(insertPoint + 3);
       }
     }
-    await fs6.writeFile(rulesPath, rulesContent, "utf-8");
+    await fs8.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;
   }
 }
@@ -546,13 +674,13 @@ __export(governance_exports, {
   performOverride: () => performOverride,
   setSoftLock: () => setSoftLock
 });
-import fs7 from "fs/promises";
-import path8 from "path";
-import chalk9 from "chalk";
+import fs9 from "fs/promises";
+import path10 from "path";
+import chalk10 from "chalk";
 async function getGovernanceConfig(rootDir = process.cwd()) {
   try {
-    const configPath = path8.join(rootDir, "rigstate.config.json");
-    const content = await fs7.readFile(configPath, "utf-8");
+    const configPath = path10.join(rootDir, "rigstate.config.json");
+    const content = await fs9.readFile(configPath, "utf-8");
     const userConfig = JSON.parse(content);
     return {
       governance: {
@@ -566,37 +694,37 @@ async function getGovernanceConfig(rootDir = process.cwd()) {
 }
 async function getSessionState(rootDir = process.cwd()) {
   try {
-    const sessionPath = path8.join(rootDir, ".rigstate", "session.json");
-    const content = await fs7.readFile(sessionPath, "utf-8");
+    const sessionPath = path10.join(rootDir, ".rigstate", "session.json");
+    const content = await fs9.readFile(sessionPath, "utf-8");
     return JSON.parse(content);
   } catch (e) {
     return DEFAULT_SESSION;
   }
 }
 async function setSoftLock(reason, violationId, rootDir = process.cwd()) {
-  const sessionPath = path8.join(rootDir, ".rigstate", "session.json");
+  const sessionPath = path10.join(rootDir, ".rigstate", "session.json");
   const state = {
     status: "SOFT_LOCK",
     active_violation: violationId,
     lock_reason: reason,
     last_updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs7.mkdir(path8.dirname(sessionPath), { recursive: true });
-  await fs7.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs9.mkdir(path10.dirname(sessionPath), { recursive: true });
+  await fs9.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
 }
 async function clearSoftLock(rootDir = process.cwd()) {
-  const sessionPath = path8.join(rootDir, ".rigstate", "session.json");
+  const sessionPath = path10.join(rootDir, ".rigstate", "session.json");
   const state = {
     ...DEFAULT_SESSION,
     last_updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs7.mkdir(path8.dirname(sessionPath), { recursive: true });
-  await fs7.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs9.mkdir(path10.dirname(sessionPath), { recursive: true });
+  await fs9.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
 }
 async function performOverride(violationId, reason, rootDir = process.cwd()) {
   const config2 = await getGovernanceConfig(rootDir);
   if (!config2.governance.allow_overrides) {
-    console.log(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);
@@ -633,22 +761,22 @@ var watchdog_exports = {};
 __export(watchdog_exports, {
   runGuardianWatchdog: () => runGuardianWatchdog
 });
-import fs8 from "fs/promises";
-import path9 from "path";
-import chalk10 from "chalk";
+import fs10 from "fs/promises";
+import path11 from "path";
+import chalk11 from "chalk";
 import axios7 from "axios";
 async function countLines(filePath) {
   try {
-    const content = await fs8.readFile(filePath, "utf-8");
+    const content = await fs10.readFile(filePath, "utf-8");
     return content.split("\n").length;
   } catch (e) {
     return 0;
   }
 }
 async function getFiles(dir, extension) {
-  const entries = await fs8.readdir(dir, { withFileTypes: true });
+  const entries = await fs10.readdir(dir, { withFileTypes: true });
   const files = await Promise.all(entries.map(async (entry) => {
-    const res = path9.resolve(dir, entry.name);
+    const res = path11.resolve(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".next" || entry.name === "dist") return [];
       return getFiles(res, extension);
@@ -676,8 +804,8 @@ async function fetchRulesFromApi(projectId) {
     }
   } catch (error) {
     try {
-      const cachePath = path9.join(process.cwd(), CACHE_FILE);
-      const content = await fs8.readFile(cachePath, "utf-8");
+      const cachePath = path11.join(process.cwd(), CACHE_FILE);
+      const content = await fs10.readFile(cachePath, "utf-8");
       const cached = JSON.parse(content);
       if (cached.settings) {
         return {
@@ -696,7 +824,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";
@@ -706,47 +834,47 @@ 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 = path9.join(rootPath, "apps", "web", "src");
+  const webSrc = path11.join(rootPath, "apps", "web", "src");
   try {
-    await fs8.access(webSrc);
+    await fs10.access(webSrc);
     scanTarget = webSrc;
   } catch {
   }
-  console.log(chalk10.dim(`Scanning target: ${path9.relative(process.cwd(), scanTarget)}`));
+  console.log(chalk11.dim(`Scanning target: ${path11.relative(process.cwd(), scanTarget)}`));
   const files = await getFiles(scanTarget, targetExtensions);
   let violations = 0;
   let warnings = 0;
   const results = [];
   for (const file of files) {
     const lines = await countLines(file);
-    const relPath = path9.relative(rootPath, file);
+    const relPath = path11.relative(rootPath, file);
     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);
       }
     }
@@ -769,9 +897,9 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
       }, {
         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")));
     }
   }
 }
@@ -1668,7 +1796,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@rigstate/cli",
-      version: "0.7.32",
+      version: "0.7.34",
       description: "Rigstate CLI - Code audit, sync and supervision tool",
       type: "module",
       main: "./dist/index.js",
@@ -1725,32 +1853,32 @@ var require_package = __commonJS({
 // src/index.ts
 init_esm_shims();
 import { Command as Command24 } from "commander";
-import chalk35 from "chalk";
+import chalk36 from "chalk";
 // src/commands/login.ts
 init_esm_shims();
 init_config();
 import { Command } from "commander";
-import chalk from "chalk";
+import chalk2 from "chalk";
 function createLoginCommand() {
   return new Command("login").description("Authenticate with your Rigstate API key").argument("<api-key>", "Your Rigstate API key (starts with sk_)").action(async (apiKey) => {
     try {
       if (!apiKey || !apiKey.startsWith("sk_rigstate_")) {
-        console.error(chalk.red("\u274C Invalid API key format"));
-        console.error(chalk.dim('API keys must start with "sk_rigstate_"'));
+        console.error(chalk2.red("\u274C Invalid API key format"));
+        console.error(chalk2.dim('API keys must start with "sk_rigstate_"'));
         process.exit(1);
       }
       setApiKey(apiKey);
-      console.log(chalk.green("\u2705 Successfully logged in!"));
+      console.log(chalk2.green("\u2705 Successfully logged in!"));
       console.log(
-        chalk.dim(
+        chalk2.dim(
           `
 Your API key has been securely stored. You can now use "rigstate scan" to audit your code.`
         )
       );
-      console.log(chalk.bold("\n\u{1F916} Cursor MCP Configuration"));
-      console.log(chalk.dim("Copy and paste this into Cursor Settings -> Features -> MCP:"));
-      console.log(chalk.cyan(`
+      console.log(chalk2.bold("\n\u{1F916} Cursor MCP Configuration"));
+      console.log(chalk2.dim("Copy and paste this into Cursor Settings -> Features -> MCP:"));
+      console.log(chalk2.cyan(`
 {
   "mcpServers": {
     "rigstate": {
@@ -1767,7 +1895,7 @@ Your API key has been securely stored. You can now use "rigstate scan" to audit
 }`));
     } catch (error) {
       console.error(
-        chalk.red("\u274C Login failed:"),
+        chalk2.red("\u274C Login failed:"),
         error instanceof Error ? error.message : "Unknown error"
       );
       process.exit(1);
@@ -1779,24 +1907,24 @@ Your API key has been securely stored. You can now use "rigstate scan" to audit
 init_esm_shims();
 init_config();
 import { Command as Command4 } from "commander";
-import fs2 from "fs/promises";
-import path3 from "path";
-import chalk5 from "chalk";
+import fs4 from "fs/promises";
+import path5 from "path";
+import chalk6 from "chalk";
 import os from "os";
 function createLinkCommand() {
   return new Command4("link").description("Link current directory to a Rigstate project").argument("[projectId]", "Project ID to link").action(async (projectId) => {
     try {
-      const globalPath = path3.join(os.homedir(), ".rigstate", "config.json");
-      const globalData = await fs2.readFile(globalPath, "utf-8").catch(() => null);
+      const globalPath = path5.join(os.homedir(), ".rigstate", "config.json");
+      const globalData = await fs4.readFile(globalPath, "utf-8").catch(() => null);
       if (globalData) {
         const config2 = JSON.parse(globalData);
-        const cwd = process.cwd();
-        if (config2.overrides && config2.overrides[cwd]) {
-          const overrideId = config2.overrides[cwd];
-          console.warn(chalk5.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
+        const cwd2 = process.cwd();
+        if (config2.overrides && config2.overrides[cwd2]) {
+          const overrideId = config2.overrides[cwd2];
+          console.warn(chalk6.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
           if (!projectId) projectId = overrideId;
           else if (projectId !== overrideId) {
-            console.warn(chalk5.red(`Ignoring provided ID ${projectId}. Using override.`));
+            console.warn(chalk6.red(`Ignoring provided ID ${projectId}. Using override.`));
             projectId = overrideId;
           }
         }
@@ -1810,16 +1938,16 @@ function createLinkCommand() {
         const apiKey = getApiKey();
         const apiUrl = getApiUrl();
         if (!apiKey) {
-          console.error(chalk5.red('Not authenticated. Please run "rigstate login" or provide a Project ID.'));
+          console.error(chalk6.red('Not authenticated. Please run "rigstate login" or provide a Project ID.'));
           process.exit(1);
         }
-        console.log(chalk5.dim("Fetching your projects..."));
+        console.log(chalk6.dim("Fetching your projects..."));
         const axios24 = (await import("axios")).default;
         const response = await axios24.get(`${apiUrl}/api/v1/projects`, {
           headers: { Authorization: `Bearer ${apiKey}` }
         });
         if (!response.data.success || !response.data.data.projects?.length) {
-          console.error(chalk5.yellow("No projects found. Create one at https://app.rigstate.com"));
+          console.error(chalk6.yellow("No projects found. Create one at https://app.rigstate.com"));
           process.exit(1);
         }
         const choices = response.data.data.projects.map((p) => ({
@@ -1834,54 +1962,49 @@ function createLinkCommand() {
         }]);
         projectId = answer.id;
       } catch (e) {
-        console.error(chalk5.red(`Failed to fetch projects: ${e.message}`));
+        console.error(chalk6.red(`Failed to fetch projects: ${e.message}`));
         console.error("Please provide project ID manually: rigstate link <id>");
         process.exit(1);
       }
     }
-    const manifestPath = path3.join(process.cwd(), ".rigstate");
-    const content = {
-      project_id: projectId,
-      linked_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const currentUrl = getApiUrl();
-    if (currentUrl !== "https://app.rigstate.com") {
-      content.api_url = currentUrl;
-    }
+    const cwd = process.cwd();
     try {
-      await fs2.mkdir(path3.dirname(manifestPath), { recursive: true });
-      await fs2.writeFile(manifestPath, JSON.stringify(content, null, 2), "utf-8");
-      console.log(chalk5.green(`\u2714 Linked to project ID: ${projectId}`));
-      console.log(chalk5.dim(`Created local context manifest at .rigstate`));
+      const { saveManifest: saveManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+      const targetFile = await saveManifest2({
+        project_id: projectId,
+        linked_at: (/* @__PURE__ */ new Date()).toISOString(),
+        api_url: getApiUrl() !== "https://app.rigstate.com" ? getApiUrl() : void 0
+      });
+      console.log(chalk6.green(`\u2714 Linked to project ID: ${projectId}`));
+      console.log(chalk6.dim(`Created local identity manifest at ${path5.relative(cwd, targetFile)}`));
       console.log("");
-      console.log(chalk5.bold("\u{1F916} Rigstate Automation Detected"));
+      console.log(chalk6.bold("\u{1F916} Rigstate Automation Detected"));
       console.log("");
-      const { getApiKey: _getApiKey, getApiUrl: _getApiUrl } = await Promise.resolve().then(() => (init_config(), config_exports));
       const apiKey = getApiKey();
       const apiUrl = getApiUrl();
       if (apiKey) {
-        console.log(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  Injecting Guardian hooks & Safety nets..."));
+        console.log(chalk6.blue("\u{1F6E1}\uFE0F  Injecting Guardian hooks & Safety nets..."));
         await installHooks(process.cwd());
         await hardenGitIgnore(process.cwd());
         console.log("");
-        console.log(chalk5.bold.green("\u{1F680} Link Complete! Your environment is ready."));
+        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(chalk5.bold.green("\u{1F680} Link Complete!"));
+        console.log(chalk6.bold.green("\u{1F680} Link Complete!"));
       }
     } 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}`));
       }
     }
   });
@@ -1910,15 +2033,15 @@ async function hardenGitIgnore(cwd) {
     }
     const missing = REQUIRED_IGNORES.filter((line) => !content.includes(line) && !line.startsWith("#"));
     if (missing.length > 0) {
-      console.log(chalk5.dim("   Configuring .gitignore for Rigstate safety..."));
+      console.log(chalk6.dim("   Configuring .gitignore for Rigstate safety..."));
       const toAppend = "\n\n" + REQUIRED_IGNORES.join("\n") + "\n";
       await fs26.writeFile(ignorePath, content + toAppend, "utf-8");
-      console.log(chalk5.green("   \u2714 .gitignore updated (Artifacts protected)"));
+      console.log(chalk6.green("   \u2714 .gitignore updated (Artifacts protected)"));
     } else {
-      console.log(chalk5.green("   \u2714 .gitignore already hardened"));
+      console.log(chalk6.green("   \u2714 .gitignore already hardened"));
     }
   } catch (e) {
-    console.warn(chalk5.yellow(`   Could not update .gitignore: ${e.message}`));
+    console.warn(chalk6.yellow(`   Could not update .gitignore: ${e.message}`));
   }
 }
 async function installHooks(cwd) {
@@ -1927,7 +2050,7 @@ async function installHooks(cwd) {
   try {
     await fs26.access(path29.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 = path29.join(cwd, ".husky");
@@ -1938,7 +2061,7 @@ async function installHooks(cwd) {
       await fs26.access(preCommitPath);
       const content = await fs26.readFile(preCommitPath, "utf-8");
       if (content.includes("rigstate")) {
-        console.log(chalk5.green("   \u2714 Git hooks already active"));
+        console.log(chalk6.green("   \u2714 Git hooks already active"));
       } else {
         shouldInstall = true;
       }
@@ -1967,10 +2090,10 @@ exit $?
       } else {
         await fs26.writeFile(preCommitPath, PRE_COMMIT_SCRIPT2, { mode: 493 });
       }
-      console.log(chalk5.green("   \u2714 Applied Guardian protection (git-hooks)"));
+      console.log(chalk6.green("   \u2714 Applied Guardian protection (git-hooks)"));
     }
   } catch (e) {
-    console.log(chalk5.dim("   (Skipped hooks: " + e.message + ")"));
+    console.log(chalk6.dim("   (Skipped hooks: " + e.message + ")"));
   }
 }
 async function fileExists(path29) {
@@ -1987,21 +2110,21 @@ async function fileExists(path29) {
 init_esm_shims();
 init_config();
 import { Command as Command5 } from "commander";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import ora3 from "ora";
 import axios4 from "axios";
 import { glob } from "glob";
-import fs4 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path7 from "path";
 // src/utils/files.ts
 init_esm_shims();
-import fs3 from "fs/promises";
-import path4 from "path";
+import fs5 from "fs/promises";
+import path6 from "path";
 async function readGitignore(dir) {
-  const gitignorePath = path4.join(dir, ".gitignore");
+  const gitignorePath = path6.join(dir, ".gitignore");
   try {
-    const content = await fs3.readFile(gitignorePath, "utf-8");
+    const content = await fs5.readFile(gitignorePath, "utf-8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error) {
     return [];
@@ -2063,7 +2186,7 @@ function isCodeFile(filePath) {
     ".vue",
     ".svelte"
   ];
-  const ext = path4.extname(filePath).toLowerCase();
+  const ext = path6.extname(filePath).toLowerCase();
   return codeExtensions.includes(ext);
 }
@@ -2077,26 +2200,26 @@ 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 = path5.resolve(process.cwd(), targetPath);
-      spinner.start(`Scanning ${chalk6.cyan(scanPath)}...`);
+      const scanPath = path7.resolve(process.cwd(), targetPath);
+      spinner.start(`Scanning ${chalk7.cyan(scanPath)}...`);
       const gitignorePatterns = await readGitignore(scanPath);
-      const pattern = path5.join(scanPath, "**/*");
+      const pattern = path7.join(scanPath, "**/*");
       const allFiles = await glob(pattern, {
         nodir: true,
         dot: false,
         ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"]
       });
       const codeFiles = allFiles.filter((file) => {
-        const relativePath = path5.relative(scanPath, file);
+        const relativePath = path7.relative(scanPath, file);
         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...`;
@@ -2105,10 +2228,10 @@ function createScanCommand() {
       const severityCounts = {};
       for (let i = 0; i < codeFiles.length; i++) {
         const filePath = codeFiles[i];
-        const relativePath = path5.relative(scanPath, filePath);
+        const relativePath = path7.relative(scanPath, filePath);
         spinner.text = `Scanning ${i + 1}/${codeFiles.length}: ${relativePath}`;
         try {
-          const content = await fs4.readFile(filePath, "utf-8");
+          const content = await fs6.readFile(filePath, "utf-8");
           const response = await axios4.post(
             `${apiUrl}/api/v1/audit`,
             {
@@ -2144,15 +2267,15 @@ function createScanCommand() {
           }
         } catch (fileError) {
           if (axios4.isAxiosError(fileError)) {
-            console.warn(chalk6.yellow(`
+            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: {
@@ -2167,21 +2290,21 @@ function createScanCommand() {
         printPrettyResults(aggregatedResponse);
       }
     } catch (error) {
-      spinner.fail(chalk6.red("\u274C Scan failed"));
+      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"
         );
       }
@@ -2191,10 +2314,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]) => {
@@ -2203,39 +2326,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;
   }
 }
@@ -2243,12 +2366,12 @@ function getSeverityColor(severity) {
 init_esm_shims();
 init_config();
 import { Command as Command6 } from "commander";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import ora4 from "ora";
 import axios5 from "axios";
 import { glob as glob2 } from "glob";
-import fs5 from "fs/promises";
-import path6 from "path";
+import fs7 from "fs/promises";
+import path8 from "path";
 import inquirer from "inquirer";
 import * as Diff from "diff";
 function createFixCommand() {
@@ -2259,31 +2382,31 @@ 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 = path6.resolve(process.cwd(), targetPath);
+      const scanPath = path8.resolve(process.cwd(), targetPath);
       const gitignorePatterns = await readGitignore(scanPath);
-      const pattern = path6.join(scanPath, "**/*");
+      const pattern = path8.join(scanPath, "**/*");
       const allFiles = await glob2(pattern, { nodir: true, dot: false, ignore: ["**/node_modules/**", "**/.git/**"] });
       const codeFiles = allFiles.filter((file) => {
-        const relativePath = path6.relative(scanPath, file);
+        const relativePath = path8.relative(scanPath, file);
         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++) {
         const filePath = codeFiles[i];
-        const relativePath = path6.relative(scanPath, filePath);
+        const relativePath = path8.relative(scanPath, filePath);
         spinner.start(`Analyzing ${relativePath}...`);
         try {
-          const content = await fs5.readFile(filePath, "utf-8");
+          const content = await fs7.readFile(filePath, "utf-8");
           const response = await axios5.post(
             `${apiUrl}/api/v1/audit`,
             { content, file_path: relativePath, project_id: projectId },
@@ -2294,22 +2417,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 fs5.writeFile(filePath, issue.fixed_content);
-                console.log(chalk7.green(`\u2705 Fixed applied!`));
+                await fs7.writeFile(filePath, issue.fixed_content);
+                console.log(chalk8.green(`\u2705 Fixed applied!`));
                 fixedCount++;
                 if (issue.related_step_id) {
                   const { completeStep } = await inquirer.prompt([{
@@ -2325,15 +2448,15 @@ ${chalk7.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
                         { 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 {
@@ -2343,11 +2466,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);
@@ -2359,11 +2482,11 @@ ${chalk7.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
 init_esm_shims();
 init_config();
 import { Command as Command7 } from "commander";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import ora5 from "ora";
 import axios8 from "axios";
-import fs9 from "fs/promises";
-import path10 from "path";
+import fs11 from "fs/promises";
+import path12 from "path";
 function createSyncCommand() {
   const sync = new Command7("sync");
   sync.description("Synchronize local state with Rigstate Cloud").option("-p, --project <id>", "Specify Project ID (saves to config automatically)").action(async (options) => {
@@ -2378,13 +2501,9 @@ function createSyncCommand() {
       }
       let projectId = options.project;
       if (!projectId) {
-        try {
-          const manifestPath = path10.join(process.cwd(), ".rigstate");
-          const manifestContent = await fs9.readFile(manifestPath, "utf-8");
-          const manifest = JSON.parse(manifestContent);
-          if (manifest.project_id) projectId = manifest.project_id;
-        } catch (e) {
-        }
+        const { loadManifest: loadManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+        const manifest = await loadManifest2();
+        if (manifest?.project_id) projectId = manifest.project_id;
       }
       if (!projectId) projectId = getProjectId();
       if (options.project) {
@@ -2404,31 +2523,30 @@ function createSyncCommand() {
       }
       const { roadmap, project } = response.data.data;
       const timestamp = response.data.timestamp;
-      const targetPath = path10.join(process.cwd(), "roadmap.json");
+      const targetPath = path12.join(process.cwd(), "roadmap.json");
       const fileContent = JSON.stringify({
         project,
         last_synced: timestamp,
         roadmap
       }, null, 2);
-      await fs9.writeFile(targetPath, fileContent, "utf-8");
+      await fs11.writeFile(targetPath, fileContent, "utf-8");
       try {
-        const manifestPath = path10.join(process.cwd(), ".rigstate");
-        const manifestContent = {
+        const { saveManifest: saveManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+        await saveManifest2({
           project_id: projectId,
-          project_name: project,
-          last_synced: timestamp,
+          linked_at: timestamp,
+          // Using timestamp as linked_at for consistency
           api_url: apiUrl
-        };
-        await fs9.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());
-        const cursorRulesPath = path10.join(process.cwd(), ".cursorrules");
+        const cursorRulesPath = path12.join(process.cwd(), ".cursorrules");
         try {
-          let rulesContent = await fs9.readFile(cursorRulesPath, "utf-8");
+          let rulesContent = await fs11.readFile(cursorRulesPath, "utf-8");
           const skillsBlock = generateSkillsDiscoveryBlock2(skills);
           if (rulesContent.includes("<available_skills>")) {
             rulesContent = rulesContent.replace(
@@ -2441,17 +2559,17 @@ function createSyncCommand() {
               rulesContent = rulesContent.slice(0, insertPoint + 3) + "\n\n" + skillsBlock + "\n" + rulesContent.slice(insertPoint + 3);
             }
           }
-          await fs9.writeFile(cursorRulesPath, rulesContent, "utf-8");
-          console.log(chalk11.dim(`  Updated .cursorrules with skills discovery block`));
+          await fs11.writeFile(cursorRulesPath, rulesContent, "utf-8");
+          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 = path10.join(process.cwd(), ".rigstate", "logs", "last_execution.json");
+        const logPath = path12.join(process.cwd(), ".rigstate", "logs", "last_execution.json");
         try {
-          const logContent = await fs9.readFile(logPath, "utf-8");
+          const logContent = await fs11.readFile(logPath, "utf-8");
           const logData = JSON.parse(logContent);
           if (logData.task_summary) {
             await axios8.post(`${apiUrl}/api/v1/execution-logs`, {
@@ -2461,8 +2579,8 @@ function createSyncCommand() {
             }, {
               headers: { Authorization: `Bearer ${apiKey}` }
             });
-            await fs9.unlink(logPath);
-            console.log(chalk11.dim(`\u2714 Mission Report uploaded.`));
+            await fs11.unlink(logPath);
+            console.log(chalk12.dim(`\u2714 Mission Report uploaded.`));
           }
         } catch (e) {
           if (e.code !== "ENOENT") {
@@ -2470,12 +2588,12 @@ 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 axios8.get(`${apiUrl}/api/v1/agent/bridge`, {
           params: { project_id: projectId },
@@ -2486,10 +2604,10 @@ function createSyncCommand() {
           const pending = tasks.filter((t) => t.status === "PENDING");
           const approved = tasks.filter((t) => t.status === "APPROVED");
           if (pending.length > 0 || approved.length > 0) {
-            console.log(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) {
@@ -2500,25 +2618,25 @@ function createSyncCommand() {
             }, {
               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 = path10.join(process.cwd(), "supabase", "migrations");
-        const files = await fs9.readdir(migrationDir);
+        const migrationDir = path12.join(process.cwd(), "supabase", "migrations");
+        const files = await fs11.readdir(migrationDir);
         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) {
       }
@@ -2530,15 +2648,15 @@ function createSyncCommand() {
         );
         if (vaultResponse.data.success) {
           const vaultContent = vaultResponse.data.data.content || "";
-          const localEnvPath = path10.join(process.cwd(), ".env.local");
+          const localEnvPath = path12.join(process.cwd(), ".env.local");
           let localContent = "";
           try {
-            localContent = await fs9.readFile(localEnvPath, "utf-8");
+            localContent = await fs11.readFile(localEnvPath, "utf-8");
           } 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",
@@ -2546,25 +2664,25 @@ function createSyncCommand() {
               default: false
             }]));
             if (syncVault) {
-              await fs9.writeFile(localEnvPath, vaultContent, "utf-8");
-              console.log(chalk11.green("   \u2705 .env.local synchronized with Vault."));
+              await fs11.writeFile(localEnvPath, vaultContent, "utf-8");
+              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 (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")));
       }
     }
   });
@@ -2580,65 +2698,50 @@ 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();
+init_manifest();
+init_config();
 import { Command as Command8 } from "commander";
-import chalk12 from "chalk";
-import fs11 from "fs/promises";
-import path12 from "path";
+import chalk13 from "chalk";
+import fs12 from "fs/promises";
+import path13 from "path";
 import ora6 from "ora";
 import { execSync } from "child_process";
-// src/utils/manifest.ts
-init_esm_shims();
-import fs10 from "fs/promises";
-import path11 from "path";
-async function loadManifest() {
-  try {
-    const manifestPath = path11.join(process.cwd(), ".rigstate");
-    const content = await fs10.readFile(manifestPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-// src/commands/init.ts
-init_config();
 import axios9 from "axios";
 function createInitCommand() {
   return new Command8("init").description("Initialize or link a Rigstate project (interactive mode available)").argument("[project-id]", "ID of the project to link (optional, prompts if not provided)").option("-f, --force", "Overwrite existing .cursorrules file").option("--rules-only", "Only regenerate .cursorrules without interactive setup").action(async (projectIdArg, options) => {
@@ -2647,7 +2750,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();
@@ -2744,7 +2847,7 @@ 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...");
@@ -2756,13 +2859,13 @@ function createInitCommand() {
                 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 {
@@ -2772,28 +2875,27 @@ function createInitCommand() {
         spinner.start(`Linking to project ID: ${projectId}...`);
       }
       setProjectId(projectId);
-      const manifestPath = path12.join(process.cwd(), ".rigstate");
-      const manifestContent = {
+      const { saveManifest: saveManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+      await saveManifest2({
         project_id: projectId,
-        last_linked: (/* @__PURE__ */ new Date()).toISOString(),
+        linked_at: (/* @__PURE__ */ new Date()).toISOString(),
         api_url: apiUrl
-      };
-      await fs11.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
+      });
       try {
-        await fs11.access(".git");
+        await fs12.access(".git");
       } catch {
         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));
     }
   });
 }
@@ -2808,67 +2910,68 @@ async function generateRules(apiUrl, apiKey, projectId, force, spinner) {
     if (response.data.success || response.data.files) {
       const files = response.data.files || [];
       if (files.length === 0 && response.data.rules) {
-        const rulesPath = path12.join(process.cwd(), ".cursorrules");
-        await fs11.writeFile(rulesPath, response.data.rules, "utf-8");
-        spinner.succeed(chalk12.green("\u2714 Generated .cursorrules (legacy mode)"));
+        const rulesPath = path13.join(process.cwd(), ".cursorrules");
+        await fs12.writeFile(rulesPath, response.data.rules, "utf-8");
+        spinner.succeed(chalk13.green("\u2714 Generated .cursorrules (legacy mode)"));
         return;
       }
       for (const file of files) {
-        const targetPath = path12.join(process.cwd(), file.path);
-        const targetDir = path12.dirname(targetPath);
-        await fs11.mkdir(targetDir, { recursive: true });
+        const targetPath = path13.join(process.cwd(), file.path);
+        const targetDir = path13.dirname(targetPath);
+        await fs12.mkdir(targetDir, { recursive: true });
         try {
-          await fs11.access(targetPath);
+          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 {
         }
-        await fs11.writeFile(targetPath, file.content, "utf-8");
+        await fs12.writeFile(targetPath, file.content, "utf-8");
       }
       if (files.length > 0) {
-        const legacyPath = path12.join(process.cwd(), ".cursorrules");
+        const legacyPath = path13.join(process.cwd(), ".cursorrules");
         try {
-          const stats = await fs11.stat(legacyPath);
+          const stats = await fs12.stat(legacyPath);
           if (stats.isFile()) {
-            await fs11.rename(legacyPath, `${legacyPath}.bak`);
-            console.log(chalk12.dim("  Moved legacy .cursorrules to .cursorrules.bak"));
+            await fs12.rename(legacyPath, `${legacyPath}.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}`));
   }
 }
 // src/commands/check.ts
 init_esm_shims();
 init_config();
+init_manifest();
 import { Command as Command9 } from "commander";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import ora7 from "ora";
 import axios10 from "axios";
 import { glob as glob3 } from "glob";
-import fs13 from "fs/promises";
-import path14 from "path";
+import fs14 from "fs/promises";
+import path15 from "path";
 import { execSync as execSync2 } from "child_process";
 // src/utils/rule-engine.ts
 init_esm_shims();
-import fs12 from "fs/promises";
-import path13 from "path";
-import chalk13 from "chalk";
+import fs13 from "fs/promises";
+import path14 from "path";
+import chalk14 from "chalk";
 async function checkFile(filePath, rules, rootPath) {
   const violations = [];
-  const relativePath = path13.relative(rootPath, filePath);
+  const relativePath = path14.relative(rootPath, filePath);
   try {
-    const content = await fs12.readFile(filePath, "utf-8");
+    const content = await fs13.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     for (const rule of rules) {
       const ruleViolations = await evaluateRule(rule, content, lines, relativePath);
@@ -2959,7 +3062,7 @@ async function evaluateRule(rule, content, lines, filePath) {
     case "NAMING_CONVENTION": {
       const value = rule.value;
       const pattern = new RegExp(value.pattern);
-      const fileName = path13.basename(filePath);
+      const fileName = path14.basename(filePath);
       if (filePath.includes(value.context) && !pattern.test(fileName)) {
         violations.push({
           file: filePath,
@@ -3018,12 +3121,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)}`);
     }
   }
 }
@@ -3068,15 +3171,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...");
@@ -3104,17 +3207,17 @@ 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);
         }
       }
       spinner.succeed(`Loaded ${rules.length} Guardian rules`);
-      const scanPath = path14.resolve(process.cwd(), targetPath);
+      const scanPath = path15.resolve(process.cwd(), targetPath);
       let filesToCheck;
       if (options.staged) {
         spinner.start("Getting staged files...");
@@ -3123,14 +3226,14 @@ function createCheckCommand() {
             encoding: "utf-8",
             cwd: process.cwd()
           });
-          filesToCheck = stagedOutput.split("\n").filter((f) => f.trim()).filter((f) => isCodeFile2(f)).map((f) => path14.resolve(process.cwd(), f));
+          filesToCheck = stagedOutput.split("\n").filter((f) => f.trim()).filter((f) => isCodeFile2(f)).map((f) => path15.resolve(process.cwd(), f));
         } catch {
           spinner.fail("Not a git repository or no staged files");
           process.exit(2);
         }
       } else {
-        spinner.start(`Scanning ${chalk14.cyan(targetPath)}...`);
-        const pattern = path14.join(scanPath, "**/*");
+        spinner.start(`Scanning ${chalk15.cyan(targetPath)}...`);
+        const pattern = path15.join(scanPath, "**/*");
         const allFiles = await glob3(pattern, {
           nodir: true,
           dot: false,
@@ -3146,7 +3249,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);
       }
@@ -3155,7 +3258,7 @@ function createCheckCommand() {
       const results = [];
       for (let i = 0; i < filesToCheck.length; i++) {
         const file = filesToCheck[i];
-        spinner.text = `Checking ${i + 1}/${filesToCheck.length}: ${path14.basename(file)}`;
+        spinner.text = `Checking ${i + 1}/${filesToCheck.length}: ${path15.basename(file)}`;
         const result = await checkFile(file, rules, process.cwd());
         results.push(result);
       }
@@ -3165,47 +3268,47 @@ 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);
     }
   });
 }
 function isCodeFile2(filePath) {
   const codeExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-  const ext = path14.extname(filePath).toLowerCase();
+  const ext = path15.extname(filePath).toLowerCase();
   return codeExtensions.includes(ext);
 }
 async function loadCachedRules(projectId) {
   try {
-    const cachePath = path14.join(process.cwd(), CACHE_FILE2);
-    const content = await fs13.readFile(cachePath, "utf-8");
+    const cachePath = path15.join(process.cwd(), CACHE_FILE2);
+    const content = await fs14.readFile(cachePath, "utf-8");
     const cached = JSON.parse(content);
     if (cached.projectId !== projectId) {
       return null;
@@ -3217,16 +3320,16 @@ async function loadCachedRules(projectId) {
 }
 async function saveCachedRules(projectId, rules, settings) {
   try {
-    const cacheDir = path14.join(process.cwd(), ".rigstate");
-    await fs13.mkdir(cacheDir, { recursive: true });
+    const cacheDir = path15.join(process.cwd(), ".rigstate");
+    await fs14.mkdir(cacheDir, { recursive: true });
     const cached = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       projectId,
       rules,
       settings
     };
-    await fs13.writeFile(
-      path14.join(cacheDir, "rules-cache.json"),
+    await fs14.writeFile(
+      path15.join(cacheDir, "rules-cache.json"),
       JSON.stringify(cached, null, 2)
     );
   } catch {
@@ -3248,8 +3351,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);
@@ -3260,9 +3363,9 @@ function outputResults(results, json) {
 // src/commands/hooks.ts
 init_esm_shims();
 import { Command as Command10 } from "commander";
-import chalk15 from "chalk";
-import fs14 from "fs/promises";
-import path15 from "path";
+import chalk16 from "chalk";
+import fs15 from "fs/promises";
+import path16 from "path";
 var PRE_COMMIT_SCRIPT = `#!/bin/sh
 # Rigstate Guardian Pre-commit Hook
 # Installed by: rigstate hooks install
@@ -3291,23 +3394,23 @@ function createHooksCommand() {
   const hooks = new Command10("hooks").description("Manage git hooks for Guardian integration");
   hooks.command("install").description("Install pre-commit hook to run Guardian checks").option("--strict [level]", 'Strict level: "all" or "critical" (default)', "critical").action(async (options) => {
     try {
-      const gitDir = path15.join(process.cwd(), ".git");
+      const gitDir = path16.join(process.cwd(), ".git");
       try {
-        await fs14.access(gitDir);
+        await fs15.access(gitDir);
       } catch {
-        console.log(chalk15.red("\u274C Not a git repository."));
-        console.log(chalk15.dim('   Initialize with "git init" first.'));
+        console.log(chalk16.red("\u274C Not a git repository."));
+        console.log(chalk16.dim('   Initialize with "git init" first.'));
         process.exit(1);
       }
-      const hooksDir = path15.join(gitDir, "hooks");
-      await fs14.mkdir(hooksDir, { recursive: true });
-      const preCommitPath = path15.join(hooksDir, "pre-commit");
+      const hooksDir = path16.join(gitDir, "hooks");
+      await fs15.mkdir(hooksDir, { recursive: true });
+      const preCommitPath = path16.join(hooksDir, "pre-commit");
       let existingContent = "";
       try {
-        existingContent = await fs14.readFile(preCommitPath, "utf-8");
+        existingContent = await fs15.readFile(preCommitPath, "utf-8");
         if (existingContent.includes("rigstate")) {
-          console.log(chalk15.yellow("\u26A0 Rigstate pre-commit hook already installed."));
-          console.log(chalk15.dim('   Use "rigstate hooks uninstall" to remove first.'));
+          console.log(chalk16.yellow("\u26A0 Rigstate pre-commit hook already installed."));
+          console.log(chalk16.dim('   Use "rigstate hooks uninstall" to remove first.'));
           return;
         }
       } catch {
@@ -3318,34 +3421,34 @@ function createHooksCommand() {
       }
       if (existingContent && !existingContent.includes("rigstate")) {
         const combinedScript = existingContent + "\n\n" + script.replace("#!/bin/sh\n", "");
-        await fs14.writeFile(preCommitPath, combinedScript, { mode: 493 });
-        console.log(chalk15.green("\u2705 Rigstate hook appended to existing pre-commit."));
+        await fs15.writeFile(preCommitPath, combinedScript, { mode: 493 });
+        console.log(chalk16.green("\u2705 Rigstate hook appended to existing pre-commit."));
       } else {
-        await fs14.writeFile(preCommitPath, script, { mode: 493 });
-        console.log(chalk15.green("\u2705 Pre-commit hook installed!"));
+        await fs15.writeFile(preCommitPath, script, { mode: 493 });
+        console.log(chalk16.green("\u2705 Pre-commit hook installed!"));
       }
-      console.log(chalk15.dim(`   Path: ${preCommitPath}`));
-      console.log(chalk15.dim(`   Strict level: ${options.strict}`));
+      console.log(chalk16.dim(`   Path: ${preCommitPath}`));
+      console.log(chalk16.dim(`   Strict level: ${options.strict}`));
       console.log("");
-      console.log(chalk15.cyan("Guardian will now check your code before each commit."));
-      console.log(chalk15.dim('Use "rigstate hooks uninstall" to remove the hook.'));
+      console.log(chalk16.cyan("Guardian will now check your code before each commit."));
+      console.log(chalk16.dim('Use "rigstate hooks uninstall" to remove the hook.'));
     } catch (error) {
-      console.error(chalk15.red("Failed to install hook:"), error.message);
+      console.error(chalk16.red("Failed to install hook:"), error.message);
       process.exit(1);
     }
   });
   hooks.command("uninstall").description("Remove Rigstate pre-commit hook").action(async () => {
     try {
-      const preCommitPath = path15.join(process.cwd(), ".git", "hooks", "pre-commit");
+      const preCommitPath = path16.join(process.cwd(), ".git", "hooks", "pre-commit");
       try {
-        const content = await fs14.readFile(preCommitPath, "utf-8");
+        const content = await fs15.readFile(preCommitPath, "utf-8");
         if (!content.includes("rigstate")) {
-          console.log(chalk15.yellow("\u26A0 No Rigstate hook found in pre-commit."));
+          console.log(chalk16.yellow("\u26A0 No Rigstate hook found in pre-commit."));
           return;
         }
         if (content.includes("# Rigstate Guardian Pre-commit Hook") && content.trim().split("\n").filter((l) => l && !l.startsWith("#")).length <= 4) {
-          await fs14.unlink(preCommitPath);
-          console.log(chalk15.green("\u2705 Pre-commit hook removed."));
+          await fs15.unlink(preCommitPath);
+          console.log(chalk16.green("\u2705 Pre-commit hook removed."));
         } else {
           const lines = content.split("\n");
           const filteredLines = [];
@@ -3363,14 +3466,14 @@ function createHooksCommand() {
               filteredLines.push(line);
             }
           }
-          await fs14.writeFile(preCommitPath, filteredLines.join("\n"), { mode: 493 });
-          console.log(chalk15.green("\u2705 Rigstate section removed from pre-commit hook."));
+          await fs15.writeFile(preCommitPath, filteredLines.join("\n"), { mode: 493 });
+          console.log(chalk16.green("\u2705 Rigstate section removed from pre-commit hook."));
         }
       } catch {
-        console.log(chalk15.yellow("\u26A0 No pre-commit hook found."));
+        console.log(chalk16.yellow("\u26A0 No pre-commit hook found."));
       }
     } catch (error) {
-      console.error(chalk15.red("Failed to uninstall hook:"), error.message);
+      console.error(chalk16.red("Failed to uninstall hook:"), error.message);
       process.exit(1);
     }
   });
@@ -3380,40 +3483,40 @@ function createHooksCommand() {
 // src/commands/daemon.ts
 init_esm_shims();
 import { Command as Command11 } from "commander";
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 import ora8 from "ora";
-import fs20 from "fs/promises";
-import path23 from "path";
+import fs21 from "fs/promises";
+import path24 from "path";
 // src/daemon/factory.ts
 init_esm_shims();
 // src/daemon/core.ts
 init_esm_shims();
-import chalk19 from "chalk";
-import * as fs18 from "fs/promises";
-import path21 from "path";
+import chalk20 from "chalk";
+import * as fs19 from "fs/promises";
+import path22 from "path";
 import { EventEmitter as EventEmitter4 } from "events";
 // src/daemon/file-watcher.ts
 init_esm_shims();
 import * as chokidar from "chokidar";
-import path16 from "path";
+import path17 from "path";
 import { EventEmitter } from "events";
 var CODE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 function isCodeFile3(filePath) {
-  const ext = path16.extname(filePath).toLowerCase();
+  const ext = path17.extname(filePath).toLowerCase();
   return CODE_EXTENSIONS.includes(ext);
 }
 function createFileWatcher(watchPath) {
   const emitter = new EventEmitter();
   let watcher = null;
   emitter.start = () => {
-    const absolutePath = path16.resolve(process.cwd(), watchPath);
+    const absolutePath = path17.resolve(process.cwd(), watchPath);
     watcher = chokidar.watch(absolutePath, {
       ignored: (pathStr) => {
-        const relativePath = path16.relative(process.cwd(), pathStr);
-        const segments = relativePath.split(path16.sep);
+        const relativePath = path17.relative(process.cwd(), pathStr);
+        const segments = relativePath.split(path17.sep);
         const ignoreDirs = [
           "node_modules",
           ".git",
@@ -3445,7 +3548,7 @@ function createFileWatcher(watchPath) {
         if (segments.some((segment) => ignoreDirs.includes(segment))) {
           return true;
         }
-        const isFile = !!path16.extname(pathStr);
+        const isFile = !!path17.extname(pathStr);
         if (isFile && !isCodeFile3(pathStr)) {
           return true;
         }
@@ -3468,17 +3571,17 @@ function createFileWatcher(watchPath) {
     });
     watcher.on("change", (filePath) => {
       if (isCodeFile3(filePath)) {
-        emitter.emit("change", path16.relative(process.cwd(), filePath));
+        emitter.emit("change", path17.relative(process.cwd(), filePath));
       }
     });
     watcher.on("add", (filePath) => {
       if (isCodeFile3(filePath)) {
-        emitter.emit("add", path16.relative(process.cwd(), filePath));
+        emitter.emit("add", path17.relative(process.cwd(), filePath));
       }
     });
     watcher.on("unlink", (filePath) => {
       if (isCodeFile3(filePath)) {
-        emitter.emit("unlink", path16.relative(process.cwd(), filePath));
+        emitter.emit("unlink", path17.relative(process.cwd(), filePath));
       }
     });
     watcher.on("error", (error) => {
@@ -3501,7 +3604,7 @@ function createFileWatcher(watchPath) {
 init_esm_shims();
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { dirname } from "path";
-import path17 from "path";
+import path18 from "path";
 import axios11 from "axios";
 var GLOBAL_HEURISTICS = [
   {
@@ -3533,7 +3636,7 @@ var HeuristicEngine = class {
   rules = [];
   cachePath;
   constructor() {
-    this.cachePath = path17.join(process.cwd(), ".rigstate", "cache", "heuristics.json");
+    this.cachePath = path18.join(process.cwd(), ".rigstate", "cache", "heuristics.json");
     this.loadRules();
   }
   async loadRules() {
@@ -3648,9 +3751,9 @@ function createHeuristicEngine() {
 // src/daemon/intervention-protocol.ts
 init_esm_shims();
-import chalk16 from "chalk";
-import * as fs15 from "fs";
-import * as path18 from "path";
+import chalk17 from "chalk";
+import * as fs16 from "fs";
+import * as path19 from "path";
 var InterventionProtocol = class {
   activeViolators = /* @__PURE__ */ new Set();
   /**
@@ -3673,18 +3776,18 @@ var InterventionProtocol = class {
   }
   syncLockFile() {
     try {
-      const lockDir = path18.join(process.cwd(), ".rigstate");
-      if (!fs15.existsSync(lockDir)) fs15.mkdirSync(lockDir, { recursive: true });
-      const lockPath = path18.join(lockDir, "guardian.lock");
+      const lockDir = path19.join(process.cwd(), ".rigstate");
+      if (!fs16.existsSync(lockDir)) fs16.mkdirSync(lockDir, { recursive: true });
+      const lockPath = path19.join(lockDir, "guardian.lock");
       if (this.activeViolators.size > 0) {
         const content = `HARD_LOCK_ACTIVE
 Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
 Blocking Files:
 ${Array.from(this.activeViolators).join("\n")}`;
-        fs15.writeFileSync(lockPath, content, "utf-8");
+        fs16.writeFileSync(lockPath, content, "utf-8");
       } else {
-        if (fs15.existsSync(lockPath)) fs15.unlinkSync(lockPath);
+        if (fs16.existsSync(lockPath)) fs16.unlinkSync(lockPath);
       }
     } catch (e) {
       console.error("Failed to sync guardian lock file:", e);
@@ -3738,11 +3841,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" ? chalk16.bgRed.white.bold : chalk16.yellow.bold;
+    const color = decision.mode === "HARD_LOCK" ? chalk17.bgRed.white.bold : chalk17.yellow.bold;
     console.log("\n" + color(` ${icon} [${decision.mode}] INTERVENTION `));
-    console.log(chalk16.redBright(` ${decision.message}`));
+    console.log(chalk17.redBright(` ${decision.message}`));
     if (decision.blockCommit) {
-      console.log(chalk16.dim(" \u{1F512} Commit functionality is logically suspended until fixed."));
+      console.log(chalk17.dim(" \u{1F512} Commit functionality is logically suspended until fixed."));
     }
   }
 };
@@ -3753,9 +3856,9 @@ function createInterventionProtocol() {
 // src/daemon/guardian-monitor.ts
 init_esm_shims();
 import axios12 from "axios";
-import chalk17 from "chalk";
-import fs16 from "fs/promises";
-import path19 from "path";
+import chalk18 from "chalk";
+import fs17 from "fs/promises";
+import path20 from "path";
 var CACHE_FILE3 = ".rigstate/rules-cache.json";
 var CACHE_TTL_MS2 = 5 * 60 * 1e3;
 function createGuardianMonitor(projectId, apiUrl, apiKey) {
@@ -3780,7 +3883,7 @@ function createGuardianMonitor(projectId, apiUrl, apiKey) {
     } catch (error) {
       if (apiUrl.includes("localhost") || apiUrl.includes("127.0.0.1")) {
         const cloudUrl = "https://app.rigstate.com";
-        console.log(chalk17.blue(`  \u2601\uFE0F  Local API not found. Attempting Cloud Fallback (${cloudUrl})...`));
+        console.log(chalk18.blue(`  \u2601\uFE0F  Local API not found. Attempting Cloud Fallback (${cloudUrl})...`));
         try {
           const cloudResponse = await axios12.get(`${cloudUrl}/api/v1/guardian/rules`, {
             params: { project_id: projectId },
@@ -3789,22 +3892,22 @@ function createGuardianMonitor(projectId, apiUrl, apiKey) {
           });
           if (cloudResponse.data.success && cloudResponse.data.data.rules) {
             rules = cloudResponse.data.data.rules;
-            console.log(chalk17.green(`  \u2705 Successfully loaded rules from Rigstate Cloud!`));
+            console.log(chalk18.green(`  \u2705 Successfully loaded rules from Rigstate Cloud!`));
             lastFetch = Date.now();
             await saveCachedRules2(projectId, rules);
             return;
           }
         } catch (cloudError) {
-          console.error(chalk17.red(`  \u274C Cloud Fallback failed: ${cloudError.message}`));
+          console.error(chalk18.red(`  \u274C Cloud Fallback failed: ${cloudError.message}`));
         }
       }
-      console.error(chalk17.red(`  \u26A0\uFE0F  Failed to fetch rules from API: ${error.message}`));
+      console.error(chalk18.red(`  \u26A0\uFE0F  Failed to fetch rules from API: ${error.message}`));
       if (error.response) {
-        console.error(chalk17.red(`     Status: ${error.response.status} - ${JSON.stringify(error.response.data)}`));
+        console.error(chalk18.red(`     Status: ${error.response.status} - ${JSON.stringify(error.response.data)}`));
       }
       const cached = await loadCachedRules2(projectId);
       if (cached) {
-        console.log(chalk17.yellow("  \u2139\uFE0F  Using cached rules as fallback"));
+        console.log(chalk18.yellow("  \u2139\uFE0F  Using cached rules as fallback"));
         rules = cached.rules;
         lastFetch = Date.now();
         return;
@@ -3821,7 +3924,7 @@ function createGuardianMonitor(projectId, apiUrl, apiKey) {
         passed: true
       };
     }
-    const absolutePath = path19.resolve(process.cwd(), filePath);
+    const absolutePath = path20.resolve(process.cwd(), filePath);
     return checkFile(absolutePath, rules, process.cwd());
   };
   const getRuleCount = () => rules.length;
@@ -3835,8 +3938,8 @@ function createGuardianMonitor(projectId, apiUrl, apiKey) {
 }
 async function loadCachedRules2(projectId) {
   try {
-    const cachePath = path19.join(process.cwd(), CACHE_FILE3);
-    const content = await fs16.readFile(cachePath, "utf-8");
+    const cachePath = path20.join(process.cwd(), CACHE_FILE3);
+    const content = await fs17.readFile(cachePath, "utf-8");
     const cached = JSON.parse(content);
     if (cached.projectId !== projectId) {
       return null;
@@ -3848,16 +3951,16 @@ async function loadCachedRules2(projectId) {
 }
 async function saveCachedRules2(projectId, rules) {
   try {
-    const cacheDir = path19.join(process.cwd(), ".rigstate");
-    await fs16.mkdir(cacheDir, { recursive: true });
+    const cacheDir = path20.join(process.cwd(), ".rigstate");
+    await fs17.mkdir(cacheDir, { recursive: true });
     const cached = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       projectId,
       rules,
       settings: { lmax: 400, lmax_warning: 350 }
     };
-    await fs16.writeFile(
-      path19.join(cacheDir, "rules-cache.json"),
+    await fs17.writeFile(
+      path20.join(cacheDir, "rules-cache.json"),
       JSON.stringify(cached, null, 2)
     );
   } catch {
@@ -3957,37 +4060,37 @@ init_sync_rules();
 // src/utils/logger.ts
 init_esm_shims();
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 var Logger = class {
   static formatMessage(level, message, context) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     let prefix = "";
     switch (level) {
       case "INFO" /* INFO */:
-        prefix = chalk18.blue(`[${"INFO" /* INFO */}]`);
+        prefix = chalk19.blue(`[${"INFO" /* INFO */}]`);
         break;
       case "WARN" /* WARN */:
-        prefix = chalk18.yellow(`[${"WARN" /* WARN */}]`);
+        prefix = chalk19.yellow(`[${"WARN" /* WARN */}]`);
         break;
       case "ERROR" /* ERROR */:
-        prefix = chalk18.red(`[${"ERROR" /* ERROR */}]`);
+        prefix = chalk19.red(`[${"ERROR" /* ERROR */}]`);
         break;
       case "DEBUG" /* DEBUG */:
-        prefix = chalk18.gray(`[${"DEBUG" /* DEBUG */}]`);
+        prefix = chalk19.gray(`[${"DEBUG" /* DEBUG */}]`);
         break;
     }
-    let output = `${chalk18.gray(timestamp)} ${prefix} ${message}`;
+    let output = `${chalk19.gray(timestamp)} ${prefix} ${message}`;
     if (context) {
       if (context instanceof Error) {
         output += `
-${chalk18.red(context.stack || context.message)}`;
+${chalk19.red(context.stack || context.message)}`;
       } else if (typeof context === "object") {
         try {
           output += `
-${chalk18.gray(JSON.stringify(context, null, 2))}`;
+${chalk19.gray(JSON.stringify(context, null, 2))}`;
         } catch (e) {
           output += `
-${chalk18.gray("[Circular or invalid object]")}`;
+${chalk19.gray("[Circular or invalid object]")}`;
         }
       } else {
         output += ` ${String(context)}`;
@@ -4015,8 +4118,8 @@ ${chalk18.gray("[Circular or invalid object]")}`;
 init_esm_shims();
 import { EventEmitter as EventEmitter3 } from "events";
 import chokidar2 from "chokidar";
-import path20 from "path";
-import fs17 from "fs/promises";
+import path21 from "path";
+import fs18 from "fs/promises";
 import crypto from "crypto";
 import axios15 from "axios";
 var KnowledgeHarvester = class extends EventEmitter3 {
@@ -4034,8 +4137,8 @@ var KnowledgeHarvester = class extends EventEmitter3 {
   }
   async start() {
     await this.loadHashes();
-    const rulesPath = path20.join(this.config.watchPath, ".cursor", "rules");
-    const watchPattern = path20.join(rulesPath, "**", "*.mdc");
+    const rulesPath = path21.join(this.config.watchPath, ".cursor", "rules");
+    const watchPattern = path21.join(rulesPath, "**", "*.mdc");
     Logger.debug(`\u{1F33E} Harvester watching: ${watchPattern}`);
     this.watcher = chokidar2.watch(watchPattern, {
       persistent: true,
@@ -4056,7 +4159,7 @@ var KnowledgeHarvester = class extends EventEmitter3 {
     }
   }
   async handleFileEvent(filePath, event) {
-    const fileName = path20.basename(filePath);
+    const fileName = path21.basename(filePath);
     if (this.IGNORED_PREFIXES.some((prefix) => fileName.startsWith(prefix))) {
       return;
     }
@@ -4072,27 +4175,27 @@ var KnowledgeHarvester = class extends EventEmitter3 {
     if (this.processingQueue.has(filePath)) return;
     this.processingQueue.add(filePath);
     try {
-      const content = await fs17.readFile(filePath, "utf-8");
+      const content = await fs18.readFile(filePath, "utf-8");
       const currentHash = this.computeHash(content);
       if (this.ruleHashes.get(filePath) === currentHash) {
-        Logger.debug(`Skipping ${path20.basename(filePath)} (unchanged hash)`);
+        Logger.debug(`Skipping ${path21.basename(filePath)} (unchanged hash)`);
         return;
       }
       if (content.length < 20) {
-        Logger.debug(`Skipping ${path20.basename(filePath)} (too short)`);
+        Logger.debug(`Skipping ${path21.basename(filePath)} (too short)`);
         return;
       }
       await this.submitSignal(filePath, content);
       this.ruleHashes.set(filePath, currentHash);
     } catch (error) {
-      Logger.warn(`Harvester failed to process ${path20.basename(filePath)}: ${error.message}`);
+      Logger.warn(`Harvester failed to process ${path21.basename(filePath)}: ${error.message}`);
     } finally {
       this.processingQueue.delete(filePath);
     }
   }
   async submitSignal(filePath, content) {
-    const title = path20.basename(filePath, ".mdc");
-    const relativePath = path20.relative(process.cwd(), filePath);
+    const title = path21.basename(filePath, ".mdc");
+    const relativePath = path21.relative(process.cwd(), filePath);
     Logger.info(`\u{1F33E} Harvesting new knowledge: ${title}`);
     try {
       const descriptionMatch = content.match(/description:\s*(.*)/);
@@ -4126,14 +4229,14 @@ var KnowledgeHarvester = class extends EventEmitter3 {
     }
   }
   async loadHashes() {
-    const rulesPath = path20.join(this.config.watchPath, ".cursor", "rules");
+    const rulesPath = path21.join(this.config.watchPath, ".cursor", "rules");
     try {
-      await fs17.mkdir(rulesPath, { recursive: true });
-      const files = await fs17.readdir(rulesPath);
+      await fs18.mkdir(rulesPath, { recursive: true });
+      const files = await fs18.readdir(rulesPath);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const fullPath = path20.join(rulesPath, file);
-          const content = await fs17.readFile(fullPath, "utf-8");
+          const fullPath = path21.join(rulesPath, file);
+          const content = await fs18.readFile(fullPath, "utf-8");
           this.ruleHashes.set(fullPath, this.computeHash(content));
         }
       }
@@ -4170,7 +4273,7 @@ var GuardianDaemon = class extends EventEmitter4 {
   }
   async start() {
     if (this.state.isRunning) {
-      console.log(chalk19.yellow("Daemon is already running."));
+      console.log(chalk20.yellow("Daemon is already running."));
       return;
     }
     this.printWelcome();
@@ -4202,8 +4305,8 @@ var GuardianDaemon = class extends EventEmitter4 {
       try {
         await this.setupBridge();
       } catch (e) {
-        console.error(chalk19.yellow(`  \u26A0\uFE0F  Agent Bridge connection failed: ${e.message}`));
-        console.log(chalk19.dim("     (Daemon will continue with local monitoring only)"));
+        console.error(chalk20.yellow(`  \u26A0\uFE0F  Agent Bridge connection failed: ${e.message}`));
+        console.log(chalk20.dim("     (Daemon will continue with local monitoring only)"));
       }
     }
     this.printActive();
@@ -4219,16 +4322,16 @@ var GuardianDaemon = class extends EventEmitter4 {
     }
   }
   printWelcome() {
-    console.log(chalk19.bold.blue("\n\u{1F6E1}\uFE0F  Guardian Daemon Starting..."));
-    console.log(chalk19.dim(`Project: ${this.config.projectId}`));
-    console.log(chalk19.dim(`API URL: ${this.config.apiUrl}`));
-    console.log(chalk19.dim(`Watch Path: ${this.config.watchPath}`));
-    console.log(chalk19.dim("\u2500".repeat(50)));
+    console.log(chalk20.bold.blue("\n\u{1F6E1}\uFE0F  Guardian Daemon Starting..."));
+    console.log(chalk20.dim(`Project: ${this.config.projectId}`));
+    console.log(chalk20.dim(`API URL: ${this.config.apiUrl}`));
+    console.log(chalk20.dim(`Watch Path: ${this.config.watchPath}`));
+    console.log(chalk20.dim("\u2500".repeat(50)));
   }
   printActive() {
-    console.log(chalk19.dim("\u2500".repeat(50)));
-    console.log(chalk19.green.bold("\u2705 Guardian Daemon is now active"));
-    console.log(chalk19.dim("Press Ctrl+C to stop\n"));
+    console.log(chalk20.dim("\u2500".repeat(50)));
+    console.log(chalk20.green.bold("\u2705 Guardian Daemon is now active"));
+    console.log(chalk20.dim("Press Ctrl+C to stop\n"));
   }
   async syncHeuristics() {
     if (!this.heuristicEngine) return;
@@ -4251,7 +4354,7 @@ var GuardianDaemon = class extends EventEmitter4 {
   }
   async getLineCount(filePath) {
     try {
-      const content = await fs18.readFile(filePath, "utf-8");
+      const content = await fs19.readFile(filePath, "utf-8");
       return content.split("\n").length;
     } catch (e) {
       return 0;
@@ -4288,7 +4391,7 @@ var GuardianDaemon = class extends EventEmitter4 {
     }
   }
   async updateViolationReport(violations) {
-    const reportPath = path21.join(process.cwd(), ".rigstate", "ACTIVE_VIOLATIONS.md");
+    const reportPath = path22.join(process.cwd(), ".rigstate", "ACTIVE_VIOLATIONS.md");
     const allViolations = Array.from(this.violationsMap.entries());
     const totalCount = allViolations.reduce((acc, [, v]) => acc + v.length, 0);
     let content = `# \u{1F6E1}\uFE0F Guardian Status: ${totalCount > 0 ? "\u26A0\uFE0F ATTENTION" : "\u2705 PASS"}
@@ -4304,7 +4407,7 @@ var GuardianDaemon = class extends EventEmitter4 {
     } else {
       content += "### \u{1F6A8} Active Violations\n\n";
       for (const [file, fileViolations] of allViolations) {
-        const relPath = path21.relative(process.cwd(), file);
+        const relPath = path22.relative(process.cwd(), file);
         content += `#### \u{1F4C4} ${relPath}
 `;
         for (const v of fileViolations) {
@@ -4316,7 +4419,7 @@ var GuardianDaemon = class extends EventEmitter4 {
       content += "\n---\n*Rigstate Daemon is watching. Fix violations to clear this report.*";
     }
     try {
-      await fs18.writeFile(reportPath, content, "utf-8");
+      await fs19.writeFile(reportPath, content, "utf-8");
     } catch (e) {
     }
   }
@@ -4336,27 +4439,27 @@ var GuardianDaemon = class extends EventEmitter4 {
     }
   }
   async setupBridge() {
-    console.log(chalk19.dim("\u{1F309} Connecting to Agent Bridge..."));
+    console.log(chalk20.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(chalk19.cyan(`
+      console.log(chalk20.cyan(`
 \u{1F4E5} New task received: ${task.id}`));
       this.emit("task", task);
     });
     await this.bridgeListener.connect();
-    console.log(chalk19.green("  \u2713 Agent Bridge connected"));
+    console.log(chalk20.green("  \u2713 Agent Bridge connected"));
   }
   async stop() {
     if (!this.state.isRunning) return;
-    console.log(chalk19.dim("\n\u{1F6D1} Stopping Guardian Daemon..."));
+    console.log(chalk20.dim("\n\u{1F6D1} Stopping Guardian Daemon..."));
     if (this.fileWatcher) await this.fileWatcher.stop();
     if (this.bridgeListener) await this.bridgeListener.disconnect();
     if (this.harvester) await this.harvester.stop();
     if (this.syncInterval) clearInterval(this.syncInterval);
     this.state.isRunning = false;
-    console.log(chalk19.green("\u2713 Daemon stopped."));
+    console.log(chalk20.green("\u2713 Daemon stopped."));
     this.emit("stopped", this.state);
   }
   getState() {
@@ -4366,6 +4469,7 @@ var GuardianDaemon = class extends EventEmitter4 {
 // src/daemon/factory.ts
 init_config();
+init_manifest();
 async function createDaemon(options) {
   const apiUrl = getApiUrl();
   let projectId = options.project;
@@ -4395,9 +4499,9 @@ async function createDaemon(options) {
 // src/utils/service-manager.ts
 init_esm_shims();
-import chalk20 from "chalk";
-import fs19 from "fs/promises";
-import path22 from "path";
+import chalk21 from "chalk";
+import fs20 from "fs/promises";
+import path23 from "path";
 import { execSync as execSync3 } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function execShellCommand(cmd) {
@@ -4409,22 +4513,22 @@ async function execShellCommand(cmd) {
   }
 }
 async function enableDaemon() {
-  console.log(chalk20.bold("\n\u2699\uFE0F  Enabling Rigstate Background Service (macOS)\n"));
+  console.log(chalk21.bold("\n\u2699\uFE0F  Enabling Rigstate Background Service (macOS)\n"));
   if (process.platform !== "darwin") {
-    console.error(chalk20.red("\u274C Currently only macOS is supported for auto-start."));
-    console.error(chalk20.yellow("PRs welcome for Linux/Windows support!"));
+    console.error(chalk21.red("\u274C Currently only macOS is supported for auto-start."));
+    console.error(chalk21.yellow("PRs welcome for Linux/Windows support!"));
     return;
   }
   const homeDir = process.env.HOME || "";
   if (!homeDir) {
-    console.error(chalk20.red("\u274C Could not determine HOME directory."));
+    console.error(chalk21.red("\u274C Could not determine HOME directory."));
     return;
   }
-  const agentsDir = path22.join(homeDir, "Library/LaunchAgents");
-  const logDir = path22.join(homeDir, ".rigstate/logs");
-  const plistPath = path22.join(agentsDir, "com.rigstate.daemon.plist");
-  await fs19.mkdir(agentsDir, { recursive: true });
-  await fs19.mkdir(logDir, { recursive: true });
+  const agentsDir = path23.join(homeDir, "Library/LaunchAgents");
+  const logDir = path23.join(homeDir, ".rigstate/logs");
+  const plistPath = path23.join(agentsDir, "com.rigstate.daemon.plist");
+  await fs20.mkdir(agentsDir, { recursive: true });
+  await fs20.mkdir(logDir, { recursive: true });
   const scriptPath = fileURLToPath2(import.meta.url);
   const nodePath = process.execPath;
   const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
@@ -4443,9 +4547,9 @@ async function enableDaemon() {
     <key>WorkingDirectory</key>
     <string>${process.cwd()}</string>
     <key>StandardOutPath</key>
-    <string>${path22.join(logDir, "daemon.out.log")}</string>
+    <string>${path23.join(logDir, "daemon.out.log")}</string>
     <key>StandardErrorPath</key>
-    <string>${path22.join(logDir, "daemon.err.log")}</string>
+    <string>${path23.join(logDir, "daemon.err.log")}</string>
     <key>RunAtLoad</key>
     <true/>
     <key>KeepAlive</key>
@@ -4458,33 +4562,33 @@ async function enableDaemon() {
 </dict>
 </plist>`;
   try {
-    await fs19.writeFile(plistPath, plistContent);
-    console.log(chalk20.dim(`Created plist at: ${plistPath}`));
+    await fs20.writeFile(plistPath, plistContent);
+    console.log(chalk21.dim(`Created plist at: ${plistPath}`));
     try {
       await execShellCommand(`launchctl unload ${plistPath}`);
     } catch (e) {
     }
     await execShellCommand(`launchctl load ${plistPath}`);
-    console.log(chalk20.green("\u2705 Successfully enabled background daemon!"));
-    console.log(chalk20.dim(`Logs: ${logDir}`));
-    console.log(chalk20.dim("The daemon will now restart automatically if it crashes or on reboot."));
+    console.log(chalk21.green("\u2705 Successfully enabled background daemon!"));
+    console.log(chalk21.dim(`Logs: ${logDir}`));
+    console.log(chalk21.dim("The daemon will now restart automatically if it crashes or on reboot."));
   } catch (error) {
-    console.error(chalk20.red("\u274C Failed to enable daemon:"), error.message);
+    console.error(chalk21.red("\u274C Failed to enable daemon:"), error.message);
   }
 }
 async function disableDaemon() {
-  console.log(chalk20.bold("\n\u2699\uFE0F  Disabling Rigstate Background Service\n"));
+  console.log(chalk21.bold("\n\u2699\uFE0F  Disabling Rigstate Background Service\n"));
   const homeDir = process.env.HOME || "";
-  const plistPath = path22.join(homeDir, "Library/LaunchAgents/com.rigstate.daemon.plist");
+  const plistPath = path23.join(homeDir, "Library/LaunchAgents/com.rigstate.daemon.plist");
   try {
     await execShellCommand(`launchctl unload ${plistPath}`);
-    await fs19.unlink(plistPath);
-    console.log(chalk20.green("\u2705 Successfully disabled background daemon."));
+    await fs20.unlink(plistPath);
+    console.log(chalk21.green("\u2705 Successfully disabled background daemon."));
   } catch (error) {
     if (error.code === "ENOENT") {
-      console.log(chalk20.green("\u2705 Daemon was not enabled."));
+      console.log(chalk21.green("\u2705 Daemon was not enabled."));
     } else {
-      console.error(chalk20.red("\u274C Failed to disable daemon:"), error.message);
+      console.error(chalk21.red("\u274C Failed to disable daemon:"), error.message);
     }
   }
 }
@@ -4509,17 +4613,17 @@ function createDaemonCommand() {
     }
     const spinner = ora8();
     try {
-      const pidPath = path23.join(process.cwd(), PID_FILE);
+      const pidPath = path24.join(process.cwd(), PID_FILE);
       try {
-        const content = await fs20.readFile(pidPath, "utf-8");
+        const content = await fs21.readFile(pidPath, "utf-8");
         const pid = parseInt(content.trim(), 10);
         try {
           process.kill(pid, 0);
-          console.log(chalk21.yellow("\u26A0 Another daemon instance is active (PID " + pid + ")."));
-          console.log(chalk21.dim(`   Run "rigstate daemon status" for details or Ctrl+C to stop.
+          console.log(chalk22.yellow("\u26A0 Another daemon instance is active (PID " + pid + ")."));
+          console.log(chalk22.dim(`   Run "rigstate daemon status" for details or Ctrl+C to stop.
 `));
         } catch {
-          await fs20.unlink(pidPath).catch(() => {
+          await fs21.unlink(pidPath).catch(() => {
           });
         }
       } catch {
@@ -4534,7 +4638,7 @@ function createDaemonCommand() {
       spinner.stop();
       await writePidFile();
       process.on("SIGINT", async () => {
-        console.log(chalk21.dim("\n\nShutting down..."));
+        console.log(chalk22.dim("\n\nShutting down..."));
         await daemonInstance.stop();
         await cleanupPidFile();
         process.exit(0);
@@ -4554,8 +4658,8 @@ function createDaemonCommand() {
       await new Promise(() => {
       });
     } catch (error) {
-      spinner.fail(chalk21.red("Failed to start daemon"));
-      console.error(chalk21.red("Error:"), error.message);
+      spinner.fail(chalk22.red("Failed to start daemon"));
+      console.error(chalk22.red("Error:"), error.message);
       process.exit(1);
     }
   });
@@ -4563,14 +4667,14 @@ function createDaemonCommand() {
 }
 async function isRunning() {
   try {
-    const pidPath = path23.join(process.cwd(), PID_FILE);
-    const content = await fs20.readFile(pidPath, "utf-8");
+    const pidPath = path24.join(process.cwd(), PID_FILE);
+    const content = await fs21.readFile(pidPath, "utf-8");
     const pid = parseInt(content.trim(), 10);
     try {
       process.kill(pid, 0);
       return true;
     } catch {
-      await fs20.unlink(pidPath);
+      await fs21.unlink(pidPath);
       return false;
     }
   } catch {
@@ -4579,57 +4683,57 @@ async function isRunning() {
 }
 async function writePidFile() {
   try {
-    const dir = path23.join(process.cwd(), ".rigstate");
-    await fs20.mkdir(dir, { recursive: true });
-    await fs20.writeFile(path23.join(dir, "daemon.pid"), process.pid.toString());
+    const dir = path24.join(process.cwd(), ".rigstate");
+    await fs21.mkdir(dir, { recursive: true });
+    await fs21.writeFile(path24.join(dir, "daemon.pid"), process.pid.toString());
   } catch {
   }
 }
 async function cleanupPidFile() {
   try {
-    await fs20.unlink(path23.join(process.cwd(), PID_FILE));
-    await fs20.unlink(path23.join(process.cwd(), STATE_FILE));
+    await fs21.unlink(path24.join(process.cwd(), PID_FILE));
+    await fs21.unlink(path24.join(process.cwd(), STATE_FILE));
   } catch {
   }
 }
 async function writeStateFile(state) {
   try {
-    const dir = path23.join(process.cwd(), ".rigstate");
-    await fs20.mkdir(dir, { recursive: true });
-    await fs20.writeFile(
-      path23.join(dir, "daemon.state.json"),
+    const dir = path24.join(process.cwd(), ".rigstate");
+    await fs21.mkdir(dir, { recursive: true });
+    await fs21.writeFile(
+      path24.join(dir, "daemon.state.json"),
       JSON.stringify(state, null, 2)
     );
   } catch {
   }
 }
 async function showStatus() {
-  console.log(chalk21.bold("\n\u{1F6E1}\uFE0F  Guardian Daemon Status\n"));
+  console.log(chalk22.bold("\n\u{1F6E1}\uFE0F  Guardian Daemon Status\n"));
   const running = await isRunning();
   if (!running) {
-    console.log(chalk21.yellow("Status: Not running"));
-    console.log(chalk21.dim('Use "rigstate daemon" to start.\n'));
+    console.log(chalk22.yellow("Status: Not running"));
+    console.log(chalk22.dim('Use "rigstate daemon" to start.\n'));
     return;
   }
-  console.log(chalk21.green("Status: Running"));
+  console.log(chalk22.green("Status: Running"));
   try {
-    const statePath = path23.join(process.cwd(), STATE_FILE);
-    const content = await fs20.readFile(statePath, "utf-8");
+    const statePath = path24.join(process.cwd(), STATE_FILE);
+    const content = await fs21.readFile(statePath, "utf-8");
     const state = JSON.parse(content);
-    console.log(chalk21.dim("\u2500".repeat(40)));
+    console.log(chalk22.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(chalk21.dim("\u2500".repeat(40)));
+    console.log(chalk22.dim("\u2500".repeat(40)));
   } catch {
-    console.log(chalk21.dim("(State file not found)"));
+    console.log(chalk22.dim("(State file not found)"));
   }
   try {
-    const pidPath = path23.join(process.cwd(), PID_FILE);
-    const pid = await fs20.readFile(pidPath, "utf-8");
-    console.log(chalk21.dim(`PID: ${pid.trim()}`));
+    const pidPath = path24.join(process.cwd(), PID_FILE);
+    const pid = await fs21.readFile(pidPath, "utf-8");
+    console.log(chalk22.dim(`PID: ${pid.trim()}`));
   } catch {
   }
   console.log("");
@@ -4640,7 +4744,7 @@ init_esm_shims();
 init_config();
 init_suggest();
 import { Command as Command13 } from "commander";
-import chalk23 from "chalk";
+import chalk24 from "chalk";
 import ora10 from "ora";
 import axios17 from "axios";
 import inquirer3 from "inquirer";
@@ -4649,11 +4753,11 @@ import inquirer3 from "inquirer";
 init_esm_shims();
 init_config();
 import { Command as Command12 } from "commander";
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 import ora9 from "ora";
 import axios16 from "axios";
-import fs21 from "fs/promises";
-import path24 from "path";
+import fs22 from "fs/promises";
+import path25 from "path";
 import inquirer2 from "inquirer";
 function createPlanCommand() {
   const plan = new Command12("plan");
@@ -4711,7 +4815,7 @@ async function executePlan(taskId) {
       taskDescription = task.description;
     }
     spinner.start("Generating Context for Frank...");
-    const contextPath = path24.join(process.cwd(), ".rigstate", "CURRENT_CONTEXT.md");
+    const contextPath = path25.join(process.cwd(), ".rigstate", "CURRENT_CONTEXT.md");
     const contextContent = `
 # \u{1F3AF} Active Mission: ${taskTitle}
 **ID:** ${taskId}
@@ -4726,10 +4830,10 @@ ${taskDescription}
 *Generated by Rigstate CLI at ${(/* @__PURE__ */ new Date()).toLocaleString()}*
 `;
-    await fs21.mkdir(path24.dirname(contextPath), { recursive: true });
-    await fs21.writeFile(contextPath, contextContent.trim());
-    const planPath = path24.join(process.cwd(), "IMPLEMENTATION_PLAN.md");
-    const planExists = await fs21.stat(planPath).then(() => true).catch(() => false);
+    await fs22.mkdir(path25.dirname(contextPath), { recursive: true });
+    await fs22.writeFile(contextPath, contextContent.trim());
+    const planPath = path25.join(process.cwd(), "IMPLEMENTATION_PLAN.md");
+    const planExists = await fs22.stat(planPath).then(() => true).catch(() => false);
     if (!planExists) {
       const planTemplate = `
 # \u{1F4CB} Implementation Plan: ${taskTitle}
@@ -4748,23 +4852,38 @@ ${taskDescription}
 ## 4. \u{1F680} Execution
 [Frank: Log your progress here]
 `;
-      await fs21.writeFile(planPath, planTemplate.trim());
-      spinner.succeed(chalk22.green("Created new IMPLEMENTATION_PLAN.md"));
+      await fs22.writeFile(planPath, planTemplate.trim());
+      spinner.succeed(chalk23.green("Created new IMPLEMENTATION_PLAN.md"));
     } else {
-      spinner.info(chalk22.yellow("IMPLEMENTATION_PLAN.md already exists. Preserving it."));
+      spinner.info(chalk23.yellow("IMPLEMENTATION_PLAN.md already exists. Preserving it."));
+    }
+    try {
+      spinner.start("\u{1F4E1} Signaling Frank to start drafting...");
+      await axios16.post(`${apiUrl}/api/v1/agent/bridge`, {
+        project_id: projectId,
+        task_id: realId,
+        status: "APPROVED",
+        proposal: `draft_plan:${taskId}`,
+        summary: `Requesting implementation plan for ${taskTitle}`
+      }, {
+        headers: { "Authorization": `Bearer ${apiKey}` }
+      });
+      spinner.succeed("Signal sent to Agent Bridge.");
+    } catch (e) {
+      spinner.info(chalk23.dim("Agent Bridge signal skipped (non-critical)."));
     }
     console.log("");
-    console.log(chalk22.bold.blue("\u{1F680} Planning Mode Activated"));
-    console.log(chalk22.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    console.log(`1. Context loaded into: ${chalk22.bold(".rigstate/CURRENT_CONTEXT.md")}`);
-    console.log(`2. Plan template ready: ${chalk22.bold("IMPLEMENTATION_PLAN.md")}`);
+    console.log(chalk23.bold.blue("\u{1F680} Planning Mode Activated"));
+    console.log(chalk23.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`1. Context loaded into: ${chalk23.bold(".rigstate/CURRENT_CONTEXT.md")}`);
+    console.log(`2. Plan template ready: ${chalk23.bold("IMPLEMENTATION_PLAN.md")}`);
     console.log("");
-    console.log(chalk22.yellow("\u{1F449} NEXT STEP:"));
-    console.log(`   Open ${chalk22.bold("IMPLEMENTATION_PLAN.md")} in your IDE.`);
-    console.log(`   Tell Frank: ${chalk22.italic('"Read the context and draft the plan."')}`);
+    console.log(chalk23.green("\u2728 FRANK IS ON IT!"));
+    console.log(chalk23.dim("   He has received the bridge signal and will begin drafting shortly."));
+    console.log(chalk23.dim("   No further manual steps required once he wakes up."));
     console.log("");
   } catch (e) {
-    spinner.fail(chalk22.red(`Planning failed: ${e.message}`));
+    spinner.fail(chalk23.red(`Planning failed: ${e.message}`));
   }
 }
 function getContext() {
@@ -4809,7 +4928,7 @@ async function listInteractive() {
     });
     spinner.stop();
     if (actionableTasks.length === 0) {
-      console.log(chalk23.yellow("Roadmap clear. No actionable tasks found."));
+      console.log(chalk24.yellow("Roadmap clear. No actionable tasks found."));
       return;
     }
     const choices = actionableTasks.map((t) => {
@@ -4818,7 +4937,7 @@ async function listInteractive() {
       if (t.status === "IN_PROGRESS") icon = "\u{1F525}";
       if (t.status === "ACTIVE") icon = "\u25B6\uFE0F";
       return {
-        name: `${icon}  ${chalk23.bold(id)}: ${t.title} [${t.status}]`,
+        name: `${icon}  ${chalk24.bold(id)}: ${t.title} [${t.status}]`,
         value: t.id
       };
     });
@@ -4865,25 +4984,25 @@ async function setTaskStatus(taskId, status) {
       { step_id: realId, status, project_id: projectId },
       { headers: { "Authorization": `Bearer ${apiKey}` } }
     );
-    spinner.succeed(chalk23.green(`Task updated to ${status}.`));
+    spinner.succeed(chalk24.green(`Task updated to ${status}.`));
     if (status === "IN_PROGRESS") {
-      console.log(chalk23.blue(`
+      console.log(chalk24.blue(`
 \u{1F4A1} Tip: Provide 'Frank' with context by mentioning @.cursorrules in your chat.`));
     }
   } catch (e) {
-    spinner.fail(chalk23.red(`Failed: ${e.message}`));
+    spinner.fail(chalk24.red(`Failed: ${e.message}`));
   }
 }
 async function finishTask(taskId) {
   console.log("");
-  console.log(chalk23.bold.yellow("\u{1F6E1}\uFE0F  FRANK'S QUALITY GATE"));
-  console.log(chalk23.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk24.bold.yellow("\u{1F6E1}\uFE0F  FRANK'S QUALITY GATE"));
+  console.log(chalk24.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   const auditSpinner = ora10(" Analyzing architectural integrity...").start();
   await new Promise((r) => setTimeout(r, 1500));
   auditSpinner.succeed("Architecture: VALIDATED (SEC-ARCH-01 Pass)");
   await setTaskStatus(taskId, "COMPLETED");
   console.log("");
-  console.log(chalk23.bold.green("\u{1F389} TASK COMPLETE! Momentum Preserved."));
+  console.log(chalk24.bold.green("\u{1F389} TASK COMPLETE! Momentum Preserved."));
   const { projectId, apiKey, apiUrl } = getContext2();
   await suggestNextMove(projectId, apiKey, apiUrl);
 }
@@ -4901,39 +5020,35 @@ function getContext2() {
 init_esm_shims();
 init_config();
 import { Command as Command14 } from "commander";
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 import ora11 from "ora";
 import chokidar3 from "chokidar";
-import fs22 from "fs/promises";
-import path25 from "path";
+import fs23 from "fs/promises";
+import path26 from "path";
 import { execSync as execSync4 } from "child_process";
 import axios18 from "axios";
 function createWatchCommand() {
   const watch2 = new Command14("watch");
   watch2.description("Watch for changes and auto-verify roadmap tasks").option("--no-auto-commit", "Disable auto-commit on verification").option("--no-auto-push", "Disable auto-push after commit").option("--run-tests", "Run tests before committing").option("--test-command <cmd>", "Custom test command (default: npm test)").action(async (options) => {
-    console.log(chalk24.bold.blue("\u{1F52D} Rigstate Watch Mode"));
-    console.log(chalk24.dim("Monitoring for task completion..."));
+    console.log(chalk25.bold.blue("\u{1F52D} Rigstate Watch Mode"));
+    console.log(chalk25.dim("Monitoring for task completion..."));
     console.log("");
     let apiKey;
     let projectId;
     try {
       apiKey = getApiKey();
     } catch (e) {
-      console.log(chalk24.red('Not authenticated. Run "rigstate login" first.'));
+      console.log(chalk25.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
-      try {
-        const manifestPath = path25.join(process.cwd(), ".rigstate");
-        const content = await fs22.readFile(manifestPath, "utf-8");
-        const manifest = JSON.parse(content);
-        projectId = manifest.project_id;
-      } catch (e) {
-      }
+      const { loadManifest: loadManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+      const manifest = await loadManifest2();
+      if (manifest?.project_id) projectId = manifest.project_id;
     }
     if (!projectId) {
-      console.log(chalk24.red('No project context. Run "rigstate link" or "rigstate sync --project <id>" first.'));
+      console.log(chalk25.red('No project context. Run "rigstate link" or "rigstate sync --project <id>" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -4943,8 +5058,8 @@ function createWatchCommand() {
       runTests: options.runTests || false,
       testCommand: options.testCommand || "npm test"
     };
-    console.log(chalk24.dim(`Auto-commit: ${config2.autoCommit ? "ON" : "OFF"}`));
-    console.log(chalk24.dim(`Auto-push: ${config2.autoPush ? "ON" : "OFF"}`));
+    console.log(chalk25.dim(`Auto-commit: ${config2.autoCommit ? "ON" : "OFF"}`));
+    console.log(chalk25.dim(`Auto-push: ${config2.autoPush ? "ON" : "OFF"}`));
     console.log("");
     const fetchActiveTask = async () => {
       try {
@@ -4972,17 +5087,17 @@ function createWatchCommand() {
     };
     const checkCriteria = async (criteria) => {
       try {
-        const fullPath = path25.resolve(process.cwd(), criteria.path);
+        const fullPath = path26.resolve(process.cwd(), criteria.path);
         switch (criteria.type) {
           case "file_exists":
-            await fs22.access(fullPath);
+            await fs23.access(fullPath);
             return true;
           case "file_content":
-            const content = await fs22.readFile(fullPath, "utf-8");
+            const content = await fs23.readFile(fullPath, "utf-8");
             return content.length > 0;
           case "content_match":
             if (!criteria.match) return false;
-            const fileContent = await fs22.readFile(fullPath, "utf-8");
+            const fileContent = await fs23.readFile(fullPath, "utf-8");
             return fileContent.includes(criteria.match);
           default:
             return false;
@@ -5011,7 +5126,7 @@ function createWatchCommand() {
         }, {
           headers: { Authorization: `Bearer ${apiKey}` }
         });
-        spinner.succeed(chalk24.green(`\u2705 Task #${task.step_number} completed: ${task.title}`));
+        spinner.succeed(chalk25.green(`\u2705 Task #${task.step_number} completed: ${task.title}`));
         if (config2.autoCommit) {
           spinner.start("Committing changes...");
           try {
@@ -5033,7 +5148,7 @@ function createWatchCommand() {
           }
         }
         console.log("");
-        console.log(chalk24.blue("Watching for next task..."));
+        console.log(chalk25.blue("Watching for next task..."));
       } catch (e) {
         spinner.fail(`Failed to complete task: ${e.message}`);
       }
@@ -5046,7 +5161,7 @@ function createWatchCommand() {
       const task = await fetchActiveTask();
       if (!task) {
         if (currentTask) {
-          console.log(chalk24.green("\u{1F389} All tasks completed! Watching for new tasks..."));
+          console.log(chalk25.green("\u{1F389} All tasks completed! Watching for new tasks..."));
           currentTask = null;
         }
         isProcessing = false;
@@ -5055,10 +5170,10 @@ function createWatchCommand() {
       if (!currentTask || currentTask.id !== task.id) {
         currentTask = task;
         console.log("");
-        console.log(chalk24.bold.yellow(`\u{1F4CC} Active Task #${task.step_number}: ${task.title}`));
-        console.log(chalk24.dim(`Status: ${task.status}`));
+        console.log(chalk25.bold.yellow(`\u{1F4CC} Active Task #${task.step_number}: ${task.title}`));
+        console.log(chalk25.dim(`Status: ${task.status}`));
         if (task.verification_criteria) {
-          console.log(chalk24.dim("Verification: Auto-checking criteria..."));
+          console.log(chalk25.dim("Verification: Auto-checking criteria..."));
         }
       }
       if (task.verification_criteria && Array.isArray(task.verification_criteria)) {
@@ -5071,7 +5186,7 @@ function createWatchCommand() {
           }
         }
         if (allPassed) {
-          console.log(chalk24.green("\u2713 All verification criteria passed!"));
+          console.log(chalk25.green("\u2713 All verification criteria passed!"));
           await completeTask(task.id, task);
           currentTask = null;
         }
@@ -5096,11 +5211,11 @@ function createWatchCommand() {
         setTimeout(() => processActiveTask(), 500);
       }
     });
-    console.log(chalk24.dim("Watching for file changes... (Ctrl+C to exit)"));
+    console.log(chalk25.dim("Watching for file changes... (Ctrl+C to exit)"));
     setInterval(() => processActiveTask(), 3e4);
     process.on("SIGINT", () => {
       console.log("");
-      console.log(chalk24.dim("Watch mode stopped."));
+      console.log(chalk25.dim("Watch mode stopped."));
       watcher.close();
       process.exit(0);
     });
@@ -5112,12 +5227,10 @@ function createWatchCommand() {
 init_esm_shims();
 init_config();
 import { Command as Command15 } from "commander";
-import chalk25 from "chalk";
+import chalk26 from "chalk";
 import ora12 from "ora";
 import axios19 from "axios";
 import { execSync as execSync5 } from "child_process";
-import fs23 from "fs/promises";
-import path26 from "path";
 function createFocusCommand() {
   const focus = new Command15("focus");
   focus.alias("task").description("Get the next active roadmap task and copy its prompt to clipboard").option("--no-copy", "Do not copy to clipboard").action(async (options) => {
@@ -5127,21 +5240,17 @@ function createFocusCommand() {
     try {
       apiKey = getApiKey();
     } catch (e) {
-      spinner.fail(chalk25.red('Not authenticated. Run "rigstate login" first.'));
+      spinner.fail(chalk26.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
-      try {
-        const manifestPath = path26.join(process.cwd(), ".rigstate");
-        const content = await fs23.readFile(manifestPath, "utf-8");
-        const manifest = JSON.parse(content);
-        projectId = manifest.project_id;
-      } catch (e) {
-      }
+      const { loadManifest: loadManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+      const manifest = await loadManifest2();
+      if (manifest?.project_id) projectId = manifest.project_id;
     }
     if (!projectId) {
-      spinner.fail(chalk25.red('No project context. Run "rigstate link" first.'));
+      spinner.fail(chalk26.red('No project context. Run "rigstate link" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -5172,41 +5281,41 @@ function createFocusCommand() {
       const nextTask = activeTasks[0];
       spinner.stop();
       console.log("");
-      console.log(chalk25.bold.blue(`\u{1F4CC} Task #${nextTask.step_number || "?"}: ${nextTask.title}`));
-      const statusColor = nextTask.status === "IN_PROGRESS" ? chalk25.yellow : nextTask.status === "ACTIVE" ? chalk25.green : chalk25.dim;
-      console.log(chalk25.dim("Status: ") + statusColor(nextTask.status));
-      console.log(chalk25.dim("\u2500".repeat(60)));
+      console.log(chalk26.bold.blue(`\u{1F4CC} Task #${nextTask.step_number || "?"}: ${nextTask.title}`));
+      const statusColor = nextTask.status === "IN_PROGRESS" ? chalk26.yellow : nextTask.status === "ACTIVE" ? chalk26.green : chalk26.dim;
+      console.log(chalk26.dim("Status: ") + statusColor(nextTask.status));
+      console.log(chalk26.dim("\u2500".repeat(60)));
       if (nextTask.prompt_content) {
-        console.log(chalk25.white(nextTask.prompt_content));
-        console.log(chalk25.dim("\u2500".repeat(60)));
+        console.log(chalk26.white(nextTask.prompt_content));
+        console.log(chalk26.dim("\u2500".repeat(60)));
         if (options.copy !== false) {
           try {
             if (process.platform === "darwin") {
               execSync5("pbcopy", { input: nextTask.prompt_content });
-              console.log(chalk25.green("\u2705 Prompt copied to clipboard! Ready to paste (Cmd+V)."));
+              console.log(chalk26.green("\u2705 Prompt copied to clipboard! Ready to paste (Cmd+V)."));
             } else if (process.platform === "linux") {
               try {
                 execSync5("xclip -selection clipboard", { input: nextTask.prompt_content });
-                console.log(chalk25.green("\u2705 Prompt copied to clipboard!"));
+                console.log(chalk26.green("\u2705 Prompt copied to clipboard!"));
               } catch (e) {
-                console.log(chalk25.yellow("\u2139\uFE0F  Copy prompt manually (xclip not available)"));
+                console.log(chalk26.yellow("\u2139\uFE0F  Copy prompt manually (xclip not available)"));
               }
             } else {
-              console.log(chalk25.yellow("\u2139\uFE0F  Copy prompt manually (Auto-copy not supported on this OS)"));
+              console.log(chalk26.yellow("\u2139\uFE0F  Copy prompt manually (Auto-copy not supported on this OS)"));
             }
           } catch (e) {
           }
         }
       } else {
-        console.log(chalk25.yellow("No prompt instructions available."));
+        console.log(chalk26.yellow("No prompt instructions available."));
         if (nextTask.architectural_brief) {
-          console.log(chalk25.bold("Brief:"));
+          console.log(chalk26.bold("Brief:"));
           console.log(nextTask.architectural_brief);
         }
       }
       console.log("");
     } catch (e) {
-      spinner.fail(chalk25.red(`Failed to fetch task: ${e.message}`));
+      spinner.fail(chalk26.red(`Failed to fetch task: ${e.message}`));
     }
   });
   return focus;
@@ -5219,25 +5328,25 @@ init_env();
 init_esm_shims();
 init_config();
 import { Command as Command16 } from "commander";
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 function createConfigCommand() {
   const config2 = new Command16("config");
   config2.description("View or modify Rigstate configuration").argument("[key]", "Configuration key to view/set (api_key, project_id, api_url)").argument("[value]", "Value to set").action(async (key, value) => {
     if (!key) {
-      console.log(chalk26.bold("Rigstate Configuration"));
-      console.log(chalk26.dim("\u2500".repeat(40)));
+      console.log(chalk27.bold("Rigstate Configuration"));
+      console.log(chalk27.dim("\u2500".repeat(40)));
       try {
         const apiKey = getApiKey();
-        console.log(`${chalk26.cyan("api_key")}: ${apiKey.substring(0, 20)}...`);
+        console.log(`${chalk27.cyan("api_key")}: ${apiKey.substring(0, 20)}...`);
       } catch (e) {
-        console.log(`${chalk26.cyan("api_key")}: ${chalk26.dim("(not set)")}`);
+        console.log(`${chalk27.cyan("api_key")}: ${chalk27.dim("(not set)")}`);
       }
       const projectId = getProjectId();
-      console.log(`${chalk26.cyan("project_id")}: ${projectId || chalk26.dim("(not set)")}`);
+      console.log(`${chalk27.cyan("project_id")}: ${projectId || chalk27.dim("(not set)")}`);
       const apiUrl = getApiUrl();
-      console.log(`${chalk26.cyan("api_url")}: ${apiUrl}`);
+      console.log(`${chalk27.cyan("api_url")}: ${apiUrl}`);
       console.log("");
-      console.log(chalk26.dim('Use "rigstate config <key> <value>" to set a value.'));
+      console.log(chalk27.dim('Use "rigstate config <key> <value>" to set a value.'));
       return;
     }
     if (!value) {
@@ -5247,37 +5356,37 @@ function createConfigCommand() {
             const apiKey = getApiKey();
             console.log(apiKey);
           } catch (e) {
-            console.log(chalk26.dim("(not set)"));
+            console.log(chalk27.dim("(not set)"));
           }
           break;
         case "project_id":
-          console.log(getProjectId() || chalk26.dim("(not set)"));
+          console.log(getProjectId() || chalk27.dim("(not set)"));
           break;
         case "api_url":
           console.log(getApiUrl());
           break;
         default:
-          console.log(chalk26.red(`Unknown config key: ${key}`));
-          console.log(chalk26.dim("Valid keys: api_key, project_id, api_url"));
+          console.log(chalk27.red(`Unknown config key: ${key}`));
+          console.log(chalk27.dim("Valid keys: api_key, project_id, api_url"));
       }
       return;
     }
     switch (key) {
       case "api_key":
         setApiKey(value);
-        console.log(chalk26.green(`\u2705 api_key updated`));
+        console.log(chalk27.green(`\u2705 api_key updated`));
         break;
       case "project_id":
         setProjectId(value);
-        console.log(chalk26.green(`\u2705 project_id updated`));
+        console.log(chalk27.green(`\u2705 project_id updated`));
         break;
       case "api_url":
         setApiUrl(value);
-        console.log(chalk26.green(`\u2705 api_url updated`));
+        console.log(chalk27.green(`\u2705 api_url updated`));
         break;
       default:
-        console.log(chalk26.red(`Unknown config key: ${key}`));
-        console.log(chalk26.dim("Valid keys: api_key, project_id, api_url"));
+        console.log(chalk27.red(`Unknown config key: ${key}`));
+        console.log(chalk27.dim("Valid keys: api_key, project_id, api_url"));
     }
   });
   return config2;
@@ -5287,7 +5396,7 @@ function createConfigCommand() {
 init_esm_shims();
 init_config();
 import { Command as Command17 } from "commander";
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 import { spawn } from "child_process";
 import path27 from "path";
 import fs24 from "fs";
@@ -5313,15 +5422,15 @@ function createMcpCommand() {
       }
     }
     if (!serverPath) {
-      console.error(chalk27.red("\u274C Error: Rigstate MCP Server binary not found."));
-      console.error(chalk27.yellow("Please ensure that the mcp package is built:"));
-      console.error(chalk27.white("   cd packages/mcp && npm run build"));
+      console.error(chalk28.red("\u274C Error: Rigstate MCP Server binary not found."));
+      console.error(chalk28.yellow("Please ensure that the mcp package is built:"));
+      console.error(chalk28.white("   cd packages/mcp && npm run build"));
       console.error("");
-      console.error(chalk27.dim("Or run directly with:"));
-      console.error(chalk27.white("   npx @rigstate/mcp"));
+      console.error(chalk28.dim("Or run directly with:"));
+      console.error(chalk28.white("   npx @rigstate/mcp"));
       process.exit(1);
     }
-    console.log(chalk27.dim(`Starting MCP server from: ${serverPath}`));
+    console.log(chalk28.dim(`Starting MCP server from: ${serverPath}`));
     const env = { ...process.env };
     try {
       const apiKey = getApiKey();
@@ -5340,7 +5449,7 @@ function createMcpCommand() {
       stdio: ["inherit", "inherit", "inherit"]
     });
     worker.on("error", (err) => {
-      console.error(chalk27.red(`\u274C Failed to start MCP server: ${err.message}`));
+      console.error(chalk28.red(`\u274C Failed to start MCP server: ${err.message}`));
       process.exit(1);
     });
     worker.on("exit", (code) => {
@@ -5355,7 +5464,7 @@ function createMcpCommand() {
 // src/commands/nexus.ts
 init_esm_shims();
 import { Command as Command18 } from "commander";
-import chalk29 from "chalk";
+import chalk30 from "chalk";
 // src/nexus/dispatcher.ts
 init_esm_shims();
@@ -5423,7 +5532,7 @@ var HiveScrubber = class {
 };
 // src/hive/gateway.ts
-import chalk28 from "chalk";
+import chalk29 from "chalk";
 var HiveGateway = class {
   client;
   enabled;
@@ -5433,7 +5542,7 @@ var HiveGateway = class {
   constructor(baseUrl, token) {
     this.enabled = !!token;
     if (!this.enabled) {
-      console.log(chalk28.dim("\u26A0\uFE0F Hive Gateway disabled (No Token provided). Running in localized mode."));
+      console.log(chalk29.dim("\u26A0\uFE0F Hive Gateway disabled (No Token provided). Running in localized mode."));
     }
     this.client = axios20.create({
       baseURL: baseUrl,
@@ -5453,23 +5562,23 @@ var HiveGateway = class {
     if (!this.enabled) return false;
     const now = Date.now();
     if (now - this.lastSignalTime < this.MIN_INTERVAL_MS) {
-      console.warn(chalk28.yellow("\u23F3 Hive Gateway Throttled. Signal dropped to preventing spam."));
+      console.warn(chalk29.yellow("\u23F3 Hive Gateway Throttled. Signal dropped to preventing spam."));
       return false;
     }
     const scrubResult = HiveScrubber.scrub(signal.ruleContent);
     if (scrubResult.riskScore > 20) {
-      console.error(chalk28.red(`\u{1F6D1} HIVE BLOCKED: Signal contains sensitive data (Risk: ${scrubResult.riskScore})`));
+      console.error(chalk29.red(`\u{1F6D1} HIVE BLOCKED: Signal contains sensitive data (Risk: ${scrubResult.riskScore})`));
       return false;
     }
     try {
-      console.log(chalk28.blue(`\u{1F4E1} Uplinking to Hive... [${signal.vector}]`));
+      console.log(chalk29.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(chalk28.green("\u2705 Signal Received by Hive Core. Knowledge Shared."));
+      console.log(chalk29.green("\u2705 Signal Received by Hive Core. Knowledge Shared."));
       return true;
     } catch (error) {
-      console.error(chalk28.red(`\u274C Hive Transmission Failed: ${error.message}`));
+      console.error(chalk29.red(`\u274C Hive Transmission Failed: ${error.message}`));
       return false;
     }
   }
@@ -5571,10 +5680,10 @@ import inquirer4 from "inquirer";
 function createNexusCommand() {
   const command = new Command18("nexus");
   command.description("Interact with The Multi-Agent Nexus (Phase 8)").argument("<intent>", "The natural language instruction for the swarm").option("--dry-run", "Enable Dry-Run mode (Kill-Switch Active)", true).option("--force", "Disable Dry-Run mode (DANGEROUS)", false).action(async (intent, options) => {
-    console.log(chalk29.bold.magenta("\n\u{1F981} Welcome to The Nexus (Phase 8)\n"));
+    console.log(chalk30.bold.magenta("\n\u{1F981} Welcome to The Nexus (Phase 8)\n"));
     const dryRun = !options.force;
     if (!dryRun) {
-      console.log(chalk29.black.bgYellow(" WARNING ") + chalk29.yellow(" Dry-Run disabled! Eitri is authorized to write code."));
+      console.log(chalk30.black.bgYellow(" WARNING ") + chalk30.yellow(" Dry-Run disabled! Eitri is authorized to write code."));
       const { confirm } = await inquirer4.prompt([{
         type: "confirm",
         name: "confirm",
@@ -5595,26 +5704,26 @@ function createNexusCommand() {
     };
     const dispatcher = new NexusDispatcher(context);
     dispatcher.on("order:created", (o) => {
-      console.log(chalk29.blue(`\u{1F195} [${o.id.slice(0, 6)}] Order Created: `) + o.intent);
+      console.log(chalk30.blue(`\u{1F195} [${o.id.slice(0, 6)}] Order Created: `) + o.intent);
     });
     dispatcher.on("order:started", (o) => {
-      console.log(chalk29.yellow(`\u23F3 [${o.id.slice(0, 6)}] Processing...`));
+      console.log(chalk30.yellow(`\u23F3 [${o.id.slice(0, 6)}] Processing...`));
     });
     dispatcher.on("order:blocked", (o) => {
-      console.log(chalk29.red(`\u{1F6D1} [${o.id.slice(0, 6)}] BLOCKED by Kill-Switch`));
-      console.log(chalk29.dim(`   Target: ${o.targetAgent} | Action: ${o.action}`));
-      console.log(chalk29.dim("   Run with --force to execute automatically (NOT RECOMMENDED)."));
+      console.log(chalk30.red(`\u{1F6D1} [${o.id.slice(0, 6)}] BLOCKED by Kill-Switch`));
+      console.log(chalk30.dim(`   Target: ${o.targetAgent} | Action: ${o.action}`));
+      console.log(chalk30.dim("   Run with --force to execute automatically (NOT RECOMMENDED)."));
     });
-    dispatcher.on("agent:SINDRE", (o) => console.log(chalk29.cyan(`\u{1F916} Sindre (Vault): I'm on it! (${o.action})`)));
-    dispatcher.on("agent:EITRI", (o) => console.log(chalk29.green(`\u{1F477} Eitri (Smith): Ready to build! (${o.action})`)));
-    console.log(chalk29.dim("\u{1F9E0} Frank is analyzing your intent..."));
+    dispatcher.on("agent:SINDRE", (o) => console.log(chalk30.cyan(`\u{1F916} Sindre (Vault): I'm on it! (${o.action})`)));
+    dispatcher.on("agent:EITRI", (o) => console.log(chalk30.green(`\u{1F477} Eitri (Smith): Ready to build! (${o.action})`)));
+    console.log(chalk30.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(chalk29.gray("Frank didn't understand. Try 'create file' or 'check database'."));
+      console.log(chalk30.gray("Frank didn't understand. Try 'create file' or 'check database'."));
     }
   });
   return command;
@@ -5628,25 +5737,25 @@ init_esm_shims();
 init_governance();
 init_config();
 import { Command as Command19 } from "commander";
-import chalk30 from "chalk";
+import chalk31 from "chalk";
 import axios21 from "axios";
 function createOverrideCommand() {
   const override = new Command19("override");
   override.description("Emergency Override for Governance Soft Locks").argument("<violationId>", 'ID of the violation to override (or "all")').requiredOption("-r, --reason <reason>", "Description of why this override is necessary").action(async (violationId, options) => {
     const { reason } = options;
-    console.log(chalk30.bold(`
+    console.log(chalk31.bold(`
 \u{1F513} Initiating Governance Override Protocol...`));
     const session = await getSessionState(process.cwd());
     if (session.status !== "SOFT_LOCK") {
-      console.log(chalk30.yellow("   Info: Session is not currently locked."));
+      console.log(chalk31.yellow("   Info: Session is not currently locked."));
       return;
     }
-    console.log(chalk30.dim(`   Active Violation: ${session.active_violation}`));
-    console.log(chalk30.dim(`   Reason Provided:  "${reason}"`));
+    console.log(chalk31.dim(`   Active Violation: ${session.active_violation}`));
+    console.log(chalk31.dim(`   Reason Provided:  "${reason}"`));
     const success = await performOverride(violationId, reason, process.cwd());
     if (success) {
-      console.log(chalk30.green(`   \u2705 Session UNLOCKED.`));
-      console.log(chalk30.dim(`   This event has been logged to the Mission Report.`));
+      console.log(chalk31.green(`   \u2705 Session UNLOCKED.`));
+      console.log(chalk31.dim(`   This event has been logged to the Mission Report.`));
       try {
         const projectId = getProjectId();
         if (projectId) {
@@ -5663,13 +5772,13 @@ function createOverrideCommand() {
           }, {
             headers: { Authorization: `Bearer ${apiKey}` }
           });
-          console.log(chalk30.dim(`   \u2601 Audit log synced to Cloud.`));
+          console.log(chalk31.dim(`   \u2601 Audit log synced to Cloud.`));
         }
       } catch (e) {
-        console.log(chalk30.dim(`   (Cloud audit sync failed: ${e.message})`));
+        console.log(chalk31.dim(`   (Cloud audit sync failed: ${e.message})`));
       }
     } else {
-      console.log(chalk30.red(`   \u{1F6D1} Override Failed. Check project configuration.`));
+      console.log(chalk31.red(`   \u{1F6D1} Override Failed. Check project configuration.`));
     }
   });
   return override;
@@ -5679,7 +5788,7 @@ function createOverrideCommand() {
 init_esm_shims();
 init_config();
 import { Command as Command20 } from "commander";
-import chalk31 from "chalk";
+import chalk32 from "chalk";
 import ora13 from "ora";
 import axios22 from "axios";
 import inquirer5 from "inquirer";
@@ -5690,7 +5799,7 @@ function createIdeaCommand() {
       const apiUrl = getApiUrl();
       const projectId = getProjectId();
       if (!projectId) {
-        console.error(chalk31.red("Project context missing. Run rigstate link."));
+        console.error(chalk32.red("Project context missing. Run rigstate link."));
         process.exit(1);
       }
       let ideaTitle = title;
@@ -5726,14 +5835,14 @@ function createIdeaCommand() {
         { headers: { Authorization: `Bearer ${apiKey}` } }
       );
       if (response.data.success) {
-        spinner.succeed(chalk31.green("Idea Captured! \u{1F4A1}"));
-        console.log(chalk31.dim(`ID: ${response.data.data?.id || "Saved"}`));
+        spinner.succeed(chalk32.green("Idea Captured! \u{1F4A1}"));
+        console.log(chalk32.dim(`ID: ${response.data.data?.id || "Saved"}`));
       } else {
         throw new Error(response.data.error);
       }
     } catch (e) {
       const errorDetail = e.response?.data?.error || e.message;
-      console.error(chalk31.red(`
+      console.error(chalk32.red(`
 Failed to capture idea: ${errorDetail}`));
     }
   });
@@ -5743,7 +5852,7 @@ Failed to capture idea: ${errorDetail}`));
 init_esm_shims();
 init_config();
 import { Command as Command21 } from "commander";
-import chalk32 from "chalk";
+import chalk33 from "chalk";
 import ora14 from "ora";
 import inquirer6 from "inquirer";
 import fs25 from "fs/promises";
@@ -8617,7 +8726,7 @@ function versionParser(stdOut) {
 }
 var NOT_INSTALLED;
 var parsers7;
-var init_version = __esm2({
+var init_version2 = __esm2({
   "src/lib/tasks/version.ts"() {
     "use strict";
     init_utils();
@@ -8665,7 +8774,7 @@ var init_simple_git_api = __esm2({
     init_show();
     init_status();
     init_task();
-    init_version();
+    init_version2();
     init_utils();
     SimpleGitApi = class {
       constructor(_executor) {
@@ -10319,7 +10428,7 @@ function createReleaseCommand() {
       if (type === "major") newVersion = `${major + 1}.0.0`;
       if (type === "minor") newVersion = `${major}.${minor + 1}.0`;
       if (type === "patch") newVersion = `${major}.${minor}.${patch + 1}`;
-      spinner.succeed(`Bumping ${pkg2.name} from ${chalk32.dim(currentVersion)} to ${chalk32.green(newVersion)}`);
+      spinner.succeed(`Bumping ${pkg2.name} from ${chalk33.dim(currentVersion)} to ${chalk33.green(newVersion)}`);
       const { confirm } = await inquirer6.prompt([{
         type: "confirm",
         name: "confirm",
@@ -10349,7 +10458,7 @@ function createReleaseCommand() {
       await git.addTag(`v${newVersion}`);
       await git.push();
       await git.pushTags();
-      spinner.succeed(chalk32.bold.green(`\u{1F680} Release v${newVersion} shipped!`));
+      spinner.succeed(chalk33.bold.green(`\u{1F680} Release v${newVersion} shipped!`));
     } catch (e) {
       spinner.fail(e.message);
     }
@@ -10367,7 +10476,7 @@ function getContext3() {
 init_esm_shims();
 init_config();
 import { Command as Command22 } from "commander";
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 import ora15 from "ora";
 import axios23 from "axios";
 function createRoadmapCommand() {
@@ -10378,7 +10487,7 @@ function createRoadmapCommand() {
       const apiUrl = getApiUrl();
       const projectId = getProjectId();
       if (!projectId) {
-        spinner.fail(chalk33.red('Project context missing. Run "rigstate link".'));
+        spinner.fail(chalk34.red('Project context missing. Run "rigstate link".'));
         return;
       }
       const response = await axios23.get(
@@ -10391,11 +10500,11 @@ function createRoadmapCommand() {
       const tasks = response.data.data.roadmap || [];
       spinner.stop();
       if (tasks.length === 0) {
-        console.log(chalk33.yellow("\nRoadmap is empty. Use the web UI to define your journey."));
+        console.log(chalk34.yellow("\nRoadmap is empty. Use the web UI to define your journey."));
         return;
       }
-      console.log("\n" + chalk33.bold.underline("\u{1F6F0}\uFE0F  TACTICAL OVERVIEW: PROJECT ROADMAP"));
-      console.log(chalk33.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log("\n" + chalk34.bold.underline("\u{1F6F0}\uFE0F  TACTICAL OVERVIEW: PROJECT ROADMAP"));
+      console.log(chalk34.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
       const columns = {
         "IN_PROGRESS": [],
         "ACTIVE": [],
@@ -10407,14 +10516,14 @@ function createRoadmapCommand() {
           columns[t.status].push(t);
         }
       });
-      displayColumn("\u{1F525} IN PROGRESS", columns.IN_PROGRESS, chalk33.yellow);
-      displayColumn("\u25B6\uFE0F  ACTIVE / NEXT", columns.ACTIVE, chalk33.green);
-      displayColumn("\u{1F512} LOCKED", columns.LOCKED, chalk33.blue);
-      displayColumn("\u23F3 PENDING", columns.PENDING, chalk33.gray);
-      console.log(chalk33.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(chalk33.dim(`Total: ${tasks.length} tasks | Run "rigstate work" to start coding.`));
+      displayColumn("\u{1F525} IN PROGRESS", columns.IN_PROGRESS, chalk34.yellow);
+      displayColumn("\u25B6\uFE0F  ACTIVE / NEXT", columns.ACTIVE, chalk34.green);
+      displayColumn("\u{1F512} LOCKED", columns.LOCKED, chalk34.blue);
+      displayColumn("\u23F3 PENDING", columns.PENDING, chalk34.gray);
+      console.log(chalk34.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk34.dim(`Total: ${tasks.length} tasks | Run "rigstate work" to start coding.`));
     } catch (e) {
-      spinner.fail(chalk33.red(`
+      spinner.fail(chalk34.red(`
 Failed to fetch roadmap: ${e.message}`));
     }
   });
@@ -10425,8 +10534,8 @@ function displayColumn(title, items, color) {
 ${color.bold(title)}`);
   items.sort((a, b) => a.step_number - b.step_number).forEach((item) => {
     const id = `T-${item.step_number}`.padEnd(8);
-    const priority = item.priority === "MVP" ? chalk33.magenta(" [MVP]") : "";
-    console.log(` ${color("\u2022")} ${chalk33.bold(id)} ${item.title}${priority}`);
+    const priority = item.priority === "MVP" ? chalk34.magenta(" [MVP]") : "";
+    console.log(` ${color("\u2022")} ${chalk34.bold(id)} ${item.title}${priority}`);
   });
 }
@@ -10434,7 +10543,7 @@ ${color.bold(title)}`);
 init_esm_shims();
 init_config();
 import { Command as Command23 } from "commander";
-import chalk34 from "chalk";
+import chalk35 from "chalk";
 import ora16 from "ora";
 import inquirer7 from "inquirer";
 function createCouncilCommand() {
@@ -10445,7 +10554,7 @@ function createCouncilCommand() {
       const apiUrl = getApiUrl();
       const projectId = getProjectId();
       if (!projectId) {
-        console.error(chalk34.red('Project context missing. Run "rigstate link".'));
+        console.error(chalk35.red('Project context missing. Run "rigstate link".'));
         return;
       }
       let sessionTopic = topic;
@@ -10457,25 +10566,25 @@ function createCouncilCommand() {
         }]);
         sessionTopic = ans.topic;
       }
-      console.log(chalk34.bold.magenta("\n\u2696\uFE0F  CONVENING THE COUNCIL OF SOVEREIGNTY\n"));
-      console.log(chalk34.dim(`Topic: ${sessionTopic}`));
-      console.log(chalk34.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(chalk34.yellow("\n\u{1F9E0} Frank (Architect): Analyzing alignment with Project DNA..."));
+      console.log(chalk35.bold.magenta("\n\u2696\uFE0F  CONVENING THE COUNCIL OF SOVEREIGNTY\n"));
+      console.log(chalk35.dim(`Topic: ${sessionTopic}`));
+      console.log(chalk35.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk35.yellow("\n\u{1F9E0} Frank (Architect): Analyzing alignment with Project DNA..."));
       await sleep(1500);
-      console.log(chalk34.gray('  "This decision affects our backend scalability. I recommend caution."'));
-      console.log(chalk34.blue("\n\u{1F6E1}\uFE0F  Sigrid (Curator): Checking historical precedents..."));
+      console.log(chalk35.gray('  "This decision affects our backend scalability. I recommend caution."'));
+      console.log(chalk35.blue("\n\u{1F6E1}\uFE0F  Sigrid (Curator): Checking historical precedents..."));
       await sleep(1500);
-      console.log(chalk34.gray(`  "Similar patterns in other projects led to technical debt. Let's review RLS."`));
-      console.log(chalk34.green("\n\u{1F4D0} Einar (Analyst): Scanning dependency impact..."));
+      console.log(chalk35.gray(`  "Similar patterns in other projects led to technical debt. Let's review RLS."`));
+      console.log(chalk35.green("\n\u{1F4D0} Einar (Analyst): Scanning dependency impact..."));
       await sleep(1500);
-      console.log(chalk34.gray('  "Implementation will require updating 3 core services."'));
-      console.log(chalk34.bold.white("\n\u{1F4CB} [FINAL DECISION RECORD]"));
-      console.log(chalk34.white("  Status:    Approved with conditions"));
-      console.log(chalk34.white("  Rationale: Value outweighs migration cost. Ensure SEC-SQL-01 compliance."));
-      console.log(chalk34.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(chalk34.green("\u2705 Decision saved to Project Brain (ADR-102)"));
+      console.log(chalk35.gray('  "Implementation will require updating 3 core services."'));
+      console.log(chalk35.bold.white("\n\u{1F4CB} [FINAL DECISION RECORD]"));
+      console.log(chalk35.white("  Status:    Approved with conditions"));
+      console.log(chalk35.white("  Rationale: Value outweighs migration cost. Ensure SEC-SQL-01 compliance."));
+      console.log(chalk35.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk35.green("\u2705 Decision saved to Project Brain (ADR-102)"));
     } catch (e) {
-      console.error(chalk34.red(`
+      console.error(chalk35.red(`
 Council session aborted: ${e.message}`));
     }
   });
@@ -10484,12 +10593,8 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-// src/utils/version.ts
-init_esm_shims();
-async function checkVersion() {
-}
 // src/index.ts
+init_version();
 import dotenv from "dotenv";
 var pkg = require_package();
 dotenv.config();
@@ -10523,19 +10628,19 @@ program.hook("preAction", async () => {
 });
 program.on("--help", () => {
   console.log("");
-  console.log(chalk35.bold("Examples:"));
+  console.log(chalk36.bold("Examples:"));
   console.log("");
-  console.log(chalk35.cyan("  $ rigstate login sk_rigstate_your_api_key"));
-  console.log(chalk35.dim("    Authenticate with your Rigstate API key"));
+  console.log(chalk36.cyan("  $ rigstate login sk_rigstate_your_api_key"));
+  console.log(chalk36.dim("    Authenticate with your Rigstate API key"));
   console.log("");
-  console.log(chalk35.cyan("  $ rigstate scan"));
-  console.log(chalk35.dim("    Scan the current directory"));
+  console.log(chalk36.cyan("  $ rigstate scan"));
+  console.log(chalk36.dim("    Scan the current directory"));
   console.log("");
-  console.log(chalk35.cyan("  $ rigstate scan ./src --project abc123"));
-  console.log(chalk35.dim("    Scan a specific directory with project ID"));
+  console.log(chalk36.cyan("  $ rigstate scan ./src --project abc123"));
+  console.log(chalk36.dim("    Scan a specific directory with project ID"));
   console.log("");
-  console.log(chalk35.cyan("  $ rigstate scan --json"));
-  console.log(chalk35.dim("    Output results in JSON format (useful for IDE extensions)"));
+  console.log(chalk36.cyan("  $ rigstate scan --json"));
+  console.log(chalk36.dim("    Output results in JSON format (useful for IDE extensions)"));
   console.log("");
 });
 program.parse(process.argv);