@a-company/paradigm 3.44.0 → 5.3.3

package/dist/decision-loader-WWCLIQPJ.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import {
+  findDecisionsForSymbol,
+  getDecisionSummary,
+  loadDecision,
+  loadDecisions,
+  recordDecision,
+  supersedeDecision,
+  updateDecision
+} from "./chunk-EZ3GOCYC.js";
+import "./chunk-7N7GSU6K.js";
+export {
+  findDecisionsForSymbol,
+  getDecisionSummary,
+  loadDecision,
+  loadDecisions,
+  recordDecision,
+  supersedeDecision,
+  updateDecision
+};

package/dist/{delete-RRK4RL6Y.js → delete-KBRPQLPC.js}

@@ -2,8 +2,8 @@
 import {
   deleteLoreEntry,
   loadLoreEntry
-} from "./chunk-QIOCFXDQ.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-EKGMAM62.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/lore/delete.ts
 import chalk from "chalk";

package/dist/{diff-IP5CIARP.js → diff-RQLLNAFI.js}

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import {
   BackgroundOrchestrator
-} from "./chunk-QWA26UNO.js";
-import "./chunk-J4E6K5MG.js";
+} from "./chunk-WQITYKHM.js";
+import "./chunk-LSRABQIY.js";
 import "./chunk-PBHIFAL4.js";
-import "./chunk-FS3WTUHY.js";
+import "./chunk-TXESEO7Y.js";
 import "./chunk-6QC3YGB6.js";
 import "./chunk-PMXRGPRQ.js";
-import "./chunk-MW5DMGBB.js";
 import "./chunk-5JGJACDU.js";
 import "./chunk-ZGUAAVMA.js";
 import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-YMDLDELF.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/team/diff.ts
 import * as fs from "fs";

package/dist/{discipline-5F5OVTXB.js → discipline-FA4OZXIS.js}

@@ -10,7 +10,7 @@ import {
   getStackConfig,
   listStackPresets
 } from "./chunk-UPLDI7CN.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 export {
   DISCIPLINE_MAPPINGS,
   GENERIC_SYMBOL_MAPPING,

package/dist/{dist-UXWV4OKX.js → dist-34NA5RS5.js}

@@ -36,7 +36,7 @@ import {
 } from "./chunk-ZGUAAVMA.js";
 import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 export {
   PREFIX_TO_TYPE,
   SYMBOL_PREFIXES,

package/dist/{dist-5QE2BB2B-X6DYVSUL.js → dist-5QE2BB2B-5S3T6Y3T.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // ../sentinel/dist/dist-5QE2BB2B.js
 import * as fs4 from "fs";

package/dist/{dist-CM3MVWWW.js → dist-77JDTVAY.js}

@@ -29,6 +29,7 @@ import {
   loadUniversalPatterns,
   writeConfig
 } from "./chunk-ZDHLG5VP.js";
+import "./chunk-7N7GSU6K.js";
 export {
   ContextEnricher,
   DEFAULT_AUTH_CONFIG,

package/dist/{dist-POMVY6WP.js → dist-QK4SQAK7.js}

@@ -31,7 +31,7 @@ import {
   loadServerConfig,
   writeConfig
 } from "./chunk-FKJUBQU3.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 export {
   ContextEnricher,
   DEFAULT_AUTH_CONFIG,

package/dist/{dist-3RVKEJRT.js → dist-TA6LSC2Q.js}

@@ -8,7 +8,7 @@ import {
   serializeGateConfig,
   validateGateConfig
 } from "./chunk-IRKUEJVW.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 export {
   findGateFiles,
   formatValidationResult,

package/dist/docs-LVLRPBAW.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import {
+  buildDocsManifest,
+  buildFlowPage,
+  buildPortalPage,
+  buildSymbolPage,
+  loadCustomPages,
+  loadDocsConfig
+} from "./chunk-2T6BTYBN.js";
+import "./chunk-PDX44BCA.js";
+
+// src/commands/docs/serve.ts
+import chalk from "chalk";
+async function docsServeCommand(options) {
+  const projectDir = process.cwd();
+  const port = parseInt(options.port || "3850", 10);
+  const shouldOpen = options.open !== false;
+  console.log(chalk.cyan("\n  Starting Paradigm Docs...\n"));
+  try {
+    const { startPlatformServer } = await import("./platform-server-PMD57BEG.js");
+    await startPlatformServer({
+      projectDir,
+      port,
+      open: shouldOpen,
+      sections: ["overview", "docs"]
+    });
+    console.log(chalk.green(`  Docs running at ${chalk.bold(`http://localhost:${port}`)}`));
+    console.log(chalk.gray("  Press Ctrl+C to stop\n"));
+    await new Promise(() => {
+    });
+  } catch (error) {
+    if (error.code === "EADDRINUSE") {
+      console.error(chalk.red(`
+  Error: Port ${port} is already in use.`));
+      console.log(chalk.gray(`  Try: paradigm docs serve --port ${port + 1}
+`));
+    } else {
+      console.error(chalk.red("\n  Failed to start Paradigm Docs:"), error);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/docs/build.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk2 from "chalk";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+async function docsBuildCommand(options) {
+  let rootDir = process.cwd();
+  while (rootDir !== "/") {
+    if (fs.existsSync(path.join(rootDir, ".paradigm"))) break;
+    rootDir = path.dirname(rootDir);
+  }
+  if (rootDir === "/") {
+    console.error(chalk2.red("  Not in a Paradigm project (no .paradigm/ directory found)"));
+    process.exit(1);
+  }
+  const config = loadDocsConfig(rootDir);
+  const outputDir = options.output || config.output || ".paradigm/docs-site";
+  const outputPath = path.resolve(rootDir, outputDir);
+  const dataDir = path.join(outputPath, "_data");
+  console.log(chalk2.cyan(`
+  Building docs to ${chalk2.white(outputPath)}...
+`));
+  fs.mkdirSync(path.join(dataDir, "symbols"), { recursive: true });
+  fs.mkdirSync(path.join(dataDir, "flows"), { recursive: true });
+  fs.mkdirSync(path.join(dataDir, "pages"), { recursive: true });
+  const manifest = buildDocsManifest(rootDir, config);
+  fs.writeFileSync(
+    path.join(dataDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2),
+    "utf8"
+  );
+  console.log(chalk2.gray(`  manifest.json (${manifest.totalSymbols} symbols)`));
+  let symbolCount = 0;
+  for (const group of manifest.groups) {
+    const items = [...group.items];
+    if (group.subgroups) {
+      for (const sg of group.subgroups) {
+        items.push(...sg.items);
+      }
+    }
+    for (const item of items) {
+      if (["component", "signal", "aspect", "gate"].includes(item.kind)) {
+        const page = buildSymbolPage(rootDir, item.id);
+        if (page) {
+          fs.writeFileSync(
+            path.join(dataDir, "symbols", `${item.id}.json`),
+            JSON.stringify(page, null, 2),
+            "utf8"
+          );
+          symbolCount++;
+        }
+      } else if (item.kind === "flow") {
+        const page = buildFlowPage(rootDir, item.id);
+        if (page) {
+          fs.writeFileSync(
+            path.join(dataDir, "flows", `${item.id}.json`),
+            JSON.stringify(page, null, 2),
+            "utf8"
+          );
+        }
+      }
+    }
+  }
+  const portal = buildPortalPage(rootDir);
+  fs.writeFileSync(
+    path.join(dataDir, "portal.json"),
+    JSON.stringify(portal, null, 2),
+    "utf8"
+  );
+  const customPages = loadCustomPages(rootDir, config.customContent);
+  for (const page of customPages) {
+    fs.writeFileSync(
+      path.join(dataDir, "pages", `${page.slug}.json`),
+      JSON.stringify(page, null, 2),
+      "utf8"
+    );
+  }
+  let uiDistPath = path.join(__dirname, "..", "..", "platform-ui", "dist");
+  if (!fs.existsSync(uiDistPath)) {
+    uiDistPath = path.join(__dirname, "..", "..", "..", "platform-ui", "dist");
+  }
+  if (fs.existsSync(uiDistPath)) {
+    copyDir(uiDistPath, outputPath);
+    console.log(chalk2.gray("  Copied SPA shell"));
+  }
+  console.log(chalk2.gray(`  ${symbolCount} symbol pages`));
+  console.log(chalk2.gray(`  ${customPages.length} custom pages`));
+  console.log(chalk2.gray("  portal.json"));
+  console.log(chalk2.green(`
+  Docs built to ${outputPath}
+`));
+}
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== "_data") {
+        copyDir(srcPath, destPath);
+      }
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+export {
+  docsBuildCommand,
+  docsServeCommand
+};

package/dist/docs-PBZB7LYP.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import {
+  buildDocsManifest,
+  buildFlowPage,
+  buildPortalPage,
+  buildSymbolPage,
+  loadCustomPage,
+  loadDocsConfig,
+  searchDocs
+} from "./chunk-2T6BTYBN.js";
+import "./chunk-PDX44BCA.js";
+
+// src/platform-server/routes/docs.ts
+import { Router } from "express";
+function createDocsRouter(projectDir) {
+  const router = Router();
+  router.get("/manifest", (_req, res) => {
+    try {
+      const config = loadDocsConfig(projectDir);
+      const manifest = buildDocsManifest(projectDir, config);
+      res.json(manifest);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to build docs manifest", detail: String(err) });
+    }
+  });
+  router.get("/symbol/:id", (req, res) => {
+    try {
+      const page = buildSymbolPage(projectDir, req.params.id);
+      if (!page) {
+        res.status(404).json({ error: `Symbol "${req.params.id}" not found` });
+        return;
+      }
+      res.json(page);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to build symbol page", detail: String(err) });
+    }
+  });
+  router.get("/flow/:id", (req, res) => {
+    try {
+      const page = buildFlowPage(projectDir, req.params.id);
+      if (!page) {
+        res.status(404).json({ error: `Flow "${req.params.id}" not found` });
+        return;
+      }
+      res.json(page);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to build flow page", detail: String(err) });
+    }
+  });
+  router.get("/portal", (_req, res) => {
+    try {
+      const page = buildPortalPage(projectDir);
+      res.json(page);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to build portal page", detail: String(err) });
+    }
+  });
+  router.get("/page/:slug", (req, res) => {
+    try {
+      const config = loadDocsConfig(projectDir);
+      const page = loadCustomPage(projectDir, req.params.slug, config);
+      if (!page) {
+        res.status(404).json({ error: `Page "${req.params.slug}" not found` });
+        return;
+      }
+      res.json(page);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to load custom page", detail: String(err) });
+    }
+  });
+  router.get("/search", (req, res) => {
+    try {
+      const q = req.query.q || "";
+      if (!q) {
+        res.json({ count: 0, results: [] });
+        return;
+      }
+      const limit = req.query.limit ? parseInt(req.query.limit, 10) : 20;
+      const results = searchDocs(projectDir, q, limit);
+      res.json({ count: results.length, results });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to search docs", detail: String(err) });
+    }
+  });
+  return router;
+}
+export {
+  createDocsRouter
+};

package/dist/{doctor-GKZJU7QG.js → doctor-ULBOHEIC.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   doctorCommand
-} from "./chunk-2SKXFXIT.js";
-import "./chunk-KB4XJWE3.js";
+} from "./chunk-S3ORKP3V.js";
+import "./chunk-6N3JTACN.js";
 import "./chunk-YO6DVTL7.js";
 import "./chunk-4NCFWYGG.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 export {
   doctorCommand
 };

package/dist/{drift-YGT4LJ7Q.js → drift-R5NRKFHI.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/drift.ts
 import * as fs from "fs";

package/dist/{echo-A6HD5UP7.js → echo-O2LY7CC2.js}

@@ -2,7 +2,7 @@
 import {
   log
 } from "./chunk-4NCFWYGG.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/echo.ts
 import * as fs from "fs";

package/dist/{edit-4CLNN5JG.js → edit-R2HNLMOG.js}

@@ -2,8 +2,8 @@
 import {
   loadLoreEntry,
   updateLoreEntry
-} from "./chunk-QIOCFXDQ.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-EKGMAM62.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/lore/edit.ts
 import chalk from "chalk";

package/dist/event-25OJKDCE.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/commands/event.ts
+import * as fs from "fs";
+import * as path from "path";
+async function eventEmitCommand(options) {
+  const cwd = process.cwd();
+  const eventsDir = path.join(cwd, ".paradigm", "events");
+  const streamFile = path.join(eventsDir, "stream.jsonl");
+  const now = Date.now();
+  const rand = Math.floor(Math.random() * 9999).toString().padStart(4, "0");
+  const event = {
+    id: `ev-${now}-${rand}`,
+    type: options.type,
+    source: options.source,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...options.path ? { path: options.path } : {},
+    ...options.symbols?.length ? { symbols: options.symbols } : {},
+    ...options.context ? { context: options.context } : {},
+    ...options.severity ? { severity: options.severity } : {}
+  };
+  try {
+    fs.mkdirSync(eventsDir, { recursive: true });
+    fs.appendFileSync(streamFile, JSON.stringify(event) + "\n", "utf8");
+  } catch {
+  }
+}
+export {
+  eventEmitCommand
+};

package/dist/{export-T7CMMJIB.js → export-IWVL7XLF.js}

@@ -2,7 +2,7 @@
 import {
   AuditLogger
 } from "./chunk-PBHIFAL4.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/team/export.ts
 import * as path from "path";

package/dist/{flow-UFMPVOEM.js → flow-CRRVV3O3.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import "./chunk-MW5DMGBB.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-YMDLDELF.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/flow.ts
 import * as fs2 from "fs";

package/dist/{global-HHUJSBG5.js → global-3NG5JXUB.js}

@@ -2,7 +2,7 @@
 import {
   log
 } from "./chunk-4NCFWYGG.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/global.ts
 import * as fs from "fs";

package/dist/graduate-USAWGBJM.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/commands/graduate/index.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import * as yaml from "js-yaml";
+function loadGraduationYaml(rootDir) {
+  const filePath = path.join(rootDir, ".paradigm", "graduation.yaml");
+  if (!fs.existsSync(filePath)) return { states: {} };
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    return yaml.load(content) || { states: {} };
+  } catch {
+    return { states: {} };
+  }
+}
+var SEED_HABIT_NAMES = {
+  "explore-before-implement": "Explore Before Implementing",
+  "ripple-before-modify": "Ripple Before Modifying",
+  "check-fragility": "Check Fragility",
+  "wisdom-before-implement": "Check Team Wisdom",
+  "verify-before-done": "Verify Before Done",
+  "postflight-compliance": "Postflight Compliance",
+  "test-new-components": "Test New Components",
+  "purpose-coverage": "Purpose File Coverage",
+  "record-lore-for-significant": "Record Lore for Significant Changes",
+  "confidence-on-decisions": "Confidence on Decisions",
+  "gates-for-routes": "Gates for Routes",
+  "university-content-valid": "University Content Valid",
+  "university-onboarded": "University Onboarding"
+};
+var TIER_COLORS = {
+  hook: chalk.green,
+  habit: chalk.yellow,
+  mcp: chalk.red
+};
+async function graduateStatusCommand(options) {
+  const cwd = process.cwd();
+  const data = loadGraduationYaml(cwd);
+  const states = data.states || {};
+  if (options.json) {
+    console.log(JSON.stringify({ states }, null, 2));
+    return;
+  }
+  console.log(chalk.blue("\n\u26A1 Automation Tier Status\n"));
+  console.log(chalk.gray("\u2500".repeat(60)));
+  const byTier = {
+    hook: [],
+    habit: [],
+    mcp: []
+  };
+  const allIds = /* @__PURE__ */ new Set([...Object.keys(SEED_HABIT_NAMES), ...Object.keys(states)]);
+  for (const id of allIds) {
+    const state = states[id] || {};
+    const tier = state.tier || "habit";
+    if (!byTier[tier]) byTier[tier] = [];
+    byTier[tier].push({ id, state });
+  }
+  const hookCount = byTier.hook.length;
+  const habitCount = byTier.habit.length;
+  const mcpCount = byTier.mcp.length;
+  const total = hookCount + habitCount + mcpCount;
+  console.log(`  ${chalk.green(`${hookCount} hook`)}  ${chalk.yellow(`${habitCount} habit`)}  ${chalk.red(`${mcpCount} mcp`)}  (${total} total)
+`);
+  if (byTier.hook.length > 0) {
+    console.log(chalk.green.bold("  \u26A1 Hooks (zero context cost)"));
+    for (const { id, state } of byTier.hook) {
+      const name = SEED_HABIT_NAMES[id] || id;
+      const date = state.graduatedAt ? ` \u2014 graduated ${state.graduatedAt.split("T")[0]}` : "";
+      console.log(`    ${chalk.green("\u25CF")} ${name} ${chalk.gray(`(${id})${date}`)}`);
+    }
+    console.log();
+  }
+  if (byTier.habit.length > 0) {
+    console.log(chalk.yellow.bold("  \u{1F4AD} Habits (agent-reminded)"));
+    for (const { id, state } of byTier.habit) {
+      const name = SEED_HABIT_NAMES[id] || id;
+      const lock = state.neverGraduate ? chalk.gray(" \u{1F512} never-graduate") : "";
+      const cooldown = state.cooldownUntil && new Date(state.cooldownUntil) > /* @__PURE__ */ new Date() ? chalk.gray(` \u23F3 cooldown until ${state.cooldownUntil.split("T")[0]}`) : "";
+      console.log(`    ${chalk.yellow("\u25CF")} ${name} ${chalk.gray(`(${id})`)}${lock}${cooldown}`);
+    }
+    console.log();
+  }
+  if (byTier.mcp.length > 0) {
+    console.log(chalk.red.bold("  \u{1F527} MCP Tools (manual, high token cost)"));
+    for (const { id, state } of byTier.mcp) {
+      const name = SEED_HABIT_NAMES[id] || id;
+      console.log(`    ${chalk.red("\u25CF")} ${name} ${chalk.gray(`(${id})`)}`);
+    }
+    console.log();
+  }
+  if (hookCount > 0) {
+    const estimatedSavings = hookCount * 150;
+    console.log(chalk.gray(`  Estimated savings: ~${estimatedSavings} tokens/session from ${hookCount} graduated habit(s)`));
+  }
+  console.log();
+}
+function saveGraduationYaml(rootDir, data) {
+  const filePath = path.join(rootDir, ".paradigm", "graduation.yaml");
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const content = yaml.dump(data, { lineWidth: 120, noRefs: true, sortKeys: true });
+  fs.writeFileSync(filePath, content, "utf8");
+}
+async function graduatePromoteCommand(habitId) {
+  const cwd = process.cwd();
+  const data = loadGraduationYaml(cwd);
+  if (!data.states) data.states = {};
+  const state = data.states[habitId] || {};
+  if (state.tier === "hook") {
+    console.log(chalk.yellow(`${habitId} is already graduated to hook tier.`));
+    return;
+  }
+  if (state.neverGraduate) {
+    console.log(chalk.red(`${habitId} is marked as never-graduate (requires agent cognition).`));
+    return;
+  }
+  data.states[habitId] = {
+    ...state,
+    tier: "hook",
+    graduatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    complianceAtGraduation: 100,
+    failureCount: 0
+  };
+  saveGraduationYaml(cwd, data);
+  const name = SEED_HABIT_NAMES[habitId] || habitId;
+  console.log(chalk.green(`${chalk.bold("\u26A1")} Graduated "${name}" to hook tier.`));
+  console.log(chalk.gray("  MCP evaluation will skip this habit. Stop hook enforces compliance."));
+}
+async function graduateDemoteCommand(habitId, options) {
+  const cwd = process.cwd();
+  const data = loadGraduationYaml(cwd);
+  if (!data.states) data.states = {};
+  const state = data.states[habitId] || {};
+  if (state.tier !== "hook") {
+    console.log(chalk.yellow(`${habitId} is not at hook tier (currently: ${state.tier || "habit"}).`));
+    return;
+  }
+  const cooldownDays = options.cooldown ? parseInt(options.cooldown) : 14;
+  const cooldownUntil = /* @__PURE__ */ new Date();
+  cooldownUntil.setDate(cooldownUntil.getDate() + cooldownDays);
+  data.states[habitId] = {
+    ...state,
+    tier: "habit",
+    demotedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cooldownUntil: cooldownUntil.toISOString()
+  };
+  saveGraduationYaml(cwd, data);
+  const name = SEED_HABIT_NAMES[habitId] || habitId;
+  console.log(chalk.yellow(`${chalk.bold("\u{1F4AD}")} Demoted "${name}" back to habit tier.`));
+  console.log(chalk.gray(`  Cooldown: ${cooldownDays} days (until ${cooldownUntil.toISOString().split("T")[0]}).`));
+  console.log(chalk.gray("  MCP evaluation will resume checking this habit."));
+}
+export {
+  graduateDemoteCommand,
+  graduatePromoteCommand,
+  graduateStatusCommand
+};

package/dist/{graph-YYUXI3F7.js → graph-VHUMAAS6.js}

@@ -3,8 +3,8 @@ import {
   cliBuildGraphState,
   graphCommand,
   graphGenerateCommand
-} from "./chunk-QDXI2DHR.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-J2JEQRT3.js";
+import "./chunk-PDX44BCA.js";
 export {
   cliBuildGraphState,
   graphCommand,

package/dist/{graph-server-ZPXRSGCW.js → graph-server-YL22VBBN.js}

@@ -3,7 +3,7 @@ import {
   createGraphsRouter,
   createSymbolsRouter
 } from "./chunk-F3BCHPYT.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/graph-server/index.ts
 import express from "express";

package/dist/{habits-RG5SVKXP.js → habits-OL5NGPXO.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/habits/index.ts
 import * as fs2 from "fs";
@@ -934,7 +934,7 @@ async function habitsStatusCommand(options) {
   const enabled = getEnabledHabits(habits);
   let practiceData = null;
   try {
-    const { SentinelStorage } = await import("./dist-POMVY6WP.js");
+    const { SentinelStorage } = await import("./dist-QK4SQAK7.js");
     const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
     if (fs2.existsSync(sentinelDir)) {
       const storage = new SentinelStorage(sentinelDir);
@@ -1302,7 +1302,7 @@ async function habitsCheckCommand(options) {
     try {
       const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
       if (fs2.existsSync(sentinelDir)) {
-        const { SentinelStorage } = await import("./dist-POMVY6WP.js");
+        const { SentinelStorage } = await import("./dist-QK4SQAK7.js");
         const storage = new SentinelStorage(sentinelDir);
         for (const e of evaluation.evaluations) {
           storage.recordPracticeEvent({