@grainulation/orchard 1.0.1 → 1.0.4

package/lib/server.js

@@ -11,26 +11,36 @@
  *   orchard serve [--port 9097] [--root /path/to/repo]
  */
 
-import { createServer } from 'node:http';
-import { readFileSync, existsSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { join, resolve, extname, dirname, basename } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-import { watch as fsWatch } from 'node:fs';
+import { createServer } from "node:http";
+import {
+  readFileSync,
+  existsSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join, resolve, extname, dirname, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { watch as fsWatch } from "node:fs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 
 // ── Crash handlers ──
-process.on('uncaughtException', (err) => {
-  process.stderr.write(`[${new Date().toISOString()}] FATAL: ${err.stack || err}\n`);
+process.on("uncaughtException", (err) => {
+  process.stderr.write(
+    `[${new Date().toISOString()}] FATAL: ${err.stack || err}\n`,
+  );
   process.exit(1);
 });
-process.on('unhandledRejection', (reason) => {
-  process.stderr.write(`[${new Date().toISOString()}] WARN unhandledRejection: ${reason}\n`);
+process.on("unhandledRejection", (reason) => {
+  process.stderr.write(
+    `[${new Date().toISOString()}] WARN unhandledRejection: ${reason}\n`,
+  );
 });
 
-const PUBLIC_DIR = join(__dirname, '..', 'public');
+const PUBLIC_DIR = join(__dirname, "..", "public");
 
 // ── CLI args ──────────────────────────────────────────────────────────────────
 
@@ -40,47 +50,107 @@ function arg(name, fallback) {
   return i !== -1 && args[i + 1] ? args[i + 1] : fallback;
 }
 
-const PORT = parseInt(arg('port', '9097'), 10);
-const CORS_ORIGIN = arg('cors', null);
+const PORT = parseInt(arg("port", "9097"), 10);
+const CORS_ORIGIN = arg("cors", null);
 
 // Resolve ROOT: walk up from cwd to find a directory with claims.json or orchard.json
 function resolveRoot(initial) {
-  if (existsSync(join(initial, 'claims.json')) || existsSync(join(initial, 'orchard.json'))) return initial;
+  if (
+    existsSync(join(initial, "claims.json")) ||
+    existsSync(join(initial, "orchard.json"))
+  )
+    return initial;
   let dir = initial;
   for (let i = 0; i < 5; i++) {
-    const parent = resolve(dir, '..');
+    const parent = resolve(dir, "..");
     if (parent === dir) break;
     dir = parent;
-    if (existsSync(join(dir, 'claims.json')) || existsSync(join(dir, 'orchard.json'))) return dir;
+    if (
+      existsSync(join(dir, "claims.json")) ||
+      existsSync(join(dir, "orchard.json"))
+    )
+      return dir;
   }
   return initial;
 }
-const ROOT = resolveRoot(resolve(arg('root', process.cwd())));
+const ROOT = resolveRoot(resolve(arg("root", process.cwd())));
 
 // ── Verbose logging ──────────────────────────────────────────────────────────
 
-const verbose = process.argv.includes('--verbose') || process.argv.includes('-v');
+const verbose =
+  process.argv.includes("--verbose") || process.argv.includes("-v");
 function vlog(...a) {
   if (!verbose) return;
   const ts = new Date().toISOString();
-  process.stderr.write(`[${ts}] orchard: ${a.join(' ')}\n`);
+  process.stderr.write(`[${ts}] orchard: ${a.join(" ")}\n`);
 }
 
 // ── Routes manifest ──────────────────────────────────────────────────────────
 
 const ROUTES = [
-  { method: 'GET', path: '/events', description: 'SSE event stream for live updates' },
-  { method: 'GET', path: '/api/portfolio', description: 'Sprint portfolio with status and metadata' },
-  { method: 'GET', path: '/api/dependencies', description: 'Sprint dependency graph (nodes + edges)' },
-  { method: 'GET', path: '/api/conflicts', description: 'Cross-sprint claim conflicts' },
-  { method: 'GET', path: '/api/timeline', description: 'Sprint phase timeline with dates' },
-  { method: 'POST', path: '/api/scan', description: 'Rescan directories for sprint changes' },
-  { method: 'GET', path: '/api/docs', description: 'This API documentation page' },
+  {
+    method: "GET",
+    path: "/events",
+    description: "SSE event stream for live updates",
+  },
+  {
+    method: "GET",
+    path: "/api/portfolio",
+    description: "Sprint portfolio with status and metadata",
+  },
+  {
+    method: "GET",
+    path: "/api/dependencies",
+    description: "Sprint dependency graph (nodes + edges)",
+  },
+  {
+    method: "GET",
+    path: "/api/dependencies/mermaid",
+    description: "Sprint dependency graph as Mermaid DAG",
+  },
+  {
+    method: "GET",
+    path: "/api/conflicts",
+    description:
+      "Cross-sprint claim conflicts (?severity=critical|warning|info)",
+  },
+  {
+    method: "GET",
+    path: "/api/timeline",
+    description: "Sprint phase timeline with dates",
+  },
+  {
+    method: "GET",
+    path: "/api/hackathon",
+    description: "Hackathon timer and leaderboard",
+  },
+  {
+    method: "POST",
+    path: "/api/decompose",
+    description: "Auto-decompose a question into sub-sprints",
+  },
+  {
+    method: "POST",
+    path: "/api/scan",
+    description: "Rescan directories for sprint changes",
+  },
+  {
+    method: "GET",
+    path: "/api/docs",
+    description: "This API documentation page",
+  },
 ];
 
 // ── Load existing CJS modules via createRequire ──────────────────────────────
 
-const { claimsPaths } = require('./dashboard.js');
+const { claimsPaths } = require("./dashboard.js");
+const { generateMermaid } = require("./planner.js");
+const {
+  filterBySeverity: filterConflictsBySeverity,
+  SEVERITY,
+} = require("./conflicts.js");
+const hackathonLib = require("./hackathon.js");
+const decomposeLib = require("./decompose.js");
 
 // ── State ─────────────────────────────────────────────────────────────────────
 
@@ -97,7 +167,11 @@ const sseClients = new Set();
 function broadcast(event) {
   const data = `data: ${JSON.stringify(event)}\n\n`;
   for (const res of sseClients) {
-    try { res.write(data); } catch { sseClients.delete(res); }
+    try {
+      res.write(data);
+    } catch {
+      sseClients.delete(res);
+    }
   }
 }
 
@@ -105,15 +179,17 @@ function broadcast(event) {
 
 function scanForSprints(rootDir) {
   const sprints = [];
-  const orchardJson = join(rootDir, 'orchard.json');
+  const orchardJson = join(rootDir, "orchard.json");
 
   // If there's an orchard.json, use its sprint list as hints
   let configSprints = [];
   if (existsSync(orchardJson)) {
     try {
-      const config = JSON.parse(readFileSync(orchardJson, 'utf8'));
+      const config = JSON.parse(readFileSync(orchardJson, "utf8"));
       configSprints = config.sprints || [];
-    } catch { /* ignore */ }
+    } catch {
+      /* ignore */
+    }
   }
 
   // Also scan directory tree for claims.json files (up to 3 levels deep)
@@ -124,16 +200,19 @@ function scanForSprints(rootDir) {
       const entries = readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+          continue;
         const sub = join(dir, entry.name);
-        const claimsPath = join(sub, 'claims.json');
+        const claimsPath = join(sub, "claims.json");
         if (existsSync(claimsPath) && !seen.has(sub)) {
           seen.add(sub);
           sprints.push(readSprintDir(sub));
         }
         walk(sub, depth + 1);
       }
-    } catch { /* permission errors, etc */ }
+    } catch {
+      /* permission errors, etc */
+    }
   }
 
   // Add configured sprints first
@@ -156,12 +235,12 @@ function scanForSprints(rootDir) {
 }
 
 function readSprintDir(dir) {
-  const name = dir.split('/').pop();
+  const name = dir.split("/").pop();
   const info = {
     path: dir,
     name,
-    phase: 'unknown',
-    status: 'unknown',
+    phase: "unknown",
+    status: "unknown",
     claimCount: 0,
     claimTypes: {},
     hasCompilation: false,
@@ -175,16 +254,16 @@ function readSprintDir(dir) {
   };
 
   // Read claims.json
-  const claimsPath = join(dir, 'claims.json');
+  const claimsPath = join(dir, "claims.json");
   if (existsSync(claimsPath)) {
     try {
-      const raw = JSON.parse(readFileSync(claimsPath, 'utf8'));
-      const claims = Array.isArray(raw) ? raw : (raw.claims || []);
+      const raw = JSON.parse(readFileSync(claimsPath, "utf8"));
+      const claims = Array.isArray(raw) ? raw : raw.claims || [];
       info.claimCount = claims.length;
 
       // Count types
       for (const c of claims) {
-        const t = c.type || 'unknown';
+        const t = c.type || "unknown";
         info.claimTypes[t] = (info.claimTypes[t] || 0) + 1;
         // Collect tags
         for (const tag of c.tags || []) {
@@ -193,46 +272,55 @@ function readSprintDir(dir) {
       }
 
       // Infer phase from claim ID prefixes
-      const prefixes = claims.map(c => (c.id || '').replace(/\d+$/, '')).filter(Boolean);
-      if (prefixes.some(p => p.startsWith('cal'))) info.phase = 'calibrate';
-      else if (prefixes.some(p => p === 'f')) info.phase = 'feedback';
-      else if (prefixes.some(p => p === 'e')) info.phase = 'evaluate';
-      else if (prefixes.some(p => p === 'p')) info.phase = 'prototype';
-      else if (prefixes.some(p => p === 'x' || p === 'w')) info.phase = 'challenge';
-      else if (prefixes.some(p => p === 'r')) info.phase = 'research';
-      else if (prefixes.some(p => p === 'd')) info.phase = 'define';
+      const prefixes = claims
+        .map((c) => (c.id || "").replace(/\d+$/, ""))
+        .filter(Boolean);
+      if (prefixes.some((p) => p.startsWith("cal"))) info.phase = "calibrate";
+      else if (prefixes.some((p) => p === "f")) info.phase = "feedback";
+      else if (prefixes.some((p) => p === "e")) info.phase = "evaluate";
+      else if (prefixes.some((p) => p === "p")) info.phase = "prototype";
+      else if (prefixes.some((p) => p === "x" || p === "w"))
+        info.phase = "challenge";
+      else if (prefixes.some((p) => p === "r")) info.phase = "research";
+      else if (prefixes.some((p) => p === "d")) info.phase = "define";
 
       const stat = statSync(claimsPath);
       info.lastModified = stat.mtime.toISOString();
-    } catch { /* ignore parse errors */ }
+    } catch {
+      /* ignore parse errors */
+    }
   }
 
   // Check compilation
-  const compilationPath = join(dir, 'compilation.json');
+  const compilationPath = join(dir, "compilation.json");
   if (existsSync(compilationPath)) {
     info.hasCompilation = true;
     try {
-      const comp = JSON.parse(readFileSync(compilationPath, 'utf8'));
+      const comp = JSON.parse(readFileSync(compilationPath, "utf8"));
       if (comp.question) info.question = comp.question;
-    } catch { /* ignore */ }
+    } catch {
+      /* ignore */
+    }
   }
 
   // Check CLAUDE.md for question
   if (!info.question) {
-    const claudePath = join(dir, 'CLAUDE.md');
+    const claudePath = join(dir, "CLAUDE.md");
     if (existsSync(claudePath)) {
       try {
-        const md = readFileSync(claudePath, 'utf8');
+        const md = readFileSync(claudePath, "utf8");
         const match = md.match(/\*\*Question:\*\*\s*(.+)/);
         if (match) info.question = match[1].trim();
-      } catch { /* ignore */ }
+      } catch {
+        /* ignore */
+      }
     }
   }
 
   // Infer status
-  if (info.claimCount === 0) info.status = 'not-started';
-  else if (info.hasCompilation) info.status = 'compiled';
-  else info.status = 'active';
+  if (info.claimCount === 0) info.status = "not-started";
+  else if (info.hasCompilation) info.status = "compiled";
+  else info.status = "active";
 
   return info;
 }
@@ -240,7 +328,7 @@ function readSprintDir(dir) {
 // ── Dependencies — detect cross-sprint references ─────────────────────────────
 
 function buildDependencies(sprints) {
-  const nodes = sprints.map(s => ({
+  const nodes = sprints.map((s) => ({
     id: s.path,
     name: s.name,
     phase: s.phase,
@@ -249,24 +337,24 @@ function buildDependencies(sprints) {
   }));
 
   const edges = [];
-  const sprintPaths = new Set(sprints.map(s => s.path));
+  const sprintPaths = new Set(sprints.map((s) => s.path));
 
   for (const sprint of sprints) {
     // Check explicit depends_on from orchard.json
     for (const dep of sprint.dependsOn || []) {
       const resolved_dep = resolve(ROOT, dep);
       if (sprintPaths.has(resolved_dep)) {
-        edges.push({ from: resolved_dep, to: sprint.path, type: 'explicit' });
+        edges.push({ from: resolved_dep, to: sprint.path, type: "explicit" });
       }
     }
 
     // Check claims for cross-references (claim IDs from other sprints)
-    const claimsPath_dep = join(sprint.path, 'claims.json');
+    const claimsPath_dep = join(sprint.path, "claims.json");
     if (!existsSync(claimsPath_dep)) continue;
 
     try {
-      const raw = JSON.parse(readFileSync(claimsPath_dep, 'utf8'));
-      const claims = Array.isArray(raw) ? raw : (raw.claims || []);
+      const raw = JSON.parse(readFileSync(claimsPath_dep, "utf8"));
+      const claims = Array.isArray(raw) ? raw : raw.claims || [];
       const text = JSON.stringify(claims);
 
       for (const other of sprints) {
@@ -274,15 +362,24 @@ function buildDependencies(sprints) {
         const otherName = other.name;
         // Check if claims mention other sprint by name or path
         if (text.includes(otherName) && otherName.length > 3) {
-          const exists = edges.some(e =>
-            e.from === other.path && e.to === sprint.path && e.type === 'reference'
+          const exists = edges.some(
+            (e) =>
+              e.from === other.path &&
+              e.to === sprint.path &&
+              e.type === "reference",
           );
           if (!exists) {
-            edges.push({ from: other.path, to: sprint.path, type: 'reference' });
+            edges.push({
+              from: other.path,
+              to: sprint.path,
+              type: "reference",
+            });
           }
         }
       }
-    } catch { /* ignore */ }
+    } catch {
+      /* ignore */
+    }
   }
 
   return { nodes, edges };
@@ -294,15 +391,21 @@ function detectConflicts(sprints) {
   const allClaims = [];
 
   for (const sprint of sprints) {
-    const claimsPath = join(sprint.path, 'claims.json');
+    const claimsPath = join(sprint.path, "claims.json");
     if (!existsSync(claimsPath)) continue;
     try {
-      const raw = JSON.parse(readFileSync(claimsPath, 'utf8'));
-      const claims = Array.isArray(raw) ? raw : (raw.claims || []);
+      const raw = JSON.parse(readFileSync(claimsPath, "utf8"));
+      const claims = Array.isArray(raw) ? raw : raw.claims || [];
       for (const c of claims) {
-        allClaims.push({ ...c, _sprint: sprint.name, _sprintPath: sprint.path });
+        allClaims.push({
+          ...c,
+          _sprint: sprint.name,
+          _sprintPath: sprint.path,
+        });
       }
-    } catch { /* ignore */ }
+    } catch {
+      /* ignore */
+    }
   }
 
   const conflicts = [];
@@ -323,29 +426,47 @@ function detectConflicts(sprints) {
         if (a._sprintPath === b._sprintPath) continue;
 
         // Opposing recommendations
-        if (a.type === 'recommendation' && b.type === 'recommendation') {
+        if (a.type === "recommendation" && b.type === "recommendation") {
           if (couldContradict(a.text, b.text)) {
             conflicts.push({
-              type: 'opposing-recommendations',
+              type: "opposing-recommendations",
               tag,
-              claimA: { id: a.id, text: (a.text || '').substring(0, 120), sprint: a._sprint },
-              claimB: { id: b.id, text: (b.text || '').substring(0, 120), sprint: b._sprint },
-              severity: 'high',
+              claimA: {
+                id: a.id,
+                text: (a.text || "").substring(0, 120),
+                sprint: a._sprint,
+              },
+              claimB: {
+                id: b.id,
+                text: (b.text || "").substring(0, 120),
+                sprint: b._sprint,
+              },
+              severity: "high",
             });
           }
         }
 
         // Constraint vs recommendation
         if (
-          (a.type === 'constraint' && b.type === 'recommendation') ||
-          (a.type === 'recommendation' && b.type === 'constraint')
+          (a.type === "constraint" && b.type === "recommendation") ||
+          (a.type === "recommendation" && b.type === "constraint")
         ) {
           conflicts.push({
-            type: 'constraint-tension',
+            type: "constraint-tension",
             tag,
-            claimA: { id: a.id, text: (a.text || '').substring(0, 120), sprint: a._sprint, type: a.type },
-            claimB: { id: b.id, text: (b.text || '').substring(0, 120), sprint: b._sprint, type: b.type },
-            severity: 'medium',
+            claimA: {
+              id: a.id,
+              text: (a.text || "").substring(0, 120),
+              sprint: a._sprint,
+              type: a.type,
+            },
+            claimB: {
+              id: b.id,
+              text: (b.text || "").substring(0, 120),
+              sprint: b._sprint,
+              type: b.type,
+            },
+            severity: "medium",
           });
         }
       }
@@ -357,46 +478,68 @@ function detectConflicts(sprints) {
 
 function couldContradict(textA, textB) {
   if (!textA || !textB) return false;
-  const negators = ['not', 'no', 'never', 'avoid', 'instead', 'rather', 'without', "don't"];
+  const negators = [
+    "not",
+    "no",
+    "never",
+    "avoid",
+    "instead",
+    "rather",
+    "without",
+    "don't",
+  ];
   const aWords = new Set(textA.toLowerCase().split(/\s+/));
   const bWords = new Set(textB.toLowerCase().split(/\s+/));
-  const aNeg = negators.some(n => aWords.has(n));
-  const bNeg = negators.some(n => bWords.has(n));
+  const aNeg = negators.some((n) => aWords.has(n));
+  const bNeg = negators.some((n) => bWords.has(n));
   return aNeg !== bNeg;
 }
 
 // ── Timeline — extract phase transitions ──────────────────────────────────────
 
 function buildTimeline(sprints) {
-  return sprints.map(s => {
+  return sprints.map((s) => {
     const phases = [];
-    const claimsPath = join(s.path, 'claims.json');
+    const claimsPath = join(s.path, "claims.json");
 
     if (existsSync(claimsPath)) {
       try {
-        const raw = JSON.parse(readFileSync(claimsPath, 'utf8'));
-        const claims = Array.isArray(raw) ? raw : (raw.claims || []);
+        const raw = JSON.parse(readFileSync(claimsPath, "utf8"));
+        const claims = Array.isArray(raw) ? raw : raw.claims || [];
 
         // Group claims by prefix to detect phase transitions
         const phaseMap = new Map();
         for (const c of claims) {
-          const prefix = (c.id || '').replace(/\d+$/, '');
+          const prefix = (c.id || "").replace(/\d+$/, "");
           const date = c.created || c.date || null;
           if (!prefix) continue;
 
           const phaseName =
-            prefix === 'd' ? 'define' :
-            prefix === 'r' ? 'research' :
-            prefix === 'p' ? 'prototype' :
-            prefix === 'e' ? 'evaluate' :
-            prefix === 'f' ? 'feedback' :
-            prefix === 'x' ? 'challenge' :
-            prefix === 'w' ? 'witness' :
-            prefix.startsWith('cal') ? 'calibrate' :
-            'other';
+            prefix === "d"
+              ? "define"
+              : prefix === "r"
+                ? "research"
+                : prefix === "p"
+                  ? "prototype"
+                  : prefix === "e"
+                    ? "evaluate"
+                    : prefix === "f"
+                      ? "feedback"
+                      : prefix === "x"
+                        ? "challenge"
+                        : prefix === "w"
+                          ? "witness"
+                          : prefix.startsWith("cal")
+                            ? "calibrate"
+                            : "other";
 
           if (!phaseMap.has(phaseName)) {
-            phaseMap.set(phaseName, { name: phaseName, claimCount: 0, firstDate: date, lastDate: date });
+            phaseMap.set(phaseName, {
+              name: phaseName,
+              claimCount: 0,
+              firstDate: date,
+              lastDate: date,
+            });
           }
           const p = phaseMap.get(phaseName);
           p.claimCount++;
@@ -405,7 +548,9 @@ function buildTimeline(sprints) {
         }
 
         phases.push(...phaseMap.values());
-      } catch { /* ignore */ }
+      } catch {
+        /* ignore */
+      }
     }
 
     return {
@@ -423,7 +568,7 @@ function buildTimeline(sprints) {
 
 function refreshState() {
   const sprints = scanForSprints(ROOT);
-  state.portfolio = sprints.map(s => ({
+  state.portfolio = sprints.map((s) => ({
     name: s.name,
     path: s.path,
     phase: s.phase,
@@ -441,36 +586,39 @@ function refreshState() {
   state.conflicts = detectConflicts(sprints);
   state.timeline = buildTimeline(sprints);
   state.lastScan = new Date().toISOString();
-  broadcast({ type: 'state', data: state });
+  broadcast({ type: "state", data: state });
 }
 
 // ── MIME types ────────────────────────────────────────────────────────────────
 
 const MIME = {
-  '.html': 'text/html; charset=utf-8',
-  '.css': 'text/css; charset=utf-8',
-  '.js': 'application/javascript; charset=utf-8',
-  '.json': 'application/json; charset=utf-8',
-  '.svg': 'image/svg+xml',
-  '.png': 'image/png',
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
 };
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function json(res, data, status = 200) {
-  res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
   res.end(JSON.stringify(data));
 }
 
 function readBody(req) {
   return new Promise((resolve, reject) => {
     const chunks = [];
-    req.on('data', c => chunks.push(c));
-    req.on('end', () => {
-      try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
-      catch { resolve({}); }
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch {
+        resolve({});
+      }
     });
-    req.on('error', reject);
+    req.on("error", reject);
   });
 }
 
@@ -481,92 +629,159 @@ const server = createServer(async (req, res) => {
 
   // CORS (only when --cors is passed)
   if (CORS_ORIGIN) {
-    res.setHeader('Access-Control-Allow-Origin', CORS_ORIGIN);
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    res.setHeader("Access-Control-Allow-Origin", CORS_ORIGIN);
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
   }
 
-  if (req.method === 'OPTIONS' && CORS_ORIGIN) {
+  if (req.method === "OPTIONS" && CORS_ORIGIN) {
     res.writeHead(204);
     res.end();
     return;
   }
 
-  vlog('request', req.method, url.pathname);
+  vlog("request", req.method, url.pathname);
 
   // ── API: docs ──
-  if (req.method === 'GET' && url.pathname === '/api/docs') {
+  if (req.method === "GET" && url.pathname === "/api/docs") {
     const html = `<!DOCTYPE html><html><head><title>orchard API</title>
 <style>body{font-family:system-ui;background:#0a0e1a;color:#e8ecf1;max-width:800px;margin:40px auto;padding:0 20px}
 table{width:100%;border-collapse:collapse}th,td{padding:8px 12px;border-bottom:1px solid #1e293b;text-align:left}
 th{color:#9ca3af}code{background:#1e293b;padding:2px 6px;border-radius:4px;font-size:13px}</style></head>
 <body><h1>orchard API</h1><p>${ROUTES.length} endpoints</p>
 <table><tr><th>Method</th><th>Path</th><th>Description</th></tr>
-${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</code></td><td>'+r.description+'</td></tr>').join('')}
+${ROUTES.map((r) => "<tr><td><code>" + r.method + "</code></td><td><code>" + r.path + "</code></td><td>" + r.description + "</td></tr>").join("")}
 </table></body></html>`;
-    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.writeHead(200, { "Content-Type": "text/html" });
     res.end(html);
     return;
   }
 
   // ── SSE endpoint ──
-  if (req.method === 'GET' && url.pathname === '/events') {
+  if (req.method === "GET" && url.pathname === "/events") {
     res.writeHead(200, {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
     });
-    res.write(`data: ${JSON.stringify({ type: 'state', data: state })}\n\n`);
+    res.write(`data: ${JSON.stringify({ type: "state", data: state })}\n\n`);
     const heartbeat = setInterval(() => {
-      try { res.write(': heartbeat\n\n'); } catch { clearInterval(heartbeat); }
+      try {
+        res.write(": heartbeat\n\n");
+      } catch {
+        clearInterval(heartbeat);
+      }
     }, 15000);
     sseClients.add(res);
-    vlog('sse', `client connected (${sseClients.size} total)`);
-    req.on('close', () => { clearInterval(heartbeat); sseClients.delete(res); vlog('sse', `client disconnected (${sseClients.size} total)`); });
+    vlog("sse", `client connected (${sseClients.size} total)`);
+    req.on("close", () => {
+      clearInterval(heartbeat);
+      sseClients.delete(res);
+      vlog("sse", `client disconnected (${sseClients.size} total)`);
+    });
     return;
   }
 
   // ── API: portfolio ──
-  if (req.method === 'GET' && url.pathname === '/api/portfolio') {
+  if (req.method === "GET" && url.pathname === "/api/portfolio") {
     json(res, { portfolio: state.portfolio, lastScan: state.lastScan });
     return;
   }
 
   // ── API: dependencies ──
-  if (req.method === 'GET' && url.pathname === '/api/dependencies') {
+  if (req.method === "GET" && url.pathname === "/api/dependencies") {
     json(res, state.dependencies);
     return;
   }
 
+  // ── API: dependencies/mermaid ──
+  if (req.method === "GET" && url.pathname === "/api/dependencies/mermaid") {
+    // Build an orchard-style config from server state for generateMermaid
+    const orchardJson = join(ROOT, "orchard.json");
+    let config = { sprints: [] };
+    if (existsSync(orchardJson)) {
+      try {
+        config = JSON.parse(readFileSync(orchardJson, "utf8"));
+      } catch {
+        /* ignore */
+      }
+    }
+    const mermaid = generateMermaid(config);
+    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end(mermaid);
+    return;
+  }
+
   // ── API: conflicts ──
-  if (req.method === 'GET' && url.pathname === '/api/conflicts') {
-    json(res, { conflicts: state.conflicts, count: state.conflicts.length });
+  if (req.method === "GET" && url.pathname === "/api/conflicts") {
+    const severity = url.searchParams.get("severity") || "info";
+    const filtered = filterConflictsBySeverity(state.conflicts, severity);
+    json(res, { conflicts: filtered, count: filtered.length });
+    return;
+  }
+
+  // ── API: hackathon ──
+  if (req.method === "GET" && url.pathname === "/api/hackathon") {
+    const timer = hackathonLib.timerStatus(ROOT);
+    const board = hackathonLib.leaderboard(ROOT);
+    json(res, { timer, leaderboard: board });
+    return;
+  }
+
+  // ── API: decompose ──
+  if (req.method === "POST" && url.pathname === "/api/decompose") {
+    const body = await readBody(req);
+    const question = body.question;
+    if (!question) {
+      json(res, { error: "question field required" }, 400);
+      return;
+    }
+    const apply = body.apply === true;
+    if (apply) {
+      const sprints = decomposeLib.applyDecomposition(ROOT, question, {
+        maxSprints: body.maxSprints,
+      });
+      refreshState();
+      json(res, { applied: true, sprints });
+    } else {
+      const sprints = decomposeLib.decompose(question, {
+        maxSprints: body.maxSprints,
+      });
+      json(res, { preview: true, sprints });
+    }
     return;
   }
 
   // ── API: timeline ──
-  if (req.method === 'GET' && url.pathname === '/api/timeline') {
+  if (req.method === "GET" && url.pathname === "/api/timeline") {
     json(res, { timeline: state.timeline });
     return;
   }
 
   // ── API: scan ──
-  if (req.method === 'POST' && url.pathname === '/api/scan') {
+  if (req.method === "POST" && url.pathname === "/api/scan") {
     refreshState();
-    json(res, { ok: true, sprintCount: state.portfolio.length, lastScan: state.lastScan });
+    json(res, {
+      ok: true,
+      sprintCount: state.portfolio.length,
+      lastScan: state.lastScan,
+    });
     return;
   }
 
   // ── Dashboard UI (web app from public/) ──
-  if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/index.html')) {
-    const indexPath = join(PUBLIC_DIR, 'index.html');
+  if (
+    req.method === "GET" &&
+    (url.pathname === "/" || url.pathname === "/index.html")
+  ) {
+    const indexPath = join(PUBLIC_DIR, "index.html");
     try {
-      const html = readFileSync(indexPath, 'utf8');
-      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      const html = readFileSync(indexPath, "utf8");
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(html);
     } catch (err) {
-      res.writeHead(500, { 'Content-Type': 'text/plain' });
-      res.end('Error reading dashboard: ' + err.message);
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("Error reading dashboard: " + err.message);
     }
     return;
   }
@@ -577,40 +792,44 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
 
   if (existsSync(filePath) && !statSync(filePath).isDirectory()) {
     const ext = extname(filePath);
-    const mime = MIME[ext] || 'application/octet-stream';
+    const mime = MIME[ext] || "application/octet-stream";
     try {
       const content = readFileSync(filePath);
-      res.writeHead(200, { 'Content-Type': mime });
+      res.writeHead(200, { "Content-Type": mime });
       res.end(content);
     } catch {
       res.writeHead(500);
-      res.end('read error');
+      res.end("read error");
     }
     return;
   }
 
   // ── 404 ──
-  res.writeHead(404, { 'Content-Type': 'text/plain' });
-  res.end('not found');
+  res.writeHead(404, { "Content-Type": "text/plain" });
+  res.end("not found");
 });
 
 // ── Graceful shutdown ─────────────────────────────────────────────────────────
 const shutdown = (signal) => {
   console.log(`\norchard: ${signal} received, shutting down...`);
-  for (const res of sseClients) { try { res.end(); } catch {} }
+  for (const res of sseClients) {
+    try {
+      res.end();
+    } catch {}
+  }
   sseClients.clear();
   server.close(() => process.exit(0));
   setTimeout(() => process.exit(1), 5000);
 };
-process.on('SIGTERM', () => shutdown('SIGTERM'));
-process.on('SIGINT', () => shutdown('SIGINT'));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
 
 // ── Start ─────────────────────────────────────────────────────────────────────
 
 refreshState();
 
-server.on('error', (err) => {
-  if (err.code === 'EADDRINUSE') {
+server.on("error", (err) => {
+  if (err.code === "EADDRINUSE") {
     console.error(`\norchard: port ${PORT} is already in use.`);
     console.error(`  Try: orchard serve --port ${Number(PORT) + 1}`);
     console.error(`  Or stop the process using port ${PORT}.\n`);
@@ -629,9 +848,13 @@ function onClaimsChange() {
   debounceTimer = setTimeout(() => {
     refreshState();
     // Send update event so SSE clients reload
-    const updateData = `event: update\ndata: ${JSON.stringify({ type: 'update' })}\n\n`;
+    const updateData = `event: update\ndata: ${JSON.stringify({ type: "update" })}\n\n`;
     for (const client of sseClients) {
-      try { client.write(updateData); } catch { sseClients.delete(client); }
+      try {
+        client.write(updateData);
+      } catch {
+        sseClients.delete(client);
+      }
     }
   }, 500);
 }
@@ -642,24 +865,31 @@ function watchClaims() {
     try {
       const w = fsWatch(p, { persistent: false }, () => onClaimsChange());
       watchers.push(w);
-    } catch { /* file may not exist yet */ }
+    } catch {
+      /* file may not exist yet */
+    }
   }
   // Watch sprint directories for new claims files
-  for (const dir of [ROOT, join(ROOT, 'sprints'), join(ROOT, 'archive')]) {
+  for (const dir of [ROOT, join(ROOT, "sprints"), join(ROOT, "archive")]) {
     if (!existsSync(dir)) continue;
     try {
       const w = fsWatch(dir, { persistent: false }, (_, filename) => {
-        if (filename && (filename === 'claims.json' || filename.includes('claims'))) {
+        if (
+          filename &&
+          (filename === "claims.json" || filename.includes("claims"))
+        ) {
           onClaimsChange();
         }
       });
       watchers.push(w);
-    } catch { /* ignore */ }
+    } catch {
+      /* ignore */
+    }
   }
 }
 
-server.listen(PORT, '127.0.0.1', () => {
-  vlog('listen', `port=${PORT}`, `root=${ROOT}`);
+server.listen(PORT, "127.0.0.1", () => {
+  vlog("listen", `port=${PORT}`, `root=${ROOT}`);
   console.log(`orchard: serving on http://localhost:${PORT}`);
   console.log(`  sprints: ${state.portfolio.length} found`);
   console.log(`  conflicts: ${state.conflicts.length} detected`);