@a-company/paradigm 3.0.3 → 3.1.2

package/dist/habits-FA65W77Y.js

@@ -0,0 +1,1153 @@
+#!/usr/bin/env node
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/habits/index.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+import { execSync } from "child_process";
+import chalk from "chalk";
+import * as yaml2 from "js-yaml";
+
+// src/core/habits/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+// src/core/habits/seed-habits.json
+var seed_habits_default = [
+  {
+    id: "explore-before-implement",
+    name: "Explore Before Implementing",
+    description: "Call ripple/navigate/search before modifying existing symbols to understand impact",
+    category: "discovery",
+    trigger: "preflight",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_ripple", "paradigm_navigate", "paradigm_search", "paradigm_related"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "ripple-before-modify",
+    name: "Ripple Before Modifying",
+    description: "Run ripple analysis before modifying symbols with dependents",
+    category: "discovery",
+    trigger: "preflight",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_ripple"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "check-fragility",
+    name: "Check Fragility",
+    description: "Check history fragility for symbols before modifying frequently-broken code",
+    category: "discovery",
+    trigger: "preflight",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_history_fragility"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "wisdom-before-implement",
+    name: "Check Team Wisdom",
+    description: "Check team wisdom (preferences, antipatterns, decisions) before implementing",
+    category: "collaboration",
+    trigger: "preflight",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_wisdom_context", "paradigm_wisdom_expert"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "verify-before-done",
+    name: "Verify Before Done",
+    description: "Run postflight compliance checks before finishing a session",
+    category: "verification",
+    trigger: "on-stop",
+    severity: "warn",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_pm_postflight"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "postflight-compliance",
+    name: "Postflight Compliance",
+    description: "Ensure postflight checks pass without errors before finishing",
+    category: "verification",
+    trigger: "on-stop",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_pm_postflight", "paradigm_reindex"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "test-new-components",
+    name: "Test New Components",
+    description: "New components should have associated tests or test plan documented",
+    category: "testing",
+    trigger: "postflight",
+    severity: "advisory",
+    check: {
+      type: "tests-exist",
+      params: {
+        patterns: ["**/*.test.*", "**/*.spec.*", "**/tests/**"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "purpose-coverage",
+    name: "Purpose File Coverage",
+    description: "All modified source directories should have .purpose file coverage",
+    category: "documentation",
+    trigger: "postflight",
+    severity: "warn",
+    check: {
+      type: "file-exists",
+      params: {
+        patterns: ["**/.purpose"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "record-lore-for-significant",
+    name: "Record Lore for Significant Changes",
+    description: "Sessions modifying 3+ files should record a lore entry",
+    category: "documentation",
+    trigger: "on-stop",
+    severity: "warn",
+    check: {
+      type: "lore-recorded",
+      params: {}
+    },
+    enabled: true
+  },
+  {
+    id: "gates-for-routes",
+    name: "Gates for Routes",
+    description: "API routes should have corresponding gate declarations in portal.yaml",
+    category: "security",
+    trigger: "postflight",
+    severity: "warn",
+    check: {
+      type: "gates-declared",
+      params: {
+        requireRoutes: true
+      }
+    },
+    enabled: true
+  }
+];
+
+// src/core/habits/loader.ts
+var SEED_HABITS = seed_habits_default;
+var HABITS_CACHE_TTL_MS = 30 * 1e3;
+var habitsCache = /* @__PURE__ */ new Map();
+function loadHabits(rootDir) {
+  const absoluteRoot = path.resolve(rootDir);
+  const cached = habitsCache.get(absoluteRoot);
+  if (cached && Date.now() - cached.loadedAt < HABITS_CACHE_TTL_MS) {
+    return cached.habits;
+  }
+  const habits = loadHabitsFresh(absoluteRoot);
+  habitsCache.set(absoluteRoot, {
+    habits,
+    loadedAt: Date.now()
+  });
+  return habits;
+}
+function loadHabitsFresh(rootDir) {
+  const habitsById = /* @__PURE__ */ new Map();
+  for (const seed of SEED_HABITS) {
+    habitsById.set(seed.id, { ...seed });
+  }
+  const globalHabitsPath = path.join(
+    process.env.HOME || process.env.USERPROFILE || "~",
+    ".paradigm",
+    "habits.yaml"
+  );
+  const globalConfig = loadHabitsYaml(globalHabitsPath);
+  if (globalConfig) {
+    mergeHabits(habitsById, globalConfig);
+  }
+  const projectHabitsPath = path.join(rootDir, ".paradigm", "habits.yaml");
+  const projectConfig = loadHabitsYaml(projectHabitsPath);
+  if (projectConfig) {
+    mergeHabits(habitsById, projectConfig);
+  }
+  return Array.from(habitsById.values());
+}
+function loadHabitsYaml(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    return yaml.load(content);
+  } catch {
+    return null;
+  }
+}
+function mergeHabits(habitsById, config) {
+  if (config.habits) {
+    for (const habit of config.habits) {
+      habitsById.set(habit.id, { ...habit });
+    }
+  }
+  if (config.overrides) {
+    for (const [habitId, override] of Object.entries(config.overrides)) {
+      const existing = habitsById.get(habitId);
+      if (existing) {
+        applyOverride(existing, override);
+      }
+    }
+  }
+}
+function applyOverride(habit, override) {
+  if (override.severity !== void 0) {
+    habit.severity = override.severity;
+  }
+  if (override.enabled !== void 0) {
+    habit.enabled = override.enabled;
+  }
+}
+function getHabitsByTrigger(habits, trigger) {
+  return habits.filter((h) => h.enabled && h.trigger === trigger);
+}
+function getEnabledHabits(habits) {
+  return habits.filter((h) => h.enabled);
+}
+function invalidateHabitsCache(rootDir) {
+  const absoluteRoot = path.resolve(rootDir);
+  habitsCache.delete(absoluteRoot);
+}
+
+// src/core/habits/evaluator.ts
+import * as path2 from "path";
+function evaluateHabits(habits, trigger, context) {
+  const activeHabits = getHabitsByTrigger(habits, trigger);
+  const evaluations = [];
+  for (const habit of activeHabits) {
+    const evaluation = evaluateHabit(habit, context);
+    evaluations.push(evaluation);
+  }
+  const followed = evaluations.filter((e) => e.result === "followed").length;
+  const skipped = evaluations.filter((e) => e.result === "skipped").length;
+  const partial = evaluations.filter((e) => e.result === "partial").length;
+  const blockingViolations = evaluations.filter(
+    (e) => e.result === "skipped" && e.habit.severity === "block"
+  ).length;
+  return {
+    trigger,
+    evaluations,
+    summary: {
+      total: evaluations.length,
+      followed,
+      skipped,
+      partial,
+      blockingViolations
+    },
+    blocksCompletion: blockingViolations > 0
+  };
+}
+function evaluateHabit(habit, context) {
+  switch (habit.check.type) {
+    case "tool-called":
+      return evaluateToolCalled(habit, context);
+    case "file-exists":
+      return evaluateFileExists(habit, context);
+    case "lore-recorded":
+      return evaluateLoreRecorded(habit, context);
+    case "symbols-registered":
+      return evaluateSymbolsRegistered(habit, context);
+    case "gates-declared":
+      return evaluateGatesDeclared(habit, context);
+    case "tests-exist":
+      return evaluateTestsExist(habit, context);
+    case "file-modified":
+      return evaluateFileModified(habit, context);
+    case "git-clean":
+      return evaluateGitClean(habit, context);
+    default:
+      return {
+        habit,
+        result: "partial",
+        reason: `Unknown check type: ${habit.check.type}`
+      };
+  }
+}
+function evaluateToolCalled(habit, context) {
+  const requiredTools = habit.check.params.tools || [];
+  if (requiredTools.length === 0) {
+    return { habit, result: "followed", reason: "No tools required" };
+  }
+  const calledTools = requiredTools.filter(
+    (tool) => context.toolsCalled.includes(tool)
+  );
+  if (calledTools.length > 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: `Called: ${calledTools.join(", ")}`,
+      evidence: calledTools
+    };
+  }
+  if (context.filesModified.length === 0 && context.symbolsTouched.length === 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: "No modifications made, habit not applicable"
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: `None of [${requiredTools.join(", ")}] were called before modifying code`
+  };
+}
+function evaluateFileExists(habit, context) {
+  if (context.filesModified.length === 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: "No files modified, check not applicable"
+    };
+  }
+  const hasPurposeUpdates = context.filesModified.some(
+    (f) => f.endsWith(".purpose") || f.includes(".paradigm/")
+  );
+  if (hasPurposeUpdates) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Purpose files were updated alongside source changes"
+    };
+  }
+  const sourceFiles = context.filesModified.filter(
+    (f) => !f.endsWith(".md") && !f.endsWith(".json") && !f.endsWith(".yaml") && !f.endsWith(".yml") && !f.endsWith(".lock") && !f.endsWith(".purpose") && !f.includes(".paradigm/")
+  );
+  if (sourceFiles.length === 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Only non-source files modified"
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: `${sourceFiles.length} source file(s) modified without .purpose updates`,
+    evidence: sourceFiles.slice(0, 5)
+  };
+}
+function evaluateLoreRecorded(habit, context) {
+  const sourceFiles = context.filesModified.filter(
+    (f) => !f.endsWith(".md") && !f.endsWith(".json") && !f.endsWith(".yaml") && !f.endsWith(".yml") && !f.endsWith(".lock") && !f.endsWith(".purpose") && !f.includes(".paradigm/")
+  );
+  if (sourceFiles.length < 3) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Session not significant enough to require lore (< 3 source files)"
+    };
+  }
+  if (context.loreRecorded) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Lore entry was recorded for this session"
+    };
+  }
+  if (context.toolsCalled.includes("paradigm_lore_record")) {
+    return {
+      habit,
+      result: "followed",
+      reason: "paradigm_lore_record was called during session"
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: `${sourceFiles.length} source files modified but no lore entry recorded`,
+    evidence: sourceFiles.slice(0, 5)
+  };
+}
+function evaluateSymbolsRegistered(habit, context) {
+  if (context.symbolsTouched.length === 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: "No symbols touched"
+    };
+  }
+  const purposeTools = [
+    "paradigm_purpose_add_component",
+    "paradigm_purpose_add_signal",
+    "paradigm_purpose_add_flow",
+    "paradigm_purpose_add_gate",
+    "paradigm_purpose_add_aspect",
+    "paradigm_purpose_add_state",
+    "paradigm_purpose_init"
+  ];
+  const calledPurposeTools = purposeTools.filter(
+    (t) => context.toolsCalled.includes(t)
+  );
+  if (calledPurposeTools.length > 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: `Purpose tools called: ${calledPurposeTools.join(", ")}`,
+      evidence: calledPurposeTools
+    };
+  }
+  return {
+    habit,
+    result: "partial",
+    reason: `${context.symbolsTouched.length} symbol(s) touched but no purpose registration tools called`
+  };
+}
+function evaluateGatesDeclared(habit, context) {
+  if (!context.taskAddsRoutes) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Task does not add routes"
+    };
+  }
+  if (context.hasPortalRoutes) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Portal.yaml has route declarations"
+    };
+  }
+  const gateTools = [
+    "paradigm_gates_for_route",
+    "paradigm_portal_add_route",
+    "paradigm_portal_add_gate"
+  ];
+  const calledGateTools = gateTools.filter(
+    (t) => context.toolsCalled.includes(t)
+  );
+  if (calledGateTools.length > 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: `Gate tools called: ${calledGateTools.join(", ")}`,
+      evidence: calledGateTools
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: "Task adds routes but no gate declarations or portal tools called"
+  };
+}
+function evaluateTestsExist(habit, context) {
+  if (context.filesModified.length === 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: "No files modified"
+    };
+  }
+  const testFiles = context.filesModified.filter(
+    (f) => f.includes(".test.") || f.includes(".spec.") || f.includes("/tests/") || f.includes("/test/") || f.includes("__tests__")
+  );
+  if (testFiles.length > 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: `Test files modified: ${testFiles.length}`,
+      evidence: testFiles.slice(0, 5)
+    };
+  }
+  const newSourceFiles = context.filesModified.filter(
+    (f) => !f.endsWith(".md") && !f.endsWith(".json") && !f.endsWith(".yaml") && !f.endsWith(".lock") && !f.endsWith(".purpose") && !f.includes(".paradigm/") && !f.includes("node_modules/")
+  );
+  if (newSourceFiles.length === 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: "No new source files to test"
+    };
+  }
+  return {
+    habit,
+    result: "partial",
+    reason: `${newSourceFiles.length} source file(s) modified but no test files updated`,
+    evidence: newSourceFiles.slice(0, 5)
+  };
+}
+function evaluateFileModified(habit, context) {
+  if (context.filesModified.length === 0) {
+    return { habit, result: "followed", reason: "No files modified" };
+  }
+  const patterns = habit.check.params.patterns || [];
+  if (patterns.length === 0) {
+    return { habit, result: "followed", reason: "No patterns specified" };
+  }
+  const matched = context.filesModified.filter(
+    (f) => patterns.some((p) => f.includes(p) || path2.basename(f) === p)
+  );
+  if (matched.length > 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: `Matching files: ${matched.join(", ")}`,
+      evidence: matched
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: `None of [${patterns.join(", ")}] found in modified files`
+  };
+}
+function evaluateGitClean(habit, context) {
+  if (context.filesModified.length === 0) {
+    return { habit, result: "followed", reason: "No files modified" };
+  }
+  if (context.gitClean === void 0) {
+    return { habit, result: "partial", reason: "Git status not available" };
+  }
+  if (context.gitClean) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Working tree is clean \u2014 changes committed"
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: "Uncommitted changes in working tree"
+  };
+}
+function buildEvaluationContext(params) {
+  return {
+    toolsCalled: params.toolsCalled || [],
+    filesModified: params.filesModified || [],
+    symbolsTouched: params.symbolsTouched || [],
+    loreRecorded: params.loreRecorded || false,
+    hasPortalRoutes: params.hasPortalRoutes || false,
+    taskAddsRoutes: params.taskAddsRoutes || false,
+    taskDescription: params.taskDescription,
+    gitClean: params.gitClean
+  };
+}
+
+// src/commands/habits/index.ts
+var HABITS_FILE = ".paradigm/habits.yaml";
+var SEED_HABIT_IDS = /* @__PURE__ */ new Set([
+  "explore-before-implement",
+  "ripple-before-modify",
+  "check-fragility",
+  "wisdom-before-implement",
+  "verify-before-done",
+  "postflight-compliance",
+  "test-new-components",
+  "purpose-coverage",
+  "record-lore-for-significant",
+  "gates-for-routes"
+]);
+var VALID_CATEGORIES = ["discovery", "verification", "testing", "documentation", "collaboration", "security"];
+var VALID_TRIGGERS = ["preflight", "postflight", "on-stop", "on-commit"];
+var VALID_SEVERITIES = ["advisory", "warn", "block"];
+var VALID_CHECK_TYPES = ["tool-called", "file-exists", "file-modified", "lore-recorded", "symbols-registered", "gates-declared", "tests-exist", "git-clean"];
+function resolveHabitLocation(rootDir, habitId) {
+  const projectPath = path3.join(rootDir, HABITS_FILE);
+  const projectLocation = findInConfig(projectPath, habitId);
+  if (projectLocation) return { source: "project", ...projectLocation };
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  const globalPath = path3.join(home, ".paradigm", "habits.yaml");
+  const globalLocation = findInConfig(globalPath, habitId);
+  if (globalLocation) return { source: "global", ...globalLocation };
+  if (SEED_HABIT_IDS.has(habitId)) return { source: "seed", filePath: "", index: -1 };
+  return null;
+}
+function findInConfig(filePath, habitId) {
+  if (!fs2.existsSync(filePath)) return null;
+  try {
+    const content = fs2.readFileSync(filePath, "utf8");
+    const config = yaml2.load(content);
+    if (!config?.habits) return null;
+    const idx = config.habits.findIndex((h) => h.id === habitId);
+    if (idx === -1) return null;
+    return { filePath, index: idx };
+  } catch {
+    return null;
+  }
+}
+function loadConfigFile(filePath) {
+  const content = fs2.readFileSync(filePath, "utf8");
+  const config = yaml2.load(content);
+  if (!config.habits) config.habits = [];
+  if (!config.overrides) config.overrides = {};
+  return config;
+}
+function writeConfigFile(filePath, config) {
+  fs2.writeFileSync(filePath, yaml2.dump(config, { lineWidth: 80, noRefs: true }), "utf8");
+}
+function ensureProjectConfig(rootDir) {
+  const configPath = path3.join(rootDir, HABITS_FILE);
+  if (!fs2.existsSync(configPath)) {
+    const dir = path3.dirname(configPath);
+    if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+    const initial = { version: "1.0", habits: [], overrides: {} };
+    writeConfigFile(configPath, initial);
+  }
+  return configPath;
+}
+async function habitsListCommand(options) {
+  const rootDir = process.cwd();
+  let habits;
+  try {
+    habits = loadHabits(rootDir);
+  } catch (err) {
+    console.log(chalk.red("Failed to load habits:"), err.message);
+    return;
+  }
+  if (options.trigger) {
+    habits = habits.filter((h) => h.trigger === options.trigger);
+  }
+  if (options.category) {
+    habits = habits.filter((h) => h.category === options.category);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(habits, null, 2));
+    return;
+  }
+  const enabled = habits.filter((h) => h.enabled);
+  const disabled = habits.filter((h) => !h.enabled);
+  console.log(chalk.magenta(`
+  Habits (${enabled.length} active, ${disabled.length} disabled)
+`));
+  const triggers = ["preflight", "postflight", "on-stop", "on-commit"];
+  for (const trigger of triggers) {
+    const group = habits.filter((h) => h.trigger === trigger);
+    if (group.length === 0) continue;
+    console.log(chalk.cyan(`  ${trigger}:`));
+    for (const h of group) {
+      const status = h.enabled ? chalk.green("ON") : chalk.gray("OFF");
+      const severity = h.severity === "block" ? chalk.red(h.severity) : h.severity === "warn" ? chalk.yellow(h.severity) : chalk.gray(h.severity);
+      console.log(`    ${status} ${chalk.white(h.id)} [${severity}] - ${h.name}`);
+      console.log(chalk.gray(`       ${h.description}`));
+    }
+    console.log();
+  }
+  const projectConfig = path3.join(rootDir, HABITS_FILE);
+  if (fs2.existsSync(projectConfig)) {
+    console.log(chalk.gray(`  Config: ${HABITS_FILE}`));
+  } else {
+    console.log(chalk.gray(`  Config: using seed habits only (run 'paradigm habits init' to customize)`));
+  }
+  console.log();
+}
+async function habitsStatusCommand(options) {
+  const rootDir = process.cwd();
+  let habits;
+  try {
+    habits = loadHabits(rootDir);
+  } catch (err) {
+    console.log(chalk.red("Failed to load habits:"), err.message);
+    return;
+  }
+  const enabled = getEnabledHabits(habits);
+  let practiceData = null;
+  try {
+    const { SentinelStorage } = await import("./dist-GPQ4LAY3.js");
+    const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
+    if (fs2.existsSync(sentinelDir)) {
+      const storage = new SentinelStorage(sentinelDir);
+      const period = options.period || "30d";
+      const days = parseInt(period.replace("d", ""), 10) || 30;
+      const dateFrom = period === "all" ? void 0 : new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+      const compliance = storage.getComplianceRate({ dateFrom });
+      const events = storage.getPracticeEvents({ dateFrom, limit: 500 });
+      const catStats = /* @__PURE__ */ new Map();
+      for (const event of events) {
+        const cat = event.habitCategory;
+        const existing = catStats.get(cat) || { followed: 0, skipped: 0, partial: 0 };
+        existing[event.result]++;
+        catStats.set(cat, existing);
+      }
+      const byCategory = Array.from(catStats.entries()).map(([category, stats]) => {
+        const total = stats.followed + stats.skipped + stats.partial;
+        const rate = total > 0 ? Math.round((stats.followed + stats.partial * 0.5) / total * 100) : 100;
+        return { category, rate, total };
+      }).sort((a, b) => a.rate - b.rate);
+      practiceData = {
+        total: compliance.total,
+        followed: compliance.followed,
+        skipped: compliance.skipped,
+        partial: compliance.partial,
+        rate: compliance.rate,
+        byCategory
+      };
+    }
+  } catch {
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      habits: { total: habits.length, enabled: enabled.length },
+      practice: practiceData
+    }, null, 2));
+    return;
+  }
+  console.log(chalk.magenta("\n  Habits Practice Profile\n"));
+  console.log(chalk.white(`  Total habits: ${habits.length} (${enabled.length} active)`));
+  const byTrigger = /* @__PURE__ */ new Map();
+  for (const h of enabled) {
+    byTrigger.set(h.trigger, (byTrigger.get(h.trigger) || 0) + 1);
+  }
+  for (const [trigger, count] of byTrigger) {
+    console.log(chalk.gray(`    ${trigger}: ${count} habit(s)`));
+  }
+  console.log();
+  if (practiceData && practiceData.total > 0) {
+    const rateColor = practiceData.rate >= 80 ? chalk.green : practiceData.rate >= 60 ? chalk.yellow : chalk.red;
+    console.log(chalk.white(`  Compliance Rate: ${rateColor(`${practiceData.rate}%`)}`));
+    console.log(chalk.gray(`    Followed: ${practiceData.followed} | Skipped: ${practiceData.skipped} | Partial: ${practiceData.partial}`));
+    console.log(chalk.gray(`    Total events: ${practiceData.total}
+`));
+    if (practiceData.byCategory.length > 0) {
+      console.log(chalk.white("  By Category:"));
+      for (const cat of practiceData.byCategory) {
+        const catColor = cat.rate >= 80 ? chalk.green : cat.rate >= 60 ? chalk.yellow : chalk.red;
+        const bar = "\u2588".repeat(Math.round(cat.rate / 5)) + "\u2591".repeat(20 - Math.round(cat.rate / 5));
+        console.log(`    ${cat.category.padEnd(15)} ${catColor(bar)} ${catColor(`${cat.rate}%`)} (${cat.total})`);
+      }
+    }
+  } else {
+    console.log(chalk.gray("  No practice events recorded yet."));
+    console.log(chalk.gray("  Call paradigm_habits_check via MCP to start recording.\n"));
+  }
+  console.log();
+}
+async function habitsInitCommand(options) {
+  const rootDir = process.cwd();
+  const configPath = path3.join(rootDir, HABITS_FILE);
+  if (fs2.existsSync(configPath) && !options.force) {
+    console.log(chalk.yellow(`${HABITS_FILE} already exists. Use --force to overwrite.`));
+    return;
+  }
+  const dir = path3.dirname(configPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  const defaultConfig = {
+    version: "1.0",
+    habits: [],
+    overrides: {
+      "verify-before-done": {
+        severity: "warn"
+      }
+    }
+  };
+  const content = `# Paradigm Habits Configuration
+# See: paradigm habits list (for all seed habits)
+#
+# Seed habits are built-in and active by default.
+# Use 'overrides' to tune severity or disable specific habits.
+# Add custom habits in the 'habits' section.
+
+${yaml2.dump(defaultConfig, { lineWidth: 80, noRefs: true })}
+# Example custom habit:
+# habits:
+#   - id: my-custom-check
+#     name: "Custom Check"
+#     description: "Describe what this habit enforces"
+#     category: verification
+#     trigger: postflight
+#     severity: advisory
+#     check:
+#       type: tool-called
+#       params:
+#         tools: [paradigm_pm_postflight]
+#     enabled: true
+#
+# Override seed habits:
+# overrides:
+#   verify-before-done:
+#     severity: block      # Upgrade to blocking
+#   check-fragility:
+#     enabled: false        # Disable this habit
+`;
+  fs2.writeFileSync(configPath, content, "utf8");
+  invalidateHabitsCache(rootDir);
+  console.log(chalk.green(`Created ${HABITS_FILE}`));
+  console.log(chalk.gray("  10 seed habits are active by default."));
+  console.log(chalk.gray("  Use overrides section to tune severity or disable habits."));
+  console.log(chalk.gray("  Run `paradigm habits list` to see all habits.\n"));
+}
+async function habitsAddCommand(options) {
+  const rootDir = process.cwd();
+  const configPath = path3.join(rootDir, HABITS_FILE);
+  if (!fs2.existsSync(configPath)) {
+    console.log(chalk.yellow(`No ${HABITS_FILE} found. Run 'paradigm habits init' first.`));
+    return;
+  }
+  if (!VALID_CATEGORIES.includes(options.category)) {
+    console.log(chalk.red(`Invalid category: ${options.category}. Valid: ${VALID_CATEGORIES.join(", ")}`));
+    return;
+  }
+  if (!VALID_TRIGGERS.includes(options.trigger)) {
+    console.log(chalk.red(`Invalid trigger: ${options.trigger}. Valid: ${VALID_TRIGGERS.join(", ")}`));
+    return;
+  }
+  if (options.severity && !VALID_SEVERITIES.includes(options.severity)) {
+    console.log(chalk.red(`Invalid severity: ${options.severity}. Valid: ${VALID_SEVERITIES.join(", ")}`));
+    return;
+  }
+  const checkType = options.checkType || "tool-called";
+  if (!VALID_CHECK_TYPES.includes(checkType)) {
+    console.log(chalk.red(`Invalid check-type: ${checkType}. Valid: ${VALID_CHECK_TYPES.join(", ")}`));
+    return;
+  }
+  let config;
+  try {
+    const content = fs2.readFileSync(configPath, "utf8");
+    config = yaml2.load(content);
+    if (!config.habits) config.habits = [];
+  } catch (err) {
+    console.log(chalk.red("Failed to parse habits.yaml:"), err.message);
+    return;
+  }
+  const existingIds = /* @__PURE__ */ new Set([
+    ...config.habits.map((h) => h.id),
+    ...loadHabits(rootDir).map((h) => h.id)
+  ]);
+  if (existingIds.has(options.id)) {
+    console.log(chalk.yellow(`Habit "${options.id}" already exists.`));
+    return;
+  }
+  const tools = options.tools ? options.tools.split(",").map((t) => t.trim()) : [];
+  const patterns = options.patterns ? options.patterns.split(",").map((p) => p.trim()) : [];
+  const checkParams = {};
+  if (checkType === "tool-called" && tools.length > 0) checkParams.tools = tools;
+  if ((checkType === "file-exists" || checkType === "file-modified" || checkType === "tests-exist") && patterns.length > 0) {
+    checkParams.patterns = patterns;
+  }
+  const newHabit = {
+    id: options.id,
+    name: options.name,
+    description: options.description,
+    category: options.category,
+    trigger: options.trigger,
+    severity: options.severity || "advisory",
+    check: {
+      type: checkType,
+      params: checkParams
+    },
+    enabled: true
+  };
+  config.habits.push(newHabit);
+  writeConfigFile(configPath, config);
+  invalidateHabitsCache(rootDir);
+  console.log(chalk.green(`Added habit: ${options.id}`));
+  console.log(chalk.gray(`  Name: ${options.name}`));
+  console.log(chalk.gray(`  Category: ${options.category} | Trigger: ${options.trigger} | Severity: ${options.severity || "advisory"}`));
+  console.log(chalk.gray(`  Check: ${checkType}`));
+  if (tools.length > 0) console.log(chalk.gray(`  Tools: ${tools.join(", ")}`));
+  if (patterns.length > 0) console.log(chalk.gray(`  Patterns: ${patterns.join(", ")}`));
+  console.log();
+}
+async function habitsEditCommand(id, options) {
+  const rootDir = process.cwd();
+  if (options.category && !VALID_CATEGORIES.includes(options.category)) {
+    console.log(chalk.red(`Invalid category: ${options.category}. Valid: ${VALID_CATEGORIES.join(", ")}`));
+    return;
+  }
+  if (options.trigger && !VALID_TRIGGERS.includes(options.trigger)) {
+    console.log(chalk.red(`Invalid trigger: ${options.trigger}. Valid: ${VALID_TRIGGERS.join(", ")}`));
+    return;
+  }
+  if (options.severity && !VALID_SEVERITIES.includes(options.severity)) {
+    console.log(chalk.red(`Invalid severity: ${options.severity}. Valid: ${VALID_SEVERITIES.join(", ")}`));
+    return;
+  }
+  if (options.checkType && !VALID_CHECK_TYPES.includes(options.checkType)) {
+    console.log(chalk.red(`Invalid check-type: ${options.checkType}. Valid: ${VALID_CHECK_TYPES.join(", ")}`));
+    return;
+  }
+  const location = resolveHabitLocation(rootDir, id);
+  if (!location) {
+    console.log(chalk.red(`Habit not found: ${id}`));
+    return;
+  }
+  if (location.source === "seed") {
+    const nonOverrideFields = ["name", "description", "category", "trigger", "checkType", "patterns", "tools"];
+    const hasNonOverride = nonOverrideFields.some((f) => options[f] !== void 0);
+    if (hasNonOverride) {
+      console.log(chalk.yellow(`"${id}" is a seed habit. Only --severity and --enabled can be changed.`));
+      console.log(chalk.gray("  Other fields require creating a custom habit with the same functionality."));
+      return;
+    }
+    if (!options.severity && options.enabled === void 0) {
+      console.log(chalk.yellow("No changes specified. Use --severity or --enabled for seed habits."));
+      return;
+    }
+    const configPath = ensureProjectConfig(rootDir);
+    const config2 = loadConfigFile(configPath);
+    if (!config2.overrides) config2.overrides = {};
+    if (!config2.overrides[id]) config2.overrides[id] = {};
+    if (options.severity) config2.overrides[id].severity = options.severity;
+    if (options.enabled !== void 0) config2.overrides[id].enabled = options.enabled === "true";
+    writeConfigFile(configPath, config2);
+    invalidateHabitsCache(rootDir);
+    console.log(chalk.green(`Updated seed habit override: ${id}`));
+    if (options.severity) console.log(chalk.gray(`  Severity: ${options.severity}`));
+    if (options.enabled !== void 0) console.log(chalk.gray(`  Enabled: ${options.enabled}`));
+    console.log();
+    return;
+  }
+  const config = loadConfigFile(location.filePath);
+  const habit = config.habits[location.index];
+  if (options.name) habit.name = options.name;
+  if (options.description) habit.description = options.description;
+  if (options.category) habit.category = options.category;
+  if (options.trigger) habit.trigger = options.trigger;
+  if (options.severity) habit.severity = options.severity;
+  if (options.enabled !== void 0) habit.enabled = options.enabled === "true";
+  if (options.checkType) habit.check.type = options.checkType;
+  if (options.tools) habit.check.params.tools = options.tools.split(",").map((t) => t.trim());
+  if (options.patterns) habit.check.params.patterns = options.patterns.split(",").map((p) => p.trim());
+  config.habits[location.index] = habit;
+  writeConfigFile(location.filePath, config);
+  invalidateHabitsCache(rootDir);
+  const source = location.source === "global" ? "(global)" : "(project)";
+  console.log(chalk.green(`Updated habit: ${id} ${chalk.gray(source)}`));
+  console.log();
+}
+async function habitsRemoveCommand(id, options) {
+  const rootDir = process.cwd();
+  const location = resolveHabitLocation(rootDir, id);
+  if (!location) {
+    console.log(chalk.red(`Habit not found: ${id}`));
+    return;
+  }
+  if (location.source === "seed") {
+    console.log(chalk.yellow(`"${id}" is a seed habit and cannot be removed.`));
+    console.log(chalk.gray(`  Use: paradigm habits edit ${id} --enabled false`));
+    return;
+  }
+  const config = loadConfigFile(location.filePath);
+  const habit = config.habits[location.index];
+  if (!options.yes) {
+    console.log(chalk.yellow(`
+Will remove habit: ${habit.name} (${id})`));
+    console.log(chalk.gray(`  Source: ${location.source} (${location.filePath})`));
+    console.log(chalk.gray(`  Use --yes to confirm.
+`));
+    return;
+  }
+  config.habits.splice(location.index, 1);
+  writeConfigFile(location.filePath, config);
+  invalidateHabitsCache(rootDir);
+  console.log(chalk.green(`Removed habit: ${id}`));
+  console.log();
+}
+async function habitsToggleCommand(id, action) {
+  const rootDir = process.cwd();
+  const enabled = action === "enable";
+  const location = resolveHabitLocation(rootDir, id);
+  if (!location) {
+    console.log(chalk.red(`Habit not found: ${id}`));
+    return;
+  }
+  if (location.source === "seed") {
+    const configPath = ensureProjectConfig(rootDir);
+    const config2 = loadConfigFile(configPath);
+    if (!config2.overrides) config2.overrides = {};
+    if (!config2.overrides[id]) config2.overrides[id] = {};
+    config2.overrides[id].enabled = enabled;
+    writeConfigFile(configPath, config2);
+    invalidateHabitsCache(rootDir);
+    console.log(chalk.green(`${enabled ? "Enabled" : "Disabled"} seed habit: ${id}`));
+    console.log();
+    return;
+  }
+  const config = loadConfigFile(location.filePath);
+  config.habits[location.index].enabled = enabled;
+  writeConfigFile(location.filePath, config);
+  invalidateHabitsCache(rootDir);
+  console.log(chalk.green(`${enabled ? "Enabled" : "Disabled"} habit: ${id}`));
+  console.log();
+}
+async function habitsCheckCommand(options) {
+  const rootDir = process.cwd();
+  const trigger = options.trigger;
+  let habits;
+  try {
+    habits = loadHabits(rootDir);
+  } catch (err) {
+    console.log(chalk.red("Failed to load habits:"), err.message);
+    process.exitCode = 1;
+    return;
+  }
+  const filesModified = options.files ? options.files.split(",").map((f) => f.trim()).filter(Boolean) : getGitModifiedFiles(rootDir);
+  const symbolsTouched = options.symbols ? options.symbols.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  let gitClean;
+  try {
+    const status = execSync("git status --porcelain", {
+      cwd: rootDir,
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    gitClean = status.trim() === "";
+  } catch {
+  }
+  const portalPath = path3.join(rootDir, "portal.yaml");
+  let hasPortalRoutes = false;
+  if (fs2.existsSync(portalPath)) {
+    try {
+      const portalContent = fs2.readFileSync(portalPath, "utf8");
+      const portal = yaml2.load(portalContent);
+      hasPortalRoutes = portal?.routes != null && Object.keys(portal.routes).length > 0;
+    } catch {
+    }
+  }
+  const evalContext = buildEvaluationContext({
+    toolsCalled: [],
+    // CLI has no session breadcrumbs
+    filesModified,
+    symbolsTouched,
+    loreRecorded: false,
+    hasPortalRoutes,
+    taskAddsRoutes: false,
+    gitClean
+  });
+  const evaluation = evaluateHabits(habits, trigger, evalContext);
+  let recordedCount = 0;
+  if (options.record && evaluation.evaluations.length > 0) {
+    try {
+      const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
+      if (fs2.existsSync(sentinelDir)) {
+        const { SentinelStorage } = await import("./dist-GPQ4LAY3.js");
+        const storage = new SentinelStorage(sentinelDir);
+        for (const e of evaluation.evaluations) {
+          storage.recordPracticeEvent({
+            habitId: e.habit.id,
+            habitCategory: e.habit.category,
+            result: e.result,
+            engineer: "agent",
+            sessionId: `cli-${Date.now().toString(36)}`,
+            symbolsTouched,
+            filesModified,
+            notes: e.reason
+          });
+          recordedCount++;
+        }
+      }
+    } catch {
+    }
+  }
+  const markerPath = path3.join(rootDir, ".paradigm", ".habits-blocking");
+  try {
+    if (trigger === "on-stop" && evaluation.blocksCompletion) {
+      const blocking = evaluation.evaluations.filter((e) => e.result === "skipped" && e.habit.severity === "block").map((e) => `${e.habit.name}: ${e.reason}`);
+      fs2.writeFileSync(markerPath, blocking.join("\n"), "utf8");
+    } else if (trigger === "on-stop") {
+      if (fs2.existsSync(markerPath)) fs2.unlinkSync(markerPath);
+    }
+  } catch {
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      trigger,
+      evaluation: {
+        total: evaluation.summary.total,
+        followed: evaluation.summary.followed,
+        skipped: evaluation.summary.skipped,
+        partial: evaluation.summary.partial,
+        blockingViolations: evaluation.summary.blockingViolations,
+        blocksCompletion: evaluation.blocksCompletion
+      },
+      habits: evaluation.evaluations.map((e) => ({
+        id: e.habit.id,
+        name: e.habit.name,
+        category: e.habit.category,
+        severity: e.habit.severity,
+        result: e.result,
+        reason: e.reason,
+        evidence: e.evidence
+      })),
+      recorded: recordedCount
+    }, null, 2));
+  } else {
+    printHumanReadableResults(evaluation, recordedCount);
+  }
+  if (evaluation.blocksCompletion) {
+    process.exitCode = 1;
+  }
+}
+function getGitModifiedFiles(rootDir) {
+  try {
+    const output = execSync("git diff --name-only HEAD", {
+      cwd: rootDir,
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    return output.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function printHumanReadableResults(evaluation, recordedCount) {
+  const { summary } = evaluation;
+  console.log(chalk.magenta(`
+  Habits Check (${evaluation.trigger})
+`));
+  for (const e of evaluation.evaluations) {
+    const icon = e.result === "followed" ? chalk.green("PASS") : e.result === "skipped" ? e.habit.severity === "block" ? chalk.red("BLOCK") : chalk.yellow("SKIP") : chalk.gray("PART");
+    const severity = e.habit.severity === "block" ? chalk.red(e.habit.severity) : e.habit.severity === "warn" ? chalk.yellow(e.habit.severity) : chalk.gray(e.habit.severity);
+    console.log(`  ${icon} ${chalk.white(e.habit.id)} [${severity}]`);
+    console.log(chalk.gray(`       ${e.reason}`));
+  }
+  console.log();
+  console.log(chalk.white(`  Summary: ${summary.followed} followed, ${summary.skipped} skipped, ${summary.partial} partial`));
+  if (summary.blockingViolations > 0) {
+    console.log(chalk.red(`  ${summary.blockingViolations} blocking violation(s) \u2014 exit code 1`));
+  }
+  if (recordedCount > 0) {
+    console.log(chalk.gray(`  Recorded ${recordedCount} practice event(s) to Sentinel`));
+  }
+  console.log();
+}
+export {
+  habitsAddCommand,
+  habitsCheckCommand,
+  habitsEditCommand,
+  habitsInitCommand,
+  habitsListCommand,
+  habitsRemoveCommand,
+  habitsStatusCommand,
+  habitsToggleCommand
+};