@a-company/paradigm 3.1.0 → 3.1.4

package/dist/mcp.js

@@ -525,15 +525,15 @@ var require_sql_wasm = __commonJS({
         "undefined" != typeof __filename ? ya = __filename : ba && (ya = self.location.href);
         var za = "", Aa, Ba;
         if (ca) {
-          var fs26 = __require("fs");
+          var fs27 = __require("fs");
           za = __dirname + "/";
           Ba = (a) => {
             a = Ca(a) ? new URL(a) : a;
-            return fs26.readFileSync(a);
+            return fs27.readFileSync(a);
           };
           Aa = async (a) => {
             a = Ca(a) ? new URL(a) : a;
-            return fs26.readFileSync(a, void 0);
+            return fs27.readFileSync(a, void 0);
           };
           1 < process.argv.length && (wa = process.argv[1].replace(/\\/g, "/"));
           process.argv.slice(2);
@@ -815,7 +815,7 @@ var require_sql_wasm = __commonJS({
               if (ca) {
                 var b = Buffer.alloc(256), c = 0, d = process.stdin.fd;
                 try {
-                  c = fs26.readSync(d, b, 0, 256);
+                  c = fs27.readSync(d, b, 0, 256);
                 } catch (e) {
                   if (e.toString().includes("EOF")) c = 0;
                   else throw e;
@@ -3986,6 +3986,7 @@ var SessionTracker = class {
   session;
   rootDir = null;
   _recovered = false;
+  lastLoreEntryId = null;
   constructor() {
     this.session = this.createNewSession();
   }
@@ -4163,6 +4164,18 @@ var SessionTracker = class {
     } catch {
     }
   }
+  /**
+   * Set the last lore entry ID recorded in this session
+   */
+  setLastLoreEntryId(id) {
+    this.lastLoreEntryId = id;
+  }
+  /**
+   * Get the last lore entry ID recorded in this session
+   */
+  getLastLoreEntryId() {
+    return this.lastLoreEntryId;
+  }
   /**
    * Check whether auto-recovery has already fired this session.
    */
@@ -4278,8 +4291,8 @@ var SessionTracker = class {
    * Extract resource type from URI
    */
   extractResourceType(uri) {
-    const path30 = uri.replace("paradigm://", "");
-    const firstPart = path30.split("/")[0];
+    const path31 = uri.replace("paradigm://", "");
+    const firstPart = path31.split("/")[0];
     return firstPart || "unknown";
   }
   /**
@@ -4393,6 +4406,7 @@ var SessionTracker = class {
   reset() {
     this.session = this.createNewSession();
     this._recovered = false;
+    this.lastLoreEntryId = null;
   }
 };
 var tracker = null;
@@ -6989,7 +7003,7 @@ function navigateExplore(config, target, rootDir) {
   }
   if (result.paths.length === 0) {
     const areaSymbols = Object.entries(config.symbols).filter(
-      ([sym, path30]) => sym.toLowerCase().includes(targetLower) || path30.toLowerCase().includes(targetLower)
+      ([sym, path31]) => sym.toLowerCase().includes(targetLower) || path31.toLowerCase().includes(targetLower)
     ).slice(0, 10);
     result.paths = [...new Set(areaSymbols.map(([, p]) => p))];
     result.symbols = areaSymbols.map(([s]) => s);
@@ -12081,6 +12095,10 @@ async function handleTagsTool(name, args, ctx) {
   }
 }
 
+// ../paradigm-mcp/src/tools/purpose-portal.ts
+import * as fs21 from "fs";
+import * as path23 from "path";
+
 // ../paradigm-mcp/src/utils/purpose-writer.ts
 import * as fs19 from "fs";
 import * as path21 from "path";
@@ -13053,6 +13071,21 @@ async function handleAddAspect(args, ctx, reloadContext2) {
     }
   }
   const filePath = resolvePurposeFilePath(purposeFile, ctx.rootDir);
+  const purposeDir = path23.dirname(filePath);
+  for (const anchor of anchors) {
+    const anchorFile = anchor.replace(/:.*$/, "");
+    const resolved = path23.resolve(purposeDir, anchorFile);
+    if (!fs21.existsSync(resolved)) {
+      const rootResolved = path23.resolve(ctx.rootDir, anchorFile);
+      if (fs21.existsSync(rootResolved)) {
+        const corrected = path23.relative(purposeDir, rootResolved);
+        const idx = anchors.indexOf(anchor);
+        anchors[idx] = anchor.replace(anchorFile, corrected);
+      } else {
+        return err(`Anchor file not found: "${anchorFile}". Anchors must be relative to the .purpose file directory (${purposeDir}).`);
+      }
+    }
+  }
   const data = readPurposeFile(filePath);
   if (!data.aspects) data.aspects = {};
   const bareId = stripSymbolPrefix(id);
@@ -13452,12 +13485,12 @@ async function handleValidate(args, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/pm.ts
-import * as fs22 from "fs";
-import * as path25 from "path";
+import * as fs23 from "fs";
+import * as path26 from "path";
 
 // ../paradigm-mcp/src/utils/habits-loader.ts
-import * as fs21 from "fs";
-import * as path23 from "path";
+import * as fs22 from "fs";
+import * as path24 from "path";
 import * as yaml13 from "js-yaml";
 var SEED_HABITS = [
   {
@@ -13564,7 +13597,7 @@ var SEED_HABITS = [
 var HABITS_CACHE_TTL_MS = 30 * 1e3;
 var habitsCache = /* @__PURE__ */ new Map();
 function loadHabits(rootDir) {
-  const absoluteRoot = path23.resolve(rootDir);
+  const absoluteRoot = path24.resolve(rootDir);
   const cached = habitsCache.get(absoluteRoot);
   if (cached && Date.now() - cached.loadedAt < HABITS_CACHE_TTL_MS) {
     return cached.habits;
@@ -13579,16 +13612,16 @@ function loadHabitsFresh(rootDir) {
     habitsById.set(seed.id, { ...seed });
   }
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  const globalConfig = loadHabitsYaml(path23.join(home, ".paradigm", "habits.yaml"));
+  const globalConfig = loadHabitsYaml(path24.join(home, ".paradigm", "habits.yaml"));
   if (globalConfig) mergeHabits(habitsById, globalConfig);
-  const projectConfig = loadHabitsYaml(path23.join(rootDir, ".paradigm", "habits.yaml"));
+  const projectConfig = loadHabitsYaml(path24.join(rootDir, ".paradigm", "habits.yaml"));
   if (projectConfig) mergeHabits(habitsById, projectConfig);
   return Array.from(habitsById.values());
 }
 function loadHabitsYaml(filePath) {
-  if (!fs21.existsSync(filePath)) return null;
+  if (!fs22.existsSync(filePath)) return null;
   try {
-    const content = fs21.readFileSync(filePath, "utf8");
+    const content = fs22.readFileSync(filePath, "utf8");
     return yaml13.load(content);
   } catch {
     return null;
@@ -13613,8 +13646,11 @@ function mergeHabits(habitsById, config) {
 function getHabitsByTrigger(habits, trigger) {
   return habits.filter((h) => h.enabled && h.trigger === trigger);
 }
-function evaluateHabits(habits, trigger, context2) {
-  const activeHabits = getHabitsByTrigger(habits, trigger);
+function evaluateHabits(habits, trigger, context2, platform2) {
+  let activeHabits = getHabitsByTrigger(habits, trigger);
+  if (platform2) {
+    activeHabits = activeHabits.filter((h) => !h.platforms || h.platforms.includes(platform2));
+  }
   const evaluations = activeHabits.map((h) => evaluateHabit(h, context2));
   const followed = evaluations.filter((e) => e.result === "followed").length;
   const skipped = evaluations.filter((e) => e.result === "skipped").length;
@@ -13637,7 +13673,8 @@ function buildEvaluationContext(params) {
     loreRecorded: params.loreRecorded || false,
     hasPortalRoutes: params.hasPortalRoutes || false,
     taskAddsRoutes: params.taskAddsRoutes || false,
-    taskDescription: params.taskDescription
+    taskDescription: params.taskDescription,
+    gitClean: params.gitClean
   };
 }
 function evaluateHabit(habit, ctx) {
@@ -13646,6 +13683,8 @@ function evaluateHabit(habit, ctx) {
       return evalToolCalled(habit, ctx);
     case "file-exists":
       return evalFileExists(habit, ctx);
+    case "file-modified":
+      return evalFileModified(habit, ctx);
     case "lore-recorded":
       return evalLoreRecorded(habit, ctx);
     case "symbols-registered":
@@ -13654,6 +13693,8 @@ function evaluateHabit(habit, ctx) {
       return evalGatesDeclared(habit, ctx);
     case "tests-exist":
       return evalTestsExist(habit, ctx);
+    case "git-clean":
+      return evalGitClean(habit, ctx);
     default:
       return { habit, result: "partial", reason: `Unknown check: ${habit.check.type}` };
   }
@@ -13722,14 +13763,36 @@ function evalTestsExist(habit, ctx) {
   if (src.length === 0) return { habit, result: "followed", reason: "No source files to test" };
   return { habit, result: "partial", reason: `${src.length} source file(s), no test files updated`, evidence: src.slice(0, 5) };
 }
+function evalFileModified(habit, ctx) {
+  if (ctx.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 = ctx.filesModified.filter(
+    (f) => patterns.some((p) => f.includes(p) || path24.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 evalGitClean(habit, ctx) {
+  if (ctx.filesModified.length === 0) return { habit, result: "followed", reason: "No files modified" };
+  if (ctx.gitClean === void 0) {
+    return { habit, result: "partial", reason: "Git status not available" };
+  }
+  if (ctx.gitClean) {
+    return { habit, result: "followed", reason: "Working tree is clean \u2014 changes committed" };
+  }
+  return { habit, result: "skipped", reason: "Uncommitted changes in working tree" };
+}
 
 // ../paradigm-mcp/src/utils/practice-store.ts
-import * as path24 from "path";
+import * as path25 from "path";
 var storageInstance = null;
 var storageInitialized2 = false;
 async function getStorage2(rootDir) {
   if (!storageInstance) {
-    const dbPath = path24.join(rootDir, ".paradigm", "sentinel", "sentinel.db");
+    const dbPath = path25.join(rootDir, ".paradigm", "sentinel", "sentinel.db");
     storageInstance = new SentinelStorage(dbPath);
     await storageInstance.ensureReady();
     storageInitialized2 = true;
@@ -13781,6 +13844,7 @@ async function recordEvaluationResults(rootDir, evaluations, context2) {
       result: eval_.result,
       engineer: context2.engineer,
       sessionId: context2.sessionId,
+      loreEntryId: context2.loreEntryId,
       taskDescription: context2.taskDescription,
       symbolsTouched: context2.symbolsTouched,
       filesModified: context2.filesModified,
@@ -13792,6 +13856,7 @@ async function recordEvaluationResults(rootDir, evaluations, context2) {
 }
 
 // ../paradigm-mcp/src/tools/pm.ts
+import { execSync } from "child_process";
 var SYMBOL_PATTERN2 = /[@#$%^!?&~][a-zA-Z][a-zA-Z0-9_-]*/g;
 var ROUTE_KEYWORDS = [
   "endpoint",
@@ -13942,17 +14007,36 @@ async function runPreflightCheck(task, ctx) {
     requiredChecks.push("signal-registration");
   }
   requiredChecks.push("purpose-coverage");
-  let activeHabits = [];
+  let habitsEvaluation = null;
   let recentCompliance = null;
   try {
     const habits = loadHabits(ctx.rootDir);
-    const preflightHabits = getHabitsByTrigger(habits, "preflight");
-    activeHabits = preflightHabits.map((h) => ({
-      id: h.id,
-      name: h.name,
-      category: h.category,
-      severity: h.severity
-    }));
+    const tracker2 = getSessionTracker();
+    const stats = tracker2.getStats();
+    const toolsCalled = [...new Set(stats.toolCalls.map((tc) => tc.toolName))];
+    const evalContext = buildEvaluationContext({
+      toolsCalled,
+      filesModified: [],
+      symbolsTouched: uniqueSymbols,
+      loreRecorded: false,
+      hasPortalRoutes: portalStatus.exists && portalStatus.routeCount > 0,
+      taskAddsRoutes,
+      taskDescription: task
+    });
+    const evalResult = evaluateHabits(habits, "preflight", evalContext);
+    habitsEvaluation = {
+      total: evalResult.summary.total,
+      followed: evalResult.summary.followed,
+      skipped: evalResult.summary.skipped,
+      partial: evalResult.summary.partial,
+      results: evalResult.evaluations.map((e) => ({
+        id: e.habit.id,
+        name: e.habit.name,
+        severity: e.habit.severity,
+        result: e.result,
+        reason: e.reason
+      }))
+    };
     const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3).toISOString();
     recentCompliance = await getComplianceRate(ctx.rootDir, { dateFrom: thirtyDaysAgo });
   } catch {
@@ -13966,12 +14050,11 @@ async function runPreflightCheck(task, ctx) {
     requiredChecks,
     recommendations: buildPreflightRecommendations(affectedSymbols, rippleAnalysis, portalStatus, taskAddsRoutes),
     habits: {
-      active: activeHabits,
+      evaluation: habitsEvaluation,
       recentCompliance: recentCompliance ? {
         rate: recentCompliance.rate,
         totalEvents: recentCompliance.total
-      } : null,
-      note: activeHabits.length > 0 ? `${activeHabits.length} preflight habit(s) active. Call paradigm_habits_check with trigger="preflight" to evaluate.` : "No habits configured. Run paradigm habits init to set up."
+      } : null
     }
   };
 }
@@ -14000,11 +14083,11 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
   const violations = [];
   const declaredRoutes = ctx.gateConfig?.routes ? Object.keys(ctx.gateConfig.routes) : [];
   for (const file of filesModified) {
-    const absPath = path25.isAbsolute(file) ? file : path25.join(ctx.rootDir, file);
-    if (!fs22.existsSync(absPath)) continue;
+    const absPath = path26.isAbsolute(file) ? file : path26.join(ctx.rootDir, file);
+    if (!fs23.existsSync(absPath)) continue;
     let content;
     try {
-      content = fs22.readFileSync(absPath, "utf-8");
+      content = fs23.readFileSync(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -14022,8 +14105,8 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
             violations.push({
               type: "missing-portal-gate",
               severity: "warning",
-              message: `Route "${routePath}" in ${path25.relative(ctx.rootDir, absPath)} not in portal.yaml`,
-              file: path25.relative(ctx.rootDir, absPath),
+              message: `Route "${routePath}" in ${path26.relative(ctx.rootDir, absPath)} not in portal.yaml`,
+              file: path26.relative(ctx.rootDir, absPath),
               suggestion: "Add route to portal.yaml with ^gates. Use paradigm_gates_for_route for suggestions."
             });
           } else if (!ctx.gateConfig && routePath.startsWith("/api/")) {
@@ -14031,7 +14114,7 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
               type: "missing-portal-gate",
               severity: "warning",
               message: `API route "${routePath}" found but no portal.yaml exists`,
-              file: path25.relative(ctx.rootDir, absPath),
+              file: path26.relative(ctx.rootDir, absPath),
               suggestion: "Create portal.yaml to declare gates for API routes."
             });
           }
@@ -14089,8 +14172,8 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
             });
           } else {
             for (const anchor of anchors) {
-              const filePath = path25.isAbsolute(anchor.path) ? anchor.path : path25.join(ctx.rootDir, anchor.path);
-              if (!fs22.existsSync(filePath)) {
+              const filePath = path26.isAbsolute(anchor.path) ? anchor.path : path26.join(ctx.rootDir, anchor.path);
+              if (!fs23.existsSync(filePath)) {
                 violations.push({
                   type: "stale-aspect",
                   severity: "warning",
@@ -14129,14 +14212,54 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
   let status = "pass";
   if (errors > 0) status = "violations";
   else if (warnings > 0) status = "warnings";
-  let habitReminder = null;
+  let habitsEvaluation = null;
   try {
     const habits = loadHabits(ctx.rootDir);
-    const postflightHabits = getHabitsByTrigger(habits, "postflight");
-    const stopHabits = getHabitsByTrigger(habits, "on-stop");
-    const totalActive = postflightHabits.length + stopHabits.length;
-    if (totalActive > 0) {
-      habitReminder = `${totalActive} habit(s) should be checked. Call paradigm_habits_check with trigger="postflight" to evaluate and record practice events.`;
+    const tracker2 = getSessionTracker();
+    const stats = tracker2.getStats();
+    const toolsCalled = [...new Set(stats.toolCalls.map((tc) => tc.toolName))];
+    const loreRecorded = toolsCalled.includes("paradigm_lore_record");
+    let gitClean;
+    try {
+      const gitStatus = execSync("git status --porcelain", {
+        cwd: ctx.rootDir,
+        encoding: "utf8",
+        timeout: 5e3
+      });
+      gitClean = gitStatus.trim() === "";
+    } catch {
+    }
+    const evalContext = buildEvaluationContext({
+      toolsCalled,
+      filesModified,
+      symbolsTouched,
+      loreRecorded,
+      hasPortalRoutes: ctx.gateConfig !== null && ctx.gateConfig.routes != null,
+      taskAddsRoutes: false,
+      gitClean
+    });
+    const evalResult = evaluateHabits(habits, "postflight", evalContext);
+    habitsEvaluation = {
+      trigger: "postflight",
+      total: evalResult.summary.total,
+      followed: evalResult.summary.followed,
+      skipped: evalResult.summary.skipped,
+      partial: evalResult.summary.partial,
+      blockingViolations: evalResult.summary.blockingViolations,
+      results: evalResult.evaluations.map((e) => ({
+        id: e.habit.id,
+        name: e.habit.name,
+        severity: e.habit.severity,
+        result: e.result,
+        reason: e.reason
+      }))
+    };
+    const markerPath = path26.join(ctx.rootDir, ".paradigm", ".habits-blocking");
+    if (evalResult.blocksCompletion) {
+      const blocking = evalResult.evaluations.filter((e) => e.result === "skipped" && e.habit.severity === "block").map((e) => `${e.habit.name}: ${e.reason}`);
+      fs23.writeFileSync(markerPath, blocking.join("\n"), "utf8");
+    } else if (fs23.existsSync(markerPath)) {
+      fs23.unlinkSync(markerPath);
     }
   } catch {
   }
@@ -14150,13 +14273,13 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
       errors
     },
     blocksCompletion: errors > 0,
-    habitReminder
+    habitsEvaluation
   };
 }
 
 // ../paradigm-mcp/src/tools/reindex.ts
-import * as fs23 from "fs";
-import * as path26 from "path";
+import * as fs24 from "fs";
+import * as path27 from "path";
 import * as yaml14 from "js-yaml";
 
 // ../probe/core/dist/generator.js
@@ -14495,10 +14618,10 @@ async function rebuildStaticFiles(rootDir, ctx) {
   } else {
     aggregation = await aggregateFromDirectory(rootDir);
   }
-  const projectName = ctx?.projectName || path26.basename(rootDir);
-  const paradigmDir = path26.join(rootDir, ".paradigm");
-  if (!fs23.existsSync(paradigmDir)) {
-    fs23.mkdirSync(paradigmDir, { recursive: true });
+  const projectName = ctx?.projectName || path27.basename(rootDir);
+  const paradigmDir = path27.join(rootDir, ".paradigm");
+  if (!fs24.existsSync(paradigmDir)) {
+    fs24.mkdirSync(paradigmDir, { recursive: true });
   }
   const scanIndex = generateScanIndex(
     {
@@ -14508,12 +14631,12 @@ async function rebuildStaticFiles(rootDir, ctx) {
     },
     { projectName }
   );
-  const scanIndexPath = path26.join(paradigmDir, "scan-index.json");
-  fs23.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
+  const scanIndexPath = path27.join(paradigmDir, "scan-index.json");
+  fs24.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
   filesWritten.push(".paradigm/scan-index.json");
   const navigatorData = buildNavigatorData(rootDir, aggregation);
-  const navigatorPath = path26.join(paradigmDir, "navigator.yaml");
-  fs23.writeFileSync(
+  const navigatorPath = path27.join(paradigmDir, "navigator.yaml");
+  fs24.writeFileSync(
     navigatorPath,
     yaml14.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
     "utf8"
@@ -14522,8 +14645,8 @@ async function rebuildStaticFiles(rootDir, ctx) {
   const flowIndex = generateFlowIndex(rootDir, aggregation.purposeFiles);
   let flowCount = 0;
   if (flowIndex && Object.keys(flowIndex.flows).length > 0) {
-    const flowIndexPath = path26.join(paradigmDir, "flow-index.json");
-    fs23.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    const flowIndexPath = path27.join(paradigmDir, "flow-index.json");
+    fs24.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
     filesWritten.push(".paradigm/flow-index.json");
     flowCount = Object.keys(flowIndex.flows).length;
   }
@@ -14552,7 +14675,7 @@ function buildNavigatorData(rootDir, aggregation) {
 function buildStructure(rootDir) {
   const structure = {};
   for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs23.existsSync(path26.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs24.existsSync(path27.join(rootDir, p)));
     if (existingPaths.length > 0) {
       const symbolInfo = Object.values(SYMBOL_CATEGORIES).find((s) => s.category === category);
       structure[category] = { paths: existingPaths, symbol: symbolInfo?.prefix || "@" };
@@ -14563,7 +14686,7 @@ function buildStructure(rootDir) {
 function buildKeyFiles(rootDir) {
   const keyFiles = {};
   for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs23.existsSync(path26.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs24.existsSync(path27.join(rootDir, p)));
     if (existingPaths.length > 0) {
       keyFiles[category] = existingPaths;
     }
@@ -14579,10 +14702,10 @@ function buildSkipPatterns(rootDir) {
     unless_testing: [...DEFAULT_SKIP_PATTERNS.unless_testing],
     unless_docs: [...DEFAULT_SKIP_PATTERNS.unless_docs]
   };
-  const gitignorePath = path26.join(rootDir, ".gitignore");
-  if (fs23.existsSync(gitignorePath)) {
+  const gitignorePath = path27.join(rootDir, ".gitignore");
+  if (fs24.existsSync(gitignorePath)) {
     try {
-      const content = fs23.readFileSync(gitignorePath, "utf8");
+      const content = fs24.readFileSync(gitignorePath, "utf8");
       const gitignorePatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).filter(
         (line) => line.endsWith("/") || line.includes("*") || ["node_modules", "dist", "build", ".cache"].some((p) => line.includes(p))
       ).slice(0, 20);
@@ -14631,11 +14754,11 @@ function buildSymbolMap(symbols, purposeFiles, _rootDir) {
       symbolMap[symbolId] = symbol.filePath;
     } else {
       const matchingPurpose = purposeFiles.find((pf) => {
-        const dir = path26.dirname(pf);
+        const dir = path27.dirname(pf);
         return dir.toLowerCase().includes(symbol.id.toLowerCase());
       });
       if (matchingPurpose) {
-        symbolMap[symbolId] = path26.dirname(matchingPurpose) + "/";
+        symbolMap[symbolId] = path27.dirname(matchingPurpose) + "/";
       }
     }
   }
@@ -14646,7 +14769,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
   const symbolToFlows = {};
   for (const filePath of purposeFiles) {
     try {
-      const content = fs23.readFileSync(filePath, "utf8");
+      const content = fs24.readFileSync(filePath, "utf8");
       const data = yaml14.load(content);
       if (!data?.flows) continue;
       if (Array.isArray(data.flows)) {
@@ -14660,7 +14783,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               id: flowId,
               description: flow.description || "",
               steps,
-              definedIn: path26.relative(rootDir, filePath)
+              definedIn: path27.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -14676,7 +14799,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               trigger: flowDef.trigger,
               steps,
               validation: flowDef.validation,
-              definedIn: path26.relative(rootDir, filePath)
+              definedIn: path27.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -14729,28 +14852,28 @@ function indexFlowSymbols(flowId, steps, symbolToFlows) {
 }
 
 // ../paradigm-mcp/src/utils/lore-loader.ts
-import * as fs24 from "fs";
-import * as path27 from "path";
+import * as fs25 from "fs";
+import * as path28 from "path";
 import * as yaml15 from "js-yaml";
 var LORE_DIR = ".paradigm/lore";
 var ENTRIES_DIR = "entries";
 var TIMELINE_FILE = "timeline.yaml";
 async function loadLoreEntries(rootDir, filter) {
-  const entriesPath = path27.join(rootDir, LORE_DIR, ENTRIES_DIR);
-  if (!fs24.existsSync(entriesPath)) {
+  const entriesPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs25.existsSync(entriesPath)) {
     return [];
   }
   migrateLegacyEntries(rootDir);
   const entries = [];
-  const dateDirs = fs24.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
+  const dateDirs = fs25.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
   for (const dateDir of dateDirs) {
     if (filter?.dateFrom && dateDir < filter.dateFrom.slice(0, 10)) continue;
     if (filter?.dateTo && dateDir > filter.dateTo.slice(0, 10)) continue;
-    const dirPath = path27.join(entriesPath, dateDir);
-    const files = fs24.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+    const dirPath = path28.join(entriesPath, dateDir);
+    const files = fs25.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
     for (const file of files) {
       try {
-        const content = fs24.readFileSync(path27.join(dirPath, file), "utf8");
+        const content = fs25.readFileSync(path28.join(dirPath, file), "utf8");
         const entry = yaml15.load(content);
         entries.push(entry);
       } catch {
@@ -14759,48 +14882,65 @@ async function loadLoreEntries(rootDir, filter) {
   }
   return filter ? applyFilter(entries, filter) : entries;
 }
+async function loadLoreEntry(rootDir, entryId) {
+  const dateMatch = entryId.match(/^L-(\d{4}-\d{2}-\d{2})-/);
+  if (dateMatch) {
+    const dateStr = dateMatch[1];
+    const entryPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+    if (fs25.existsSync(entryPath)) {
+      try {
+        const content = fs25.readFileSync(entryPath, "utf8");
+        return yaml15.load(content);
+      } catch {
+        return null;
+      }
+    }
+  }
+  const entries = await loadLoreEntries(rootDir);
+  return entries.find((e) => e.id === entryId) || null;
+}
 async function loadLoreTimeline(rootDir) {
-  const timelinePath = path27.join(rootDir, LORE_DIR, TIMELINE_FILE);
-  if (!fs24.existsSync(timelinePath)) {
+  const timelinePath = path28.join(rootDir, LORE_DIR, TIMELINE_FILE);
+  if (!fs25.existsSync(timelinePath)) {
     return null;
   }
   try {
-    const content = fs24.readFileSync(timelinePath, "utf8");
+    const content = fs25.readFileSync(timelinePath, "utf8");
     return yaml15.load(content);
   } catch {
     return null;
   }
 }
 async function recordLoreEntry(rootDir, entry) {
-  const lorePath = path27.join(rootDir, LORE_DIR);
+  const lorePath = path28.join(rootDir, LORE_DIR);
   const dateStr = entry.timestamp.slice(0, 10);
-  const datePath = path27.join(lorePath, ENTRIES_DIR, dateStr);
-  if (!fs24.existsSync(datePath)) {
-    fs24.mkdirSync(datePath, { recursive: true });
+  const datePath = path28.join(lorePath, ENTRIES_DIR, dateStr);
+  if (!fs25.existsSync(datePath)) {
+    fs25.mkdirSync(datePath, { recursive: true });
   }
   if (!entry.id) {
     entry.id = generateLoreId(rootDir, dateStr);
   }
-  const entryPath = path27.join(datePath, `${entry.id}.yaml`);
-  fs24.writeFileSync(entryPath, yaml15.dump(entry, { lineWidth: -1, noRefs: true }));
+  const entryPath = path28.join(datePath, `${entry.id}.yaml`);
+  fs25.writeFileSync(entryPath, yaml15.dump(entry, { lineWidth: -1, noRefs: true }));
   await rebuildTimeline(rootDir);
   return entry.id;
 }
 async function rebuildTimeline(rootDir) {
-  const lorePath = path27.join(rootDir, LORE_DIR);
-  const entriesPath = path27.join(lorePath, ENTRIES_DIR);
-  if (!fs24.existsSync(entriesPath)) return;
+  const lorePath = path28.join(rootDir, LORE_DIR);
+  const entriesPath = path28.join(lorePath, ENTRIES_DIR);
+  if (!fs25.existsSync(entriesPath)) return;
   migrateLegacyEntries(rootDir);
   const authors = /* @__PURE__ */ new Set();
   let entryCount = 0;
   let lastUpdated = "";
-  const dateDirs = fs24.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
+  const dateDirs = fs25.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
   for (const dateDir of dateDirs) {
-    const dirPath = path27.join(entriesPath, dateDir);
-    const files = fs24.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
+    const dirPath = path28.join(entriesPath, dateDir);
+    const files = fs25.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
     for (const file of files) {
       try {
-        const content = fs24.readFileSync(path27.join(dirPath, file), "utf8");
+        const content = fs25.readFileSync(path28.join(dirPath, file), "utf8");
         const entry = yaml15.load(content);
         authors.add(entry.author.id);
         entryCount++;
@@ -14812,10 +14952,10 @@ async function rebuildTimeline(rootDir) {
     }
   }
   let project = "unknown";
-  const configPath = path27.join(rootDir, ".paradigm", "config.yaml");
-  if (fs24.existsSync(configPath)) {
+  const configPath = path28.join(rootDir, ".paradigm", "config.yaml");
+  if (fs25.existsSync(configPath)) {
     try {
-      const config = yaml15.load(fs24.readFileSync(configPath, "utf8"));
+      const config = yaml15.load(fs25.readFileSync(configPath, "utf8"));
       project = config.project || config.name || "unknown";
     } catch {
     }
@@ -14827,31 +14967,31 @@ async function rebuildTimeline(rootDir) {
     last_updated: lastUpdated || (/* @__PURE__ */ new Date()).toISOString(),
     authors: Array.from(authors)
   };
-  if (!fs24.existsSync(lorePath)) {
-    fs24.mkdirSync(lorePath, { recursive: true });
+  if (!fs25.existsSync(lorePath)) {
+    fs25.mkdirSync(lorePath, { recursive: true });
   }
-  fs24.writeFileSync(
-    path27.join(lorePath, TIMELINE_FILE),
+  fs25.writeFileSync(
+    path28.join(lorePath, TIMELINE_FILE),
     yaml15.dump(timeline, { lineWidth: -1, noRefs: true })
   );
 }
 function migrateLegacyEntries(rootDir) {
-  const entriesPath = path27.join(rootDir, LORE_DIR, ENTRIES_DIR);
-  if (!fs24.existsSync(entriesPath)) return 0;
-  const rootFiles = fs24.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml") && !f.startsWith("."));
+  const entriesPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs25.existsSync(entriesPath)) return 0;
+  const rootFiles = fs25.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml") && !f.startsWith("."));
   let migrated = 0;
   for (const file of rootFiles) {
-    const filePath = path27.join(entriesPath, file);
-    const stat = fs24.statSync(filePath);
+    const filePath = path28.join(entriesPath, file);
+    const stat = fs25.statSync(filePath);
     if (!stat.isFile()) continue;
     try {
-      const content = fs24.readFileSync(filePath, "utf8");
+      const content = fs25.readFileSync(filePath, "utf8");
       const raw = yaml15.load(content);
       if (raw.author && typeof raw.author === "object") continue;
       const dateStr = typeof raw.date === "string" ? raw.date.slice(0, 10) : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const datePath = path27.join(entriesPath, dateStr);
-      if (!fs24.existsSync(datePath)) {
-        fs24.mkdirSync(datePath, { recursive: true });
+      const datePath = path28.join(entriesPath, dateStr);
+      if (!fs25.existsSync(datePath)) {
+        fs25.mkdirSync(datePath, { recursive: true });
       }
       const id = generateLoreId(rootDir, dateStr);
       const oldType = String(raw.type || "agent-session");
@@ -14876,17 +15016,58 @@ function migrateLegacyEntries(rootDir) {
         ...verification ? { verification } : {},
         tags: ["migrated", oldType]
       };
-      fs24.writeFileSync(
-        path27.join(datePath, `${id}.yaml`),
+      fs25.writeFileSync(
+        path28.join(datePath, `${id}.yaml`),
         yaml15.dump(v2Entry, { lineWidth: -1, noRefs: true })
       );
-      fs24.unlinkSync(filePath);
+      fs25.unlinkSync(filePath);
       migrated++;
     } catch {
     }
   }
   return migrated;
 }
+async function updateLoreEntry(rootDir, entryId, partial) {
+  const entry = await loadLoreEntry(rootDir, entryId);
+  if (!entry) return false;
+  const dateStr = entry.timestamp.slice(0, 10);
+  const entryPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+  if (!fs25.existsSync(entryPath)) return false;
+  if (partial.title !== void 0) entry.title = partial.title;
+  if (partial.summary !== void 0) entry.summary = partial.summary;
+  if (partial.type !== void 0) entry.type = partial.type;
+  if (partial.duration_minutes !== void 0) entry.duration_minutes = partial.duration_minutes;
+  if (partial.symbols_touched !== void 0) entry.symbols_touched = partial.symbols_touched;
+  if (partial.symbols_created !== void 0) entry.symbols_created = partial.symbols_created;
+  if (partial.files_created !== void 0) entry.files_created = partial.files_created;
+  if (partial.files_modified !== void 0) entry.files_modified = partial.files_modified;
+  if (partial.lines_added !== void 0) entry.lines_added = partial.lines_added;
+  if (partial.lines_removed !== void 0) entry.lines_removed = partial.lines_removed;
+  if (partial.commit !== void 0) entry.commit = partial.commit;
+  if (partial.decisions !== void 0) entry.decisions = partial.decisions;
+  if (partial.errors_encountered !== void 0) entry.errors_encountered = partial.errors_encountered;
+  if (partial.learnings !== void 0) entry.learnings = partial.learnings;
+  if (partial.verification !== void 0) entry.verification = partial.verification;
+  if (partial.tags !== void 0) entry.tags = partial.tags;
+  fs25.writeFileSync(entryPath, yaml15.dump(entry, { lineWidth: -1, noRefs: true }));
+  await rebuildTimeline(rootDir);
+  return true;
+}
+async function deleteLoreEntry(rootDir, entryId) {
+  const entry = await loadLoreEntry(rootDir, entryId);
+  if (!entry) return false;
+  const dateStr = entry.timestamp.slice(0, 10);
+  const entryPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+  if (!fs25.existsSync(entryPath)) return false;
+  fs25.unlinkSync(entryPath);
+  const dateDir = path28.dirname(entryPath);
+  const remaining = fs25.readdirSync(dateDir).filter((f) => f.endsWith(".yaml"));
+  if (remaining.length === 0) {
+    fs25.rmdirSync(dateDir);
+  }
+  await rebuildTimeline(rootDir);
+  return true;
+}
 function applyFilter(entries, filter) {
   let result = entries;
   if (filter.author) {
@@ -14923,11 +15104,11 @@ function applyFilter(entries, filter) {
   return result;
 }
 function generateLoreId(rootDir, dateStr) {
-  const datePath = path27.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
-  if (!fs24.existsSync(datePath)) {
+  const datePath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
+  if (!fs25.existsSync(datePath)) {
     return `L-${dateStr}-001`;
   }
-  const existing = fs24.readdirSync(datePath).filter((f) => f.startsWith("L-") && f.endsWith(".yaml")).map((f) => {
+  const existing = fs25.readdirSync(datePath).filter((f) => f.startsWith("L-") && f.endsWith(".yaml")).map((f) => {
     const match = f.match(/L-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
     return match ? parseInt(match[1], 10) : 0;
   });
@@ -15109,6 +15290,109 @@ function getLoreToolsList() {
         readOnlyHint: true,
         destructiveHint: false
       }
+    },
+    {
+      name: "paradigm_lore_get",
+      description: "Fetch a single lore entry by ID. Returns the full entry with all fields.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Lore entry ID (e.g., "L-2026-02-23-001")'
+          }
+        },
+        required: ["id"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_lore_update",
+      description: "Update an existing lore entry. Merges provided fields into the existing entry.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Lore entry ID to update"
+          },
+          title: { type: "string", description: "New title" },
+          summary: { type: "string", description: "New summary" },
+          type: {
+            type: "string",
+            enum: ["agent-session", "human-note", "decision", "review", "incident", "milestone"],
+            description: "New entry type"
+          },
+          symbols_touched: {
+            type: "array",
+            items: { type: "string" },
+            description: "Updated symbols list"
+          },
+          symbols_created: {
+            type: "array",
+            items: { type: "string" },
+            description: "Updated created symbols"
+          },
+          files_created: {
+            type: "array",
+            items: { type: "string" }
+          },
+          files_modified: {
+            type: "array",
+            items: { type: "string" }
+          },
+          lines_added: { type: "number" },
+          lines_removed: { type: "number" },
+          commit: { type: "string" },
+          duration_minutes: { type: "number" },
+          learnings: {
+            type: "array",
+            items: { type: "string" },
+            description: "Updated learnings"
+          },
+          verification: {
+            type: "object",
+            properties: {
+              status: { type: "string", enum: ["pass", "fail", "partial", "untested"] },
+              details: { type: "object" }
+            }
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" }
+          }
+        },
+        required: ["id"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_lore_delete",
+      description: "Delete a lore entry. Requires explicit confirmation to prevent accidental deletion.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Lore entry ID to delete"
+          },
+          confirm: {
+            type: "boolean",
+            description: "Must be true to proceed with deletion"
+          }
+        },
+        required: ["id", "confirm"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true
+      }
     }
   ];
 }
@@ -15199,6 +15483,7 @@ async function handleLoreTool(name, args, ctx) {
         habit_compliance
       };
       const id = await recordLoreEntry(ctx.rootDir, entry);
+      getSessionTracker().setLastLoreEntryId(id);
       return {
         handled: true,
         text: JSON.stringify({
@@ -15247,6 +15532,61 @@ async function handleLoreTool(name, args, ctx) {
         }, null, 2)
       };
     }
+    case "paradigm_lore_get": {
+      const id = args.id;
+      const entry = await loadLoreEntry(ctx.rootDir, id);
+      if (!entry) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Lore entry not found: ${id}` })
+        };
+      }
+      return {
+        handled: true,
+        text: JSON.stringify(entry, null, 2)
+      };
+    }
+    case "paradigm_lore_update": {
+      const id = args.id;
+      const { id: _, ...rest } = args;
+      const partial = {};
+      for (const [key, value] of Object.entries(rest)) {
+        if (value !== void 0) {
+          partial[key] = value;
+        }
+      }
+      const success = await updateLoreEntry(ctx.rootDir, id, partial);
+      return {
+        handled: true,
+        text: JSON.stringify({
+          success,
+          id,
+          message: success ? "Lore entry updated" : `Lore entry not found: ${id}`
+        })
+      };
+    }
+    case "paradigm_lore_delete": {
+      const id = args.id;
+      const confirm = args.confirm;
+      if (!confirm) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            success: false,
+            message: "Deletion requires confirm: true"
+          })
+        };
+      }
+      const success = await deleteLoreEntry(ctx.rootDir, id);
+      return {
+        handled: true,
+        text: JSON.stringify({
+          success,
+          id,
+          message: success ? "Lore entry deleted" : `Lore entry not found: ${id}`
+        })
+      };
+    }
     default:
       return { handled: false, text: "" };
   }
@@ -15271,10 +15611,38 @@ function summarizeEntry(entry) {
 }
 
 // ../paradigm-mcp/src/tools/habits.ts
-import * as fs25 from "fs";
-import * as path28 from "path";
+import * as fs26 from "fs";
+import * as path29 from "path";
+import { execSync as execSync2 } from "child_process";
 function getHabitsToolsList() {
   return [
+    {
+      name: "paradigm_habits_list",
+      description: "List all habit definitions: seed (built-in), global (~/.paradigm/habits.yaml), and project (.paradigm/habits.yaml). Shows what habits exist, their triggers, severity, and enabled state. Use to discover available habits before evaluating them.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          trigger: {
+            type: "string",
+            enum: ["preflight", "postflight", "on-commit", "on-stop"],
+            description: "Filter by trigger point"
+          },
+          category: {
+            type: "string",
+            enum: ["discovery", "verification", "testing", "documentation", "collaboration", "security"],
+            description: "Filter by category"
+          },
+          enabled: {
+            type: "boolean",
+            description: "Filter by enabled state (default: show all)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
     {
       name: "paradigm_habits_check",
       description: "Evaluate habit compliance for the current session and record practice events. Call at preflight (before implementing), postflight (after implementing), or on-stop (session end). Returns which habits were followed, skipped, or partially met.",
@@ -15283,7 +15651,7 @@ function getHabitsToolsList() {
         properties: {
           trigger: {
             type: "string",
-            enum: ["preflight", "postflight", "on-stop"],
+            enum: ["preflight", "postflight", "on-stop", "on-commit"],
             description: "When to evaluate: preflight (before task), postflight (after task), on-stop (session end)"
           },
           filesModified: {
@@ -15361,6 +15729,11 @@ function getHabitsToolsList() {
 }
 async function handleHabitsTool(name, args, ctx) {
   switch (name) {
+    case "paradigm_habits_list": {
+      const result = handleHabitsList(args, ctx);
+      trackToolCall(result.length, name);
+      return { text: result, handled: true };
+    }
     case "paradigm_habits_check": {
       const result = await handleHabitsCheck(args, ctx);
       trackToolCall(result.length, name);
@@ -15380,6 +15753,45 @@ async function handleHabitsTool(name, args, ctx) {
       return { text: "", handled: false };
   }
 }
+function handleHabitsList(args, ctx) {
+  const triggerFilter = args.trigger;
+  const categoryFilter = args.category;
+  const enabledFilter = args.enabled;
+  let habits = loadHabits(ctx.rootDir);
+  if (triggerFilter) habits = habits.filter((h) => h.trigger === triggerFilter);
+  if (categoryFilter) habits = habits.filter((h) => h.category === categoryFilter);
+  if (enabledFilter !== void 0) habits = habits.filter((h) => h.enabled === enabledFilter);
+  const byTrigger = {};
+  for (const h of habits) {
+    if (!byTrigger[h.trigger]) byTrigger[h.trigger] = [];
+    byTrigger[h.trigger].push(h);
+  }
+  return JSON.stringify(
+    {
+      total: habits.length,
+      filters: Object.fromEntries(
+        Object.entries({ trigger: triggerFilter, category: categoryFilter, enabled: enabledFilter }).filter(([, v]) => v !== void 0)
+      ),
+      byTrigger: Object.fromEntries(
+        Object.entries(byTrigger).map(([trigger, list]) => [
+          trigger,
+          list.map((h) => ({
+            id: h.id,
+            name: h.name,
+            description: h.description,
+            category: h.category,
+            severity: h.severity,
+            enabled: h.enabled,
+            check: { type: h.check.type, params: h.check.params },
+            platforms: h.platforms || null
+          }))
+        ])
+      )
+    },
+    null,
+    2
+  );
+}
 async function handleHabitsCheck(args, ctx) {
   const trigger = args.trigger;
   const filesModified = args.filesModified || [];
@@ -15403,6 +15815,16 @@ async function handleHabitsCheck(args, ctx) {
     "patch",
     "delete"
   ].some((k) => taskLower.includes(k));
+  let gitClean;
+  try {
+    const status = execSync2("git status --porcelain", {
+      cwd: ctx.rootDir,
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    gitClean = status.trim() === "";
+  } catch {
+  }
   const evalContext = buildEvaluationContext({
     toolsCalled,
     filesModified,
@@ -15410,12 +15832,15 @@ async function handleHabitsCheck(args, ctx) {
     loreRecorded,
     hasPortalRoutes: ctx.gateConfig !== null && ctx.gateConfig.routes != null,
     taskAddsRoutes,
-    taskDescription
+    taskDescription,
+    gitClean
   });
-  const evaluation = evaluateHabits(habits, trigger, evalContext);
+  const platform2 = "claude";
+  const evaluation = evaluateHabits(habits, trigger, evalContext, platform2);
   let recordedIds = [];
   if (shouldRecord && evaluation.evaluations.length > 0) {
     try {
+      const loreEntryId = tracker2.getLastLoreEntryId() ?? void 0;
       recordedIds = await recordEvaluationResults(
         ctx.rootDir,
         evaluation.evaluations.map((e) => ({
@@ -15427,6 +15852,7 @@ async function handleHabitsCheck(args, ctx) {
         {
           engineer: "agent",
           sessionId: stats.sessionId,
+          loreEntryId,
           taskDescription,
           symbolsTouched,
           filesModified
@@ -15435,13 +15861,13 @@ async function handleHabitsCheck(args, ctx) {
     } catch {
     }
   }
-  const markerPath = path28.join(ctx.rootDir, ".paradigm", ".habits-blocking");
+  const markerPath = path29.join(ctx.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}`);
-      fs25.writeFileSync(markerPath, blocking.join("\n"), "utf8");
+      fs26.writeFileSync(markerPath, blocking.join("\n"), "utf8");
     } else if (trigger === "on-stop") {
-      if (fs25.existsSync(markerPath)) fs25.unlinkSync(markerPath);
+      if (fs26.existsSync(markerPath)) fs26.unlinkSync(markerPath);
     }
   } catch {
   }
@@ -15499,6 +15925,12 @@ function buildRecommendations(evaluation) {
         case "purpose-coverage":
           recs.push(`Update .purpose files using paradigm_purpose_add_component.`);
           break;
+        case "changelog-updated":
+          recs.push(`Update CHANGELOG.md with the changes made in this phase.`);
+          break;
+        case "changes-committed":
+          recs.push(`Commit all changes to git before finishing this phase.`);
+          break;
         default:
           recs.push(`${e.habit.name}: ${e.reason}`);
       }
@@ -15648,8 +16080,8 @@ async function handlePracticeContext(args, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/fallback-grep.ts
-import * as path29 from "path";
-import { execSync } from "child_process";
+import * as path30 from "path";
+import { execSync as execSync3 } from "child_process";
 function grepForReferences(rootDir, symbol, options = {}) {
   const { maxResults = 20 } = options;
   const results = [];
@@ -15663,7 +16095,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
   let output = "";
   for (const cmd of grepCommands) {
     try {
-      output = execSync(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
+      output = execSync3(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
       if (output.trim()) break;
     } catch {
       continue;
@@ -15677,7 +16109,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
     const match = line.match(/^(.+?):(\d+):(.*)$/);
     if (match) {
       const [, filePath, lineNum, content] = match;
-      const relativePath = path29.relative(rootDir, filePath);
+      const relativePath = path30.relative(rootDir, filePath);
       let context2 = "unknown";
       if (relativePath.includes(".purpose") || relativePath.includes("portal.yaml")) {
         context2 = "purpose";