@a-company/paradigm 2.0.13 → 3.0.0

package/dist/{doctor-6Y6L6HEB.js → doctor-QMPFQONP.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   doctorCommand
-} from "./chunk-753RICFF.js";
-import "./chunk-YDNKXH4Z.js";
+} from "./chunk-2NMUSZFA.js";
+import "./chunk-A5BKW7QV.js";
 import "./chunk-4NCFWYGG.js";
 import "./chunk-YO6DVTL7.js";
 import "./chunk-MO4EEYFW.js";

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

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

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   initCommand
-} from "./chunk-5GOA7WYD.js";
+} from "./chunk-MOZPTZ77.js";
 import "./chunk-CHSHON3O.js";
 import "./chunk-N6PJAPDE.js";
 import {
@@ -15,7 +15,7 @@ import {
 import {
   findGateFiles
 } from "./chunk-IRKUEJVW.js";
-import "./chunk-YDNKXH4Z.js";
+import "./chunk-A5BKW7QV.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";
@@ -107,7 +107,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-HKIAP4ZN.js");
+  const { shiftCommand } = await import("./shift-BJKPOYEF.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) => {
@@ -151,7 +151,7 @@ premiseCmd.command("snapshot <name>").description("Create a timeline snapshot").
   await premiseSnapshotCommand(name, options.description);
 });
 program.command("sync [ide]").description("Generate IDE instruction files from .paradigm/ config").option("--all", "Sync all supported IDEs").option("-f, --force", "Overwrite existing files").option("--mcp", "Generate MCP configuration (default: true)").option("--no-mcp", "Skip MCP configuration generation").option("--nested", "Generate nested CLAUDE.md files for directories with .purpose").action(async (ide, options) => {
-  const { syncCommand } = await import("./sync-BEOCW7TZ.js");
+  const { syncCommand } = await import("./sync-PF3MJ3E4.js");
   await syncCommand(ide, options);
 });
 program.command("cursorrules [path]").description("[DEPRECATED] Use `paradigm sync cursor` instead").option("-a, --append", "Append to existing .cursorrules").option("-f, --force", "Overwrite existing .cursorrules").option("-p, --preview", "Preview output without writing").option("--init", "Create default .paradigm config if missing").option("--with-scan", "Include probe protocol section").action(async (path2, options) => {
@@ -169,7 +169,7 @@ probeCmd.command("index [path]").description("Generate probe index (alias for `p
   await indexCommand(path2, options);
 });
 program.command("upgrade [path]").description("Upgrade project with new Paradigm features").option("--features <features...>", "Features to upgrade (probe, logger)").option("--all", "Apply all available upgrades").option("--from-horizon", "Migrate from Horizon to Paradigm").option("--dry-run", "Show what would be upgraded without making changes").option("-f, --force", "Force re-upgrade even if already configured").action(async (path2, options) => {
-  const { upgradeCommand } = await import("./upgrade-5B3YGGC6.js");
+  const { upgradeCommand } = await import("./upgrade-X4PVS7UV.js");
   await upgradeCommand(path2, options);
 });
 program.command("lint [path]").description("Validate .purpose files for schema errors").option("-f, --fix", "Auto-fix issues where possible").option("-s, --strict", "Fail on warnings (not just errors)").option("-q, --quiet", "Suppress output except errors").option("--json", "Output as JSON").action(async (path2, options) => {
@@ -181,8 +181,8 @@ program.command("cost [path]").description("Analyze token costs for AI context")
   await costCommand(path2, options);
 });
 var scanCmd = program.command("scan").description("Visual discovery and auto-generation commands");
-scanCmd.command("auto [path]").description("Auto-generate .purpose files from code analysis").option("-n, --dry-run", "Show what would be generated without writing").option("-f, --force", "Overwrite existing .purpose files").option("--json", "Output as JSON").action(async (path2, options) => {
-  const { autoScanCommand } = await import("./auto-IU7VN55K.js");
+scanCmd.command("auto [path]").description("Auto-generate .purpose files from code analysis").option("-n, --dry-run", "Show what would be generated without writing").option("-f, --force", "Overwrite existing .purpose files").option("--json", "Output as JSON").option("--init", "Full project initialization: generate .purpose files + portal.yaml").action(async (path2, options) => {
+  const { autoScanCommand } = await import("./auto-6MOGYQ4G.js");
   await autoScanCommand(path2, options);
 });
 scanCmd.action(() => {
@@ -276,15 +276,15 @@ teamCmd.action(async () => {
   await teamStatusCommand(void 0, {});
 });
 program.command("doctor").description("Health check - validate Paradigm setup").action(async () => {
-  const { doctorCommand } = await import("./doctor-6Y6L6HEB.js");
+  const { doctorCommand } = await import("./doctor-QMPFQONP.js");
   await doctorCommand();
 });
 program.command("watch").description("Watch for changes and auto-sync IDE files").action(async () => {
-  const { watchCommand } = await import("./watch-6IIWPWDN.js");
+  const { watchCommand } = await import("./watch-QYGAIYZ3.js");
   await watchCommand();
 });
 program.command("summary").description("Generate .paradigm/project.md with project stats").action(async () => {
-  const { summaryCommand } = await import("./summary-H6J6N6PJ.js");
+  const { summaryCommand } = await import("./summary-ZIEIBCAF.js");
   await summaryCommand();
 });
 program.command("constellation [path]").alias("const").description("Generate .paradigm/constellation.json - symbol relationship graph for AI agents").option("-f, --format <format>", "Output format: json or yaml", "json").option("-o, --output <path>", "Custom output path").option("-q, --quiet", "Suppress output").action(async (path2, options) => {
@@ -405,7 +405,7 @@ mcpCmd.action(async () => {
   await mcpSwitchStatusCommand({});
 });
 program.command("promote").description("Copy local build to production (~/.paradigm-cli/)").option("-f, --force", "Create production directory if missing").option("--skip-build", "Skip npm run build step").option("--json", "Output as JSON").action(async (options) => {
-  const { promoteCommand } = await import("./promote-Z52ZJTJU.js");
+  const { promoteCommand } = await import("./promote-E6NBZ3BK.js");
   await promoteCommand(options);
 });
 var wisdomCmd = program.command("wisdom").description("Team wisdom - preferences, antipatterns, decisions, expertise");
@@ -468,101 +468,122 @@ 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-MBWE4ILT.js");
+  const { hooksInstallCommand } = await import("./hooks-7TQIRXXS.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-MBWE4ILT.js");
+  const { hooksUninstallCommand } = await import("./hooks-7TQIRXXS.js");
   await hooksUninstallCommand(options);
 });
 hooksCmd.command("status").description("Check git hooks status").action(async () => {
-  const { hooksStatusCommand } = await import("./hooks-MBWE4ILT.js");
+  const { hooksStatusCommand } = await import("./hooks-7TQIRXXS.js");
   await hooksStatusCommand();
 });
 hooksCmd.action(async () => {
-  const { hooksStatusCommand } = await import("./hooks-MBWE4ILT.js");
+  const { hooksStatusCommand } = await import("./hooks-7TQIRXXS.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-ETVXXFMV.js");
+  const { triageListCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triageShowCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triageResolveCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triageNoteCommand } = await import("./triage-RM5KNG5V.js");
   await triageNoteCommand(id, note);
 });
 triageCmd.command("link <id1> <id2>").description("Link two related incidents").action(async (id1, id2) => {
-  const { triageLinkCommand } = await import("./triage-ETVXXFMV.js");
+  const { triageLinkCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triagePatternsListCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triagePatternsShowCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triagePatternsAddCommand } = await import("./triage-RM5KNG5V.js");
   await triagePatternsAddCommand(options);
 });
 triagePatternsCmd.command("delete <id>").alias("rm").description("Delete a pattern").action(async (id) => {
-  const { triagePatternsDeleteCommand } = await import("./triage-ETVXXFMV.js");
+  const { triagePatternsDeleteCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triagePatternsTestCommand } = await import("./triage-RM5KNG5V.js");
   await triagePatternsTestCommand(id, options);
 });
 triagePatternsCmd.command("seed").description("Load built-in seed patterns").action(async () => {
-  const { triagePatternsSeedCommand } = await import("./triage-ETVXXFMV.js");
+  const { triagePatternsSeedCommand } = await import("./triage-RM5KNG5V.js");
   await triagePatternsSeedCommand();
 });
 triagePatternsCmd.action(async () => {
-  const { triagePatternsListCommand } = await import("./triage-ETVXXFMV.js");
+  const { triagePatternsListCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triageExportCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triageImportCommand } = await import("./triage-RM5KNG5V.js");
   await triageImportCommand(file, options);
 });
 triageCmd.command("restore <file>").description("Restore from full backup").action(async (file) => {
-  const { triageRestoreCommand } = await import("./triage-ETVXXFMV.js");
+  const { triageRestoreCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triageStatsCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triageRecordCommand } = await import("./triage-RM5KNG5V.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-ETVXXFMV.js");
+  const { triageListCommand } = await import("./triage-RM5KNG5V.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");
+  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");
+  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");
+  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");
+  await loreReviewCommand(id, 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");
+  await loreServeCommand(void 0, options);
+});
 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-LCFD56OJ.js");
+  const { sentinelCommand } = await import("./sentinel-J64XJVTU.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) => {
-  const { universityCommand } = await import("./university-R2WDQLSI.js");
+  const { universityCommand } = await import("./university-IXTJCROL.js");
   await universityCommand(void 0, options);
 });
 program.parse();

package/dist/list-QMUE7DPK.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import {
+  loadLoreEntries
+} from "./chunk-27OSFWHG.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/lore/list.ts
+import chalk from "chalk";
+async function loreListCommand(options) {
+  const rootDir = process.cwd();
+  const filter = {};
+  if (options.author) filter.author = options.author;
+  if (options.type) filter.type = options.type;
+  if (options.symbol) filter.symbol = options.symbol;
+  if (options.tags) filter.tags = options.tags.split(",");
+  filter.limit = parseInt(options.limit || "20", 10);
+  const entries = await loadLoreEntries(rootDir, filter);
+  if (options.json) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  if (entries.length === 0) {
+    console.log(chalk.gray("\nNo lore entries found.\n"));
+    console.log(chalk.gray("Record one with: paradigm lore record"));
+    return;
+  }
+  console.log(chalk.cyan(`
+  Lore Entries (${entries.length})
+`));
+  const typeColor = {
+    "agent-session": chalk.hex("#818cf8"),
+    "human-note": chalk.hex("#34d399"),
+    "decision": chalk.hex("#fbbf24"),
+    "review": chalk.hex("#c084fc"),
+    "incident": chalk.hex("#f87171"),
+    "milestone": chalk.hex("#60a5fa")
+  };
+  for (const entry of entries) {
+    const colorFn = typeColor[entry.type] || chalk.white;
+    const date = new Date(entry.timestamp);
+    const dateStr = date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    const timeStr = date.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" });
+    const authorIcon = entry.author.type === "agent" ? "\u{1F916}" : "\u{1F464}";
+    const verifyIcon = entry.verification?.status === "pass" ? chalk.green("\u2713") : entry.verification?.status === "fail" ? chalk.red("\u2717") : entry.verification?.status === "partial" ? chalk.yellow("\u26A0") : chalk.gray("\xB7");
+    const reviewStr = entry.review ? chalk.yellow("\u2605".repeat(entry.review.quality) + "\u2606".repeat(5 - entry.review.quality)) : "";
+    console.log(`  ${chalk.gray(entry.id)} ${colorFn(entry.type.padEnd(14))} ${verifyIcon} ${chalk.white(entry.title)}`);
+    console.log(`  ${chalk.gray(dateStr + " " + timeStr)}  ${authorIcon} ${chalk.gray(entry.author.id)}  ${entry.symbols_touched.map((s) => chalk.cyan(s)).join(" ")} ${reviewStr}`);
+    console.log();
+  }
+}
+export {
+  loreListCommand
+};

package/dist/lore-server-3TAIUZ3Y.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+import "./chunk-MO4EEYFW.js";
+
+// src/lore-server/index.ts
+import express from "express";
+import * as path3 from "path";
+import * as fs3 from "fs";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+
+// src/lore-server/routes/lore.ts
+import { Router } from "express";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var LORE_DIR = ".paradigm/lore";
+var ENTRIES_DIR = "entries";
+function loadAllEntries(projectDir) {
+  const entriesPath = path.join(projectDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs.existsSync(entriesPath)) {
+    return [];
+  }
+  const entries = [];
+  const dateDirs = fs.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
+  for (const dateDir of dateDirs) {
+    const dirPath = path.join(entriesPath, dateDir);
+    const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dirPath, file), "utf8");
+        const entry = yaml.load(content);
+        entries.push(entry);
+      } catch {
+      }
+    }
+  }
+  return entries;
+}
+function createLoreRouter(projectDir) {
+  const router = Router();
+  router.get("/", (req, res) => {
+    let entries = loadAllEntries(projectDir);
+    const { author, authorType, symbol, type, from, to, tags, hasReview, limit, offset } = req.query;
+    if (author) {
+      entries = entries.filter((e) => e.author.id === author);
+    }
+    if (authorType) {
+      entries = entries.filter((e) => e.author.type === authorType);
+    }
+    if (symbol) {
+      entries = entries.filter(
+        (e) => e.symbols_touched.includes(symbol) || e.symbols_created?.includes(symbol)
+      );
+    }
+    if (type) {
+      entries = entries.filter((e) => e.type === type);
+    }
+    if (from) {
+      const fromDate = new Date(from).getTime();
+      entries = entries.filter((e) => new Date(e.timestamp).getTime() >= fromDate);
+    }
+    if (to) {
+      const toDate = new Date(to).getTime();
+      entries = entries.filter((e) => new Date(e.timestamp).getTime() <= toDate);
+    }
+    if (tags) {
+      const tagList = tags.split(",");
+      entries = entries.filter((e) => tagList.some((t) => e.tags?.includes(t)));
+    }
+    if (hasReview === "true") {
+      entries = entries.filter((e) => e.review != null);
+    } else if (hasReview === "false") {
+      entries = entries.filter((e) => e.review == null);
+    }
+    entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    const off = parseInt(offset || "0", 10);
+    const lim = parseInt(limit || "100", 10);
+    const total = entries.length;
+    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)) {
+      res.json({ version: "1.0", project: "unknown", entries: 0, last_updated: "", authors: [] });
+      return;
+    }
+    try {
+      const content = fs.readFileSync(timelinePath, "utf8");
+      res.json(yaml.load(content));
+    } catch {
+      res.status(500).json({ error: "Failed to load timeline" });
+    }
+  });
+  router.get("/symbols", (_req, res) => {
+    const entries = loadAllEntries(projectDir);
+    const symbolCounts = {};
+    for (const entry of entries) {
+      for (const sym of entry.symbols_touched) {
+        symbolCounts[sym] = (symbolCounts[sym] || 0) + 1;
+      }
+      if (entry.symbols_created) {
+        for (const sym of entry.symbols_created) {
+          symbolCounts[sym] = (symbolCounts[sym] || 0) + 1;
+        }
+      }
+    }
+    const symbols = Object.entries(symbolCounts).map(([symbol, count]) => ({ symbol, count })).sort((a, b) => b.count - a.count);
+    res.json({ symbols });
+  });
+  router.get("/authors", (_req, res) => {
+    const entries = loadAllEntries(projectDir);
+    const authorMap = {};
+    for (const entry of entries) {
+      const aid = entry.author.id;
+      if (!authorMap[aid]) {
+        authorMap[aid] = { type: entry.author.type, count: 0, lastActive: entry.timestamp };
+      }
+      authorMap[aid].count++;
+      if (entry.timestamp > authorMap[aid].lastActive) {
+        authorMap[aid].lastActive = entry.timestamp;
+      }
+    }
+    const authors = Object.entries(authorMap).map(([id, info]) => ({ id, ...info })).sort((a, b) => b.count - a.count);
+    res.json({ authors });
+  });
+  return router;
+}
+
+// src/lore-server/routes/info.ts
+import { Router as Router2 } from "express";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as yaml2 from "js-yaml";
+function createInfoRouter(projectDir) {
+  const router = Router2();
+  router.get("/", (_req, res) => {
+    const configPath = path2.join(projectDir, ".paradigm", "config.yaml");
+    let project = path2.basename(projectDir);
+    if (fs2.existsSync(configPath)) {
+      try {
+        const config = yaml2.load(fs2.readFileSync(configPath, "utf8"));
+        project = config.project || config.name || project;
+      } catch {
+      }
+    }
+    res.json({
+      project,
+      projectDir,
+      paradigmVersion: "2.0"
+    });
+  });
+  return router;
+}
+
+// src/lore-server/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+var log = {
+  component(name) {
+    const symbol = chalk.magenta(`#${name}`);
+    return {
+      info: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.blue("i")} ${symbol} ${msg}${dataStr}`);
+      },
+      success: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.green("+")} ${symbol} ${msg}${dataStr}`);
+      },
+      warn: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.yellow("!")} ${symbol} ${msg}${dataStr}`);
+      },
+      error: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.error(`${chalk.red("x")} ${symbol} ${msg}${dataStr}`);
+      }
+    };
+  }
+};
+function createLoreApp(options) {
+  const app = express();
+  app.use(express.json());
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    if (_req.method === "OPTIONS") {
+      res.sendStatus(204);
+      return;
+    }
+    next();
+  });
+  app.use("/api/lore", createLoreRouter(options.projectDir));
+  app.use("/api/info", createInfoRouter(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");
+  }
+  if (fs3.existsSync(uiDistPath)) {
+    app.use(express.static(uiDistPath));
+    app.get("{*path}", (req, res) => {
+      if (!req.path.startsWith("/api")) {
+        res.sendFile(path3.join(uiDistPath, "index.html"));
+      }
+    });
+  } else {
+    app.get("/", (_req, res) => {
+      res.send(`
+        <html>
+        <head><title>Paradigm Lore</title></head>
+        <body style="background:#0a0a0f;color:#e2e8f0;font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0">
+          <div style="text-align:center">
+            <h1>Paradigm Lore</h1>
+            <p style="color:#94a3b8">UI not built yet. Run <code style="background:#1e293b;padding:4px 8px;border-radius:4px">cd lore-ui && npx vite build</code></p>
+            <p style="color:#94a3b8">API available at <a href="/api/lore" style="color:#7dd3fc">/api/lore</a></p>
+          </div>
+        </body>
+        </html>
+      `);
+    });
+  }
+  return app;
+}
+async function startLoreServer(options) {
+  const app = createLoreApp(options);
+  log.component("lore-server").info("Starting server", { port: options.port });
+  log.component("lore-server").info("Project directory", { path: options.projectDir });
+  return new Promise((resolve, reject) => {
+    const server = app.listen(options.port, () => {
+      log.component("lore-server").success("Server running", { url: `http://localhost:${options.port}` });
+      if (options.open) {
+        import("open").then((openModule) => {
+          openModule.default(`http://localhost:${options.port}`);
+          log.component("lore-server").info("Opened browser");
+        }).catch(() => {
+          log.component("lore-server").warn("Could not open browser automatically");
+        });
+      }
+      resolve();
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        log.component("lore-server").error("Port already in use", { port: options.port });
+      } else {
+        log.component("lore-server").error("Server error", { error: err.message });
+      }
+      reject(err);
+    });
+  });
+}
+export {
+  createLoreApp,
+  startLoreServer
+};