syntaur 0.17.0 → 0.17.2

package/dist/dashboard/server.js

@@ -3871,8 +3871,8 @@ async function migrateFromMarkdown(projectsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile21 } = await import("fs/promises");
-  const raw = await readFile21(filePath, "utf-8");
+  const { readFile: readFile20 } = await import("fs/promises");
+  const raw = await readFile20(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -4270,13 +4270,16 @@ __export(scanner_exports, {
   autoLinkPane: () => autoLinkPane,
   checkTmuxAvailable: () => checkTmuxAvailable,
   clearScanCache: () => clearScanCache,
+  descendantPidsFromSnapshot: () => descendantPidsFromSnapshot,
   execQuiet: () => execQuiet,
   findListeningPorts: () => findListeningPorts,
   getDescendantPids: () => getDescendantPids,
   getGitInfo: () => getGitInfo,
   getLsofOutput: () => getLsofOutput,
+  getProcessSnapshot: () => getProcessSnapshot,
   listTmuxPanes: () => listTmuxPanes,
   loadWorkspaceRecords: () => loadWorkspaceRecords,
+  parseProcessSnapshot: () => parseProcessSnapshot,
   parseTmuxPaneOutput: () => parseTmuxPaneOutput,
   resolveAndNormalize: () => resolveAndNormalize,
   scanAllSessions: () => scanAllSessions,
@@ -4286,9 +4289,27 @@ __export(scanner_exports, {
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { resolve as resolve12 } from "path";
-import { realpath, readdir as readdir7, readFile as readFile9 } from "fs/promises";
+import { realpath } from "fs/promises";
 function clearScanCache() {
   cache = null;
+  forceFreshNext = true;
+  scanEpoch++;
+  inFlight = null;
+  tmuxAvailableCache = null;
+}
+function emptyScan() {
+  return { sessions: [], tmuxAvailable: false };
+}
+function scanKey(serversDir2, projectsDir, assignmentsDir2) {
+  return `${serversDir2}\0${projectsDir}\0${assignmentsDir2 ?? ""}`;
+}
+function delay(ms) {
+  return new Promise((resolve29) => {
+    const timer2 = setTimeout(resolve29, ms);
+    if (typeof timer2.unref === "function") {
+      timer2.unref();
+    }
+  });
 }
 function parseTmuxPaneOutput(output) {
   return output.trim().split("\n").filter((line) => line.length > 0).map((line) => {
@@ -4322,15 +4343,20 @@ function findListeningPorts(lsofOutput, pids) {
 }
 async function execQuiet(cmd, args) {
   try {
-    const { stdout } = await exec(cmd, args);
+    const { stdout } = await exec(cmd, args, {
+      timeout: PROBE_TIMEOUT_MS,
+      maxBuffer: PROBE_MAX_BUFFER
+    });
     return stdout.trim();
   } catch {
     return "";
   }
 }
 async function checkTmuxAvailable() {
-  const result = await execQuiet("which", ["tmux"]);
-  return result.length > 0;
+  if (!tmuxAvailableCache) {
+    tmuxAvailableCache = execQuiet("which", ["tmux"]).then((result) => result.length > 0);
+  }
+  return tmuxAvailableCache;
 }
 async function sessionAlive(name) {
   try {
@@ -4370,6 +4396,40 @@ async function getDescendantPids(rootPid, maxDepth = 4) {
   }
   return all;
 }
+function parseProcessSnapshot(psOutput) {
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const line of psOutput.split("\n")) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 2) continue;
+    const pid = parseInt(parts[0], 10);
+    const ppid = parseInt(parts[1], 10);
+    if (isNaN(pid) || isNaN(ppid)) continue;
+    const siblings = childrenOf.get(ppid);
+    if (siblings) siblings.push(pid);
+    else childrenOf.set(ppid, [pid]);
+  }
+  return { childrenOf };
+}
+async function getProcessSnapshot() {
+  return parseProcessSnapshot(await execQuiet("ps", ["-axo", "pid=,ppid="]));
+}
+function descendantPidsFromSnapshot(rootPid, snapshot, maxDepth = 4) {
+  const all = /* @__PURE__ */ new Set([rootPid]);
+  let frontier = [rootPid];
+  for (let depth = 0; depth < maxDepth && frontier.length > 0; depth++) {
+    const nextFrontier = [];
+    for (const pid of frontier) {
+      for (const child of snapshot.childrenOf.get(pid) ?? []) {
+        if (!all.has(child)) {
+          all.add(child);
+          nextFrontier.push(child);
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  return all;
+}
 async function getLsofOutput() {
   return execQuiet("lsof", ["-i", "-P", "-n", "-sTCP:LISTEN"]);
 }
@@ -4391,62 +4451,11 @@ async function getGitInfo(cwd) {
   return { branch: branch || null, worktree: isWorktree };
 }
 async function loadWorkspaceRecords(projectsDir, assignmentsDir2) {
-  const records = [];
   try {
-    const projects = await listProjects(projectsDir);
-    for (const project of projects) {
-      const projectAssignmentsDir = resolve12(projectsDir, project.slug, "assignments");
-      let slugs;
-      try {
-        slugs = await readdir7(projectAssignmentsDir);
-      } catch {
-        continue;
-      }
-      for (const aslug of slugs) {
-        const aFile = resolve12(projectAssignmentsDir, aslug, "assignment.md");
-        try {
-          const raw = await readFile9(aFile, "utf-8");
-          const [fm] = extractFrontmatter2(raw);
-          if (!fm) continue;
-          records.push({
-            projectSlug: project.slug,
-            assignmentSlug: aslug,
-            assignmentTitle: getField(fm, "title") ?? aslug,
-            worktreePath: getNestedField(fm, "workspace", "worktreePath") ?? null,
-            branch: getNestedField(fm, "workspace", "branch") ?? null
-          });
-        } catch {
-          continue;
-        }
-      }
-    }
+    return await listWorkspaceRecords(projectsDir, assignmentsDir2);
   } catch {
+    return [];
   }
-  if (assignmentsDir2) {
-    try {
-      const entries = await readdir7(assignmentsDir2);
-      for (const id of entries) {
-        if (id.startsWith(".") || id.startsWith("_")) continue;
-        const aFile = resolve12(assignmentsDir2, id, "assignment.md");
-        try {
-          const raw = await readFile9(aFile, "utf-8");
-          const [fm] = extractFrontmatter2(raw);
-          if (!fm) continue;
-          records.push({
-            projectSlug: null,
-            assignmentSlug: id,
-            assignmentTitle: getField(fm, "title") ?? id,
-            worktreePath: getNestedField(fm, "workspace", "worktreePath") ?? null,
-            branch: getNestedField(fm, "workspace", "branch") ?? null
-          });
-        } catch {
-          continue;
-        }
-      }
-    } catch {
-    }
-  }
-  return records;
 }
 async function resolveAndNormalize(p) {
   try {
@@ -4475,7 +4484,7 @@ async function autoLinkPane(cwd, branch, records) {
   }
   return null;
 }
-async function scanSession(sessionData, lsofOutput, workspaceRecords) {
+async function scanSession(sessionData, lsofOutput, workspaceRecords, procSnapshot) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const alive = await sessionAlive(sessionData.session);
   if (!alive) {
@@ -4498,13 +4507,13 @@ async function scanSession(sessionData, lsofOutput, workspaceRecords) {
     windowMap.get(rp.windowIndex).panes.push(rp);
   }
   const cwdSet = new Set(rawPanes.map((p) => p.cwd));
-  const gitInfoCache = /* @__PURE__ */ new Map();
-  for (const cwd of cwdSet) {
-    gitInfoCache.set(cwd, await getGitInfo(cwd));
-  }
+  const gitInfoEntries = await Promise.all(
+    [...cwdSet].map(async (cwd) => [cwd, await getGitInfo(cwd)])
+  );
+  const gitInfoCache = new Map(gitInfoEntries);
   const pidToPaneKey = /* @__PURE__ */ new Map();
   for (const rp of rawPanes) {
-    const descendants = await getDescendantPids(rp.pid);
+    const descendants = descendantPidsFromSnapshot(rp.pid, procSnapshot);
     const key = `${rp.windowIndex}:${rp.paneIndex}`;
     for (const pid of descendants) {
       pidToPaneKey.set(pid, key);
@@ -4529,37 +4538,38 @@ async function scanSession(sessionData, lsofOutput, workspaceRecords) {
   }
   const windows = [];
   for (const [windowIndex, { name, panes: rawPanesInWindow }] of windowMap) {
-    const panes = [];
-    for (const rp of rawPanesInWindow) {
-      const key = `${rp.windowIndex}:${rp.paneIndex}`;
-      const gitInfo = gitInfoCache.get(rp.cwd) ?? { branch: null, worktree: false };
-      const ports = panePorts.get(key) ?? [];
-      const urls = ports.map((p) => `http://localhost:${p}`);
-      const override = sessionData.overrides[key];
-      let assignment = null;
-      if (override) {
-        const rec = workspaceRecords.find(
-          (r) => r.projectSlug === override.project && r.assignmentSlug === override.assignment
-        );
-        assignment = {
-          project: override.project,
-          slug: override.assignment,
-          title: rec?.assignmentTitle ?? override.assignment
+    const panes = await Promise.all(
+      rawPanesInWindow.map(async (rp) => {
+        const key = `${rp.windowIndex}:${rp.paneIndex}`;
+        const gitInfo = gitInfoCache.get(rp.cwd) ?? { branch: null, worktree: false };
+        const ports = panePorts.get(key) ?? [];
+        const urls = ports.map((p) => `http://localhost:${p}`);
+        const override = sessionData.overrides[key];
+        let assignment = null;
+        if (override) {
+          const rec = workspaceRecords.find(
+            (r) => r.projectSlug === override.project && r.assignmentSlug === override.assignment
+          );
+          assignment = {
+            project: override.project,
+            slug: override.assignment,
+            title: rec?.assignmentTitle ?? override.assignment
+          };
+        } else {
+          assignment = await autoLinkPane(rp.cwd, gitInfo.branch, workspaceRecords);
+        }
+        return {
+          index: rp.paneIndex,
+          command: rp.command,
+          cwd: rp.cwd,
+          branch: gitInfo.branch,
+          worktree: gitInfo.worktree,
+          ports,
+          urls,
+          assignment
         };
-      } else {
-        assignment = await autoLinkPane(rp.cwd, gitInfo.branch, workspaceRecords);
-      }
-      panes.push({
-        index: rp.paneIndex,
-        command: rp.command,
-        cwd: rp.cwd,
-        branch: gitInfo.branch,
-        worktree: gitInfo.worktree,
-        ports,
-        urls,
-        assignment
-      });
-    }
+      })
+    );
     windows.push({ index: windowIndex, name, panes });
   }
   windows.sort((a, b) => a.index - b.index);
@@ -4631,53 +4641,114 @@ async function scanProcessSession(sessionData, lsofOutput, workspaceRecords) {
     windows: [{ index: 0, name: "process", panes: [pane] }]
   };
 }
+async function performScan(serversDir2, projectsDir, options) {
+  const epoch = scanEpoch;
+  const [tmuxAvailable, names, lsofOutput, workspaceRecords, procSnapshot] = await Promise.all([
+    checkTmuxAvailable(),
+    listSessionFiles(serversDir2),
+    getLsofOutput(),
+    loadWorkspaceRecords(projectsDir, options?.assignmentsDir),
+    getProcessSnapshot()
+  ]);
+  const datas = await Promise.all(names.map((name) => readSessionFile(serversDir2, name)));
+  const scanned = await Promise.all(
+    datas.map(async (data) => {
+      if (!data) return null;
+      if (data.kind === "process") {
+        return scanProcessSession(data, lsofOutput, workspaceRecords);
+      }
+      if (tmuxAvailable) {
+        return scanSession(data, lsofOutput, workspaceRecords, procSnapshot);
+      }
+      return null;
+    })
+  );
+  const result = {
+    sessions: scanned.filter((s) => s !== null),
+    tmuxAvailable
+  };
+  if (epoch === scanEpoch) {
+    cache = { data: result, expiry: Date.now() + CACHE_TTL_MS };
+    lastKnown = result;
+    forceFreshNext = false;
+  }
+  return result;
+}
+function refreshInBackground(serversDir2, projectsDir, options) {
+  if (!inFlight) {
+    const p = performScan(serversDir2, projectsDir, options);
+    p.finally(() => {
+      if (inFlight === p) inFlight = null;
+    }).catch(() => {
+    });
+    inFlight = p;
+  }
+  return inFlight;
+}
 async function scanAllSessions(serversDir2, projectsDir, options) {
+  const key = scanKey(serversDir2, projectsDir, options?.assignmentsDir);
+  if (key !== cacheKey) {
+    cache = null;
+    lastKnown = null;
+    inFlight = null;
+    forceFreshNext = false;
+    scanEpoch++;
+    cacheKey = key;
+  }
   if (!options?.bypassCache && cache && Date.now() < cache.expiry) {
     return cache.data;
   }
-  const tmuxAvailable = await checkTmuxAvailable();
-  const names = await listSessionFiles(serversDir2);
-  const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir, options?.assignmentsDir);
-  const sessions = [];
-  for (const name of names) {
-    const data = await readSessionFile(serversDir2, name);
-    if (!data) continue;
-    if (data.kind === "process") {
-      sessions.push(await scanProcessSession(data, lsofOutput, workspaceRecords));
-    } else if (tmuxAvailable) {
-      sessions.push(await scanSession(data, lsofOutput, workspaceRecords));
-    }
+  const refresh = refreshInBackground(serversDir2, projectsDir, options);
+  const canServeStale = lastKnown !== null && !options?.bypassCache && !forceFreshNext;
+  if (canServeStale) {
+    void refresh.catch(() => {
+    });
+    return lastKnown;
   }
-  const result = { sessions, tmuxAvailable };
-  cache = { data: result, expiry: Date.now() + CACHE_TTL_MS };
-  return result;
+  if (options?.nonBlocking) {
+    return Promise.race([
+      refresh.catch(() => emptyScan()),
+      delay(COLD_WAIT_BUDGET_MS).then(() => emptyScan())
+    ]);
+  }
+  return refresh;
 }
 async function scanSingleSession(serversDir2, projectsDir, name, options) {
   const data = await readSessionFile(serversDir2, name);
   if (!data) return null;
-  const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir, options?.assignmentsDir);
+  const [lsofOutput, workspaceRecords, procSnapshot] = await Promise.all([
+    getLsofOutput(),
+    loadWorkspaceRecords(projectsDir, options?.assignmentsDir),
+    getProcessSnapshot()
+  ]);
   if (data.kind === "process") {
     return scanProcessSession(data, lsofOutput, workspaceRecords);
   }
-  return scanSession(data, lsofOutput, workspaceRecords);
+  return scanSession(data, lsofOutput, workspaceRecords, procSnapshot);
 }
-var exec, cache, CACHE_TTL_MS;
+var exec, cache, lastKnown, inFlight, forceFreshNext, scanEpoch, cacheKey, CACHE_TTL_MS, COLD_WAIT_BUDGET_MS, PROBE_TIMEOUT_MS, PROBE_MAX_BUFFER, tmuxAvailableCache;
 var init_scanner = __esm({
   "src/dashboard/scanner.ts"() {
     "use strict";
     init_api();
     init_servers();
-    init_parser();
     exec = promisify(execFile);
     cache = null;
+    lastKnown = null;
+    inFlight = null;
+    forceFreshNext = false;
+    scanEpoch = 0;
+    cacheKey = null;
     CACHE_TTL_MS = 1e4;
+    COLD_WAIT_BUDGET_MS = 2500;
+    PROBE_TIMEOUT_MS = 15e3;
+    PROBE_MAX_BUFFER = 32 * 1024 * 1024;
+    tmuxAvailableCache = null;
   }
 });
 
 // src/dashboard/api.ts
-import { readdir as readdir8, readFile as readFile10, writeFile as writeFile3 } from "fs/promises";
+import { readdir as readdir7, readFile as readFile9, writeFile as writeFile3 } from "fs/promises";
 import { resolve as resolve13, dirname as dirname2, basename } from "path";
 function clearFrontmatterField(content, key) {
   const fieldRegex = new RegExp(`^(${escapeRegExp2(key)}:)\\s*.*$`, "m");
@@ -4717,10 +4788,41 @@ function emitTrace(traces, meta) {
     JSON.stringify({ kind: "overview-trace", totalMs, phases: traces.entries, subPhases, ...meta })
   );
 }
+function invalidateRecordsCache() {
+  projectRecordsCache.clear();
+  standaloneRecordsCache.clear();
+}
+function installRecordsInvalidation(router) {
+  for (const method of ["post", "put", "patch", "delete"]) {
+    const original = router[method].bind(router);
+    router[method] = (path, ...handlers) => {
+      if (handlers.length > 0) {
+        const last = handlers[handlers.length - 1];
+        handlers[handlers.length - 1] = async (req, res, next) => {
+          try {
+            return await last(req, res, next);
+          } finally {
+            invalidateRecordsCache();
+          }
+        };
+      }
+      return original(path, ...handlers);
+    };
+  }
+}
 async function listStandaloneRecords(assignmentsDir2) {
+  const key = assignmentsDir2 ?? "";
+  const cached = standaloneRecordsCache.get(key);
+  if (cached) return cached;
+  const promise = computeStandaloneRecords(assignmentsDir2);
+  standaloneRecordsCache.set(key, promise);
+  promise.catch(() => standaloneRecordsCache.delete(key));
+  return promise;
+}
+async function computeStandaloneRecords(assignmentsDir2) {
   if (!assignmentsDir2) return [];
   if (!await fileExists(assignmentsDir2)) return [];
-  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir7(assignmentsDir2, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
@@ -4728,7 +4830,7 @@ async function listStandaloneRecords(assignmentsDir2) {
     const assignmentMdPath = resolve13(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath)) continue;
     try {
-      const content = await readFile10(assignmentMdPath, "utf-8");
+      const content = await readFile9(assignmentMdPath, "utf-8");
       const record = parseAssignmentFull(content);
       records.push({ assignmentDir, id: entry.name, record });
     } catch {
@@ -4804,7 +4906,7 @@ async function listProjects(projectsDir) {
 async function readWorkspaceRegistry(projectsDir) {
   const registryPath = resolve13(dirname2(projectsDir), "workspaces.json");
   try {
-    const raw = await readFile10(registryPath, "utf-8");
+    const raw = await readFile9(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
@@ -4840,6 +4942,34 @@ async function listWorkspaces(projectsDir, assignmentsDir2) {
   const workspaces = Array.from(workspaceSet).sort();
   return { workspaces, hasUngrouped };
 }
+async function listWorkspaceRecords(projectsDir, assignmentsDir2) {
+  const [projectRecords, standaloneRecords] = await Promise.all([
+    listProjectRecords(projectsDir),
+    listStandaloneRecords(assignmentsDir2)
+  ]);
+  const records = [];
+  for (const project of projectRecords) {
+    for (const assignment of project.assignments) {
+      records.push({
+        projectSlug: project.summary.slug,
+        assignmentSlug: assignment.slug,
+        assignmentTitle: assignment.title || assignment.slug,
+        worktreePath: assignment.workspace.worktreePath ?? null,
+        branch: assignment.workspace.branch ?? null
+      });
+    }
+  }
+  for (const standalone of standaloneRecords) {
+    records.push({
+      projectSlug: null,
+      assignmentSlug: standalone.id,
+      assignmentTitle: standalone.record.title || standalone.id,
+      worktreePath: standalone.record.workspace.worktreePath ?? null,
+      branch: standalone.record.workspace.branch ?? null
+    });
+  }
+  return records;
+}
 async function createWorkspace(projectsDir, name) {
   const registered = await readWorkspaceRegistry(projectsDir);
   if (!registered.includes(name)) {
@@ -4865,7 +4995,7 @@ async function deleteWorkspace(projectsDir, name, opts = {}) {
     const timestamp = nowTimestamp();
     for (const slug of projectsReferencing) {
       const path = resolve13(projectsDir, slug, "project.md");
-      const raw = await readFile10(path, "utf-8");
+      const raw = await readFile9(path, "utf-8");
       let next = clearFrontmatterField(raw, "workspace");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
@@ -4874,7 +5004,7 @@ async function deleteWorkspace(projectsDir, name, opts = {}) {
     for (const id of standalonesReferencing) {
       if (!opts.assignmentsDir) break;
       const path = resolve13(opts.assignmentsDir, id, "assignment.md");
-      const raw = await readFile10(path, "utf-8");
+      const raw = await readFile9(path, "utf-8");
       let next = clearFrontmatterField(raw, "workspaceGroup");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
@@ -4884,6 +5014,9 @@ async function deleteWorkspace(projectsDir, name, opts = {}) {
   const registered = await readWorkspaceRegistry(projectsDir);
   const filtered = registered.filter((w) => w !== name);
   await writeWorkspaceRegistry(projectsDir, filtered);
+  if (rewroteFiles) {
+    invalidateRecordsCache();
+  }
   return { rewroteFiles };
 }
 async function getOverview(projectsDir, serversDir2, assignmentsDir2, options = {}) {
@@ -4927,7 +5060,12 @@ async function getOverview(projectsDir, serversDir2, assignmentsDir2, options =
       const servers = await timed(
         traces,
         "scan-tmux-sessions",
-        () => scanAllSessions2(serversDir2, projectsDir, { assignmentsDir: assignmentsDir2 })
+        () => (
+          // Overview only needs aggregate counts — never block its render on a
+          // live scan; serve last-known stats and let the scan refresh in the
+          // background (stale-while-revalidate).
+          scanAllSessions2(serversDir2, projectsDir, { assignmentsDir: assignmentsDir2, nonBlocking: true })
+        )
       );
       if (servers.tmuxAvailable) {
         const alive = servers.sessions.filter((s) => s.alive).length;
@@ -5046,7 +5184,7 @@ async function getEditableDocument(projectsDir, documentType, projectSlug, assig
   if (!filePath || !await fileExists(filePath)) {
     return null;
   }
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile9(filePath, "utf-8");
   const title = getEditableDocumentTitle(documentType, projectSlug, assignmentSlug);
   return {
     documentType,
@@ -5072,7 +5210,7 @@ async function getEditableDocumentById(projectsDir, assignmentsDir2, documentTyp
   if (!fileName) return null;
   const filePath = resolve13(resolved.assignmentDir, fileName);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile9(filePath, "utf-8");
   const label = resolved.id;
   const title = documentType === "assignment" ? `Edit Assignment: ${label}` : documentType === "plan" ? `Edit Plan: ${label}` : documentType === "scratchpad" ? `Edit Scratchpad: ${label}` : documentType === "handoff" ? `Append Handoff: ${label}` : `Append Decision: ${label}`;
   return {
@@ -5091,7 +5229,7 @@ async function getProjectDetail(projectsDir, slug) {
   if (!await fileExists(projectMdPath)) {
     return null;
   }
-  const projectContent = await readFile10(projectMdPath, "utf-8");
+  const projectContent = await readFile9(projectMdPath, "utf-8");
   const project = parseProject(projectContent);
   const assignments = await listAssignmentRecords(projectPath);
   const rollup = await buildProjectRollup(projectPath, project, assignments);
@@ -5128,18 +5266,18 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
-  const assignmentContent = await readFile10(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile9(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let projectWorkspace = null;
   const projectMdPath = resolve13(projectsDir, projectSlug, "project.md");
   if (await fileExists(projectMdPath)) {
-    const projectContent = await readFile10(projectMdPath, "utf-8");
+    const projectContent = await readFile9(projectMdPath, "utf-8");
     projectWorkspace = parseProject(projectContent).workspace;
   }
   let plan = null;
   const planPath = resolve13(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const planContent = await readFile10(planPath, "utf-8");
+    const planContent = await readFile9(planPath, "utf-8");
     const parsed = parsePlan(planContent);
     plan = {
       status: parsed.status,
@@ -5150,7 +5288,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
   let scratchpad = null;
   const scratchpadPath = resolve13(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const scratchpadContent = await readFile10(scratchpadPath, "utf-8");
+    const scratchpadContent = await readFile9(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
     scratchpad = {
       updated: parsed.updated,
@@ -5160,7 +5298,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
   let handoff = null;
   const handoffPath = resolve13(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const handoffContent = await readFile10(handoffPath, "utf-8");
+    const handoffContent = await readFile9(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
     handoff = {
       updated: parsed.updated,
@@ -5171,7 +5309,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
   let decisionRecord = null;
   const decisionRecordPath = resolve13(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const decisionRecordContent = await readFile10(decisionRecordPath, "utf-8");
+    const decisionRecordContent = await readFile9(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
     decisionRecord = {
       updated: parsed.updated,
@@ -5182,7 +5320,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
   let progress = null;
   const progressPath = resolve13(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const progressContent = await readFile10(progressPath, "utf-8");
+    const progressContent = await readFile9(progressPath, "utf-8");
     const parsed = parseProgress(progressContent);
     progress = {
       updated: parsed.updated,
@@ -5193,7 +5331,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
   let comments = null;
   const commentsPath = resolve13(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const commentsContent = await readFile10(commentsPath, "utf-8");
+    const commentsContent = await readFile9(commentsPath, "utf-8");
     const parsed = parseComments(commentsContent);
     comments = {
       updated: parsed.updated,
@@ -5344,7 +5482,7 @@ async function countMentionsInAssignment(sourceDir, target) {
   const bodies = [];
   const assignmentMd = resolve13(sourceDir, "assignment.md");
   if (await fileExists(assignmentMd)) {
-    const content = await readFile10(assignmentMd, "utf-8");
+    const content = await readFile9(assignmentMd, "utf-8");
     const todosMatch = content.match(/^## Todos\s*$([\s\S]*?)(?=^## |$(?![\r\n]))/m);
     if (todosMatch) bodies.push(todosMatch[1]);
   }
@@ -5352,7 +5490,7 @@ async function countMentionsInAssignment(sourceDir, target) {
     const path = resolve13(sourceDir, filename);
     if (await fileExists(path)) {
       try {
-        bodies.push(await readFile10(path, "utf-8"));
+        bodies.push(await readFile9(path, "utf-8"));
       } catch {
       }
     }
@@ -5412,42 +5550,42 @@ async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
   const assignmentMdPath = resolve13(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) return null;
-  const assignmentContent = await readFile10(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile9(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
   const planPath = resolve13(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const parsed = parsePlan(await readFile10(planPath, "utf-8"));
+    const parsed = parsePlan(await readFile9(planPath, "utf-8"));
     plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
   }
   let scratchpad = null;
   const scratchpadPath = resolve13(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const parsed = parseScratchpad(await readFile10(scratchpadPath, "utf-8"));
+    const parsed = parseScratchpad(await readFile9(scratchpadPath, "utf-8"));
     scratchpad = { updated: parsed.updated, body: parsed.body };
   }
   let handoff = null;
   const handoffPath = resolve13(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const parsed = parseHandoff(await readFile10(handoffPath, "utf-8"));
+    const parsed = parseHandoff(await readFile9(handoffPath, "utf-8"));
     handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
   }
   let decisionRecord = null;
   const decisionRecordPath = resolve13(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const parsed = parseDecisionRecord(await readFile10(decisionRecordPath, "utf-8"));
+    const parsed = parseDecisionRecord(await readFile9(decisionRecordPath, "utf-8"));
     decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
   }
   let progress = null;
   const progressPath = resolve13(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const parsed = parseProgress(await readFile10(progressPath, "utf-8"));
+    const parsed = parseProgress(await readFile9(progressPath, "utf-8"));
     progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   let comments = null;
   const commentsPath = resolve13(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const parsed = parseComments(await readFile10(commentsPath, "utf-8"));
+    const parsed = parseComments(await readFile9(commentsPath, "utf-8"));
     comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   const detail = {
@@ -5484,6 +5622,14 @@ async function buildStandaloneAssignmentDetail(resolved) {
   return detail;
 }
 async function listProjectRecords(projectsDir, traces) {
+  const cached = projectRecordsCache.get(projectsDir);
+  if (cached) return cached;
+  const promise = computeProjectRecords(projectsDir, traces);
+  projectRecordsCache.set(projectsDir, promise);
+  promise.catch(() => projectRecordsCache.delete(projectsDir));
+  return promise;
+}
+async function computeProjectRecords(projectsDir, traces) {
   if (!await fileExists(projectsDir)) {
     return [];
   }
@@ -5491,7 +5637,7 @@ async function listProjectRecords(projectsDir, traces) {
     migratedProjectsDirs.add(projectsDir);
     await migrateLegacyProjectFiles(projectsDir);
   }
-  const entries = await readdir8(projectsDir, { withFileTypes: true });
+  const entries = await readdir7(projectsDir, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const maybeRecords = await Promise.all(
     projectDirs.map(async (entry) => {
@@ -5501,7 +5647,7 @@ async function listProjectRecords(projectsDir, traces) {
         return null;
       }
       const t0 = traces ? performance.now() : 0;
-      const projectContent = await readFile10(projectMdPath, "utf-8");
+      const projectContent = await readFile9(projectMdPath, "utf-8");
       const project = parseProject(projectContent);
       if (traces) accumulatePhase(traces, "parse-project-md", performance.now() - t0);
       const t1 = traces ? performance.now() : 0;
@@ -5546,7 +5692,7 @@ async function listAssignmentRecords(projectPath, traces) {
   if (!await fileExists(assignmentsDir2)) {
     return [];
   }
-  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir7(assignmentsDir2, { withFileTypes: true });
   const dirEntries = entries.filter((entry) => entry.isDirectory());
   const maybeRecords = await Promise.all(
     dirEntries.map(async (entry) => {
@@ -5555,7 +5701,7 @@ async function listAssignmentRecords(projectPath, traces) {
         return null;
       }
       const t0 = traces ? performance.now() : 0;
-      const content = await readFile10(assignmentMd, "utf-8");
+      const content = await readFile9(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       if (traces) accumulatePhase(traces, "read-assignment-md", performance.now() - t0);
       return parsed;
@@ -5570,14 +5716,14 @@ async function listResources(projectPath) {
   if (!await fileExists(resourcesDir)) {
     return [];
   }
-  const entries = await readdir8(resourcesDir, { withFileTypes: true });
+  const entries = await readdir7(resourcesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
     const filePath = resolve13(resourcesDir, entry.name);
-    const content = await readFile10(filePath, "utf-8");
+    const content = await readFile9(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
       name: parsed.name,
@@ -5596,14 +5742,14 @@ async function listMemories(projectPath) {
   if (!await fileExists(memoriesDir)) {
     return [];
   }
-  const entries = await readdir8(memoriesDir, { withFileTypes: true });
+  const entries = await readdir7(memoriesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
     const filePath = resolve13(memoriesDir, entry.name);
-    const content = await readFile10(filePath, "utf-8");
+    const content = await readFile9(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
       name: parsed.name,
@@ -5666,7 +5812,7 @@ async function getMemoryDetail(projectsDir, projectSlug, itemSlug) {
   if (!projectRecord) return null;
   const filePath = resolve13(projectRecord.projectPath, "memories", `${itemSlug}.md`);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile9(filePath, "utf-8");
   const parsed = parseMemory(content);
   return {
     name: parsed.name,
@@ -5692,7 +5838,7 @@ async function getResourceDetail(projectsDir, projectSlug, itemSlug) {
   if (!projectRecord) return null;
   const filePath = resolve13(projectRecord.projectPath, "resources", `${itemSlug}.md`);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile9(filePath, "utf-8");
   const parsed = parseResource(content);
   return {
     name: parsed.name,
@@ -5710,7 +5856,7 @@ async function getResourceDetail(projectsDir, projectSlug, itemSlug) {
 async function loadDependencyGraph(projectPath, assignments) {
   const statusPath = resolve13(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
-    const statusContent = await readFile10(statusPath, "utf-8");
+    const statusContent = await readFile9(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
     const derivedGraph = extractMermaidGraph(parsed.body);
     if (derivedGraph) {
@@ -5871,7 +6017,7 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses, de
       unmet.push(`${dependency} (missing)`);
       continue;
     }
-    const content = await readFile10(dependencyPath, "utf-8");
+    const content = await readFile9(dependencyPath, "utf-8");
     const parsed = parseAssignmentFull(content);
     if (!terminals.has(parsed.status)) {
       unmet.push(`${dependency} (${parsed.status})`);
@@ -6164,7 +6310,7 @@ async function countOpenQuestions(projectPath, assignmentSlug) {
     return 0;
   }
   try {
-    const content = await readFile10(commentsPath, "utf-8");
+    const content = await readFile9(commentsPath, "utf-8");
     const parsed = parseComments(content);
     return parsed.entries.filter(
       (e) => e.type === "question" && e.resolved !== true
@@ -6232,12 +6378,12 @@ async function listPlaybooks(playbooksDir2) {
   if (!await fileExists(playbooksDir2)) return [];
   const config = await readConfig();
   const disabledSet = new Set(config.playbooks.disabled);
-  const entries = await readdir8(playbooksDir2, { withFileTypes: true });
+  const entries = await readdir7(playbooksDir2, { withFileTypes: true });
   const playbooks = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
     const filePath = resolve13(playbooksDir2, entry.name);
-    const raw = await readFile10(filePath, "utf-8");
+    const raw = await readFile9(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
@@ -6271,7 +6417,7 @@ async function getPlaybookDetail(playbooksDir2, slug) {
     enabled
   };
 }
-var WorkspaceBlockedError, STALE_ASSIGNMENT_MS, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, RECENT_SESSIONS_LIMIT, NEWEST_CREATED_LIMIT, SEGMENT_DISPLAY_CAP, STALE_LIMIT_DEFAULT, STALE_LIMIT_MAX, TERMINAL_STATUSES2, STATUS_TO_SEGMENT, HERO_PRIORITY, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, REFERENCED_BY_LIMIT, migratedProjectsDirs, DEFAULT_GRAPH_COLORS;
+var WorkspaceBlockedError, STALE_ASSIGNMENT_MS, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, RECENT_SESSIONS_LIMIT, NEWEST_CREATED_LIMIT, SEGMENT_DISPLAY_CAP, STALE_LIMIT_DEFAULT, STALE_LIMIT_MAX, TERMINAL_STATUSES2, STATUS_TO_SEGMENT, HERO_PRIORITY, projectRecordsCache, standaloneRecordsCache, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, REFERENCED_BY_LIMIT, migratedProjectsDirs, DEFAULT_GRAPH_COLORS;
 var init_api = __esm({
   "src/dashboard/api.ts"() {
     "use strict";
@@ -6322,6 +6468,8 @@ var init_api = __esm({
       ["blocked", "blocked"],
       ["stale", "stale"]
     ];
+    projectRecordsCache = /* @__PURE__ */ new Map();
+    standaloneRecordsCache = /* @__PURE__ */ new Map();
     DEFAULT_TRANSITION_DEFINITIONS = [
       {
         command: "start",
@@ -6870,7 +7018,7 @@ function mergePatch(current, patch) {
 // src/utils/view-prefs.ts
 init_paths();
 init_fs();
-import { readFile as readFile11, rename as rename3, unlink as unlink3 } from "fs/promises";
+import { readFile as readFile10, rename as rename3, unlink as unlink3 } from "fs/promises";
 import { resolve as resolve14 } from "path";
 function corruptFilePath() {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -6893,7 +7041,7 @@ async function readViewPrefsFile() {
   }
   let raw;
   try {
-    raw = await readFile11(path, "utf-8");
+    raw = await readFile10(path, "utf-8");
   } catch {
     return { ...DEFAULT_VIEW_PREFS_FILE };
   }
@@ -7076,7 +7224,7 @@ function isDashboardSlot(value) {
 // src/utils/saved-views.ts
 init_paths();
 init_fs();
-import { readFile as readFile12, rename as rename4, unlink as unlink4 } from "fs/promises";
+import { readFile as readFile11, rename as rename4, unlink as unlink4 } from "fs/promises";
 import { randomUUID } from "crypto";
 import { resolve as resolve15 } from "path";
 function corruptFilePath2() {
@@ -7106,7 +7254,7 @@ async function readSavedViewsFile() {
   }
   let raw;
   try {
-    raw = await readFile12(path, "utf-8");
+    raw = await readFile11(path, "utf-8");
   } catch {
     return cloneDefault();
   }
@@ -7422,7 +7570,7 @@ init_lifecycle();
 init_slug();
 import { Router as Router2 } from "express";
 import { resolve as resolve18, basename as basename3, isAbsolute as isAbsolute2 } from "path";
-import { rm, readFile as readFile15, open as fsOpen, stat as fsStat, realpath as fsRealpath } from "fs/promises";
+import { rm, readFile as readFile14, open as fsOpen, stat as fsStat, realpath as fsRealpath } from "fs/promises";
 import { spawnSync as spawnSync3 } from "child_process";
 
 // src/utils/uuid.ts
@@ -7439,7 +7587,7 @@ init_fs();
 init_frontmatter();
 init_fs();
 import { spawn } from "child_process";
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 function run(command, args, cwd) {
   return new Promise((resolvePromise) => {
     const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
@@ -7489,7 +7637,7 @@ async function createWorktreeAndRecord(opts) {
   const { assignmentPath, repository, branch, worktreePath, parentBranch } = opts;
   await createWorktree({ repository, branch, worktreePath, parentBranch });
   try {
-    const content = await readFile13(assignmentPath, "utf-8");
+    const content = await readFile12(assignmentPath, "utf-8");
     const updated = updateAssignmentWorkspace(content, {
       repository,
       worktreePath,
@@ -7573,14 +7721,14 @@ function detectCurrentBranch(cwd) {
 // src/dashboard/repository-candidates.ts
 init_fs();
 init_parser();
-import { readdir as readdir9, readFile as readFile14 } from "fs/promises";
+import { readdir as readdir8, readFile as readFile13 } from "fs/promises";
 import { resolve as resolve17 } from "path";
 async function getProjectRepositoryCandidates(projectsDir, projectSlug) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   const projectPath = resolve17(projectsDir, projectSlug, "project.md");
   if (await fileExists(projectPath)) {
-    const project = parseProject(await readFile14(projectPath, "utf-8"));
+    const project = parseProject(await readFile13(projectPath, "utf-8"));
     for (const raw of project.repositories) {
       const path = raw.trim();
       if (!path) continue;
@@ -7592,12 +7740,12 @@ async function getProjectRepositoryCandidates(projectsDir, projectSlug) {
   }
   const assignmentsDir2 = resolve17(projectsDir, projectSlug, "assignments");
   if (await fileExists(assignmentsDir2)) {
-    const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
+    const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const assignmentMd = resolve17(assignmentsDir2, entry.name, "assignment.md");
       if (!await fileExists(assignmentMd)) continue;
-      const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
+      const parsed = parseAssignmentFull(await readFile13(assignmentMd, "utf-8"));
       const repo = parsed.workspace.repository?.trim();
       if (!repo) continue;
       const abs = resolve17(repo);
@@ -7614,13 +7762,13 @@ async function getStandaloneRepositoryCandidates(assignmentsDir2, excludeAssignm
   }
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name === excludeAssignmentId) continue;
     const assignmentMd = resolve17(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) continue;
-    const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
+    const parsed = parseAssignmentFull(await readFile13(assignmentMd, "utf-8"));
     const repo = parsed.workspace.repository?.trim();
     if (!repo) continue;
     const abs = resolve17(repo);
@@ -8186,14 +8334,14 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile15(filePath, "utf-8");
+  return readFile14(filePath, "utf-8");
 }
 async function handleWorktreeCreate(req, res, ctx) {
   if (!await fileExists(ctx.assignmentPath)) {
     res.status(404).json({ error: "Assignment not found" });
     return;
   }
-  const parsed = parseAssignmentFull(await readFile15(ctx.assignmentPath, "utf-8"));
+  const parsed = parseAssignmentFull(await readFile14(ctx.assignmentPath, "utf-8"));
   if (parsed.workspace.worktreePath) {
     res.status(409).json({ error: "Worktree already configured for this assignment" });
     return;
@@ -8285,6 +8433,7 @@ async function handleWorktreeCreate(req, res, ctx) {
 function createWriteRouter(projectsDir, assignmentsDir2, todosDir2) {
   const linkedTodosLookup = todosDir2 ? { todosDir: todosDir2, projectsDir } : void 0;
   const router = Router2();
+  installRecordsInvalidation(router);
   router.get("/api/templates/project", (_req, res) => {
     const content = renderProject({
       id: generateId(),
@@ -8562,7 +8711,7 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
         }
         const nextContentRaw = requireContent(req, res);
         if (!nextContentRaw) return;
-        const currentContent = await readFile15(filePath, "utf-8");
+        const currentContent = await readFile14(filePath, "utf-8");
         const frontmatterBlock = extractFrontmatterBlock(currentContent);
         if (!frontmatterBlock) {
           res.status(500).json({ error: `${kind} file is malformed (no frontmatter)` });
@@ -9013,7 +9162,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
       let currentContent;
       let currentCount = 0;
       if (await fileExists(commentsPath)) {
-        currentContent = await readFile15(commentsPath, "utf-8");
+        currentContent = await readFile14(commentsPath, "utf-8");
         const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
         if (countMatch) currentCount = parseInt(countMatch[1], 10);
       } else {
@@ -9070,7 +9219,7 @@ ${entry}`;
         res.status(400).json({ error: "resolved (boolean) is required" });
         return;
       }
-      const content = await readFile15(commentsPath, "utf-8");
+      const content = await readFile14(commentsPath, "utf-8");
       const parsed = parseComments(content);
       const target = parsed.entries.find((e) => e.id === commentId);
       if (!target) {
@@ -9117,7 +9266,7 @@ ${entry}`;
         });
         return;
       }
-      let content = await readFile15(projectPath, "utf-8");
+      let content = await readFile14(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -9154,7 +9303,7 @@ ${entry}`;
         return;
       }
       const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "workspaceGroup", workspaceGroup ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -9249,7 +9398,7 @@ ${entry}`;
           return;
         }
         const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
-        const parsedForSlug = parseAssignmentFull(await readFile15(assignmentPath, "utf-8"));
+        const parsedForSlug = parseAssignmentFull(await readFile14(assignmentPath, "utf-8"));
         const assignmentSlugForBranch = parsedForSlug.slug || resolved.id;
         await handleWorktreeCreate(req, res, {
           assignmentPath,
@@ -9278,7 +9427,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile15(projectPath, "utf-8");
+      let content = await readFile14(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -9311,7 +9460,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -9345,7 +9494,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -9376,7 +9525,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "title", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -9894,7 +10043,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -9930,7 +10079,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -9963,7 +10112,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "title", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -10032,7 +10181,7 @@ ${entry}`;
           if (!await fileExists(assignmentPath)) {
             throw new Error("assignment file not found");
           }
-          let content = await readFile15(assignmentPath, "utf-8");
+          let content = await readFile14(assignmentPath, "utf-8");
           content = setTopLevelField(content, "status", status);
           content = setTopLevelField(content, "updated", timestamp);
           if (status !== "blocked") {
@@ -10188,7 +10337,7 @@ async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDet
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile15(commentsPath, "utf-8");
+    currentContent = await readFile14(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -10228,7 +10377,7 @@ async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloa
     res.status(400).json({ error: "resolved (boolean) is required" });
     return;
   }
-  const content = await readFile15(commentsPath, "utf-8");
+  const content = await readFile14(commentsPath, "utf-8");
   const parsed = parseComments(content);
   const target = parsed.entries.find((e) => e.id === commentId);
   if (!target) {
@@ -10956,26 +11105,26 @@ import { Router as Router8 } from "express";
 
 // src/utils/status-config-resolution.ts
 init_frontmatter();
-import { readFile as readFile16, writeFile as writeFile4, rm as rm2 } from "fs/promises";
+import { readFile as readFile15, writeFile as writeFile4, rm as rm2 } from "fs/promises";
 import { dirname as dirname4 } from "path";
 
 // src/utils/assignment-walk.ts
 init_fs();
 import { resolve as resolve20 } from "path";
-import { readdir as readdir10 } from "fs/promises";
+import { readdir as readdir9 } from "fs/promises";
 async function listAssignmentsByProject(projectsDir, standaloneDir) {
   const result = {
     withAssignmentMd: [],
     orphanFolders: []
   };
   if (await fileExists(projectsDir)) {
-    const projects = await readdir10(projectsDir, { withFileTypes: true });
+    const projects = await readdir9(projectsDir, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
       const assignmentsDir2 = resolve20(projectsDir, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir10(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -10997,7 +11146,7 @@ async function listAssignmentsByProject(projectsDir, standaloneDir) {
     }
   }
   if (standaloneDir !== null && await fileExists(standaloneDir)) {
-    const entries = await readdir10(standaloneDir, { withFileTypes: true });
+    const entries = await readdir9(standaloneDir, { withFileTypes: true });
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -11039,7 +11188,7 @@ async function scanAssignmentsByStatus(projectsDir, standaloneDir, ids) {
     const assignmentPath = `${entry.assignmentDir}/assignment.md`;
     let content;
     try {
-      content = await readFile16(assignmentPath, "utf-8");
+      content = await readFile15(assignmentPath, "utf-8");
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT") {
@@ -11102,7 +11251,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const content = await readFile16(a.path, "utf-8");
+        const content = await readFile15(a.path, "utf-8");
         buffer.set(a.path, content);
       } catch (err) {
         const code = err?.code;
@@ -11130,7 +11279,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       for (const a of list) {
         let current;
         try {
-          current = await readFile16(a.path, "utf-8");
+          current = await readFile15(a.path, "utf-8");
         } catch (err) {
           const code = err?.code;
           if (code === "ENOENT") {
@@ -11179,7 +11328,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const current = await readFile16(a.path, "utf-8");
+        const current = await readFile15(a.path, "utf-8");
         const fm = parseAssignmentFrontmatter(current);
         if (fm.status !== r.id) {
           console.warn(
@@ -11315,6 +11464,7 @@ function mapResolutionErrorToHttp(err, applied) {
 }
 function createStatusConfigRouter(projectsDir, assignmentsDir2) {
   const router = Router8();
+  installRecordsInvalidation(router);
   router.get("/", async (_req, res) => {
     try {
       const config = await getStatusConfig();
@@ -12025,7 +12175,7 @@ init_timestamp();
 init_fs();
 import { Router as Router11 } from "express";
 import { resolve as resolve23 } from "path";
-import { readFile as readFile17 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 init_playbooks();
 function statusForPlaybookError(code) {
   switch (code) {
@@ -12108,7 +12258,7 @@ function createPlaybooksRouter(playbooksDir2) {
         return;
       }
       const filePath = resolve23(playbooksDir2, resolved.filename);
-      const content = await readFile17(filePath, "utf-8");
+      const content = await readFile16(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${resolved.slug}`,
@@ -12205,7 +12355,7 @@ init_parser2();
 init_fs();
 init_paths();
 import { Router as Router12 } from "express";
-import { readdir as readdir11 } from "fs/promises";
+import { readdir as readdir10 } from "fs/promises";
 import { resolve as resolvePath, dirname as dirname5 } from "path";
 import { rename as rename5, mkdir as mkdir2 } from "fs/promises";
 init_slug();
@@ -12545,6 +12695,7 @@ async function promoteTodosToNewAssignment(groups, options) {
 }
 
 // src/dashboard/api-todos.ts
+init_api();
 var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
 function getWorkspaceParam(value) {
   if (Array.isArray(value)) {
@@ -12559,6 +12710,7 @@ function touchItem3(item) {
 }
 function createTodosRouter(todosDir2, broadcast, projectsDir) {
   const router = Router12();
+  installRecordsInvalidation(router);
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -12678,7 +12830,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir11(todosDir2).catch(() => []);
+      const files = await readdir10(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -12793,7 +12945,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
       const { resolve: resolve29 } = await import("path");
-      const { readFile: readFile21 } = await import("fs/promises");
+      const { readFile: readFile20 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const checklist = await readChecklist(todosDir2, workspace);
@@ -12812,7 +12964,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
       await ensureDir(resolve29(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile21(archFile, "utf-8");
+        archContent = await readFile20(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -13094,7 +13246,7 @@ workspace: ${workspace}
         const { readConfig: readConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
         const { assignmentsDir: assignmentsDirFn } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const { fileExists: fileExists2, writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        const { readFile: readFile21 } = await import("fs/promises");
+        const { readFile: readFile20 } = await import("fs/promises");
         const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
         const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
         let assignmentRef;
@@ -13115,7 +13267,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile21(assignmentMdPath, "utf-8");
+        let content = await readFile20(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -13303,8 +13455,9 @@ init_fs();
 init_paths();
 init_slug();
 import { Router as Router13 } from "express";
-import { mkdir as mkdir3, readFile as readFile18, rename as rename6 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile17, rename as rename6 } from "fs/promises";
 import { resolve as resolve25, dirname as dirname6 } from "path";
+init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem4(item) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -13353,6 +13506,7 @@ function notFound(res, slug) {
 }
 function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
   const router = Router13({ mergeParams: true });
+  installRecordsInvalidation(router);
   function broadcastUpdate(projectSlug) {
     broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -13525,7 +13679,7 @@ function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
       const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile18(archFile, "utf-8");
+        archContent = await readFile17(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -13982,7 +14136,7 @@ workspace: ${slug}
         }
         const assignmentMdPath = resolve25(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile18(assignmentMdPath, "utf-8");
+        let content = await readFile17(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -14178,7 +14332,7 @@ workspace: ${slug}
 
 // src/dashboard/api-bundles.ts
 import { Router as Router14 } from "express";
-import { readdir as readdir12 } from "fs/promises";
+import { readdir as readdir11 } from "fs/promises";
 
 // src/todos/bundle-parser.ts
 init_parser();
@@ -14186,7 +14340,7 @@ init_fs();
 init_paths();
 init_parser2();
 import { randomBytes as randomBytes2 } from "crypto";
-import { readFile as readFile19 } from "fs/promises";
+import { readFile as readFile18 } from "fs/promises";
 var BUNDLE_ID_REGEX = /^[a-f0-9]{4}$/;
 var SCOPE_VALUES = /* @__PURE__ */ new Set(["workspace", "project", "global"]);
 var SCOPE_ID_REGEX = /^[a-z0-9_][a-z0-9_-]*$/;
@@ -14253,7 +14407,7 @@ function parseBundles(content) {
 async function readBundles(todosDir2) {
   const path = bundlesPath(todosDir2);
   if (!await fileExists(path)) return [];
-  const content = await readFile19(path, "utf-8");
+  const content = await readFile18(path, "utf-8");
   return parseBundles(content).bundles;
 }
 
@@ -14302,7 +14456,7 @@ function createBundlesRouter(todosDir2, broadcast) {
     try {
       await ensureDir(todosDir2);
       const bundles = await readBundles(todosDir2);
-      const workspaceFiles = await readdir12(todosDir2).catch(() => []);
+      const workspaceFiles = await readdir11(todosDir2).catch(() => []);
       const itemsByKey = /* @__PURE__ */ new Map();
       for (const f of workspaceFiles) {
         if (typeof f !== "string") continue;
@@ -14416,6 +14570,8 @@ function createProjectBundlesRouter(projectsDir, broadcast) {
 
 // src/dashboard/api-backup.ts
 init_config2();
+init_api();
+init_scanner();
 import { Router as Router16 } from "express";
 
 // src/utils/github-backup.ts
@@ -14424,7 +14580,7 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp, mkdtemp, rm as rm3, readFile as readFile20, writeFile as writeFile5, unlink as unlink5, stat, open as open2, rename as rename7 } from "fs/promises";
+import { cp, mkdtemp, rm as rm3, readFile as readFile19, writeFile as writeFile5, unlink as unlink5, stat, open as open2, rename as rename7 } from "fs/promises";
 import { resolve as resolve27, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
@@ -14485,7 +14641,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err) {
     if (err.code === "EEXIST") {
-      const pid = await readFile20(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile19(lockPath, "utf-8").catch(() => "");
       throw new Error(
         `Backup operation already in progress (lock file at ${lockPath}, pid ${pid.trim() || "unknown"}). If stale, delete the file and retry.`
       );
@@ -14532,7 +14688,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile20(configPath, "utf-8");
+  const content = await readFile19(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -14814,6 +14970,9 @@ function createBackupRouter() {
         success: false,
         error: error instanceof Error ? error.message : String(error)
       });
+    } finally {
+      invalidateRecordsCache();
+      clearScanCache();
     }
   });
   return router;
@@ -15052,6 +15211,9 @@ function createDashboardServer(options) {
     });
   });
   function broadcast(message) {
+    if (message.type === "project-updated" || message.type === "assignment-updated") {
+      invalidateRecordsCache();
+    }
     const data = JSON.stringify(message);
     for (const client of clients) {
       if (client.readyState === WebSocket.OPEN) {