@rigstate/cli 0.7.32 → 0.7.35

package/dist/index.cjs

@@ -59,6 +59,24 @@ __export(config_exports, {
   setProjectId: () => setProjectId
 });
 function getApiKey() {
+  try {
+    const cwd = process.cwd();
+    const manifestPaths = [
+      import_path.default.join(cwd, ".rigstate", "identity.json"),
+      import_path.default.join(cwd, ".rigstate")
+    ];
+    for (const manifestPath of manifestPaths) {
+      if (import_fs.default.existsSync(manifestPath) && import_fs.default.statSync(manifestPath).isFile()) {
+        const content = import_fs.default.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(
@@ -71,12 +89,54 @@ function setApiKey(key) {
   config.set("apiKey", key);
 }
 function getProjectId() {
-  return config.get("projectId");
+  try {
+    const cwd = process.cwd();
+    const manifestPaths = [
+      import_path.default.join(cwd, ".rigstate", "identity.json"),
+      import_path.default.join(cwd, ".rigstate")
+    ];
+    for (const manifestPath of manifestPaths) {
+      if (import_fs.default.existsSync(manifestPath) && import_fs.default.statSync(manifestPath).isFile()) {
+        const content = import_fs.default.readFileSync(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        if (manifest.project_id) {
+          console.log(import_chalk.default.dim(`   [Auth] Context: Project ID ${manifest.project_id.substring(0, 8)}... (from ${import_path.default.basename(manifestPath)})`));
+          return manifest.project_id;
+        }
+      }
+    }
+  } catch (e) {
+    console.log(import_chalk.default.red(`   [Error] Failed to read context: ${e.message}`));
+  }
+  if (process.env.RIGSTATE_PROJECT_ID) {
+    console.log(import_chalk.default.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(import_chalk.default.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 = [
+      import_path.default.join(cwd, ".rigstate", "identity.json"),
+      import_path.default.join(cwd, ".rigstate")
+    ];
+    for (const manifestPath of manifestPaths) {
+      if (import_fs.default.existsSync(manifestPath) && import_fs.default.statSync(manifestPath).isFile()) {
+        const content = import_fs.default.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;
   }
@@ -92,12 +152,15 @@ function setApiUrl(url) {
 function clearConfig() {
   config.clear();
 }
-var import_conf, config;
+var import_conf, import_chalk, import_fs, import_path, config;
 var init_config = __esm({
   "src/utils/config.ts"() {
     "use strict";
     init_cjs_shims();
     import_conf = __toESM(require("conf"), 1);
+    import_chalk = __toESM(require("chalk"), 1);
+    import_fs = __toESM(require("fs"), 1);
+    import_path = __toESM(require("path"), 1);
     config = new import_conf.default({
       projectName: "rigstate-cli",
       defaults: {
@@ -107,6 +170,66 @@ var init_config = __esm({
   }
 });
 
+// src/utils/manifest.ts
+var manifest_exports = {};
+__export(manifest_exports, {
+  loadManifest: () => loadManifest,
+  saveManifest: () => saveManifest
+});
+async function loadManifest() {
+  const cwd = process.cwd();
+  const manifestPaths = [
+    import_path2.default.join(cwd, ".rigstate", "identity.json"),
+    import_path2.default.join(cwd, ".rigstate")
+  ];
+  for (const p of manifestPaths) {
+    try {
+      if (import_fs2.default.existsSync(p) && import_fs2.default.statSync(p).isFile()) {
+        const content = await import_promises.default.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 = import_path2.default.join(cwd, ".rigstate");
+  let targetFile = rigstatePath;
+  try {
+    const stats = await import_promises.default.stat(rigstatePath);
+    if (stats.isDirectory()) {
+      targetFile = import_path2.default.join(rigstatePath, "identity.json");
+    }
+  } catch (e) {
+  }
+  const existing = await loadManifest() || {};
+  const merged = { ...existing, ...data };
+  if (targetFile.endsWith("identity.json")) {
+    await import_promises.default.mkdir(rigstatePath, { recursive: true });
+  }
+  await import_promises.default.writeFile(targetFile, JSON.stringify(merged, null, 2), "utf-8");
+  return targetFile;
+}
+var import_promises, import_fs2, import_path2;
+var init_manifest = __esm({
+  "src/utils/manifest.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises = __toESM(require("fs/promises"), 1);
+    import_fs2 = __toESM(require("fs"), 1);
+    import_path2 = __toESM(require("path"), 1);
+  }
+});
+
 // src/commands/env.ts
 var env_exports = {};
 __export(env_exports, {
@@ -116,9 +239,9 @@ __export(env_exports, {
 async function syncEnv(projectId, apiKey, apiUrl, silent = false) {
   if (!silent) {
     console.log("");
-    console.log(import_chalk2.default.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(import_chalk2.default.bold.yellow("\u2551") + import_chalk2.default.bold.white("  \u{1F6E1}\uFE0F  RIGSTATE SOVEREIGN VAULT SYNC  \u{1F6E1}\uFE0F   ") + import_chalk2.default.bold.yellow("\u2551"));
-    console.log(import_chalk2.default.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(import_chalk3.default.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(import_chalk3.default.bold.yellow("\u2551") + import_chalk3.default.bold.white("  \u{1F6E1}\uFE0F  RIGSTATE SOVEREIGN VAULT SYNC  \u{1F6E1}\uFE0F   ") + import_chalk3.default.bold.yellow("\u2551"));
+    console.log(import_chalk3.default.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 = (0, import_ora.default)("Fetching secrets from Vault...").start();
@@ -135,15 +258,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(import_chalk2.default.dim("  Add secrets via the Rigstate web interface."));
+      if (!silent) console.log(import_chalk3.default.dim("  Add secrets via the Rigstate web interface."));
       return true;
     }
-    spinner.succeed(`Retrieved ${import_chalk2.default.bold(secretCount)} secret(s)`);
-    const envFile = import_path.default.resolve(process.cwd(), ".env.local");
+    spinner.succeed(`Retrieved ${import_chalk3.default.bold(secretCount)} secret(s)`);
+    const envFile = import_path3.default.resolve(process.cwd(), ".env.local");
     let existingContent = "";
     let existingKeys = /* @__PURE__ */ new Set();
     try {
-      existingContent = await import_promises.default.readFile(envFile, "utf-8");
+      existingContent = await import_promises2.default.readFile(envFile, "utf-8");
       existingContent.split("\n").forEach((line) => {
         const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
         if (match) existingKeys.add(match[1]);
@@ -175,25 +298,25 @@ async function syncEnv(projectId, apiKey, apiUrl, silent = false) {
       "# ==========================================",
       ""
     ].join("\n");
-    await import_promises.default.writeFile(envFile, header + vaultContent + "\n");
+    await import_promises2.default.writeFile(envFile, header + vaultContent + "\n");
     spinner.succeed("Written to .env.local");
     if (!silent) {
       console.log("");
-      console.log(import_chalk2.default.bold.green("\u2705 Environment synchronized successfully"));
+      console.log(import_chalk3.default.bold.green("\u2705 Environment synchronized successfully"));
       console.log("");
-      console.log(import_chalk2.default.dim("   Summary:"));
-      console.log(import_chalk2.default.green(`   + ${newCount} new`));
-      console.log(import_chalk2.default.yellow(`   ~ ${updatedCount} updated`));
-      console.log(import_chalk2.default.dim(`   = ${unchangedCount} unchanged`));
+      console.log(import_chalk3.default.dim("   Summary:"));
+      console.log(import_chalk3.default.green(`   + ${newCount} new`));
+      console.log(import_chalk3.default.yellow(`   ~ ${updatedCount} updated`));
+      console.log(import_chalk3.default.dim(`   = ${unchangedCount} unchanged`));
       console.log("");
-      console.log(import_chalk2.default.bold.yellow("\u26A0\uFE0F  Security Reminder:"));
-      console.log(import_chalk2.default.dim("   - Never commit .env.local to version control."));
-      console.log(import_chalk2.default.dim("   - Ensure .gitignore includes .env.local"));
+      console.log(import_chalk3.default.bold.yellow("\u26A0\uFE0F  Security Reminder:"));
+      console.log(import_chalk3.default.dim("   - Never commit .env.local to version control."));
+      console.log(import_chalk3.default.dim("   - Ensure .gitignore includes .env.local"));
       console.log("");
     }
     return true;
   } catch (e) {
-    spinner.fail(import_chalk2.default.red(`Failed to fetch secrets: ${e.message}`));
+    spinner.fail(import_chalk3.default.red(`Failed to fetch secrets: ${e.message}`));
     return false;
   }
 }
@@ -205,21 +328,17 @@ function createEnvPullCommand() {
     try {
       apiKey = getApiKey();
     } catch (e) {
-      console.error(import_chalk2.default.red('Not authenticated. Run "rigstate login" first.'));
+      console.error(import_chalk3.default.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
-      try {
-        const manifestPath = import_path.default.join(process.cwd(), ".rigstate");
-        const content = await import_promises.default.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(import_chalk2.default.red('No project context. Run "rigstate link" first.'));
+      console.error(import_chalk3.default.red('No project context. Run "rigstate link" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -227,28 +346,40 @@ function createEnvPullCommand() {
   });
   return envPull;
 }
-var import_commander2, import_chalk2, import_ora, import_promises, import_path, import_axios;
+var import_commander2, import_chalk3, import_ora, import_promises2, import_path3, import_axios;
 var init_env = __esm({
   "src/commands/env.ts"() {
     "use strict";
     init_cjs_shims();
     import_commander2 = require("commander");
-    import_chalk2 = __toESM(require("chalk"), 1);
+    import_chalk3 = __toESM(require("chalk"), 1);
     import_ora = __toESM(require("ora"), 1);
-    import_promises = __toESM(require("fs/promises"), 1);
-    import_path = __toESM(require("path"), 1);
+    import_promises2 = __toESM(require("fs/promises"), 1);
+    import_path3 = __toESM(require("path"), 1);
     init_config();
     import_axios = __toESM(require("axios"), 1);
   }
 });
 
+// src/utils/version.ts
+async function checkVersion() {
+}
+var CLI_VERSION;
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+    init_cjs_shims();
+    CLI_VERSION = "0.7.34";
+  }
+});
+
 // src/commands/sync-rules.ts
 var sync_rules_exports = {};
 __export(sync_rules_exports, {
   createSyncRulesCommand: () => createSyncRulesCommand,
   syncProjectRules: () => syncProjectRules
 });
-async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
+async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false, version = CLI_VERSION) {
   const spinner = (0, import_ora2.default)("\u{1F6E1}\uFE0F Frank Protocol: Initializing retroactive sync...").start();
   let success = true;
   try {
@@ -263,7 +394,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(import_chalk3.default.yellow(`  [DRY-RUN] Would sync: ${project.name}`));
+      spinner.succeed(import_chalk4.default.yellow(`  [DRY-RUN] Would sync: ${project.name}`));
       return true;
     }
     const syncResponse = await import_axios2.default.post(`${apiUrl}/api/v1/rules/sync`, {
@@ -273,9 +404,9 @@ async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
     });
     if (syncResponse.data.success) {
       if (syncResponse.data.data.github_synced) {
-        spinner.succeed(import_chalk3.default.green(`  \u2705 ${project.name} [${project.id}] \u2192 GitHub synced`));
+        spinner.succeed(import_chalk4.default.green(`  \u2705 ${project.name} [${project.id}] \u2192 GitHub synced`));
       } else {
-        spinner.info(import_chalk3.default.blue(`  \u2139\uFE0F ${project.name} [${project.id}] \u2192 Rules generated (no GitHub)`));
+        spinner.info(import_chalk4.default.blue(`  \u2139\uFE0F ${project.name} [${project.id}] \u2192 Rules generated (no GitHub)`));
       }
       const files = syncResponse.data.data.files;
       if (files && Array.isArray(files)) {
@@ -286,7 +417,7 @@ async function syncProjectRules(projectId, apiKey, apiUrl, dryRun = false) {
           await fs26.mkdir(path28.dirname(filePath), { recursive: true });
           await fs26.writeFile(filePath, file.content, "utf-8");
         }
-        console.log(import_chalk3.default.dim(`      \u{1F4BE} Wrote ${files.length} rule files to local .cursor/rules/`));
+        console.log(import_chalk4.default.dim(`      \u{1F4BE} Wrote ${files.length} rule files to local .cursor/rules/`));
         try {
           const masterPath = path28.join(process.cwd(), ".cursorrules");
           let masterContent = "";
@@ -300,7 +431,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:
@@ -321,20 +452,20 @@ ${END_MARKER}`;
 ${governanceBlock}` : governanceBlock;
           }
           await fs26.writeFile(masterPath, newContent, "utf-8");
-          console.log(import_chalk3.default.dim("      \u{1F4DC} Updated master .cursorrules (Constitution enforced)"));
+          console.log(import_chalk4.default.dim("      \u{1F4DC} Updated master .cursorrules (Constitution enforced)"));
         } catch (e) {
-          console.warn(import_chalk3.default.yellow(`      \u26A0\uFE0F  Could not update .cursorrules: ${e.message}`));
+          console.warn(import_chalk4.default.yellow(`      \u26A0\uFE0F  Could not update .cursorrules: ${e.message}`));
         }
       }
       console.log("");
-      console.log(import_chalk3.default.cyan("\u{1F6E1}\uFE0F Frank Protocol v1.0 has been injected into the rules engine."));
-      console.log(import_chalk3.default.dim("   All new chats will now boot with mandatory governance checks."));
+      console.log(import_chalk4.default.cyan("\u{1F6E1}\uFE0F Frank Protocol v1.0 has been injected into the rules engine."));
+      console.log(import_chalk4.default.dim("   All new chats will now boot with mandatory governance checks."));
     } else {
-      spinner.warn(import_chalk3.default.yellow(`  \u26A0\uFE0F ${project.name} \u2192 ${syncResponse.data.error || "Unknown error"}`));
+      spinner.warn(import_chalk4.default.yellow(`  \u26A0\uFE0F ${project.name} \u2192 ${syncResponse.data.error || "Unknown error"}`));
       success = false;
     }
   } catch (e) {
-    spinner.fail(import_chalk3.default.red(`Sync failed: ${e.message}`));
+    spinner.fail(import_chalk4.default.red(`Sync failed: ${e.message}`));
     success = false;
   }
   return success;
@@ -346,30 +477,29 @@ function createSyncRulesCommand() {
     try {
       apiKey = getApiKey();
     } catch (e) {
-      console.error(import_chalk3.default.red('Not authenticated. Run "rigstate login" first.'));
+      console.error(import_chalk4.default.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(import_chalk3.default.yellow("Use --project <id> for now. (Mass sync logic awaiting migration)"));
+      console.log(import_chalk4.default.yellow("Use --project <id> for now. (Mass sync logic awaiting migration)"));
     }
   });
   return syncRules;
 }
-var import_commander3, import_chalk3, import_ora2, import_axios2, import_module, require2;
+var import_commander3, import_chalk4, import_ora2, import_axios2;
 var init_sync_rules = __esm({
   "src/commands/sync-rules.ts"() {
     "use strict";
     init_cjs_shims();
     import_commander3 = require("commander");
-    import_chalk3 = __toESM(require("chalk"), 1);
+    import_chalk4 = __toESM(require("chalk"), 1);
     import_ora2 = __toESM(require("ora"), 1);
     init_config();
     import_axios2 = __toESM(require("axios"), 1);
-    import_module = require("module");
-    require2 = (0, import_module.createRequire)(importMetaUrl);
+    init_version();
   }
 });
 
@@ -396,28 +526,28 @@ async function suggestNextMove(projectId, apiKey, apiUrl) {
     if (tasks.length === 0) return;
     const nextTask = tasks[0];
     console.log("");
-    console.log(import_chalk4.default.bold("\u{1F3AF} TACTICAL INTELLIGENCE"));
-    console.log(import_chalk4.default.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(`${import_chalk4.default.bold("Active Phase:")}  Implementation`);
-    console.log(`${import_chalk4.default.bold("Next Mission:")}  ${import_chalk4.default.cyan(nextTask.title)}`);
+    console.log(import_chalk5.default.bold("\u{1F3AF} TACTICAL INTELLIGENCE"));
+    console.log(import_chalk5.default.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(`${import_chalk5.default.bold("Active Phase:")}  Implementation`);
+    console.log(`${import_chalk5.default.bold("Next Mission:")}  ${import_chalk5.default.cyan(nextTask.title)}`);
     if (nextTask.role) {
-      console.log(`${import_chalk4.default.bold("Required Role:")} ${import_chalk4.default.magenta(nextTask.role)}`);
+      console.log(`${import_chalk5.default.bold("Required Role:")} ${import_chalk5.default.magenta(nextTask.role)}`);
     }
     console.log("");
-    console.log(import_chalk4.default.yellow("SUGGESTED NEXT MOVE:"));
-    console.log(import_chalk4.default.white(`> rigstate work start ${nextTask.id}   `) + import_chalk4.default.dim("(Start this task)"));
-    console.log(import_chalk4.default.white(`> rigstate chat "How do I solve T-${nextTask.step_number}?" `) + import_chalk4.default.dim("(Ask Architect)"));
-    console.log(import_chalk4.default.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(import_chalk5.default.yellow("SUGGESTED NEXT MOVE:"));
+    console.log(import_chalk5.default.white(`> rigstate work start ${nextTask.id}   `) + import_chalk5.default.dim("(Start this task)"));
+    console.log(import_chalk5.default.white(`> rigstate chat "How do I solve T-${nextTask.step_number}?" `) + import_chalk5.default.dim("(Ask Architect)"));
+    console.log(import_chalk5.default.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     console.log("");
   } catch (e) {
   }
 }
-var import_chalk4, import_axios3;
+var import_chalk5, import_axios3;
 var init_suggest = __esm({
   "src/commands/suggest.ts"() {
     "use strict";
     init_cjs_shims();
-    import_chalk4 = __toESM(require("chalk"), 1);
+    import_chalk5 = __toESM(require("chalk"), 1);
     import_axios3 = __toESM(require("axios"), 1);
   }
 });
@@ -450,18 +580,18 @@ async function provisionSkills(apiUrl, apiKey, projectId, rootDir) {
     }
   } catch (e) {
     const msg = e.response?.data?.error || e.message;
-    console.log(import_chalk8.default.dim(`  (Skills API not available: ${msg}, using core library)`));
+    console.log(import_chalk9.default.dim(`  (Skills API not available: ${msg}, using core library)`));
   }
   if (skills.length === 0) {
     const { getRigstateStandardSkills } = await import("@rigstate/rules-engine");
     const coreSkills = getRigstateStandardSkills();
     skills.push(...coreSkills);
   }
-  const skillsDir = import_path6.default.join(rootDir, ".agent", "skills");
-  await import_promises6.default.mkdir(skillsDir, { recursive: true });
+  const skillsDir = import_path8.default.join(rootDir, ".agent", "skills");
+  await import_promises7.default.mkdir(skillsDir, { recursive: true });
   for (const skill of skills) {
-    const skillDir = import_path6.default.join(skillsDir, skill.name);
-    await import_promises6.default.mkdir(skillDir, { recursive: true });
+    const skillDir = import_path8.default.join(skillsDir, skill.name);
+    await import_promises7.default.mkdir(skillDir, { recursive: true });
     const skillContent = `---
 name: ${skill.name}
 description: ${skill.description}
@@ -474,10 +604,10 @@ ${skill.content}
 
 ---
 *Provisioned by Rigstate CLI. Do not modify manually.*`;
-    const skillPath = import_path6.default.join(skillDir, "SKILL.md");
-    await import_promises6.default.writeFile(skillPath, skillContent, "utf-8");
+    const skillPath = import_path8.default.join(skillDir, "SKILL.md");
+    await import_promises7.default.writeFile(skillPath, skillContent, "utf-8");
   }
-  console.log(import_chalk8.default.green(`  \u2705 Provisioned ${skills.length} skill(s) to .agent/skills/`));
+  console.log(import_chalk9.default.green(`  \u2705 Provisioned ${skills.length} skill(s) to .agent/skills/`));
   return skills;
 }
 function generateSkillsDiscoveryBlock(skills) {
@@ -492,16 +622,16 @@ ${skillBlocks}
 </available_skills>`;
 }
 async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
-  const rulesPath = import_path6.default.join(rootDir, ".cursorrules");
+  const rulesPath = import_path8.default.join(rootDir, ".cursorrules");
   let rulesContent = "";
   try {
-    rulesContent = await import_promises6.default.readFile(rulesPath, "utf-8");
+    rulesContent = await import_promises7.default.readFile(rulesPath, "utf-8");
   } catch (e) {
     return false;
   }
   const isProvisioned = rulesContent.includes(`<name>${skillId}</name>`) || rulesContent.includes(`.agent/skills/${skillId}`);
   if (isProvisioned) return false;
-  console.log(import_chalk8.default.yellow(`  \u26A1 JIT PROVISIONING: Injecting ${skillId}...`));
+  console.log(import_chalk9.default.yellow(`  \u26A1 JIT PROVISIONING: Injecting ${skillId}...`));
   try {
     const skills = await provisionSkills(apiUrl, apiKey, projectId, rootDir);
     const skillsBlock = generateSkillsDiscoveryBlock(skills);
@@ -516,22 +646,22 @@ async function jitProvisionSkill(skillId, apiUrl, apiKey, projectId, rootDir) {
         rulesContent = rulesContent.slice(0, insertPoint + 3) + "\n\n" + skillsBlock + "\n" + rulesContent.slice(insertPoint + 3);
       }
     }
-    await import_promises6.default.writeFile(rulesPath, rulesContent, "utf-8");
+    await import_promises7.default.writeFile(rulesPath, rulesContent, "utf-8");
     return true;
   } catch (e) {
-    console.log(import_chalk8.default.red(`  Failed to provision skill: ${e.message}`));
+    console.log(import_chalk9.default.red(`  Failed to provision skill: ${e.message}`));
     return false;
   }
 }
-var import_axios6, import_promises6, import_path6, import_chalk8;
+var import_axios6, import_promises7, import_path8, import_chalk9;
 var init_skills_provisioner = __esm({
   "src/utils/skills-provisioner.ts"() {
     "use strict";
     init_cjs_shims();
     import_axios6 = __toESM(require("axios"), 1);
-    import_promises6 = __toESM(require("fs/promises"), 1);
-    import_path6 = __toESM(require("path"), 1);
-    import_chalk8 = __toESM(require("chalk"), 1);
+    import_promises7 = __toESM(require("fs/promises"), 1);
+    import_path8 = __toESM(require("path"), 1);
+    import_chalk9 = __toESM(require("chalk"), 1);
   }
 });
 
@@ -547,8 +677,8 @@ __export(governance_exports, {
 });
 async function getGovernanceConfig(rootDir = process.cwd()) {
   try {
-    const configPath = import_path7.default.join(rootDir, "rigstate.config.json");
-    const content = await import_promises7.default.readFile(configPath, "utf-8");
+    const configPath = import_path9.default.join(rootDir, "rigstate.config.json");
+    const content = await import_promises8.default.readFile(configPath, "utf-8");
     const userConfig = JSON.parse(content);
     return {
       governance: {
@@ -562,50 +692,50 @@ async function getGovernanceConfig(rootDir = process.cwd()) {
 }
 async function getSessionState(rootDir = process.cwd()) {
   try {
-    const sessionPath = import_path7.default.join(rootDir, ".rigstate", "session.json");
-    const content = await import_promises7.default.readFile(sessionPath, "utf-8");
+    const sessionPath = import_path9.default.join(rootDir, ".rigstate", "session.json");
+    const content = await import_promises8.default.readFile(sessionPath, "utf-8");
     return JSON.parse(content);
   } catch (e) {
     return DEFAULT_SESSION;
   }
 }
 async function setSoftLock(reason, violationId, rootDir = process.cwd()) {
-  const sessionPath = import_path7.default.join(rootDir, ".rigstate", "session.json");
+  const sessionPath = import_path9.default.join(rootDir, ".rigstate", "session.json");
   const state = {
     status: "SOFT_LOCK",
     active_violation: violationId,
     lock_reason: reason,
     last_updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await import_promises7.default.mkdir(import_path7.default.dirname(sessionPath), { recursive: true });
-  await import_promises7.default.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
+  await import_promises8.default.mkdir(import_path9.default.dirname(sessionPath), { recursive: true });
+  await import_promises8.default.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
 }
 async function clearSoftLock(rootDir = process.cwd()) {
-  const sessionPath = import_path7.default.join(rootDir, ".rigstate", "session.json");
+  const sessionPath = import_path9.default.join(rootDir, ".rigstate", "session.json");
   const state = {
     ...DEFAULT_SESSION,
     last_updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await import_promises7.default.mkdir(import_path7.default.dirname(sessionPath), { recursive: true });
-  await import_promises7.default.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
+  await import_promises8.default.mkdir(import_path9.default.dirname(sessionPath), { recursive: true });
+  await import_promises8.default.writeFile(sessionPath, JSON.stringify(state, null, 2), "utf-8");
 }
 async function performOverride(violationId, reason, rootDir = process.cwd()) {
   const config2 = await getGovernanceConfig(rootDir);
   if (!config2.governance.allow_overrides) {
-    console.log(import_chalk9.default.red("\u274C Overrides are disabled for this project."));
+    console.log(import_chalk10.default.red("\u274C Overrides are disabled for this project."));
     return false;
   }
   await clearSoftLock(rootDir);
   return true;
 }
-var import_promises7, import_path7, import_chalk9, InterventionLevel, DEFAULT_CONFIG, DEFAULT_SESSION;
+var import_promises8, import_path9, import_chalk10, InterventionLevel, DEFAULT_CONFIG, DEFAULT_SESSION;
 var init_governance = __esm({
   "src/utils/governance.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises7 = __toESM(require("fs/promises"), 1);
-    import_path7 = __toESM(require("path"), 1);
-    import_chalk9 = __toESM(require("chalk"), 1);
+    import_promises8 = __toESM(require("fs/promises"), 1);
+    import_path9 = __toESM(require("path"), 1);
+    import_chalk10 = __toESM(require("chalk"), 1);
     InterventionLevel = /* @__PURE__ */ ((InterventionLevel2) => {
       InterventionLevel2[InterventionLevel2["GHOST"] = 0] = "GHOST";
       InterventionLevel2[InterventionLevel2["NUDGE"] = 1] = "NUDGE";
@@ -634,16 +764,16 @@ __export(watchdog_exports, {
 });
 async function countLines(filePath) {
   try {
-    const content = await import_promises8.default.readFile(filePath, "utf-8");
+    const content = await import_promises9.default.readFile(filePath, "utf-8");
     return content.split("\n").length;
   } catch (e) {
     return 0;
   }
 }
 async function getFiles(dir, extension) {
-  const entries = await import_promises8.default.readdir(dir, { withFileTypes: true });
+  const entries = await import_promises9.default.readdir(dir, { withFileTypes: true });
   const files = await Promise.all(entries.map(async (entry) => {
-    const res = import_path8.default.resolve(dir, entry.name);
+    const res = import_path10.default.resolve(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".next" || entry.name === "dist") return [];
       return getFiles(res, extension);
@@ -671,8 +801,8 @@ async function fetchRulesFromApi(projectId) {
     }
   } catch (error) {
     try {
-      const cachePath = import_path8.default.join(process.cwd(), CACHE_FILE);
-      const content = await import_promises8.default.readFile(cachePath, "utf-8");
+      const cachePath = import_path10.default.join(process.cwd(), CACHE_FILE);
+      const content = await import_promises9.default.readFile(cachePath, "utf-8");
       const cached = JSON.parse(content);
       if (cached.settings) {
         return {
@@ -691,7 +821,7 @@ async function fetchRulesFromApi(projectId) {
   };
 }
 async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
-  console.log(import_chalk10.default.bold("\n\u{1F6E1}\uFE0F  Active Guardian Watchdog Initiated..."));
+  console.log(import_chalk11.default.bold("\n\u{1F6E1}\uFE0F  Active Guardian Watchdog Initiated..."));
   let lmax = settings.lmax || DEFAULT_LMAX;
   let lmaxWarning = settings.lmax_warning || DEFAULT_LMAX_WARNING;
   let ruleSource = settings.lmax ? "Settings (Passed)" : "Default";
@@ -701,47 +831,47 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
     lmaxWarning = apiRules.lmaxWarning;
     ruleSource = apiRules.source;
   }
-  console.log(import_chalk10.default.dim(`Governance Rules: L_max=${lmax}, L_max_warning=${lmaxWarning}, Source: ${ruleSource}`));
+  console.log(import_chalk11.default.dim(`Governance Rules: L_max=${lmax}, L_max_warning=${lmaxWarning}, Source: ${ruleSource}`));
   const targetExtensions = [".ts", ".tsx"];
   let scanTarget = rootPath;
-  const webSrc = import_path8.default.join(rootPath, "apps", "web", "src");
+  const webSrc = import_path10.default.join(rootPath, "apps", "web", "src");
   try {
-    await import_promises8.default.access(webSrc);
+    await import_promises9.default.access(webSrc);
     scanTarget = webSrc;
   } catch {
   }
-  console.log(import_chalk10.default.dim(`Scanning target: ${import_path8.default.relative(process.cwd(), scanTarget)}`));
+  console.log(import_chalk11.default.dim(`Scanning target: ${import_path10.default.relative(process.cwd(), scanTarget)}`));
   const files = await getFiles(scanTarget, targetExtensions);
   let violations = 0;
   let warnings = 0;
   const results = [];
   for (const file of files) {
     const lines = await countLines(file);
-    const relPath = import_path8.default.relative(rootPath, file);
+    const relPath = import_path10.default.relative(rootPath, file);
     if (lines > lmax) {
       results.push({ file: relPath, lines, status: "VIOLATION" });
       violations++;
-      console.log(import_chalk10.default.red(`[VIOLATION] ${relPath}: ${lines} lines (Limit: ${lmax})`));
+      console.log(import_chalk11.default.red(`[VIOLATION] ${relPath}: ${lines} lines (Limit: ${lmax})`));
     } else if (lines > lmaxWarning) {
       results.push({ file: relPath, lines, status: "WARNING" });
       warnings++;
-      console.log(import_chalk10.default.yellow(`[WARNING]   ${relPath}: ${lines} lines (Threshold: ${lmaxWarning})`));
+      console.log(import_chalk11.default.yellow(`[WARNING]   ${relPath}: ${lines} lines (Threshold: ${lmaxWarning})`));
     }
   }
   if (violations === 0 && warnings === 0) {
-    console.log(import_chalk10.default.green(`\u2714 All ${files.length} files are within governance limits.`));
+    console.log(import_chalk11.default.green(`\u2714 All ${files.length} files are within governance limits.`));
   } else {
-    console.log("\n" + import_chalk10.default.bold("Summary:"));
-    console.log(import_chalk10.default.red(`Violations: ${violations}`));
-    console.log(import_chalk10.default.yellow(`Warnings:   ${warnings}`));
+    console.log("\n" + import_chalk11.default.bold("Summary:"));
+    console.log(import_chalk11.default.red(`Violations: ${violations}`));
+    console.log(import_chalk11.default.yellow(`Warnings:   ${warnings}`));
     const { getGovernanceConfig: getGovernanceConfig2, setSoftLock: setSoftLock2, InterventionLevel: InterventionLevel2 } = await Promise.resolve().then(() => (init_governance(), governance_exports));
     const { governance } = await getGovernanceConfig2(rootPath);
-    console.log(import_chalk10.default.dim(`Intervention Level: ${InterventionLevel2[governance.intervention_level] || "UNKNOWN"} (${governance.intervention_level})`));
+    console.log(import_chalk11.default.dim(`Intervention Level: ${InterventionLevel2[governance.intervention_level] || "UNKNOWN"} (${governance.intervention_level})`));
     if (violations > 0) {
-      console.log(import_chalk10.default.red.bold("\nCRITICAL: Governance violations detected. Immediate refactoring required."));
+      console.log(import_chalk11.default.red.bold("\nCRITICAL: Governance violations detected. Immediate refactoring required."));
       if (governance.intervention_level >= InterventionLevel2.SENTINEL) {
-        console.log(import_chalk10.default.red.bold("\u{1F6D1} SENTINEL MODE: Session SOFT_LOCKED until resolved."));
-        console.log(import_chalk10.default.red('   Run "rigstate override <id> --reason \\"...\\"" if this is an emergency.'));
+        console.log(import_chalk11.default.red.bold("\u{1F6D1} SENTINEL MODE: Session SOFT_LOCKED until resolved."));
+        console.log(import_chalk11.default.red('   Run "rigstate override <id> --reason \\"...\\"" if this is an emergency.'));
         await setSoftLock2("Sentinel Mode: Governance Violations Detected", "ARC-VIOLATION", rootPath);
       }
     }
@@ -764,20 +894,20 @@ async function runGuardianWatchdog(rootPath, settings = {}, projectId) {
       }, {
         headers: { Authorization: `Bearer ${apiKey}` }
       });
-      console.log(import_chalk10.default.dim("\u2714 Violations synced to Rigstate Cloud."));
+      console.log(import_chalk11.default.dim("\u2714 Violations synced to Rigstate Cloud."));
     } catch (e) {
-      console.log(import_chalk10.default.dim("\u26A0 Cloud sync skipped: " + (e.message || "Unknown")));
+      console.log(import_chalk11.default.dim("\u26A0 Cloud sync skipped: " + (e.message || "Unknown")));
     }
   }
 }
-var import_promises8, import_path8, import_chalk10, import_axios7, DEFAULT_LMAX, DEFAULT_LMAX_WARNING, CACHE_FILE;
+var import_promises9, import_path10, import_chalk11, import_axios7, DEFAULT_LMAX, DEFAULT_LMAX_WARNING, CACHE_FILE;
 var init_watchdog = __esm({
   "src/utils/watchdog.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises8 = __toESM(require("fs/promises"), 1);
-    import_path8 = __toESM(require("path"), 1);
-    import_chalk10 = __toESM(require("chalk"), 1);
+    import_promises9 = __toESM(require("fs/promises"), 1);
+    import_path10 = __toESM(require("path"), 1);
+    import_chalk11 = __toESM(require("chalk"), 1);
     import_axios7 = __toESM(require("axios"), 1);
     init_config();
     DEFAULT_LMAX = 400;
@@ -1667,7 +1797,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.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",
@@ -1724,32 +1854,32 @@ var require_package = __commonJS({
 // src/index.ts
 init_cjs_shims();
 var import_commander24 = require("commander");
-var import_chalk35 = __toESM(require("chalk"), 1);
+var import_chalk36 = __toESM(require("chalk"), 1);
 
 // src/commands/login.ts
 init_cjs_shims();
 var import_commander = require("commander");
-var import_chalk = __toESM(require("chalk"), 1);
+var import_chalk2 = __toESM(require("chalk"), 1);
 init_config();
 function createLoginCommand() {
   return new import_commander.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(import_chalk.default.red("\u274C Invalid API key format"));
-        console.error(import_chalk.default.dim('API keys must start with "sk_rigstate_"'));
+        console.error(import_chalk2.default.red("\u274C Invalid API key format"));
+        console.error(import_chalk2.default.dim('API keys must start with "sk_rigstate_"'));
         process.exit(1);
       }
       setApiKey(apiKey);
-      console.log(import_chalk.default.green("\u2705 Successfully logged in!"));
+      console.log(import_chalk2.default.green("\u2705 Successfully logged in!"));
       console.log(
-        import_chalk.default.dim(
+        import_chalk2.default.dim(
           `
 Your API key has been securely stored. You can now use "rigstate scan" to audit your code.`
         )
       );
-      console.log(import_chalk.default.bold("\n\u{1F916} Cursor MCP Configuration"));
-      console.log(import_chalk.default.dim("Copy and paste this into Cursor Settings -> Features -> MCP:"));
-      console.log(import_chalk.default.cyan(`
+      console.log(import_chalk2.default.bold("\n\u{1F916} Cursor MCP Configuration"));
+      console.log(import_chalk2.default.dim("Copy and paste this into Cursor Settings -> Features -> MCP:"));
+      console.log(import_chalk2.default.cyan(`
 {
   "mcpServers": {
     "rigstate": {
@@ -1766,7 +1896,7 @@ Your API key has been securely stored. You can now use "rigstate scan" to audit
 }`));
     } catch (error) {
       console.error(
-        import_chalk.default.red("\u274C Login failed:"),
+        import_chalk2.default.red("\u274C Login failed:"),
         error instanceof Error ? error.message : "Unknown error"
       );
       process.exit(1);
@@ -1777,25 +1907,25 @@ Your API key has been securely stored. You can now use "rigstate scan" to audit
 // src/commands/link.ts
 init_cjs_shims();
 var import_commander4 = require("commander");
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_path2 = __toESM(require("path"), 1);
-var import_chalk5 = __toESM(require("chalk"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_chalk6 = __toESM(require("chalk"), 1);
 var import_os = __toESM(require("os"), 1);
 init_config();
 function createLinkCommand() {
   return new import_commander4.Command("link").description("Link current directory to a Rigstate project").argument("[projectId]", "Project ID to link").action(async (projectId) => {
     try {
-      const globalPath = import_path2.default.join(import_os.default.homedir(), ".rigstate", "config.json");
-      const globalData = await import_promises2.default.readFile(globalPath, "utf-8").catch(() => null);
+      const globalPath = import_path4.default.join(import_os.default.homedir(), ".rigstate", "config.json");
+      const globalData = await import_promises3.default.readFile(globalPath, "utf-8").catch(() => null);
       if (globalData) {
         const config2 = JSON.parse(globalData);
-        const cwd = process.cwd();
-        if (config2.overrides && config2.overrides[cwd]) {
-          const overrideId = config2.overrides[cwd];
-          console.warn(import_chalk5.default.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(import_chalk6.default.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
           if (!projectId) projectId = overrideId;
           else if (projectId !== overrideId) {
-            console.warn(import_chalk5.default.red(`Ignoring provided ID ${projectId}. Using override.`));
+            console.warn(import_chalk6.default.red(`Ignoring provided ID ${projectId}. Using override.`));
             projectId = overrideId;
           }
         }
@@ -1809,16 +1939,16 @@ function createLinkCommand() {
         const apiKey = getApiKey();
         const apiUrl = getApiUrl();
         if (!apiKey) {
-          console.error(import_chalk5.default.red('Not authenticated. Please run "rigstate login" or provide a Project ID.'));
+          console.error(import_chalk6.default.red('Not authenticated. Please run "rigstate login" or provide a Project ID.'));
           process.exit(1);
         }
-        console.log(import_chalk5.default.dim("Fetching your projects..."));
+        console.log(import_chalk6.default.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(import_chalk5.default.yellow("No projects found. Create one at https://app.rigstate.com"));
+          console.error(import_chalk6.default.yellow("No projects found. Create one at https://app.rigstate.com"));
           process.exit(1);
         }
         const choices = response.data.data.projects.map((p) => ({
@@ -1833,54 +1963,49 @@ function createLinkCommand() {
         }]);
         projectId = answer.id;
       } catch (e) {
-        console.error(import_chalk5.default.red(`Failed to fetch projects: ${e.message}`));
+        console.error(import_chalk6.default.red(`Failed to fetch projects: ${e.message}`));
         console.error("Please provide project ID manually: rigstate link <id>");
         process.exit(1);
       }
     }
-    const manifestPath = import_path2.default.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 import_promises2.default.mkdir(import_path2.default.dirname(manifestPath), { recursive: true });
-      await import_promises2.default.writeFile(manifestPath, JSON.stringify(content, null, 2), "utf-8");
-      console.log(import_chalk5.default.green(`\u2714 Linked to project ID: ${projectId}`));
-      console.log(import_chalk5.default.dim(`Created local context manifest at .rigstate`));
+      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(import_chalk6.default.green(`\u2714 Linked to project ID: ${projectId}`));
+      console.log(import_chalk6.default.dim(`Created local identity manifest at ${import_path4.default.relative(cwd, targetFile)}`));
       console.log("");
-      console.log(import_chalk5.default.bold("\u{1F916} Rigstate Automation Detected"));
+      console.log(import_chalk6.default.bold("\u{1F916} Rigstate Automation Detected"));
       console.log("");
-      const { getApiKey: _getApiKey, getApiUrl: _getApiUrl } = await Promise.resolve().then(() => (init_config(), config_exports));
       const apiKey = getApiKey();
       const apiUrl = getApiUrl();
       if (apiKey) {
-        console.log(import_chalk5.default.blue("\u{1F510} Checking Vault for secrets..."));
+        console.log(import_chalk6.default.blue("\u{1F510} Checking Vault for secrets..."));
         const { syncEnv: syncEnv2 } = await Promise.resolve().then(() => (init_env(), env_exports));
         await syncEnv2(projectId, apiKey, apiUrl, true);
-        console.log(import_chalk5.default.blue("\u{1F9E0} Syncing neural instructions..."));
+        console.log(import_chalk6.default.blue("\u{1F9E0} Syncing neural instructions..."));
         const { syncProjectRules: syncProjectRules2 } = await Promise.resolve().then(() => (init_sync_rules(), sync_rules_exports));
         await syncProjectRules2(projectId, apiKey, apiUrl);
-        console.log(import_chalk5.default.blue("\u{1F6E1}\uFE0F  Injecting Guardian hooks & Safety nets..."));
+        console.log(import_chalk6.default.blue("\u{1F6E1}\uFE0F  Injecting Guardian hooks & Safety nets..."));
         await installHooks(process.cwd());
         await hardenGitIgnore(process.cwd());
         console.log("");
-        console.log(import_chalk5.default.bold.green("\u{1F680} Link Complete! Your environment is ready."));
+        console.log(import_chalk6.default.bold.green("\u{1F680} Link Complete! Your environment is ready."));
         const { suggestNextMove: suggestNextMove2 } = await Promise.resolve().then(() => (init_suggest(), suggest_exports));
         await suggestNextMove2(projectId, apiKey, apiUrl);
       } else {
         console.log("");
-        console.log(import_chalk5.default.bold.green("\u{1F680} Link Complete!"));
+        console.log(import_chalk6.default.bold.green("\u{1F680} Link Complete!"));
       }
     } catch (error) {
       if (error.message?.includes("Not authenticated")) {
-        console.warn(import_chalk5.default.yellow('\u26A0\uFE0F  Not authenticated. Run "rigstate login" to enable automation features.'));
+        console.warn(import_chalk6.default.yellow('\u26A0\uFE0F  Not authenticated. Run "rigstate login" to enable automation features.'));
       } else {
-        console.error(import_chalk5.default.red(`Failed to link project: ${error.message}`));
+        console.error(import_chalk6.default.red(`Failed to link project: ${error.message}`));
       }
     }
   });
@@ -1909,15 +2034,15 @@ async function hardenGitIgnore(cwd) {
     }
     const missing = REQUIRED_IGNORES.filter((line) => !content.includes(line) && !line.startsWith("#"));
     if (missing.length > 0) {
-      console.log(import_chalk5.default.dim("   Configuring .gitignore for Rigstate safety..."));
+      console.log(import_chalk6.default.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(import_chalk5.default.green("   \u2714 .gitignore updated (Artifacts protected)"));
+      console.log(import_chalk6.default.green("   \u2714 .gitignore updated (Artifacts protected)"));
     } else {
-      console.log(import_chalk5.default.green("   \u2714 .gitignore already hardened"));
+      console.log(import_chalk6.default.green("   \u2714 .gitignore already hardened"));
     }
   } catch (e) {
-    console.warn(import_chalk5.default.yellow(`   Could not update .gitignore: ${e.message}`));
+    console.warn(import_chalk6.default.yellow(`   Could not update .gitignore: ${e.message}`));
   }
 }
 async function installHooks(cwd) {
@@ -1926,7 +2051,7 @@ async function installHooks(cwd) {
   try {
     await fs26.access(path28.join(cwd, ".git"));
   } catch {
-    console.log(import_chalk5.default.dim("   (Not a git repository, skipping hooks)"));
+    console.log(import_chalk6.default.dim("   (Not a git repository, skipping hooks)"));
     return;
   }
   const hooksDir = path28.join(cwd, ".husky");
@@ -1937,7 +2062,7 @@ async function installHooks(cwd) {
       await fs26.access(preCommitPath);
       const content = await fs26.readFile(preCommitPath, "utf-8");
       if (content.includes("rigstate")) {
-        console.log(import_chalk5.default.green("   \u2714 Git hooks already active"));
+        console.log(import_chalk6.default.green("   \u2714 Git hooks already active"));
       } else {
         shouldInstall = true;
       }
@@ -1966,10 +2091,10 @@ exit $?
       } else {
         await fs26.writeFile(preCommitPath, PRE_COMMIT_SCRIPT2, { mode: 493 });
       }
-      console.log(import_chalk5.default.green("   \u2714 Applied Guardian protection (git-hooks)"));
+      console.log(import_chalk6.default.green("   \u2714 Applied Guardian protection (git-hooks)"));
     }
   } catch (e) {
-    console.log(import_chalk5.default.dim("   (Skipped hooks: " + e.message + ")"));
+    console.log(import_chalk6.default.dim("   (Skipped hooks: " + e.message + ")"));
   }
 }
 async function fileExists(path28) {
@@ -1985,22 +2110,22 @@ async function fileExists(path28) {
 // src/commands/scan.ts
 init_cjs_shims();
 var import_commander5 = require("commander");
-var import_chalk6 = __toESM(require("chalk"), 1);
+var import_chalk7 = __toESM(require("chalk"), 1);
 var import_ora3 = __toESM(require("ora"), 1);
 var import_axios4 = __toESM(require("axios"), 1);
 var import_glob = require("glob");
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_path4 = __toESM(require("path"), 1);
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_path6 = __toESM(require("path"), 1);
 init_config();
 
 // src/utils/files.ts
 init_cjs_shims();
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_path3 = __toESM(require("path"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_path5 = __toESM(require("path"), 1);
 async function readGitignore(dir) {
-  const gitignorePath = import_path3.default.join(dir, ".gitignore");
+  const gitignorePath = import_path5.default.join(dir, ".gitignore");
   try {
-    const content = await import_promises3.default.readFile(gitignorePath, "utf-8");
+    const content = await import_promises4.default.readFile(gitignorePath, "utf-8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error) {
     return [];
@@ -2062,7 +2187,7 @@ function isCodeFile(filePath) {
     ".vue",
     ".svelte"
   ];
-  const ext = import_path3.default.extname(filePath).toLowerCase();
+  const ext = import_path5.default.extname(filePath).toLowerCase();
   return codeExtensions.includes(ext);
 }
 
@@ -2076,26 +2201,26 @@ function createScanCommand() {
       const projectId = options.project || getProjectId();
       if (!projectId) {
         console.warn(
-          import_chalk6.default.yellow(
+          import_chalk7.default.yellow(
             "\u26A0\uFE0F  No project ID specified. Use --project <id> or set a default."
           )
         );
       }
-      const scanPath = import_path4.default.resolve(process.cwd(), targetPath);
-      spinner.start(`Scanning ${import_chalk6.default.cyan(scanPath)}...`);
+      const scanPath = import_path6.default.resolve(process.cwd(), targetPath);
+      spinner.start(`Scanning ${import_chalk7.default.cyan(scanPath)}...`);
       const gitignorePatterns = await readGitignore(scanPath);
-      const pattern = import_path4.default.join(scanPath, "**/*");
+      const pattern = import_path6.default.join(scanPath, "**/*");
       const allFiles = await (0, import_glob.glob)(pattern, {
         nodir: true,
         dot: false,
         ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"]
       });
       const codeFiles = allFiles.filter((file) => {
-        const relativePath = import_path4.default.relative(scanPath, file);
+        const relativePath = import_path6.default.relative(scanPath, file);
         return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
       });
       if (codeFiles.length === 0) {
-        spinner.warn(import_chalk6.default.yellow("No code files found to scan."));
+        spinner.warn(import_chalk7.default.yellow("No code files found to scan."));
         return;
       }
       spinner.text = `Found ${codeFiles.length} files. Scanning...`;
@@ -2104,10 +2229,10 @@ function createScanCommand() {
       const severityCounts = {};
       for (let i = 0; i < codeFiles.length; i++) {
         const filePath = codeFiles[i];
-        const relativePath = import_path4.default.relative(scanPath, filePath);
+        const relativePath = import_path6.default.relative(scanPath, filePath);
         spinner.text = `Scanning ${i + 1}/${codeFiles.length}: ${relativePath}`;
         try {
-          const content = await import_promises4.default.readFile(filePath, "utf-8");
+          const content = await import_promises5.default.readFile(filePath, "utf-8");
           const response = await import_axios4.default.post(
             `${apiUrl}/api/v1/audit`,
             {
@@ -2143,15 +2268,15 @@ function createScanCommand() {
           }
         } catch (fileError) {
           if (import_axios4.default.isAxiosError(fileError)) {
-            console.warn(import_chalk6.default.yellow(`
+            console.warn(import_chalk7.default.yellow(`
 \u26A0\uFE0F  Skipping ${relativePath}: ${fileError.message}`));
           } else {
-            console.warn(import_chalk6.default.yellow(`
+            console.warn(import_chalk7.default.yellow(`
 \u26A0\uFE0F  Error reading ${relativePath}`));
           }
         }
       }
-      spinner.succeed(import_chalk6.default.green("\u2705 Scan completed!"));
+      spinner.succeed(import_chalk7.default.green("\u2705 Scan completed!"));
       const aggregatedResponse = {
         results,
         summary: {
@@ -2166,21 +2291,21 @@ function createScanCommand() {
         printPrettyResults(aggregatedResponse);
       }
     } catch (error) {
-      spinner.fail(import_chalk6.default.red("\u274C Scan failed"));
+      spinner.fail(import_chalk7.default.red("\u274C Scan failed"));
       if (import_axios4.default.isAxiosError(error)) {
         if (error.response) {
-          console.error(import_chalk6.default.red("API Error:"), error.response.data);
+          console.error(import_chalk7.default.red("API Error:"), error.response.data);
         } else if (error.request) {
           console.error(
-            import_chalk6.default.red("Network Error:"),
+            import_chalk7.default.red("Network Error:"),
             "Could not reach the API. Is the server running?"
           );
         } else {
-          console.error(import_chalk6.default.red("Error:"), error.message);
+          console.error(import_chalk7.default.red("Error:"), error.message);
         }
       } else {
         console.error(
-          import_chalk6.default.red("Error:"),
+          import_chalk7.default.red("Error:"),
           error instanceof Error ? error.message : "Unknown error"
         );
       }
@@ -2190,10 +2315,10 @@ function createScanCommand() {
 }
 function printPrettyResults(data) {
   const { results, summary } = data;
-  console.log("\n" + import_chalk6.default.bold("\u{1F4CA} Scan Summary"));
-  console.log(import_chalk6.default.dim("\u2500".repeat(60)));
-  console.log(`Total Files Scanned: ${import_chalk6.default.cyan(summary.total_files)}`);
-  console.log(`Total Issues Found: ${import_chalk6.default.yellow(summary.total_issues)}`);
+  console.log("\n" + import_chalk7.default.bold("\u{1F4CA} Scan Summary"));
+  console.log(import_chalk7.default.dim("\u2500".repeat(60)));
+  console.log(`Total Files Scanned: ${import_chalk7.default.cyan(summary.total_files)}`);
+  console.log(`Total Issues Found: ${import_chalk7.default.yellow(summary.total_issues)}`);
   if (summary.by_severity) {
     console.log("\nIssues by Severity:");
     Object.entries(summary.by_severity).forEach(([severity, count]) => {
@@ -2202,51 +2327,51 @@ function printPrettyResults(data) {
     });
   }
   if (results && results.length > 0) {
-    console.log("\n" + import_chalk6.default.bold("\u{1F50D} Detailed Results"));
-    console.log(import_chalk6.default.dim("\u2500".repeat(60)));
+    console.log("\n" + import_chalk7.default.bold("\u{1F50D} Detailed Results"));
+    console.log(import_chalk7.default.dim("\u2500".repeat(60)));
     results.forEach((result) => {
       if (result.issues && result.issues.length > 0) {
         console.log(`
-${import_chalk6.default.bold(result.file_path)}`);
+${import_chalk7.default.bold(result.file_path)}`);
         result.issues.forEach((issue) => {
           const severityColor = getSeverityColor(issue.severity);
-          const lineInfo = issue.line ? import_chalk6.default.dim(`:${issue.line}`) : "";
+          const lineInfo = issue.line ? import_chalk7.default.dim(`:${issue.line}`) : "";
           console.log(
             `  ${severityColor(`[${issue.severity.toUpperCase()}]`)} ${issue.type}${lineInfo}`
           );
-          console.log(`  ${import_chalk6.default.dim(issue.message)}`);
+          console.log(`  ${import_chalk7.default.dim(issue.message)}`);
         });
       }
     });
   }
-  console.log("\n" + import_chalk6.default.dim("\u2500".repeat(60)));
+  console.log("\n" + import_chalk7.default.dim("\u2500".repeat(60)));
 }
 function getSeverityColor(severity) {
   switch (severity.toLowerCase()) {
     case "critical":
-      return import_chalk6.default.red.bold;
+      return import_chalk7.default.red.bold;
     case "high":
-      return import_chalk6.default.red;
+      return import_chalk7.default.red;
     case "medium":
-      return import_chalk6.default.yellow;
+      return import_chalk7.default.yellow;
     case "low":
-      return import_chalk6.default.blue;
+      return import_chalk7.default.blue;
     case "info":
-      return import_chalk6.default.gray;
+      return import_chalk7.default.gray;
     default:
-      return import_chalk6.default.white;
+      return import_chalk7.default.white;
   }
 }
 
 // src/commands/fix.ts
 init_cjs_shims();
 var import_commander6 = require("commander");
-var import_chalk7 = __toESM(require("chalk"), 1);
+var import_chalk8 = __toESM(require("chalk"), 1);
 var import_ora4 = __toESM(require("ora"), 1);
 var import_axios5 = __toESM(require("axios"), 1);
 var import_glob2 = require("glob");
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_path5 = __toESM(require("path"), 1);
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_path7 = __toESM(require("path"), 1);
 var import_inquirer = __toESM(require("inquirer"), 1);
 var Diff = __toESM(require("diff"), 1);
 init_config();
@@ -2258,31 +2383,31 @@ function createFixCommand() {
       const apiUrl = getApiUrl();
       const projectId = options.project || getProjectId();
       if (!projectId) {
-        console.log(import_chalk7.default.yellow("\u26A0\uFE0F  Project ID is required for fixing. Using default or pass --project <id>"));
+        console.log(import_chalk8.default.yellow("\u26A0\uFE0F  Project ID is required for fixing. Using default or pass --project <id>"));
       }
-      const scanPath = import_path5.default.resolve(process.cwd(), targetPath);
+      const scanPath = import_path7.default.resolve(process.cwd(), targetPath);
       const gitignorePatterns = await readGitignore(scanPath);
-      const pattern = import_path5.default.join(scanPath, "**/*");
+      const pattern = import_path7.default.join(scanPath, "**/*");
       const allFiles = await (0, import_glob2.glob)(pattern, { nodir: true, dot: false, ignore: ["**/node_modules/**", "**/.git/**"] });
       const codeFiles = allFiles.filter((file) => {
-        const relativePath = import_path5.default.relative(scanPath, file);
+        const relativePath = import_path7.default.relative(scanPath, file);
         return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
       });
       if (codeFiles.length === 0) {
-        console.log(import_chalk7.default.yellow("No code files found."));
+        console.log(import_chalk8.default.yellow("No code files found."));
         return;
       }
-      console.log(import_chalk7.default.bold(`
+      console.log(import_chalk8.default.bold(`
 \u{1F9E0} Rigstate Fix Mode`));
-      console.log(import_chalk7.default.dim(`Scanning ${codeFiles.length} files with Project Context...
+      console.log(import_chalk8.default.dim(`Scanning ${codeFiles.length} files with Project Context...
 `));
       let fixedCount = 0;
       for (let i = 0; i < codeFiles.length; i++) {
         const filePath = codeFiles[i];
-        const relativePath = import_path5.default.relative(scanPath, filePath);
+        const relativePath = import_path7.default.relative(scanPath, filePath);
         spinner.start(`Analyzing ${relativePath}...`);
         try {
-          const content = await import_promises5.default.readFile(filePath, "utf-8");
+          const content = await import_promises6.default.readFile(filePath, "utf-8");
           const response = await import_axios5.default.post(
             `${apiUrl}/api/v1/audit`,
             { content, file_path: relativePath, project_id: projectId },
@@ -2293,22 +2418,22 @@ function createFixCommand() {
           if (fixableIssues.length > 0) {
             spinner.stop();
             console.log(`
-${import_chalk7.default.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
+${import_chalk8.default.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
             for (const issue of fixableIssues) {
-              console.log(import_chalk7.default.red(`
+              console.log(import_chalk8.default.red(`
 [${issue.type}] ${issue.title}`));
-              console.log(import_chalk7.default.dim(issue.suggestion || issue.message));
+              console.log(import_chalk8.default.dim(issue.suggestion || issue.message));
               const diff = Diff.createTwoFilesPatch(relativePath, relativePath, content, issue.fixed_content, "Current", "Fixed");
               console.log("\n" + diff.split("\n").slice(0, 15).join("\n") + (diff.split("\n").length > 15 ? "\n..." : ""));
               const { apply } = await import_inquirer.default.prompt([{
                 type: "confirm",
                 name: "apply",
-                message: `Apply this fix to ${import_chalk7.default.cyan(relativePath)}?`,
+                message: `Apply this fix to ${import_chalk8.default.cyan(relativePath)}?`,
                 default: true
               }]);
               if (apply) {
-                await import_promises5.default.writeFile(filePath, issue.fixed_content);
-                console.log(import_chalk7.default.green(`\u2705 Fixed applied!`));
+                await import_promises6.default.writeFile(filePath, issue.fixed_content);
+                console.log(import_chalk8.default.green(`\u2705 Fixed applied!`));
                 fixedCount++;
                 if (issue.related_step_id) {
                   const { completeStep } = await import_inquirer.default.prompt([{
@@ -2324,15 +2449,15 @@ ${import_chalk7.default.bold(relativePath)}: Found ${fixableIssues.length} fixab
                         { step_id: issue.related_step_id, status: "COMPLETED", project_id: projectId },
                         { headers: { "Authorization": `Bearer ${apiKey}` } }
                       );
-                      console.log(import_chalk7.default.green(`\u{1F680} Roadmap updated! Mission Control is in sync.`));
+                      console.log(import_chalk8.default.green(`\u{1F680} Roadmap updated! Mission Control is in sync.`));
                     } catch (err) {
-                      console.error(import_chalk7.default.yellow(`Failed to update roadmap: ${err.message}`));
+                      console.error(import_chalk8.default.yellow(`Failed to update roadmap: ${err.message}`));
                     }
                   }
                 }
                 break;
               } else {
-                console.log(import_chalk7.default.dim("Skipped."));
+                console.log(import_chalk8.default.dim("Skipped."));
               }
             }
           } else {
@@ -2342,11 +2467,11 @@ ${import_chalk7.default.bold(relativePath)}: Found ${fixableIssues.length} fixab
         }
       }
       spinner.stop();
-      console.log(import_chalk7.default.bold.green(`
+      console.log(import_chalk8.default.bold.green(`
 
 \u{1F680} Fix session complete!`));
       console.log(`Frank fixed ${fixedCount} detected issues.`);
-      console.log(import_chalk7.default.dim(`Run 'rigstate scan' to verify remaining issues.`));
+      console.log(import_chalk8.default.dim(`Run 'rigstate scan' to verify remaining issues.`));
     } catch (error) {
       spinner.fail("Fix session failed");
       console.error(error.message);
@@ -2357,12 +2482,12 @@ ${import_chalk7.default.bold(relativePath)}: Found ${fixableIssues.length} fixab
 // src/commands/sync.ts
 init_cjs_shims();
 var import_commander7 = require("commander");
-var import_chalk11 = __toESM(require("chalk"), 1);
+var import_chalk12 = __toESM(require("chalk"), 1);
 var import_ora5 = __toESM(require("ora"), 1);
 init_config();
 var import_axios8 = __toESM(require("axios"), 1);
-var import_promises9 = __toESM(require("fs/promises"), 1);
-var import_path9 = __toESM(require("path"), 1);
+var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_path11 = __toESM(require("path"), 1);
 function createSyncCommand() {
   const sync = new import_commander7.Command("sync");
   sync.description("Synchronize local state with Rigstate Cloud").option("-p, --project <id>", "Specify Project ID (saves to config automatically)").action(async (options) => {
@@ -2377,13 +2502,9 @@ function createSyncCommand() {
       }
       let projectId = options.project;
       if (!projectId) {
-        try {
-          const manifestPath = import_path9.default.join(process.cwd(), ".rigstate");
-          const manifestContent = await import_promises9.default.readFile(manifestPath, "utf-8");
-          const manifest = JSON.parse(manifestContent);
-          if (manifest.project_id) projectId = manifest.project_id;
-        } catch (e) {
-        }
+        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) {
@@ -2403,31 +2524,30 @@ function createSyncCommand() {
       }
       const { roadmap, project } = response.data.data;
       const timestamp = response.data.timestamp;
-      const targetPath = import_path9.default.join(process.cwd(), "roadmap.json");
+      const targetPath = import_path11.default.join(process.cwd(), "roadmap.json");
       const fileContent = JSON.stringify({
         project,
         last_synced: timestamp,
         roadmap
       }, null, 2);
-      await import_promises9.default.writeFile(targetPath, fileContent, "utf-8");
+      await import_promises10.default.writeFile(targetPath, fileContent, "utf-8");
       try {
-        const manifestPath = import_path9.default.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 import_promises9.default.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
+        });
       } catch (e) {
       }
-      console.log(import_chalk11.default.bold("\n\u{1F9E0} Agent Skills Provisioning..."));
+      console.log(import_chalk12.default.bold("\n\u{1F9E0} Agent Skills Provisioning..."));
       try {
         const { provisionSkills: provisionSkills2, generateSkillsDiscoveryBlock: generateSkillsDiscoveryBlock2 } = await Promise.resolve().then(() => (init_skills_provisioner(), skills_provisioner_exports));
         const skills = await provisionSkills2(apiUrl, apiKey, projectId, process.cwd());
-        const cursorRulesPath = import_path9.default.join(process.cwd(), ".cursorrules");
+        const cursorRulesPath = import_path11.default.join(process.cwd(), ".cursorrules");
         try {
-          let rulesContent = await import_promises9.default.readFile(cursorRulesPath, "utf-8");
+          let rulesContent = await import_promises10.default.readFile(cursorRulesPath, "utf-8");
           const skillsBlock = generateSkillsDiscoveryBlock2(skills);
           if (rulesContent.includes("<available_skills>")) {
             rulesContent = rulesContent.replace(
@@ -2440,17 +2560,17 @@ function createSyncCommand() {
               rulesContent = rulesContent.slice(0, insertPoint + 3) + "\n\n" + skillsBlock + "\n" + rulesContent.slice(insertPoint + 3);
             }
           }
-          await import_promises9.default.writeFile(cursorRulesPath, rulesContent, "utf-8");
-          console.log(import_chalk11.default.dim(`  Updated .cursorrules with skills discovery block`));
+          await import_promises10.default.writeFile(cursorRulesPath, rulesContent, "utf-8");
+          console.log(import_chalk12.default.dim(`  Updated .cursorrules with skills discovery block`));
         } catch (e) {
         }
       } catch (e) {
-        console.log(import_chalk11.default.yellow(`  \u26A0 Skills provisioning skipped: ${e.message}`));
+        console.log(import_chalk12.default.yellow(`  \u26A0 Skills provisioning skipped: ${e.message}`));
       }
       try {
-        const logPath = import_path9.default.join(process.cwd(), ".rigstate", "logs", "last_execution.json");
+        const logPath = import_path11.default.join(process.cwd(), ".rigstate", "logs", "last_execution.json");
         try {
-          const logContent = await import_promises9.default.readFile(logPath, "utf-8");
+          const logContent = await import_promises10.default.readFile(logPath, "utf-8");
           const logData = JSON.parse(logContent);
           if (logData.task_summary) {
             await import_axios8.default.post(`${apiUrl}/api/v1/execution-logs`, {
@@ -2460,8 +2580,8 @@ function createSyncCommand() {
             }, {
               headers: { Authorization: `Bearer ${apiKey}` }
             });
-            await import_promises9.default.unlink(logPath);
-            console.log(import_chalk11.default.dim(`\u2714 Mission Report uploaded.`));
+            await import_promises10.default.unlink(logPath);
+            console.log(import_chalk12.default.dim(`\u2714 Mission Report uploaded.`));
           }
         } catch (e) {
           if (e.code !== "ENOENT") {
@@ -2469,12 +2589,12 @@ function createSyncCommand() {
         }
       } catch (e) {
       }
-      spinner.succeed(import_chalk11.default.green(`Synced ${roadmap.length} roadmap steps for project "${project}"`));
-      console.log(import_chalk11.default.dim(`Local files updated: roadmap.json`));
+      spinner.succeed(import_chalk12.default.green(`Synced ${roadmap.length} roadmap steps for project "${project}"`));
+      console.log(import_chalk12.default.dim(`Local files updated: roadmap.json`));
       const { runGuardianWatchdog: runGuardianWatchdog2 } = await Promise.resolve().then(() => (init_watchdog(), watchdog_exports));
       const settings = response.data.data.settings || {};
       await runGuardianWatchdog2(process.cwd(), settings, projectId);
-      console.log(import_chalk11.default.bold("\n\u{1F4E1} Agent Bridge Heartbeat..."));
+      console.log(import_chalk12.default.bold("\n\u{1F4E1} Agent Bridge Heartbeat..."));
       try {
         const bridgeResponse = await import_axios8.default.get(`${apiUrl}/api/v1/agent/bridge`, {
           params: { project_id: projectId },
@@ -2485,10 +2605,10 @@ function createSyncCommand() {
           const pending = tasks.filter((t) => t.status === "PENDING");
           const approved = tasks.filter((t) => t.status === "APPROVED");
           if (pending.length > 0 || approved.length > 0) {
-            console.log(import_chalk11.default.yellow(`\u26A0 Bridge Alert: ${pending.length} pending, ${approved.length} approved tasks found.`));
-            console.log(import_chalk11.default.dim('Run "rigstate fix" to process these tasks or ensure your IDE MCP server is active.'));
+            console.log(import_chalk12.default.yellow(`\u26A0 Bridge Alert: ${pending.length} pending, ${approved.length} approved tasks found.`));
+            console.log(import_chalk12.default.dim('Run "rigstate fix" to process these tasks or ensure your IDE MCP server is active.'));
           } else {
-            console.log(import_chalk11.default.green("\u2714 Heartbeat healthy. No pending bridge tasks."));
+            console.log(import_chalk12.default.green("\u2714 Heartbeat healthy. No pending bridge tasks."));
           }
           const pings = pending.filter((t) => t.proposal?.startsWith("ping"));
           for (const ping of pings) {
@@ -2499,25 +2619,25 @@ function createSyncCommand() {
             }, {
               headers: { Authorization: `Bearer ${apiKey}` }
             });
-            console.log(import_chalk11.default.cyan(`\u{1F3D3} Pong! Acknowledged heartbeat signal [${ping.id}]`));
+            console.log(import_chalk12.default.cyan(`\u{1F3D3} Pong! Acknowledged heartbeat signal [${ping.id}]`));
           }
         }
       } catch (e) {
-        console.log(import_chalk11.default.yellow(`\u26A0 Could not verify Bridge status: ${e.message}`));
+        console.log(import_chalk12.default.yellow(`\u26A0 Could not verify Bridge status: ${e.message}`));
       }
       if (options.project) {
-        console.log(import_chalk11.default.blue(`Project context saved. Future commands will use this project.`));
+        console.log(import_chalk12.default.blue(`Project context saved. Future commands will use this project.`));
       }
       try {
-        const migrationDir = import_path9.default.join(process.cwd(), "supabase", "migrations");
-        const files = await import_promises9.default.readdir(migrationDir);
+        const migrationDir = import_path11.default.join(process.cwd(), "supabase", "migrations");
+        const files = await import_promises10.default.readdir(migrationDir);
         const sqlFiles = files.filter((f) => f.endsWith(".sql")).sort();
         if (sqlFiles.length > 0) {
           const latestMigration = sqlFiles[sqlFiles.length - 1];
-          console.log(import_chalk11.default.dim(`
+          console.log(import_chalk12.default.dim(`
 \u{1F6E1}  Migration Guard:`));
-          console.log(import_chalk11.default.dim(`   Latest Local: ${latestMigration}`));
-          console.log(import_chalk11.default.yellow(`   \u26A0  Ensure DB schema matches this version. CLI cannot verify Remote RLS policies directly.`));
+          console.log(import_chalk12.default.dim(`   Latest Local: ${latestMigration}`));
+          console.log(import_chalk12.default.yellow(`   \u26A0  Ensure DB schema matches this version. CLI cannot verify Remote RLS policies directly.`));
         }
       } catch (e) {
       }
@@ -2529,15 +2649,15 @@ function createSyncCommand() {
         );
         if (vaultResponse.data.success) {
           const vaultContent = vaultResponse.data.data.content || "";
-          const localEnvPath = import_path9.default.join(process.cwd(), ".env.local");
+          const localEnvPath = import_path11.default.join(process.cwd(), ".env.local");
           let localContent = "";
           try {
-            localContent = await import_promises9.default.readFile(localEnvPath, "utf-8");
+            localContent = await import_promises10.default.readFile(localEnvPath, "utf-8");
           } catch (e) {
           }
           if (vaultContent.trim() !== localContent.trim()) {
-            console.log(import_chalk11.default.bold("\n\u{1F510} Sovereign Foundation (Vault):"));
-            console.log(import_chalk11.default.yellow("   Status: Drift Detected / Update Available"));
+            console.log(import_chalk12.default.bold("\n\u{1F510} Sovereign Foundation (Vault):"));
+            console.log(import_chalk12.default.yellow("   Status: Drift Detected / Update Available"));
             const { syncVault } = await import("inquirer").then((m) => m.default.prompt([{
               type: "confirm",
               name: "syncVault",
@@ -2545,25 +2665,25 @@ function createSyncCommand() {
               default: false
             }]));
             if (syncVault) {
-              await import_promises9.default.writeFile(localEnvPath, vaultContent, "utf-8");
-              console.log(import_chalk11.default.green("   \u2705 .env.local synchronized with Vault."));
+              await import_promises10.default.writeFile(localEnvPath, vaultContent, "utf-8");
+              console.log(import_chalk12.default.green("   \u2705 .env.local synchronized with Vault."));
             } else {
-              console.log(import_chalk11.default.dim("   Skipped vault sync."));
+              console.log(import_chalk12.default.dim("   Skipped vault sync."));
             }
           } else {
-            console.log(import_chalk11.default.dim("\n\u{1F510} Sovereign Foundation: Synced."));
+            console.log(import_chalk12.default.dim("\n\u{1F510} Sovereign Foundation: Synced."));
           }
         }
       } catch (e) {
       }
-      console.log(import_chalk11.default.dim("\n\u{1F6E1}\uFE0F System Integrity Check..."));
+      console.log(import_chalk12.default.dim("\n\u{1F6E1}\uFE0F System Integrity Check..."));
       await checkSystemIntegrity(apiUrl, apiKey, projectId);
     } catch (error) {
       if (import_axios8.default.isAxiosError(error)) {
         const message = error.response?.data?.error || error.message;
-        spinner.fail(import_chalk11.default.red(`Sync failed: ${message}`));
+        spinner.fail(import_chalk12.default.red(`Sync failed: ${message}`));
       } else {
-        spinner.fail(import_chalk11.default.red("Sync failed: " + (error.message || "Unknown error")));
+        spinner.fail(import_chalk12.default.red("Sync failed: " + (error.message || "Unknown error")));
       }
     }
   });
@@ -2579,64 +2699,49 @@ async function checkSystemIntegrity(apiUrl, apiKey, projectId) {
       const { migrations, rls, guardian_violations } = response.data.data;
       if (migrations) {
         if (migrations.in_sync) {
-          console.log(import_chalk11.default.green(`   \u2705 Migrations synced (${migrations.count} versions)`));
+          console.log(import_chalk12.default.green(`   \u2705 Migrations synced (${migrations.count} versions)`));
         } else {
-          console.log(import_chalk11.default.red(`   \u{1F6D1} CRITICAL: DB Schema out of sync! ${migrations.missing?.length || 0} migrations not applied.`));
+          console.log(import_chalk12.default.red(`   \u{1F6D1} CRITICAL: DB Schema out of sync! ${migrations.missing?.length || 0} migrations not applied.`));
           if (migrations.missing?.length > 0) {
-            console.log(import_chalk11.default.dim(`      Missing: ${migrations.missing.slice(0, 3).join(", ")}${migrations.missing.length > 3 ? "..." : ""}`));
+            console.log(import_chalk12.default.dim(`      Missing: ${migrations.missing.slice(0, 3).join(", ")}${migrations.missing.length > 3 ? "..." : ""}`));
           }
-          console.log(import_chalk11.default.yellow(`      Run 'supabase db push' or apply migrations immediately.`));
+          console.log(import_chalk12.default.yellow(`      Run 'supabase db push' or apply migrations immediately.`));
         }
       }
       if (rls) {
         if (rls.all_secured) {
-          console.log(import_chalk11.default.green(`   \u2705 RLS Audit Passed (${rls.table_count} tables secured)`));
+          console.log(import_chalk12.default.green(`   \u2705 RLS Audit Passed (${rls.table_count} tables secured)`));
         } else {
-          console.log(import_chalk11.default.red(`   \u{1F6D1} CRITICAL: Security Vulnerability! ${rls.unsecured?.length || 0} tables have RLS disabled.`));
+          console.log(import_chalk12.default.red(`   \u{1F6D1} CRITICAL: Security Vulnerability! ${rls.unsecured?.length || 0} tables have RLS disabled.`));
           rls.unsecured?.forEach((table) => {
-            console.log(import_chalk11.default.red(`      - ${table}`));
+            console.log(import_chalk12.default.red(`      - ${table}`));
           });
-          console.log(import_chalk11.default.yellow('      Enable RLS immediately: ALTER TABLE "table" ENABLE ROW LEVEL SECURITY;'));
+          console.log(import_chalk12.default.yellow('      Enable RLS immediately: ALTER TABLE "table" ENABLE ROW LEVEL SECURITY;'));
         }
       }
       if (guardian_violations) {
         if (guardian_violations.count === 0) {
-          console.log(import_chalk11.default.green("   \u2705 Guardian: No active violations"));
+          console.log(import_chalk12.default.green("   \u2705 Guardian: No active violations"));
         } else {
-          console.log(import_chalk11.default.yellow(`   \u26A0\uFE0F Guardian: ${guardian_violations.count} active violations`));
-          console.log(import_chalk11.default.dim('      Run "rigstate check" for details.'));
+          console.log(import_chalk12.default.yellow(`   \u26A0\uFE0F Guardian: ${guardian_violations.count} active violations`));
+          console.log(import_chalk12.default.dim('      Run "rigstate check" for details.'));
         }
       }
     }
   } catch (e) {
-    console.log(import_chalk11.default.dim("   (System integrity check skipped - API endpoint not available)"));
+    console.log(import_chalk12.default.dim("   (System integrity check skipped - API endpoint not available)"));
   }
 }
 
 // src/commands/init.ts
 init_cjs_shims();
 var import_commander8 = require("commander");
-var import_chalk12 = __toESM(require("chalk"), 1);
+var import_chalk13 = __toESM(require("chalk"), 1);
 var import_promises11 = __toESM(require("fs/promises"), 1);
-var import_path11 = __toESM(require("path"), 1);
+var import_path12 = __toESM(require("path"), 1);
 var import_ora6 = __toESM(require("ora"), 1);
 var import_child_process = require("child_process");
-
-// src/utils/manifest.ts
-init_cjs_shims();
-var import_promises10 = __toESM(require("fs/promises"), 1);
-var import_path10 = __toESM(require("path"), 1);
-async function loadManifest() {
-  try {
-    const manifestPath = import_path10.default.join(process.cwd(), ".rigstate");
-    const content = await import_promises10.default.readFile(manifestPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-
-// src/commands/init.ts
+init_manifest();
 init_config();
 var import_axios9 = __toESM(require("axios"), 1);
 function createInitCommand() {
@@ -2646,7 +2751,7 @@ function createInitCommand() {
     try {
       apiKey = getApiKey();
     } catch (e) {
-      spinner.fail(import_chalk12.default.red('Not authenticated. Run "rigstate login" first.'));
+      spinner.fail(import_chalk13.default.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -2743,7 +2848,7 @@ function createInitCommand() {
               selectedOrgId = orgId;
             }
             if (!selectedOrgId) {
-              console.log(import_chalk12.default.yellow("No organization available. Please create the project via the Rigstate dashboard."));
+              console.log(import_chalk13.default.yellow("No organization available. Please create the project via the Rigstate dashboard."));
               return;
             }
             spinner.start("Creating new project...");
@@ -2755,13 +2860,13 @@ function createInitCommand() {
                 headers: { Authorization: `Bearer ${apiKey}` }
               });
               if (!createResponse.data.success) {
-                spinner.fail(import_chalk12.default.red("Failed to create project: " + createResponse.data.error));
+                spinner.fail(import_chalk13.default.red("Failed to create project: " + createResponse.data.error));
                 return;
               }
               projectId = createResponse.data.data.project.id;
-              spinner.succeed(import_chalk12.default.green(`Created new project: ${newName}`));
+              spinner.succeed(import_chalk13.default.green(`Created new project: ${newName}`));
             } catch (e) {
-              spinner.fail(import_chalk12.default.red("Project creation API not available. Please create via dashboard."));
+              spinner.fail(import_chalk13.default.red("Project creation API not available. Please create via dashboard."));
               return;
             }
           } else {
@@ -2771,28 +2876,27 @@ function createInitCommand() {
         spinner.start(`Linking to project ID: ${projectId}...`);
       }
       setProjectId(projectId);
-      const manifestPath = import_path11.default.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 import_promises11.default.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), "utf-8");
+      });
       try {
         await import_promises11.default.access(".git");
       } catch {
         spinner.text = "Initializing git repository...";
         (0, import_child_process.execSync)("git init", { stdio: "ignore" });
       }
-      spinner.succeed(import_chalk12.default.green(`\u2705 Linked to project: ${projectId}`));
+      spinner.succeed(import_chalk13.default.green(`\u2705 Linked to project: ${projectId}`));
       await generateRules(apiUrl, apiKey, projectId, options.force, spinner);
       console.log("");
-      console.log(import_chalk12.default.blue("Next steps:"));
-      console.log(import_chalk12.default.dim("  rigstate sync     - Sync roadmap and context"));
-      console.log(import_chalk12.default.dim("  rigstate watch    - Start development loop"));
-      console.log(import_chalk12.default.dim("  rigstate focus    - Get current task"));
+      console.log(import_chalk13.default.blue("Next steps:"));
+      console.log(import_chalk13.default.dim("  rigstate sync     - Sync roadmap and context"));
+      console.log(import_chalk13.default.dim("  rigstate watch    - Start development loop"));
+      console.log(import_chalk13.default.dim("  rigstate focus    - Get current task"));
     } catch (e) {
-      spinner.fail(import_chalk12.default.red("Initialization failed: " + e.message));
+      spinner.fail(import_chalk13.default.red("Initialization failed: " + e.message));
     }
   });
 }
@@ -2807,19 +2911,19 @@ async function generateRules(apiUrl, apiKey, projectId, force, spinner) {
     if (response.data.success || response.data.files) {
       const files = response.data.files || [];
       if (files.length === 0 && response.data.rules) {
-        const rulesPath = import_path11.default.join(process.cwd(), ".cursorrules");
+        const rulesPath = import_path12.default.join(process.cwd(), ".cursorrules");
         await import_promises11.default.writeFile(rulesPath, response.data.rules, "utf-8");
-        spinner.succeed(import_chalk12.default.green("\u2714 Generated .cursorrules (legacy mode)"));
+        spinner.succeed(import_chalk13.default.green("\u2714 Generated .cursorrules (legacy mode)"));
         return;
       }
       for (const file of files) {
-        const targetPath = import_path11.default.join(process.cwd(), file.path);
-        const targetDir = import_path11.default.dirname(targetPath);
+        const targetPath = import_path12.default.join(process.cwd(), file.path);
+        const targetDir = import_path12.default.dirname(targetPath);
         await import_promises11.default.mkdir(targetDir, { recursive: true });
         try {
           await import_promises11.default.access(targetPath);
           if (!force && !file.path.startsWith(".cursor/rules/")) {
-            console.log(import_chalk12.default.dim(`  ${file.path} already exists. Skipping.`));
+            console.log(import_chalk13.default.dim(`  ${file.path} already exists. Skipping.`));
             continue;
           }
         } catch {
@@ -2827,45 +2931,46 @@ async function generateRules(apiUrl, apiKey, projectId, force, spinner) {
         await import_promises11.default.writeFile(targetPath, file.content, "utf-8");
       }
       if (files.length > 0) {
-        const legacyPath = import_path11.default.join(process.cwd(), ".cursorrules");
+        const legacyPath = import_path12.default.join(process.cwd(), ".cursorrules");
         try {
           const stats = await import_promises11.default.stat(legacyPath);
           if (stats.isFile()) {
             await import_promises11.default.rename(legacyPath, `${legacyPath}.bak`);
-            console.log(import_chalk12.default.dim("  Moved legacy .cursorrules to .cursorrules.bak"));
+            console.log(import_chalk13.default.dim("  Moved legacy .cursorrules to .cursorrules.bak"));
           }
         } catch (e) {
         }
       }
-      spinner.succeed(import_chalk12.default.green(`\u2714 Generated ${files.length} rule files (v${response.data.version || "3.0"})`));
+      spinner.succeed(import_chalk13.default.green(`\u2714 Generated ${files.length} rule files (v${response.data.version || "3.0"})`));
     } else {
-      spinner.info(import_chalk12.default.dim("  Rules generation skipped (API response invalid)"));
+      spinner.info(import_chalk13.default.dim("  Rules generation skipped (API response invalid)"));
     }
   } catch (e) {
-    spinner.info(import_chalk12.default.dim(`  Rules generation failed: ${e.message}`));
+    spinner.info(import_chalk13.default.dim(`  Rules generation failed: ${e.message}`));
   }
 }
 
 // src/commands/check.ts
 init_cjs_shims();
 var import_commander9 = require("commander");
-var import_chalk14 = __toESM(require("chalk"), 1);
+var import_chalk15 = __toESM(require("chalk"), 1);
 var import_ora7 = __toESM(require("ora"), 1);
 var import_axios10 = __toESM(require("axios"), 1);
 var import_glob3 = require("glob");
 var import_promises13 = __toESM(require("fs/promises"), 1);
-var import_path13 = __toESM(require("path"), 1);
+var import_path14 = __toESM(require("path"), 1);
 var import_child_process2 = require("child_process");
 init_config();
+init_manifest();
 
 // src/utils/rule-engine.ts
 init_cjs_shims();
 var import_promises12 = __toESM(require("fs/promises"), 1);
-var import_path12 = __toESM(require("path"), 1);
-var import_chalk13 = __toESM(require("chalk"), 1);
+var import_path13 = __toESM(require("path"), 1);
+var import_chalk14 = __toESM(require("chalk"), 1);
 async function checkFile(filePath, rules, rootPath) {
   const violations = [];
-  const relativePath = import_path12.default.relative(rootPath, filePath);
+  const relativePath = import_path13.default.relative(rootPath, filePath);
   try {
     const content = await import_promises12.default.readFile(filePath, "utf-8");
     const lines = content.split("\n");
@@ -2958,7 +3063,7 @@ async function evaluateRule(rule, content, lines, filePath) {
     case "NAMING_CONVENTION": {
       const value = rule.value;
       const pattern = new RegExp(value.pattern);
-      const fileName = import_path12.default.basename(filePath);
+      const fileName = import_path13.default.basename(filePath);
       if (filePath.includes(value.context) && !pattern.test(fileName)) {
         violations.push({
           file: filePath,
@@ -3017,12 +3122,12 @@ function checkFunctionLines(content, lines, filePath, rule, limit) {
 }
 function formatViolations(violations) {
   for (const v of violations) {
-    const severityColor = v.severity === "critical" ? import_chalk13.default.red : v.severity === "warning" ? import_chalk13.default.yellow : import_chalk13.default.blue;
-    const lineInfo = v.line ? import_chalk13.default.dim(`:${v.line}`) : "";
+    const severityColor = v.severity === "critical" ? import_chalk14.default.red : v.severity === "warning" ? import_chalk14.default.yellow : import_chalk14.default.blue;
+    const lineInfo = v.line ? import_chalk14.default.dim(`:${v.line}`) : "";
     console.log(`  ${severityColor(`[${v.severity.toUpperCase()}]`)} ${v.file}${lineInfo}`);
     console.log(`    ${v.message}`);
     if (v.details) {
-      console.log(`    ${import_chalk13.default.dim(v.details)}`);
+      console.log(`    ${import_chalk14.default.dim(v.details)}`);
     }
   }
 }
@@ -3067,15 +3172,15 @@ function createCheckCommand() {
         projectId = getProjectId();
       }
       if (!projectId) {
-        console.log(import_chalk14.default.red("\u274C No project context found."));
-        console.log(import_chalk14.default.dim('   Run "rigstate link" or pass --project <id>'));
+        console.log(import_chalk15.default.red("\u274C No project context found."));
+        console.log(import_chalk15.default.dim('   Run "rigstate link" or pass --project <id>'));
         process.exit(2);
       }
       let apiKey;
       try {
         apiKey = getApiKey();
       } catch {
-        console.log(import_chalk14.default.red('\u274C Not authenticated. Run "rigstate login" first.'));
+        console.log(import_chalk15.default.red('\u274C Not authenticated. Run "rigstate login" first.'));
         process.exit(2);
       }
       spinner.start("Fetching Guardian rules...");
@@ -3103,17 +3208,17 @@ function createCheckCommand() {
       } catch (apiError) {
         const cached = await loadCachedRules(projectId);
         if (cached && !isStale(cached.timestamp, CACHE_MAX_AGE_MS)) {
-          spinner.warn(import_chalk14.default.yellow("Using cached rules (API unavailable)"));
+          spinner.warn(import_chalk15.default.yellow("Using cached rules (API unavailable)"));
           rules = cached.rules;
           settings = cached.settings;
         } else {
-          spinner.fail(import_chalk14.default.red("Failed to fetch rules and no valid cache"));
-          console.log(import_chalk14.default.dim(`   Error: ${apiError.message}`));
+          spinner.fail(import_chalk15.default.red("Failed to fetch rules and no valid cache"));
+          console.log(import_chalk15.default.dim(`   Error: ${apiError.message}`));
           process.exit(2);
         }
       }
       spinner.succeed(`Loaded ${rules.length} Guardian rules`);
-      const scanPath = import_path13.default.resolve(process.cwd(), targetPath);
+      const scanPath = import_path14.default.resolve(process.cwd(), targetPath);
       let filesToCheck;
       if (options.staged) {
         spinner.start("Getting staged files...");
@@ -3122,14 +3227,14 @@ function createCheckCommand() {
             encoding: "utf-8",
             cwd: process.cwd()
           });
-          filesToCheck = stagedOutput.split("\n").filter((f) => f.trim()).filter((f) => isCodeFile2(f)).map((f) => import_path13.default.resolve(process.cwd(), f));
+          filesToCheck = stagedOutput.split("\n").filter((f) => f.trim()).filter((f) => isCodeFile2(f)).map((f) => import_path14.default.resolve(process.cwd(), f));
         } catch {
           spinner.fail("Not a git repository or no staged files");
           process.exit(2);
         }
       } else {
-        spinner.start(`Scanning ${import_chalk14.default.cyan(targetPath)}...`);
-        const pattern = import_path13.default.join(scanPath, "**/*");
+        spinner.start(`Scanning ${import_chalk15.default.cyan(targetPath)}...`);
+        const pattern = import_path14.default.join(scanPath, "**/*");
         const allFiles = await (0, import_glob3.glob)(pattern, {
           nodir: true,
           dot: false,
@@ -3145,7 +3250,7 @@ function createCheckCommand() {
         filesToCheck = allFiles.filter((f) => isCodeFile2(f));
       }
       if (filesToCheck.length === 0) {
-        spinner.warn(import_chalk14.default.yellow("No code files found to check."));
+        spinner.warn(import_chalk15.default.yellow("No code files found to check."));
         outputResults([], !!options.json);
         process.exit(0);
       }
@@ -3154,7 +3259,7 @@ function createCheckCommand() {
       const results = [];
       for (let i = 0; i < filesToCheck.length; i++) {
         const file = filesToCheck[i];
-        spinner.text = `Checking ${i + 1}/${filesToCheck.length}: ${import_path13.default.basename(file)}`;
+        spinner.text = `Checking ${i + 1}/${filesToCheck.length}: ${import_path14.default.basename(file)}`;
         const result = await checkFile(file, rules, process.cwd());
         results.push(result);
       }
@@ -3164,46 +3269,46 @@ function createCheckCommand() {
         outputResults(results, true);
       } else {
         outputResults(results, false);
-        console.log("\n" + import_chalk14.default.bold("\u{1F4CA} Summary"));
-        console.log(import_chalk14.default.dim("\u2500".repeat(50)));
-        console.log(`Files checked: ${import_chalk14.default.cyan(summary.totalFiles)}`);
-        console.log(`Total violations: ${summary.totalViolations > 0 ? import_chalk14.default.red(summary.totalViolations) : import_chalk14.default.green(0)}`);
+        console.log("\n" + import_chalk15.default.bold("\u{1F4CA} Summary"));
+        console.log(import_chalk15.default.dim("\u2500".repeat(50)));
+        console.log(`Files checked: ${import_chalk15.default.cyan(summary.totalFiles)}`);
+        console.log(`Total violations: ${summary.totalViolations > 0 ? import_chalk15.default.red(summary.totalViolations) : import_chalk15.default.green(0)}`);
         if (summary.totalViolations > 0) {
-          console.log(`  ${import_chalk14.default.red("Critical:")} ${summary.criticalCount}`);
-          console.log(`  ${import_chalk14.default.yellow("Warning:")} ${summary.warningCount}`);
-          console.log(`  ${import_chalk14.default.blue("Info:")} ${summary.infoCount}`);
+          console.log(`  ${import_chalk15.default.red("Critical:")} ${summary.criticalCount}`);
+          console.log(`  ${import_chalk15.default.yellow("Warning:")} ${summary.warningCount}`);
+          console.log(`  ${import_chalk15.default.blue("Info:")} ${summary.infoCount}`);
         }
-        console.log(import_chalk14.default.dim("\u2500".repeat(50)));
+        console.log(import_chalk15.default.dim("\u2500".repeat(50)));
       }
       if (options.strict !== void 0) {
         const strictLevel = typeof options.strict === "string" ? options.strict : "all";
         if (strictLevel === "critical" && summary.criticalCount > 0) {
-          console.log(import_chalk14.default.red("\n\u274C Check failed: Critical violations found"));
+          console.log(import_chalk15.default.red("\n\u274C Check failed: Critical violations found"));
           process.exit(1);
         } else if (strictLevel === "all" && summary.totalViolations > 0) {
-          console.log(import_chalk14.default.red("\n\u274C Check failed: Violations found"));
+          console.log(import_chalk15.default.red("\n\u274C Check failed: Violations found"));
           process.exit(1);
         }
       }
       if (summary.totalViolations === 0) {
-        console.log(import_chalk14.default.green("\n\u2705 All checks passed!"));
+        console.log(import_chalk15.default.green("\n\u2705 All checks passed!"));
       }
       process.exit(0);
     } catch (error) {
-      spinner.fail(import_chalk14.default.red("Check failed"));
-      console.error(import_chalk14.default.red("Error:"), error.message);
+      spinner.fail(import_chalk15.default.red("Check failed"));
+      console.error(import_chalk15.default.red("Error:"), error.message);
       process.exit(2);
     }
   });
 }
 function isCodeFile2(filePath) {
   const codeExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-  const ext = import_path13.default.extname(filePath).toLowerCase();
+  const ext = import_path14.default.extname(filePath).toLowerCase();
   return codeExtensions.includes(ext);
 }
 async function loadCachedRules(projectId) {
   try {
-    const cachePath = import_path13.default.join(process.cwd(), CACHE_FILE2);
+    const cachePath = import_path14.default.join(process.cwd(), CACHE_FILE2);
     const content = await import_promises13.default.readFile(cachePath, "utf-8");
     const cached = JSON.parse(content);
     if (cached.projectId !== projectId) {
@@ -3216,7 +3321,7 @@ async function loadCachedRules(projectId) {
 }
 async function saveCachedRules(projectId, rules, settings) {
   try {
-    const cacheDir = import_path13.default.join(process.cwd(), ".rigstate");
+    const cacheDir = import_path14.default.join(process.cwd(), ".rigstate");
     await import_promises13.default.mkdir(cacheDir, { recursive: true });
     const cached = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3225,7 +3330,7 @@ async function saveCachedRules(projectId, rules, settings) {
       settings
     };
     await import_promises13.default.writeFile(
-      import_path13.default.join(cacheDir, "rules-cache.json"),
+      import_path14.default.join(cacheDir, "rules-cache.json"),
       JSON.stringify(cached, null, 2)
     );
   } catch {
@@ -3247,8 +3352,8 @@ function outputResults(results, json) {
   if (!hasViolations) {
     return;
   }
-  console.log("\n" + import_chalk14.default.bold("\u{1F50D} Violations Found"));
-  console.log(import_chalk14.default.dim("\u2500".repeat(50)));
+  console.log("\n" + import_chalk15.default.bold("\u{1F50D} Violations Found"));
+  console.log(import_chalk15.default.dim("\u2500".repeat(50)));
   for (const result of results) {
     if (result.violations.length > 0) {
       formatViolations(result.violations);
@@ -3259,9 +3364,9 @@ function outputResults(results, json) {
 // src/commands/hooks.ts
 init_cjs_shims();
 var import_commander10 = require("commander");
-var import_chalk15 = __toESM(require("chalk"), 1);
+var import_chalk16 = __toESM(require("chalk"), 1);
 var import_promises14 = __toESM(require("fs/promises"), 1);
-var import_path14 = __toESM(require("path"), 1);
+var import_path15 = __toESM(require("path"), 1);
 var PRE_COMMIT_SCRIPT = `#!/bin/sh
 # Rigstate Guardian Pre-commit Hook
 # Installed by: rigstate hooks install
@@ -3290,23 +3395,23 @@ function createHooksCommand() {
   const hooks = new import_commander10.Command("hooks").description("Manage git hooks for Guardian integration");
   hooks.command("install").description("Install pre-commit hook to run Guardian checks").option("--strict [level]", 'Strict level: "all" or "critical" (default)', "critical").action(async (options) => {
     try {
-      const gitDir = import_path14.default.join(process.cwd(), ".git");
+      const gitDir = import_path15.default.join(process.cwd(), ".git");
       try {
         await import_promises14.default.access(gitDir);
       } catch {
-        console.log(import_chalk15.default.red("\u274C Not a git repository."));
-        console.log(import_chalk15.default.dim('   Initialize with "git init" first.'));
+        console.log(import_chalk16.default.red("\u274C Not a git repository."));
+        console.log(import_chalk16.default.dim('   Initialize with "git init" first.'));
         process.exit(1);
       }
-      const hooksDir = import_path14.default.join(gitDir, "hooks");
+      const hooksDir = import_path15.default.join(gitDir, "hooks");
       await import_promises14.default.mkdir(hooksDir, { recursive: true });
-      const preCommitPath = import_path14.default.join(hooksDir, "pre-commit");
+      const preCommitPath = import_path15.default.join(hooksDir, "pre-commit");
       let existingContent = "";
       try {
         existingContent = await import_promises14.default.readFile(preCommitPath, "utf-8");
         if (existingContent.includes("rigstate")) {
-          console.log(import_chalk15.default.yellow("\u26A0 Rigstate pre-commit hook already installed."));
-          console.log(import_chalk15.default.dim('   Use "rigstate hooks uninstall" to remove first.'));
+          console.log(import_chalk16.default.yellow("\u26A0 Rigstate pre-commit hook already installed."));
+          console.log(import_chalk16.default.dim('   Use "rigstate hooks uninstall" to remove first.'));
           return;
         }
       } catch {
@@ -3318,33 +3423,33 @@ function createHooksCommand() {
       if (existingContent && !existingContent.includes("rigstate")) {
         const combinedScript = existingContent + "\n\n" + script.replace("#!/bin/sh\n", "");
         await import_promises14.default.writeFile(preCommitPath, combinedScript, { mode: 493 });
-        console.log(import_chalk15.default.green("\u2705 Rigstate hook appended to existing pre-commit."));
+        console.log(import_chalk16.default.green("\u2705 Rigstate hook appended to existing pre-commit."));
       } else {
         await import_promises14.default.writeFile(preCommitPath, script, { mode: 493 });
-        console.log(import_chalk15.default.green("\u2705 Pre-commit hook installed!"));
+        console.log(import_chalk16.default.green("\u2705 Pre-commit hook installed!"));
       }
-      console.log(import_chalk15.default.dim(`   Path: ${preCommitPath}`));
-      console.log(import_chalk15.default.dim(`   Strict level: ${options.strict}`));
+      console.log(import_chalk16.default.dim(`   Path: ${preCommitPath}`));
+      console.log(import_chalk16.default.dim(`   Strict level: ${options.strict}`));
       console.log("");
-      console.log(import_chalk15.default.cyan("Guardian will now check your code before each commit."));
-      console.log(import_chalk15.default.dim('Use "rigstate hooks uninstall" to remove the hook.'));
+      console.log(import_chalk16.default.cyan("Guardian will now check your code before each commit."));
+      console.log(import_chalk16.default.dim('Use "rigstate hooks uninstall" to remove the hook.'));
     } catch (error) {
-      console.error(import_chalk15.default.red("Failed to install hook:"), error.message);
+      console.error(import_chalk16.default.red("Failed to install hook:"), error.message);
       process.exit(1);
     }
   });
   hooks.command("uninstall").description("Remove Rigstate pre-commit hook").action(async () => {
     try {
-      const preCommitPath = import_path14.default.join(process.cwd(), ".git", "hooks", "pre-commit");
+      const preCommitPath = import_path15.default.join(process.cwd(), ".git", "hooks", "pre-commit");
       try {
         const content = await import_promises14.default.readFile(preCommitPath, "utf-8");
         if (!content.includes("rigstate")) {
-          console.log(import_chalk15.default.yellow("\u26A0 No Rigstate hook found in pre-commit."));
+          console.log(import_chalk16.default.yellow("\u26A0 No Rigstate hook found in pre-commit."));
           return;
         }
         if (content.includes("# Rigstate Guardian Pre-commit Hook") && content.trim().split("\n").filter((l) => l && !l.startsWith("#")).length <= 4) {
           await import_promises14.default.unlink(preCommitPath);
-          console.log(import_chalk15.default.green("\u2705 Pre-commit hook removed."));
+          console.log(import_chalk16.default.green("\u2705 Pre-commit hook removed."));
         } else {
           const lines = content.split("\n");
           const filteredLines = [];
@@ -3363,13 +3468,13 @@ function createHooksCommand() {
             }
           }
           await import_promises14.default.writeFile(preCommitPath, filteredLines.join("\n"), { mode: 493 });
-          console.log(import_chalk15.default.green("\u2705 Rigstate section removed from pre-commit hook."));
+          console.log(import_chalk16.default.green("\u2705 Rigstate section removed from pre-commit hook."));
         }
       } catch {
-        console.log(import_chalk15.default.yellow("\u26A0 No pre-commit hook found."));
+        console.log(import_chalk16.default.yellow("\u26A0 No pre-commit hook found."));
       }
     } catch (error) {
-      console.error(import_chalk15.default.red("Failed to uninstall hook:"), error.message);
+      console.error(import_chalk16.default.red("Failed to uninstall hook:"), error.message);
       process.exit(1);
     }
   });
@@ -3379,40 +3484,40 @@ function createHooksCommand() {
 // src/commands/daemon.ts
 init_cjs_shims();
 var import_commander11 = require("commander");
-var import_chalk21 = __toESM(require("chalk"), 1);
+var import_chalk22 = __toESM(require("chalk"), 1);
 var import_ora8 = __toESM(require("ora"), 1);
 var import_promises19 = __toESM(require("fs/promises"), 1);
-var import_path22 = __toESM(require("path"), 1);
+var import_path23 = __toESM(require("path"), 1);
 
 // src/daemon/factory.ts
 init_cjs_shims();
 
 // src/daemon/core.ts
 init_cjs_shims();
-var import_chalk19 = __toESM(require("chalk"), 1);
-var fs18 = __toESM(require("fs/promises"), 1);
-var import_path20 = __toESM(require("path"), 1);
+var import_chalk20 = __toESM(require("chalk"), 1);
+var fs19 = __toESM(require("fs/promises"), 1);
+var import_path21 = __toESM(require("path"), 1);
 var import_events4 = require("events");
 
 // src/daemon/file-watcher.ts
 init_cjs_shims();
 var chokidar = __toESM(require("chokidar"), 1);
-var import_path15 = __toESM(require("path"), 1);
+var import_path16 = __toESM(require("path"), 1);
 var import_events = require("events");
 var CODE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 function isCodeFile3(filePath) {
-  const ext = import_path15.default.extname(filePath).toLowerCase();
+  const ext = import_path16.default.extname(filePath).toLowerCase();
   return CODE_EXTENSIONS.includes(ext);
 }
 function createFileWatcher(watchPath) {
   const emitter = new import_events.EventEmitter();
   let watcher = null;
   emitter.start = () => {
-    const absolutePath = import_path15.default.resolve(process.cwd(), watchPath);
+    const absolutePath = import_path16.default.resolve(process.cwd(), watchPath);
     watcher = chokidar.watch(absolutePath, {
       ignored: (pathStr) => {
-        const relativePath = import_path15.default.relative(process.cwd(), pathStr);
-        const segments = relativePath.split(import_path15.default.sep);
+        const relativePath = import_path16.default.relative(process.cwd(), pathStr);
+        const segments = relativePath.split(import_path16.default.sep);
         const ignoreDirs = [
           "node_modules",
           ".git",
@@ -3444,7 +3549,7 @@ function createFileWatcher(watchPath) {
         if (segments.some((segment) => ignoreDirs.includes(segment))) {
           return true;
         }
-        const isFile = !!import_path15.default.extname(pathStr);
+        const isFile = !!import_path16.default.extname(pathStr);
         if (isFile && !isCodeFile3(pathStr)) {
           return true;
         }
@@ -3467,17 +3572,17 @@ function createFileWatcher(watchPath) {
     });
     watcher.on("change", (filePath) => {
       if (isCodeFile3(filePath)) {
-        emitter.emit("change", import_path15.default.relative(process.cwd(), filePath));
+        emitter.emit("change", import_path16.default.relative(process.cwd(), filePath));
       }
     });
     watcher.on("add", (filePath) => {
       if (isCodeFile3(filePath)) {
-        emitter.emit("add", import_path15.default.relative(process.cwd(), filePath));
+        emitter.emit("add", import_path16.default.relative(process.cwd(), filePath));
       }
     });
     watcher.on("unlink", (filePath) => {
       if (isCodeFile3(filePath)) {
-        emitter.emit("unlink", import_path15.default.relative(process.cwd(), filePath));
+        emitter.emit("unlink", import_path16.default.relative(process.cwd(), filePath));
       }
     });
     watcher.on("error", (error) => {
@@ -3499,8 +3604,8 @@ function createFileWatcher(watchPath) {
 // src/daemon/heuristic-engine.ts
 init_cjs_shims();
 var import_promises15 = require("fs/promises");
-var import_path16 = require("path");
-var import_path17 = __toESM(require("path"), 1);
+var import_path17 = require("path");
+var import_path18 = __toESM(require("path"), 1);
 var import_axios11 = __toESM(require("axios"), 1);
 var GLOBAL_HEURISTICS = [
   {
@@ -3532,7 +3637,7 @@ var HeuristicEngine = class {
   rules = [];
   cachePath;
   constructor() {
-    this.cachePath = import_path17.default.join(process.cwd(), ".rigstate", "cache", "heuristics.json");
+    this.cachePath = import_path18.default.join(process.cwd(), ".rigstate", "cache", "heuristics.json");
     this.loadRules();
   }
   async loadRules() {
@@ -3549,7 +3654,7 @@ var HeuristicEngine = class {
   }
   async refreshRules(projectId, apiUrl, apiKey) {
     try {
-      await (0, import_promises15.mkdir)((0, import_path16.dirname)(this.cachePath), { recursive: true });
+      await (0, import_promises15.mkdir)((0, import_path17.dirname)(this.cachePath), { recursive: true });
       const endpoint = `${apiUrl}/api/v1/skills/triggers`;
       const response = await import_axios11.default.get(endpoint, {
         headers: {
@@ -3647,9 +3752,9 @@ function createHeuristicEngine() {
 
 // src/daemon/intervention-protocol.ts
 init_cjs_shims();
-var import_chalk16 = __toESM(require("chalk"), 1);
-var fs15 = __toESM(require("fs"), 1);
-var path17 = __toESM(require("path"), 1);
+var import_chalk17 = __toESM(require("chalk"), 1);
+var fs16 = __toESM(require("fs"), 1);
+var path18 = __toESM(require("path"), 1);
 var InterventionProtocol = class {
   activeViolators = /* @__PURE__ */ new Set();
   /**
@@ -3672,18 +3777,18 @@ var InterventionProtocol = class {
   }
   syncLockFile() {
     try {
-      const lockDir = path17.join(process.cwd(), ".rigstate");
-      if (!fs15.existsSync(lockDir)) fs15.mkdirSync(lockDir, { recursive: true });
-      const lockPath = path17.join(lockDir, "guardian.lock");
+      const lockDir = path18.join(process.cwd(), ".rigstate");
+      if (!fs16.existsSync(lockDir)) fs16.mkdirSync(lockDir, { recursive: true });
+      const lockPath = path18.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);
@@ -3737,11 +3842,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" ? import_chalk16.default.bgRed.white.bold : import_chalk16.default.yellow.bold;
+    const color = decision.mode === "HARD_LOCK" ? import_chalk17.default.bgRed.white.bold : import_chalk17.default.yellow.bold;
     console.log("\n" + color(` ${icon} [${decision.mode}] INTERVENTION `));
-    console.log(import_chalk16.default.redBright(` ${decision.message}`));
+    console.log(import_chalk17.default.redBright(` ${decision.message}`));
     if (decision.blockCommit) {
-      console.log(import_chalk16.default.dim(" \u{1F512} Commit functionality is logically suspended until fixed."));
+      console.log(import_chalk17.default.dim(" \u{1F512} Commit functionality is logically suspended until fixed."));
     }
   }
 };
@@ -3752,9 +3857,9 @@ function createInterventionProtocol() {
 // src/daemon/guardian-monitor.ts
 init_cjs_shims();
 var import_axios12 = __toESM(require("axios"), 1);
-var import_chalk17 = __toESM(require("chalk"), 1);
+var import_chalk18 = __toESM(require("chalk"), 1);
 var import_promises16 = __toESM(require("fs/promises"), 1);
-var import_path18 = __toESM(require("path"), 1);
+var import_path19 = __toESM(require("path"), 1);
 var CACHE_FILE3 = ".rigstate/rules-cache.json";
 var CACHE_TTL_MS2 = 5 * 60 * 1e3;
 function createGuardianMonitor(projectId, apiUrl, apiKey) {
@@ -3779,7 +3884,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(import_chalk17.default.blue(`  \u2601\uFE0F  Local API not found. Attempting Cloud Fallback (${cloudUrl})...`));
+        console.log(import_chalk18.default.blue(`  \u2601\uFE0F  Local API not found. Attempting Cloud Fallback (${cloudUrl})...`));
         try {
           const cloudResponse = await import_axios12.default.get(`${cloudUrl}/api/v1/guardian/rules`, {
             params: { project_id: projectId },
@@ -3788,22 +3893,22 @@ function createGuardianMonitor(projectId, apiUrl, apiKey) {
           });
           if (cloudResponse.data.success && cloudResponse.data.data.rules) {
             rules = cloudResponse.data.data.rules;
-            console.log(import_chalk17.default.green(`  \u2705 Successfully loaded rules from Rigstate Cloud!`));
+            console.log(import_chalk18.default.green(`  \u2705 Successfully loaded rules from Rigstate Cloud!`));
             lastFetch = Date.now();
             await saveCachedRules2(projectId, rules);
             return;
           }
         } catch (cloudError) {
-          console.error(import_chalk17.default.red(`  \u274C Cloud Fallback failed: ${cloudError.message}`));
+          console.error(import_chalk18.default.red(`  \u274C Cloud Fallback failed: ${cloudError.message}`));
         }
       }
-      console.error(import_chalk17.default.red(`  \u26A0\uFE0F  Failed to fetch rules from API: ${error.message}`));
+      console.error(import_chalk18.default.red(`  \u26A0\uFE0F  Failed to fetch rules from API: ${error.message}`));
       if (error.response) {
-        console.error(import_chalk17.default.red(`     Status: ${error.response.status} - ${JSON.stringify(error.response.data)}`));
+        console.error(import_chalk18.default.red(`     Status: ${error.response.status} - ${JSON.stringify(error.response.data)}`));
       }
       const cached = await loadCachedRules2(projectId);
       if (cached) {
-        console.log(import_chalk17.default.yellow("  \u2139\uFE0F  Using cached rules as fallback"));
+        console.log(import_chalk18.default.yellow("  \u2139\uFE0F  Using cached rules as fallback"));
         rules = cached.rules;
         lastFetch = Date.now();
         return;
@@ -3820,7 +3925,7 @@ function createGuardianMonitor(projectId, apiUrl, apiKey) {
         passed: true
       };
     }
-    const absolutePath = import_path18.default.resolve(process.cwd(), filePath);
+    const absolutePath = import_path19.default.resolve(process.cwd(), filePath);
     return checkFile(absolutePath, rules, process.cwd());
   };
   const getRuleCount = () => rules.length;
@@ -3834,7 +3939,7 @@ function createGuardianMonitor(projectId, apiUrl, apiKey) {
 }
 async function loadCachedRules2(projectId) {
   try {
-    const cachePath = import_path18.default.join(process.cwd(), CACHE_FILE3);
+    const cachePath = import_path19.default.join(process.cwd(), CACHE_FILE3);
     const content = await import_promises16.default.readFile(cachePath, "utf-8");
     const cached = JSON.parse(content);
     if (cached.projectId !== projectId) {
@@ -3847,7 +3952,7 @@ async function loadCachedRules2(projectId) {
 }
 async function saveCachedRules2(projectId, rules) {
   try {
-    const cacheDir = import_path18.default.join(process.cwd(), ".rigstate");
+    const cacheDir = import_path19.default.join(process.cwd(), ".rigstate");
     await import_promises16.default.mkdir(cacheDir, { recursive: true });
     const cached = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3856,7 +3961,7 @@ async function saveCachedRules2(projectId, rules) {
       settings: { lmax: 400, lmax_warning: 350 }
     };
     await import_promises16.default.writeFile(
-      import_path18.default.join(cacheDir, "rules-cache.json"),
+      import_path19.default.join(cacheDir, "rules-cache.json"),
       JSON.stringify(cached, null, 2)
     );
   } catch {
@@ -3956,37 +4061,37 @@ init_sync_rules();
 
 // src/utils/logger.ts
 init_cjs_shims();
-var import_chalk18 = __toESM(require("chalk"), 1);
+var import_chalk19 = __toESM(require("chalk"), 1);
 var Logger = class {
   static formatMessage(level, message, context) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     let prefix = "";
     switch (level) {
       case "INFO" /* INFO */:
-        prefix = import_chalk18.default.blue(`[${"INFO" /* INFO */}]`);
+        prefix = import_chalk19.default.blue(`[${"INFO" /* INFO */}]`);
         break;
       case "WARN" /* WARN */:
-        prefix = import_chalk18.default.yellow(`[${"WARN" /* WARN */}]`);
+        prefix = import_chalk19.default.yellow(`[${"WARN" /* WARN */}]`);
         break;
       case "ERROR" /* ERROR */:
-        prefix = import_chalk18.default.red(`[${"ERROR" /* ERROR */}]`);
+        prefix = import_chalk19.default.red(`[${"ERROR" /* ERROR */}]`);
         break;
       case "DEBUG" /* DEBUG */:
-        prefix = import_chalk18.default.gray(`[${"DEBUG" /* DEBUG */}]`);
+        prefix = import_chalk19.default.gray(`[${"DEBUG" /* DEBUG */}]`);
         break;
     }
-    let output = `${import_chalk18.default.gray(timestamp)} ${prefix} ${message}`;
+    let output = `${import_chalk19.default.gray(timestamp)} ${prefix} ${message}`;
     if (context) {
       if (context instanceof Error) {
         output += `
-${import_chalk18.default.red(context.stack || context.message)}`;
+${import_chalk19.default.red(context.stack || context.message)}`;
       } else if (typeof context === "object") {
         try {
           output += `
-${import_chalk18.default.gray(JSON.stringify(context, null, 2))}`;
+${import_chalk19.default.gray(JSON.stringify(context, null, 2))}`;
         } catch (e) {
           output += `
-${import_chalk18.default.gray("[Circular or invalid object]")}`;
+${import_chalk19.default.gray("[Circular or invalid object]")}`;
         }
       } else {
         output += ` ${String(context)}`;
@@ -4014,7 +4119,7 @@ ${import_chalk18.default.gray("[Circular or invalid object]")}`;
 init_cjs_shims();
 var import_events3 = require("events");
 var import_chokidar = __toESM(require("chokidar"), 1);
-var import_path19 = __toESM(require("path"), 1);
+var import_path20 = __toESM(require("path"), 1);
 var import_promises17 = __toESM(require("fs/promises"), 1);
 var import_crypto = __toESM(require("crypto"), 1);
 var import_axios15 = __toESM(require("axios"), 1);
@@ -4033,8 +4138,8 @@ var KnowledgeHarvester = class extends import_events3.EventEmitter {
   }
   async start() {
     await this.loadHashes();
-    const rulesPath = import_path19.default.join(this.config.watchPath, ".cursor", "rules");
-    const watchPattern = import_path19.default.join(rulesPath, "**", "*.mdc");
+    const rulesPath = import_path20.default.join(this.config.watchPath, ".cursor", "rules");
+    const watchPattern = import_path20.default.join(rulesPath, "**", "*.mdc");
     Logger.debug(`\u{1F33E} Harvester watching: ${watchPattern}`);
     this.watcher = import_chokidar.default.watch(watchPattern, {
       persistent: true,
@@ -4055,7 +4160,7 @@ var KnowledgeHarvester = class extends import_events3.EventEmitter {
     }
   }
   async handleFileEvent(filePath, event) {
-    const fileName = import_path19.default.basename(filePath);
+    const fileName = import_path20.default.basename(filePath);
     if (this.IGNORED_PREFIXES.some((prefix) => fileName.startsWith(prefix))) {
       return;
     }
@@ -4074,24 +4179,24 @@ var KnowledgeHarvester = class extends import_events3.EventEmitter {
       const content = await import_promises17.default.readFile(filePath, "utf-8");
       const currentHash = this.computeHash(content);
       if (this.ruleHashes.get(filePath) === currentHash) {
-        Logger.debug(`Skipping ${import_path19.default.basename(filePath)} (unchanged hash)`);
+        Logger.debug(`Skipping ${import_path20.default.basename(filePath)} (unchanged hash)`);
         return;
       }
       if (content.length < 20) {
-        Logger.debug(`Skipping ${import_path19.default.basename(filePath)} (too short)`);
+        Logger.debug(`Skipping ${import_path20.default.basename(filePath)} (too short)`);
         return;
       }
       await this.submitSignal(filePath, content);
       this.ruleHashes.set(filePath, currentHash);
     } catch (error) {
-      Logger.warn(`Harvester failed to process ${import_path19.default.basename(filePath)}: ${error.message}`);
+      Logger.warn(`Harvester failed to process ${import_path20.default.basename(filePath)}: ${error.message}`);
     } finally {
       this.processingQueue.delete(filePath);
     }
   }
   async submitSignal(filePath, content) {
-    const title = import_path19.default.basename(filePath, ".mdc");
-    const relativePath = import_path19.default.relative(process.cwd(), filePath);
+    const title = import_path20.default.basename(filePath, ".mdc");
+    const relativePath = import_path20.default.relative(process.cwd(), filePath);
     Logger.info(`\u{1F33E} Harvesting new knowledge: ${title}`);
     try {
       const descriptionMatch = content.match(/description:\s*(.*)/);
@@ -4125,13 +4230,13 @@ var KnowledgeHarvester = class extends import_events3.EventEmitter {
     }
   }
   async loadHashes() {
-    const rulesPath = import_path19.default.join(this.config.watchPath, ".cursor", "rules");
+    const rulesPath = import_path20.default.join(this.config.watchPath, ".cursor", "rules");
     try {
       await import_promises17.default.mkdir(rulesPath, { recursive: true });
       const files = await import_promises17.default.readdir(rulesPath);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const fullPath = import_path19.default.join(rulesPath, file);
+          const fullPath = import_path20.default.join(rulesPath, file);
           const content = await import_promises17.default.readFile(fullPath, "utf-8");
           this.ruleHashes.set(fullPath, this.computeHash(content));
         }
@@ -4169,7 +4274,7 @@ var GuardianDaemon = class extends import_events4.EventEmitter {
   }
   async start() {
     if (this.state.isRunning) {
-      console.log(import_chalk19.default.yellow("Daemon is already running."));
+      console.log(import_chalk20.default.yellow("Daemon is already running."));
       return;
     }
     this.printWelcome();
@@ -4201,8 +4306,8 @@ var GuardianDaemon = class extends import_events4.EventEmitter {
       try {
         await this.setupBridge();
       } catch (e) {
-        console.error(import_chalk19.default.yellow(`  \u26A0\uFE0F  Agent Bridge connection failed: ${e.message}`));
-        console.log(import_chalk19.default.dim("     (Daemon will continue with local monitoring only)"));
+        console.error(import_chalk20.default.yellow(`  \u26A0\uFE0F  Agent Bridge connection failed: ${e.message}`));
+        console.log(import_chalk20.default.dim("     (Daemon will continue with local monitoring only)"));
       }
     }
     this.printActive();
@@ -4218,16 +4323,16 @@ var GuardianDaemon = class extends import_events4.EventEmitter {
     }
   }
   printWelcome() {
-    console.log(import_chalk19.default.bold.blue("\n\u{1F6E1}\uFE0F  Guardian Daemon Starting..."));
-    console.log(import_chalk19.default.dim(`Project: ${this.config.projectId}`));
-    console.log(import_chalk19.default.dim(`API URL: ${this.config.apiUrl}`));
-    console.log(import_chalk19.default.dim(`Watch Path: ${this.config.watchPath}`));
-    console.log(import_chalk19.default.dim("\u2500".repeat(50)));
+    console.log(import_chalk20.default.bold.blue("\n\u{1F6E1}\uFE0F  Guardian Daemon Starting..."));
+    console.log(import_chalk20.default.dim(`Project: ${this.config.projectId}`));
+    console.log(import_chalk20.default.dim(`API URL: ${this.config.apiUrl}`));
+    console.log(import_chalk20.default.dim(`Watch Path: ${this.config.watchPath}`));
+    console.log(import_chalk20.default.dim("\u2500".repeat(50)));
   }
   printActive() {
-    console.log(import_chalk19.default.dim("\u2500".repeat(50)));
-    console.log(import_chalk19.default.green.bold("\u2705 Guardian Daemon is now active"));
-    console.log(import_chalk19.default.dim("Press Ctrl+C to stop\n"));
+    console.log(import_chalk20.default.dim("\u2500".repeat(50)));
+    console.log(import_chalk20.default.green.bold("\u2705 Guardian Daemon is now active"));
+    console.log(import_chalk20.default.dim("Press Ctrl+C to stop\n"));
   }
   async syncHeuristics() {
     if (!this.heuristicEngine) return;
@@ -4250,7 +4355,7 @@ var GuardianDaemon = class extends import_events4.EventEmitter {
   }
   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;
@@ -4287,7 +4392,7 @@ var GuardianDaemon = class extends import_events4.EventEmitter {
     }
   }
   async updateViolationReport(violations) {
-    const reportPath = import_path20.default.join(process.cwd(), ".rigstate", "ACTIVE_VIOLATIONS.md");
+    const reportPath = import_path21.default.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"}
@@ -4303,7 +4408,7 @@ var GuardianDaemon = class extends import_events4.EventEmitter {
     } else {
       content += "### \u{1F6A8} Active Violations\n\n";
       for (const [file, fileViolations] of allViolations) {
-        const relPath = import_path20.default.relative(process.cwd(), file);
+        const relPath = import_path21.default.relative(process.cwd(), file);
         content += `#### \u{1F4C4} ${relPath}
 `;
         for (const v of fileViolations) {
@@ -4315,7 +4420,7 @@ var GuardianDaemon = class extends import_events4.EventEmitter {
       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) {
     }
   }
@@ -4335,27 +4440,27 @@ var GuardianDaemon = class extends import_events4.EventEmitter {
     }
   }
   async setupBridge() {
-    console.log(import_chalk19.default.dim("\u{1F309} Connecting to Agent Bridge..."));
+    console.log(import_chalk20.default.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(import_chalk19.default.cyan(`
+      console.log(import_chalk20.default.cyan(`
 \u{1F4E5} New task received: ${task.id}`));
       this.emit("task", task);
     });
     await this.bridgeListener.connect();
-    console.log(import_chalk19.default.green("  \u2713 Agent Bridge connected"));
+    console.log(import_chalk20.default.green("  \u2713 Agent Bridge connected"));
   }
   async stop() {
     if (!this.state.isRunning) return;
-    console.log(import_chalk19.default.dim("\n\u{1F6D1} Stopping Guardian Daemon..."));
+    console.log(import_chalk20.default.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(import_chalk19.default.green("\u2713 Daemon stopped."));
+    console.log(import_chalk20.default.green("\u2713 Daemon stopped."));
     this.emit("stopped", this.state);
   }
   getState() {
@@ -4365,6 +4470,7 @@ var GuardianDaemon = class extends import_events4.EventEmitter {
 
 // src/daemon/factory.ts
 init_config();
+init_manifest();
 async function createDaemon(options) {
   const apiUrl = getApiUrl();
   let projectId = options.project;
@@ -4394,9 +4500,9 @@ async function createDaemon(options) {
 
 // src/utils/service-manager.ts
 init_cjs_shims();
-var import_chalk20 = __toESM(require("chalk"), 1);
+var import_chalk21 = __toESM(require("chalk"), 1);
 var import_promises18 = __toESM(require("fs/promises"), 1);
-var import_path21 = __toESM(require("path"), 1);
+var import_path22 = __toESM(require("path"), 1);
 var import_child_process3 = require("child_process");
 var import_url = require("url");
 async function execShellCommand(cmd) {
@@ -4408,20 +4514,20 @@ async function execShellCommand(cmd) {
   }
 }
 async function enableDaemon() {
-  console.log(import_chalk20.default.bold("\n\u2699\uFE0F  Enabling Rigstate Background Service (macOS)\n"));
+  console.log(import_chalk21.default.bold("\n\u2699\uFE0F  Enabling Rigstate Background Service (macOS)\n"));
   if (process.platform !== "darwin") {
-    console.error(import_chalk20.default.red("\u274C Currently only macOS is supported for auto-start."));
-    console.error(import_chalk20.default.yellow("PRs welcome for Linux/Windows support!"));
+    console.error(import_chalk21.default.red("\u274C Currently only macOS is supported for auto-start."));
+    console.error(import_chalk21.default.yellow("PRs welcome for Linux/Windows support!"));
     return;
   }
   const homeDir = process.env.HOME || "";
   if (!homeDir) {
-    console.error(import_chalk20.default.red("\u274C Could not determine HOME directory."));
+    console.error(import_chalk21.default.red("\u274C Could not determine HOME directory."));
     return;
   }
-  const agentsDir = import_path21.default.join(homeDir, "Library/LaunchAgents");
-  const logDir = import_path21.default.join(homeDir, ".rigstate/logs");
-  const plistPath = import_path21.default.join(agentsDir, "com.rigstate.daemon.plist");
+  const agentsDir = import_path22.default.join(homeDir, "Library/LaunchAgents");
+  const logDir = import_path22.default.join(homeDir, ".rigstate/logs");
+  const plistPath = import_path22.default.join(agentsDir, "com.rigstate.daemon.plist");
   await import_promises18.default.mkdir(agentsDir, { recursive: true });
   await import_promises18.default.mkdir(logDir, { recursive: true });
   const scriptPath = (0, import_url.fileURLToPath)(importMetaUrl);
@@ -4442,9 +4548,9 @@ async function enableDaemon() {
     <key>WorkingDirectory</key>
     <string>${process.cwd()}</string>
     <key>StandardOutPath</key>
-    <string>${import_path21.default.join(logDir, "daemon.out.log")}</string>
+    <string>${import_path22.default.join(logDir, "daemon.out.log")}</string>
     <key>StandardErrorPath</key>
-    <string>${import_path21.default.join(logDir, "daemon.err.log")}</string>
+    <string>${import_path22.default.join(logDir, "daemon.err.log")}</string>
     <key>RunAtLoad</key>
     <true/>
     <key>KeepAlive</key>
@@ -4458,32 +4564,32 @@ async function enableDaemon() {
 </plist>`;
   try {
     await import_promises18.default.writeFile(plistPath, plistContent);
-    console.log(import_chalk20.default.dim(`Created plist at: ${plistPath}`));
+    console.log(import_chalk21.default.dim(`Created plist at: ${plistPath}`));
     try {
       await execShellCommand(`launchctl unload ${plistPath}`);
     } catch (e) {
     }
     await execShellCommand(`launchctl load ${plistPath}`);
-    console.log(import_chalk20.default.green("\u2705 Successfully enabled background daemon!"));
-    console.log(import_chalk20.default.dim(`Logs: ${logDir}`));
-    console.log(import_chalk20.default.dim("The daemon will now restart automatically if it crashes or on reboot."));
+    console.log(import_chalk21.default.green("\u2705 Successfully enabled background daemon!"));
+    console.log(import_chalk21.default.dim(`Logs: ${logDir}`));
+    console.log(import_chalk21.default.dim("The daemon will now restart automatically if it crashes or on reboot."));
   } catch (error) {
-    console.error(import_chalk20.default.red("\u274C Failed to enable daemon:"), error.message);
+    console.error(import_chalk21.default.red("\u274C Failed to enable daemon:"), error.message);
   }
 }
 async function disableDaemon() {
-  console.log(import_chalk20.default.bold("\n\u2699\uFE0F  Disabling Rigstate Background Service\n"));
+  console.log(import_chalk21.default.bold("\n\u2699\uFE0F  Disabling Rigstate Background Service\n"));
   const homeDir = process.env.HOME || "";
-  const plistPath = import_path21.default.join(homeDir, "Library/LaunchAgents/com.rigstate.daemon.plist");
+  const plistPath = import_path22.default.join(homeDir, "Library/LaunchAgents/com.rigstate.daemon.plist");
   try {
     await execShellCommand(`launchctl unload ${plistPath}`);
     await import_promises18.default.unlink(plistPath);
-    console.log(import_chalk20.default.green("\u2705 Successfully disabled background daemon."));
+    console.log(import_chalk21.default.green("\u2705 Successfully disabled background daemon."));
   } catch (error) {
     if (error.code === "ENOENT") {
-      console.log(import_chalk20.default.green("\u2705 Daemon was not enabled."));
+      console.log(import_chalk21.default.green("\u2705 Daemon was not enabled."));
     } else {
-      console.error(import_chalk20.default.red("\u274C Failed to disable daemon:"), error.message);
+      console.error(import_chalk21.default.red("\u274C Failed to disable daemon:"), error.message);
     }
   }
 }
@@ -4508,14 +4614,14 @@ function createDaemonCommand() {
     }
     const spinner = (0, import_ora8.default)();
     try {
-      const pidPath = import_path22.default.join(process.cwd(), PID_FILE);
+      const pidPath = import_path23.default.join(process.cwd(), PID_FILE);
       try {
         const content = await import_promises19.default.readFile(pidPath, "utf-8");
         const pid = parseInt(content.trim(), 10);
         try {
           process.kill(pid, 0);
-          console.log(import_chalk21.default.yellow("\u26A0 Another daemon instance is active (PID " + pid + ")."));
-          console.log(import_chalk21.default.dim(`   Run "rigstate daemon status" for details or Ctrl+C to stop.
+          console.log(import_chalk22.default.yellow("\u26A0 Another daemon instance is active (PID " + pid + ")."));
+          console.log(import_chalk22.default.dim(`   Run "rigstate daemon status" for details or Ctrl+C to stop.
 `));
         } catch {
           await import_promises19.default.unlink(pidPath).catch(() => {
@@ -4533,7 +4639,7 @@ function createDaemonCommand() {
       spinner.stop();
       await writePidFile();
       process.on("SIGINT", async () => {
-        console.log(import_chalk21.default.dim("\n\nShutting down..."));
+        console.log(import_chalk22.default.dim("\n\nShutting down..."));
         await daemonInstance.stop();
         await cleanupPidFile();
         process.exit(0);
@@ -4553,8 +4659,8 @@ function createDaemonCommand() {
       await new Promise(() => {
       });
     } catch (error) {
-      spinner.fail(import_chalk21.default.red("Failed to start daemon"));
-      console.error(import_chalk21.default.red("Error:"), error.message);
+      spinner.fail(import_chalk22.default.red("Failed to start daemon"));
+      console.error(import_chalk22.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
@@ -4562,7 +4668,7 @@ function createDaemonCommand() {
 }
 async function isRunning() {
   try {
-    const pidPath = import_path22.default.join(process.cwd(), PID_FILE);
+    const pidPath = import_path23.default.join(process.cwd(), PID_FILE);
     const content = await import_promises19.default.readFile(pidPath, "utf-8");
     const pid = parseInt(content.trim(), 10);
     try {
@@ -4578,57 +4684,57 @@ async function isRunning() {
 }
 async function writePidFile() {
   try {
-    const dir = import_path22.default.join(process.cwd(), ".rigstate");
+    const dir = import_path23.default.join(process.cwd(), ".rigstate");
     await import_promises19.default.mkdir(dir, { recursive: true });
-    await import_promises19.default.writeFile(import_path22.default.join(dir, "daemon.pid"), process.pid.toString());
+    await import_promises19.default.writeFile(import_path23.default.join(dir, "daemon.pid"), process.pid.toString());
   } catch {
   }
 }
 async function cleanupPidFile() {
   try {
-    await import_promises19.default.unlink(import_path22.default.join(process.cwd(), PID_FILE));
-    await import_promises19.default.unlink(import_path22.default.join(process.cwd(), STATE_FILE));
+    await import_promises19.default.unlink(import_path23.default.join(process.cwd(), PID_FILE));
+    await import_promises19.default.unlink(import_path23.default.join(process.cwd(), STATE_FILE));
   } catch {
   }
 }
 async function writeStateFile(state) {
   try {
-    const dir = import_path22.default.join(process.cwd(), ".rigstate");
+    const dir = import_path23.default.join(process.cwd(), ".rigstate");
     await import_promises19.default.mkdir(dir, { recursive: true });
     await import_promises19.default.writeFile(
-      import_path22.default.join(dir, "daemon.state.json"),
+      import_path23.default.join(dir, "daemon.state.json"),
       JSON.stringify(state, null, 2)
     );
   } catch {
   }
 }
 async function showStatus() {
-  console.log(import_chalk21.default.bold("\n\u{1F6E1}\uFE0F  Guardian Daemon Status\n"));
+  console.log(import_chalk22.default.bold("\n\u{1F6E1}\uFE0F  Guardian Daemon Status\n"));
   const running = await isRunning();
   if (!running) {
-    console.log(import_chalk21.default.yellow("Status: Not running"));
-    console.log(import_chalk21.default.dim('Use "rigstate daemon" to start.\n'));
+    console.log(import_chalk22.default.yellow("Status: Not running"));
+    console.log(import_chalk22.default.dim('Use "rigstate daemon" to start.\n'));
     return;
   }
-  console.log(import_chalk21.default.green("Status: Running"));
+  console.log(import_chalk22.default.green("Status: Running"));
   try {
-    const statePath = import_path22.default.join(process.cwd(), STATE_FILE);
+    const statePath = import_path23.default.join(process.cwd(), STATE_FILE);
     const content = await import_promises19.default.readFile(statePath, "utf-8");
     const state = JSON.parse(content);
-    console.log(import_chalk21.default.dim("\u2500".repeat(40)));
+    console.log(import_chalk22.default.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(import_chalk21.default.dim("\u2500".repeat(40)));
+    console.log(import_chalk22.default.dim("\u2500".repeat(40)));
   } catch {
-    console.log(import_chalk21.default.dim("(State file not found)"));
+    console.log(import_chalk22.default.dim("(State file not found)"));
   }
   try {
-    const pidPath = import_path22.default.join(process.cwd(), PID_FILE);
+    const pidPath = import_path23.default.join(process.cwd(), PID_FILE);
     const pid = await import_promises19.default.readFile(pidPath, "utf-8");
-    console.log(import_chalk21.default.dim(`PID: ${pid.trim()}`));
+    console.log(import_chalk22.default.dim(`PID: ${pid.trim()}`));
   } catch {
   }
   console.log("");
@@ -4637,7 +4743,7 @@ async function showStatus() {
 // src/commands/work.ts
 init_cjs_shims();
 var import_commander13 = require("commander");
-var import_chalk23 = __toESM(require("chalk"), 1);
+var import_chalk24 = __toESM(require("chalk"), 1);
 var import_ora10 = __toESM(require("ora"), 1);
 var import_axios17 = __toESM(require("axios"), 1);
 var import_inquirer3 = __toESM(require("inquirer"), 1);
@@ -4647,11 +4753,11 @@ init_suggest();
 // src/commands/plan.ts
 init_cjs_shims();
 var import_commander12 = require("commander");
-var import_chalk22 = __toESM(require("chalk"), 1);
+var import_chalk23 = __toESM(require("chalk"), 1);
 var import_ora9 = __toESM(require("ora"), 1);
 var import_axios16 = __toESM(require("axios"), 1);
 var import_promises20 = __toESM(require("fs/promises"), 1);
-var import_path23 = __toESM(require("path"), 1);
+var import_path24 = __toESM(require("path"), 1);
 var import_inquirer2 = __toESM(require("inquirer"), 1);
 init_config();
 function createPlanCommand() {
@@ -4710,7 +4816,7 @@ async function executePlan(taskId) {
       taskDescription = task.description;
     }
     spinner.start("Generating Context for Frank...");
-    const contextPath = import_path23.default.join(process.cwd(), ".rigstate", "CURRENT_CONTEXT.md");
+    const contextPath = import_path24.default.join(process.cwd(), ".rigstate", "CURRENT_CONTEXT.md");
     const contextContent = `
 # \u{1F3AF} Active Mission: ${taskTitle}
 **ID:** ${taskId}
@@ -4725,9 +4831,9 @@ ${taskDescription}
 
 *Generated by Rigstate CLI at ${(/* @__PURE__ */ new Date()).toLocaleString()}*
 `;
-    await import_promises20.default.mkdir(import_path23.default.dirname(contextPath), { recursive: true });
+    await import_promises20.default.mkdir(import_path24.default.dirname(contextPath), { recursive: true });
     await import_promises20.default.writeFile(contextPath, contextContent.trim());
-    const planPath = import_path23.default.join(process.cwd(), "IMPLEMENTATION_PLAN.md");
+    const planPath = import_path24.default.join(process.cwd(), "IMPLEMENTATION_PLAN.md");
     const planExists = await import_promises20.default.stat(planPath).then(() => true).catch(() => false);
     if (!planExists) {
       const planTemplate = `
@@ -4748,22 +4854,37 @@ ${taskDescription}
 [Frank: Log your progress here]
 `;
       await import_promises20.default.writeFile(planPath, planTemplate.trim());
-      spinner.succeed(import_chalk22.default.green("Created new IMPLEMENTATION_PLAN.md"));
+      spinner.succeed(import_chalk23.default.green("Created new IMPLEMENTATION_PLAN.md"));
     } else {
-      spinner.info(import_chalk22.default.yellow("IMPLEMENTATION_PLAN.md already exists. Preserving it."));
+      spinner.info(import_chalk23.default.yellow("IMPLEMENTATION_PLAN.md already exists. Preserving it."));
+    }
+    try {
+      spinner.start("\u{1F4E1} Signaling Frank to start drafting...");
+      await import_axios16.default.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(import_chalk23.default.dim("Agent Bridge signal skipped (non-critical)."));
     }
     console.log("");
-    console.log(import_chalk22.default.bold.blue("\u{1F680} Planning Mode Activated"));
-    console.log(import_chalk22.default.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: ${import_chalk22.default.bold(".rigstate/CURRENT_CONTEXT.md")}`);
-    console.log(`2. Plan template ready: ${import_chalk22.default.bold("IMPLEMENTATION_PLAN.md")}`);
+    console.log(import_chalk23.default.bold.blue("\u{1F680} Planning Mode Activated"));
+    console.log(import_chalk23.default.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: ${import_chalk23.default.bold(".rigstate/CURRENT_CONTEXT.md")}`);
+    console.log(`2. Plan template ready: ${import_chalk23.default.bold("IMPLEMENTATION_PLAN.md")}`);
     console.log("");
-    console.log(import_chalk22.default.yellow("\u{1F449} NEXT STEP:"));
-    console.log(`   Open ${import_chalk22.default.bold("IMPLEMENTATION_PLAN.md")} in your IDE.`);
-    console.log(`   Tell Frank: ${import_chalk22.default.italic('"Read the context and draft the plan."')}`);
+    console.log(import_chalk23.default.green("\u2728 FRANK IS ON IT!"));
+    console.log(import_chalk23.default.dim("   He has received the bridge signal and will begin drafting shortly."));
+    console.log(import_chalk23.default.dim("   No further manual steps required once he wakes up."));
     console.log("");
   } catch (e) {
-    spinner.fail(import_chalk22.default.red(`Planning failed: ${e.message}`));
+    spinner.fail(import_chalk23.default.red(`Planning failed: ${e.message}`));
   }
 }
 function getContext() {
@@ -4808,7 +4929,7 @@ async function listInteractive() {
     });
     spinner.stop();
     if (actionableTasks.length === 0) {
-      console.log(import_chalk23.default.yellow("Roadmap clear. No actionable tasks found."));
+      console.log(import_chalk24.default.yellow("Roadmap clear. No actionable tasks found."));
       return;
     }
     const choices = actionableTasks.map((t) => {
@@ -4817,7 +4938,7 @@ async function listInteractive() {
       if (t.status === "IN_PROGRESS") icon = "\u{1F525}";
       if (t.status === "ACTIVE") icon = "\u25B6\uFE0F";
       return {
-        name: `${icon}  ${import_chalk23.default.bold(id)}: ${t.title} [${t.status}]`,
+        name: `${icon}  ${import_chalk24.default.bold(id)}: ${t.title} [${t.status}]`,
         value: t.id
       };
     });
@@ -4864,25 +4985,25 @@ async function setTaskStatus(taskId, status) {
       { step_id: realId, status, project_id: projectId },
       { headers: { "Authorization": `Bearer ${apiKey}` } }
     );
-    spinner.succeed(import_chalk23.default.green(`Task updated to ${status}.`));
+    spinner.succeed(import_chalk24.default.green(`Task updated to ${status}.`));
     if (status === "IN_PROGRESS") {
-      console.log(import_chalk23.default.blue(`
+      console.log(import_chalk24.default.blue(`
 \u{1F4A1} Tip: Provide 'Frank' with context by mentioning @.cursorrules in your chat.`));
     }
   } catch (e) {
-    spinner.fail(import_chalk23.default.red(`Failed: ${e.message}`));
+    spinner.fail(import_chalk24.default.red(`Failed: ${e.message}`));
   }
 }
 async function finishTask(taskId) {
   console.log("");
-  console.log(import_chalk23.default.bold.yellow("\u{1F6E1}\uFE0F  FRANK'S QUALITY GATE"));
-  console.log(import_chalk23.default.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(import_chalk24.default.bold.yellow("\u{1F6E1}\uFE0F  FRANK'S QUALITY GATE"));
+  console.log(import_chalk24.default.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 = (0, import_ora10.default)(" 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(import_chalk23.default.bold.green("\u{1F389} TASK COMPLETE! Momentum Preserved."));
+  console.log(import_chalk24.default.bold.green("\u{1F389} TASK COMPLETE! Momentum Preserved."));
   const { projectId, apiKey, apiUrl } = getContext2();
   await suggestNextMove(projectId, apiKey, apiUrl);
 }
@@ -4899,40 +5020,36 @@ function getContext2() {
 // src/commands/watch.ts
 init_cjs_shims();
 var import_commander14 = require("commander");
-var import_chalk24 = __toESM(require("chalk"), 1);
+var import_chalk25 = __toESM(require("chalk"), 1);
 var import_ora11 = __toESM(require("ora"), 1);
 var import_chokidar2 = __toESM(require("chokidar"), 1);
 var import_promises21 = __toESM(require("fs/promises"), 1);
-var import_path24 = __toESM(require("path"), 1);
+var import_path25 = __toESM(require("path"), 1);
 var import_child_process4 = require("child_process");
 init_config();
 var import_axios18 = __toESM(require("axios"), 1);
 function createWatchCommand() {
   const watch2 = new import_commander14.Command("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(import_chalk24.default.bold.blue("\u{1F52D} Rigstate Watch Mode"));
-    console.log(import_chalk24.default.dim("Monitoring for task completion..."));
+    console.log(import_chalk25.default.bold.blue("\u{1F52D} Rigstate Watch Mode"));
+    console.log(import_chalk25.default.dim("Monitoring for task completion..."));
     console.log("");
     let apiKey;
     let projectId;
     try {
       apiKey = getApiKey();
     } catch (e) {
-      console.log(import_chalk24.default.red('Not authenticated. Run "rigstate login" first.'));
+      console.log(import_chalk25.default.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
-      try {
-        const manifestPath = import_path24.default.join(process.cwd(), ".rigstate");
-        const content = await import_promises21.default.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(import_chalk24.default.red('No project context. Run "rigstate link" or "rigstate sync --project <id>" first.'));
+      console.log(import_chalk25.default.red('No project context. Run "rigstate link" or "rigstate sync --project <id>" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -4942,8 +5059,8 @@ function createWatchCommand() {
       runTests: options.runTests || false,
       testCommand: options.testCommand || "npm test"
     };
-    console.log(import_chalk24.default.dim(`Auto-commit: ${config2.autoCommit ? "ON" : "OFF"}`));
-    console.log(import_chalk24.default.dim(`Auto-push: ${config2.autoPush ? "ON" : "OFF"}`));
+    console.log(import_chalk25.default.dim(`Auto-commit: ${config2.autoCommit ? "ON" : "OFF"}`));
+    console.log(import_chalk25.default.dim(`Auto-push: ${config2.autoPush ? "ON" : "OFF"}`));
     console.log("");
     const fetchActiveTask = async () => {
       try {
@@ -4971,7 +5088,7 @@ function createWatchCommand() {
     };
     const checkCriteria = async (criteria) => {
       try {
-        const fullPath = import_path24.default.resolve(process.cwd(), criteria.path);
+        const fullPath = import_path25.default.resolve(process.cwd(), criteria.path);
         switch (criteria.type) {
           case "file_exists":
             await import_promises21.default.access(fullPath);
@@ -5010,7 +5127,7 @@ function createWatchCommand() {
         }, {
           headers: { Authorization: `Bearer ${apiKey}` }
         });
-        spinner.succeed(import_chalk24.default.green(`\u2705 Task #${task.step_number} completed: ${task.title}`));
+        spinner.succeed(import_chalk25.default.green(`\u2705 Task #${task.step_number} completed: ${task.title}`));
         if (config2.autoCommit) {
           spinner.start("Committing changes...");
           try {
@@ -5032,7 +5149,7 @@ function createWatchCommand() {
           }
         }
         console.log("");
-        console.log(import_chalk24.default.blue("Watching for next task..."));
+        console.log(import_chalk25.default.blue("Watching for next task..."));
       } catch (e) {
         spinner.fail(`Failed to complete task: ${e.message}`);
       }
@@ -5045,7 +5162,7 @@ function createWatchCommand() {
       const task = await fetchActiveTask();
       if (!task) {
         if (currentTask) {
-          console.log(import_chalk24.default.green("\u{1F389} All tasks completed! Watching for new tasks..."));
+          console.log(import_chalk25.default.green("\u{1F389} All tasks completed! Watching for new tasks..."));
           currentTask = null;
         }
         isProcessing = false;
@@ -5054,10 +5171,10 @@ function createWatchCommand() {
       if (!currentTask || currentTask.id !== task.id) {
         currentTask = task;
         console.log("");
-        console.log(import_chalk24.default.bold.yellow(`\u{1F4CC} Active Task #${task.step_number}: ${task.title}`));
-        console.log(import_chalk24.default.dim(`Status: ${task.status}`));
+        console.log(import_chalk25.default.bold.yellow(`\u{1F4CC} Active Task #${task.step_number}: ${task.title}`));
+        console.log(import_chalk25.default.dim(`Status: ${task.status}`));
         if (task.verification_criteria) {
-          console.log(import_chalk24.default.dim("Verification: Auto-checking criteria..."));
+          console.log(import_chalk25.default.dim("Verification: Auto-checking criteria..."));
         }
       }
       if (task.verification_criteria && Array.isArray(task.verification_criteria)) {
@@ -5070,7 +5187,7 @@ function createWatchCommand() {
           }
         }
         if (allPassed) {
-          console.log(import_chalk24.default.green("\u2713 All verification criteria passed!"));
+          console.log(import_chalk25.default.green("\u2713 All verification criteria passed!"));
           await completeTask(task.id, task);
           currentTask = null;
         }
@@ -5095,11 +5212,11 @@ function createWatchCommand() {
         setTimeout(() => processActiveTask(), 500);
       }
     });
-    console.log(import_chalk24.default.dim("Watching for file changes... (Ctrl+C to exit)"));
+    console.log(import_chalk25.default.dim("Watching for file changes... (Ctrl+C to exit)"));
     setInterval(() => processActiveTask(), 3e4);
     process.on("SIGINT", () => {
       console.log("");
-      console.log(import_chalk24.default.dim("Watch mode stopped."));
+      console.log(import_chalk25.default.dim("Watch mode stopped."));
       watcher.close();
       process.exit(0);
     });
@@ -5110,13 +5227,11 @@ function createWatchCommand() {
 // src/commands/focus.ts
 init_cjs_shims();
 var import_commander15 = require("commander");
-var import_chalk25 = __toESM(require("chalk"), 1);
+var import_chalk26 = __toESM(require("chalk"), 1);
 var import_ora12 = __toESM(require("ora"), 1);
 init_config();
 var import_axios19 = __toESM(require("axios"), 1);
 var import_child_process5 = require("child_process");
-var import_promises22 = __toESM(require("fs/promises"), 1);
-var import_path25 = __toESM(require("path"), 1);
 function createFocusCommand() {
   const focus = new import_commander15.Command("focus");
   focus.alias("task").description("Get the next active roadmap task and copy its prompt to clipboard").option("--no-copy", "Do not copy to clipboard").action(async (options) => {
@@ -5126,21 +5241,17 @@ function createFocusCommand() {
     try {
       apiKey = getApiKey();
     } catch (e) {
-      spinner.fail(import_chalk25.default.red('Not authenticated. Run "rigstate login" first.'));
+      spinner.fail(import_chalk26.default.red('Not authenticated. Run "rigstate login" first.'));
       return;
     }
     projectId = getProjectId();
     if (!projectId) {
-      try {
-        const manifestPath = import_path25.default.join(process.cwd(), ".rigstate");
-        const content = await import_promises22.default.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(import_chalk25.default.red('No project context. Run "rigstate link" first.'));
+      spinner.fail(import_chalk26.default.red('No project context. Run "rigstate link" first.'));
       return;
     }
     const apiUrl = getApiUrl();
@@ -5171,41 +5282,41 @@ function createFocusCommand() {
       const nextTask = activeTasks[0];
       spinner.stop();
       console.log("");
-      console.log(import_chalk25.default.bold.blue(`\u{1F4CC} Task #${nextTask.step_number || "?"}: ${nextTask.title}`));
-      const statusColor = nextTask.status === "IN_PROGRESS" ? import_chalk25.default.yellow : nextTask.status === "ACTIVE" ? import_chalk25.default.green : import_chalk25.default.dim;
-      console.log(import_chalk25.default.dim("Status: ") + statusColor(nextTask.status));
-      console.log(import_chalk25.default.dim("\u2500".repeat(60)));
+      console.log(import_chalk26.default.bold.blue(`\u{1F4CC} Task #${nextTask.step_number || "?"}: ${nextTask.title}`));
+      const statusColor = nextTask.status === "IN_PROGRESS" ? import_chalk26.default.yellow : nextTask.status === "ACTIVE" ? import_chalk26.default.green : import_chalk26.default.dim;
+      console.log(import_chalk26.default.dim("Status: ") + statusColor(nextTask.status));
+      console.log(import_chalk26.default.dim("\u2500".repeat(60)));
       if (nextTask.prompt_content) {
-        console.log(import_chalk25.default.white(nextTask.prompt_content));
-        console.log(import_chalk25.default.dim("\u2500".repeat(60)));
+        console.log(import_chalk26.default.white(nextTask.prompt_content));
+        console.log(import_chalk26.default.dim("\u2500".repeat(60)));
         if (options.copy !== false) {
           try {
             if (process.platform === "darwin") {
               (0, import_child_process5.execSync)("pbcopy", { input: nextTask.prompt_content });
-              console.log(import_chalk25.default.green("\u2705 Prompt copied to clipboard! Ready to paste (Cmd+V)."));
+              console.log(import_chalk26.default.green("\u2705 Prompt copied to clipboard! Ready to paste (Cmd+V)."));
             } else if (process.platform === "linux") {
               try {
                 (0, import_child_process5.execSync)("xclip -selection clipboard", { input: nextTask.prompt_content });
-                console.log(import_chalk25.default.green("\u2705 Prompt copied to clipboard!"));
+                console.log(import_chalk26.default.green("\u2705 Prompt copied to clipboard!"));
               } catch (e) {
-                console.log(import_chalk25.default.yellow("\u2139\uFE0F  Copy prompt manually (xclip not available)"));
+                console.log(import_chalk26.default.yellow("\u2139\uFE0F  Copy prompt manually (xclip not available)"));
               }
             } else {
-              console.log(import_chalk25.default.yellow("\u2139\uFE0F  Copy prompt manually (Auto-copy not supported on this OS)"));
+              console.log(import_chalk26.default.yellow("\u2139\uFE0F  Copy prompt manually (Auto-copy not supported on this OS)"));
             }
           } catch (e) {
           }
         }
       } else {
-        console.log(import_chalk25.default.yellow("No prompt instructions available."));
+        console.log(import_chalk26.default.yellow("No prompt instructions available."));
         if (nextTask.architectural_brief) {
-          console.log(import_chalk25.default.bold("Brief:"));
+          console.log(import_chalk26.default.bold("Brief:"));
           console.log(nextTask.architectural_brief);
         }
       }
       console.log("");
     } catch (e) {
-      spinner.fail(import_chalk25.default.red(`Failed to fetch task: ${e.message}`));
+      spinner.fail(import_chalk26.default.red(`Failed to fetch task: ${e.message}`));
     }
   });
   return focus;
@@ -5217,26 +5328,26 @@ init_env();
 // src/commands/config.ts
 init_cjs_shims();
 var import_commander16 = require("commander");
-var import_chalk26 = __toESM(require("chalk"), 1);
+var import_chalk27 = __toESM(require("chalk"), 1);
 init_config();
 function createConfigCommand() {
   const config2 = new import_commander16.Command("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(import_chalk26.default.bold("Rigstate Configuration"));
-      console.log(import_chalk26.default.dim("\u2500".repeat(40)));
+      console.log(import_chalk27.default.bold("Rigstate Configuration"));
+      console.log(import_chalk27.default.dim("\u2500".repeat(40)));
       try {
         const apiKey = getApiKey();
-        console.log(`${import_chalk26.default.cyan("api_key")}: ${apiKey.substring(0, 20)}...`);
+        console.log(`${import_chalk27.default.cyan("api_key")}: ${apiKey.substring(0, 20)}...`);
       } catch (e) {
-        console.log(`${import_chalk26.default.cyan("api_key")}: ${import_chalk26.default.dim("(not set)")}`);
+        console.log(`${import_chalk27.default.cyan("api_key")}: ${import_chalk27.default.dim("(not set)")}`);
       }
       const projectId = getProjectId();
-      console.log(`${import_chalk26.default.cyan("project_id")}: ${projectId || import_chalk26.default.dim("(not set)")}`);
+      console.log(`${import_chalk27.default.cyan("project_id")}: ${projectId || import_chalk27.default.dim("(not set)")}`);
       const apiUrl = getApiUrl();
-      console.log(`${import_chalk26.default.cyan("api_url")}: ${apiUrl}`);
+      console.log(`${import_chalk27.default.cyan("api_url")}: ${apiUrl}`);
       console.log("");
-      console.log(import_chalk26.default.dim('Use "rigstate config <key> <value>" to set a value.'));
+      console.log(import_chalk27.default.dim('Use "rigstate config <key> <value>" to set a value.'));
       return;
     }
     if (!value) {
@@ -5246,37 +5357,37 @@ function createConfigCommand() {
             const apiKey = getApiKey();
             console.log(apiKey);
           } catch (e) {
-            console.log(import_chalk26.default.dim("(not set)"));
+            console.log(import_chalk27.default.dim("(not set)"));
           }
           break;
         case "project_id":
-          console.log(getProjectId() || import_chalk26.default.dim("(not set)"));
+          console.log(getProjectId() || import_chalk27.default.dim("(not set)"));
           break;
         case "api_url":
           console.log(getApiUrl());
           break;
         default:
-          console.log(import_chalk26.default.red(`Unknown config key: ${key}`));
-          console.log(import_chalk26.default.dim("Valid keys: api_key, project_id, api_url"));
+          console.log(import_chalk27.default.red(`Unknown config key: ${key}`));
+          console.log(import_chalk27.default.dim("Valid keys: api_key, project_id, api_url"));
       }
       return;
     }
     switch (key) {
       case "api_key":
         setApiKey(value);
-        console.log(import_chalk26.default.green(`\u2705 api_key updated`));
+        console.log(import_chalk27.default.green(`\u2705 api_key updated`));
         break;
       case "project_id":
         setProjectId(value);
-        console.log(import_chalk26.default.green(`\u2705 project_id updated`));
+        console.log(import_chalk27.default.green(`\u2705 project_id updated`));
         break;
       case "api_url":
         setApiUrl(value);
-        console.log(import_chalk26.default.green(`\u2705 api_url updated`));
+        console.log(import_chalk27.default.green(`\u2705 api_url updated`));
         break;
       default:
-        console.log(import_chalk26.default.red(`Unknown config key: ${key}`));
-        console.log(import_chalk26.default.dim("Valid keys: api_key, project_id, api_url"));
+        console.log(import_chalk27.default.red(`Unknown config key: ${key}`));
+        console.log(import_chalk27.default.dim("Valid keys: api_key, project_id, api_url"));
     }
   });
   return config2;
@@ -5285,10 +5396,10 @@ function createConfigCommand() {
 // src/commands/mcp.ts
 init_cjs_shims();
 var import_commander17 = require("commander");
-var import_chalk27 = __toESM(require("chalk"), 1);
+var import_chalk28 = __toESM(require("chalk"), 1);
 var import_child_process6 = require("child_process");
 var import_path26 = __toESM(require("path"), 1);
-var import_fs = __toESM(require("fs"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
 var import_url2 = require("url");
 init_config();
 var __filename2 = (0, import_url2.fileURLToPath)(importMetaUrl);
@@ -5306,21 +5417,21 @@ function createMcpCommand() {
     ];
     let serverPath = "";
     for (const p of possiblePaths) {
-      if (import_fs.default.existsSync(p)) {
+      if (import_fs3.default.existsSync(p)) {
         serverPath = p;
         break;
       }
     }
     if (!serverPath) {
-      console.error(import_chalk27.default.red("\u274C Error: Rigstate MCP Server binary not found."));
-      console.error(import_chalk27.default.yellow("Please ensure that the mcp package is built:"));
-      console.error(import_chalk27.default.white("   cd packages/mcp && npm run build"));
+      console.error(import_chalk28.default.red("\u274C Error: Rigstate MCP Server binary not found."));
+      console.error(import_chalk28.default.yellow("Please ensure that the mcp package is built:"));
+      console.error(import_chalk28.default.white("   cd packages/mcp && npm run build"));
       console.error("");
-      console.error(import_chalk27.default.dim("Or run directly with:"));
-      console.error(import_chalk27.default.white("   npx @rigstate/mcp"));
+      console.error(import_chalk28.default.dim("Or run directly with:"));
+      console.error(import_chalk28.default.white("   npx @rigstate/mcp"));
       process.exit(1);
     }
-    console.log(import_chalk27.default.dim(`Starting MCP server from: ${serverPath}`));
+    console.log(import_chalk28.default.dim(`Starting MCP server from: ${serverPath}`));
     const env = { ...process.env };
     try {
       const apiKey = getApiKey();
@@ -5339,7 +5450,7 @@ function createMcpCommand() {
       stdio: ["inherit", "inherit", "inherit"]
     });
     worker.on("error", (err) => {
-      console.error(import_chalk27.default.red(`\u274C Failed to start MCP server: ${err.message}`));
+      console.error(import_chalk28.default.red(`\u274C Failed to start MCP server: ${err.message}`));
       process.exit(1);
     });
     worker.on("exit", (code) => {
@@ -5354,7 +5465,7 @@ function createMcpCommand() {
 // src/commands/nexus.ts
 init_cjs_shims();
 var import_commander18 = require("commander");
-var import_chalk29 = __toESM(require("chalk"), 1);
+var import_chalk30 = __toESM(require("chalk"), 1);
 
 // src/nexus/dispatcher.ts
 init_cjs_shims();
@@ -5422,7 +5533,7 @@ var HiveScrubber = class {
 };
 
 // src/hive/gateway.ts
-var import_chalk28 = __toESM(require("chalk"), 1);
+var import_chalk29 = __toESM(require("chalk"), 1);
 var HiveGateway = class {
   client;
   enabled;
@@ -5432,7 +5543,7 @@ var HiveGateway = class {
   constructor(baseUrl, token) {
     this.enabled = !!token;
     if (!this.enabled) {
-      console.log(import_chalk28.default.dim("\u26A0\uFE0F Hive Gateway disabled (No Token provided). Running in localized mode."));
+      console.log(import_chalk29.default.dim("\u26A0\uFE0F Hive Gateway disabled (No Token provided). Running in localized mode."));
     }
     this.client = import_axios20.default.create({
       baseURL: baseUrl,
@@ -5452,23 +5563,23 @@ var HiveGateway = class {
     if (!this.enabled) return false;
     const now = Date.now();
     if (now - this.lastSignalTime < this.MIN_INTERVAL_MS) {
-      console.warn(import_chalk28.default.yellow("\u23F3 Hive Gateway Throttled. Signal dropped to preventing spam."));
+      console.warn(import_chalk29.default.yellow("\u23F3 Hive Gateway Throttled. Signal dropped to preventing spam."));
       return false;
     }
     const scrubResult = HiveScrubber.scrub(signal.ruleContent);
     if (scrubResult.riskScore > 20) {
-      console.error(import_chalk28.default.red(`\u{1F6D1} HIVE BLOCKED: Signal contains sensitive data (Risk: ${scrubResult.riskScore})`));
+      console.error(import_chalk29.default.red(`\u{1F6D1} HIVE BLOCKED: Signal contains sensitive data (Risk: ${scrubResult.riskScore})`));
       return false;
     }
     try {
-      console.log(import_chalk28.default.blue(`\u{1F4E1} Uplinking to Hive... [${signal.vector}]`));
+      console.log(import_chalk29.default.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(import_chalk28.default.green("\u2705 Signal Received by Hive Core. Knowledge Shared."));
+      console.log(import_chalk29.default.green("\u2705 Signal Received by Hive Core. Knowledge Shared."));
       return true;
     } catch (error) {
-      console.error(import_chalk28.default.red(`\u274C Hive Transmission Failed: ${error.message}`));
+      console.error(import_chalk29.default.red(`\u274C Hive Transmission Failed: ${error.message}`));
       return false;
     }
   }
@@ -5570,10 +5681,10 @@ var import_inquirer4 = __toESM(require("inquirer"), 1);
 function createNexusCommand() {
   const command = new import_commander18.Command("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(import_chalk29.default.bold.magenta("\n\u{1F981} Welcome to The Nexus (Phase 8)\n"));
+    console.log(import_chalk30.default.bold.magenta("\n\u{1F981} Welcome to The Nexus (Phase 8)\n"));
     const dryRun = !options.force;
     if (!dryRun) {
-      console.log(import_chalk29.default.black.bgYellow(" WARNING ") + import_chalk29.default.yellow(" Dry-Run disabled! Eitri is authorized to write code."));
+      console.log(import_chalk30.default.black.bgYellow(" WARNING ") + import_chalk30.default.yellow(" Dry-Run disabled! Eitri is authorized to write code."));
       const { confirm } = await import_inquirer4.default.prompt([{
         type: "confirm",
         name: "confirm",
@@ -5594,26 +5705,26 @@ function createNexusCommand() {
     };
     const dispatcher = new NexusDispatcher(context);
     dispatcher.on("order:created", (o) => {
-      console.log(import_chalk29.default.blue(`\u{1F195} [${o.id.slice(0, 6)}] Order Created: `) + o.intent);
+      console.log(import_chalk30.default.blue(`\u{1F195} [${o.id.slice(0, 6)}] Order Created: `) + o.intent);
     });
     dispatcher.on("order:started", (o) => {
-      console.log(import_chalk29.default.yellow(`\u23F3 [${o.id.slice(0, 6)}] Processing...`));
+      console.log(import_chalk30.default.yellow(`\u23F3 [${o.id.slice(0, 6)}] Processing...`));
     });
     dispatcher.on("order:blocked", (o) => {
-      console.log(import_chalk29.default.red(`\u{1F6D1} [${o.id.slice(0, 6)}] BLOCKED by Kill-Switch`));
-      console.log(import_chalk29.default.dim(`   Target: ${o.targetAgent} | Action: ${o.action}`));
-      console.log(import_chalk29.default.dim("   Run with --force to execute automatically (NOT RECOMMENDED)."));
+      console.log(import_chalk30.default.red(`\u{1F6D1} [${o.id.slice(0, 6)}] BLOCKED by Kill-Switch`));
+      console.log(import_chalk30.default.dim(`   Target: ${o.targetAgent} | Action: ${o.action}`));
+      console.log(import_chalk30.default.dim("   Run with --force to execute automatically (NOT RECOMMENDED)."));
     });
-    dispatcher.on("agent:SINDRE", (o) => console.log(import_chalk29.default.cyan(`\u{1F916} Sindre (Vault): I'm on it! (${o.action})`)));
-    dispatcher.on("agent:EITRI", (o) => console.log(import_chalk29.default.green(`\u{1F477} Eitri (Smith): Ready to build! (${o.action})`)));
-    console.log(import_chalk29.default.dim("\u{1F9E0} Frank is analyzing your intent..."));
+    dispatcher.on("agent:SINDRE", (o) => console.log(import_chalk30.default.cyan(`\u{1F916} Sindre (Vault): I'm on it! (${o.action})`)));
+    dispatcher.on("agent:EITRI", (o) => console.log(import_chalk30.default.green(`\u{1F477} Eitri (Smith): Ready to build! (${o.action})`)));
+    console.log(import_chalk30.default.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(import_chalk29.default.gray("Frank didn't understand. Try 'create file' or 'check database'."));
+      console.log(import_chalk30.default.gray("Frank didn't understand. Try 'create file' or 'check database'."));
     }
   });
   return command;
@@ -5625,7 +5736,7 @@ init_sync_rules();
 // src/commands/override.ts
 init_cjs_shims();
 var import_commander19 = require("commander");
-var import_chalk30 = __toESM(require("chalk"), 1);
+var import_chalk31 = __toESM(require("chalk"), 1);
 init_governance();
 init_config();
 var import_axios21 = __toESM(require("axios"), 1);
@@ -5633,19 +5744,19 @@ function createOverrideCommand() {
   const override = new import_commander19.Command("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(import_chalk30.default.bold(`
+    console.log(import_chalk31.default.bold(`
 \u{1F513} Initiating Governance Override Protocol...`));
     const session = await getSessionState(process.cwd());
     if (session.status !== "SOFT_LOCK") {
-      console.log(import_chalk30.default.yellow("   Info: Session is not currently locked."));
+      console.log(import_chalk31.default.yellow("   Info: Session is not currently locked."));
       return;
     }
-    console.log(import_chalk30.default.dim(`   Active Violation: ${session.active_violation}`));
-    console.log(import_chalk30.default.dim(`   Reason Provided:  "${reason}"`));
+    console.log(import_chalk31.default.dim(`   Active Violation: ${session.active_violation}`));
+    console.log(import_chalk31.default.dim(`   Reason Provided:  "${reason}"`));
     const success = await performOverride(violationId, reason, process.cwd());
     if (success) {
-      console.log(import_chalk30.default.green(`   \u2705 Session UNLOCKED.`));
-      console.log(import_chalk30.default.dim(`   This event has been logged to the Mission Report.`));
+      console.log(import_chalk31.default.green(`   \u2705 Session UNLOCKED.`));
+      console.log(import_chalk31.default.dim(`   This event has been logged to the Mission Report.`));
       try {
         const projectId = getProjectId();
         if (projectId) {
@@ -5662,13 +5773,13 @@ function createOverrideCommand() {
           }, {
             headers: { Authorization: `Bearer ${apiKey}` }
           });
-          console.log(import_chalk30.default.dim(`   \u2601 Audit log synced to Cloud.`));
+          console.log(import_chalk31.default.dim(`   \u2601 Audit log synced to Cloud.`));
         }
       } catch (e) {
-        console.log(import_chalk30.default.dim(`   (Cloud audit sync failed: ${e.message})`));
+        console.log(import_chalk31.default.dim(`   (Cloud audit sync failed: ${e.message})`));
       }
     } else {
-      console.log(import_chalk30.default.red(`   \u{1F6D1} Override Failed. Check project configuration.`));
+      console.log(import_chalk31.default.red(`   \u{1F6D1} Override Failed. Check project configuration.`));
     }
   });
   return override;
@@ -5677,7 +5788,7 @@ function createOverrideCommand() {
 // src/commands/idea.ts
 init_cjs_shims();
 var import_commander20 = require("commander");
-var import_chalk31 = __toESM(require("chalk"), 1);
+var import_chalk32 = __toESM(require("chalk"), 1);
 var import_ora13 = __toESM(require("ora"), 1);
 var import_axios22 = __toESM(require("axios"), 1);
 var import_inquirer5 = __toESM(require("inquirer"), 1);
@@ -5689,7 +5800,7 @@ function createIdeaCommand() {
       const apiUrl = getApiUrl();
       const projectId = getProjectId();
       if (!projectId) {
-        console.error(import_chalk31.default.red("Project context missing. Run rigstate link."));
+        console.error(import_chalk32.default.red("Project context missing. Run rigstate link."));
         process.exit(1);
       }
       let ideaTitle = title;
@@ -5725,14 +5836,14 @@ function createIdeaCommand() {
         { headers: { Authorization: `Bearer ${apiKey}` } }
       );
       if (response.data.success) {
-        spinner.succeed(import_chalk31.default.green("Idea Captured! \u{1F4A1}"));
-        console.log(import_chalk31.default.dim(`ID: ${response.data.data?.id || "Saved"}`));
+        spinner.succeed(import_chalk32.default.green("Idea Captured! \u{1F4A1}"));
+        console.log(import_chalk32.default.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(import_chalk31.default.red(`
+      console.error(import_chalk32.default.red(`
 Failed to capture idea: ${errorDetail}`));
     }
   });
@@ -5741,10 +5852,10 @@ Failed to capture idea: ${errorDetail}`));
 // src/commands/release.ts
 init_cjs_shims();
 var import_commander21 = require("commander");
-var import_chalk32 = __toESM(require("chalk"), 1);
+var import_chalk33 = __toESM(require("chalk"), 1);
 var import_ora14 = __toESM(require("ora"), 1);
 var import_inquirer6 = __toESM(require("inquirer"), 1);
-var import_promises23 = __toESM(require("fs/promises"), 1);
+var import_promises22 = __toESM(require("fs/promises"), 1);
 var import_path27 = __toESM(require("path"), 1);
 init_config();
 
@@ -8616,7 +8727,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();
@@ -8664,7 +8775,7 @@ var init_simple_git_api = __esm2({
     init_show();
     init_status();
     init_task();
-    init_version();
+    init_version2();
     init_utils();
     SimpleGitApi = class {
       constructor(_executor) {
@@ -10310,7 +10421,7 @@ function createReleaseCommand() {
       }
       spinner.text = "Scanning completed tasks...";
       const pkgPath = import_path27.default.resolve(process.cwd(), "package.json");
-      const pkgContent = await import_promises23.default.readFile(pkgPath, "utf-8");
+      const pkgContent = await import_promises22.default.readFile(pkgPath, "utf-8");
       const pkg2 = JSON.parse(pkgContent);
       const currentVersion = pkg2.version;
       const [major, minor, patch] = currentVersion.split(".").map(Number);
@@ -10318,7 +10429,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 ${import_chalk32.default.dim(currentVersion)} to ${import_chalk32.default.green(newVersion)}`);
+      spinner.succeed(`Bumping ${pkg2.name} from ${import_chalk33.default.dim(currentVersion)} to ${import_chalk33.default.green(newVersion)}`);
       const { confirm } = await import_inquirer6.default.prompt([{
         type: "confirm",
         name: "confirm",
@@ -10330,7 +10441,7 @@ function createReleaseCommand() {
         return;
       }
       pkg2.version = newVersion;
-      await import_promises23.default.writeFile(pkgPath, JSON.stringify(pkg2, null, 4));
+      await import_promises22.default.writeFile(pkgPath, JSON.stringify(pkg2, null, 4));
       const changelogPath = import_path27.default.resolve(process.cwd(), "CHANGELOG.md");
       const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       const entry = `
@@ -10338,9 +10449,9 @@ function createReleaseCommand() {
 - Automated release via Rigstate.
 `;
       try {
-        await import_promises23.default.appendFile(changelogPath, entry);
+        await import_promises22.default.appendFile(changelogPath, entry);
       } catch {
-        await import_promises23.default.writeFile(changelogPath, "# Changelog\n" + entry);
+        await import_promises22.default.writeFile(changelogPath, "# Changelog\n" + entry);
       }
       spinner.start("Tagging and pushing...");
       await git.add(["package.json", "CHANGELOG.md"]);
@@ -10348,7 +10459,7 @@ function createReleaseCommand() {
       await git.addTag(`v${newVersion}`);
       await git.push();
       await git.pushTags();
-      spinner.succeed(import_chalk32.default.bold.green(`\u{1F680} Release v${newVersion} shipped!`));
+      spinner.succeed(import_chalk33.default.bold.green(`\u{1F680} Release v${newVersion} shipped!`));
     } catch (e) {
       spinner.fail(e.message);
     }
@@ -10365,7 +10476,7 @@ function getContext3() {
 // src/commands/roadmap.ts
 init_cjs_shims();
 var import_commander22 = require("commander");
-var import_chalk33 = __toESM(require("chalk"), 1);
+var import_chalk34 = __toESM(require("chalk"), 1);
 var import_ora15 = __toESM(require("ora"), 1);
 var import_axios23 = __toESM(require("axios"), 1);
 init_config();
@@ -10377,7 +10488,7 @@ function createRoadmapCommand() {
       const apiUrl = getApiUrl();
       const projectId = getProjectId();
       if (!projectId) {
-        spinner.fail(import_chalk33.default.red('Project context missing. Run "rigstate link".'));
+        spinner.fail(import_chalk34.default.red('Project context missing. Run "rigstate link".'));
         return;
       }
       const response = await import_axios23.default.get(
@@ -10390,11 +10501,11 @@ function createRoadmapCommand() {
       const tasks = response.data.data.roadmap || [];
       spinner.stop();
       if (tasks.length === 0) {
-        console.log(import_chalk33.default.yellow("\nRoadmap is empty. Use the web UI to define your journey."));
+        console.log(import_chalk34.default.yellow("\nRoadmap is empty. Use the web UI to define your journey."));
         return;
       }
-      console.log("\n" + import_chalk33.default.bold.underline("\u{1F6F0}\uFE0F  TACTICAL OVERVIEW: PROJECT ROADMAP"));
-      console.log(import_chalk33.default.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" + import_chalk34.default.bold.underline("\u{1F6F0}\uFE0F  TACTICAL OVERVIEW: PROJECT ROADMAP"));
+      console.log(import_chalk34.default.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": [],
@@ -10406,14 +10517,14 @@ function createRoadmapCommand() {
           columns[t.status].push(t);
         }
       });
-      displayColumn("\u{1F525} IN PROGRESS", columns.IN_PROGRESS, import_chalk33.default.yellow);
-      displayColumn("\u25B6\uFE0F  ACTIVE / NEXT", columns.ACTIVE, import_chalk33.default.green);
-      displayColumn("\u{1F512} LOCKED", columns.LOCKED, import_chalk33.default.blue);
-      displayColumn("\u23F3 PENDING", columns.PENDING, import_chalk33.default.gray);
-      console.log(import_chalk33.default.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(import_chalk33.default.dim(`Total: ${tasks.length} tasks | Run "rigstate work" to start coding.`));
+      displayColumn("\u{1F525} IN PROGRESS", columns.IN_PROGRESS, import_chalk34.default.yellow);
+      displayColumn("\u25B6\uFE0F  ACTIVE / NEXT", columns.ACTIVE, import_chalk34.default.green);
+      displayColumn("\u{1F512} LOCKED", columns.LOCKED, import_chalk34.default.blue);
+      displayColumn("\u23F3 PENDING", columns.PENDING, import_chalk34.default.gray);
+      console.log(import_chalk34.default.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(import_chalk34.default.dim(`Total: ${tasks.length} tasks | Run "rigstate work" to start coding.`));
     } catch (e) {
-      spinner.fail(import_chalk33.default.red(`
+      spinner.fail(import_chalk34.default.red(`
 Failed to fetch roadmap: ${e.message}`));
     }
   });
@@ -10424,15 +10535,15 @@ 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" ? import_chalk33.default.magenta(" [MVP]") : "";
-    console.log(` ${color("\u2022")} ${import_chalk33.default.bold(id)} ${item.title}${priority}`);
+    const priority = item.priority === "MVP" ? import_chalk34.default.magenta(" [MVP]") : "";
+    console.log(` ${color("\u2022")} ${import_chalk34.default.bold(id)} ${item.title}${priority}`);
   });
 }
 
 // src/commands/council.ts
 init_cjs_shims();
 var import_commander23 = require("commander");
-var import_chalk34 = __toESM(require("chalk"), 1);
+var import_chalk35 = __toESM(require("chalk"), 1);
 var import_ora16 = __toESM(require("ora"), 1);
 var import_inquirer7 = __toESM(require("inquirer"), 1);
 init_config();
@@ -10444,7 +10555,7 @@ function createCouncilCommand() {
       const apiUrl = getApiUrl();
       const projectId = getProjectId();
       if (!projectId) {
-        console.error(import_chalk34.default.red('Project context missing. Run "rigstate link".'));
+        console.error(import_chalk35.default.red('Project context missing. Run "rigstate link".'));
         return;
       }
       let sessionTopic = topic;
@@ -10456,25 +10567,25 @@ function createCouncilCommand() {
         }]);
         sessionTopic = ans.topic;
       }
-      console.log(import_chalk34.default.bold.magenta("\n\u2696\uFE0F  CONVENING THE COUNCIL OF SOVEREIGNTY\n"));
-      console.log(import_chalk34.default.dim(`Topic: ${sessionTopic}`));
-      console.log(import_chalk34.default.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(import_chalk34.default.yellow("\n\u{1F9E0} Frank (Architect): Analyzing alignment with Project DNA..."));
+      console.log(import_chalk35.default.bold.magenta("\n\u2696\uFE0F  CONVENING THE COUNCIL OF SOVEREIGNTY\n"));
+      console.log(import_chalk35.default.dim(`Topic: ${sessionTopic}`));
+      console.log(import_chalk35.default.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(import_chalk35.default.yellow("\n\u{1F9E0} Frank (Architect): Analyzing alignment with Project DNA..."));
       await sleep(1500);
-      console.log(import_chalk34.default.gray('  "This decision affects our backend scalability. I recommend caution."'));
-      console.log(import_chalk34.default.blue("\n\u{1F6E1}\uFE0F  Sigrid (Curator): Checking historical precedents..."));
+      console.log(import_chalk35.default.gray('  "This decision affects our backend scalability. I recommend caution."'));
+      console.log(import_chalk35.default.blue("\n\u{1F6E1}\uFE0F  Sigrid (Curator): Checking historical precedents..."));
       await sleep(1500);
-      console.log(import_chalk34.default.gray(`  "Similar patterns in other projects led to technical debt. Let's review RLS."`));
-      console.log(import_chalk34.default.green("\n\u{1F4D0} Einar (Analyst): Scanning dependency impact..."));
+      console.log(import_chalk35.default.gray(`  "Similar patterns in other projects led to technical debt. Let's review RLS."`));
+      console.log(import_chalk35.default.green("\n\u{1F4D0} Einar (Analyst): Scanning dependency impact..."));
       await sleep(1500);
-      console.log(import_chalk34.default.gray('  "Implementation will require updating 3 core services."'));
-      console.log(import_chalk34.default.bold.white("\n\u{1F4CB} [FINAL DECISION RECORD]"));
-      console.log(import_chalk34.default.white("  Status:    Approved with conditions"));
-      console.log(import_chalk34.default.white("  Rationale: Value outweighs migration cost. Ensure SEC-SQL-01 compliance."));
-      console.log(import_chalk34.default.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(import_chalk34.default.green("\u2705 Decision saved to Project Brain (ADR-102)"));
+      console.log(import_chalk35.default.gray('  "Implementation will require updating 3 core services."'));
+      console.log(import_chalk35.default.bold.white("\n\u{1F4CB} [FINAL DECISION RECORD]"));
+      console.log(import_chalk35.default.white("  Status:    Approved with conditions"));
+      console.log(import_chalk35.default.white("  Rationale: Value outweighs migration cost. Ensure SEC-SQL-01 compliance."));
+      console.log(import_chalk35.default.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(import_chalk35.default.green("\u2705 Decision saved to Project Brain (ADR-102)"));
     } catch (e) {
-      console.error(import_chalk34.default.red(`
+      console.error(import_chalk35.default.red(`
 Council session aborted: ${e.message}`));
     }
   });
@@ -10483,12 +10594,8 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/utils/version.ts
-init_cjs_shims();
-async function checkVersion() {
-}
-
 // src/index.ts
+init_version();
 var import_dotenv = __toESM(require("dotenv"), 1);
 var pkg = require_package();
 import_dotenv.default.config();
@@ -10522,19 +10629,19 @@ program.hook("preAction", async () => {
 });
 program.on("--help", () => {
   console.log("");
-  console.log(import_chalk35.default.bold("Examples:"));
+  console.log(import_chalk36.default.bold("Examples:"));
   console.log("");
-  console.log(import_chalk35.default.cyan("  $ rigstate login sk_rigstate_your_api_key"));
-  console.log(import_chalk35.default.dim("    Authenticate with your Rigstate API key"));
+  console.log(import_chalk36.default.cyan("  $ rigstate login sk_rigstate_your_api_key"));
+  console.log(import_chalk36.default.dim("    Authenticate with your Rigstate API key"));
   console.log("");
-  console.log(import_chalk35.default.cyan("  $ rigstate scan"));
-  console.log(import_chalk35.default.dim("    Scan the current directory"));
+  console.log(import_chalk36.default.cyan("  $ rigstate scan"));
+  console.log(import_chalk36.default.dim("    Scan the current directory"));
   console.log("");
-  console.log(import_chalk35.default.cyan("  $ rigstate scan ./src --project abc123"));
-  console.log(import_chalk35.default.dim("    Scan a specific directory with project ID"));
+  console.log(import_chalk36.default.cyan("  $ rigstate scan ./src --project abc123"));
+  console.log(import_chalk36.default.dim("    Scan a specific directory with project ID"));
   console.log("");
-  console.log(import_chalk35.default.cyan("  $ rigstate scan --json"));
-  console.log(import_chalk35.default.dim("    Output results in JSON format (useful for IDE extensions)"));
+  console.log(import_chalk36.default.cyan("  $ rigstate scan --json"));
+  console.log(import_chalk36.default.dim("    Output results in JSON format (useful for IDE extensions)"));
   console.log("");
 });
 program.parse(process.argv);