@grainulation/harvest 1.0.1 → 1.0.2

package/lib/server.js

@@ -9,25 +9,29 @@
  *   harvest serve [--port 9096] [--root /path/to/sprints]
  */
 
-import { createServer } from 'node:http';
-import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
-import { join, resolve, extname, dirname, basename } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
+import { createServer } from "node:http";
+import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join, resolve, extname, dirname, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 
 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 ──────────────────────────────────────────────────────────────────
 
@@ -37,51 +41,108 @@ function arg(name, fallback) {
   return i !== -1 && args[i + 1] ? args[i + 1] : fallback;
 }
 
-const PORT = parseInt(arg('port', '9096'), 10);
-const CORS_ORIGIN = arg('cors', null);
+const PORT = parseInt(arg("port", "9096"), 10);
+const CORS_ORIGIN = arg("cors", null);
 
 // Resolve ROOT: walk up from cwd to find a directory with claims.json
 function resolveRoot(initial) {
-  if (existsSync(join(initial, 'claims.json'))) return initial;
+  if (existsSync(join(initial, "claims.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'))) return dir;
+    if (existsSync(join(dir, "claims.json"))) return dir;
   }
   return initial; // fall back to original
 }
-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}] harvest: ${a.join(' ')}\n`);
+  process.stderr.write(`[${ts}] harvest: ${a.join(" ")}\n`);
 }
 
 // ── Routes manifest ──────────────────────────────────────────────────────────
 
 const ROUTES = [
-  { method: 'GET', path: '/events', description: 'SSE event stream for live updates' },
-  { method: 'GET', path: '/api/sprints', description: 'List discovered sprints with claim counts' },
-  { method: 'GET', path: '/api/analysis/:name', description: 'Full analysis of a single sprint' },
-  { method: 'GET', path: '/api/calibration', description: 'Prediction calibration across all sprints' },
-  { method: 'GET', path: '/api/decay', description: 'Find stale claims needing refresh (?days=N)' },
-  { method: 'GET', path: '/api/dashboard', description: 'Combined analytics dashboard summary' },
-  { 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/sprints",
+    description: "List discovered sprints with claim counts",
+  },
+  {
+    method: "GET",
+    path: "/api/analysis/:name",
+    description: "Full analysis of a single sprint",
+  },
+  {
+    method: "GET",
+    path: "/api/calibration",
+    description:
+      "Prediction calibration with Brier score and calibration curve",
+  },
+  {
+    method: "GET",
+    path: "/api/decay",
+    description: "Find stale claims needing refresh (?days=N)",
+  },
+  {
+    method: "GET",
+    path: "/api/decay-alerts",
+    description: "Topic-aware decay alerts with tiered urgency",
+  },
+  {
+    method: "GET",
+    path: "/api/tokens",
+    description: "Token cost tracking and efficiency metrics",
+  },
+  {
+    method: "GET",
+    path: "/api/harvest-card",
+    description: "Generate Harvest Report SVG card",
+  },
+  {
+    method: "GET",
+    path: "/api/harvest-report",
+    description: "Harvest Report stats (JSON)",
+  },
+  {
+    method: "GET",
+    path: "/api/intelligence",
+    description: "Full intelligence report (all features)",
+  },
+  {
+    method: "GET",
+    path: "/api/dashboard",
+    description: "Combined analytics dashboard summary",
+  },
+  {
+    method: "GET",
+    path: "/api/docs",
+    description: "This API documentation page",
+  },
 ];
 
 // ── Load existing CJS modules via createRequire ──────────────────────────────
 
-const { analyze } = require('./analyzer.js');
-const { measureVelocity } = require('./velocity.js');
-const { checkDecay } = require('./decay.js');
-const { calibrate } = require('./calibration.js');
-const { claimsPaths } = require('./dashboard.js');
+const { analyze } = require("./analyzer.js");
+const { measureVelocity } = require("./velocity.js");
+const { checkDecay, decayAlerts } = require("./decay.js");
+const { calibrate } = require("./calibration.js");
+const { claimsPaths } = require("./dashboard.js");
+const { analyzeTokens } = require("./tokens.js");
+const { generateCard, computeReportStats } = require("./harvest-card.js");
 
 // ── Sprint discovery ─────────────────────────────────────────────────────────
 
@@ -90,7 +151,7 @@ function discoverSprints(rootDir) {
   if (!existsSync(rootDir)) return sprints;
 
   // Include root if it has claims.json
-  const directClaims = join(rootDir, 'claims.json');
+  const directClaims = join(rootDir, "claims.json");
   if (existsSync(directClaims)) {
     sprints.push(loadSingleSprint(rootDir));
   }
@@ -100,9 +161,9 @@ function discoverSprints(rootDir) {
     const entries = readdirSync(rootDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      if (entry.name.startsWith('.')) continue;
+      if (entry.name.startsWith(".")) continue;
       const childDir = join(rootDir, entry.name);
-      const childClaims = join(childDir, 'claims.json');
+      const childClaims = join(childDir, "claims.json");
       if (existsSync(childClaims)) {
         sprints.push(loadSingleSprint(childDir));
       }
@@ -111,16 +172,20 @@ function discoverSprints(rootDir) {
         const subEntries = readdirSync(childDir, { withFileTypes: true });
         for (const sub of subEntries) {
           if (!sub.isDirectory()) continue;
-          if (sub.name.startsWith('.')) continue;
+          if (sub.name.startsWith(".")) continue;
           const subDir = join(childDir, sub.name);
-          const subClaims = join(subDir, 'claims.json');
+          const subClaims = join(subDir, "claims.json");
           if (existsSync(subClaims)) {
             sprints.push(loadSingleSprint(subDir));
           }
         }
-      } catch { /* skip */ }
+      } catch {
+        /* skip */
+      }
     }
-  } catch { /* skip if unreadable */ }
+  } catch {
+    /* skip if unreadable */
+  }
 
   return sprints;
 }
@@ -134,29 +199,42 @@ function loadSingleSprint(dir) {
     gitLog: [],
   };
 
-  const claimsPath = join(dir, 'claims.json');
+  const claimsPath = join(dir, "claims.json");
   try {
-    const raw = JSON.parse(readFileSync(claimsPath, 'utf8'));
+    const raw = JSON.parse(readFileSync(claimsPath, "utf8"));
     sprint.claims = Array.isArray(raw) ? raw : raw.claims || [];
-  } catch { /* skip */ }
+  } catch {
+    /* skip */
+  }
 
-  const compilationPath = join(dir, 'compilation.json');
+  const compilationPath = join(dir, "compilation.json");
   if (existsSync(compilationPath)) {
     try {
-      sprint.compilation = JSON.parse(readFileSync(compilationPath, 'utf8'));
-    } catch { /* skip */ }
+      sprint.compilation = JSON.parse(readFileSync(compilationPath, "utf8"));
+    } catch {
+      /* skip */
+    }
   }
 
   // Git log for velocity
   try {
-    const { execSync } = require('node:child_process');
+    const { execSync } = require("node:child_process");
     sprint.gitLog = execSync(
       `git log --oneline --format="%H|%ai|%s" -- claims.json`,
-      { cwd: dir, encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
-    ).trim().split('\n').filter(Boolean).map(line => {
-      const [hash, date, ...msg] = line.split('|');
-      return { hash, date, message: msg.join('|') };
-    });
+      {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    )
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => {
+        const [hash, date, ...msg] = line.split("|");
+        return { hash, date, message: msg.join("|") };
+      });
   } catch {
     sprint.gitLog = [];
   }
@@ -176,31 +254,38 @@ 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);
+    }
   }
 }
 
 function refreshState() {
   state.sprints = discoverSprints(ROOT);
   state.lastRefresh = new Date().toISOString();
-  broadcast({ type: 'state', data: { sprintCount: state.sprints.length, lastRefresh: state.lastRefresh } });
+  broadcast({
+    type: "state",
+    data: { sprintCount: state.sprints.length, lastRefresh: state.lastRefresh },
+  });
 }
 
 // ── 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 jsonResponse(res, code, data) {
-  res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8' });
+  res.writeHead(code, { "Content-Type": "application/json; charset=utf-8" });
   res.end(JSON.stringify(data));
 }
 
@@ -211,55 +296,65 @@ 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>harvest 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>harvest 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: { sprintCount: state.sprints.length, lastRefresh: state.lastRefresh } })}\n\n`);
+    res.write(
+      `data: ${JSON.stringify({ type: "state", data: { sprintCount: state.sprints.length, lastRefresh: state.lastRefresh } })}\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: list sprints ──
-  if (req.method === 'GET' && url.pathname === '/api/sprints') {
+  if (req.method === "GET" && url.pathname === "/api/sprints") {
     refreshState();
-    const sprintList = state.sprints.map(s => ({
+    const sprintList = state.sprints.map((s) => ({
       name: s.name,
       dir: s.dir,
       claimCount: s.claims.length,
@@ -271,14 +366,22 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
   }
 
   // ── API: full analysis of a sprint ──
-  if (req.method === 'GET' && url.pathname.startsWith('/api/analysis/')) {
-    const sprintName = decodeURIComponent(url.pathname.slice('/api/analysis/'.length));
-    if (!sprintName) { jsonResponse(res, 400, { error: 'missing sprint name' }); return; }
+  if (req.method === "GET" && url.pathname.startsWith("/api/analysis/")) {
+    const sprintName = decodeURIComponent(
+      url.pathname.slice("/api/analysis/".length),
+    );
+    if (!sprintName) {
+      jsonResponse(res, 400, { error: "missing sprint name" });
+      return;
+    }
 
     // Refresh and find the sprint
     refreshState();
-    const sprint = state.sprints.find(s => s.name === sprintName);
-    if (!sprint) { jsonResponse(res, 404, { error: `sprint "${sprintName}" not found` }); return; }
+    const sprint = state.sprints.find((s) => s.name === sprintName);
+    if (!sprint) {
+      jsonResponse(res, 404, { error: `sprint "${sprintName}" not found` });
+      return;
+    }
 
     const analysis = analyze([sprint]);
     const velocity = measureVelocity([sprint]);
@@ -292,10 +395,12 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
   }
 
   // ── API: calibration (all sprints) ──
-  if (req.method === 'GET' && url.pathname === '/api/calibration') {
+  if (req.method === "GET" && url.pathname === "/api/calibration") {
     refreshState();
     if (state.sprints.length === 0) {
-      jsonResponse(res, 200, { calibration: { summary: { totalSprints: 0 }, sprints: [] } });
+      jsonResponse(res, 200, {
+        calibration: { summary: { totalSprints: 0 }, sprints: [] },
+      });
       return;
     }
     const result = calibrate(state.sprints);
@@ -304,11 +409,18 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
   }
 
   // ── API: decay detection ──
-  if (req.method === 'GET' && url.pathname === '/api/decay') {
-    const days = parseInt(url.searchParams.get('days') || '30', 10);
+  if (req.method === "GET" && url.pathname === "/api/decay") {
+    const days = parseInt(url.searchParams.get("days") || "30", 10);
     refreshState();
     if (state.sprints.length === 0) {
-      jsonResponse(res, 200, { decay: { summary: { totalClaims: 0 }, stale: [], decaying: [], unresolved: [] } });
+      jsonResponse(res, 200, {
+        decay: {
+          summary: { totalClaims: 0 },
+          stale: [],
+          decaying: [],
+          unresolved: [],
+        },
+      });
       return;
     }
     const result = checkDecay(state.sprints, { thresholdDays: days });
@@ -316,8 +428,88 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
     return;
   }
 
+  // ── API: topic-aware decay alerts ──
+  if (req.method === "GET" && url.pathname === "/api/decay-alerts") {
+    refreshState();
+    if (state.sprints.length === 0) {
+      jsonResponse(res, 200, {
+        decayAlerts: {
+          summary: { totalAlerts: 0 },
+          alerts: [],
+          byUrgency: {},
+          topicDecayRates: [],
+        },
+      });
+      return;
+    }
+    const result = decayAlerts(state.sprints);
+    jsonResponse(res, 200, { decayAlerts: result });
+    return;
+  }
+
+  // ── API: token cost tracking ──
+  if (req.method === "GET" && url.pathname === "/api/tokens") {
+    refreshState();
+    if (state.sprints.length === 0) {
+      jsonResponse(res, 200, {
+        tokens: { summary: { totalSprints: 0 }, perSprint: [] },
+      });
+      return;
+    }
+    const result = analyzeTokens(state.sprints);
+    jsonResponse(res, 200, { tokens: result });
+    return;
+  }
+
+  // ── API: Harvest Report SVG card ──
+  if (req.method === "GET" && url.pathname === "/api/harvest-card") {
+    refreshState();
+    if (state.sprints.length === 0) {
+      res.writeHead(200, { "Content-Type": "image/svg+xml" });
+      res.end(
+        '<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="630"><rect width="1200" height="630" fill="#0d1117"/><text x="600" y="315" fill="#6e7681" font-family="system-ui" font-size="24" text-anchor="middle">No sprint data</text></svg>',
+      );
+      return;
+    }
+    const { svg } = generateCard(state.sprints);
+    res.writeHead(200, { "Content-Type": "image/svg+xml" });
+    res.end(svg);
+    return;
+  }
+
+  // ── API: Harvest Report stats (JSON) ──
+  if (req.method === "GET" && url.pathname === "/api/harvest-report") {
+    refreshState();
+    if (state.sprints.length === 0) {
+      jsonResponse(res, 200, { report: null });
+      return;
+    }
+    const stats = computeReportStats(state.sprints);
+    jsonResponse(res, 200, { report: stats });
+    return;
+  }
+
+  // ── API: full intelligence report ──
+  if (req.method === "GET" && url.pathname === "/api/intelligence") {
+    refreshState();
+    if (state.sprints.length === 0) {
+      jsonResponse(res, 200, { intelligence: null });
+      return;
+    }
+    const result = {
+      analysis: analyze(state.sprints),
+      calibration: calibrate(state.sprints),
+      decayAlerts: decayAlerts(state.sprints),
+      tokens: analyzeTokens(state.sprints),
+      velocity: measureVelocity(state.sprints),
+      harvestReport: computeReportStats(state.sprints),
+    };
+    jsonResponse(res, 200, { intelligence: result });
+    return;
+  }
+
   // ── API: dashboard summary (all sprints combined) ──
-  if (req.method === 'GET' && url.pathname === '/api/dashboard') {
+  if (req.method === "GET" && url.pathname === "/api/dashboard") {
     refreshState();
     if (state.sprints.length === 0) {
       jsonResponse(res, 200, {
@@ -344,15 +536,18 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
   }
 
   // ── 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;
   }
@@ -363,40 +558,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(`\nharvest: ${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(`\nharvest: port ${PORT} is already in use.`);
     console.error(`  Try: harvest serve --port ${Number(PORT) + 1}`);
     console.error(`  Or stop the process using port ${PORT}.\n`);
@@ -407,7 +606,7 @@ server.on('error', (err) => {
 
 // ── File watching for live reload ────────────────────────────────────────────
 
-import { watch as fsWatch } from 'node:fs';
+import { watch as fsWatch } from "node:fs";
 
 const watchers = [];
 let debounceTimer = null;
@@ -417,9 +616,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);
 }
@@ -430,24 +633,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(`harvest: serving on http://localhost:${PORT}`);
   console.log(`  sprints: ${state.sprints.length} found`);
   console.log(`  root:    ${ROOT}`);