p-backlog 0.5.1 → 0.6.0

package/dist/cli.js

@@ -42,7 +42,7 @@ function formatLocalIso(date) {
 }
 
 // src/core/store/runs.ts
-import { appendFile, mkdir, open } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
 import { join as join3 } from "node:path";
 import { z } from "zod";
 
@@ -201,7 +201,7 @@ import { setTimeout as sleep2 } from "node:timers/promises";
 
 // src/core/store/fs-utils.ts
 import { createHash, randomUUID } from "node:crypto";
-import { chmod, link, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { chmod, link, open, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 function contentVersion(text) {
@@ -215,16 +215,56 @@ async function readTextOrNull(path) {
     throw error;
   }
 }
-async function readJsonLines(path, schema) {
-  const text = await readTextOrNull(path) ?? "";
+function parseJsonLines(text, schema) {
   const parsed = text.split("\n").filter((line) => line.trim() !== "").map((line) => parseJson(line, schema));
   const values = parsed.filter((value) => value !== null);
   return { values, invalidLines: parsed.length - values.length };
 }
+async function readJsonLines(path, schema) {
+  const text = await readTextOrNull(path) ?? "";
+  return parseJsonLines(text, schema);
+}
 function toJsonLines(values) {
   return values.map((value) => `${JSON.stringify(value)}
 `).join("");
 }
+var NEWLINE = 10;
+async function appendJsonLines(path, values) {
+  await withFile(
+    path,
+    async (handle) => {
+      const { size } = await handle.stat();
+      const endsMidLine = size > 0 && (await readAt(handle, size - 1, 1))[0] !== NEWLINE;
+      await handle.appendFile((endsMidLine ? "\n" : "") + toJsonLines(values), "utf8");
+    },
+    "a+"
+  );
+}
+async function withFile(path, use, flags = "r") {
+  return closingAfter(await open(path, flags), use);
+}
+async function withExistingFile(path, use) {
+  const handle = await open(path, "r").catch((error) => {
+    if (hasErrorCode(error, "ENOENT")) return null;
+    throw error;
+  });
+  return handle === null ? null : closingAfter(handle, use);
+}
+async function closingAfter(handle, use) {
+  try {
+    return await use(handle);
+  } finally {
+    await handle.close();
+  }
+}
+async function readAt(handle, position, length) {
+  const buffer = Buffer.alloc(length);
+  const { bytesRead } = await handle.read(buffer, 0, length, position);
+  return buffer.subarray(0, bytesRead);
+}
+function readFileAt(path, position, length) {
+  return withFile(path, (handle) => readAt(handle, position, length));
+}
 function parseJson(text, schema) {
   try {
     const parsed = schema.safeParse(JSON.parse(text));
@@ -400,10 +440,7 @@ var cliRunSchema = z.object({
 async function appendRun(root, run) {
   await mkdir(root, { recursive: true });
   const path = join3(root, RUNS_FILE);
-  await withFileLock(path, () => appendFile(path, toJsonLines([run]), "utf8"));
-}
-async function readRuns(root) {
-  return (await readJsonLines(join3(root, RUNS_FILE), cliRunSchema)).values;
+  await withFileLock(path, () => appendJsonLines(path, [run]));
 }
 async function trimRuns(root, now) {
   const path = join3(root, RUNS_FILE);
@@ -423,20 +460,13 @@ async function trimRunsWhenStale(root, now) {
   return needsTrim ? trimRuns(root, now) : 0;
 }
 async function firstRun(path) {
-  const file = await open(path, "r").catch((error) => {
-    if (hasErrorCode(error, "ENOENT")) return null;
-    throw error;
-  });
-  if (file === null) return "none";
-  try {
-    const { buffer, bytesRead } = await file.read(Buffer.alloc(FIRST_LINE_BYTES), 0, FIRST_LINE_BYTES, 0);
-    const [firstLine = ""] = buffer.toString("utf8", 0, bytesRead).split("\n");
-    if (firstLine.trim() === "") return "none";
-    const run = parseJson(firstLine, cliRunSchema);
-    return run === null ? "unparsable" : Date.parse(run.at);
-  } finally {
-    await file.close();
-  }
+  return await withExistingFile(path, firstRunIn) ?? "none";
+}
+async function firstRunIn(handle) {
+  const [firstLine = ""] = (await readAt(handle, 0, FIRST_LINE_BYTES)).toString("utf8").split("\n");
+  if (firstLine.trim() === "") return "none";
+  const run = parseJson(firstLine, cliRunSchema);
+  return run === null ? "unparsable" : Date.parse(run.at);
 }
 
 // src/core/store/paths.ts
@@ -598,7 +628,7 @@ var cliEn = {
   taskNotFound: (id) => `Task ${id} not found`,
   fileConflict: (id) => `Task file ${id} changed while writing, retry the command`,
   statsTitle: (scopeName) => `${scopeName} \xB7 stats`,
-  statsOpenLine: ({ open: open3, weight, net, created, closed }) => `Open: ${open3} (weight ${weight}) \xB7 this week: ${net} (created ${created}, closed ${closed})`,
+  statsOpenLine: ({ open: open2, weight, net, created, closed }) => `Open: ${open2} (weight ${weight}) \xB7 this week: ${net} (created ${created}, closed ${closed})`,
   statsAgeLine: (ageMedian, leadMedian, tail) => `Age, median: ${ageMedian} \xB7 time to close, median: ${leadMedian}${tail}`,
   statsP90Tail: (p903) => ` (90% \u2014 ${p903})`,
   statsForecastLine: (forecast3, tail) => `Forecast: ${forecast3} (${tail})`,
@@ -652,7 +682,7 @@ var cliEn = {
     "delete <id> --confirm <id>    (deletes the project directory with all its tasks)"
   ],
   noProjects: "No projects",
-  projectListLine: ({ id, name, prefix, statusWord: statusWord2, open: open3 }) => `${id} \xB7 ${name} \xB7 ${prefix} \xB7 ${statusWord2} \xB7 open ${open3}`,
+  projectListLine: ({ id, name, prefix, statusWord: statusWord2, open: open2 }) => `${id} \xB7 ${name} \xB7 ${prefix} \xB7 ${statusWord2} \xB7 open ${open2}`,
   confirmProjectDelete: (id) => `Confirm the deletion: backlog project delete ${id} --confirm ${id}`,
   projectDeleted: (id, taskCount) => `${id} deleted: tasks ${taskCount}`,
   projectActive: "active",
@@ -775,7 +805,7 @@ var cliRu = {
   taskNotFound: (id) => `\u0417\u0430\u0434\u0430\u0447\u0430 ${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430`,
   fileConflict: (id) => `\u0424\u0430\u0439\u043B \u0437\u0430\u0434\u0430\u0447\u0438 ${id} \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u0441\u044F \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u0437\u0430\u043F\u0438\u0441\u0438, \u043F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0435 \u043A\u043E\u043C\u0430\u043D\u0434\u0443`,
   statsTitle: (scopeName) => `${scopeName} \xB7 \u0441\u0442\u0430\u0442\u0438\u0441\u0442\u0438\u043A\u0430`,
-  statsOpenLine: ({ open: open3, weight, net, created, closed }) => `\u041E\u0442\u043A\u0440\u044B\u0442\u043E: ${open3} (\u0432\u0435\u0441 ${weight}) \xB7 \u0437\u0430 \u043D\u0435\u0434\u0435\u043B\u044E: ${net} (\u0441\u043E\u0437\u0434\u0430\u043D\u043E ${created}, \u0437\u0430\u043A\u0440\u044B\u0442\u043E ${closed})`,
+  statsOpenLine: ({ open: open2, weight, net, created, closed }) => `\u041E\u0442\u043A\u0440\u044B\u0442\u043E: ${open2} (\u0432\u0435\u0441 ${weight}) \xB7 \u0437\u0430 \u043D\u0435\u0434\u0435\u043B\u044E: ${net} (\u0441\u043E\u0437\u0434\u0430\u043D\u043E ${created}, \u0437\u0430\u043A\u0440\u044B\u0442\u043E ${closed})`,
   statsAgeLine: (ageMedian, leadMedian, tail) => `\u0412\u043E\u0437\u0440\u0430\u0441\u0442, \u043C\u0435\u0434\u0438\u0430\u043D\u0430: ${ageMedian} \xB7 \u0434\u043E \u0437\u0430\u043A\u0440\u044B\u0442\u0438\u044F, \u043C\u0435\u0434\u0438\u0430\u043D\u0430: ${leadMedian}${tail}`,
   statsP90Tail: (p903) => ` (90% \u2014 ${p903})`,
   statsForecastLine: (forecast3, tail) => `\u041F\u0440\u043E\u0433\u043D\u043E\u0437: ${forecast3} (${tail})`,
@@ -840,8 +870,8 @@ var cliRu = {
     name,
     prefix,
     statusWord: statusWord2,
-    open: open3
-  }) => `${id} \xB7 ${name} \xB7 ${prefix} \xB7 ${statusWord2} \xB7 \u043E\u0442\u043A\u0440\u044B\u0442\u044B\u0445 ${open3}`,
+    open: open2
+  }) => `${id} \xB7 ${name} \xB7 ${prefix} \xB7 ${statusWord2} \xB7 \u043E\u0442\u043A\u0440\u044B\u0442\u044B\u0445 ${open2}`,
   confirmProjectDelete: (id) => `\u041F\u043E\u0434\u0442\u0432\u0435\u0440\u0434\u0438\u0442\u0435 \u0443\u0434\u0430\u043B\u0435\u043D\u0438\u0435: backlog project delete ${id} --confirm ${id}`,
   projectDeleted: (id, taskCount) => `${id} \u0443\u0434\u0430\u043B\u0451\u043D: \u0437\u0430\u0434\u0430\u0447 ${taskCount}`,
   projectActive: "\u0430\u043A\u0442\u0438\u0432\u0435\u043D",
@@ -1477,8 +1507,8 @@ function p90(value) {
   if (value === null) return "\u2014";
   return value < 1 ? "within a day" : `within ${days(value)}`;
 }
-function forecast({ open: open3, weeklyNet, weeks, until }) {
-  if (open3 === 0) return "No open tasks";
+function forecast({ open: open2, weeklyNet, weeks, until }) {
+  if (open2 === 0) return "No open tasks";
   if (weeks !== null && until !== null) return `Debt clears in about ${weeks} wk. (by ${formatDayMonth("en", new Date(until))})`;
   if (weeklyNet === 0) return "Debt is not shrinking";
   const growth = roundToTenth(-weeklyNet);
@@ -1710,8 +1740,8 @@ function p902(value) {
   if (value === null) return "\u2014";
   return value < 1 ? "\u0431\u044B\u0441\u0442\u0440\u0435\u0435 \u0441\u0443\u0442\u043E\u043A" : `\u0437\u0430 ${days2(value)}`;
 }
-function forecast2({ open: open3, weeklyNet, weeks, until }) {
-  if (open3 === 0) return "\u041E\u0442\u043A\u0440\u044B\u0442\u044B\u0445 \u0437\u0430\u0434\u0430\u0447 \u043D\u0435\u0442";
+function forecast2({ open: open2, weeklyNet, weeks, until }) {
+  if (open2 === 0) return "\u041E\u0442\u043A\u0440\u044B\u0442\u044B\u0445 \u0437\u0430\u0434\u0430\u0447 \u043D\u0435\u0442";
   if (weeks !== null && until !== null) return `\u0414\u043E\u043B\u0433 \u0440\u0430\u0437\u0431\u0435\u0440\u0451\u0442\u0441\u044F \u043F\u0440\u0438\u043C\u0435\u0440\u043D\u043E \u0437\u0430 ${weeks}${NBSP}\u043D\u0435\u0434. (\u043A ${formatDayMonth("ru", new Date(until))})`;
   if (weeklyNet === 0) return "\u0414\u043E\u043B\u0433 \u043D\u0435 \u0443\u043C\u0435\u043D\u044C\u0448\u0430\u0435\u0442\u0441\u044F";
   const growth = roundToTenth(-weeklyNet);
@@ -2149,20 +2179,21 @@ function findBlockerCycle(start, resolve7) {
 }
 
 // src/core/store/journal.ts
-import { appendFile as appendFile2 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 var JOURNAL_FILE = "journal.jsonl";
 async function appendJournal(projectDir2, events, onError = reportToStderr) {
   if (events.length === 0) return;
   const path = join7(projectDir2, JOURNAL_FILE);
   try {
-    await appendFile2(path, toJsonLines(events), "utf8");
+    await appendJsonLines(path, events);
   } catch (error) {
     onError(path, error);
   }
 }
 async function readJournal(projectDir2, projectId) {
-  const { values, invalidLines } = await readJsonLines(join7(projectDir2, JOURNAL_FILE), journalEventSchema);
+  return projectJournal(projectId, await readJsonLines(join7(projectDir2, JOURNAL_FILE), journalEventSchema));
+}
+function projectJournal(projectId, { values, invalidLines }) {
   return { projectId, events: values, invalidLines };
 }
 async function readJournals(root, projectIds) {
@@ -2940,11 +2971,11 @@ function anchorState(task, facts) {
   return moved === null || movedAnchor === null ? { kind: "changed" } : { kind: "moved", source: moved, anchor: movedAnchor };
 }
 function findSimilarTask(draft, tasks) {
-  const open3 = tasks.filter((task) => task.type === "task" && !isClosed(task.status));
+  const open2 = tasks.filter((task) => task.type === "task" && !isClosed(task.status));
   const { source } = draft;
-  const bySource = source === void 0 ? void 0 : open3.find((task) => task.source !== void 0 && samePlace(task.source, source));
+  const bySource = source === void 0 ? void 0 : open2.find((task) => task.source !== void 0 && samePlace(task.source, source));
   if (bySource !== void 0) return { task: taskRef(bySource), match: "source" };
-  const byTitle = open3.find((task) => similarTitles(task.title, draft.title));
+  const byTitle = open2.find((task) => similarTitles(task.title, draft.title));
   return byTitle === void 0 ? null : { task: taskRef(byTitle), match: "title" };
 }
 function duplicateCandidates(tasks, symbolOf = () => null) {
@@ -4640,12 +4671,12 @@ async function rememberShown(projectDir2, shown, io) {
 
 // src/cli/describe.ts
 function describeTask(task, index) {
-  const open3 = openBlockers(task, index);
+  const open2 = openBlockers(task, index);
   return {
     task,
     progress: taskProgress(task, index),
-    openBlockers: open3,
-    inactiveBlockerIds: task.blockedBy.filter((id) => !open3.some((blocker) => blocker.id === id)),
+    openBlockers: open2,
+    inactiveBlockerIds: task.blockedBy.filter((id) => !open2.some((blocker) => blocker.id === id)),
     blocks: dependentTasks(task, index),
     related: relatedTasks(task, index),
     epic: task.epic === void 0 ? void 0 : index.byId.get(task.epic),
@@ -4830,8 +4861,8 @@ async function listProjects(io) {
   }
   const index = buildIndex(loaded.tasks);
   for (const project of loaded.projects) {
-    const open3 = filterTasks(loaded.tasks, { projectId: project.id, statuses: OPEN_STATUSES }, index).length;
-    io.print(cli.projectListLine({ id: project.id, name: project.name, prefix: project.prefix, statusWord: statusWord(cli, project.active), open: open3 }));
+    const open2 = filterTasks(loaded.tasks, { projectId: project.id, statuses: OPEN_STATUSES }, index).length;
+    io.print(cli.projectListLine({ id: project.id, name: project.name, prefix: project.prefix, statusWord: statusWord(cli, project.active), open: open2 }));
   }
   return EXIT.ok;
 }
@@ -5012,7 +5043,7 @@ function listenFailure(error, port, messages) {
 // src/server/start.ts
 import { serve } from "@hono/node-server";
 import { mkdir as mkdir6, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 
 // src/core/store/sweep.ts
 import { dirname as dirname7, join as join22 } from "node:path";
@@ -5162,7 +5193,7 @@ async function reserveNumbers(projects, expired) {
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono as Hono3 } from "hono";
 import { secureHeaders } from "hono/secure-headers";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 
 // src/server/api.ts
 import { Hono as Hono2 } from "hono";
@@ -5292,17 +5323,22 @@ function previousOf(task) {
 function createReportCache({ ttlMs, now }) {
   let entries = /* @__PURE__ */ new Map();
   return {
-    get: (key, compute) => {
+    get: (key, compute, tags = []) => {
       const cached = entries.get(key);
       if (cached !== void 0 && now() - cached.at <= ttlMs) return cached.value;
-      const generation = entries;
       const value = compute();
-      generation.set(key, { at: now(), value });
-      value.catch(() => generation.delete(key));
+      entries.set(key, { at: now(), value, tags });
+      value.catch(() => {
+        if (entries.get(key)?.value === value) entries.delete(key);
+      });
       return value;
     },
     clear: () => {
       entries = /* @__PURE__ */ new Map();
+    },
+    clearTagged: (tags) => {
+      const tagged = new Set(tags);
+      for (const [key, entry] of entries) if (entry.tags.some((tag) => tagged.has(tag))) entries.delete(key);
     }
   };
 }
@@ -5347,32 +5383,36 @@ async function markOf(path) {
 
 // src/server/stats-api.ts
 import { Hono } from "hono";
+import { relative as relative3, sep as sep4 } from "node:path";
 
 // src/core/code/code-cache.ts
 import { join as join23 } from "node:path";
 import { z as z15 } from "zod";
 var CODE_CACHE_FILE = ".code-cache.json";
-var CODE_CACHE_VERSION = 1;
-var repoCodeSchema = z15.object({
-  commits: z15.array(z15.array(z15.string())),
-  lines: z15.array(z15.object({ path: z15.string(), lines: z15.number() })),
-  units: z15.array(z15.object({ date: z15.string(), lines: z15.number() }))
+var CODE_CACHE_VERSION = 2;
+var repoScanSchema = z15.object({
+  head: z15.string(),
+  main: z15.string().nullable(),
+  commits: z15.array(z15.object({ date: z15.string(), paths: z15.array(z15.string()) })),
+  units: z15.array(z15.object({ date: z15.string(), lines: z15.number() })),
+  lines: z15.array(z15.object({ path: z15.string(), lines: z15.number() }))
 });
 var fixCommitSchema = z15.object({ date: z15.string(), landedAt: z15.string().optional(), byAgent: z15.boolean(), lines: z15.number(), testLines: z15.number() });
 var snapshotSchema = z15.object({
   version: z15.literal(CODE_CACHE_VERSION),
-  repos: z15.record(z15.string(), z15.object({ key: z15.string(), code: repoCodeSchema })),
-  fixes: z15.record(z15.string(), fixCommitSchema)
+  repos: z15.record(z15.string(), repoScanSchema),
+  fixes: z15.record(z15.string(), fixCommitSchema),
+  unsettled: z15.record(z15.string(), z15.string().nullable())
 });
 function emptyCodeCache() {
-  return { repos: {}, fixes: {} };
+  return { repos: {}, fixes: {}, unsettled: {} };
 }
 function createCodeCacheFile(root) {
   const path = join23(root, CODE_CACHE_FILE);
   return {
     read: async () => {
       const snapshot = await readJsonFile(path, snapshotSchema);
-      return snapshot === null ? emptyCodeCache() : { repos: snapshot.repos, fixes: snapshot.fixes };
+      return snapshot === null ? emptyCodeCache() : { repos: snapshot.repos, fixes: snapshot.fixes, unsettled: snapshot.unsettled };
     },
     write: (snapshot) => writeFileAtomic(path, JSON.stringify({ version: CODE_CACHE_VERSION, ...snapshot }))
   };
@@ -5380,6 +5420,9 @@ function createCodeCacheFile(root) {
 
 // src/core/code/code-window.ts
 var CHURN_DAYS = 90;
+function churnWindowStart(now) {
+  return new Date(now.getTime() - CHURN_DAYS * DAY_MS);
+}
 
 // src/core/code/test-paths.ts
 var TEST_DIRECTORIES = /* @__PURE__ */ new Set(["test", "tests", "__tests__", "e2e", "spec"]);
@@ -5401,7 +5444,6 @@ var CHURN_EXCLUDES = [...LOCK_EXCLUDES, ...NON_CODE_EXTENSIONS.map((ext) => `:!*
 var HEAD = "HEAD";
 var MAIN_REFS = ["origin/HEAD", "main", "master"];
 var AGENT_TRAILER = /^claude/i;
-var GREP_PREFIX = "HEAD:";
 var RENAME_ARROW = " => ";
 async function readRefs(git, repo) {
   const commits = await resolveCommits(git, repo, [HEAD, ...MAIN_REFS]) ?? /* @__PURE__ */ new Map();
@@ -5409,14 +5451,68 @@ async function readRefs(git, repo) {
   const main = MAIN_REFS.map((ref) => commits.get(ref)).find((commit) => commit !== void 0);
   return { head, main: main ?? head };
 }
-async function readRepoCode(git, repo, since, mainCommit) {
-  const [log2, grep, units] = await Promise.all([
-    git(repo, ["log", `--since=${since.toISOString()}`, `--format=tformat:${RECORD}`, "--name-only", "-M", "--relative", "-z", "--", "."]),
-    git(repo, ["grep", "-I", "-c", "-z", "", "HEAD", "--", ".", ...LOCK_EXCLUDES]),
-    readUnits(git, repo, since, mainCommit)
+async function readCommitsSince(git, repo, since, range) {
+  const output = await git(repo, [
+    "log",
+    revisionsOf(range),
+    "--full-history",
+    "--sparse",
+    `--since=${since.toISOString()}`,
+    `--format=tformat:${RECORD}%P${FIELD}%cI`,
+    "--name-only",
+    "-M",
+    "--relative",
+    "-z",
+    "--",
+    "."
   ]);
-  if (log2 === null || grep === null) return null;
-  return { commits: parseCommits(log2), lines: parseLines(grep), units };
+  if (output === null) return null;
+  const { after } = range;
+  const commits = records(output).map((record) => {
+    const [header = "", ...files] = record.split("\0");
+    return { ...parseHistoryHeader(header), paths: files.map((file) => file.replace(/^\n/, "")).filter((file) => file !== "") };
+  });
+  return {
+    entries: commits.filter(({ paths }) => paths.length > 0).map(({ date, paths }) => ({ date, paths })),
+    reachesAfter: after === void 0 || commits.some(({ parents }) => parents.includes(after))
+  };
+}
+async function readUnits(git, repo, since, range) {
+  const output = await git(repo, [
+    "log",
+    revisionsOf(range),
+    "--first-parent",
+    "--sparse",
+    "--diff-merges=first-parent",
+    `--since=${since.toISOString()}`,
+    `--format=tformat:${RECORD}%P${FIELD}%cI`,
+    "--numstat",
+    "--relative",
+    "--",
+    ".",
+    ...CHURN_EXCLUDES
+  ]);
+  if (output === null) return null;
+  const { after } = range;
+  const units = records(output).map((record) => {
+    const [header = "", ...rows] = record.split("\n");
+    return { ...parseHistoryHeader(header), rows: rows.filter((row) => row.trim() !== "") };
+  });
+  return {
+    entries: units.filter(({ rows }) => rows.length > 0).map(({ date, rows }) => ({ date, lines: numstatLines(rows) })),
+    reachesAfter: after === void 0 || units.some(({ parents }) => parents[0] === after)
+  };
+}
+async function readLines(git, repo, head) {
+  const output = await git(repo, ["grep", "-I", "-c", "-z", "", head, "--", ".", ...LOCK_EXCLUDES]);
+  return output === null ? null : parseLines(output, `${head}:`);
+}
+function revisionsOf({ tip, after }) {
+  return after === void 0 ? tip : `${after}..${tip}`;
+}
+function parseHistoryHeader(header) {
+  const [parents = "", date = ""] = header.split(FIELD);
+  return { parents: parents.split(" ").filter((parent) => parent !== ""), date: date.trim() };
 }
 async function readFixCommits(git, repo, { hashes, mainCommit }) {
   const fullHashes = await resolveCommits(git, repo, hashes);
@@ -5480,29 +5576,6 @@ function parseFixStats(output) {
 function records(output) {
   return output.split(RECORD).filter((record) => record.trim() !== "");
 }
-async function readUnits(git, repo, since, mainCommit) {
-  if (mainCommit === null) return [];
-  const output = await git(repo, [
-    "log",
-    mainCommit,
-    "--first-parent",
-    "--diff-merges=first-parent",
-    `--since=${since.toISOString()}`,
-    `--format=tformat:${RECORD}%cI`,
-    "--numstat",
-    "--relative",
-    "--",
-    ".",
-    ...CHURN_EXCLUDES
-  ]);
-  return output === null ? [] : parseUnits(output);
-}
-function parseUnits(output) {
-  return output.split(RECORD).filter((record) => record.trim() !== "").map((record) => {
-    const [date = "", ...rows] = record.split("\n");
-    return { date: date.trim(), lines: numstatLines(rows) };
-  });
-}
 function numstatLines(rows) {
   return sum(rows.filter((row) => row.trim() !== "").map(numstatRowLines).filter((lines) => !Number.isNaN(lines)));
 }
@@ -5510,43 +5583,95 @@ function numstatRowLines(row) {
   const [added = "", deleted = ""] = row.split("	");
   return Number(added) + Number(deleted);
 }
-function parseCommits(output) {
-  return output.split(RECORD).map((record) => record.split("\0").map((file) => file.replace(/^\n/, "")).filter((file) => file !== "")).filter((files) => files.length > 0);
-}
-function parseLines(output) {
-  return output.split("\n").filter((record) => record.startsWith(GREP_PREFIX)).map((record) => {
-    const [path = "", count3 = ""] = record.slice(GREP_PREFIX.length).split("\0");
+function parseLines(output, prefix) {
+  return output.split("\n").filter((record) => record.startsWith(prefix)).map((record) => {
+    const [path = "", count3 = ""] = record.slice(prefix.length).split("\0");
     return { path, lines: Number(count3) };
   });
 }
 
+// src/core/code/repo-scan.ts
+async function scanRepo(git, repo, { refs, now, previous }) {
+  const { head, main } = refs;
+  if (head === null) return null;
+  const since = churnWindowStart(now);
+  const [commits, units, lines] = await Promise.all([
+    extendHistory((range) => readCommitsSince(git, repo, since, range), head, historyOf2(previous?.head, previous?.commits)),
+    main === null ? [] : extendHistory((range) => readUnits(git, repo, since, range), main, historyOf2(previous?.main, previous?.units)),
+    previous?.head === head ? previous.lines : readLines(git, repo, head)
+  ]);
+  if (commits === null || units === null || lines === null) return null;
+  const scan = { head, main, commits: windowOf2(commits, since), units: windowOf2(units, since), lines };
+  return previous !== void 0 && isSameScan(previous, scan) ? previous : scan;
+}
+function repoCodeOf(scan) {
+  return { commits: scan.commits.map(({ paths }) => paths), lines: scan.lines, units: scan.units };
+}
+function historyOf2(tip, entries) {
+  return tip === void 0 || tip === null || entries === void 0 ? void 0 : { tip, entries };
+}
+async function extendHistory(read, tip, previous) {
+  if (previous?.tip === tip) return previous.entries;
+  if (previous !== void 0) {
+    const added = await read({ tip, after: previous.tip });
+    if (added?.reachesAfter === true) return [...added.entries, ...previous.entries];
+  }
+  return (await read({ tip }))?.entries ?? null;
+}
+function windowOf2(entries, since) {
+  return entries.filter((entry) => Date.parse(entry.date) >= since.getTime()).sort((a, b) => Date.parse(b.date) - Date.parse(a.date));
+}
+function isSameScan(previous, scan) {
+  return previous.head === scan.head && previous.main === scan.main && previous.commits.length === scan.commits.length && previous.units.length === scan.units.length;
+}
+
 // src/core/code/code-source.ts
 function createCodeSource({ home: home2, git = runGit, store, onError = () => {
 } }) {
   const repoCache = /* @__PURE__ */ new Map();
   const fixCache = /* @__PURE__ */ new Map();
+  const unsettledCheckedAt = /* @__PURE__ */ new Map();
   let changed = false;
   let restored = null;
+  let retainedRepos = null;
   const restore = () => {
     restored ??= readSnapshot(store, (error) => onError("read", error)).then((snapshot) => {
       for (const [repo, entry] of Object.entries(snapshot.repos)) if (!repoCache.has(repo)) repoCache.set(repo, entry);
       for (const [key, commit] of Object.entries(snapshot.fixes)) if (!fixCache.has(key)) fixCache.set(key, commit);
+      for (const [key, main] of Object.entries(snapshot.unsettled)) if (!unsettledCheckedAt.has(key)) unsettledCheckedAt.set(key, main);
     });
     return restored;
   };
   const dropStaleFixes = (now, requested) => {
-    const oldest = now.getTime() - CHURN_DAYS * DAY_MS;
+    const oldest = churnWindowStart(now).getTime();
     for (const [key, commit] of fixCache) {
       if (requested.has(key) || Date.parse(commit.date) >= oldest) continue;
       fixCache.delete(key);
+      unsettledCheckedAt.delete(key);
+      changed = true;
+    }
+  };
+  const dropUnretainedRepos = () => {
+    if (retainedRepos === null) return;
+    const kept = retainedRepos;
+    for (const repo of repoCache.keys()) {
+      if (kept.has(repo)) continue;
+      repoCache.delete(repo);
+      changed = true;
+    }
+    for (const key of /* @__PURE__ */ new Set([...fixCache.keys(), ...unsettledCheckedAt.keys()])) {
+      if (kept.has(repoOfFixCacheKey(key))) continue;
+      fixCache.delete(key);
+      unsettledCheckedAt.delete(key);
       changed = true;
     }
   };
   let writing = Promise.resolve();
   const persist = () => {
+    dropUnretainedRepos();
     if (store === void 0 || !changed) return writing;
     changed = false;
-    const snapshot = { repos: Object.fromEntries(repoCache), fixes: Object.fromEntries(fixCache) };
+    const snapshot = { repos: Object.fromEntries(repoCache), fixes: Object.fromEntries(fixCache), unsettled: Object.fromEntries(unsettledCheckedAt) };
     writing = writing.then(
       () => store.write(snapshot).catch((error) => {
         changed = true;
@@ -5564,35 +5689,39 @@ function createCodeSource({ home: home2, git = runGit, store, onError = () => {
     return started;
   };
   const readRepoOnce = async (repo, now) => {
-    const refs = await readRefs(git, repo);
-    if (refs.head === null) return null;
-    const key = repoKey(refs, now);
-    const cached = repoCache.get(repo);
-    if (cached?.key === key) return { key, code: cached.code };
-    const code = await readRepoCode(git, repo, new Date(now.getTime() - CHURN_DAYS * DAY_MS), refs.main);
-    if (code === null) return null;
-    repoCache.set(repo, { key, code });
+    const previous = repoCache.get(repo);
+    const scan = await scanRepo(git, repo, { refs: await readRefs(git, repo), now, previous });
+    if (scan === null) return null;
+    if (scan !== previous) {
+      repoCache.set(repo, scan);
+      changed = true;
+    }
+    return repoCodeOf(scan);
+  };
+  const rememberUnsettled = (key, main, commit) => {
+    const checkedAt = commit.landedAt === void 0 ? main : void 0;
+    if (unsettledCheckedAt.get(key) === checkedAt) return;
+    if (checkedAt === void 0) unsettledCheckedAt.delete(key);
+    else unsettledCheckedAt.set(key, checkedAt);
     changed = true;
-    return { key, code };
   };
-  const unsettledCheckedAt = /* @__PURE__ */ new Map();
   const needsReading = (key, main) => {
     const cached = fixCache.get(key);
     return cached === void 0 || cached.landedAt === void 0 && unsettledCheckedAt.get(key) !== main;
   };
   const fixCommitsOf = async (repo, main, hashes) => {
-    const unsettled = hashes.filter((hash) => needsReading(`${repo} ${hash}`, main));
+    const unsettled = hashes.filter((hash) => needsReading(fixCacheKey(repo, hash), main));
     if (unsettled.length === 0) return;
     const found = await readFixCommits(git, repo, { hashes: unsettled, mainCommit: main });
     for (const [hash, commit] of found ?? []) {
-      const key = `${repo} ${hash}`;
-      if (commit.landedAt === void 0) unsettledCheckedAt.set(key, main);
+      const key = fixCacheKey(repo, hash);
+      rememberUnsettled(key, main, commit);
       if (fixCache.has(key) && commit.landedAt === void 0) continue;
       fixCache.set(key, commit);
       changed = true;
     }
   };
-  const fixReposOf = async (projects, now) => {
+  const fixReposOf = async (projects) => {
     const refsOf = /* @__PURE__ */ new Map();
     const refsOnce = (repo) => remembered(refsOf, repo, () => readRefs(git, repo));
     const entries = await Promise.all(
@@ -5601,7 +5730,7 @@ function createCodeSource({ home: home2, git = runGit, store, onError = () => {
           project.repos.map(async (repo) => {
             const expanded = expandHome(repo, home2);
             const refs = await refsOnce(expanded);
-            return refs.head === null ? [] : [{ repo: expanded, key: repoKey(refs, now), main: refs.main }];
+            return refs.head === null ? [] : [{ repo: expanded, main: refs.main }];
           })
         );
         return [project.id, repos.flat()];
@@ -5610,6 +5739,9 @@ function createCodeSource({ home: home2, git = runGit, store, onError = () => {
     return new Map(entries);
   };
   return {
+    retain: (backlogProjects) => {
+      retainedRepos = new Set(backlogProjects.flatMap((project) => project.repos.map((repo) => expandHome(repo, home2))));
+    },
     stateKey: async (projects) => {
       const repos = [...new Set(projects.flatMap((project) => project.repos.map((repo) => expandHome(repo, home2))))];
       const states = await Promise.all(repos.map(async (repo) => `${repo}@${refsKey(await readRefs(git, repo))}`));
@@ -5630,7 +5762,7 @@ function createCodeSource({ home: home2, git = runGit, store, onError = () => {
         const readable = [];
         for (const { repo, read } of repos) {
           if (read !== null) {
-            readable.push(read.code);
+            readable.push(read);
           } else if (!seenUnavailable.has(repo)) {
             seenUnavailable.add(repo);
             unavailableRepos.push(repo);
@@ -5643,13 +5775,13 @@ function createCodeSource({ home: home2, git = runGit, store, onError = () => {
     },
     fixCommits: async (projects, requests, now) => {
       await restore();
-      const reposOf = await fixReposOf(projects, now);
+      const reposOf = await fixReposOf(projects);
       await Promise.all(requests.flatMap(({ projectId, hashes }) => (reposOf.get(projectId) ?? []).map(({ repo, main }) => fixCommitsOf(repo, main, hashes))));
       const found = /* @__PURE__ */ new Map();
       const requested = /* @__PURE__ */ new Set();
       for (const { projectId, hashes } of requests) {
         for (const hash of hashes) {
-          const keys = (reposOf.get(projectId) ?? []).map(({ repo }) => `${repo} ${hash}`);
+          const keys = (reposOf.get(projectId) ?? []).map(({ repo }) => fixCacheKey(repo, hash));
           for (const key of keys) requested.add(key);
           const commit = keys.map((key) => fixCache.get(key)).find((cached) => cached !== void 0);
           if (commit !== void 0) found.set(fixKey(projectId, hash), commit);
@@ -5661,12 +5793,15 @@ function createCodeSource({ home: home2, git = runGit, store, onError = () => {
     }
   };
 }
+function fixCacheKey(repo, hash) {
+  return `${repo} ${hash}`;
+}
+function repoOfFixCacheKey(key) {
+  return key.slice(0, key.lastIndexOf(" "));
+}
 function refsKey(refs) {
   return `${refs.head ?? ""} ${refs.main ?? ""}`;
 }
-function repoKey(refs, now) {
-  return `${refsKey(refs)} ${formatLocalDay(now)}`;
-}
 async function readSnapshot(store, onError) {
   try {
     return await store?.read() ?? emptyCodeCache();
@@ -5735,14 +5870,14 @@ function folderRows(project, openTasks) {
     (file) => file.lines
   );
   const ownSources = openTasks.flatMap((task) => task.projectId === project.projectId && task.source !== void 0 ? [task.source] : []);
-  const open3 = countBy(ownSources, folderOf);
-  return [...open3.entries()].flatMap(([label, count3]) => {
+  const open2 = countBy(ownSources, folderOf);
+  return [...open2.entries()].flatMap(([label, count3]) => {
     const folderLines = lines.get(label) ?? 0;
     return folderLines >= MIN_FOLDER_LINES ? [{ label, ...densityRow(folderLines, count3) }] : [];
   }).sort((a, b) => byDensity(a, b) || a.label.localeCompare(b.label)).slice(0, FOLDER_LIMIT);
 }
-function densityRow(lines, open3) {
-  return { lines, open: open3, perKloc: lines === 0 ? null : open3 * LINES_PER_UNIT / lines };
+function densityRow(lines, open2) {
+  return { lines, open: open2, perKloc: lines === 0 ? null : open2 * LINES_PER_UNIT / lines };
 }
 function byDensity(a, b) {
   return (b.perKloc ?? -1) - (a.perKloc ?? -1);
@@ -6040,8 +6175,8 @@ function sizeOf(samples) {
 }
 function totalsOf2(deferred, units, estimate) {
   const fixed = deferred.flatMap((item) => item.fixedLines === null ? [] : [item.fixedLines]);
-  const open3 = deferred.filter((item) => item.fixedLines === null);
-  const estimated = estimatedSizeOf(open3, estimate);
+  const open2 = deferred.filter((item) => item.fixedLines === null);
+  const estimated = estimatedSizeOf(open2, estimate);
   const estimatedLines = estimated?.lines ?? null;
   const realLines = sum(units.map((unit) => unit.lines));
   const fixedLines = sum(fixed);
@@ -6051,15 +6186,15 @@ function totalsOf2(deferred, units, estimate) {
     realLines,
     fixedTasks: fixed.length,
     fixedLines,
-    openTasks: open3.length,
+    openTasks: open2.length,
     estimatedLines,
     deferredLines,
     deferredTestLines: sum(deferred.map((item) => item.fixedTestLines)) + (estimated?.testLines ?? 0),
-    noiseShare: realLines === 0 || estimatedLines === null && open3.length > 0 ? null : Math.min(1, deferredLines / denominator)
+    noiseShare: realLines === 0 || estimatedLines === null && open2.length > 0 ? null : Math.min(1, deferredLines / denominator)
   };
 }
-function estimatedSizeOf(open3, estimate) {
-  const estimates = open3.map((item) => estimate(item.history.category));
+function estimatedSizeOf(open2, estimate) {
+  const estimates = open2.map((item) => estimate(item.history.category));
   if (estimates.some((size) => size === null)) return null;
   const sizes = estimates.filter((size) => size !== null);
   return { lines: sum(sizes.map((size) => size.lines)), testLines: sum(sizes.map((size) => size.testLines)) };
@@ -6234,9 +6369,150 @@ function previousTotals(histories, nowMs, journalStart) {
   };
 }
 
+// src/server/stats-sources.ts
+import { join as join24 } from "node:path";
+
+// src/core/store/jsonl-tail.ts
+import { createHash as createHash5 } from "node:crypto";
+var HEAD_FINGERPRINT_BYTES = 4096;
+var EMPTY_FINGERPRINT = createHash5("sha1").digest("hex");
+function createJsonlTail(path, schema) {
+  let state = emptyState();
+  let generation = 0;
+  let queue = Promise.resolve();
+  function read() {
+    const result = queue.then(doRead);
+    queue = result.catch(() => void 0);
+    return result;
+  }
+  async function doRead() {
+    const pending = await withExistingFile(path, consumeNew);
+    if (pending === null) restart();
+    const { values, invalidLines, bytes } = pending ?? nothingPending();
+    return { values: values.length === 0 ? state.values : [...state.values, ...values], invalidLines: state.invalidLines + invalidLines, length: state.offset + bytes, generation };
+  }
+  async function consumeNew(handle) {
+    const { size } = await handle.stat();
+    if (size < state.offset || !await headMatches(handle)) restart();
+    return size > state.offset ? consumeUpTo(handle, size) : nothingPending();
+  }
+  function restart() {
+    if (state.offset === 0) return;
+    generation += 1;
+    state = emptyState();
+  }
+  async function headMatches(handle) {
+    if (state.offset === 0) return true;
+    return await headFingerprintAt(handle, state.offset) === state.headFingerprint;
+  }
+  async function consumeUpTo(handle, size) {
+    const chunk = await readAt(handle, state.offset, size - state.offset);
+    const completeLength = chunk.lastIndexOf(NEWLINE) + 1;
+    if (completeLength > 0) {
+      const parsed = parseJsonLines(chunk.subarray(0, completeLength).toString("utf8"), schema);
+      const offset = state.offset + completeLength;
+      state = { offset, headFingerprint: await headFingerprintAt(handle, offset), values: [...state.values, ...parsed.values], invalidLines: state.invalidLines + parsed.invalidLines };
+    }
+    const pending = chunk.subarray(completeLength);
+    return { ...parseJsonLines(pending.toString("utf8"), schema), bytes: pending.length };
+  }
+  return { read };
+}
+function emptyState() {
+  return { offset: 0, headFingerprint: EMPTY_FINGERPRINT, values: [], invalidLines: 0 };
+}
+function nothingPending() {
+  return { values: [], invalidLines: 0, bytes: 0 };
+}
+async function headFingerprintAt(handle, offset) {
+  const length = Math.min(offset, HEAD_FINGERPRINT_BYTES);
+  if (length === 0) return EMPTY_FINGERPRINT;
+  return createHash5("sha1").update(await readAt(handle, 0, length)).digest("hex");
+}
+
+// src/server/stats-sources.ts
+var ALL_PROJECTS_SLOT = "*";
+function createStatsSources(root, computeCost) {
+  const tails = /* @__PURE__ */ new Map();
+  const bases = /* @__PURE__ */ new Map();
+  const runsTail = createJsonlTail(join24(root, RUNS_FILE), cliRunSchema);
+  const costMemos = /* @__PURE__ */ new Map();
+  const snapshotIds = /* @__PURE__ */ new WeakMap();
+  let lastSnapshotId = 0;
+  const snapshotIdOf = (snapshot) => {
+    const known = snapshotIds.get(snapshot);
+    if (known !== void 0) return known;
+    lastSnapshotId += 1;
+    snapshotIds.set(snapshot, lastSnapshotId);
+    return lastSnapshotId;
+  };
+  const tailOf = (projectId) => {
+    const known = tails.get(projectId);
+    if (known !== void 0) return known;
+    const created = createJsonlTail(join24(root, projectId, JOURNAL_FILE), journalEventSchema);
+    tails.set(projectId, created);
+    return created;
+  };
+  const readTailed = async (projectId) => {
+    const { length, generation, ...lines } = await tailOf(projectId).read();
+    return { journal: projectJournal(projectId, lines), position: `${projectId}=${generation}:${length}` };
+  };
+  const rememberedBase = (snapshot, tailed) => (slot, input) => {
+    const slotKey = `${slot}|${input.projectId ?? "*"}`;
+    const positions = tailed.filter(({ journal }) => input.projectId === void 0 || journal.projectId === input.projectId).map(({ position }) => position);
+    const key = `${snapshotIdOf(snapshot)}|${slotKey}|${positions.join(",")}`;
+    const remembered2 = bases.get(slotKey);
+    if (remembered2?.key === key) return remembered2.base;
+    const base = reportBase(input);
+    bases.set(slotKey, { projectId: input.projectId, key, base });
+    return base;
+  };
+  return {
+    read: async (snapshot, projectIds) => {
+      const tailed = await Promise.all(projectIds.map(readTailed));
+      return { journals: tailed.map(({ journal }) => journal), baseOf: rememberedBase(snapshot, tailed) };
+    },
+    retain: (projectIds) => {
+      const kept = new Set(projectIds);
+      pruneUnlessKept(tails, kept, (projectId) => projectId);
+      pruneUnlessKept(bases, kept, (_, { projectId }) => projectId);
+      pruneUnlessKept(costMemos, kept, (slot) => slot === ALL_PROJECTS_SLOT ? void 0 : slot);
+    },
+    costReport: async (request) => {
+      const { values: runs, length, generation } = await runsTail.read();
+      const inputs = { ...request, runs };
+      const slot = inputs.scope.projectId ?? ALL_PROJECTS_SLOT;
+      const keyParts = {
+        usage: `${inputs.usage.revision}`,
+        runs: `${generation}:${length}`,
+        scope: `${snapshotIdOf(inputs.scope.snapshot)}/${slot}`,
+        now: formatLocalDay(inputs.now)
+      };
+      const key = Object.values(keyParts).join("|");
+      const remembered2 = costMemos.get(slot);
+      if (remembered2?.key === key) return remembered2.report;
+      const report = computeCost(inputs);
+      costMemos.set(slot, { key, report });
+      report.catch(() => {
+        if (costMemos.get(slot)?.report === report) costMemos.delete(slot);
+      });
+      return report;
+    }
+  };
+}
+function pruneUnlessKept(map, kept, projectIdOf) {
+  for (const [key, value] of map) {
+    const projectId = projectIdOf(key, value);
+    if (projectId !== void 0 && !kept.has(projectId)) map.delete(key);
+  }
+}
+
 // src/server/stats-api.ts
 var REPORT_TTL_MS = 5 * 60 * 1e3;
-function createStatsApi({ root, readLanguage: readLanguage2, now, home: home2, usage, memory, warn: warn2, backlog }) {
+var ALL_PROJECTS_TAG = "project:*";
+var WHOLE_BACKLOG_TAG = "whole-backlog";
+var projectTag = (projectId) => `project:${projectId}`;
+function createStatsApi({ root, readLanguage: readLanguage2, now, home: home2, usage, memory, warn: warn2, backlog, graphHealth: graphHealth2 }) {
   const routes = new Hono();
   const reports = createReportCache({ ttlMs: REPORT_TTL_MS, now: () => now().getTime() });
   const onCodeSourceError = (kind, error) => void readLanguage2().then((language) => {
@@ -6246,68 +6522,95 @@ function createStatsApi({ root, readLanguage: readLanguage2, now, home: home2, u
   });
   const codeSource = createCodeSource({ home: home2, store: createCodeCacheFile(root), onError: onCodeSourceError });
   const lookupRepoRoot = cachedRepoRoots();
+  const sources = createStatsSources(root, (inputs) => costOf2(inputs, home2, lookupRepoRoot));
+  let knownProjectIds = [];
+  let forgetCount = 0;
   const statsScopeOf = async (c, { wholeBacklog }) => {
     const projectId = c.req.query("project") || void 0;
-    const { projects, tasks, errors } = await backlog();
+    const snapshot = await backlog();
+    const { projects, tasks, errors } = snapshot;
+    knownProjectIds = projects.map((project) => project.id);
+    sources.retain(knownProjectIds);
+    codeSource.retain(projects);
     if (projectId !== void 0 && !projects.some((project) => project.id === projectId)) {
       return c.json({ errors: [serverMessages(await readLanguage2()).projectNotFound(projectId)] }, 404);
     }
-    const included = (project) => project.id === projectId || (projectId === void 0 || wholeBacklog) && project.active;
-    const scoped = projects.filter(included);
+    const scoped = projectsInScope(projects, projectId, { wholeBacklog });
     const scopedIds = new Set(scoped.map((project) => project.id));
     const inScope = (task) => scopedIds.has(task.projectId);
-    return { projectId, projects: scoped, tasks: tasks.filter(inScope), unparsedTasks: unparsedTasks(errors).filter(inScope) };
+    return { projectId, projects: scoped, tasks: tasks.filter(inScope), unparsedTasks: unparsedTasks(errors).filter(inScope), snapshot };
   };
   const scopedStats = (name, report, { sourceKey, wholeBacklog = false } = {}) => async (c) => {
+    const forgetCountAtRead = forgetCount;
     const scope = await statsScopeOf(c, { wholeBacklog });
     if (scope instanceof Response) return scope;
     const moment = now();
     const key = [name, scope.projectId ?? "*", formatLocalDay(moment), sourceKey === void 0 ? "" : await sourceKey(scope.projects)].join("|");
-    const result = await reports.get(key, async () => {
-      const journals = await readJournals(root, scope.projects.map((project) => project.id));
+    const tags = wholeBacklog ? [WHOLE_BACKLOG_TAG] : [scope.projectId === void 0 ? ALL_PROJECTS_TAG : projectTag(scope.projectId)];
+    const compute = async () => {
+      const { journals, baseOf } = await sources.read(scope.snapshot, scope.projects.map((project) => project.id));
       const input = { tasks: scope.tasks, journals, now: moment, projectId: scope.projectId, unparsedTasks: scope.unparsedTasks };
-      return report(input, reportBase(input), scope.projects);
-    });
-    return c.json(result);
+      const wholeBacklogBase = () => baseOf("backlog", { ...input, projectId: void 0 });
+      return report({ input, base: baseOf("scoped", input), projects: scope.projects, snapshot: scope.snapshot, wholeBacklogBase });
+    };
+    const scopeOutdated = forgetCount !== forgetCountAtRead;
+    return c.json(await (scopeOutdated ? compute() : reports.get(key, compute, tags)));
   };
-  const statsOfCode = async (input, base, projects) => codeReport({ ...input, code: await codeSource.collect(projects, input.now) }, base);
-  const statsOfEffect = async (input, base, projects) => {
-    const backlogBase = input.projectId === void 0 ? base : reportBase({ ...input, projectId: void 0 });
+  const statsOfCode = async ({ input, base, projects }) => codeReport({ ...input, code: await codeSource.collect(projects, input.now) }, base);
+  const statsOfEffect = async ({ input, base, projects, wholeBacklogBase }) => {
+    const backlogBase = input.projectId === void 0 ? base : wholeBacklogBase();
     const scoped = projects.filter((project) => input.projectId === void 0 || project.id === input.projectId);
     const code = await codeSource.collect(scoped, input.now);
     const fixCommits = await codeSource.fixCommits(projects, codeFixRequests({ ...input, projectId: void 0 }, backlogBase), input.now);
     return effectReport({ ...input, code: { ...code, fixCommits } }, base, backlogBase);
   };
-  const statsOfQuality = async (input, base, projects) => qualityReport(input, base, await projectGraphs(projects, input.tasks, home2));
-  const statsOfCost = async (projectId, projects) => {
-    usage.ensureStarted();
-    const { cache, scan } = usage.snapshot();
-    const buckets = bucketsOf2(cache);
-    const runs = await readRuns(root);
-    const repoRoots = projectId === void 0 ? /* @__PURE__ */ new Map() : await resolveRepoRoots(lookupRepoRoot, [...buckets, ...runs].map((entry) => entry.cwd));
-    const projectOf2 = (cwd) => {
-      const roots = repoRoots.get(cwd) ?? null;
-      return roots === null ? null : findProjectForRoots(projects, roots, home2)?.id ?? null;
-    };
-    return costReport({ buckets, runs, projectOf: projectOf2, projectId, now: now(), scan });
+  const statsOfQuality = async ({ input, base, projects, snapshot }) => {
+    const graphs = await Promise.all(projects.map(async (project) => ({ projectId: project.id, name: project.name, ...await graphHealth2(snapshot, project) })));
+    return qualityReport(input, base, graphs);
   };
   const codeState = { sourceKey: (projects) => codeSource.stateKey(projects) };
-  routes.get("/stats", scopedStats("stats", (input, base) => statsReport(input, base)));
+  routes.get("/stats", scopedStats("stats", ({ input, base }) => statsReport(input, base)));
   routes.get("/stats/code", scopedStats("code", statsOfCode, codeState));
   routes.get("/stats/effect", scopedStats("effect", statsOfEffect, { ...codeState, wholeBacklog: true }));
   routes.get("/stats/quality", scopedStats("quality", statsOfQuality));
-  routes.get("/stats/signals", scopedStats("signals", (input, base) => ({ signals: statsSignals(input, base) })));
+  routes.get("/stats/signals", scopedStats("signals", ({ input, base }) => ({ signals: statsSignals(input, base) })));
   routes.get("/stats/cost", async (c) => {
     const scope = await statsScopeOf(c, { wholeBacklog: true });
-    return scope instanceof Response ? scope : c.json(await statsOfCost(scope.projectId, scope.projects));
+    if (scope instanceof Response) return scope;
+    usage.ensureStarted();
+    const { snapshot, projectId } = scope;
+    return c.json(await sources.costReport({ usage: usage.snapshot(), scope: { snapshot, projectId }, now: now() }));
   });
   routes.get("/stats/memory", (c) => c.json({ samples: memory.samples() }));
-  return { routes, forget: () => reports.clear() };
-}
-async function projectGraphs(projects, tasks, home2) {
-  return Promise.all(
-    projects.map(async (project) => ({ projectId: project.id, name: project.name, ...await projectGraphHealth(project, tasks, home2) }))
-  );
+  const projectIdOfPath = (path) => {
+    const [first] = relative3(root, path).split(sep4);
+    return knownProjectIds.find((id) => id === first);
+  };
+  const forget = (paths) => {
+    forgetCount += 1;
+    if (paths === void 0 || paths.length === 0) return void reports.clear();
+    const changedProjectIds = /* @__PURE__ */ new Set();
+    for (const path of paths) {
+      const projectId = projectIdOfPath(path);
+      if (projectId === void 0) return void reports.clear();
+      changedProjectIds.add(projectId);
+    }
+    reports.clearTagged([ALL_PROJECTS_TAG, WHOLE_BACKLOG_TAG, ...[...changedProjectIds].map(projectTag)]);
+  };
+  return { routes, forget };
+}
+function projectsInScope(projects, projectId, { wholeBacklog }) {
+  return projects.filter((project) => project.id === projectId || (projectId === void 0 || wholeBacklog) && project.active);
+}
+async function costOf2({ usage: { cache, scan }, runs, scope: { snapshot, projectId }, now }, home2, lookupRepoRoot) {
+  const projects = projectsInScope(snapshot.projects, projectId, { wholeBacklog: true });
+  const buckets = bucketsOf2(cache);
+  const repoRoots = projectId === void 0 ? /* @__PURE__ */ new Map() : await resolveRepoRoots(lookupRepoRoot, [...buckets, ...runs].map((entry) => entry.cwd));
+  const projectOf2 = (cwd) => {
+    const roots = repoRoots.get(cwd) ?? null;
+    return roots === null ? null : findProjectForRoots(projects, roots, home2)?.id ?? null;
+  };
+  return costReport({ buckets, runs, projectOf: projectOf2, projectId, now, scan });
 }
 function bucketsOf2(cache) {
   return Object.values(cache.files).flatMap((entry) => entry.buckets);
@@ -6330,30 +6633,35 @@ function createApi({ root, readLanguage: readLanguage2, changes, now, home: home
     });
     return snapshot;
   };
-  const stats = createStatsApi({ root, readLanguage: readLanguage2, now, home: home2, usage, memory, warn: warn2, backlog });
-  const graphStates = createReportCache({ ttlMs: GRAPH_STATE_TTL_MS, now: () => now().getTime() });
-  const forgetBacklog = () => {
+  const graphHealthsBySnapshot = /* @__PURE__ */ new WeakMap();
+  const graphHealth2 = (backlogSnapshot, project) => {
+    let healths = graphHealthsBySnapshot.get(backlogSnapshot);
+    if (healths === void 0) {
+      healths = createReportCache({ ttlMs: GRAPH_STATE_TTL_MS, now: () => now().getTime() });
+      graphHealthsBySnapshot.set(backlogSnapshot, healths);
+    }
+    return healths.get(project.id, () => projectGraphHealth(project, backlogSnapshot.tasks, home2));
+  };
+  const stats = createStatsApi({ root, readLanguage: readLanguage2, now, home: home2, usage, memory, warn: warn2, backlog, graphHealth: graphHealth2 });
+  const forgetBacklog = (paths) => {
     snapshot = null;
-    stats.forget();
-    graphStates.clear();
+    stats.forget(paths);
   };
   const recordOwnWrites = async (writes) => {
     if (writes.length > 0) await revisions.recordOwnWrites(writes);
-    forgetBacklog();
+    forgetBacklog(writes.length > 0 ? writes.map((write) => write.path) : void 0);
   };
   const streams = /* @__PURE__ */ new Set();
   changes.subscribe(async (paths) => {
-    if (await revisions.settle(paths) === "foreign") forgetBacklog();
-    else stats.forget();
+    if (await revisions.settle(paths) === "foreign") forgetBacklog(paths);
+    else stats.forget(paths);
     const revision = revisions.current();
     for (const send of streams) send(revision);
   });
   api.get("/projects", async (c) => {
-    const { projects, tasks, revision } = await backlog();
-    const withGraph = async (project) => {
-      const codeGraph2 = await graphStates.get(project.id, async () => (await projectGraphHealth(project, tasks, home2)).state);
-      return { ...project, codeGraph: codeGraph2 };
-    };
+    const loaded = await backlog();
+    const { projects, revision } = loaded;
+    const withGraph = async (project) => ({ ...project, codeGraph: (await graphHealth2(loaded, project)).state });
     return c.json({ projects: await Promise.all(projects.map(withGraph)), revision });
   });
   api.get("/tasks", async (c) => {
@@ -6507,13 +6815,13 @@ function createApp({ root, readLanguage: readLanguage2, changes, allowedHosts, h
   });
   if (staticDir !== void 0) {
     app.use("*", serveStatic({ root: staticDir }));
-    app.get("*", serveStatic({ path: join24(staticDir, "index.html") }));
+    app.get("*", serveStatic({ path: join25(staticDir, "index.html") }));
   }
   return app;
 }
 
 // src/server/change-feed.ts
-import { relative as relative3, sep as sep4 } from "node:path";
+import { relative as relative4, sep as sep5 } from "node:path";
 import { watch } from "chokidar";
 var CHANGE_DEBOUNCE_MS = 100;
 function createDebouncer(delayMs, run) {
@@ -6527,7 +6835,7 @@ function createDebouncer(delayMs, run) {
   };
 }
 function isHiddenPath(root, path) {
-  return relative3(root, path).split(sep4).some((segment) => segment.startsWith("."));
+  return relative4(root, path).split(sep5).some((segment) => segment.startsWith("."));
 }
 function createChangeFeed({ root, debounceMs, messages, warn: warn2 }) {
   const listeners = /* @__PURE__ */ new Set();
@@ -6618,10 +6926,13 @@ function logReport({ closedEpics, reopenedEpics, blockingFiles, deleted, conflic
   }
 }
 
+// src/server/usage-scanner.ts
+import { isDeepStrictEqual } from "node:util";
+
 // src/core/usage/transcripts.ts
-import { createHash as createHash5 } from "node:crypto";
-import { open as open2, stat as stat6 } from "node:fs/promises";
-import { basename as basename10, join as join26 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { stat as stat6 } from "node:fs/promises";
+import { basename as basename10, join as join27 } from "node:path";
 
 // src/core/stats/cost/attribute.ts
 import { z as z18 } from "zod";
@@ -6955,7 +7266,7 @@ function slotOf(timestamp) {
 
 // src/core/usage/usage-cache.ts
 import { mkdir as mkdir5 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 import { z as z19 } from "zod";
 var USAGE_CACHE_FILE = ".usage-cache.json";
 var USAGE_CACHE_VERSION = 6;
@@ -6975,33 +7286,32 @@ function emptyUsageCache() {
   return { version: USAGE_CACHE_VERSION, files: {} };
 }
 async function readUsageCache(root) {
-  return await readJsonFile(join25(root, USAGE_CACHE_FILE), usageCacheSchema) ?? emptyUsageCache();
+  return await readJsonFile(join26(root, USAGE_CACHE_FILE), usageCacheSchema) ?? emptyUsageCache();
 }
 async function writeUsageCache(root, cache) {
   await mkdir5(root, { recursive: true });
-  await writeFileAtomic(join25(root, USAGE_CACHE_FILE), JSON.stringify(cache));
+  await writeFileAtomic(join26(root, USAGE_CACHE_FILE), JSON.stringify(cache));
 }
 
 // src/core/usage/transcripts.ts
-var NEWLINE = 10;
 var FINGERPRINT_BYTES = 256;
 var ABANDONED_LINE_MS = 10 * 60 * 1e3;
-var EMPTY_FINGERPRINT = createHash5("sha1").digest("hex");
+var EMPTY_FINGERPRINT2 = createHash6("sha1").digest("hex");
 var COUNTED_LINE_MARKERS = ['"type":"assistant"', '"type":"user"'];
 async function listTranscripts(claudeProjectsDir2) {
   const files = [];
   for (const projectEntry of await listDir(claudeProjectsDir2)) {
     if (!projectEntry.isDirectory()) continue;
-    const projectDir2 = join26(claudeProjectsDir2, projectEntry.name);
+    const projectDir2 = join27(claudeProjectsDir2, projectEntry.name);
     for (const entry of await listDir(projectDir2)) {
-      const entryPath = join26(projectDir2, entry.name);
+      const entryPath = join27(projectDir2, entry.name);
       if (entry.isFile() && entry.name.endsWith(".jsonl")) {
         files.push(...await listedFile(entryPath));
         continue;
       }
       if (!entry.isDirectory()) continue;
-      for (const subagentEntry of await listDir(join26(entryPath, "subagents"), { recursive: true })) {
-        if (subagentEntry.isFile() && subagentEntry.name.endsWith(".jsonl")) files.push(...await listedFile(join26(subagentEntry.parentPath, subagentEntry.name)));
+      for (const subagentEntry of await listDir(join27(entryPath, "subagents"), { recursive: true })) {
+        if (subagentEntry.isFile() && subagentEntry.name.endsWith(".jsonl")) files.push(...await listedFile(join27(subagentEntry.parentPath, subagentEntry.name)));
       }
     }
   }
@@ -7045,7 +7355,7 @@ function deletedStillReported(cache, listedFiles, now) {
 }
 async function scanChunk(file, start, chunkSize, { longestReadableLine, now }) {
   if (chunkSize <= 0) return { size: file.size, offset: start.offset, state: start.state, buckets: start.buckets };
-  const chunk = await readChunk(file.path, start.offset, chunkSize);
+  const chunk = await readFileAt(file.path, start.offset, chunkSize);
   const tailAbandoned = start.offset + chunk.length === file.size && now.getTime() - file.mtimeMs >= ABANDONED_LINE_MS;
   const readableLength = tailAbandoned ? chunk.length : chunk.lastIndexOf(NEWLINE) + 1;
   if (readableLength === 0) {
@@ -7069,30 +7379,14 @@ async function continues(file, previous) {
   return await fingerprintOf(file.path, previous.offset) === previous.fingerprint;
 }
 async function fingerprintOf(path, offset) {
-  if (offset === 0) return EMPTY_FINGERPRINT;
+  if (offset === 0) return EMPTY_FINGERPRINT2;
   const edge = Math.min(FINGERPRINT_BYTES, offset);
   return withFile(path, async (handle) => {
     const head = await readAt(handle, 0, edge);
     const tail = await readAt(handle, offset - edge, edge);
-    return createHash5("sha1").update(head).update(tail).digest("hex");
+    return createHash6("sha1").update(head).update(tail).digest("hex");
   });
 }
-function readChunk(path, position, length) {
-  return withFile(path, (handle) => readAt(handle, position, length));
-}
-async function withFile(path, use) {
-  const handle = await open2(path, "r");
-  try {
-    return await use(handle);
-  } finally {
-    await handle.close();
-  }
-}
-async function readAt(handle, position, length) {
-  const buffer = Buffer.alloc(length);
-  const { bytesRead } = await handle.read(buffer, 0, length, position);
-  return buffer.subarray(0, bytesRead);
-}
 function parseLineOrNull(line) {
   try {
     return JSON.parse(line);
@@ -7131,17 +7425,24 @@ function createUsageScanner({
 }) {
   let cache = null;
   let scan = NOT_LISTED;
+  let revision = 0;
   let inFlight = null;
   let timer = null;
   let running = false;
   let budgetExhausted = false;
+  const setScan = (next) => {
+    if (!scanEquals(scan, next)) revision += 1;
+    scan = next;
+  };
   const runPass = async () => {
+    const published = cache ?? emptyUsageCache();
     const current = cache ?? await readUsageCache(root);
     const files = await listTranscripts(claudeProjectsDir2);
-    scan = progressBefore(files, current);
+    setScan(progressBefore(files, current));
     const result = await scanTranscripts({ files, cache: current, byteBudget, now: now() });
+    if (cacheChanged(published, result.cache)) revision += 1;
     cache = result.cache;
-    scan = { listed: true, filesTotal: files.length, filesDone: result.filesDone, bytesLeft: result.bytesLeft };
+    setScan({ listed: true, filesTotal: files.length, filesDone: result.filesDone, bytesLeft: result.bytesLeft });
     budgetExhausted = result.bytesRead >= byteBudget;
     if (result.bytesRead > 0) await writeUsageCache(root, result.cache);
   };
@@ -7173,9 +7474,21 @@ function createUsageScanner({
     ensureStarted: () => {
       if (!scan.listed && inFlight === null) void scanOnce();
     },
-    snapshot: () => ({ cache: cache ?? emptyUsageCache(), scan })
+    snapshot: () => ({ cache: cache ?? emptyUsageCache(), scan, revision })
   };
 }
+function scanEquals(a, b) {
+  return a.listed === b.listed && a.filesTotal === b.filesTotal && a.filesDone === b.filesDone && a.bytesLeft === b.bytesLeft;
+}
+function cacheChanged(previous, next) {
+  const previousPaths = Object.keys(previous.files);
+  if (previousPaths.length !== Object.keys(next.files).length) return true;
+  return previousPaths.some((path) => entryChanged(previous.files[path], next.files[path]));
+}
+function entryChanged(previous, next) {
+  if (previous === void 0 || next === void 0) return previous !== next;
+  return previous.size !== next.size || previous.offset !== next.offset || previous.fingerprint !== next.fingerprint || !isDeepStrictEqual(previous.buckets, next.buckets);
+}
 function progressBefore(files, cache) {
   const offsetOf = (file) => {
     const cached = cache.files[file.path];
@@ -7192,7 +7505,7 @@ function progressBefore(files, cache) {
 // src/server/start.ts
 var SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
 var STOP_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
-var BUNDLED_WEB_DIR = join27(import.meta.dirname, "web");
+var BUNDLED_WEB_DIR = join28(import.meta.dirname, "web");
 var log = (line) => void process.stdout.write(`${line}
 `);
 var warn = (line) => void process.stderr.write(`${line}
@@ -7293,7 +7606,7 @@ async function runServe(args, io) {
 
 // src/cli/service/launchd.ts
 import { mkdir as mkdir7, rm as rm5, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname8, join as join28, posix } from "node:path";
+import { dirname as dirname8, join as join29, posix } from "node:path";
 import { setTimeout as sleep3 } from "node:timers/promises";
 
 // src/cli/service/service.ts
@@ -7366,7 +7679,7 @@ ${entries}
 `;
 }
 function launchdManager(context, delay = sleep3) {
-  const file = join28(context.home, "Library/LaunchAgents", `${LABEL}.plist`);
+  const file = join29(context.home, "Library/LaunchAgents", `${LABEL}.plist`);
   const domain = `gui/${context.uid}`;
   const bootout = () => context.exec("launchctl", ["bootout", `${domain}/${LABEL}`]);
   const bootstrap = () => context.exec("launchctl", ["bootstrap", domain, file]);
@@ -7401,7 +7714,7 @@ function launchdManager(context, delay = sleep3) {
 
 // src/cli/service/startup-folder.ts
 import { mkdir as mkdir8, rm as rm6, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname9, join as join29, win32 } from "node:path";
+import { dirname as dirname9, join as join30, win32 } from "node:path";
 var SCRIPT_NAME = "p-backlog.vbs";
 var COMMAND_LINE_ARGUMENT = /"[^"]*"|\S+/g;
 var PROCESS_QUERY_TIMEOUT_MS = 15e3;
@@ -7409,16 +7722,16 @@ function vbsString(value) {
   return `"${value.replaceAll('"', '""')}"`;
 }
 function appDataDir(context) {
-  return join29(context.env.LOCALAPPDATA ?? join29(context.home, "AppData", "Local"), "p-backlog");
+  return join30(context.env.LOCALAPPDATA ?? join30(context.home, "AppData", "Local"), "p-backlog");
 }
 function startupFolder(context) {
-  return join29(context.env.APPDATA ?? join29(context.home, "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+  return join30(context.env.APPDATA ?? join30(context.home, "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
 }
 function logPath2(context) {
-  return join29(appDataDir(context), "p-backlog.log");
+  return join30(appDataDir(context), "p-backlog.log");
 }
 function pidFilePath(context) {
-  return join29(appDataDir(context), "server.pid");
+  return join30(appDataDir(context), "server.pid");
 }
 var NODE_PATH_ENV = "P_BACKLOG_NODE";
 var CLI_PATH_ENV = "P_BACKLOG_CLI";
@@ -7469,7 +7782,7 @@ function sameWindowsPath(left, right) {
   return win32.normalize(left).toLowerCase() === win32.normalize(right).toLowerCase();
 }
 function startupFolderManager(context) {
-  const file = join29(startupFolder(context), SCRIPT_NAME);
+  const file = join30(startupFolder(context), SCRIPT_NAME);
   return {
     file,
     logs: logPath2(context),
@@ -7496,7 +7809,7 @@ function startupFolderManager(context) {
 
 // src/cli/service/systemd.ts
 import { mkdir as mkdir9, rm as rm7, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname10, join as join30 } from "node:path";
+import { dirname as dirname10, join as join31 } from "node:path";
 var UNIT = "p-backlog.service";
 function quoted(value) {
   return `"${value.replace(/[\\"]/g, "\\$&").replaceAll("%", "%%")}"`;
@@ -7530,7 +7843,7 @@ async function systemctlSteps(exec, steps) {
   return "done";
 }
 function systemdManager(context) {
-  const file = join30(context.home, ".config/systemd/user", UNIT);
+  const file = join31(context.home, ".config/systemd/user", UNIT);
   return {
     file,
     logs: "journalctl --user -u p-backlog",
@@ -7648,10 +7961,10 @@ function reportFailure({ failed, code, output }, io) {
 }
 
 // src/cli/commands/setup.ts
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 
 // src/cli/agents/agent-hooks.ts
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 
 // src/cli/agents/grouped-stop-hooks.ts
 import { z as z20 } from "zod";
@@ -7799,7 +8112,7 @@ async function removeCursorStopHook(path, isOurs) {
 var CODEX_HOOK_TIMEOUT_SECONDS = 30;
 var AGENT_HOOKS_FILE = "hooks.json";
 function agentHookConfigPath(agent, places) {
-  return agent === "claude" ? claudeSettingsPath(places.env, places.home) : join31(agentHomeDir(agent, places), AGENT_HOOKS_FILE);
+  return agent === "claude" ? claudeSettingsPath(places.env, places.home) : join32(agentHomeDir(agent, places), AGENT_HOOKS_FILE);
 }
 function installAgentHook(agent, site) {
   const path = agentHookConfigPath(agent, site);
@@ -7895,7 +8208,7 @@ async function setUpAgent(agent, io) {
 async function linkAgentSkill(agent, io, voice) {
   const messages = cliMessages(io.language);
   const skillsDir = agentSkillsDir(agent, io);
-  const target = join32(skillsDir, "backlog");
+  const target = join33(skillsDir, "backlog");
   const source = skillSourceDir(io.packageRoot, io.language);
   let link2;
   try {
@@ -7914,7 +8227,7 @@ async function linkAgentSkill(agent, io, voice) {
 }
 async function removeLegacySkillLinks(agent, io, voice) {
   for (const legacyDir of legacySkillsDirs(agent, io)) {
-    if (await unlinkOurSkill(legacyDir) === "removed") voice.print(cliMessages(io.language).manualSkillRemoval.removed(join32(legacyDir, "backlog")));
+    if (await unlinkOurSkill(legacyDir) === "removed") voice.print(cliMessages(io.language).manualSkillRemoval.removed(join33(legacyDir, "backlog")));
   }
 }
 function reportHook(result, configPath, io, voice) {
@@ -7935,7 +8248,7 @@ async function removeManualSetup(agent, removing, io) {
   const voice = agentVoice(agent, io);
   const messages = cliMessages(io.language);
   const skillsDir = agentSkillsDir(agent, io);
-  const target = join32(skillsDir, "backlog");
+  const target = join33(skillsDir, "backlog");
   const sharer = await remainingSkillDirUser(agent, removing, io);
   voice.print(sharer === null ? messages.manualSkillRemoval[await unlinkOurSkill(skillsDir)](target) : messages.manualSkillShared(target, AGENT_LABELS[sharer]));
   await removeLegacySkillLinks(agent, io, voice);
@@ -7990,7 +8303,7 @@ function backlogAgeWeeks(histories, now) {
   return firstCreated === null ? null : (now.getTime() - firstCreated) / WEEK_MS;
 }
 var clampedWeeks = (weeks) => Math.min(FORECAST_WINDOW_WEEKS, Math.max(MIN_WINDOW_WEEKS, weeks));
-function flowForecast(histories, open3, now) {
+function flowForecast(histories, open2, now) {
   const ageWeeks = backlogAgeWeeks(histories, now);
   const windowWeeks = ageWeeks === null ? FORECAST_WINDOW_WEEKS : clampedWeeks(Math.floor(ageWeeks) + 1);
   const observedWeeks = ageWeeks === null ? FORECAST_WINDOW_WEEKS : clampedWeeks(ageWeeks);
@@ -7999,9 +8312,9 @@ function flowForecast(histories, open3, now) {
   const closed = histories.flatMap(closingsOf).filter((closing) => inWindow(closing.at)).length;
   const created = histories.filter((history) => inWindow(history.createdAt)).length;
   const weeklyNet = (closed - created) / observedWeeks;
-  const weeks = open3 > 0 && weeklyNet > 0 ? Math.ceil(open3 / weeklyNet) : null;
+  const weeks = open2 > 0 && weeklyNet > 0 ? Math.ceil(open2 / weeklyNet) : null;
   const windowDays = Math.round(observedWeeks * DAYS_PER_WEEK);
-  return { closed, created, open: open3, weeklyNet, weeks, until: weeks === null ? null : formatLocalIso(weeksLater(now, weeks)), windowDays };
+  return { closed, created, open: open2, weeklyNet, weeks, until: weeks === null ? null : formatLocalIso(weeksLater(now, weeks)), windowDays };
 }
 function weeksLater(now, weeks) {
   return new Date(now.getFullYear(), now.getMonth(), now.getDate() + DAYS_PER_WEEK * weeks, now.getHours(), now.getMinutes(), now.getSeconds());
@@ -8086,7 +8399,7 @@ var statusCommand = taskFieldCommand({
 
 // src/cli/commands/take.ts
 import { realpathSync as realpathSync3 } from "node:fs";
-import { relative as relative4, resolve as resolve5, sep as sep5 } from "node:path";
+import { relative as relative5, resolve as resolve5, sep as sep6 } from "node:path";
 var takeCommand = {
   name: "take",
   usage: (language) => cliMessages(language).takeUsage(),
@@ -8161,7 +8474,7 @@ function isInside(file, path) {
 function repoRelativePath(io, project, path) {
   const roots = findGitRoots(io.cwd);
   if (roots === null || findProjectForDir([project], io.cwd, io.home) === void 0) return sourcePath(path);
-  const fromRoot = relative4(roots.worktree, resolve5(realpathSync3(io.cwd), sourcePath(path))).split(sep5).join("/");
+  const fromRoot = relative5(roots.worktree, resolve5(realpathSync3(io.cwd), sourcePath(path))).split(sep6).join("/");
   const outsideRepo = fromRoot === ".." || fromRoot.startsWith("../");
   return outsideRepo ? sourcePath(path) : fromRoot;
 }