@a-company/paradigm 5.11.0 → 5.21.0

package/dist/habits-OL5NGPXO.js

@@ -1,1405 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.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
-  },
-  {
-    id: "commit-message-symbols",
-    name: "Commit Message Format",
-    description: "Commit messages should follow type(#symbol): format and include a Symbols: trailer",
-    category: "documentation",
-    trigger: "on-commit",
-    severity: "advisory",
-    check: {
-      type: "commit-message-format",
-      params: {
-        messagePatterns: ["^(feat|fix|refactor|chore|docs|test|style|perf|ci|build)\\(", "Symbols:"]
-      }
-    },
-    enabled: true
-  },
-  {
-    id: "flow-coverage-for-multi-component",
-    name: "Flow Coverage",
-    description: "Changes spanning 3+ components should have a documented $flow",
-    category: "documentation",
-    trigger: "postflight",
-    severity: "advisory",
-    check: {
-      type: "flow-coverage",
-      params: {
-        minSteps: 3
-      }
-    },
-    enabled: true
-  },
-  {
-    id: "context-session-awareness",
-    name: "Context Awareness",
-    description: "Use session recovery or context check tools for session continuity",
-    category: "discovery",
-    trigger: "preflight",
-    severity: "advisory",
-    check: {
-      type: "context-checked",
-      params: {
-        contextTools: ["paradigm_context_check", "paradigm_session_recover", "paradigm_session_checkpoint"]
-      }
-    },
-    enabled: true
-  },
-  {
-    id: "aspect-anchors-valid",
-    name: "Aspect Anchors Valid",
-    description: "Aspects touched during the session should have their code anchors validated",
-    category: "verification",
-    trigger: "postflight",
-    severity: "advisory",
-    check: {
-      type: "aspect-anchored",
-      params: {
-        checkAnchors: true
-      }
-    },
-    enabled: true
-  }
-];
-
-// src/core/habits/loader.ts
-var SEED_HABITS = seed_habits_default;
-var DEFAULT_HABITS_CACHE_TTL_MS = 30 * 1e3;
-function getHabitsCacheTtl(rootDir) {
-  try {
-    const configPath = path.join(rootDir, ".paradigm", "config.yaml");
-    if (fs.existsSync(configPath)) {
-      const content = fs.readFileSync(configPath, "utf8");
-      const config = yaml.load(content);
-      const limits = config?.limits;
-      if (limits?.habitsCacheTtlMs && typeof limits.habitsCacheTtlMs === "number") {
-        return limits.habitsCacheTtlMs;
-      }
-    }
-  } catch {
-  }
-  return DEFAULT_HABITS_CACHE_TTL_MS;
-}
-var habitsCache = /* @__PURE__ */ new Map();
-function loadHabits(rootDir) {
-  const absoluteRoot = path.resolve(rootDir);
-  const cached = habitsCache.get(absoluteRoot);
-  const ttl = getHabitsCacheTtl(absoluteRoot);
-  if (cached && Date.now() - cached.loadedAt < ttl) {
-    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 home = process.env.HOME || process.env.USERPROFILE || "~";
-  const globalConfig = loadHabitsYaml(path.join(home, ".paradigm", "habits.yaml"));
-  if (globalConfig) {
-    mergeHabits(habitsById, globalConfig);
-  }
-  const globalHabitFiles = loadHabitFiles(path.join(home, ".paradigm", "habits"));
-  for (const habit of globalHabitFiles) {
-    habitsById.set(habit.id, habit);
-  }
-  const projectConfig = loadHabitsYaml(path.join(rootDir, ".paradigm", "habits.yaml"));
-  if (projectConfig) {
-    mergeHabits(habitsById, projectConfig);
-  }
-  const projectHabitFiles = loadHabitFiles(path.join(rootDir, ".paradigm", "habits"));
-  for (const habit of projectHabitFiles) {
-    habitsById.set(habit.id, habit);
-  }
-  return Array.from(habitsById.values());
-}
-function loadHabitFiles(dir) {
-  if (!fs.existsSync(dir)) return [];
-  try {
-    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".habit")).sort();
-    const habits = [];
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(path.join(dir, file), "utf8");
-        const habit = yaml.load(content);
-        if (habit?.id && habit?.name) {
-          habits.push(habit);
-        }
-      } catch {
-      }
-    }
-    return habits;
-  } catch {
-    return [];
-  }
-}
-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);
-    case "commit-message-format":
-      return evaluateCommitMessageFormat(habit, context);
-    case "flow-coverage":
-      return evaluateFlowCoverage(habit, context);
-    case "context-checked":
-      return evaluateContextChecked(habit, context);
-    case "aspect-anchored":
-      return evaluateAspectAnchored(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 evaluateCommitMessageFormat(habit, context) {
-  if (!context.commitMessage) {
-    return {
-      habit,
-      result: "followed",
-      reason: "No commit message to check (not a commit trigger)"
-    };
-  }
-  const patterns = habit.check.params.messagePatterns || [
-    "^(feat|fix|refactor|chore|docs|test|style|perf|ci|build)\\(",
-    "Symbols:"
-  ];
-  const matchedPatterns = patterns.filter(
-    (p) => new RegExp(p, "m").test(context.commitMessage)
-  );
-  if (matchedPatterns.length === patterns.length) {
-    return {
-      habit,
-      result: "followed",
-      reason: "Commit message matches all required patterns",
-      evidence: matchedPatterns
-    };
-  }
-  if (matchedPatterns.length > 0) {
-    const missing = patterns.filter(
-      (p) => !new RegExp(p, "m").test(context.commitMessage)
-    );
-    return {
-      habit,
-      result: "partial",
-      reason: `Commit message matches ${matchedPatterns.length}/${patterns.length} patterns. Missing: ${missing.join(", ")}`
-    };
-  }
-  return {
-    habit,
-    result: "skipped",
-    reason: "Commit message does not match required format patterns"
-  };
-}
-function evaluateFlowCoverage(habit, context) {
-  const componentSymbols = context.symbolsTouched.filter(
-    (s) => s.startsWith("#")
-  );
-  if (componentSymbols.length < 3) {
-    return {
-      habit,
-      result: "followed",
-      reason: "Fewer than 3 components touched \u2014 flow not required"
-    };
-  }
-  if (context.hasFlowCoverage) {
-    return {
-      habit,
-      result: "followed",
-      reason: "Flow coverage exists for multi-component changes"
-    };
-  }
-  const flowTools = [
-    "paradigm_flow_validate",
-    "paradigm_flows_affected",
-    "paradigm_purpose_add_flow"
-  ];
-  const calledFlowTools = flowTools.filter(
-    (t) => context.toolsCalled.includes(t)
-  );
-  if (calledFlowTools.length > 0) {
-    return {
-      habit,
-      result: "followed",
-      reason: `Flow tools called: ${calledFlowTools.join(", ")}`,
-      evidence: calledFlowTools
-    };
-  }
-  return {
-    habit,
-    result: "skipped",
-    reason: `${componentSymbols.length} components touched without flow coverage or flow tools called`,
-    evidence: componentSymbols.slice(0, 5)
-  };
-}
-function evaluateContextChecked(habit, context) {
-  const contextTools = habit.check.params.contextTools || [
-    "paradigm_context_check",
-    "paradigm_session_recover",
-    "paradigm_session_checkpoint"
-  ];
-  const calledTools = contextTools.filter(
-    (t) => context.toolsCalled.includes(t)
-  );
-  if (calledTools.length > 0) {
-    return {
-      habit,
-      result: "followed",
-      reason: `Context tools called: ${calledTools.join(", ")}`,
-      evidence: calledTools
-    };
-  }
-  if (context.filesModified.length === 0 && context.symbolsTouched.length === 0) {
-    return {
-      habit,
-      result: "followed",
-      reason: "No modifications made, context check not applicable"
-    };
-  }
-  return {
-    habit,
-    result: "skipped",
-    reason: "No context/session tools called during session"
-  };
-}
-function evaluateAspectAnchored(habit, context) {
-  const aspectSymbols = context.symbolsTouched.filter(
-    (s) => s.startsWith("~")
-  );
-  if (aspectSymbols.length === 0) {
-    return {
-      habit,
-      result: "followed",
-      reason: "No aspects touched"
-    };
-  }
-  if (context.aspectAnchorsValid === true) {
-    return {
-      habit,
-      result: "followed",
-      reason: "Aspect anchors validated and valid"
-    };
-  }
-  if (context.toolsCalled.includes("paradigm_aspect_check")) {
-    return {
-      habit,
-      result: "followed",
-      reason: "paradigm_aspect_check was called to validate anchors"
-    };
-  }
-  return {
-    habit,
-    result: "skipped",
-    reason: `${aspectSymbols.length} aspect(s) touched without anchor validation`,
-    evidence: aspectSymbols.slice(0, 5)
-  };
-}
-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,
-    commitMessage: params.commitMessage,
-    hasFlowCoverage: params.hasFlowCoverage,
-    aspectAnchorsValid: params.aspectAnchorsValid
-  };
-}
-
-// 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-QK4SQAK7.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-QK4SQAK7.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
-};