@a-company/paradigm 3.0.3 → 3.1.2

package/dist/{hooks-7TQIRXXS.js → hooks-YXPQV4SP.js}

@@ -3,7 +3,7 @@ import {
   hooksInstallCommand,
   hooksStatusCommand,
   hooksUninstallCommand
-} from "./chunk-4WR7X3FE.js";
+} from "./chunk-AQZSUGL3.js";
 import "./chunk-MO4EEYFW.js";
 export {
   hooksInstallCommand,

package/dist/index.js

@@ -109,7 +109,7 @@ ${chalk2.magenta("\u2569  ")}${chalk2.cyan("\u2534 \u2534\u2534\u2514\u2500\u253
 program.name("paradigm").description("Unified developer tools ecosystem").version(VERSION).addHelpText("before", banner);
 program.command("init").description("Initialize Paradigm in the current project").option("-f, --force", "Overwrite existing files").option("--name <name>", "Project name").option("--ide <ide>", "Target IDE: cursor, copilot, windsurf, claude").option("--migrate", "Output migration prompt for existing IDE files").option("--quick", "Non-interactive mode with smart defaults").option("--dry-run", "Show what would be created without creating").action(initCommand);
 program.command("shift").description("Full project setup in one command (init + team init + scan + sync all IDEs + doctor)").option("-f, --force", "Reinitialize even if already setup").option("-q, --quick", "Skip slow operations (scan)").option("--verify", "Run health checks after setup").option("--ide <ide>", "Target specific IDE instead of all").option("--configure-models", "Force model configuration prompts for team agents").action(async (options) => {
-  const { shiftCommand } = await import("./shift-NABNKPGL.js");
+  const { shiftCommand } = await import("./shift-JDBRTHWO.js");
   await shiftCommand(options);
 });
 program.command("setup [path]").description("Interactive setup wizard for Paradigm").option("-y, --yes", "Accept all defaults (non-interactive)").option("-f, --force", "Overwrite existing .paradigm config").action(async (path2, options) => {
@@ -470,118 +470,171 @@ historyCmd.option("--json", "Output as JSON").action(async (options) => {
 });
 var hooksCmd = program.command("hooks").description("Git hooks for automatic history capture");
 hooksCmd.command("install").description("Install git hooks, Claude Code hooks, and Cursor hooks").option("-f, --force", "Overwrite existing hooks").option("--post-commit", "Only install post-commit hook").option("--pre-push", "Only install pre-push hook").option("--claude-code", "Only install Claude Code hooks (stop + pre-commit)").option("--cursor", "Only install Cursor hooks (.cursor/hooks.json)").action(async (options) => {
-  const { hooksInstallCommand } = await import("./hooks-7TQIRXXS.js");
+  const { hooksInstallCommand } = await import("./hooks-YXPQV4SP.js");
   await hooksInstallCommand(options);
 });
 hooksCmd.command("uninstall").description("Remove paradigm hooks (git hooks, or --cursor for Cursor hooks)").option("--cursor", "Remove Cursor hooks instead of git hooks").action(async (options) => {
-  const { hooksUninstallCommand } = await import("./hooks-7TQIRXXS.js");
+  const { hooksUninstallCommand } = await import("./hooks-YXPQV4SP.js");
   await hooksUninstallCommand(options);
 });
 hooksCmd.command("status").description("Check git hooks status").action(async () => {
-  const { hooksStatusCommand } = await import("./hooks-7TQIRXXS.js");
+  const { hooksStatusCommand } = await import("./hooks-YXPQV4SP.js");
   await hooksStatusCommand();
 });
 hooksCmd.action(async () => {
-  const { hooksStatusCommand } = await import("./hooks-7TQIRXXS.js");
+  const { hooksStatusCommand } = await import("./hooks-YXPQV4SP.js");
   await hooksStatusCommand();
 });
 var triageCmd = program.command("triage").description("Semantic error triage - incident management and pattern matching");
 triageCmd.command("list").alias("ls").description("List recent incidents with matched patterns").option("-l, --limit <number>", "Maximum incidents to show", "10").option("-s, --status <status>", "Filter by status: open, investigating, resolved, wont-fix, all").option("--symbol <symbol>", "Filter by symbol (e.g., @checkout, ^auth)").option("-e, --env <environment>", "Filter by environment").option("--search <text>", "Search in error messages").option("--from <date>", "Filter from date (ISO format)").option("--to <date>", "Filter to date (ISO format)").option("--json", "Output as JSON").action(async (options) => {
-  const { triageListCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageListCommand } = await import("./triage-TBIWJA6R.js");
   await triageListCommand(options);
 });
 triageCmd.command("show <id>").description("Show full incident details").option("--timeline", "Include flow timeline").option("--json", "Output as JSON").action(async (id, options) => {
-  const { triageShowCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageShowCommand } = await import("./triage-TBIWJA6R.js");
   await triageShowCommand(id, options);
 });
 triageCmd.command("resolve <id>").description("Mark incident as resolved").option("-p, --pattern <patternId>", "Pattern that led to resolution").option("-c, --commit <hash>", "Git commit hash of fix").option("--pr <url>", "Pull request URL").option("-n, --notes <text>", "Resolution notes").option("--wont-fix", "Mark as will not fix").action(async (id, options) => {
-  const { triageResolveCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageResolveCommand } = await import("./triage-TBIWJA6R.js");
   await triageResolveCommand(id, options);
 });
 triageCmd.command("note <id> <note>").description("Add a note to an incident").action(async (id, note) => {
-  const { triageNoteCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageNoteCommand } = await import("./triage-TBIWJA6R.js");
   await triageNoteCommand(id, note);
 });
 triageCmd.command("link <id1> <id2>").description("Link two related incidents").action(async (id1, id2) => {
-  const { triageLinkCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageLinkCommand } = await import("./triage-TBIWJA6R.js");
   await triageLinkCommand(id1, id2);
 });
 var triagePatternsCmd = triageCmd.command("patterns").description("Manage failure patterns");
 triagePatternsCmd.command("list").alias("ls").description("List all patterns").option("--source <source>", "Filter by source: manual, suggested, imported, community").option("--min-confidence <score>", "Minimum confidence score").option("--json", "Output as JSON").action(async (options) => {
-  const { triagePatternsListCommand } = await import("./triage-RM5KNG5V.js");
+  const { triagePatternsListCommand } = await import("./triage-TBIWJA6R.js");
   await triagePatternsListCommand(options);
 });
 triagePatternsCmd.command("show <id>").description("Show pattern details").option("--json", "Output as JSON").action(async (id, options) => {
-  const { triagePatternsShowCommand } = await import("./triage-RM5KNG5V.js");
+  const { triagePatternsShowCommand } = await import("./triage-TBIWJA6R.js");
   await triagePatternsShowCommand(id, options);
 });
 triagePatternsCmd.command("add").description("Create a new pattern").requiredOption("--id <id>", "Pattern ID (kebab-case)").requiredOption("--name <name>", "Human-readable name").option("--description <text>", "Pattern description").option("--symbols <pairs>", 'Symbol criteria (e.g., "feature:@checkout,gate:^auth")').option("--error-contains <keywords>", "Error keywords (comma-separated)").option("--missing-signals <signals>", "Expected missing signals (comma-separated)").option("--strategy <strategy>", "Resolution strategy: retry, fallback, fix-data, fix-code, ignore, escalate", "fix-code").option("--priority <priority>", "Priority: low, medium, high, critical", "medium").option("--code-hint <text>", "Code hint for resolution").option("--tags <tags>", "Tags (comma-separated)").option("--from-incident <id>", "Generate suggestion from incident").action(async (options) => {
-  const { triagePatternsAddCommand } = await import("./triage-RM5KNG5V.js");
+  const { triagePatternsAddCommand } = await import("./triage-TBIWJA6R.js");
   await triagePatternsAddCommand(options);
 });
 triagePatternsCmd.command("delete <id>").alias("rm").description("Delete a pattern").action(async (id) => {
-  const { triagePatternsDeleteCommand } = await import("./triage-RM5KNG5V.js");
+  const { triagePatternsDeleteCommand } = await import("./triage-TBIWJA6R.js");
   await triagePatternsDeleteCommand(id);
 });
 triagePatternsCmd.command("test <id>").description("Test pattern against historical incidents").option("-l, --limit <number>", "Max incidents to test against", "100").option("--json", "Output as JSON").action(async (id, options) => {
-  const { triagePatternsTestCommand } = await import("./triage-RM5KNG5V.js");
+  const { triagePatternsTestCommand } = await import("./triage-TBIWJA6R.js");
   await triagePatternsTestCommand(id, options);
 });
 triagePatternsCmd.command("seed").description("Load built-in seed patterns").action(async () => {
-  const { triagePatternsSeedCommand } = await import("./triage-RM5KNG5V.js");
+  const { triagePatternsSeedCommand } = await import("./triage-TBIWJA6R.js");
   await triagePatternsSeedCommand();
 });
 triagePatternsCmd.action(async () => {
-  const { triagePatternsListCommand } = await import("./triage-RM5KNG5V.js");
+  const { triagePatternsListCommand } = await import("./triage-TBIWJA6R.js");
   await triagePatternsListCommand({});
 });
 triageCmd.command("export <type>").description("Export patterns or full backup (type: patterns, backup)").option("-o, --output <path>", "Output file path").option("--include-private", "Include private patterns").action(async (type, options) => {
-  const { triageExportCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageExportCommand } = await import("./triage-TBIWJA6R.js");
   await triageExportCommand(type, options);
 });
 triageCmd.command("import <file>").description("Import patterns from JSON file").option("--overwrite", "Overwrite existing patterns").action(async (file, options) => {
-  const { triageImportCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageImportCommand } = await import("./triage-TBIWJA6R.js");
   await triageImportCommand(file, options);
 });
 triageCmd.command("restore <file>").description("Restore from full backup").action(async (file) => {
-  const { triageRestoreCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageRestoreCommand } = await import("./triage-TBIWJA6R.js");
   await triageRestoreCommand(file);
 });
 triageCmd.command("stats").description("Show statistics dashboard").option("-p, --period <period>", "Time period: 1d, 7d, 30d, 90d", "7d").option("--symbol <symbol>", "Show health for specific symbol").option("--json", "Output as JSON").action(async (options) => {
-  const { triageStatsCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageStatsCommand } = await import("./triage-TBIWJA6R.js");
   await triageStatsCommand(options);
 });
 triageCmd.command("record").description("Manually record an incident").requiredOption("--error <message>", "Error message").requiredOption("-e, --env <environment>", "Environment").option("--feature <symbol>", "Feature symbol (@...)").option("--component <symbol>", "Component symbol (#...)").option("--flow <symbol>", "Flow symbol ($...)").option("--gate <symbol>", "Gate symbol (^...)").option("--signal <symbol>", "Signal symbol (!...)").option("--state <symbol>", "State symbol (%...)").option("--integration <symbol>", "Integration symbol (&...)").option("--service <name>", "Service name").option("--version <version>", "App version").option("--stack <trace>", "Stack trace").option("--json", "Output as JSON").action(async (options) => {
-  const { triageRecordCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageRecordCommand } = await import("./triage-TBIWJA6R.js");
   await triageRecordCommand(options);
 });
 triageCmd.option("-l, --limit <number>", "Maximum incidents to show", "10").option("-s, --status <status>", "Filter by status").option("--json", "Output as JSON").action(async (options) => {
-  const { triageListCommand } = await import("./triage-RM5KNG5V.js");
+  const { triageListCommand } = await import("./triage-TBIWJA6R.js");
   await triageListCommand(options);
 });
 var loreCmd = program.command("lore").description("Project lore - timeline of everything that happened to this project");
-loreCmd.command("list").alias("ls").description("List recent lore entries").option("--author <author>", "Filter by author").option("--type <type>", "Filter by type: agent-session, human-note, decision, review, incident, milestone").option("--symbol <symbol>", "Filter by symbol").option("--tags <tags>", "Filter by tags (comma-separated)").option("-l, --limit <number>", "Number of entries", "20").option("--json", "Output as JSON").action(async (options) => {
-  const { loreListCommand } = await import("./list-QMUE7DPK.js");
+loreCmd.command("list").alias("ls").description("List recent lore entries").option("--author <author>", "Filter by author").option("--type <type>", "Filter by type: agent-session, human-note, decision, review, incident, milestone").option("--symbol <symbol>", "Filter by symbol").option("--tags <tags>", "Filter by tags (comma-separated)").option("--from <date>", "Filter from date (ISO format, e.g., 2026-02-20)").option("--to <date>", "Filter to date (ISO format)").option("-l, --limit <number>", "Number of entries", "20").option("--json", "Output as JSON").action(async (options) => {
+  const { loreListCommand } = await import("./list-R3QWW4SC.js");
   await loreListCommand(options);
 });
 loreCmd.command("show <id>").description("Show full detail for a lore entry").option("--json", "Output as JSON").action(async (id, options) => {
-  const { loreShowCommand } = await import("./show-S653P3TO.js");
+  const { loreShowCommand } = await import("./show-WTOJXUTN.js");
   await loreShowCommand(id, options);
 });
-loreCmd.command("record").description("Record a new lore entry (human note, milestone, etc.)").option("--type <type>", "Entry type: human-note, decision, milestone", "human-note").option("--author <author>", "Author name").option("--title <title>", "Entry title").option("--summary <summary>", "Entry summary").option("--symbols <symbols>", "Comma-separated symbols").option("--tags <tags>", "Comma-separated tags").action(async (options) => {
-  const { loreRecordCommand } = await import("./record-5CTCDFUO.js");
+loreCmd.command("record").description("Record a new lore entry (human note, milestone, etc.)").option("--type <type>", "Entry type: human-note, decision, milestone", "human-note").option("--author <author>", "Author name").option("--title <title>", "Entry title").option("--summary <summary>", "Entry summary").option("--symbols <symbols>", "Comma-separated symbols").option("--tags <tags>", "Comma-separated tags").option("--files-modified <files>", "Comma-separated files modified").option("--files-created <files>", "Comma-separated files created").option("--commit <hash>", "Git commit hash").option("--learnings <items>", "Comma-separated learnings").option("--duration <minutes>", "Duration in minutes").action(async (options) => {
+  const { loreRecordCommand } = await import("./record-OHQNWOUP.js");
   await loreRecordCommand(options);
 });
 loreCmd.command("review <id>").description("Add a review to a lore entry").option("--reviewer <name>", "Reviewer name").option("--completeness <n>", "Completeness score (1-5)", "3").option("--quality <n>", "Quality score (1-5)", "3").option("--notes <text>", "Review notes").action(async (id, options) => {
-  const { loreReviewCommand } = await import("./review-QEDNQAIO.js");
+  const { loreReviewCommand } = await import("./review-RUHX25A5.js");
   await loreReviewCommand(id, options);
 });
+loreCmd.command("edit <id>").description("Edit an existing lore entry").option("--title <title>", "New title").option("--summary <summary>", "New summary").option("--type <type>", "New type: agent-session, human-note, decision, review, incident, milestone").option("--symbols <symbols>", "Comma-separated symbols").option("--tags <tags>", "Comma-separated tags").option("--learnings <items>", "Comma-separated learnings").action(async (id, options) => {
+  const { loreEditCommand } = await import("./edit-Y7XPYSMK.js");
+  await loreEditCommand(id, options);
+});
+loreCmd.command("delete <id>").description("Delete a lore entry").option("-y, --yes", "Skip confirmation").action(async (id, options) => {
+  const { loreDeleteCommand } = await import("./delete-W67IVTLJ.js");
+  await loreDeleteCommand(id, options);
+});
+loreCmd.command("timeline").description("Show lore timeline grouped by date with hot symbols and authors").option("-l, --limit <number>", "Number of entries", "20").option("--json", "Output as JSON").action(async (options) => {
+  const { loreTimelineCommand } = await import("./timeline-P7BARFLI.js");
+  await loreTimelineCommand(options);
+});
 loreCmd.option("-p, --port <port>", "Port to run on", "3840").option("--no-open", "Don't open browser automatically").action(async (options) => {
-  const { loreServeCommand } = await import("./serve-WCIRW244.js");
+  const { loreServeCommand } = await import("./serve-H7ZBMODT.js");
   await loreServeCommand(void 0, options);
 });
+var habitsCmd = program.command("habits").description("Behavioral habits - practice tracking and compliance");
+habitsCmd.command("list").alias("ls").description("List all configured habits").option("--trigger <trigger>", "Filter by trigger: preflight, postflight, on-stop, on-commit").option("--category <category>", "Filter by category: discovery, verification, testing, documentation, collaboration, security").option("--json", "Output as JSON").action(async (options) => {
+  const { habitsListCommand } = await import("./habits-FA65W77Y.js");
+  await habitsListCommand(options);
+});
+habitsCmd.command("status").description("Show practice profile with compliance rates").option("-p, --period <period>", "Time period: 7d, 30d, 90d, all", "30d").option("--json", "Output as JSON").action(async (options) => {
+  const { habitsStatusCommand } = await import("./habits-FA65W77Y.js");
+  await habitsStatusCommand(options);
+});
+habitsCmd.command("init").description("Initialize habits.yaml with seed habits").option("-f, --force", "Overwrite existing file").action(async (options) => {
+  const { habitsInitCommand } = await import("./habits-FA65W77Y.js");
+  await habitsInitCommand(options);
+});
+habitsCmd.command("check").description("Evaluate habit compliance for a trigger point").requiredOption("-t, --trigger <trigger>", "Trigger: preflight, postflight, on-stop, on-commit").option("--record", "Record practice events to Sentinel").option("--json", "Output as JSON").option("--files <files>", "Comma-separated files modified (default: git diff)").option("--symbols <symbols>", "Comma-separated symbols touched").action(async (options) => {
+  const { habitsCheckCommand } = await import("./habits-FA65W77Y.js");
+  await habitsCheckCommand(options);
+});
+habitsCmd.command("add").description("Add a custom habit").requiredOption("--id <id>", "Habit ID (kebab-case)").requiredOption("--name <name>", "Human-readable name").requiredOption("--description <desc>", "What this habit enforces").requiredOption("--category <category>", "Category: discovery, verification, testing, documentation, collaboration, security").requiredOption("--trigger <trigger>", "Trigger: preflight, postflight, on-stop, on-commit").option("--severity <severity>", "Severity: advisory, warn, block", "advisory").option("--tools <tools>", "Comma-separated tools to check (for tool-called check type)").option("--check-type <type>", "Check type: tool-called, file-exists, file-modified, lore-recorded, symbols-registered, gates-declared, tests-exist, git-clean", "tool-called").option("--patterns <patterns>", "Comma-separated patterns (for file-exists, file-modified, tests-exist check types)").action(async (options) => {
+  const { habitsAddCommand } = await import("./habits-FA65W77Y.js");
+  await habitsAddCommand({ ...options, checkType: options.checkType });
+});
+habitsCmd.command("edit <id>").description("Edit a habit (seed habits: only severity/enabled; custom: all fields)").option("--name <name>", "New name").option("--description <desc>", "New description").option("--category <category>", "New category").option("--trigger <trigger>", "New trigger").option("--severity <severity>", "New severity: advisory, warn, block").option("--enabled <bool>", "Enable or disable: true, false").option("--check-type <type>", "New check type").option("--patterns <patterns>", "Comma-separated patterns").option("--tools <tools>", "Comma-separated tools").action(async (id, options) => {
+  const { habitsEditCommand } = await import("./habits-FA65W77Y.js");
+  await habitsEditCommand(id, { ...options, checkType: options.checkType });
+});
+habitsCmd.command("remove <id>").description("Remove a custom habit (seed habits cannot be removed, only disabled)").option("-y, --yes", "Skip confirmation").action(async (id, options) => {
+  const { habitsRemoveCommand } = await import("./habits-FA65W77Y.js");
+  await habitsRemoveCommand(id, options);
+});
+habitsCmd.command("enable <id>").description("Enable a habit").action(async (id) => {
+  const { habitsToggleCommand } = await import("./habits-FA65W77Y.js");
+  await habitsToggleCommand(id, "enable");
+});
+habitsCmd.command("disable <id>").description("Disable a habit").action(async (id) => {
+  const { habitsToggleCommand } = await import("./habits-FA65W77Y.js");
+  await habitsToggleCommand(id, "disable");
+});
+habitsCmd.action(async () => {
+  const { habitsListCommand } = await import("./habits-FA65W77Y.js");
+  await habitsListCommand({});
+});
 program.command("sentinel [path]").description("Launch the Sentinel UI - unified codebase intelligence visualizer").option("-p, --port <port>", "Port to run on", "3838").option("--no-open", "Don't open browser automatically").action(async (path2, options) => {
-  const { sentinelCommand } = await import("./sentinel-RSEXIRXM.js");
+  const { sentinelCommand } = await import("./sentinel-WB7GIK4V.js");
   await sentinelCommand(path2, options);
 });
 program.command("university").description("Launch Paradigm University - interactive learning platform & PLSAT certification").option("-p, --port <port>", "Port to run on", "3839").option("--no-open", "Don't open browser automatically").action(async (options) => {

package/dist/{list-QMUE7DPK.js → list-R3QWW4SC.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   loadLoreEntries
-} from "./chunk-27OSFWHG.js";
+} from "./chunk-MVXJVRFI.js";
 import "./chunk-MO4EEYFW.js";
 
 // src/commands/lore/list.ts
@@ -13,6 +13,8 @@ async function loreListCommand(options) {
   if (options.type) filter.type = options.type;
   if (options.symbol) filter.symbol = options.symbol;
   if (options.tags) filter.tags = options.tags.split(",");
+  if (options.from) filter.dateFrom = options.from;
+  if (options.to) filter.dateTo = options.to;
   filter.limit = parseInt(options.limit || "20", 10);
   const entries = await loadLoreEntries(rootDir, filter);
   if (options.json) {

package/dist/{lore-server-3TAIUZ3Y.js → lore-server-RQH5REZV.js}

@@ -3,8 +3,8 @@ import "./chunk-MO4EEYFW.js";
 
 // src/lore-server/index.ts
 import express from "express";
-import * as path3 from "path";
-import * as fs3 from "fs";
+import * as path4 from "path";
+import * as fs4 from "fs";
 import { fileURLToPath } from "url";
 import chalk from "chalk";
 
@@ -79,39 +79,6 @@ function createLoreRouter(projectDir) {
     entries = entries.slice(off, off + lim);
     res.json({ total, offset: off, limit: lim, entries });
   });
-  router.get("/:id", (req, res) => {
-    const entries = loadAllEntries(projectDir);
-    const entry = entries.find((e) => e.id === req.params.id);
-    if (!entry) {
-      res.status(404).json({ error: "Entry not found" });
-      return;
-    }
-    res.json(entry);
-  });
-  router.put("/:id/review", (req, res) => {
-    const entryId = req.params.id;
-    const entries = loadAllEntries(projectDir);
-    const entry = entries.find((e) => e.id === entryId);
-    if (!entry) {
-      res.status(404).json({ error: "Entry not found" });
-      return;
-    }
-    const dateStr = entry.timestamp.slice(0, 10);
-    const entryPath = path.join(projectDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-    if (!fs.existsSync(entryPath)) {
-      res.status(404).json({ error: "Entry file not found" });
-      return;
-    }
-    entry.review = {
-      reviewer: req.body.reviewer || "anonymous",
-      completeness: req.body.completeness || 3,
-      quality: req.body.quality || 3,
-      notes: req.body.notes,
-      reviewed_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
-    res.json({ success: true, entry });
-  });
   router.get("/timeline", (_req, res) => {
     const timelinePath = path.join(projectDir, LORE_DIR, "timeline.yaml");
     if (!fs.existsSync(timelinePath)) {
@@ -157,6 +124,39 @@ function createLoreRouter(projectDir) {
     const authors = Object.entries(authorMap).map(([id, info]) => ({ id, ...info })).sort((a, b) => b.count - a.count);
     res.json({ authors });
   });
+  router.get("/:id", (req, res) => {
+    const entries = loadAllEntries(projectDir);
+    const entry = entries.find((e) => e.id === req.params.id);
+    if (!entry) {
+      res.status(404).json({ error: "Entry not found" });
+      return;
+    }
+    res.json(entry);
+  });
+  router.put("/:id/review", (req, res) => {
+    const entryId = req.params.id;
+    const entries = loadAllEntries(projectDir);
+    const entry = entries.find((e) => e.id === entryId);
+    if (!entry) {
+      res.status(404).json({ error: "Entry not found" });
+      return;
+    }
+    const dateStr = entry.timestamp.slice(0, 10);
+    const entryPath = path.join(projectDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+    if (!fs.existsSync(entryPath)) {
+      res.status(404).json({ error: "Entry file not found" });
+      return;
+    }
+    entry.review = {
+      reviewer: req.body.reviewer || "anonymous",
+      completeness: req.body.completeness || 3,
+      quality: req.body.quality || 3,
+      notes: req.body.notes,
+      reviewed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
+    res.json({ success: true, entry });
+  });
   return router;
 }
 
@@ -186,9 +186,133 @@ function createInfoRouter(projectDir) {
   return router;
 }
 
+// src/lore-server/routes/sessions.ts
+import { Router as Router3 } from "express";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as yaml3 from "js-yaml";
+import * as os from "os";
+var LORE_DIR2 = ".paradigm/lore";
+var ENTRIES_DIR2 = "entries";
+var SESSION_GAP_MS = 4 * 60 * 60 * 1e3;
+function loadAllEntries2(projectDir) {
+  const entriesPath = path3.join(projectDir, LORE_DIR2, ENTRIES_DIR2);
+  if (!fs3.existsSync(entriesPath)) {
+    return [];
+  }
+  const entries = [];
+  const dateDirs = fs3.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
+  for (const dateDir of dateDirs) {
+    const dirPath = path3.join(entriesPath, dateDir);
+    const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+    for (const file of files) {
+      try {
+        const content = fs3.readFileSync(path3.join(dirPath, file), "utf8");
+        const entry = yaml3.load(content);
+        entries.push(entry);
+      } catch {
+      }
+    }
+  }
+  return entries;
+}
+function loadBreadcrumbs(projectDir) {
+  const localPath = path3.join(projectDir, ".paradigm", "session-breadcrumbs.json");
+  if (fs3.existsSync(localPath)) {
+    try {
+      return JSON.parse(fs3.readFileSync(localPath, "utf8"));
+    } catch {
+    }
+  }
+  const globalDir = path3.join(os.homedir(), ".paradigm", "sessions");
+  if (fs3.existsSync(globalDir)) {
+    try {
+      const dirs = fs3.readdirSync(globalDir).sort().reverse();
+      for (const dir of dirs.slice(0, 5)) {
+        const bcPath = path3.join(globalDir, dir, "breadcrumbs.json");
+        if (fs3.existsSync(bcPath)) {
+          return JSON.parse(fs3.readFileSync(bcPath, "utf8"));
+        }
+      }
+    } catch {
+    }
+  }
+  return [];
+}
+function deriveSessionsFromEntries(entries, breadcrumbs) {
+  if (entries.length === 0) return [];
+  const sorted = [...entries].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  const sessions = [];
+  let currentGroup = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const curr = sorted[i];
+    const gap = new Date(curr.timestamp).getTime() - new Date(prev.timestamp).getTime();
+    const sameAuthor = curr.author.id === prev.author.id;
+    if (gap <= SESSION_GAP_MS && sameAuthor) {
+      currentGroup.push(curr);
+    } else {
+      sessions.push(groupToSession(currentGroup));
+      currentGroup = [curr];
+    }
+  }
+  sessions.push(groupToSession(currentGroup));
+  if (breadcrumbs.length > 0 && sessions.length > 0) {
+    sessions[sessions.length - 1].breadcrumbs = breadcrumbs;
+  }
+  sessions.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+  return sessions;
+}
+function groupToSession(group) {
+  const allSymbols = /* @__PURE__ */ new Set();
+  for (const entry of group) {
+    for (const sym of entry.symbols_touched) allSymbols.add(sym);
+    if (entry.symbols_created) {
+      for (const sym of entry.symbols_created) allSymbols.add(sym);
+    }
+  }
+  const startTime = group[0].timestamp;
+  const endTime = group[group.length - 1].timestamp;
+  const date = startTime.slice(0, 10);
+  return {
+    id: `session-${date}-${group[0].author.id}-${group[0].id.slice(0, 8)}`,
+    date,
+    author: { type: group[0].author.type, id: group[0].author.id },
+    startTime,
+    endTime,
+    entryCount: group.length,
+    symbolsTouched: Array.from(allSymbols),
+    entryIds: group.map((e) => e.id)
+  };
+}
+function createSessionsRouter(projectDir) {
+  const router = Router3();
+  router.get("/", (_req, res) => {
+    const entries = loadAllEntries2(projectDir);
+    const breadcrumbs = loadBreadcrumbs(projectDir);
+    const sessions = deriveSessionsFromEntries(entries, breadcrumbs);
+    res.json({ sessions });
+  });
+  router.get("/:id", (req, res) => {
+    const entries = loadAllEntries2(projectDir);
+    const breadcrumbs = loadBreadcrumbs(projectDir);
+    const sessions = deriveSessionsFromEntries(entries, breadcrumbs);
+    const session = sessions.find((s) => s.id === req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    const sessionEntries = entries.filter((e) => session.entryIds.includes(e.id));
+    res.json({ ...session, entries: sessionEntries });
+  });
+  return router;
+}
+
 // src/lore-server/index.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path3.dirname(__filename);
+var __dirname = path4.dirname(__filename);
 var log = {
   component(name) {
     const symbol = chalk.magenta(`#${name}`);
@@ -227,18 +351,19 @@ function createLoreApp(options) {
   });
   app.use("/api/lore", createLoreRouter(options.projectDir));
   app.use("/api/info", createInfoRouter(options.projectDir));
+  app.use("/api/sessions", createSessionsRouter(options.projectDir));
   app.get("/api/health", (_req, res) => {
     res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   });
-  let uiDistPath = path3.join(__dirname, "..", "lore-ui", "dist");
-  if (!fs3.existsSync(uiDistPath)) {
-    uiDistPath = path3.join(__dirname, "..", "..", "lore-ui", "dist");
+  let uiDistPath = path4.join(__dirname, "..", "lore-ui", "dist");
+  if (!fs4.existsSync(uiDistPath)) {
+    uiDistPath = path4.join(__dirname, "..", "..", "lore-ui", "dist");
   }
-  if (fs3.existsSync(uiDistPath)) {
+  if (fs4.existsSync(uiDistPath)) {
     app.use(express.static(uiDistPath));
     app.get("{*path}", (req, res) => {
       if (!req.path.startsWith("/api")) {
-        res.sendFile(path3.join(uiDistPath, "index.html"));
+        res.sendFile(path4.join(uiDistPath, "index.html"));
       }
     });
   } else {