@a-company/paradigm 3.34.0 → 3.44.0

package/dist/{accept-orchestration-XXANWJVZ.js → accept-orchestration-ZUWQUHSK.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   BackgroundOrchestrator
-} from "./chunk-3BGSDKWD.js";
-import "./chunk-6QC3YGB6.js";
-import "./chunk-J26YQVAK.js";
+} from "./chunk-QWA26UNO.js";
+import "./chunk-J4E6K5MG.js";
 import "./chunk-PBHIFAL4.js";
-import "./chunk-5SXMV4SP.js";
+import "./chunk-FS3WTUHY.js";
+import "./chunk-6QC3YGB6.js";
 import "./chunk-PMXRGPRQ.js";
 import "./chunk-MW5DMGBB.js";
 import "./chunk-5JGJACDU.js";
-import "./chunk-CTF6RHKG.js";
-import "./chunk-VUSCJJ4A.js";
+import "./chunk-ZGUAAVMA.js";
+import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
 import "./chunk-ZXMDA7VB.js";
 

package/dist/add-VSPZ6FM4.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import {
+  rebuildUniversityIndex,
+  saveNote,
+  saveQuiz
+} from "./chunk-GT5QGC2H.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/university/add.ts
+import chalk from "chalk";
+import { execSync } from "child_process";
+import * as os from "os";
+function resolveAuthor() {
+  try {
+    return execSync("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 20) || "unknown";
+  } catch {
+    try {
+      return os.userInfo().username;
+    } catch {
+      return "unknown";
+    }
+  }
+}
+async function universityAddCommand(type, options) {
+  const rootDir = process.cwd();
+  if (!options.title) {
+    console.error(chalk.red("\n  Error: --title is required\n"));
+    process.exit(1);
+  }
+  const author = resolveAuthor();
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const slug = options.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+  const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
+  const symbols = options.symbols ? options.symbols.split(",").map((s) => s.trim()) : [];
+  if (type === "quiz") {
+    const id2 = `Q-${slug}`;
+    const quiz = {
+      id: id2,
+      title: options.title,
+      description: options.body || "",
+      author,
+      created: today,
+      updated: today,
+      tags,
+      symbols,
+      difficulty: options.difficulty || "beginner",
+      passThreshold: 0.7,
+      questions: []
+    };
+    saveQuiz(rootDir, quiz);
+    rebuildUniversityIndex(rootDir);
+    console.log(chalk.green(`
+  Created quiz: ${id2}`));
+    console.log(chalk.gray("  Add questions by editing the YAML file\n"));
+    return;
+  }
+  const prefix = type === "policy" ? "P" : "N";
+  const id = `${prefix}-${slug}`;
+  const frontmatter = {
+    id,
+    title: options.title,
+    type,
+    author,
+    created: today,
+    updated: today,
+    tags,
+    symbols,
+    difficulty: options.difficulty || "beginner",
+    estimatedMinutes: options.minutes ? parseInt(options.minutes, 10) : void 0,
+    prerequisites: []
+  };
+  saveNote(rootDir, frontmatter, options.body || "");
+  rebuildUniversityIndex(rootDir);
+  console.log(chalk.green(`
+  Created ${type}: ${id}`));
+  console.log(chalk.gray(`  Edit at .paradigm/university/content/${type === "policy" ? "policies" : "notes"}/${id}.md
+`));
+}
+export {
+  universityAddCommand
+};

package/dist/{aggregate-XHQ6GI3Z.js → aggregate-SV3VGEIL.js}

@@ -5,8 +5,8 @@ import {
   buildSymbolIndex,
   getSymbolCounts,
   parsePremiseFile
-} from "./chunk-CTF6RHKG.js";
-import "./chunk-VUSCJJ4A.js";
+} from "./chunk-ZGUAAVMA.js";
+import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
 import "./chunk-ZXMDA7VB.js";
 

package/dist/assess-UHBDYIK7.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import {
+  addAssessment,
+  loadLoreEntry
+} from "./chunk-QIOCFXDQ.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/lore/assess.ts
+import chalk from "chalk";
+async function loreAssessCommand(id, verdict, options) {
+  const rootDir = process.cwd();
+  const validVerdicts = ["correct", "partial", "incorrect"];
+  if (!validVerdicts.includes(verdict)) {
+    console.error(chalk.red(`
+  Invalid verdict: "${verdict}". Must be one of: correct, partial, incorrect
+`));
+    process.exit(1);
+  }
+  const entry = await loadLoreEntry(rootDir, id);
+  if (!entry) {
+    console.error(chalk.red(`
+  Entry not found: ${id}
+`));
+    process.exit(1);
+  }
+  const success = await addAssessment(rootDir, id, {
+    verdict,
+    assessed_by: options.assessor || "unknown",
+    assessed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    notes: options.notes
+  });
+  if (success) {
+    const verdictColors = {
+      correct: chalk.green,
+      partial: chalk.yellow,
+      incorrect: chalk.red
+    };
+    const colorFn = verdictColors[verdict] || chalk.white;
+    console.log(chalk.green(`
+  Assessment recorded for ${id}`));
+    console.log(`  Verdict: ${colorFn(verdict)}`);
+    if (entry.confidence != null) {
+      const impliedScore = verdict === "correct" ? 1 : verdict === "partial" ? 0.5 : 0;
+      const delta = impliedScore - entry.confidence;
+      const deltaStr = `${delta > 0 ? "+" : ""}${delta.toFixed(2)}`;
+      const deltaColor = Math.abs(delta) <= 0.1 ? chalk.green : Math.abs(delta) <= 0.3 ? chalk.yellow : chalk.red;
+      console.log(`  Confidence: ${entry.confidence.toFixed(2)} | Delta: ${deltaColor(deltaStr)}`);
+      if (delta > 0.1) {
+        console.log(chalk.gray("  Under-confident (outcome better than predicted)"));
+      } else if (delta < -0.1) {
+        console.log(chalk.gray("  Over-confident (outcome worse than predicted)"));
+      } else {
+        console.log(chalk.gray("  Well-calibrated"));
+      }
+    } else {
+      console.log(chalk.gray("  No confidence recorded \u2014 delta not computed"));
+    }
+    console.log();
+  } else {
+    console.error(chalk.red(`
+  Failed to assess entry: ${id}
+`));
+    process.exit(1);
+  }
+}
+export {
+  loreAssessCommand
+};

package/dist/{beacon-BTLQMYQL.js → beacon-3SJV4DAP.js}

@@ -4,8 +4,8 @@ import {
   buildSymbolIndex,
   getAllSymbols,
   getSymbolCounts
-} from "./chunk-CTF6RHKG.js";
-import "./chunk-VUSCJJ4A.js";
+} from "./chunk-ZGUAAVMA.js";
+import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
 import {
   log

package/dist/calibration-WWHK73WU.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import {
+  loadLoreEntries
+} from "./chunk-QIOCFXDQ.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/lore/calibration.ts
+import chalk from "chalk";
+async function loreCalibrationCommand(options) {
+  const rootDir = process.cwd();
+  const entries = await loadLoreEntries(rootDir, {
+    symbol: options.symbol,
+    tag: options.tag,
+    author: options.author,
+    hasAssessment: true
+  });
+  if (entries.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ totalAssessed: 0, message: "No assessed entries found" }, null, 2));
+    } else {
+      console.log(chalk.gray("\n  No assessed lore entries found.\n"));
+      console.log(chalk.gray("  Use `paradigm lore assess <id> <correct|partial|incorrect>` to assess entries.\n"));
+    }
+    return;
+  }
+  const withConfidence = entries.filter((e) => e.confidence != null);
+  const totalAssessed = entries.length;
+  const totalWithConfidence = withConfidence.length;
+  const verdictBreakdown = { correct: 0, partial: 0, incorrect: 0 };
+  let totalImpliedScore = 0;
+  let totalConfidence = 0;
+  let totalAbsDelta = 0;
+  for (const e of entries) {
+    const v = e.assessment.verdict;
+    verdictBreakdown[v]++;
+    const implied = v === "correct" ? 1 : v === "partial" ? 0.5 : 0;
+    totalImpliedScore += implied;
+    if (e.confidence != null) {
+      totalConfidence += e.confidence;
+      totalAbsDelta += Math.abs(implied - e.confidence);
+    }
+  }
+  const accuracyRate = totalImpliedScore / totalAssessed;
+  const avgConfidence = totalWithConfidence > 0 ? totalConfidence / totalWithConfidence : null;
+  const calibrationScore = totalWithConfidence > 0 ? 1 - totalAbsDelta / totalWithConfidence : null;
+  let groups;
+  if (options.groupBy && totalAssessed > 0) {
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      let keys = [];
+      if (options.groupBy === "symbol") {
+        keys = e.symbols_touched || [];
+      } else if (options.groupBy === "tag") {
+        keys = e.tags || [];
+      } else if (options.groupBy === "type") {
+        keys = [e.type || "agent-session"];
+      }
+      for (const key of keys) {
+        if (!groupMap.has(key)) groupMap.set(key, []);
+        groupMap.get(key).push(e);
+      }
+    }
+    groups = Array.from(groupMap.entries()).map(([key, gEntries]) => {
+      const gWithConf = gEntries.filter((e) => e.confidence != null);
+      const gBreakdown = { correct: 0, partial: 0, incorrect: 0 };
+      let gImplied = 0;
+      let gConf = 0;
+      let gAbsDelta = 0;
+      for (const e of gEntries) {
+        const v = e.assessment.verdict;
+        gBreakdown[v]++;
+        const implied = v === "correct" ? 1 : v === "partial" ? 0.5 : 0;
+        gImplied += implied;
+        if (e.confidence != null) {
+          gConf += e.confidence;
+          gAbsDelta += Math.abs(implied - e.confidence);
+        }
+      }
+      return {
+        key,
+        total: gEntries.length,
+        accuracyRate: gImplied / gEntries.length,
+        avgConfidence: gWithConf.length > 0 ? gConf / gWithConf.length : null,
+        calibrationScore: gWithConf.length > 0 ? 1 - gAbsDelta / gWithConf.length : null,
+        verdictBreakdown: gBreakdown
+      };
+    }).sort((a, b) => b.total - a.total);
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      totalAssessed,
+      totalWithConfidence,
+      accuracyRate: Math.round(accuracyRate * 1e3) / 1e3,
+      avgConfidence: avgConfidence != null ? Math.round(avgConfidence * 1e3) / 1e3 : null,
+      calibrationScore: calibrationScore != null ? Math.round(calibrationScore * 1e3) / 1e3 : null,
+      verdictBreakdown,
+      ...groups ? { groups } : {}
+    }, null, 2));
+    return;
+  }
+  const caveat = totalAssessed < 5 ? chalk.gray(`  (Low sample: N=${totalAssessed}. Stats may not be representative.)`) : totalAssessed < 15 ? chalk.gray(`  (Moderate sample: N=${totalAssessed}. Trends are directional.)`) : "";
+  console.log(chalk.magenta(`
+  Calibration Report (${totalAssessed} assessed entries)
+`));
+  if (caveat) console.log(caveat + "\n");
+  const total = totalAssessed;
+  console.log(chalk.white("  Verdicts:"));
+  console.log(`    ${chalk.green("correct")}:   ${verdictBreakdown.correct}/${total} (${(verdictBreakdown.correct / total * 100).toFixed(0)}%)`);
+  console.log(`    ${chalk.yellow("partial")}:   ${verdictBreakdown.partial}/${total} (${(verdictBreakdown.partial / total * 100).toFixed(0)}%)`);
+  console.log(`    ${chalk.red("incorrect")}: ${verdictBreakdown.incorrect}/${total} (${(verdictBreakdown.incorrect / total * 100).toFixed(0)}%)`);
+  console.log();
+  console.log(chalk.white("  Scores:"));
+  const accColor = accuracyRate >= 0.8 ? chalk.green : accuracyRate >= 0.5 ? chalk.yellow : chalk.red;
+  console.log(`    Accuracy rate:    ${accColor(accuracyRate.toFixed(3))}`);
+  if (avgConfidence != null) {
+    console.log(`    Avg confidence:   ${avgConfidence.toFixed(3)}`);
+  }
+  if (calibrationScore != null) {
+    const calColor = calibrationScore >= 0.9 ? chalk.green : calibrationScore >= 0.7 ? chalk.yellow : chalk.red;
+    console.log(`    Calibration:      ${calColor(calibrationScore.toFixed(3))} (1.0 = perfect)`);
+  }
+  console.log();
+  if (groups && groups.length > 0) {
+    console.log(chalk.white(`  By ${options.groupBy}:`));
+    for (const g of groups.slice(0, 15)) {
+      const gAccColor = g.accuracyRate >= 0.8 ? chalk.green : g.accuracyRate >= 0.5 ? chalk.yellow : chalk.red;
+      const calStr = g.calibrationScore != null ? ` cal:${g.calibrationScore.toFixed(2)}` : "";
+      console.log(`    ${chalk.cyan(g.key.padEnd(25))} ${gAccColor(`acc:${g.accuracyRate.toFixed(2)}`)}${calStr}  (${g.verdictBreakdown.correct}/${g.verdictBreakdown.partial}/${g.verdictBreakdown.incorrect}) N=${g.total}`);
+    }
+    console.log();
+  }
+}
+export {
+  loreCalibrationCommand
+};

package/dist/{chunk-C5ZE6WEX.js → chunk-2SKXFXIT.js}

@@ -423,6 +423,96 @@ async function doctorCommand(options = {}) {
         });
       }
     }
+    const universityDir = path.join(cwd, ".paradigm", "university");
+    if (fs.existsSync(universityDir)) {
+      try {
+        const contentDir = path.join(universityDir, "content");
+        let contentCount = 0;
+        let issues = 0;
+        if (fs.existsSync(contentDir)) {
+          for (const subdir of ["notes", "policies", "quizzes", "paths"]) {
+            const sd = path.join(contentDir, subdir);
+            if (fs.existsSync(sd)) {
+              contentCount += fs.readdirSync(sd).filter((f) => f.endsWith(".md") || f.endsWith(".yaml")).length;
+            }
+          }
+        }
+        if (contentCount === 0) {
+          results.push({
+            name: "University content",
+            status: "warn",
+            message: "University directory exists but no content found",
+            fix: 'Add content: paradigm university add note --title "Getting Started"'
+          });
+        } else {
+          const quizDir = path.join(contentDir, "quizzes");
+          if (fs.existsSync(quizDir)) {
+            for (const file of fs.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
+              try {
+                const { parse } = await import("./dist-PSF5CP4I.js");
+                const quiz = parse(fs.readFileSync(path.join(quizDir, file), "utf8"));
+                if (quiz?.questions) {
+                  for (const q of quiz.questions) {
+                    if (q.choices && q.correct && !(q.correct in q.choices)) {
+                      issues++;
+                    }
+                  }
+                }
+              } catch {
+              }
+            }
+          }
+          const pathDir = path.join(contentDir, "paths");
+          if (fs.existsSync(pathDir)) {
+            for (const file of fs.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
+              try {
+                const { parse } = await import("./dist-PSF5CP4I.js");
+                const lp = parse(fs.readFileSync(path.join(pathDir, file), "utf8"));
+                if (lp?.steps) {
+                  for (const step of lp.steps) {
+                    if (step.content && !step.content.startsWith("plsat:")) {
+                      let found = false;
+                      for (const sd of ["notes", "policies", "quizzes", "paths"]) {
+                        const sdPath = path.join(contentDir, sd);
+                        if (fs.existsSync(sdPath)) {
+                          const files = fs.readdirSync(sdPath);
+                          if (files.some((f) => f.startsWith(step.content))) {
+                            found = true;
+                            break;
+                          }
+                        }
+                      }
+                      if (!found) issues++;
+                    }
+                  }
+                }
+              } catch {
+              }
+            }
+          }
+          if (issues > 0) {
+            results.push({
+              name: "University content",
+              status: "warn",
+              message: `${contentCount} items, ${issues} issue${issues > 1 ? "s" : ""}`,
+              fix: "Run: paradigm university validate --deep"
+            });
+          } else {
+            results.push({
+              name: "University content",
+              status: "ok",
+              message: `${contentCount} content item${contentCount > 1 ? "s" : ""}`
+            });
+          }
+        }
+      } catch {
+        results.push({
+          name: "University content",
+          status: "warn",
+          message: "Could not read university directory"
+        });
+      }
+    }
     const hooksJsonPath = path.join(cwd, ".claude", "hooks.json");
     const pluginHooksPath = path.join(cwd, "plugins", "paradigm", "hooks.json");
     if (fs.existsSync(hooksJsonPath)) {
@@ -543,7 +633,7 @@ async function doctorCommand(options = {}) {
       }
     }
   }
-  const { runContextAudit } = await import("./context-audit-RI4R2WRH.js");
+  const { runContextAudit } = await import("./context-audit-557EO6PK.js");
   const contextResults = await runContextAudit(cwd, { quiet });
   let contextErrorCount = 0;
   let contextWarnCount = 0;

package/dist/{chunk-S5TDFT5Q.js → chunk-7COU5S2Z.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-36TKPM5Z.js";
 import {
   aggregateFromDirectory
-} from "./chunk-CTF6RHKG.js";
+} from "./chunk-ZGUAAVMA.js";
 import {
   cliBuildGraphState
-} from "./chunk-Z7W7HNRG.js";
+} from "./chunk-QDXI2DHR.js";
 
 // src/commands/scan/navigator.ts
 import * as fs from "fs";

package/dist/{chunk-H4TVBJD4.js → chunk-AKIMFN6I.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   indexCommand
-} from "./chunk-S5TDFT5Q.js";
+} from "./chunk-7COU5S2Z.js";
 import {
   getDefaultPremiseContent
-} from "./chunk-CTF6RHKG.js";
+} from "./chunk-ZGUAAVMA.js";
 import {
   getDefaultPurposeContent
-} from "./chunk-VUSCJJ4A.js";
+} from "./chunk-EDOAWN7J.js";
 import {
   STACK_PRESETS,
   detectDiscipline,

package/dist/{chunk-3DYYXGDC.js → chunk-CDMAMDSG.js}

@@ -300,10 +300,36 @@ async function updateLoreEntry(rootDir, entryId, partial) {
   if (partial.linked_lore !== void 0) entry.linked_lore = partial.linked_lore;
   if (partial.linked_tasks !== void 0) entry.linked_tasks = partial.linked_tasks;
   if (partial.linked_commits !== void 0) entry.linked_commits = partial.linked_commits;
+  if (partial.confidence !== void 0) entry.confidence = partial.confidence;
+  if (partial.assessment !== void 0) entry.assessment = partial.assessment;
+  if (partial.assessment_delta !== void 0) entry.assessment_delta = partial.assessment_delta;
   fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
   await rebuildTimeline(rootDir);
   return true;
 }
+function verdictToScore(verdict) {
+  switch (verdict) {
+    case "correct":
+      return 1;
+    case "partial":
+      return 0.5;
+    case "incorrect":
+      return 0;
+  }
+}
+async function addLoreAssessment(rootDir, entryId, assessment) {
+  const entry = await loadLoreEntry(rootDir, entryId);
+  if (!entry) return false;
+  const dateStr = entry.timestamp.slice(0, 10);
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) return false;
+  entry.assessment = assessment;
+  if (entry.confidence != null) {
+    entry.assessment_delta = verdictToScore(assessment.verdict) - entry.confidence;
+  }
+  fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
+  return true;
+}
 async function deleteLoreEntry(rootDir, entryId) {
   const entry = await loadLoreEntry(rootDir, entryId);
   if (!entry) return false;
@@ -366,6 +392,12 @@ function applyFilter(entries, filter) {
   if (filter.hasReview !== void 0) {
     result = result.filter((e) => filter.hasReview ? e.review != null : e.review == null);
   }
+  if (filter.hasConfidence !== void 0) {
+    result = result.filter((e) => filter.hasConfidence ? e.confidence != null : e.confidence == null);
+  }
+  if (filter.hasAssessment !== void 0) {
+    result = result.filter((e) => filter.hasAssessment ? e.assessment != null : e.assessment == null);
+  }
   result.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
   if (filter.offset) result = result.slice(filter.offset);
   if (filter.limit) result = result.slice(0, filter.limit);
@@ -399,5 +431,6 @@ export {
   addLoreReview,
   rebuildTimeline,
   updateLoreEntry,
+  addLoreAssessment,
   deleteLoreEntry
 };

package/dist/chunk-F3BCHPYT.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+// src/graph-server/routes/symbols.ts
+import { Router } from "express";
+import * as fs from "fs";
+import * as path from "path";
+function createSymbolsRouter(projectDir) {
+  const router = Router();
+  router.get("/", (_req, res) => {
+    const indexPath = path.join(projectDir, ".paradigm", "scan-index.json");
+    if (!fs.existsSync(indexPath)) {
+      res.status(404).json({
+        error: "scan-index.json not found",
+        hint: "Run `paradigm scan` to generate the symbol index."
+      });
+      return;
+    }
+    try {
+      const raw = fs.readFileSync(indexPath, "utf-8");
+      const index = JSON.parse(raw);
+      const categoryMap = {
+        components: "component",
+        features: "component",
+        flows: "flow",
+        state: "component",
+        gates: "gate",
+        signals: "signal",
+        aspects: "aspect",
+        screens: "component"
+      };
+      const prefixMap = {
+        component: "#",
+        flow: "$",
+        gate: "^",
+        signal: "!",
+        aspect: "~"
+      };
+      const symbols = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const [sectionKey, category] of Object.entries(categoryMap)) {
+        const entries = index[sectionKey];
+        if (!entries || typeof entries !== "object") continue;
+        const items = Array.isArray(entries) ? entries : Object.values(entries);
+        for (const entry of items) {
+          const name = entry.name || entry.id || "";
+          if (!name || seen.has(name)) continue;
+          seen.add(name);
+          symbols.push({
+            id: name,
+            name,
+            category,
+            prefix: prefixMap[category] || "#",
+            description: entry.description || "",
+            path: entry.path || entry.file || "",
+            tags: entry.tags || [],
+            related: entry.related || []
+          });
+        }
+      }
+      res.json({
+        symbols,
+        meta: {
+          total: symbols.length,
+          projectDir,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    } catch (err) {
+      res.status(500).json({
+        error: "Failed to read scan-index.json",
+        details: err.message
+      });
+    }
+  });
+  return router;
+}
+
+// src/graph-server/routes/graphs.ts
+import { Router as Router2 } from "express";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var GRAPHS_DIR = ".paradigm/graphs";
+function createGraphsRouter(projectDir) {
+  const router = Router2();
+  const graphsPath = path2.join(projectDir, GRAPHS_DIR);
+  router.get("/", (_req, res) => {
+    if (!fs2.existsSync(graphsPath)) {
+      res.json({ graphs: [] });
+      return;
+    }
+    try {
+      const files = fs2.readdirSync(graphsPath).filter((f) => f.endsWith(".graph.json"));
+      const graphs = files.map((file) => {
+        const filePath = path2.join(graphsPath, file);
+        const stat = fs2.statSync(filePath);
+        const slug = file.replace(/\.graph\.json$/, "");
+        let name = slug;
+        let nodeCount = 0;
+        let edgeCount = 0;
+        try {
+          const raw = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+          name = raw.name || slug;
+          nodeCount = Array.isArray(raw.nodes) ? raw.nodes.length : 0;
+          edgeCount = Array.isArray(raw.edges) ? raw.edges.length : 0;
+        } catch {
+        }
+        return {
+          slug,
+          file,
+          name,
+          nodes: nodeCount,
+          edges: edgeCount,
+          size: stat.size,
+          modified: stat.mtime.toISOString()
+        };
+      });
+      graphs.sort((a, b) => b.modified.localeCompare(a.modified));
+      res.json({ graphs });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to list graphs", details: err.message });
+    }
+  });
+  router.get("/:slug", (req, res) => {
+    const slug = req.params.slug;
+    const filePath = path2.join(graphsPath, `${slug}.graph.json`);
+    if (!fs2.existsSync(filePath)) {
+      res.status(404).json({ error: `Graph "${slug}" not found` });
+      return;
+    }
+    try {
+      const raw = fs2.readFileSync(filePath, "utf8");
+      res.type("application/json").send(raw);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to read graph", details: err.message });
+    }
+  });
+  return router;
+}
+
+export {
+  createSymbolsRouter,
+  createGraphsRouter
+};