syntaur 0.17.0 → 0.17.2

package/dist/index.js

@@ -5042,8 +5042,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile54 } = await import("fs/promises");
-  const raw = await readFile54(filePath, "utf-8");
+  const { readFile: readFile53 } = await import("fs/promises");
+  const raw = await readFile53(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -5441,13 +5441,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,
@@ -5457,9 +5460,27 @@ __export(scanner_exports, {
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { resolve as resolve15 } from "path";
-import { realpath, readdir as readdir8, readFile as readFile10 } 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, projectsDir2, assignmentsDir2) {
+  return `${serversDir2}\0${projectsDir2}\0${assignmentsDir2 ?? ""}`;
+}
+function delay(ms) {
+  return new Promise((resolve78) => {
+    const timer2 = setTimeout(resolve78, ms);
+    if (typeof timer2.unref === "function") {
+      timer2.unref();
+    }
+  });
 }
 function parseTmuxPaneOutput(output2) {
   return output2.trim().split("\n").filter((line) => line.length > 0).map((line) => {
@@ -5493,15 +5514,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 {
@@ -5541,6 +5567,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"]);
 }
@@ -5562,62 +5622,11 @@ async function getGitInfo(cwd) {
   return { branch: branch || null, worktree: isWorktree };
 }
 async function loadWorkspaceRecords(projectsDir2, assignmentsDir2) {
-  const records = [];
   try {
-    const projects = await listProjects(projectsDir2);
-    for (const project of projects) {
-      const projectAssignmentsDir = resolve15(projectsDir2, project.slug, "assignments");
-      let slugs;
-      try {
-        slugs = await readdir8(projectAssignmentsDir);
-      } catch {
-        continue;
-      }
-      for (const aslug of slugs) {
-        const aFile = resolve15(projectAssignmentsDir, aslug, "assignment.md");
-        try {
-          const raw = await readFile10(aFile, "utf-8");
-          const [fm] = extractFrontmatter(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(projectsDir2, assignmentsDir2);
   } catch {
+    return [];
   }
-  if (assignmentsDir2) {
-    try {
-      const entries = await readdir8(assignmentsDir2);
-      for (const id of entries) {
-        if (id.startsWith(".") || id.startsWith("_")) continue;
-        const aFile = resolve15(assignmentsDir2, id, "assignment.md");
-        try {
-          const raw = await readFile10(aFile, "utf-8");
-          const [fm] = extractFrontmatter(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 {
@@ -5646,7 +5655,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) {
@@ -5669,13 +5678,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);
@@ -5700,37 +5709,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);
@@ -5802,53 +5812,114 @@ async function scanProcessSession(sessionData, lsofOutput, workspaceRecords) {
     windows: [{ index: 0, name: "process", panes: [pane] }]
   };
 }
+async function performScan(serversDir2, projectsDir2, options) {
+  const epoch = scanEpoch;
+  const [tmuxAvailable, names, lsofOutput, workspaceRecords, procSnapshot] = await Promise.all([
+    checkTmuxAvailable(),
+    listSessionFiles(serversDir2),
+    getLsofOutput(),
+    loadWorkspaceRecords(projectsDir2, 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, projectsDir2, options) {
+  if (!inFlight) {
+    const p = performScan(serversDir2, projectsDir2, options);
+    p.finally(() => {
+      if (inFlight === p) inFlight = null;
+    }).catch(() => {
+    });
+    inFlight = p;
+  }
+  return inFlight;
+}
 async function scanAllSessions(serversDir2, projectsDir2, options) {
+  const key = scanKey(serversDir2, projectsDir2, 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(projectsDir2, 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, projectsDir2, 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, projectsDir2, name, options) {
   const data = await readSessionFile(serversDir2, name);
   if (!data) return null;
-  const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir2, options?.assignmentsDir);
+  const [lsofOutput, workspaceRecords, procSnapshot] = await Promise.all([
+    getLsofOutput(),
+    loadWorkspaceRecords(projectsDir2, 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 readdir9, readFile as readFile11, writeFile as writeFile3 } from "fs/promises";
+import { readdir as readdir8, readFile as readFile10, writeFile as writeFile3 } from "fs/promises";
 import { resolve as resolve16, dirname as dirname3, basename } from "path";
 function clearFrontmatterField(content, key) {
   const fieldRegex = new RegExp(`^(${escapeRegExp2(key)}:)\\s*.*$`, "m");
@@ -5888,10 +5959,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 readdir9(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
@@ -5899,7 +6001,7 @@ async function listStandaloneRecords(assignmentsDir2) {
     const assignmentMdPath2 = resolve16(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) continue;
     try {
-      const content = await readFile11(assignmentMdPath2, "utf-8");
+      const content = await readFile10(assignmentMdPath2, "utf-8");
       const record = parseAssignmentFull(content);
       records.push({ assignmentDir, id: entry.name, record });
     } catch {
@@ -5975,7 +6077,7 @@ async function listProjects(projectsDir2) {
 async function readWorkspaceRegistry(projectsDir2) {
   const registryPath = resolve16(dirname3(projectsDir2), "workspaces.json");
   try {
-    const raw = await readFile11(registryPath, "utf-8");
+    const raw = await readFile10(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
@@ -6011,6 +6113,34 @@ async function listWorkspaces(projectsDir2, assignmentsDir2) {
   const workspaces = Array.from(workspaceSet).sort();
   return { workspaces, hasUngrouped };
 }
+async function listWorkspaceRecords(projectsDir2, assignmentsDir2) {
+  const [projectRecords, standaloneRecords] = await Promise.all([
+    listProjectRecords(projectsDir2),
+    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(projectsDir2, name) {
   const registered = await readWorkspaceRegistry(projectsDir2);
   if (!registered.includes(name)) {
@@ -6036,7 +6166,7 @@ async function deleteWorkspace(projectsDir2, name, opts = {}) {
     const timestamp = nowTimestamp();
     for (const slug of projectsReferencing) {
       const path = resolve16(projectsDir2, slug, "project.md");
-      const raw = await readFile11(path, "utf-8");
+      const raw = await readFile10(path, "utf-8");
       let next = clearFrontmatterField(raw, "workspace");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
@@ -6045,7 +6175,7 @@ async function deleteWorkspace(projectsDir2, name, opts = {}) {
     for (const id of standalonesReferencing) {
       if (!opts.assignmentsDir) break;
       const path = resolve16(opts.assignmentsDir, id, "assignment.md");
-      const raw = await readFile11(path, "utf-8");
+      const raw = await readFile10(path, "utf-8");
       let next = clearFrontmatterField(raw, "workspaceGroup");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
@@ -6055,6 +6185,9 @@ async function deleteWorkspace(projectsDir2, name, opts = {}) {
   const registered = await readWorkspaceRegistry(projectsDir2);
   const filtered = registered.filter((w) => w !== name);
   await writeWorkspaceRegistry(projectsDir2, filtered);
+  if (rewroteFiles) {
+    invalidateRecordsCache();
+  }
   return { rewroteFiles };
 }
 async function getOverview(projectsDir2, serversDir2, assignmentsDir2, options = {}) {
@@ -6098,7 +6231,12 @@ async function getOverview(projectsDir2, serversDir2, assignmentsDir2, options =
       const servers = await timed(
         traces,
         "scan-tmux-sessions",
-        () => scanAllSessions2(serversDir2, projectsDir2, { 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, projectsDir2, { assignmentsDir: assignmentsDir2, nonBlocking: true })
+        )
       );
       if (servers.tmuxAvailable) {
         const alive = servers.sessions.filter((s) => s.alive).length;
@@ -6217,7 +6355,7 @@ async function getEditableDocument(projectsDir2, documentType, projectSlug, assi
   if (!filePath || !await fileExists(filePath)) {
     return null;
   }
-  const content = await readFile11(filePath, "utf-8");
+  const content = await readFile10(filePath, "utf-8");
   const title = getEditableDocumentTitle(documentType, projectSlug, assignmentSlug);
   return {
     documentType,
@@ -6243,7 +6381,7 @@ async function getEditableDocumentById(projectsDir2, assignmentsDir2, documentTy
   if (!fileName) return null;
   const filePath = resolve16(resolved.assignmentDir, fileName);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile11(filePath, "utf-8");
+  const content = await readFile10(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 {
@@ -6262,7 +6400,7 @@ async function getProjectDetail(projectsDir2, slug) {
   if (!await fileExists(projectMdPath)) {
     return null;
   }
-  const projectContent = await readFile11(projectMdPath, "utf-8");
+  const projectContent = await readFile10(projectMdPath, "utf-8");
   const project = parseProject(projectContent);
   const assignments = await listAssignmentRecords(projectPath);
   const rollup = await buildProjectRollup(projectPath, project, assignments);
@@ -6299,18 +6437,18 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
   if (!await fileExists(assignmentMdPath2)) {
     return null;
   }
-  const assignmentContent = await readFile11(assignmentMdPath2, "utf-8");
+  const assignmentContent = await readFile10(assignmentMdPath2, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let projectWorkspace = null;
   const projectMdPath = resolve16(projectsDir2, projectSlug, "project.md");
   if (await fileExists(projectMdPath)) {
-    const projectContent = await readFile11(projectMdPath, "utf-8");
+    const projectContent = await readFile10(projectMdPath, "utf-8");
     projectWorkspace = parseProject(projectContent).workspace;
   }
   let plan = null;
   const planPath = resolve16(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const planContent = await readFile11(planPath, "utf-8");
+    const planContent = await readFile10(planPath, "utf-8");
     const parsed = parsePlan(planContent);
     plan = {
       status: parsed.status,
@@ -6321,7 +6459,7 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
   let scratchpad = null;
   const scratchpadPath = resolve16(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const scratchpadContent = await readFile11(scratchpadPath, "utf-8");
+    const scratchpadContent = await readFile10(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
     scratchpad = {
       updated: parsed.updated,
@@ -6331,7 +6469,7 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
   let handoff = null;
   const handoffPath = resolve16(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const handoffContent = await readFile11(handoffPath, "utf-8");
+    const handoffContent = await readFile10(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
     handoff = {
       updated: parsed.updated,
@@ -6342,7 +6480,7 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
   let decisionRecord = null;
   const decisionRecordPath = resolve16(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const decisionRecordContent = await readFile11(decisionRecordPath, "utf-8");
+    const decisionRecordContent = await readFile10(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
     decisionRecord = {
       updated: parsed.updated,
@@ -6353,7 +6491,7 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
   let progress = null;
   const progressPath = resolve16(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const progressContent = await readFile11(progressPath, "utf-8");
+    const progressContent = await readFile10(progressPath, "utf-8");
     const parsed = parseProgress(progressContent);
     progress = {
       updated: parsed.updated,
@@ -6364,7 +6502,7 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
   let comments = null;
   const commentsPath = resolve16(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const commentsContent = await readFile11(commentsPath, "utf-8");
+    const commentsContent = await readFile10(commentsPath, "utf-8");
     const parsed = parseComments(commentsContent);
     comments = {
       updated: parsed.updated,
@@ -6515,7 +6653,7 @@ async function countMentionsInAssignment(sourceDir, target) {
   const bodies = [];
   const assignmentMd = resolve16(sourceDir, "assignment.md");
   if (await fileExists(assignmentMd)) {
-    const content = await readFile11(assignmentMd, "utf-8");
+    const content = await readFile10(assignmentMd, "utf-8");
     const todosMatch = content.match(/^## Todos\s*$([\s\S]*?)(?=^## |$(?![\r\n]))/m);
     if (todosMatch) bodies.push(todosMatch[1]);
   }
@@ -6523,7 +6661,7 @@ async function countMentionsInAssignment(sourceDir, target) {
     const path = resolve16(sourceDir, filename);
     if (await fileExists(path)) {
       try {
-        bodies.push(await readFile11(path, "utf-8"));
+        bodies.push(await readFile10(path, "utf-8"));
       } catch {
       }
     }
@@ -6583,42 +6721,42 @@ async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
   const assignmentMdPath2 = resolve16(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) return null;
-  const assignmentContent = await readFile11(assignmentMdPath2, "utf-8");
+  const assignmentContent = await readFile10(assignmentMdPath2, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
   const planPath = resolve16(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const parsed = parsePlan(await readFile11(planPath, "utf-8"));
+    const parsed = parsePlan(await readFile10(planPath, "utf-8"));
     plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
   }
   let scratchpad = null;
   const scratchpadPath = resolve16(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const parsed = parseScratchpad(await readFile11(scratchpadPath, "utf-8"));
+    const parsed = parseScratchpad(await readFile10(scratchpadPath, "utf-8"));
     scratchpad = { updated: parsed.updated, body: parsed.body };
   }
   let handoff = null;
   const handoffPath = resolve16(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const parsed = parseHandoff(await readFile11(handoffPath, "utf-8"));
+    const parsed = parseHandoff(await readFile10(handoffPath, "utf-8"));
     handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
   }
   let decisionRecord = null;
   const decisionRecordPath = resolve16(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const parsed = parseDecisionRecord(await readFile11(decisionRecordPath, "utf-8"));
+    const parsed = parseDecisionRecord(await readFile10(decisionRecordPath, "utf-8"));
     decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
   }
   let progress = null;
   const progressPath = resolve16(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const parsed = parseProgress(await readFile11(progressPath, "utf-8"));
+    const parsed = parseProgress(await readFile10(progressPath, "utf-8"));
     progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   let comments = null;
   const commentsPath = resolve16(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const parsed = parseComments(await readFile11(commentsPath, "utf-8"));
+    const parsed = parseComments(await readFile10(commentsPath, "utf-8"));
     comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   const detail = {
@@ -6655,6 +6793,14 @@ async function buildStandaloneAssignmentDetail(resolved) {
   return detail;
 }
 async function listProjectRecords(projectsDir2, traces) {
+  const cached = projectRecordsCache.get(projectsDir2);
+  if (cached) return cached;
+  const promise = computeProjectRecords(projectsDir2, traces);
+  projectRecordsCache.set(projectsDir2, promise);
+  promise.catch(() => projectRecordsCache.delete(projectsDir2));
+  return promise;
+}
+async function computeProjectRecords(projectsDir2, traces) {
   if (!await fileExists(projectsDir2)) {
     return [];
   }
@@ -6662,7 +6808,7 @@ async function listProjectRecords(projectsDir2, traces) {
     migratedProjectsDirs.add(projectsDir2);
     await migrateLegacyProjectFiles(projectsDir2);
   }
-  const entries = await readdir9(projectsDir2, { withFileTypes: true });
+  const entries = await readdir8(projectsDir2, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const maybeRecords = await Promise.all(
     projectDirs.map(async (entry) => {
@@ -6672,7 +6818,7 @@ async function listProjectRecords(projectsDir2, traces) {
         return null;
       }
       const t0 = traces ? performance.now() : 0;
-      const projectContent = await readFile11(projectMdPath, "utf-8");
+      const projectContent = await readFile10(projectMdPath, "utf-8");
       const project = parseProject(projectContent);
       if (traces) accumulatePhase(traces, "parse-project-md", performance.now() - t0);
       const t1 = traces ? performance.now() : 0;
@@ -6717,7 +6863,7 @@ async function listAssignmentRecords(projectPath, traces) {
   if (!await fileExists(assignmentsDir2)) {
     return [];
   }
-  const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
   const dirEntries = entries.filter((entry) => entry.isDirectory());
   const maybeRecords = await Promise.all(
     dirEntries.map(async (entry) => {
@@ -6726,7 +6872,7 @@ async function listAssignmentRecords(projectPath, traces) {
         return null;
       }
       const t0 = traces ? performance.now() : 0;
-      const content = await readFile11(assignmentMd, "utf-8");
+      const content = await readFile10(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       if (traces) accumulatePhase(traces, "read-assignment-md", performance.now() - t0);
       return parsed;
@@ -6741,14 +6887,14 @@ async function listResources(projectPath) {
   if (!await fileExists(resourcesDir)) {
     return [];
   }
-  const entries = await readdir9(resourcesDir, { withFileTypes: true });
+  const entries = await readdir8(resourcesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
     const filePath = resolve16(resourcesDir, entry.name);
-    const content = await readFile11(filePath, "utf-8");
+    const content = await readFile10(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
       name: parsed.name,
@@ -6767,14 +6913,14 @@ async function listMemories(projectPath) {
   if (!await fileExists(memoriesDir)) {
     return [];
   }
-  const entries = await readdir9(memoriesDir, { withFileTypes: true });
+  const entries = await readdir8(memoriesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
     const filePath = resolve16(memoriesDir, entry.name);
-    const content = await readFile11(filePath, "utf-8");
+    const content = await readFile10(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
       name: parsed.name,
@@ -6837,7 +6983,7 @@ async function getMemoryDetail(projectsDir2, projectSlug, itemSlug) {
   if (!projectRecord) return null;
   const filePath = resolve16(projectRecord.projectPath, "memories", `${itemSlug}.md`);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile11(filePath, "utf-8");
+  const content = await readFile10(filePath, "utf-8");
   const parsed = parseMemory(content);
   return {
     name: parsed.name,
@@ -6863,7 +7009,7 @@ async function getResourceDetail(projectsDir2, projectSlug, itemSlug) {
   if (!projectRecord) return null;
   const filePath = resolve16(projectRecord.projectPath, "resources", `${itemSlug}.md`);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile11(filePath, "utf-8");
+  const content = await readFile10(filePath, "utf-8");
   const parsed = parseResource(content);
   return {
     name: parsed.name,
@@ -6881,7 +7027,7 @@ async function getResourceDetail(projectsDir2, projectSlug, itemSlug) {
 async function loadDependencyGraph(projectPath, assignments) {
   const statusPath = resolve16(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
-    const statusContent = await readFile11(statusPath, "utf-8");
+    const statusContent = await readFile10(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
     const derivedGraph = extractMermaidGraph(parsed.body);
     if (derivedGraph) {
@@ -7042,7 +7188,7 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses3, d
       unmet.push(`${dependency} (missing)`);
       continue;
     }
-    const content = await readFile11(dependencyPath, "utf-8");
+    const content = await readFile10(dependencyPath, "utf-8");
     const parsed = parseAssignmentFull(content);
     if (!terminals.has(parsed.status)) {
       unmet.push(`${dependency} (${parsed.status})`);
@@ -7335,7 +7481,7 @@ async function countOpenQuestions(projectPath, assignmentSlug) {
     return 0;
   }
   try {
-    const content = await readFile11(commentsPath, "utf-8");
+    const content = await readFile10(commentsPath, "utf-8");
     const parsed = parseComments(content);
     return parsed.entries.filter(
       (e) => e.type === "question" && e.resolved !== true
@@ -7403,12 +7549,12 @@ async function listPlaybooks(playbooksDir3) {
   if (!await fileExists(playbooksDir3)) return [];
   const config = await readConfig();
   const disabledSet = new Set(config.playbooks.disabled);
-  const entries = await readdir9(playbooksDir3, { withFileTypes: true });
+  const entries = await readdir8(playbooksDir3, { 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 = resolve16(playbooksDir3, entry.name);
-    const raw = await readFile11(filePath, "utf-8");
+    const raw = await readFile10(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
@@ -7442,7 +7588,7 @@ async function getPlaybookDetail(playbooksDir3, 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";
@@ -7493,6 +7639,8 @@ var init_api = __esm({
       ["blocked", "blocked"],
       ["stale", "stale"]
     ];
+    projectRecordsCache = /* @__PURE__ */ new Map();
+    standaloneRecordsCache = /* @__PURE__ */ new Map();
     DEFAULT_TRANSITION_DEFINITIONS = [
       {
         command: "start",
@@ -7589,7 +7737,7 @@ __export(git_worktree_exports, {
   removeWorktree: () => removeWorktree
 });
 import { spawn } from "child_process";
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 function run(command, args, cwd) {
   return new Promise((resolvePromise) => {
     const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
@@ -7633,7 +7781,7 @@ async function createWorktreeAndRecord(opts) {
   const { assignmentPath, repository, branch, worktreePath, parentBranch } = opts;
   await createWorktree({ repository, branch, worktreePath, parentBranch });
   try {
-    const content = await readFile14(assignmentPath, "utf-8");
+    const content = await readFile13(assignmentPath, "utf-8");
     const updated = updateAssignmentWorkspace(content, {
       repository,
       worktreePath,
@@ -9480,7 +9628,7 @@ function mergePatch(current, patch) {
 // src/utils/view-prefs.ts
 init_paths();
 init_fs();
-import { readFile as readFile12, rename as rename3, unlink as unlink3 } from "fs/promises";
+import { readFile as readFile11, rename as rename3, unlink as unlink3 } from "fs/promises";
 import { resolve as resolve17 } from "path";
 function corruptFilePath() {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -9503,7 +9651,7 @@ async function readViewPrefsFile() {
   }
   let raw;
   try {
-    raw = await readFile12(path, "utf-8");
+    raw = await readFile11(path, "utf-8");
   } catch {
     return { ...DEFAULT_VIEW_PREFS_FILE };
   }
@@ -9686,7 +9834,7 @@ function isDashboardSlot(value) {
 // src/utils/saved-views.ts
 init_paths();
 init_fs();
-import { readFile as readFile13, rename as rename4, unlink as unlink4 } from "fs/promises";
+import { readFile as readFile12, rename as rename4, unlink as unlink4 } from "fs/promises";
 import { randomUUID as randomUUID2 } from "crypto";
 import { resolve as resolve18 } from "path";
 function corruptFilePath2() {
@@ -9716,7 +9864,7 @@ async function readSavedViewsFile() {
   }
   let raw;
   try {
-    raw = await readFile13(path, "utf-8");
+    raw = await readFile12(path, "utf-8");
   } catch {
     return cloneDefault();
   }
@@ -10036,7 +10184,7 @@ init_fs();
 init_git_worktree();
 import { Router as Router2 } from "express";
 import { resolve as resolve21, basename as basename3, isAbsolute as isAbsolute2 } from "path";
-import { rm, readFile as readFile16, open as fsOpen, stat as fsStat, realpath as fsRealpath } from "fs/promises";
+import { rm, readFile as readFile15, open as fsOpen, stat as fsStat, realpath as fsRealpath } from "fs/promises";
 import { spawnSync as spawnSync3 } from "child_process";
 
 // src/utils/worktree-defaults.ts
@@ -10083,14 +10231,14 @@ function detectCurrentBranch(cwd) {
 // src/dashboard/repository-candidates.ts
 init_fs();
 init_parser();
-import { readdir as readdir10, readFile as readFile15 } from "fs/promises";
+import { readdir as readdir9, readFile as readFile14 } from "fs/promises";
 import { resolve as resolve20 } from "path";
 async function getProjectRepositoryCandidates(projectsDir2, projectSlug) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   const projectPath = resolve20(projectsDir2, projectSlug, "project.md");
   if (await fileExists(projectPath)) {
-    const project = parseProject(await readFile15(projectPath, "utf-8"));
+    const project = parseProject(await readFile14(projectPath, "utf-8"));
     for (const raw of project.repositories) {
       const path = raw.trim();
       if (!path) continue;
@@ -10102,12 +10250,12 @@ async function getProjectRepositoryCandidates(projectsDir2, projectSlug) {
   }
   const assignmentsDir2 = resolve20(projectsDir2, projectSlug, "assignments");
   if (await fileExists(assignmentsDir2)) {
-    const entries = await readdir10(assignmentsDir2, { withFileTypes: true });
+    const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const assignmentMd = resolve20(assignmentsDir2, entry.name, "assignment.md");
       if (!await fileExists(assignmentMd)) continue;
-      const parsed = parseAssignmentFull(await readFile15(assignmentMd, "utf-8"));
+      const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
       const repo = parsed.workspace.repository?.trim();
       if (!repo) continue;
       const abs = resolve20(repo);
@@ -10124,13 +10272,13 @@ async function getStandaloneRepositoryCandidates(assignmentsDir2, excludeAssignm
   }
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const entries = await readdir10(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name === excludeAssignmentId) continue;
     const assignmentMd = resolve20(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) continue;
-    const parsed = parseAssignmentFull(await readFile15(assignmentMd, "utf-8"));
+    const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
     const repo = parsed.workspace.repository?.trim();
     if (!repo) continue;
     const abs = resolve20(repo);
@@ -10295,14 +10443,14 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile16(filePath, "utf-8");
+  return readFile15(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 readFile16(ctx.assignmentPath, "utf-8"));
+  const parsed = parseAssignmentFull(await readFile15(ctx.assignmentPath, "utf-8"));
   if (parsed.workspace.worktreePath) {
     res.status(409).json({ error: "Worktree already configured for this assignment" });
     return;
@@ -10394,6 +10542,7 @@ async function handleWorktreeCreate(req, res, ctx) {
 function createWriteRouter(projectsDir2, assignmentsDir2, todosDir2) {
   const linkedTodosLookup = todosDir2 ? { todosDir: todosDir2, projectsDir: projectsDir2 } : void 0;
   const router = Router2();
+  installRecordsInvalidation(router);
   router.get("/api/templates/project", (_req, res) => {
     const content = renderProject({
       id: generateId(),
@@ -10671,7 +10820,7 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
         }
         const nextContentRaw = requireContent(req, res);
         if (!nextContentRaw) return;
-        const currentContent = await readFile16(filePath, "utf-8");
+        const currentContent = await readFile15(filePath, "utf-8");
         const frontmatterBlock = extractFrontmatterBlock(currentContent);
         if (!frontmatterBlock) {
           res.status(500).json({ error: `${kind} file is malformed (no frontmatter)` });
@@ -11122,7 +11271,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
       let currentContent;
       let currentCount = 0;
       if (await fileExists(commentsPath)) {
-        currentContent = await readFile16(commentsPath, "utf-8");
+        currentContent = await readFile15(commentsPath, "utf-8");
         const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
         if (countMatch) currentCount = parseInt(countMatch[1], 10);
       } else {
@@ -11179,7 +11328,7 @@ ${entry}`;
         res.status(400).json({ error: "resolved (boolean) is required" });
         return;
       }
-      const content = await readFile16(commentsPath, "utf-8");
+      const content = await readFile15(commentsPath, "utf-8");
       const parsed = parseComments(content);
       const target = parsed.entries.find((e) => e.id === commentId);
       if (!target) {
@@ -11226,7 +11375,7 @@ ${entry}`;
         });
         return;
       }
-      let content = await readFile16(projectPath, "utf-8");
+      let content = await readFile15(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -11263,7 +11412,7 @@ ${entry}`;
         return;
       }
       const assignmentPath = resolve21(resolved.assignmentDir, "assignment.md");
-      let content = await readFile16(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "workspaceGroup", workspaceGroup ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -11358,7 +11507,7 @@ ${entry}`;
           return;
         }
         const assignmentPath = resolve21(resolved.assignmentDir, "assignment.md");
-        const parsedForSlug = parseAssignmentFull(await readFile16(assignmentPath, "utf-8"));
+        const parsedForSlug = parseAssignmentFull(await readFile15(assignmentPath, "utf-8"));
         const assignmentSlugForBranch = parsedForSlug.slug || resolved.id;
         await handleWorktreeCreate(req, res, {
           assignmentPath,
@@ -11387,7 +11536,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile16(projectPath, "utf-8");
+      let content = await readFile15(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -11420,7 +11569,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile16(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -11454,7 +11603,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile16(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -11485,7 +11634,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile16(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "title", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -12003,7 +12152,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile16(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -12039,7 +12188,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile16(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -12072,7 +12221,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile16(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "title", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -12141,7 +12290,7 @@ ${entry}`;
           if (!await fileExists(assignmentPath)) {
             throw new Error("assignment file not found");
           }
-          let content = await readFile16(assignmentPath, "utf-8");
+          let content = await readFile15(assignmentPath, "utf-8");
           content = setTopLevelField(content, "status", status);
           content = setTopLevelField(content, "updated", timestamp);
           if (status !== "blocked") {
@@ -12297,7 +12446,7 @@ async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDet
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile16(commentsPath, "utf-8");
+    currentContent = await readFile15(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -12337,7 +12486,7 @@ async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloa
     res.status(400).json({ error: "resolved (boolean) is required" });
     return;
   }
-  const content = await readFile16(commentsPath, "utf-8");
+  const content = await readFile15(commentsPath, "utf-8");
   const parsed = parseComments(content);
   const target = parsed.entries.find((e) => e.id === commentId);
   if (!target) {
@@ -13065,26 +13214,26 @@ import { Router as Router8 } from "express";
 
 // src/utils/status-config-resolution.ts
 init_frontmatter();
-import { readFile as readFile17, writeFile as writeFile4, rm as rm2 } from "fs/promises";
+import { readFile as readFile16, writeFile as writeFile4, rm as rm2 } from "fs/promises";
 import { dirname as dirname5 } from "path";
 
 // src/utils/assignment-walk.ts
 init_fs();
 import { resolve as resolve23 } from "path";
-import { readdir as readdir11 } from "fs/promises";
+import { readdir as readdir10 } from "fs/promises";
 async function listAssignmentsByProject(projectsDir2, standaloneDir) {
   const result = {
     withAssignmentMd: [],
     orphanFolders: []
   };
   if (await fileExists(projectsDir2)) {
-    const projects = await readdir11(projectsDir2, { withFileTypes: true });
+    const projects = await readdir10(projectsDir2, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
       const assignmentsDir2 = resolve23(projectsDir2, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir11(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir10(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -13106,7 +13255,7 @@ async function listAssignmentsByProject(projectsDir2, standaloneDir) {
     }
   }
   if (standaloneDir !== null && await fileExists(standaloneDir)) {
-    const entries = await readdir11(standaloneDir, { withFileTypes: true });
+    const entries = await readdir10(standaloneDir, { withFileTypes: true });
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -13148,7 +13297,7 @@ async function scanAssignmentsByStatus(projectsDir2, standaloneDir, ids) {
     const assignmentPath = `${entry.assignmentDir}/assignment.md`;
     let content;
     try {
-      content = await readFile17(assignmentPath, "utf-8");
+      content = await readFile16(assignmentPath, "utf-8");
     } catch (err2) {
       const code = err2?.code;
       if (code === "ENOENT") {
@@ -13211,7 +13360,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const content = await readFile17(a.path, "utf-8");
+        const content = await readFile16(a.path, "utf-8");
         buffer.set(a.path, content);
       } catch (err2) {
         const code = err2?.code;
@@ -13239,7 +13388,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       for (const a of list) {
         let current;
         try {
-          current = await readFile17(a.path, "utf-8");
+          current = await readFile16(a.path, "utf-8");
         } catch (err2) {
           const code = err2?.code;
           if (code === "ENOENT") {
@@ -13288,7 +13437,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const current = await readFile17(a.path, "utf-8");
+        const current = await readFile16(a.path, "utf-8");
         const fm = parseAssignmentFrontmatter(current);
         if (fm.status !== r.id) {
           console.warn(
@@ -13424,6 +13573,7 @@ function mapResolutionErrorToHttp(err2, applied) {
 }
 function createStatusConfigRouter(projectsDir2, assignmentsDir2) {
   const router = Router8();
+  installRecordsInvalidation(router);
   router.get("/", async (_req, res) => {
     try {
       const config = await getStatusConfig();
@@ -14648,7 +14798,7 @@ init_playbook();
 init_playbooks();
 import { Router as Router11 } from "express";
 import { resolve as resolve26 } from "path";
-import { readFile as readFile18 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 function statusForPlaybookError(code) {
   switch (code) {
     case "manifest":
@@ -14730,7 +14880,7 @@ function createPlaybooksRouter(playbooksDir3) {
         return;
       }
       const filePath = resolve26(playbooksDir3, resolved.filename);
-      const content = await readFile18(filePath, "utf-8");
+      const content = await readFile17(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${resolved.slug}`,
@@ -14827,11 +14977,12 @@ init_parser2();
 init_fs();
 init_paths();
 import { Router as Router12 } from "express";
-import { readdir as readdir12 } from "fs/promises";
+import { readdir as readdir11 } from "fs/promises";
 import { resolve as resolvePath, dirname as dirname6 } from "path";
 import { rename as rename5, mkdir as mkdir2 } from "fs/promises";
 init_slug();
 init_promote_todos();
+init_api();
 var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
 function getWorkspaceParam(value) {
   if (Array.isArray(value)) {
@@ -14846,6 +14997,7 @@ function touchItem3(item) {
 }
 function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   const router = Router12();
+  installRecordsInvalidation(router);
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -14965,7 +15117,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir12(todosDir2).catch(() => []);
+      const files = await readdir11(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -15080,7 +15232,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
       const { resolve: resolve78 } = await import("path");
-      const { readFile: readFile54 } = await import("fs/promises");
+      const { readFile: readFile53 } = 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);
@@ -15099,7 +15251,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
       await ensureDir(resolve78(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile54(archFile, "utf-8");
+        archContent = await readFile53(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -15381,7 +15533,7 @@ workspace: ${workspace}
         const { readConfig: readConfig3 } = 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: readFile54 } = await import("fs/promises");
+        const { readFile: readFile53 } = 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;
@@ -15402,7 +15554,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile54(assignmentMdPath2, "utf-8");
+        let content = await readFile53(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -15590,9 +15742,10 @@ init_fs();
 init_paths();
 init_slug();
 import { Router as Router13 } from "express";
-import { mkdir as mkdir3, readFile as readFile19, rename as rename6 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile18, rename as rename6 } from "fs/promises";
 import { resolve as resolve27, dirname as dirname7 } from "path";
 init_promote_todos();
+init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem4(item) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -15641,6 +15794,7 @@ function notFound(res, slug) {
 }
 function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
   const router = Router13({ mergeParams: true });
+  installRecordsInvalidation(router);
   function broadcastUpdate(projectSlug) {
     broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -15813,7 +15967,7 @@ function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
       const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile19(archFile, "utf-8");
+        archContent = await readFile18(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -16270,7 +16424,7 @@ workspace: ${slug}
         }
         const assignmentMdPath2 = resolve27(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile19(assignmentMdPath2, "utf-8");
+        let content = await readFile18(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -16466,7 +16620,7 @@ workspace: ${slug}
 
 // src/dashboard/api-bundles.ts
 import { Router as Router14 } from "express";
-import { readdir as readdir13 } from "fs/promises";
+import { readdir as readdir12 } from "fs/promises";
 
 // src/todos/bundle-parser.ts
 init_parser();
@@ -16474,7 +16628,7 @@ init_fs();
 init_paths();
 init_parser2();
 import { randomBytes as randomBytes2 } from "crypto";
-import { readFile as readFile20 } from "fs/promises";
+import { readFile as readFile19 } 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_-]*$/;
@@ -16577,7 +16731,7 @@ ${lines}
 async function readBundles(todosDir2) {
   const path = bundlesPath(todosDir2);
   if (!await fileExists(path)) return [];
-  const content = await readFile20(path, "utf-8");
+  const content = await readFile19(path, "utf-8");
   return parseBundles(content).bundles;
 }
 async function writeBundles(todosDir2, bundles) {
@@ -16630,7 +16784,7 @@ function createBundlesRouter(todosDir2, broadcast) {
     try {
       await ensureDir(todosDir2);
       const bundles = await readBundles(todosDir2);
-      const workspaceFiles = await readdir13(todosDir2).catch(() => []);
+      const workspaceFiles = await readdir12(todosDir2).catch(() => []);
       const itemsByKey = /* @__PURE__ */ new Map();
       for (const f of workspaceFiles) {
         if (typeof f !== "string") continue;
@@ -16744,6 +16898,8 @@ function createProjectBundlesRouter(projectsDir2, broadcast) {
 
 // src/dashboard/api-backup.ts
 init_config2();
+init_api();
+init_scanner();
 import { Router as Router16 } from "express";
 
 // src/utils/github-backup.ts
@@ -16752,7 +16908,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 readFile21, writeFile as writeFile5, unlink as unlink5, stat, open as open2, rename as rename7 } from "fs/promises";
+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 { resolve as resolve29, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
@@ -16813,7 +16969,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err2) {
     if (err2.code === "EEXIST") {
-      const pid = await readFile21(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile20(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.`
       );
@@ -16860,7 +17016,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile21(configPath, "utf-8");
+  const content = await readFile20(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -17142,6 +17298,9 @@ function createBackupRouter() {
         success: false,
         error: error instanceof Error ? error.message : String(error)
       });
+    } finally {
+      invalidateRecordsCache();
+      clearScanCache();
     }
   });
   return router;
@@ -17380,6 +17539,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) {
@@ -18248,7 +18410,7 @@ init_config2();
 init_frontmatter();
 init_timestamp();
 import { resolve as resolve33 } from "path";
-import { readdir as readdir14, readFile as readFile22 } from "fs/promises";
+import { readdir as readdir13, readFile as readFile21 } from "fs/promises";
 var PROMOTABLE_STATUSES = /* @__PURE__ */ new Set(["pending"]);
 function objectiveIsFleshedOut(content) {
   const match = content.match(/##\s+Objective\s*\n([\s\S]*?)(?=\n##\s+|$)/);
@@ -18266,7 +18428,7 @@ async function collectCandidates(baseDirs) {
   const candidates = [];
   for (const baseDir of baseDirs) {
     if (!await fileExists(baseDir)) continue;
-    const projects = await readdir14(baseDir, { withFileTypes: true });
+    const projects = await readdir13(baseDir, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
@@ -18274,7 +18436,7 @@ async function collectCandidates(baseDirs) {
       if (await fileExists(directAssignmentMd)) {
         const fm = await parseSafe(directAssignmentMd);
         if (fm && PROMOTABLE_STATUSES.has(fm.status)) {
-          const content = await readFile22(directAssignmentMd, "utf-8");
+          const content = await readFile21(directAssignmentMd, "utf-8");
           if (objectiveIsFleshedOut(content) && hasAcceptanceCriteria(content)) {
             candidates.push({
               projectSlug: null,
@@ -18289,7 +18451,7 @@ async function collectCandidates(baseDirs) {
       }
       const assignmentsDir2 = resolve33(baseDir, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir14(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir13(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -18297,7 +18459,7 @@ async function collectCandidates(baseDirs) {
         if (!await fileExists(assignmentMd)) continue;
         const fm = await parseSafe(assignmentMd);
         if (!fm || !PROMOTABLE_STATUSES.has(fm.status)) continue;
-        const content = await readFile22(assignmentMd, "utf-8");
+        const content = await readFile21(assignmentMd, "utf-8");
         if (!objectiveIsFleshedOut(content)) continue;
         if (!hasAcceptanceCriteria(content)) continue;
         candidates.push({
@@ -18314,7 +18476,7 @@ async function collectCandidates(baseDirs) {
 }
 async function parseSafe(path) {
   try {
-    const content = await readFile22(path, "utf-8");
+    const content = await readFile21(path, "utf-8");
     return parseAssignmentFrontmatter(content);
   } catch {
     return null;
@@ -18343,7 +18505,7 @@ async function migrateStatusesCommand(options) {
   const now = nowTimestamp();
   let migrated = 0;
   for (const c2 of candidates) {
-    const content = await readFile22(c2.assignmentMd, "utf-8");
+    const content = await readFile21(c2.assignmentMd, "utf-8");
     const updated = updateAssignmentFile(content, {
       status: c2.toStatus,
       updated: now
@@ -18398,10 +18560,10 @@ init_config2();
 init_fs();
 import {
   cp as cp2,
-  readdir as readdir15,
+  readdir as readdir14,
   symlink,
   lstat,
-  readFile as readFile23,
+  readFile as readFile22,
   readlink,
   rename as rename8,
   rm as rm4,
@@ -18462,7 +18624,7 @@ function getInstallMarkerPath(targetDir) {
   return resolve35(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw = await readFile23(resolve35(packageRoot, "package.json"), "utf-8");
+  const raw = await readFile22(resolve35(packageRoot, "package.json"), "utf-8");
   return JSON.parse(raw);
 }
 async function readJsonFileIfExists(pathValue) {
@@ -18470,7 +18632,7 @@ async function readJsonFileIfExists(pathValue) {
     return null;
   }
   try {
-    const raw = await readFile23(pathValue, "utf-8");
+    const raw = await readFile22(pathValue, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -18486,7 +18648,7 @@ async function readPluginManifestName(targetDir, pluginKind) {
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
-  const raw = await readFile23(manifestPath, "utf-8");
+  const raw = await readFile22(manifestPath, "utf-8");
   const parsed = JSON.parse(raw);
   return parsed.name;
 }
@@ -18496,7 +18658,7 @@ async function readInstallMetadata(targetDir) {
     return null;
   }
   try {
-    const raw = await readFile23(markerPath, "utf-8");
+    const raw = await readFile22(markerPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -18619,7 +18781,7 @@ async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
   }
   if (await fileExists(manifestPath)) {
     try {
-      const prev = await readFile23(manifestPath, "utf-8");
+      const prev = await readFile22(manifestPath, "utf-8");
       JSON.parse(prev);
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       await writeFile7(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
@@ -18692,7 +18854,7 @@ async function listClaudeMarketplaceCandidates() {
   const [knownMarketplaces, activeMarketplaceNames, entries] = await Promise.all([
     readKnownClaudeMarketplaceRecords(),
     readInstalledClaudeMarketplaceNames(),
-    readdir15(rootDir, { withFileTypes: true })
+    readdir14(rootDir, { withFileTypes: true })
   ]);
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -18767,7 +18929,7 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   const manifestPath = getClaudeKnownMarketplacesPath();
   let existing = {};
   if (await fileExists(manifestPath)) {
-    const raw = await readFile23(manifestPath, "utf-8");
+    const raw = await readFile22(manifestPath, "utf-8");
     try {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -18794,7 +18956,7 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   existing[name].autoUpdate = true;
   await ensureDir(dirname10(manifestPath));
   if (await fileExists(manifestPath)) {
-    const prev = await readFile23(manifestPath, "utf-8");
+    const prev = await readFile22(manifestPath, "utf-8");
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     await writeFile7(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
   }
@@ -18812,7 +18974,7 @@ async function setSyntaurPluginEnabled(options) {
   const key = `syntaur@${options.marketplaceName}`;
   let parsed = {};
   if (await fileExists(settingsPath)) {
-    const raw = await readFile23(settingsPath, "utf-8");
+    const raw = await readFile22(settingsPath, "utf-8");
     try {
       parsed = JSON.parse(raw);
     } catch {
@@ -18831,7 +18993,7 @@ async function setSyntaurPluginEnabled(options) {
   await ensureDir(dirname10(settingsPath));
   if (await fileExists(settingsPath)) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const prev = await readFile23(settingsPath, "utf-8");
+    const prev = await readFile22(settingsPath, "utf-8");
     await writeFile7(`${settingsPath}.bak-${stamp}`, prev, "utf-8");
   }
   const tmpPath = `${settingsPath}.tmp`;
@@ -19069,7 +19231,7 @@ async function readMarketplaceFile(marketplacePath) {
       plugins: []
     };
   }
-  const raw = await readFile23(marketplacePath, "utf-8");
+  const raw = await readFile22(marketplacePath, "utf-8");
   const parsed = JSON.parse(raw);
   return {
     name: parsed.name ?? "local",
@@ -19305,13 +19467,13 @@ async function textPrompt(question, defaultValue) {
 
 // src/utils/install-skills.ts
 init_fs();
-import { readFile as readFile25, readdir as readdir16, mkdir as mkdir4, copyFile, rm as rm5, lstat as lstat2 } from "fs/promises";
+import { readFile as readFile24, readdir as readdir15, mkdir as mkdir4, copyFile, rm as rm5, lstat as lstat2 } from "fs/promises";
 import { resolve as resolve37, relative as relative3, join as join3 } from "path";
 import { homedir as homedir4 } from "os";
 
 // src/utils/plugin-state.ts
 init_fs();
-import { readFile as readFile24 } from "fs/promises";
+import { readFile as readFile23 } from "fs/promises";
 import { resolve as resolve36 } from "path";
 import { homedir as homedir3 } from "os";
 function settingsPathFor(agent) {
@@ -19322,7 +19484,7 @@ async function readJsonOrNull(path) {
   if (!path) return null;
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile24(path, "utf-8");
+    const raw = await readFile23(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -19365,7 +19527,8 @@ var KNOWN_SKILL_NAMES = [
   "claim-resource",
   "release-resource",
   "extend-resource",
-  "list-resources"
+  "list-resources",
+  "run-playbook"
 ];
 var KNOWN_SKILLS = KNOWN_SKILL_NAMES;
 async function getSkillsDir() {
@@ -19379,7 +19542,7 @@ function defaultSkillTargetDir(target) {
 async function walkFiles(root) {
   const out = [];
   async function walk(dir) {
-    const entries = await readdir16(dir, { withFileTypes: true });
+    const entries = await readdir15(dir, { withFileTypes: true });
     for (const entry of entries) {
       const full = join3(dir, entry.name);
       if (entry.isDirectory()) {
@@ -19394,7 +19557,7 @@ async function walkFiles(root) {
 }
 async function filesEqual(a, b) {
   try {
-    const [ba, bb] = await Promise.all([readFile25(a), readFile25(b)]);
+    const [ba, bb] = await Promise.all([readFile24(a), readFile24(b)]);
     if (ba.length !== bb.length) return false;
     return ba.equals(bb);
   } catch {
@@ -19403,7 +19566,7 @@ async function filesEqual(a, b) {
 }
 async function copyDir(srcDir, destDir) {
   await mkdir4(destDir, { recursive: true });
-  const entries = await readdir16(srcDir, { withFileTypes: true });
+  const entries = await readdir15(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const src = join3(srcDir, entry.name);
     const dest = join3(destDir, entry.name);
@@ -19457,7 +19620,7 @@ async function installSkillDir(srcDir, destDir, skillName, force) {
   return { skill: skillName, status: "differs-preserved", targetPath: destDir };
 }
 async function discoverSkillNames(sourceDir) {
-  const entries = await readdir16(sourceDir, { withFileTypes: true });
+  const entries = await readdir15(sourceDir, { withFileTypes: true });
   const names = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -19516,7 +19679,7 @@ async function uninstallSkills(options) {
     if (await isSymlink(destDir)) continue;
     const skillMd = join3(destDir, "SKILL.md");
     if (!await fileExists(skillMd)) continue;
-    const content = await readFile25(skillMd, "utf-8").catch(() => "");
+    const content = await readFile24(skillMd, "utf-8").catch(() => "");
     const match = content.match(/^name:\s*(\S+)\s*$/m);
     if (!match || match[1] !== skill) continue;
     await rm5(destDir, { recursive: true, force: true });
@@ -19705,7 +19868,7 @@ async function installPluginCommand(options) {
 // src/commands/install-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile27, writeFile as writeFile9, copyFile as copyFile2, rm as rm6, stat as stat2, symlink as symlink2, unlink as unlink8, lstat as lstat3 } from "fs/promises";
+import { readFile as readFile26, writeFile as writeFile9, copyFile as copyFile2, rm as rm6, stat as stat2, symlink as symlink2, unlink as unlink8, lstat as lstat3 } from "fs/promises";
 import { resolve as resolve39, dirname as dirname12 } from "path";
 import { homedir as homedir5 } from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -19713,7 +19876,7 @@ import { fileURLToPath as fileURLToPath4 } from "url";
 // src/commands/configure-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile26, writeFile as writeFile8 } from "fs/promises";
+import { readFile as readFile25, writeFile as writeFile8 } from "fs/promises";
 import { resolve as resolve38, dirname as dirname11 } from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import { checkbox, input as input2, confirm } from "@inquirer/prompts";
@@ -19740,7 +19903,7 @@ function getConfigPath(installRoot) {
 async function readConfig2(path) {
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile26(path, "utf-8");
+    const raw = await readFile25(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     const segments = Array.isArray(parsed.segments) ? parsed.segments.filter(isSegmentName) : [];
@@ -19928,7 +20091,7 @@ function getPackageStatuslineSource() {
 }
 async function readSettingsJson(settingsPath) {
   if (!await fileExists(settingsPath)) return {};
-  const raw = await readFile27(settingsPath, "utf-8");
+  const raw = await readFile26(settingsPath, "utf-8");
   if (raw.trim() === "") return {};
   try {
     const parsed = JSON.parse(raw);
@@ -20116,7 +20279,7 @@ async function uninstallStatuslineCommand(options = {}) {
   let restored = null;
   if (await fileExists(backupPath)) {
     try {
-      const raw = await readFile27(backupPath, "utf-8");
+      const raw = await readFile26(backupPath, "utf-8");
       const parsed = JSON.parse(raw);
       const prev = parsed?.previousStatusLine;
       if (prev && typeof prev === "object" && typeof prev.command === "string") {
@@ -21149,7 +21312,7 @@ function normalizeSlashes(p) {
 }
 function detectInstallKind(scriptUrl, opts = {}) {
   const realpath3 = opts.realpath ?? realpathSync.native;
-  const readFile54 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
+  const readFile53 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
   const ua = opts.envUserAgent !== void 0 ? opts.envUserAgent : process.env.npm_config_user_agent ?? "";
   const resolved = resolveScriptPath(scriptUrl, realpath3);
   if (resolved === null) {
@@ -21170,7 +21333,7 @@ function detectInstallKind(scriptUrl, opts = {}) {
     const pkgJsonPath = join4(dir, "package.json");
     let raw;
     try {
-      raw = readFile54(pkgJsonPath);
+      raw = readFile53(pkgJsonPath);
     } catch {
       const parent2 = dirname13(dir);
       if (parent2 === dir) break;
@@ -21344,7 +21507,7 @@ init_config2();
 init_paths();
 init_fs();
 import { resolve as resolve46, isAbsolute as isAbsolute7 } from "path";
-import { readFile as readFile28 } from "fs/promises";
+import { readFile as readFile27 } from "fs/promises";
 import { select, confirm as confirm2, input as input3 } from "@inquirer/prompts";
 async function browseCommand(options) {
   const config = await readConfig();
@@ -21423,7 +21586,7 @@ async function ensureWorktree(opts) {
   if (!await fileExists(assignmentPath)) {
     return void 0;
   }
-  const content = await readFile28(assignmentPath, "utf-8");
+  const content = await readFile27(assignmentPath, "utf-8");
   const { parseAssignmentFrontmatter: parseAssignmentFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
   const fm = parseAssignmentFrontmatter2(content);
   const { workspace } = fm;
@@ -21557,7 +21720,7 @@ init_paths();
 init_fs();
 init_parser();
 init_config2();
-import { readdir as readdir17, readFile as readFile29 } from "fs/promises";
+import { readdir as readdir16, readFile as readFile28 } from "fs/promises";
 import { resolve as resolve48 } from "path";
 async function listPlaybooksCommand(options = {}) {
   const dir = playbooksDir();
@@ -21567,14 +21730,14 @@ async function listPlaybooksCommand(options = {}) {
   }
   const config = await readConfig();
   const disabledSet = new Set(config.playbooks.disabled);
-  const entries = await readdir17(dir, { withFileTypes: true });
+  const entries = await readdir16(dir, { withFileTypes: true });
   const mdFiles = entries.filter(
     (e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_") && e.name !== "manifest.md"
   );
   const rows = [];
   for (const entry of mdFiles) {
     const filePath = resolve48(dir, entry.name);
-    const raw = await readFile29(filePath, "utf-8");
+    const raw = await readFile28(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const disabled = disabledSet.has(slug);
@@ -21697,13 +21860,13 @@ init_fs();
 init_config2();
 init_slug();
 import { Command as Command2 } from "commander";
-import { readFile as readFile31 } from "fs/promises";
+import { readFile as readFile30 } from "fs/promises";
 import { resolve as resolve50 } from "path";
 
 // src/commands/bundle.ts
 init_paths();
 import { Command } from "commander";
-import { mkdir as mkdir7, readFile as readFile30, readdir as readdir18, rm as rm7, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile29, readdir as readdir17, rm as rm7, writeFile as writeFile11 } from "fs/promises";
 import { resolve as resolve49 } from "path";
 init_parser2();
 init_fs();
@@ -21996,7 +22159,7 @@ bundleCommand.command("plan").description("Create or open the bundle's shared pl
     }
     const planDir = bundlePlanDir(sc.todosPath, sc.scopeId, id);
     await ensureDir(planDir);
-    const existing = (await readdir18(planDir).catch(() => [])).filter((f) => /^plan(?:-v\d+)?\.md$/.test(f));
+    const existing = (await readdir17(planDir).catch(() => [])).filter((f) => /^plan(?:-v\d+)?\.md$/.test(f));
     const { target } = pickNextPlanFile(planDir, existing);
     const checklist = await readChecklist(sc.todosPath, sc.checklistKey);
     if (!await fileExists(target)) {
@@ -22065,8 +22228,8 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
     }
     const bundlesFilePath = bundlesPath(sc.todosPath);
     const checklistFilePath = checklistPath(sc.todosPath, sc.checklistKey);
-    const bundlesSnapshot = await fileExists(bundlesFilePath) ? await readFile30(bundlesFilePath, "utf-8") : null;
-    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile30(checklistFilePath, "utf-8") : null;
+    const bundlesSnapshot = await fileExists(bundlesFilePath) ? await readFile29(bundlesFilePath, "utf-8") : null;
+    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile29(checklistFilePath, "utf-8") : null;
     const record = async () => {
       bundle.branch = options.branch;
       bundle.worktreePath = worktreePath;
@@ -22612,7 +22775,7 @@ todoCommand.command("archive").description("Archive completed todos and their lo
     await ensureDir(resolve50(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
-      archContent = await readFile31(archFile, "utf-8");
+      archContent = await readFile30(archFile, "utf-8");
       archContent = archContent.trimEnd() + "\n\n";
     } else {
       archContent = `---
@@ -22789,12 +22952,12 @@ function describeScope(scope) {
 }
 async function injectPromotedTodos(assignmentDir, todos, scopeLabel) {
   const { resolve: resolvePath2 } = await import("path");
-  const { readFile: readFile54 } = await import("fs/promises");
+  const { readFile: readFile53 } = await import("fs/promises");
   const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
   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));
   const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
-  let content = await readFile54(assignmentMdPath2, "utf-8");
+  let content = await readFile53(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody2(
     content,
     todos.map((t) => ({
@@ -22839,8 +23002,8 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
     }
     const planDir = todoPlanDir(todosPath, workspace, id);
     await ensureDir(planDir);
-    const { readdir: readdir30 } = await import("fs/promises");
-    const existingFiles = (await readdir30(planDir).catch(() => [])).filter(
+    const { readdir: readdir29 } = await import("fs/promises");
+    const existingFiles = (await readdir29(planDir).catch(() => [])).filter(
       (f) => /^plan(?:-v\d+)?\.md$/.test(f)
     );
     let target;
@@ -23044,12 +23207,12 @@ backupCommand.command("config").description("Show or update backup configuration
 
 // src/commands/doctor.ts
 import { Command as Command4 } from "commander";
-import { readFile as readFile39 } from "fs/promises";
+import { readFile as readFile38 } from "fs/promises";
 import { isAbsolute as isAbsolute10, resolve as resolve62 } from "path";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { readFile as readFile38 } from "fs/promises";
+import { readFile as readFile37 } from "fs/promises";
 import { dirname as dirname17, join as join8 } from "path";
 
 // src/utils/doctor/context.ts
@@ -23096,7 +23259,7 @@ function closeCheckContext(ctx) {
 init_fs();
 init_paths();
 import { resolve as resolve52, isAbsolute as isAbsolute8 } from "path";
-import { readFile as readFile32, stat as stat3 } from "fs/promises";
+import { readFile as readFile31, stat as stat3 } from "fs/promises";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { dirname as dirname15, join as join6 } from "path";
 var CATEGORY = "env";
@@ -23153,7 +23316,7 @@ var configValid = {
         autoFixable: false
       };
     }
-    const content = await readFile32(configPath, "utf-8");
+    const content = await readFile31(configPath, "utf-8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fmMatch || fmMatch[1].trim() === "") {
       return {
@@ -23433,7 +23596,7 @@ async function readLocalPkg() {
     for (let i = 0; i < 6; i++) {
       const candidate = join6(dir, "package.json");
       try {
-        const text = await readFile32(candidate, "utf-8");
+        const text = await readFile31(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
         dir = dirname15(dir);
@@ -23486,7 +23649,7 @@ function versionGte(a, b) {
 // src/utils/doctor/checks/structure.ts
 init_fs();
 import { resolve as resolve53 } from "path";
-import { readdir as readdir19, stat as stat4 } from "fs/promises";
+import { readdir as readdir18, stat as stat4 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
   "projects",
@@ -23617,7 +23780,7 @@ var knownFilesRecognized = {
   category: CATEGORY2,
   title: "No unexpected top-level entries under ~/.syntaur/",
   async run(ctx) {
-    const entries = await readdir19(ctx.syntaurRoot, { withFileTypes: true });
+    const entries = await readdir18(ctx.syntaurRoot, { withFileTypes: true });
     const unexpected = [];
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
@@ -23661,7 +23824,7 @@ function pass2(check) {
 // src/utils/doctor/checks/project.ts
 init_fs();
 import { resolve as resolve54 } from "path";
-import { readdir as readdir20, stat as stat5 } from "fs/promises";
+import { readdir as readdir19, stat as stat5 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
   "project.md",
@@ -23685,7 +23848,7 @@ var PROJECT_MARKERS = ["project.md", "manifest.md", "assignments"];
 async function listProjects2(ctx) {
   const dir = ctx.config.defaultProjectDir;
   if (!await fileExists(dir)) return [];
-  const entries = await readdir20(dir, { withFileTypes: true });
+  const entries = await readdir19(dir, { withFileTypes: true });
   const result = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
@@ -23779,7 +23942,7 @@ var orphanFiles = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const entries = await readdir20(projectDir, { withFileTypes: true });
+      const entries = await readdir19(projectDir, { withFileTypes: true });
       const orphans = [];
       for (const e of entries) {
         if (e.name.startsWith(".")) continue;
@@ -23809,7 +23972,7 @@ async function newestAssignmentMtime(projectDir) {
   let newest = 0;
   let entries;
   try {
-    entries = await readdir20(assignmentsRoot, { withFileTypes: true });
+    entries = await readdir19(assignmentsRoot, { withFileTypes: true });
   } catch {
     return 0;
   }
@@ -23840,7 +24003,7 @@ init_parser();
 init_types();
 init_paths();
 import { resolve as resolve55 } from "path";
-import { readFile as readFile33, readdir as readdir21 } from "fs/promises";
+import { readFile as readFile32, readdir as readdir20 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 var PRE_WORKSPACE_STATUSES = /* @__PURE__ */ new Set([
@@ -24188,7 +24351,7 @@ var draftMissingObjective = {
       if (parsed.status !== "draft") continue;
       let raw;
       try {
-        raw = await readFile33(path, "utf-8");
+        raw = await readFile32(path, "utf-8");
       } catch {
         continue;
       }
@@ -24225,12 +24388,12 @@ var readyToImplementMissingPlan = {
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (parsed.status !== "ready_to_implement") continue;
-      const entries = await readdir21(a.assignmentDir).catch(() => []);
+      const entries = await readdir20(a.assignmentDir).catch(() => []);
       const planFiles = entries.filter((f) => /^plan(?:-v\d+)?\.md$/i.test(f));
       let hasPlanContent = false;
       for (const f of planFiles) {
         try {
-          const c2 = await readFile33(resolve55(a.assignmentDir, f), "utf-8");
+          const c2 = await readFile32(resolve55(a.assignmentDir, f), "utf-8");
           if (c2.trim().length > 0) {
             hasPlanContent = true;
             break;
@@ -24273,7 +24436,7 @@ var assignmentChecks = [
 ];
 async function parseSafe2(path) {
   try {
-    const content = await readFile33(path, "utf-8");
+    const content = await readFile32(path, "utf-8");
     return parseAssignmentFull(content);
   } catch {
     return null;
@@ -24434,7 +24597,7 @@ function skipped(check, reason) {
 // src/utils/doctor/checks/integrations.ts
 init_fs();
 import { resolve as resolve57, dirname as dirname16, basename as basename5 } from "path";
-import { readdir as readdir22, readFile as readFile34 } from "fs/promises";
+import { readdir as readdir21, readFile as readFile33 } from "fs/promises";
 import { homedir as homedir7 } from "os";
 var CATEGORY6 = "integrations";
 var claudePluginLinked = {
@@ -24497,7 +24660,7 @@ var backupConfigured = {
     if (ctx.config.backup?.repo) return pass6(this);
     const projectsDir2 = ctx.config.defaultProjectDir;
     if (!await fileExists(projectsDir2)) return skipped2(this, "no projects dir");
-    const entries = await readdir22(projectsDir2, { withFileTypes: true });
+    const entries = await readdir21(projectsDir2, { withFileTypes: true });
     const hasProjects = entries.some((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("_"));
     if (!hasProjects) return skipped2(this, "no projects yet");
     return {
@@ -24519,7 +24682,7 @@ async function readKnownMarketplaces() {
   const path = resolve57(homedir7(), ".claude", "plugins", "known_marketplaces.json");
   if (!await fileExists(path)) return {};
   try {
-    const raw = await readFile34(path, "utf-8");
+    const raw = await readFile33(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -24572,7 +24735,7 @@ var claudeMarketplaceRegistered = {
     }
     let parsed = {};
     try {
-      parsed = JSON.parse(await readFile34(marketplaceManifest, "utf-8"));
+      parsed = JSON.parse(await readFile33(marketplaceManifest, "utf-8"));
     } catch {
       return {
         id: this.id,
@@ -24645,7 +24808,7 @@ init_fs();
 init_parser();
 init_types();
 import { resolve as resolve58 } from "path";
-import { readFile as readFile35 } from "fs/promises";
+import { readFile as readFile34 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
 var BUNDLE_FIELDS = ["bundleId", "bundleScope", "bundleScopeId"];
@@ -24671,7 +24834,7 @@ async function loadContext(ctx) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw = await readFile35(path, "utf-8");
+    const raw = await readFile34(path, "utf-8");
     return { data: JSON.parse(raw), path, exists: true, parseError: null };
   } catch (err2) {
     return {
@@ -24798,7 +24961,7 @@ var contextTerminal = {
     const assignmentMd = resolve58(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
-      const content = await readFile35(assignmentMd, "utf-8");
+      const content = await readFile34(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       const terminal = terminalStatuses2(ctx);
       if (terminal.has(parsed.status)) {
@@ -24944,7 +25107,7 @@ var agentChecks = [agentsResolvable];
 // src/utils/doctor/checks/terminal.ts
 init_config2();
 import { spawnSync as spawnSync8 } from "child_process";
-import { readFile as readFile36 } from "fs/promises";
+import { readFile as readFile35 } from "fs/promises";
 import { resolve as resolve59 } from "path";
 init_paths();
 init_fs();
@@ -24952,7 +25115,7 @@ var CATEGORY9 = "terminal";
 async function readRawTerminalKey() {
   const configPath = resolve59(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) return null;
-  const content = await readFile36(configPath, "utf-8");
+  const content = await readFile35(configPath, "utf-8");
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch) return null;
   const line = fmMatch[1].split("\n").find((l) => /^terminal:\s*/.test(l));
@@ -25103,7 +25266,7 @@ var terminalChecks = [
 // src/utils/doctor/checks/skills.ts
 init_fs();
 import { resolve as resolve60, join as join7 } from "path";
-import { readdir as readdir23, readFile as readFile37, lstat as lstat4 } from "fs/promises";
+import { readdir as readdir22, readFile as readFile36, lstat as lstat4 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 var CATEGORY10 = "skills";
 var skillTargets = [
@@ -25123,7 +25286,7 @@ var skillsDedupCheck = {
       const present = [];
       let entries;
       try {
-        entries = await readdir23(dir, { withFileTypes: true });
+        entries = await readdir22(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -25132,7 +25295,7 @@ var skillsDedupCheck = {
         if (!KNOWN_SKILLS.includes(entry.name)) continue;
         const skillMd = join7(dir, entry.name, "SKILL.md");
         if (!await fileExists(skillMd)) continue;
-        const content = await readFile37(skillMd, "utf-8").catch(() => "");
+        const content = await readFile36(skillMd, "utf-8").catch(() => "");
         const match = content.match(/^name:\s*(\S+)\s*$/m);
         if (!match || match[1] !== entry.name) continue;
         let isSymlink2 = false;
@@ -25184,7 +25347,7 @@ var skillsChecks = [skillsDedupCheck];
 init_fs();
 init_paths();
 import { resolve as resolve61 } from "path";
-import { readdir as readdir24 } from "fs/promises";
+import { readdir as readdir23 } from "fs/promises";
 import { spawnSync as spawnSync9 } from "child_process";
 init_parser2();
 var CATEGORY11 = "bundles";
@@ -25192,7 +25355,7 @@ async function listScopes(ctx) {
   const out = [];
   const td = todosDir();
   if (await fileExists(td)) {
-    const entries = await readdir24(td).catch(() => []);
+    const entries = await readdir23(td).catch(() => []);
     for (const f of entries) {
       if (typeof f !== "string") continue;
       if (!f.endsWith(".md") || f.endsWith("-log.md")) continue;
@@ -25208,7 +25371,7 @@ async function listScopes(ctx) {
     }
   }
   if (await fileExists(ctx.config.defaultProjectDir)) {
-    const projectEntries = await readdir24(ctx.config.defaultProjectDir, { withFileTypes: true }).catch(() => []);
+    const projectEntries = await readdir23(ctx.config.defaultProjectDir, { withFileTypes: true }).catch(() => []);
     for (const e of projectEntries) {
       if (!e.isDirectory()) continue;
       const slug = e.name;
@@ -25504,7 +25667,7 @@ async function readVersion() {
     let dir = dirname17(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw = await readFile38(join8(dir, "package.json"), "utf-8");
+        const raw = await readFile37(join8(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
@@ -25614,7 +25777,7 @@ async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
   }
   let content;
   try {
-    content = await readFile39(absolute, "utf-8");
+    content = await readFile38(absolute, "utf-8");
   } catch (err2) {
     return {
       ok: false,
@@ -25939,7 +26102,7 @@ init_timestamp();
 init_assignment_resolver();
 init_templates();
 import { resolve as resolve63 } from "path";
-import { readFile as readFile40 } from "fs/promises";
+import { readFile as readFile39 } from "fs/promises";
 function shortId() {
   return generateId().split("-")[0];
 }
@@ -25985,7 +26148,7 @@ async function commentCommand(target, text, options = {}) {
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile40(commentsPath, "utf-8");
+    currentContent = await readFile39(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -26031,7 +26194,7 @@ init_slug();
 init_assignment_resolver();
 init_parser();
 import { resolve as resolve64 } from "path";
-import { readFile as readFile41 } from "fs/promises";
+import { readFile as readFile40 } from "fs/promises";
 var AssignmentTargetError = class extends Error {
 };
 function classifyContext(ctx) {
@@ -26046,7 +26209,7 @@ async function readAssignmentFrontmatterId(assignmentDir) {
   const path = resolve64(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile41(path, "utf-8");
+    const content = await readFile40(path, "utf-8");
     const [fm] = extractFrontmatter(content);
     return getField(fm, "id");
   } catch {
@@ -26057,7 +26220,7 @@ async function readContextJson(cwd) {
   const path = resolve64(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile41(path, "utf-8");
+    const raw = await readFile40(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -26290,7 +26453,7 @@ async function captureScreenshot(mode) {
 
 // src/utils/asciinema.ts
 import { spawn as spawn6 } from "child_process";
-import { mkdtemp as mkdtemp3, readFile as readFile42, rm as rm9 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile41, rm as rm9 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join10 } from "path";
 var SAFE_RE = /^[A-Za-z0-9_@%+=:,./-]+$/;
@@ -26353,7 +26516,7 @@ async function captureAsciinema(opts) {
       }
       throw err2;
     }
-    const text = await readFile42(castPath, "utf8").catch(() => null);
+    const text = await readFile41(castPath, "utf8").catch(() => null);
     if (text === null) {
       throw new Error(
         `asciinema produced no cast file at ${castPath} (exit ${exitCode}). Try running 'asciinema rec ${castPath}' directly to diagnose.`
@@ -26381,7 +26544,7 @@ async function captureAsciinema(opts) {
 // src/utils/recording.ts
 init_paths();
 import { spawn as spawn7 } from "child_process";
-import { mkdir as mkdir8, mkdtemp as mkdtemp4, open as open3, readFile as readFile43, rm as rm10, stat as stat7, unlink as unlink9, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir8, mkdtemp as mkdtemp4, open as open3, readFile as readFile42, rm as rm10, stat as stat7, unlink as unlink9, writeFile as writeFile12 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
 import { join as join11, resolve as resolve65 } from "path";
 import { setTimeout as sleep } from "timers/promises";
@@ -26455,7 +26618,7 @@ async function acquirePidfile(pidfile) {
     } catch (err2) {
       if (err2.code !== "EEXIST") throw err2;
       if (attempt === 1) throw err2;
-      const existing = (await readFile43(pidfile, "utf-8").catch(() => "")).trim();
+      const existing = (await readFile42(pidfile, "utf-8").catch(() => "")).trim();
       if (existing.startsWith(STARTING_SENTINEL_PREFIX)) {
         const parentPidRaw = existing.slice(STARTING_SENTINEL_PREFIX.length);
         const parentPid = Number.parseInt(parentPidRaw, 10);
@@ -26557,7 +26720,7 @@ async function startRecording(input4) {
     logHandle = null;
     if (warmupMs > 0) await sleep(warmupMs);
     if (!await isProcessAlive(pid)) {
-      const tail = await readFile43(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
+      const tail = await readFile42(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
       acquiredPid = null;
       throw new Error(
         `ffmpeg exited during startup \u2014 likely macOS Screen Recording permission missing. Grant access to your terminal in System Settings \u2192 Privacy & Security \u2192 Screen Recording, then retry. Log: ${log}
@@ -26614,7 +26777,7 @@ ${tail}`
 async function stopRecording() {
   const pidfile = pidfilePath();
   const sidecar = sidecarPath();
-  const pidRaw = await readFile43(pidfile, "utf-8").catch(() => null);
+  const pidRaw = await readFile42(pidfile, "utf-8").catch(() => null);
   if (pidRaw === null) {
     throw new Error(
       `No active recording found (no pidfile at ${pidfile}). Did you run --start?`
@@ -26624,7 +26787,7 @@ async function stopRecording() {
   if (!Number.isInteger(pid) || pid <= 0) {
     throw new Error(`Pidfile at ${pidfile} is corrupt (got "${pidRaw}").`);
   }
-  const sidecarRaw = await readFile43(sidecar, "utf-8").catch(() => null);
+  const sidecarRaw = await readFile42(sidecar, "utf-8").catch(() => null);
   if (sidecarRaw === null) {
     throw new Error(
       `No recording sidecar at ${sidecar}. The recording state is inconsistent \u2014 delete ${pidfile} and re-run --start.`
@@ -26757,7 +26920,7 @@ function listArtifactsByAssignment(assignmentId) {
 
 // src/utils/transcribers/elevenlabs.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdtemp as mkdtemp5, readFile as readFile44, rm as rm11 } from "fs/promises";
+import { mkdtemp as mkdtemp5, readFile as readFile43, rm as rm11 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import { join as join12 } from "path";
 var SCRIBE_URL = "https://api.elevenlabs.io/v1/speech-to-text";
@@ -26821,7 +26984,7 @@ async function extractAudio(videoAbsPath, wavOut) {
   throw new TranscribeFfmpegError(`ffmpeg failed (exit ${result.code}): ${tail}`);
 }
 async function callScribe(wavPath, apiKey, opts) {
-  const audio = await readFile44(wavPath);
+  const audio = await readFile43(wavPath);
   const form = new FormData();
   form.set("file", new Blob([new Uint8Array(audio)], { type: "audio/wav" }), "audio.wav");
   form.set("model_id", "scribe_v1");
@@ -27286,7 +27449,7 @@ async function captureCommand(target, options = {}) {
 
 // src/commands/proof.ts
 import { Command as Command6 } from "commander";
-import { readFile as readFile45, writeFile as writeFile14, rename as rename9, stat as stat9 } from "fs/promises";
+import { readFile as readFile44, writeFile as writeFile14, rename as rename9, stat as stat9 } from "fs/promises";
 import { resolve as resolve68, relative as relative5, isAbsolute as isAbsolute11, dirname as dirname19 } from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 
@@ -27531,7 +27694,7 @@ async function readAssignmentMeta(assignmentDir) {
   if (!await fileExists(path)) {
     return { title: "", body: "" };
   }
-  const content = await readFile45(path, "utf-8");
+  const content = await readFile44(path, "utf-8");
   const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
   let title = "";
   if (fmMatch) {
@@ -27593,7 +27756,7 @@ async function loadInlineFiles(rows, assignmentDir) {
       continue;
     }
     try {
-      out.set(r.file_path, await readFile45(abs, "utf-8"));
+      out.set(r.file_path, await readFile44(abs, "utf-8"));
     } catch {
       out.set(r.file_path, null);
     }
@@ -27612,7 +27775,7 @@ async function loadTranscriptSidecars(rows, assignmentDir) {
     const st = await stat9(sidecar);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) continue;
     try {
-      out.set(r.id, await readFile45(sidecar, "utf-8"));
+      out.set(r.id, await readFile44(sidecar, "utf-8"));
     } catch {
     }
   }
@@ -27791,13 +27954,13 @@ leaseCommand.command("claim").description("Claim an idle member of an inventory.
               process.exit(1);
               return;
             }
-            const delay = Math.min(
+            const delay2 = Math.min(
               backoffSchedule[Math.min(attempt, backoffSchedule.length - 1)] ?? 1e3,
               1e3,
               remaining
             );
             attempt += 1;
-            await new Promise((r) => setTimeout(r, delay));
+            await new Promise((r) => setTimeout(r, delay2));
           }
         }
       }
@@ -28370,7 +28533,7 @@ function isoToCcusageDate(iso) {
 
 // src/usage/cwd-extractor.ts
 init_paths();
-import { open as open4, readdir as readdir25, stat as stat10 } from "fs/promises";
+import { open as open4, readdir as readdir24, stat as stat10 } from "fs/promises";
 import { join as join13 } from "path";
 import { homedir as homedir9 } from "os";
 var SCAN_LINE_CAP = 50;
@@ -28493,7 +28656,7 @@ function resolveCodexSessionsRoot(override) {
 }
 async function listDirSafe(path) {
   try {
-    const entries = await readdir25(path, { withFileTypes: true });
+    const entries = await readdir24(path, { withFileTypes: true });
     return entries.map((e) => ({
       name: e.name,
       isFile: e.isFile(),
@@ -28849,7 +29012,7 @@ init_timestamp();
 init_assignment_resolver();
 init_assignment_todos();
 import { resolve as resolve69 } from "path";
-import { readFile as readFile46 } from "fs/promises";
+import { readFile as readFile45 } from "fs/promises";
 async function requestCommand(target, text, options = {}) {
   if (!text || !text.trim()) {
     throw new Error("Request text cannot be empty.");
@@ -28880,7 +29043,7 @@ async function requestCommand(target, text, options = {}) {
     throw new Error(`assignment.md not found at ${assignmentMdPath2}`);
   }
   const source = options.from ?? process.env.SYNTAUR_ASSIGNMENT ?? "unknown";
-  let content = await readFile46(assignmentMdPath2, "utf-8");
+  let content = await readFile45(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody(content, [
     { description: `${text.trim()} (from: ${source})` }
   ]);
@@ -28893,13 +29056,13 @@ async function requestCommand(target, text, options = {}) {
 init_fs();
 init_paths();
 import { Command as Command9 } from "commander";
-import { readFile as readFile47, readdir as readdir26 } from "fs/promises";
+import { readFile as readFile46, readdir as readdir25 } from "fs/promises";
 import { resolve as resolve70 } from "path";
 async function readContextAssignmentDir(cwd) {
   const path = resolve70(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile47(path, "utf-8");
+    const raw = await readFile46(path, "utf-8");
     const ctx = JSON.parse(raw);
     if (typeof ctx.assignmentDir === "string" && ctx.assignmentDir.length > 0) {
       return ctx.assignmentDir;
@@ -28926,7 +29089,7 @@ async function resolveAssignmentDir(opts) {
 var PLAN_PATTERN = /^plan(?:-v(\d+))?\.md$/;
 async function listPlanFiles(assignmentDir) {
   if (!await fileExists(assignmentDir)) return [];
-  const entries = await readdir26(assignmentDir, { withFileTypes: true });
+  const entries = await readdir25(assignmentDir, { withFileTypes: true });
   const out = [];
   for (const e of entries) {
     if (!e.isFile()) continue;
@@ -29074,11 +29237,11 @@ async function runPlanVersion(options) {
   if (await fileExists(newPath) && !options.force) {
     throw new Error(`${next.fileName} already exists. Use --force to overwrite.`);
   }
-  const assignmentMd = await readFile47(assignmentMdPath2, "utf-8");
+  const assignmentMd = await readFile46(assignmentMdPath2, "utf-8");
   const slugMatch = assignmentMd.match(/^slug:\s*(.+?)\s*$/m);
   const slug = slugMatch ? slugMatch[1].trim() : assignmentDir.split("/").pop() ?? "";
   const oldPlanPath = resolve70(assignmentDir, current.fileName);
-  const oldPlanContent = await readFile47(oldPlanPath, "utf-8");
+  const oldPlanContent = await readFile46(oldPlanPath, "utf-8");
   const oldBody = oldPlanContent.replace(/^---[\s\S]*?\n---\n?/, "");
   const carriedTodos = extractUncheckedTodos(oldBody);
   const stub = buildNewPlanStub({
@@ -29115,13 +29278,13 @@ planCommand.command("version").description(
 // src/commands/session.ts
 init_fs();
 import { Command as Command10 } from "commander";
-import { readFile as readFile48, readdir as readdir27, stat as stat11 } from "fs/promises";
+import { readFile as readFile47, readdir as readdir26, stat as stat11 } from "fs/promises";
 import { resolve as resolve71 } from "path";
 async function readContext(cwd) {
   const path = resolve71(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile48(path, "utf-8");
+    const raw = await readFile47(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -29130,7 +29293,7 @@ async function readContext(cwd) {
 async function findLatestSessionSummary(assignmentDir) {
   const sessionsRoot = resolve71(assignmentDir, "sessions");
   if (!await fileExists(sessionsRoot)) return null;
-  const entries = await readdir27(sessionsRoot, { withFileTypes: true });
+  const entries = await readdir26(sessionsRoot, { withFileTypes: true });
   let best = null;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -29146,7 +29309,7 @@ async function findLatestSessionSummary(assignmentDir) {
 async function findOpenHandoff(assignmentDir) {
   const handoffPath = resolve71(assignmentDir, "handoff.md");
   if (!await fileExists(handoffPath)) return null;
-  const content = await readFile48(handoffPath, "utf-8");
+  const content = await readFile47(handoffPath, "utf-8");
   const body = content.replace(/^---[\s\S]*?\n---\n?/, "").trim();
   if (body.length === 0) return null;
   if (/^<!--[\s\S]*-->$/.test(body)) return null;
@@ -29254,13 +29417,13 @@ init_git_worktree();
 init_fs();
 init_paths();
 import { Command as Command11 } from "commander";
-import { readFile as readFile49 } from "fs/promises";
+import { readFile as readFile48 } from "fs/promises";
 import { resolve as resolve72 } from "path";
 async function readContext2(cwd) {
   const path = resolve72(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    return JSON.parse(await readFile49(path, "utf-8"));
+    return JSON.parse(await readFile48(path, "utf-8"));
   } catch {
     return null;
   }
@@ -29332,7 +29495,7 @@ import { resolve as resolve74 } from "path";
 // src/utils/project-indexes.ts
 init_parser();
 init_fs();
-import { readdir as readdir28, readFile as readFile50 } from "fs/promises";
+import { readdir as readdir27, readFile as readFile49 } from "fs/promises";
 import { resolve as resolve73 } from "path";
 function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -29342,7 +29505,7 @@ function readProjectSlug(projectDir) {
 }
 async function listSlugFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir28(dir, { withFileTypes: true });
+  const entries = await readdir27(dir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_")).map((e) => e.name).sort();
 }
 function escapeCell(value) {
@@ -29368,7 +29531,7 @@ async function rebuildResourcesIndex(projectDir) {
   lines.push("| Name | Category | Source | Related Assignments | Updated |");
   lines.push("|------|----------|--------|---------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile50(resolve73(dir, fileName), "utf-8");
+    const content = await readFile49(resolve73(dir, fileName), "utf-8");
     const parsed = parseResource(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -29399,7 +29562,7 @@ async function rebuildMemoriesIndex(projectDir) {
   lines.push("| Name | Source | Scope | Source Assignment | Updated |");
   lines.push("|------|--------|-------|-------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile50(resolve73(dir, fileName), "utf-8");
+    const content = await readFile49(resolve73(dir, fileName), "utf-8");
     const parsed = parseMemory(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -29574,7 +29737,7 @@ init_paths();
 init_fs();
 init_frontmatter();
 import { Command as Command14 } from "commander";
-import { readFile as readFile51 } from "fs/promises";
+import { readFile as readFile50 } from "fs/promises";
 import { resolve as resolve76 } from "path";
 var AGE_PATTERN = /^(\d+)([dhwm])$/i;
 function parseAgeToCutoff(age) {
@@ -29608,7 +29771,7 @@ async function loadTags(item) {
   const path = assignmentMdPath(item);
   if (!await fileExists(path)) return [];
   try {
-    const content = await readFile51(path, "utf-8");
+    const content = await readFile50(path, "utf-8");
     return parseAssignmentFrontmatter(content).tags;
   } catch {
     return [];
@@ -29686,10 +29849,10 @@ var lsCommand = new Command14("ls").description(
 
 // src/cli-default-command.ts
 init_config2();
-import { readdir as readdir29 } from "fs/promises";
+import { readdir as readdir28 } from "fs/promises";
 async function hasAnyProjectContent(projectsDir2) {
   try {
-    const entries = await readdir29(projectsDir2, { withFileTypes: true });
+    const entries = await readdir28(projectsDir2, { withFileTypes: true });
     return entries.some((entry) => entry.isDirectory());
   } catch {
     return false;
@@ -29726,20 +29889,20 @@ async function getDefaultCommandName() {
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath10 } from "url";
-import { readFile as readFile53 } from "fs/promises";
+import { readFile as readFile52 } from "fs/promises";
 import { dirname as dirname21, join as join15, resolve as resolve77 } from "path";
 import { spawn as spawn10 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
 import { fileURLToPath as fileURLToPath9 } from "url";
-import { readFile as readFile52 } from "fs/promises";
+import { readFile as readFile51 } from "fs/promises";
 import { dirname as dirname20, join as join14 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath9(scriptUrl);
     const pkgRoot = dirname20(dirname20(scriptPath));
-    const raw = await readFile52(join14(pkgRoot, "package.json"), "utf-8");
+    const raw = await readFile51(join14(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -29769,7 +29932,7 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw = await readFile53(STATE_FILE, "utf-8");
+    const raw = await readFile52(STATE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -29828,7 +29991,7 @@ async function readGlobalVersion() {
   try {
     const manifestPath = join15(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw = await readFile53(manifestPath, "utf-8");
+    const raw = await readFile52(manifestPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {