p-backlog 0.2.0

package/dist/server.js

@@ -0,0 +1,3887 @@
+#!/usr/bin/env node
+
+// src/core/errors.ts
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/server/main.ts
+import { homedir } from "node:os";
+
+// src/core/store/paths.ts
+import { basename, join } from "node:path";
+var PROJECT_FILE = "project.md";
+function expandHome(path, home2) {
+  if (path === "~") return home2;
+  return path.startsWith("~/") ? join(home2, path.slice(2)) : path;
+}
+function resolveBacklogRoot(env, home2) {
+  const configured = env.BACKLOG_DIR;
+  return configured ? expandHome(configured, home2) : join(home2, "backlog");
+}
+function projectDir(root, id) {
+  const isPlainName = id !== "" && id !== "." && id !== ".." && basename(id) === id && !id.includes("\\");
+  return isPlainName ? join(root, id) : null;
+}
+
+// src/core/sqlite-warning.ts
+function suppressSqliteExperimentalWarning() {
+  const previousListeners = [...process.listeners("warning")];
+  process.removeAllListeners("warning");
+  process.on("warning", (warning) => {
+    if (isSqliteExperimentalWarning(warning)) return;
+    for (const listener of previousListeners) listener.call(process, warning);
+  });
+}
+function isSqliteExperimentalWarning(warning) {
+  return warning.name === "ExperimentalWarning" && warning.message.includes("SQLite");
+}
+
+// src/server/messages.ru.ts
+var serverRu = {
+  taskNotFound: (id) => `\u0417\u0430\u0434\u0430\u0447\u0430 ${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430`,
+  taskChangedOnDisk: "\u0417\u0430\u0434\u0430\u0447\u0430 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u0430\u0441\u044C \u043D\u0430 \u0434\u0438\u0441\u043A\u0435",
+  projectNotFound: (id) => `\u041F\u0440\u043E\u0435\u043A\u0442 ${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D`,
+  confirmMismatch: "\u041F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u0435 \u043D\u0435 \u0441\u043E\u0432\u043F\u0430\u0434\u0430\u0435\u0442 \u0441 id \u043F\u0440\u043E\u0435\u043A\u0442\u0430",
+  bodyNotParsed: "\u0422\u0435\u043B\u043E \u0437\u0430\u043F\u0440\u043E\u0441\u0430 \u043D\u0435 \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u043D\u043E: \u043E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F JSON",
+  unknownRoute: (path) => `\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u0430\u0434\u0440\u0435\u0441 API: ${path}`,
+  hostRejected: (host) => `\u0417\u0430\u043F\u0440\u043E\u0441\u044B \u0441 \u0445\u043E\u0441\u0442\u0430 ${host} \u043D\u0435 \u043F\u0440\u0438\u043D\u0438\u043C\u0430\u044E\u0442\u0441\u044F`,
+  jsonContentTypeExpected: "\u041E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F Content-Type: application/json",
+  runsTrimFailed: (detail) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0431\u0440\u0435\u0437\u0430\u0442\u044C \u0436\u0443\u0440\u043D\u0430\u043B \u0437\u0430\u043F\u0443\u0441\u043A\u043E\u0432: ${detail}`,
+  serverStarted: (port, root) => `p-backlog: http://localhost:${port}
+\u041A\u0430\u0442\u0430\u043B\u043E\u0433 \u0431\u0435\u043A\u043B\u043E\u0433\u0430: ${root}
+`,
+  settingsFileInvalid: (path) => `${path} \u043D\u0435 \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u043D, \u044F\u0437\u044B\u043A \u0434\u043B\u044F \u044D\u0442\u043E\u0433\u043E \u0437\u0430\u043F\u0443\u0441\u043A\u0430 \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0451\u043D \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438. \u0424\u0430\u0439\u043B \u043D\u0435 \u0438\u0437\u043C\u0435\u043D\u0451\u043D \u2014 \u043F\u043E\u043F\u0440\u0430\u0432\u044C\u0442\u0435 \u0435\u0433\u043E \u0432\u0440\u0443\u0447\u043D\u0443\u044E.`,
+  sweepFailed: (detail) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0443\u0434\u0430\u043B\u0438\u0442\u044C \u0437\u0430\u043A\u0440\u044B\u0442\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438: ${detail}`,
+  closedEpics: (ids) => `\u0417\u0430\u043A\u0440\u044B\u0442\u044B \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D\u043D\u044B\u0435 \u044D\u043F\u0438\u043A\u0438: ${ids}`,
+  epicsBlockedByFiles: (paths) => `\u042D\u043F\u0438\u043A\u0438 \u043D\u0435 \u0437\u0430\u043A\u0440\u044B\u0432\u0430\u044E\u0442\u0441\u044F, \u043F\u043E\u043A\u0430 \u043D\u0435 \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u043D\u044B \u0444\u0430\u0439\u043B\u044B: ${paths}`,
+  deletedClosedTasks: (ids) => `\u0423\u0434\u0430\u043B\u0435\u043D\u044B \u0437\u0430\u043A\u0440\u044B\u0442\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438: ${ids}`,
+  conflictedDuringSweep: (ids) => `\u0417\u0430\u0434\u0430\u0447\u0438 \u043C\u0435\u043D\u044F\u043B\u0438\u0441\u044C \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u043F\u0440\u043E\u0445\u043E\u0434\u0430, \u043F\u043E\u0432\u0442\u043E\u0440\u044E \u043F\u0440\u0438 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u043C: ${ids}`,
+  invalidAfterSweep: (detail) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u0437\u0430\u0434\u0430\u0447\u0438, \u0438\u0441\u043F\u0440\u0430\u0432\u044C\u0442\u0435 \u0444\u0430\u0439\u043B\u044B: ${detail}`,
+  transcriptsScanFailed: (detail) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u0442\u044C \u0440\u0430\u0441\u0448\u0438\u0444\u0440\u043E\u0432\u043A\u0438 Claude Code: ${detail}`,
+  watcherError: (root, detail) => `\u041D\u0430\u0431\u043B\u044E\u0434\u0430\u0442\u0435\u043B\u044C \u0437\u0430 \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u043E\u043C ${root}: ${detail}`,
+  listenFailed: (reason) => `p-backlog \u043D\u0435 \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u043B\u0441\u044F: ${reason}`,
+  portBusy: (port) => `\u043F\u043E\u0440\u0442 ${port} \u0443\u0436\u0435 \u0437\u0430\u043D\u044F\u0442`,
+  codeCacheReadFailed: (detail) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u0442\u044C \u043A\u044D\u0448 git: ${detail}`,
+  codeCacheWriteFailed: (detail) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u043A\u044D\u0448 git: ${detail}`
+};
+
+// src/server/port.ts
+var DEFAULT_PORT = 4317;
+function readPort(value) {
+  const port = Number(value);
+  return value !== void 0 && Number.isInteger(port) && port > 0 && port < 65536 ? port : DEFAULT_PORT;
+}
+function listenFailure(error, port, messages = serverRu) {
+  const reason = error.code === "EADDRINUSE" ? messages.portBusy(port) : error.message;
+  return messages.listenFailed(reason);
+}
+
+// src/server/start.ts
+import { serve } from "@hono/node-server";
+import { mkdir as mkdir3, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join17 } from "node:path";
+
+// src/core/claude-dir.ts
+import { join as join2 } from "node:path";
+function claudeDir(env, home2) {
+  return env.CLAUDE_CONFIG_DIR || join2(home2, ".claude");
+}
+function claudeProjectsDir(env, home2) {
+  return join2(claudeDir(env, home2), "projects");
+}
+
+// src/core/messages/en.ts
+import { z } from "zod";
+
+// src/core/check/source-lines.ts
+var SOURCE_LINES = /:(\d+)(?:-(\d+))?$/;
+function lineSuffix(source) {
+  return SOURCE_LINES.exec(source)?.[0] ?? "";
+}
+
+// src/core/numbers.ts
+function roundToTenth(value) {
+  return Math.round(value * 10) / 10;
+}
+
+// src/core/i18n/language.ts
+var LANGUAGES = ["ru", "en"];
+function languageFromLocale(locale) {
+  return locale?.toLowerCase().startsWith("ru") ? "ru" : "en";
+}
+function localeOf(language) {
+  return language === "ru" ? "ru-RU" : "en-US";
+}
+
+// src/core/i18n/format.ts
+function formatDayMonth(language, date) {
+  return date.toLocaleDateString(localeOf(language), { day: "2-digit", month: "2-digit" });
+}
+function formatDecimal(language, value) {
+  const rounded = String(roundToTenth(value));
+  return language === "ru" ? rounded.replace(".", ",") : rounded;
+}
+
+// src/core/i18n/plural.ts
+function pluralRu(n, one, few, many) {
+  if (!Number.isInteger(n)) return few;
+  const abs = Math.abs(n);
+  const lastTwo = abs % 100;
+  if (lastTwo >= 11 && lastTwo <= 14) return many;
+  const last = abs % 10;
+  if (last === 1) return one;
+  return last >= 2 && last <= 4 ? few : many;
+}
+function pluralEn(n, one, other) {
+  return n === 1 ? one : other;
+}
+var NBSP = "\xA0";
+function countRu(n, one, few, many) {
+  return `${n.toLocaleString("ru-RU")}${NBSP}${pluralRu(n, one, few, many)}`;
+}
+function countEn(n, one, other) {
+  return `${n.toLocaleString("en-US")}${NBSP}${pluralEn(n, one, other)}`;
+}
+
+// src/core/messages/zod.ts
+var TYPE_WITNESSES = {
+  number: 0,
+  nan: Number.NaN,
+  string: "",
+  boolean: false,
+  bigint: 0n,
+  symbol: /* @__PURE__ */ Symbol(),
+  function: () => void 0,
+  undefined: void 0,
+  null: null,
+  array: [],
+  object: {}
+};
+function zodIssueText(localeError, { issue, receivedType }) {
+  const input = receivedType === void 0 ? void 0 : witnessOf(receivedType);
+  const text = localeError({ ...issue, input });
+  return typeof text === "string" ? text : text?.message ?? issue.message;
+}
+function witnessOf(type) {
+  return type in TYPE_WITNESSES ? TYPE_WITNESSES[type] : /* @__PURE__ */ Object.create({ constructor: { name: type } });
+}
+
+// src/core/messages/en.ts
+var zodEn = z.locales.en().localeError;
+var CATEGORY_LABELS = {
+  bloaters: "Bloaters",
+  "change-preventers": "Change preventers",
+  couplers: "Couplers",
+  "data-dealers": "Data dealers",
+  dispensables: "Dispensables",
+  "functional-abusers": "Functional abusers",
+  "lexical-abusers": "Lexical abusers",
+  "oo-abusers": "OO abusers",
+  obfuscators: "Obfuscators",
+  bug: "Bug"
+};
+var STATUS_LABELS = {
+  backlog: "backlog",
+  "in-progress": "in progress",
+  blocked: "blocked",
+  done: "done",
+  cancelled: "cancelled"
+};
+var PRIORITY_LABELS = { low: "low", medium: "medium", high: "high", critical: "critical" };
+var RESOLUTION_LABELS = { fixed: "fixed", obsolete: "code gone", duplicate: "duplicate", "epic-done": "epic done" };
+var EVIDENCE_LABELS = {
+  "source-changed": "code changed",
+  "source-missing": "file missing",
+  duplicate: "duplicate",
+  "no-source": "no source",
+  total: "Total"
+};
+var CHECK_METHOD_LABELS = { symbol: "by symbol", anchor: "by source lines", file: "by file" };
+var DUPLICATE_MATCH_LABELS = { source: "by code location", title: "by title", symbol: "by symbol" };
+var GRAPH_STATE_LABELS = { none: "none", unreadable: "unreadable", stale: "stale", fresh: "fresh" };
+var COUNT_FORMS = {
+  task: ["task", "tasks"],
+  line: ["line", "lines"],
+  project: ["project", "projects"],
+  day: ["day", "days"],
+  week: ["week", "weeks"],
+  session: ["session", "sessions"]
+};
+function evidenceLabel(evidence) {
+  return EVIDENCE_LABELS[evidence];
+}
+function checkMethodLabel(method) {
+  return CHECK_METHOD_LABELS[method];
+}
+function duplicateMatchLabel(match) {
+  return DUPLICATE_MATCH_LABELS[match];
+}
+function graphStateLabel(state) {
+  return GRAPH_STATE_LABELS[state];
+}
+function count(n, unit) {
+  const [one, other] = COUNT_FORMS[unit];
+  return countEn(n, one, other);
+}
+function days(value) {
+  if (value === null) return "\u2014";
+  if (value < 1) return "less than a day";
+  const rounded = Math.round(value);
+  return `${rounded}${NBSP}${pluralEn(rounded, "day", "days")}`;
+}
+function p90(value) {
+  if (value === null) return "\u2014";
+  return value < 1 ? "within a day" : `within ${days(value)}`;
+}
+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);
+  return `Debt grows by ${growth} ${pluralEn(growth, "task", "tasks")} a week`;
+}
+function forecastTail({ windowWeeks, closed, created }) {
+  return `over ${countEn(windowWeeks, "week", "weeks")}: closed ${closed}, created ${created}`;
+}
+function signal(s) {
+  switch (s.kind) {
+    case "debt-growing":
+      return `Debt has grown for ${countEn(s.params.weeks, "week", "weeks")} straight: created ${s.params.created}, closed ${s.params.closed}`;
+    case "urgent-stale":
+      return `Urgent tasks have been waiting more than ${countEn(s.params.days, "day", "days")}: ${s.params.count}`;
+    case "stuck":
+      return `Stuck in progress: ${s.params.count}, longest ${s.params.id} \u2014 ${days(s.params.days)}`;
+    case "noisy-check": {
+      const { evidence, method, percent, decided, windowDays } = s.params;
+      const name = method === null ? `"${evidenceLabel(evidence)}"` : `"${evidenceLabel(evidence)}" ${checkMethodLabel(method)}`;
+      return `Check ${name} is almost always wrong: precision ${percent}% on ${decided} decided over ${countEn(windowDays, "day", "days")}`;
+    }
+    case "low-changed":
+      return `Code changed for ${countEn(s.params.count, "task", "tasks")} with low priority \u2014 re-check when convenient ("clean up the backlog")`;
+    case "stale-low":
+      return `Tasks with low priority older than ${countEn(s.params.days, "day", "days")}: ${s.params.count} \u2014 clean them up (backlog prune)`;
+  }
+}
+function schemaIssue(issue) {
+  switch (issue.kind) {
+    case "bad-id":
+      return "invalid ID";
+    case "empty-title":
+      return "empty title";
+    case "empty-name":
+      return "empty project name";
+    case "bad-prefix":
+      return "invalid prefix";
+    case "zod":
+      return zodIssueText(zodEn, issue);
+  }
+}
+function problem(p) {
+  switch (p.code) {
+    case "self-block":
+      return "a task cannot block itself";
+    case "self-related":
+      return "a task cannot be related to itself";
+    case "referenced-as-epic":
+      return `other tasks refer to this task as their epic: ${p.children.join(", ")}`;
+    case "blocker-cycle":
+      return `blocker cycle: ${p.cycle.join(" \u2192 ")}`;
+    case "resolution-needs-status":
+      return `resolution ${p.resolution} requires status ${p.status}`;
+    case "reason-without-resolution":
+      return "reason can only be set together with resolution";
+    case "epic-self":
+      return "a task cannot be its own epic";
+    case "epic-missing":
+      return `epic ${p.epic} not found`;
+    case "epic-not-epic":
+      return `${p.epic} is not an epic`;
+    case "epic-in-epic":
+      return "an epic cannot belong to another epic";
+    case "reference-missing":
+      return `${p.id} not found`;
+    case "no-frontmatter":
+      return "file does not start with frontmatter (---)";
+    case "frontmatter-unclosed":
+      return "frontmatter is not closed with a --- line";
+    case "yaml":
+      return `YAML error: ${p.detail}`;
+    case "schema":
+      return p.path === "" ? schemaIssue(p.issue) : `${p.path}: ${schemaIssue(p.issue)}`;
+    case "id-mismatch":
+      return `id ${p.id} does not match the file name ${p.file}.md`;
+    case "prefix-mismatch":
+      return `prefix of ${p.file} does not match the project prefix ${p.prefix}`;
+    case "id-exhausted":
+      return `could not allocate an ID in ${p.attempts} attempts`;
+  }
+}
+function problems(list) {
+  return [...new Set(list.map(problem))].join("; ");
+}
+function epicDoneReason(ids) {
+  return `all tasks of the epic are closed: ${ids.join(", ")}`;
+}
+function checkFix(fix) {
+  switch (fix.kind) {
+    case "references-removed":
+      return `${fix.taskId}: removed references to missing tasks: ${fix.ids.join(", ")}`;
+    case "epic-closed":
+      return `${fix.taskId}: epic closed \u2014 ${epicDoneReason(fix.childIds)}`;
+    case "source-moved":
+      return `${fix.taskId}: source moved ${lineSuffix(fix.from)} \u2192 ${lineSuffix(fix.to)}`;
+  }
+}
+function checkProblem(p) {
+  switch (p.kind) {
+    case "fix-failed":
+      return `${p.taskId}: could not fix \u2014 ${fixFailureCause(p)}`;
+    case "task-invalid":
+      return `${p.taskId}: ${problem(p.problem)}`;
+    case "file-not-parsed":
+      return `File ${p.path} could not be parsed: ${problems(p.problems)}`;
+    case "epics-wait-for-files":
+      return `Epics ${p.epicIds.join(", ")} are complete but will not close until the unparsed files are fixed`;
+    case "project-without-repos":
+      return `Project ${p.projectId}: repos has no paths \u2014 its tasks' code cannot be checked`;
+    case "project-repos-missing":
+      return `Project ${p.projectId}: none of the repos paths exist (${p.repos.join(", ")}) \u2014 its tasks' code cannot be checked`;
+  }
+}
+function fixFailureCause(p) {
+  switch (p.cause) {
+    case "invalid":
+      return problems(p.problems);
+    case "changed-during-check":
+      return "the file changed during the check";
+    case "gone-during-check":
+      return "the file disappeared during the check";
+  }
+}
+var coreEn = {
+  hookMark: "Backlog",
+  languageName: "English",
+  problem,
+  problems,
+  schemaIssue,
+  categoryLabel: (category) => category === void 0 ? "not set" : CATEGORY_LABELS[category],
+  statusLabel: (status) => STATUS_LABELS[status],
+  priorityLabel: (priority) => PRIORITY_LABELS[priority],
+  resolutionLabel: (resolution) => RESOLUTION_LABELS[resolution],
+  evidenceLabel,
+  checkMethodLabel,
+  duplicateMatchLabel,
+  graphStateLabel,
+  count,
+  days,
+  p90,
+  forecast,
+  forecastTail,
+  signal,
+  epicDoneReason,
+  fileBusy: (path, lock, seconds) => `${path} has been locked by another process for more than ${seconds} s (${lock})`,
+  checkFix,
+  checkProblem,
+  candidatesRecordFailed: (projectId, detail) => `Could not record candidates to the ${projectId} journal: ${detail}`
+};
+
+// src/core/messages/ru.ts
+import { z as z2 } from "zod";
+var zodRu = z2.locales.ru().localeError;
+var CATEGORY_LABELS2 = {
+  bloaters: "\u0420\u0430\u0437\u0431\u0443\u0445\u0448\u0435\u0435",
+  "change-preventers": "\u041C\u0435\u0448\u0430\u0435\u0442 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F\u043C",
+  couplers: "\u0421\u0432\u044F\u0437\u0430\u043D\u043D\u043E\u0441\u0442\u044C",
+  "data-dealers": "\u0420\u0430\u0431\u043E\u0442\u0430 \u0441 \u0434\u0430\u043D\u043D\u044B\u043C\u0438",
+  dispensables: "\u041B\u0438\u0448\u043D\u0435\u0435",
+  "functional-abusers": "\u0418\u043C\u043F\u0435\u0440\u0430\u0442\u0438\u0432\u043D\u043E\u0441\u0442\u044C",
+  "lexical-abusers": "\u0418\u043C\u0435\u043D\u043E\u0432\u0430\u043D\u0438\u0435",
+  "oo-abusers": "\u041E\u041E\u041F",
+  obfuscators: "\u0417\u0430\u043F\u0443\u0442\u0430\u043D\u043D\u043E\u0441\u0442\u044C",
+  bug: "\u041E\u0448\u0438\u0431\u043A\u0430"
+};
+var STATUS_LABELS2 = {
+  backlog: "\u0432 \u0431\u0435\u043A\u043B\u043E\u0433\u0435",
+  "in-progress": "\u0432 \u0440\u0430\u0431\u043E\u0442\u0435",
+  blocked: "\u0437\u0430\u0431\u043B\u043E\u043A\u0438\u0440\u043E\u0432\u0430\u043D\u0430",
+  done: "\u0441\u0434\u0435\u043B\u0430\u043D\u0430",
+  cancelled: "\u043E\u0442\u043C\u0435\u043D\u0435\u043D\u0430"
+};
+var PRIORITY_LABELS2 = { low: "\u043D\u0438\u0437\u043A\u0438\u0439", medium: "\u0441\u0440\u0435\u0434\u043D\u0438\u0439", high: "\u0432\u044B\u0441\u043E\u043A\u0438\u0439", critical: "\u043A\u0440\u0438\u0442\u0438\u0447\u043D\u044B\u0439" };
+var RESOLUTION_LABELS2 = { fixed: "\u0438\u0441\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u043E", obsolete: "\u043A\u043E\u0434\u0430 \u043D\u0435\u0442", duplicate: "\u0434\u0443\u0431\u043B\u044C", "epic-done": "\u044D\u043F\u0438\u043A \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D" };
+var EVIDENCE_LABELS2 = {
+  "source-changed": "\u043A\u043E\u0434 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u0441\u044F",
+  "source-missing": "\u0444\u0430\u0439\u043B \u043F\u0440\u043E\u043F\u0430\u043B",
+  duplicate: "\u0434\u0443\u0431\u043B\u044C",
+  "no-source": "\u043D\u0435\u0442 source",
+  total: "\u0412\u0441\u0435\u0433\u043E"
+};
+var CHECK_METHOD_LABELS2 = { symbol: "\u043F\u043E \u0441\u0438\u043C\u0432\u043E\u043B\u0443", anchor: "\u043F\u043E \u0441\u0442\u0440\u043E\u043A\u0430\u043C source", file: "\u043F\u043E \u0444\u0430\u0439\u043B\u0443" };
+var DUPLICATE_MATCH_LABELS2 = { source: "\u043F\u043E \u043C\u0435\u0441\u0442\u0443 \u0432 \u043A\u043E\u0434\u0435", title: "\u043F\u043E \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u0443", symbol: "\u043F\u043E \u0441\u0438\u043C\u0432\u043E\u043B\u0443" };
+var GRAPH_STATE_LABELS2 = { none: "\u043D\u0435\u0442", unreadable: "\u043D\u0435 \u0447\u0438\u0442\u0430\u0435\u0442\u0441\u044F", stale: "\u0443\u0441\u0442\u0430\u0440\u0435\u043B", fresh: "\u0441\u0432\u0435\u0436\u0438\u0439" };
+var COUNT_FORMS2 = {
+  task: ["\u0437\u0430\u0434\u0430\u0447\u0430", "\u0437\u0430\u0434\u0430\u0447\u0438", "\u0437\u0430\u0434\u0430\u0447"],
+  line: ["\u0441\u0442\u0440\u043E\u043A\u0430", "\u0441\u0442\u0440\u043E\u043A\u0438", "\u0441\u0442\u0440\u043E\u043A"],
+  project: ["\u043F\u0440\u043E\u0435\u043A\u0442", "\u043F\u0440\u043E\u0435\u043A\u0442\u0430", "\u043F\u0440\u043E\u0435\u043A\u0442\u043E\u0432"],
+  day: ["\u0434\u0435\u043D\u044C", "\u0434\u043D\u044F", "\u0434\u043D\u0435\u0439"],
+  week: ["\u043D\u0435\u0434\u0435\u043B\u044F", "\u043D\u0435\u0434\u0435\u043B\u0438", "\u043D\u0435\u0434\u0435\u043B\u044C"],
+  session: ["\u0441\u0435\u0441\u0441\u0438\u044F", "\u0441\u0435\u0441\u0441\u0438\u0438", "\u0441\u0435\u0441\u0441\u0438\u0439"]
+};
+function evidenceLabel2(evidence) {
+  return EVIDENCE_LABELS2[evidence];
+}
+function checkMethodLabel2(method) {
+  return CHECK_METHOD_LABELS2[method];
+}
+function duplicateMatchLabel2(match) {
+  return DUPLICATE_MATCH_LABELS2[match];
+}
+function graphStateLabel2(state) {
+  return GRAPH_STATE_LABELS2[state];
+}
+function count2(n, unit) {
+  const [one, few, many] = COUNT_FORMS2[unit];
+  return countRu(n, one, few, many);
+}
+function genitiveDays(days3) {
+  return `${days3} ${pluralRu(days3, "\u0434\u043D\u044F", "\u0434\u043D\u0435\u0439", "\u0434\u043D\u0435\u0439")}`;
+}
+function days2(value) {
+  if (value === null) return "\u2014";
+  if (value < 1) return "\u043C\u0435\u043D\u044C\u0448\u0435 \u0434\u043D\u044F";
+  return `${Math.round(value)}${NBSP}\u0434\u043D.`;
+}
+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: 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);
+  return `\u0414\u043E\u043B\u0433 \u0440\u0430\u0441\u0442\u0451\u0442 \u043D\u0430 ${formatDecimal("ru", growth)}${NBSP}${pluralRu(growth, "\u0437\u0430\u0434\u0430\u0447\u0430", "\u0437\u0430\u0434\u0430\u0447\u0438", "\u0437\u0430\u0434\u0430\u0447")} \u0432 \u043D\u0435\u0434\u0435\u043B\u044E`;
+}
+function forecastTail2({ windowWeeks, closed, created }) {
+  return `\u0437\u0430 ${countRu(windowWeeks, "\u043D\u0435\u0434\u0435\u043B\u044E", "\u043D\u0435\u0434\u0435\u043B\u0438", "\u043D\u0435\u0434\u0435\u043B\u044C")}: \u0437\u0430\u043A\u0440\u044B\u0442\u043E ${closed}, \u0441\u043E\u0437\u0434\u0430\u043D\u043E ${created}`;
+}
+function signal2(s) {
+  switch (s.kind) {
+    case "debt-growing":
+      return `\u0414\u043E\u043B\u0433 \u0440\u0430\u0441\u0442\u0451\u0442 ${countRu(s.params.weeks, "\u043D\u0435\u0434\u0435\u043B\u044E", "\u043D\u0435\u0434\u0435\u043B\u0438", "\u043D\u0435\u0434\u0435\u043B\u044C")} \u043F\u043E\u0434\u0440\u044F\u0434: \u0441\u043E\u0437\u0434\u0430\u043D\u043E ${s.params.created}, \u0437\u0430\u043A\u0440\u044B\u0442\u043E ${s.params.closed}`;
+    case "urgent-stale":
+      return `\u0421\u0440\u043E\u0447\u043D\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u0436\u0434\u0443\u0442 \u0434\u043E\u043B\u044C\u0448\u0435 ${genitiveDays(s.params.days)}: ${s.params.count}`;
+    case "stuck":
+      return `\u0417\u0430\u0441\u0442\u0440\u044F\u043B\u0438 \u0432 \u0440\u0430\u0431\u043E\u0442\u0435: ${s.params.count}, \u0434\u043E\u043B\u044C\u0448\u0435 \u0432\u0441\u0435\u0445 ${s.params.id} \u2014 ${days2(s.params.days)}`;
+    case "noisy-check": {
+      const { evidence, method, percent, decided, windowDays } = s.params;
+      const name = method === null ? `\xAB${evidenceLabel2(evidence)}\xBB` : `\xAB${evidenceLabel2(evidence)}\xBB ${checkMethodLabel2(method)}`;
+      return `\u041F\u0440\u043E\u0432\u0435\u0440\u043A\u0430 ${name} \u043F\u043E\u0447\u0442\u0438 \u0432\u0441\u0435\u0433\u0434\u0430 \u043E\u0448\u0438\u0431\u0430\u0435\u0442\u0441\u044F: \u0442\u043E\u0447\u043D\u043E\u0441\u0442\u044C ${percent}% \u043D\u0430 ${decided} \u0440\u0435\u0448\u0451\u043D\u043D\u044B\u0445 \u0437\u0430 ${countRu(windowDays, "\u0434\u0435\u043D\u044C", "\u0434\u043D\u044F", "\u0434\u043D\u0435\u0439")}`;
+    }
+    case "low-changed":
+      return `\u041A\u043E\u0434 \u043C\u0435\u043D\u044F\u043B\u0441\u044F \u0443 ${countRu(s.params.count, "\u0437\u0430\u0434\u0430\u0447\u0438", "\u0437\u0430\u0434\u0430\u0447", "\u0437\u0430\u0434\u0430\u0447")} \u0441 \u043D\u0438\u0437\u043A\u0438\u043C \u043F\u0440\u0438\u043E\u0440\u0438\u0442\u0435\u0442\u043E\u043C \u2014 \u043F\u0435\u0440\u0435\u043F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 \u043F\u0440\u0438 \u0441\u043B\u0443\u0447\u0430\u0435 (\xAB\u043F\u043E\u0447\u0438\u0441\u0442\u0438 \u0431\u0435\u043A\u043B\u043E\u0433\xBB)`;
+    case "stale-low":
+      return `\u0417\u0430\u0434\u0430\u0447 \u0441 \u043D\u0438\u0437\u043A\u0438\u043C \u043F\u0440\u0438\u043E\u0440\u0438\u0442\u0435\u0442\u043E\u043C \u0441\u0442\u0430\u0440\u0448\u0435 ${genitiveDays(s.params.days)}: ${s.params.count} \u2014 \u0440\u0430\u0437\u0431\u0435\u0440\u0438\u0442\u0435 (backlog prune)`;
+  }
+}
+function schemaIssue2(issue) {
+  switch (issue.kind) {
+    case "bad-id":
+      return "\u043D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 ID";
+    case "empty-title":
+      return "\u043F\u0443\u0441\u0442\u043E\u0439 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043E\u043A";
+    case "empty-name":
+      return "\u043F\u0443\u0441\u0442\u043E\u0435 \u0438\u043C\u044F \u043F\u0440\u043E\u0435\u043A\u0442\u0430";
+    case "bad-prefix":
+      return "\u043D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 \u043F\u0440\u0435\u0444\u0438\u043A\u0441";
+    case "zod":
+      return zodIssueText(zodRu, issue);
+  }
+}
+function problem2(p) {
+  switch (p.code) {
+    case "self-block":
+      return "\u0437\u0430\u0434\u0430\u0447\u0430 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u043B\u043E\u043A\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0441\u0430\u043C\u0443 \u0441\u0435\u0431\u044F";
+    case "self-related":
+      return "\u0437\u0430\u0434\u0430\u0447\u0430 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u0441\u0432\u044F\u0437\u0430\u043D\u0430 \u0441\u0430\u043C\u0430 \u0441 \u0441\u043E\u0431\u043E\u0439";
+    case "referenced-as-epic":
+      return `\u043D\u0430 \u0437\u0430\u0434\u0430\u0447\u0443 \u0441\u0441\u044B\u043B\u0430\u044E\u0442\u0441\u044F \u043A\u0430\u043A \u043D\u0430 \u044D\u043F\u0438\u043A: ${p.children.join(", ")}`;
+    case "blocker-cycle":
+      return `\u0446\u0438\u043A\u043B \u0431\u043B\u043E\u043A\u0435\u0440\u043E\u0432: ${p.cycle.join(" \u2192 ")}`;
+    case "resolution-needs-status":
+      return `resolution ${p.resolution} \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u0441\u0442\u0430\u0442\u0443\u0441 ${p.status}`;
+    case "reason-without-resolution":
+      return "reason \u0437\u0430\u0434\u0430\u0451\u0442\u0441\u044F \u0442\u043E\u043B\u044C\u043A\u043E \u0432\u043C\u0435\u0441\u0442\u0435 \u0441 resolution";
+    case "epic-self":
+      return "\u0437\u0430\u0434\u0430\u0447\u0430 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u0441\u0432\u043E\u0438\u043C \u044D\u043F\u0438\u043A\u043E\u043C";
+    case "epic-missing":
+      return `\u044D\u043F\u0438\u043A ${p.epic} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D`;
+    case "epic-not-epic":
+      return `${p.epic} \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u044D\u043F\u0438\u043A\u043E\u043C`;
+    case "epic-in-epic":
+      return "\u044D\u043F\u0438\u043A \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0432\u0445\u043E\u0434\u0438\u0442\u044C \u0432 \u0434\u0440\u0443\u0433\u043E\u0439 \u044D\u043F\u0438\u043A";
+    case "reference-missing":
+      return `${p.id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430`;
+    case "no-frontmatter":
+      return "\u0444\u0430\u0439\u043B \u043D\u0435 \u043D\u0430\u0447\u0438\u043D\u0430\u0435\u0442\u0441\u044F \u0441 frontmatter (---)";
+    case "frontmatter-unclosed":
+      return "frontmatter \u043D\u0435 \u0437\u0430\u043A\u0440\u044B\u0442 \u0441\u0442\u0440\u043E\u043A\u043E\u0439 ---";
+    case "yaml":
+      return `\u043E\u0448\u0438\u0431\u043A\u0430 YAML: ${p.detail}`;
+    case "schema":
+      return p.path === "" ? schemaIssue2(p.issue) : `${p.path}: ${schemaIssue2(p.issue)}`;
+    case "id-mismatch":
+      return `id ${p.id} \u043D\u0435 \u0441\u043E\u0432\u043F\u0430\u0434\u0430\u0435\u0442 \u0441 \u0438\u043C\u0435\u043D\u0435\u043C \u0444\u0430\u0439\u043B\u0430 ${p.file}.md`;
+    case "prefix-mismatch":
+      return `\u043F\u0440\u0435\u0444\u0438\u043A\u0441 ${p.file} \u043D\u0435 \u0441\u043E\u0432\u043F\u0430\u0434\u0430\u0435\u0442 \u0441 \u043F\u0440\u0435\u0444\u0438\u043A\u0441\u043E\u043C \u043F\u0440\u043E\u0435\u043A\u0442\u0430 ${p.prefix}`;
+    case "id-exhausted":
+      return `\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0432\u044B\u0434\u0435\u043B\u0438\u0442\u044C ID \u0437\u0430 ${p.attempts} \u043F\u043E\u043F\u044B\u0442\u043E\u043A`;
+  }
+}
+function problems2(list) {
+  return [...new Set(list.map(problem2))].join("; ");
+}
+function epicDoneReason2(ids) {
+  return `\u0432\u0441\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u044D\u043F\u0438\u043A\u0430 \u0437\u0430\u043A\u0440\u044B\u0442\u044B: ${ids.join(", ")}`;
+}
+function checkFix2(fix) {
+  switch (fix.kind) {
+    case "references-removed":
+      return `${fix.taskId}: \u0443\u0431\u0440\u0430\u043D\u044B \u0441\u0441\u044B\u043B\u043A\u0438 \u043D\u0430 \u043D\u0435\u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u044E\u0449\u0438\u0435 \u0437\u0430\u0434\u0430\u0447\u0438: ${fix.ids.join(", ")}`;
+    case "epic-closed":
+      return `${fix.taskId}: \u044D\u043F\u0438\u043A \u0437\u0430\u043A\u0440\u044B\u0442 \u2014 ${epicDoneReason2(fix.childIds)}`;
+    case "source-moved":
+      return `${fix.taskId}: source \u0441\u0434\u0432\u0438\u043D\u0443\u043B\u0441\u044F ${lineSuffix(fix.from)} \u2192 ${lineSuffix(fix.to)}`;
+  }
+}
+function checkProblem2(p) {
+  switch (p.kind) {
+    case "fix-failed":
+      return `${p.taskId}: \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0438\u0441\u043F\u0440\u0430\u0432\u0438\u0442\u044C \u2014 ${fixFailureCause2(p)}`;
+    case "task-invalid":
+      return `${p.taskId}: ${problem2(p.problem)}`;
+    case "file-not-parsed":
+      return `\u0424\u0430\u0439\u043B ${p.path} \u043D\u0435 \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u043D: ${problems2(p.problems)}`;
+    case "epics-wait-for-files":
+      return `\u042D\u043F\u0438\u043A\u0438 ${p.epicIds.join(", ")} \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u044B, \u043D\u043E \u043D\u0435 \u0437\u0430\u043A\u0440\u043E\u044E\u0442\u0441\u044F, \u043F\u043E\u043A\u0430 \u043D\u0435 \u0438\u0441\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u044B \u043D\u0435\u0440\u0430\u0437\u043E\u0431\u0440\u0430\u043D\u043D\u044B\u0435 \u0444\u0430\u0439\u043B\u044B`;
+    case "project-without-repos":
+      return `\u041F\u0440\u043E\u0435\u043A\u0442 ${p.projectId}: \u0432 repos \u043D\u0435\u0442 \u043F\u0443\u0442\u0435\u0439 \u2014 \u043A\u043E\u0434 \u0435\u0433\u043E \u0437\u0430\u0434\u0430\u0447 \u043D\u0435 \u043F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C`;
+    case "project-repos-missing":
+      return `\u041F\u0440\u043E\u0435\u043A\u0442 ${p.projectId}: \u043D\u0438 \u043E\u0434\u0438\u043D \u043F\u0443\u0442\u044C \u0438\u0437 repos \u043D\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442 (${p.repos.join(", ")}) \u2014 \u043A\u043E\u0434 \u0435\u0433\u043E \u0437\u0430\u0434\u0430\u0447 \u043D\u0435 \u043F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C`;
+  }
+}
+function fixFailureCause2(p) {
+  switch (p.cause) {
+    case "invalid":
+      return problems2(p.problems);
+    case "changed-during-check":
+      return "\u0444\u0430\u0439\u043B \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u0441\u044F \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0438";
+    case "gone-during-check":
+      return "\u0444\u0430\u0439\u043B \u0438\u0441\u0447\u0435\u0437 \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0438";
+  }
+}
+var coreRu = {
+  hookMark: "\u0411\u0435\u043A\u043B\u043E\u0433",
+  languageName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439",
+  problem: problem2,
+  problems: problems2,
+  schemaIssue: schemaIssue2,
+  categoryLabel: (category) => category === void 0 ? "\u043D\u0435 \u0443\u043A\u0430\u0437\u0430\u043D\u0430" : CATEGORY_LABELS2[category],
+  statusLabel: (status) => STATUS_LABELS2[status],
+  priorityLabel: (priority) => PRIORITY_LABELS2[priority],
+  resolutionLabel: (resolution) => RESOLUTION_LABELS2[resolution],
+  evidenceLabel: evidenceLabel2,
+  checkMethodLabel: checkMethodLabel2,
+  duplicateMatchLabel: duplicateMatchLabel2,
+  graphStateLabel: graphStateLabel2,
+  count: count2,
+  days: days2,
+  p90: p902,
+  forecast: forecast2,
+  forecastTail: forecastTail2,
+  signal: signal2,
+  epicDoneReason: epicDoneReason2,
+  fileBusy: (path, lock, seconds) => `${path} \u0437\u0430\u043D\u044F\u0442 \u0434\u0440\u0443\u0433\u0438\u043C \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u043E\u043C \u0434\u043E\u043B\u044C\u0448\u0435 ${seconds} \u0441 (${lock})`,
+  checkFix: checkFix2,
+  checkProblem: checkProblem2,
+  candidatesRecordFailed: (projectId, detail) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0438\u0441\u0430\u0442\u044C \u043A\u0430\u043D\u0434\u0438\u0434\u0430\u0442\u043E\u0432 \u0432 \u0436\u0443\u0440\u043D\u0430\u043B ${projectId}: ${detail}`
+};
+
+// src/core/messages/index.ts
+function coreMessages(language) {
+  return language === "ru" ? coreRu : coreEn;
+}
+
+// src/core/store/runs.ts
+import { join as join5 } from "node:path";
+import { z as z3 } from "zod";
+
+// src/core/model/dates.ts
+function formatLocalDay(date) {
+  return formatLocalIso(date).slice(0, 10);
+}
+function formatLocalIso(date) {
+  const pad = (value) => String(Math.abs(value)).padStart(2, "0");
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const offset = `${sign}${pad(Math.trunc(offsetMinutes / 60))}:${pad(offsetMinutes % 60)}`;
+  const day = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+  const time = `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+  return `${day}T${time}${offset}`;
+}
+
+// src/core/model/graph.ts
+var CLOSED_STATUSES = /* @__PURE__ */ new Set(["done", "cancelled"]);
+function isClosed(status) {
+  return CLOSED_STATUSES.has(status);
+}
+function buildIndex(tasks) {
+  const byId = /* @__PURE__ */ new Map();
+  const dependentsOf = /* @__PURE__ */ new Map();
+  const relatedFrom = /* @__PURE__ */ new Map();
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    byId.set(task.id, task);
+    for (const blockerId of task.blockedBy) appendTo(dependentsOf, blockerId, task);
+    for (const relatedId of task.related) appendTo(relatedFrom, relatedId, task);
+    if (task.epic !== void 0) appendTo(childrenOf, task.epic, task);
+  }
+  return { byId, dependentsOf, relatedFrom, childrenOf };
+}
+function epicChildren(epic, index) {
+  return index.childrenOf.get(epic.id) ?? [];
+}
+function appendTo(map, key, task) {
+  const list = map.get(key);
+  if (list) list.push(task);
+  else map.set(key, [task]);
+}
+
+// src/core/model/lifecycle.ts
+var RETENTION_DAYS = 7;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var RESOLUTION_STATUS = {
+  fixed: "done",
+  obsolete: "cancelled",
+  duplicate: "cancelled",
+  "epic-done": "done"
+};
+function changeStatus(task, status, now, closure) {
+  if (status === task.status) return task;
+  return { ...task, status, closed: closedAt(task, status, now), resolution: closure?.resolution, reason: closure?.reason };
+}
+function settleLifecycle(task, now) {
+  if (!isClosed(task.status)) return { ...task, closed: void 0, resolution: void 0, reason: void 0 };
+  return task.closed === void 0 ? { ...task, closed: formatLocalIso(now) } : task;
+}
+function deletionDate(task) {
+  if (!isClosed(task.status) || task.closed === void 0) return void 0;
+  return new Date(Date.parse(task.closed) + RETENTION_DAYS * DAY_MS);
+}
+function isExpired(task, now) {
+  const deletesAt = deletionDate(task);
+  return deletesAt !== void 0 && deletesAt.getTime() <= now.getTime();
+}
+function planEpicClosing(tasks, parseErrors) {
+  const unreadableProjects = new Set(parseErrors.map((error) => error.projectId));
+  const completed = completedEpics(tasks);
+  return {
+    close: completed.filter(({ epic }) => !unreadableProjects.has(epic.projectId)),
+    waiting: completed.filter(({ epic }) => unreadableProjects.has(epic.projectId))
+  };
+}
+function completedEpics(tasks) {
+  const index = buildIndex(tasks);
+  return tasks.flatMap((epic) => {
+    const childIds = completedEpicChildren(epic, index);
+    return childIds === null ? [] : [{ epic, childIds }];
+  });
+}
+function completedEpicChildren(task, index) {
+  if (task.type !== "epic" || isClosed(task.status)) return null;
+  const children = epicChildren(task, index);
+  const complete = children.length > 0 && children.every((child) => isClosed(child.status));
+  return complete ? children.map((child) => child.id) : null;
+}
+function epicDoneClosure(childIds, messages) {
+  return { resolution: "epic-done", reason: messages.epicDoneReason(childIds) };
+}
+function closedAt(task, status, now) {
+  if (!isClosed(status)) return void 0;
+  return isClosed(task.status) ? task.closed : formatLocalIso(now);
+}
+
+// src/core/store/file-lock.ts
+import { rm as rm2, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname2, join as join4 } from "node:path";
+import { setTimeout as sleep2 } from "node:timers/promises";
+
+// src/core/store/fs-utils.ts
+import { createHash, randomUUID } from "node:crypto";
+import { link, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { basename as basename2, dirname, join as join3 } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+function contentVersion(text) {
+  return createHash("sha1").update(text).digest("hex");
+}
+function hasErrorCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+async function readTextOrNull(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) return null;
+    throw error;
+  }
+}
+async function readJsonLines(path, schema) {
+  const text = await readTextOrNull(path) ?? "";
+  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 };
+}
+function toJsonLines(values) {
+  return values.map((value) => `${JSON.stringify(value)}
+`).join("");
+}
+function parseJson(text, schema) {
+  try {
+    const parsed = schema.safeParse(JSON.parse(text));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function readJsonFile(path, schema) {
+  const text = await readTextOrNull(path);
+  return text === null ? null : parseJson(text, schema);
+}
+async function writeJsonFile(path, value) {
+  await writeFileAtomic(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function removeIfUnchanged(path, version) {
+  const text = await readTextOrNull(path);
+  if (text !== null && contentVersion(text) !== version) return false;
+  await rm(path, { force: true });
+  return true;
+}
+async function listDir(path, { recursive = false } = {}) {
+  try {
+    return await readdir(path, { withFileTypes: true, recursive });
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) return [];
+    throw error;
+  }
+}
+var REPLACE_RETRY_DELAYS_MS = [10, 20, 40, 80, 160, 320, 640];
+var REPLACE_BLOCKED_CODES = ["EPERM", "EACCES", "EBUSY"];
+async function writeFileAtomic(path, content) {
+  await viaTemporaryFile(path, content, (temporary) => replaceFile(temporary, path));
+}
+async function replaceFile(temporary, path) {
+  if (process.platform !== "win32") return rename(temporary, path);
+  for (const delayMs of REPLACE_RETRY_DELAYS_MS) {
+    try {
+      return await rename(temporary, path);
+    } catch (error) {
+      if (!REPLACE_BLOCKED_CODES.some((code) => hasErrorCode(error, code))) throw error;
+      await sleep(delayMs);
+    }
+  }
+  await rename(temporary, path);
+}
+async function viaTemporaryFile(path, content, publish) {
+  const temporary = join3(dirname(path), `.${basename2(path)}.${randomUUID()}.tmp`);
+  try {
+    await writeFile(temporary, content, "utf8");
+    await publish(temporary);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+
+// src/core/store/file-lock.ts
+var RETRY_MS = 10;
+var WAIT_LIMIT_MS = 5e3;
+var ABANDONED_AFTER_MS = 3e4;
+var FileBusyError = class extends Error {
+  constructor(path, lock, seconds) {
+    super(`${path} is locked: ${lock}`);
+    this.path = path;
+    this.lock = lock;
+    this.seconds = seconds;
+    this.name = "FileBusyError";
+  }
+  path;
+  lock;
+  seconds;
+};
+async function withFileLock(path, action) {
+  const lock = join4(dirname2(path), `.${basename3(path)}.lock`);
+  await acquire(lock, path);
+  try {
+    return await action();
+  } finally {
+    await rm2(lock, { force: true });
+  }
+}
+async function acquire(lock, path) {
+  const giveUpAt = Date.now() + WAIT_LIMIT_MS;
+  for (; ; ) {
+    if (await tryCreate(lock)) return;
+    if (await isAbandoned(lock)) {
+      await rm2(lock, { force: true });
+      continue;
+    }
+    if (Date.now() > giveUpAt) throw new FileBusyError(path, lock, WAIT_LIMIT_MS / 1e3);
+    await sleep2(RETRY_MS);
+  }
+}
+async function tryCreate(lock) {
+  try {
+    await writeFile2(lock, String(process.pid), { flag: "wx" });
+    return true;
+  } catch (error) {
+    if (hasErrorCode(error, "EEXIST")) return false;
+    throw error;
+  }
+}
+async function isAbandoned(lock) {
+  try {
+    return Date.now() - (await stat(lock)).mtimeMs > ABANDONED_AFTER_MS;
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) return false;
+    throw error;
+  }
+}
+
+// src/core/store/runs.ts
+var RUNS_FILE = ".runs.jsonl";
+var RUNS_KEPT_DAYS = 30;
+var cliRunSchema = z3.object({
+  at: z3.iso.datetime({ offset: true }),
+  command: z3.string().min(1),
+  cwd: z3.string().min(1),
+  ms: z3.number(),
+  rssMb: z3.number(),
+  exitCode: z3.number()
+});
+async function readRuns(root) {
+  return (await readJsonLines(join5(root, RUNS_FILE), cliRunSchema)).values;
+}
+async function trimRuns(root, now) {
+  const path = join5(root, RUNS_FILE);
+  return withFileLock(path, async () => {
+    const runs = await readRuns(root);
+    const cutoff = now.getTime() - RUNS_KEPT_DAYS * DAY_MS;
+    const kept = runs.filter((run) => Date.parse(run.at) >= cutoff);
+    const removed = runs.length - kept.length;
+    if (removed > 0) await writeFileAtomic(path, toJsonLines(kept));
+    return removed;
+  });
+}
+
+// src/core/store/settings.ts
+import { mkdir } from "node:fs/promises";
+import { join as join6 } from "node:path";
+import { z as z4 } from "zod";
+var SETTINGS_FILE = ".settings.json";
+var settingsSchema = z4.object({ language: z4.enum(LANGUAGES) });
+function settingsFilePath(root) {
+  return join6(root, SETTINGS_FILE);
+}
+async function readSettingsFile(root) {
+  const text = await readTextOrNull(settingsFilePath(root));
+  if (text === null) return { found: false };
+  const settings = parseJson(text, settingsSchema);
+  return settings === null ? { found: true, valid: false } : { found: true, valid: true, settings };
+}
+async function writeSettings(root, settings) {
+  await mkdir(root, { recursive: true });
+  await writeJsonFile(settingsFilePath(root), settings);
+}
+async function settledLanguage(root, env) {
+  const file = await readSettingsFile(root);
+  if (file.found && file.valid) return { language: file.settings.language, invalidSettingsFile: false };
+  const locale = () => languageFromLocale(env.LC_ALL || env.LANG || Intl.DateTimeFormat().resolvedOptions().locale);
+  if (!file.found) {
+    const language = await hasProjects(root) ? "ru" : locale();
+    await writeSettings(root, { language }).catch(() => {
+    });
+    return { language, invalidSettingsFile: false };
+  }
+  return { language: locale(), invalidSettingsFile: true };
+}
+async function hasProjects(root) {
+  return (await listDir(root)).some((entry) => entry.isDirectory() && !entry.name.startsWith("."));
+}
+
+// src/core/store/sweep.ts
+import { dirname as dirname4 } from "node:path";
+
+// src/core/model/ids.ts
+var ID_PATTERN = /^[A-Z][A-Z0-9]{0,9}-[1-9]\d*$/;
+var PREFIX_PATTERN = /^[A-Z][A-Z0-9]{0,9}$/;
+function parseId(id) {
+  if (!ID_PATTERN.test(id)) return null;
+  const separator = id.lastIndexOf("-");
+  return { prefix: id.slice(0, separator), number: Number(id.slice(separator + 1)) };
+}
+function compareIds(a, b) {
+  const left = parseId(a);
+  const right = parseId(b);
+  if (!left || !right) return a.localeCompare(b);
+  return left.prefix === right.prefix ? left.number - right.number : left.prefix.localeCompare(right.prefix);
+}
+
+// src/core/journal/events.ts
+import { z as z6 } from "zod";
+
+// src/core/model/types.ts
+import { z as z5 } from "zod";
+
+// src/core/model/problems.ts
+var CODED_SCHEMA_ISSUES = ["bad-id", "empty-title", "empty-name", "bad-prefix"];
+function schemaCode(kind) {
+  return { error: () => kind };
+}
+
+// src/core/model/types.ts
+var TASK_TYPES = ["task", "epic"];
+var TASK_STATUSES = ["backlog", "in-progress", "blocked", "done", "cancelled"];
+var PRIORITIES = ["low", "medium", "high", "critical"];
+var TASK_CATEGORIES = [
+  "bloaters",
+  "change-preventers",
+  "couplers",
+  "data-dealers",
+  "dispensables",
+  "functional-abusers",
+  "lexical-abusers",
+  "oo-abusers",
+  "obfuscators",
+  "bug"
+];
+var RESOLUTIONS = ["fixed", "obsolete", "duplicate", "epic-done"];
+function normalizeTag(tag) {
+  return tag.trim().toLowerCase();
+}
+var taskIdSchema = z5.string().regex(ID_PATTERN, schemaCode("bad-id"));
+var taskIdList = z5.array(taskIdSchema).default([]).transform((ids) => [...new Set(ids)]);
+var taskFrontmatterSchema = z5.object({
+  id: taskIdSchema,
+  title: z5.string().trim().min(1, schemaCode("empty-title")),
+  type: z5.enum(TASK_TYPES).default("task"),
+  status: z5.enum(TASK_STATUSES).default("backlog"),
+  priority: z5.enum(PRIORITIES).default("medium"),
+  category: z5.enum(TASK_CATEGORIES).optional(),
+  tags: z5.array(z5.string()).default([]).transform((tags) => [...new Set(tags.map(normalizeTag).filter(Boolean))]),
+  epic: taskIdSchema.optional(),
+  blockedBy: taskIdList,
+  related: taskIdList,
+  created: z5.iso.datetime({ offset: true }),
+  source: z5.string().optional(),
+  anchor: z5.string().optional(),
+  closed: z5.iso.datetime({ offset: true }).optional(),
+  resolution: z5.enum(RESOLUTIONS).optional(),
+  reason: z5.string().optional(),
+  verified: z5.iso.datetime({ offset: true }).optional()
+});
+var projectFrontmatterSchema = z5.object({
+  name: z5.string().trim().min(1, schemaCode("empty-name")),
+  prefix: z5.string().regex(PREFIX_PATTERN, schemaCode("bad-prefix")),
+  repos: z5.array(z5.string()).default([]),
+  issuedUpTo: z5.number().int().nonnegative().optional(),
+  active: z5.boolean().default(true)
+});
+
+// src/core/journal/events.ts
+var CHANGE_SOURCES = ["cli", "web", "check", "sweep"];
+var FOUND_HOW = ["review", "incidental"];
+var CANDIDATE_EVIDENCE = ["source-changed", "source-missing", "duplicate", "no-source"];
+var CHECK_MODES = ["full", "changed"];
+var CHECK_METHODS = ["symbol", "anchor", "file"];
+var RECORDED_METHODS = [...CHECK_METHODS, "unknown"];
+var DUPLICATE_MATCHES = ["source", "title", "symbol"];
+var RECORDED_MATCHES = [...DUPLICATE_MATCHES, "unknown"];
+function checkMethodOf({ bySymbol, byAnchor }) {
+  if (bySymbol === true) return "symbol";
+  return byAnchor === true ? "anchor" : "file";
+}
+function recordedMethodOf({ method, bySymbol, byAnchor }) {
+  if (method !== void 0) return method;
+  return bySymbol === true || byAnchor === true ? checkMethodOf({ bySymbol, byAnchor }) : "unknown";
+}
+var eventBase = { at: z6.iso.datetime({ offset: true }), task: z6.string().min(1), via: z6.enum(CHANGE_SOURCES) };
+var journalEventSchema = z6.discriminatedUnion("kind", [
+  z6.object({
+    ...eventBase,
+    kind: z6.literal("created"),
+    type: z6.enum(TASK_TYPES),
+    priority: z6.enum(PRIORITIES),
+    tags: z6.array(z6.string()),
+    source: z6.string().optional(),
+    epic: z6.string().optional(),
+    category: z6.enum(TASK_CATEGORIES).optional(),
+    found: z6.enum(FOUND_HOW).optional(),
+    origin: z6.object({ branch: z6.string().optional(), commit: z6.string().min(1) }).optional()
+  }),
+  z6.object({ ...eventBase, kind: z6.literal("status"), from: z6.enum(TASK_STATUSES), to: z6.enum(TASK_STATUSES), resolution: z6.enum(RESOLUTIONS).optional() }),
+  z6.object({ ...eventBase, kind: z6.literal("priority"), from: z6.enum(PRIORITIES), to: z6.enum(PRIORITIES) }),
+  z6.object({ ...eventBase, kind: z6.literal("deleted"), snapshot: taskFrontmatterSchema }),
+  z6.object({ ...eventBase, kind: z6.literal("category"), from: z6.enum(TASK_CATEGORIES).optional(), to: z6.enum(TASK_CATEGORIES).optional() }),
+  z6.object({ ...eventBase, kind: z6.literal("verified"), source: z6.string().optional() }),
+  z6.object({
+    ...eventBase,
+    kind: z6.literal("candidate"),
+    evidence: z6.enum(CANDIDATE_EVIDENCE),
+    mode: z6.enum(CHECK_MODES),
+    method: z6.enum(CHECK_METHODS).optional(),
+    bySymbol: z6.boolean().optional(),
+    byAnchor: z6.boolean().optional(),
+    match: z6.enum(DUPLICATE_MATCHES).optional()
+  }),
+  z6.object({ ...eventBase, kind: z6.literal("candidate-gone"), evidence: z6.enum(CANDIDATE_EVIDENCE) }),
+  z6.object({ ...eventBase, kind: z6.literal("candidate-filtered"), symbol: z6.string() })
+]);
+var SNAPSHOT_FIELDS = Object.keys(taskFrontmatterSchema.shape);
+function changeEvents(before, after, now, via) {
+  const at = formatLocalIso(now);
+  const events = [];
+  if (before.status !== after.status) {
+    const resolution = isClosed(after.status) ? after.resolution : void 0;
+    events.push({ at, task: after.id, via, kind: "status", from: before.status, to: after.status, resolution });
+  }
+  if (before.priority !== after.priority) events.push({ at, task: after.id, via, kind: "priority", from: before.priority, to: after.priority });
+  if (before.category !== after.category) events.push({ at, task: after.id, via, kind: "category", from: before.category, to: after.category });
+  if (before.verified !== after.verified) {
+    events.push({ at, task: after.id, via, kind: "verified", source: before.source === after.source ? void 0 : after.source });
+  }
+  return events;
+}
+function deletedEvent(task, now, via) {
+  return { at: formatLocalIso(now), task: task.id, via, kind: "deleted", snapshot: snapshotOf(task) };
+}
+function snapshotOf(task) {
+  return Object.fromEntries(SNAPSHOT_FIELDS.map((field) => [field, task[field]]));
+}
+
+// src/core/store/journal.ts
+import { appendFile } 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 appendFile(path, toJsonLines(events), "utf8");
+  } catch (error) {
+    onError(path, error);
+  }
+}
+async function readJournal(projectDir2, projectId) {
+  const { values, invalidLines } = await readJsonLines(join7(projectDir2, JOURNAL_FILE), journalEventSchema);
+  return { projectId, events: values, invalidLines };
+}
+async function readJournals(root, projectIds) {
+  return Promise.all(projectIds.map((projectId) => readJournal(join7(root, projectId), projectId)));
+}
+function reportToStderr(path, error) {
+  console.error(`${path}: ${errorText(error)}`);
+}
+
+// src/core/store/load.ts
+import { basename as basename4, join as join8 } from "node:path";
+
+// src/core/model/frontmatter.ts
+import { Document, parse, visit } from "yaml";
+
+// src/core/model/zod-issues.ts
+import { z as z7 } from "zod";
+function parseSchema(schema, value) {
+  const parsed = schema.safeParse(value, { reportInput: true });
+  return parsed.success ? { ok: true, value: parsed.data } : { ok: false, problems: parsed.error.issues.map(schemaProblem) };
+}
+function parseWithLocale(schema, value, language) {
+  const parsed = parseSchema(schema, value);
+  if (parsed.ok) return parsed;
+  const messages = coreMessages(language);
+  return { ok: false, errors: [...new Set(parsed.problems.map((problem3) => messages.schemaIssue(problem3.issue)))] };
+}
+function schemaProblem(issue) {
+  return { code: "schema", path: issue.path.join("."), issue: schemaIssue3(issue) };
+}
+function schemaIssue3({ input, ...issue }) {
+  const coded = CODED_SCHEMA_ISSUES.find((kind) => kind === issue.message);
+  if (coded !== void 0) return { kind: coded };
+  return issue.code === "invalid_type" ? { kind: "zod", issue, receivedType: z7.core.util.parsedType(input) } : { kind: "zod", issue };
+}
+
+// src/core/model/frontmatter.ts
+var DELIMITER = "---";
+function parseFrontmatter(text, schema) {
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/);
+  if (lines[0] !== DELIMITER) return { ok: false, problems: [{ code: "no-frontmatter" }] };
+  const closing = lines.indexOf(DELIMITER, 1);
+  if (closing === -1) return { ok: false, problems: [{ code: "frontmatter-unclosed" }] };
+  let raw;
+  try {
+    raw = parse(lines.slice(1, closing).join("\n"));
+  } catch (error) {
+    return { ok: false, problems: [{ code: "yaml", detail: errorText(error) }] };
+  }
+  const parsed = parseSchema(schema, raw);
+  if (!parsed.ok) return parsed;
+  const knownFields = Object.keys(schema.shape);
+  const extra = Object.fromEntries(Object.entries(raw).filter(([key]) => !knownFields.includes(key)));
+  const body = lines.slice(closing + 1).join("\n").replace(/^\n+/, "");
+  return { ok: true, value: { data: parsed.value, extra, body } };
+}
+function stringifyFrontmatter(data, body) {
+  const document = new Document(data);
+  visit(document, {
+    Seq(_, node) {
+      node.flow = true;
+    }
+  });
+  const yamlText = document.toString({ lineWidth: 0, flowCollectionPadding: false });
+  const content = body.replace(/^\n+/, "").trimEnd();
+  return content === "" ? `${DELIMITER}
+${yamlText}${DELIMITER}
+` : `${DELIMITER}
+${yamlText}${DELIMITER}
+
+${content}
+`;
+}
+
+// src/core/model/project-file.ts
+function parseProjectFile(text, location) {
+  const parsed = parseFrontmatter(text, projectFrontmatterSchema);
+  if (!parsed.ok) return parsed;
+  const { data, extra, body } = parsed.value;
+  return { ok: true, value: { ...data, extra, body, ...location } };
+}
+function serializeProject(project) {
+  const { name, prefix, repos, issuedUpTo, active } = project;
+  return stringifyFrontmatter({ name, prefix, repos, issuedUpTo, active: active ? void 0 : false, ...project.extra }, project.body);
+}
+
+// src/core/model/task-file.ts
+var TASK_FIELDS = Object.keys(taskFrontmatterSchema.shape);
+function parseTaskFile(text, location) {
+  const parsed = parseFrontmatter(text, taskFrontmatterSchema);
+  if (!parsed.ok) return parsed;
+  const { data, extra, body } = parsed.value;
+  return { ok: true, value: { ...data, extra, body, ...location } };
+}
+function serializeTask(task) {
+  const known = Object.fromEntries(TASK_FIELDS.map((field) => [field, task[field]]));
+  return stringifyFrontmatter({ ...known, ...task.extra }, task.body);
+}
+
+// src/core/store/load.ts
+async function loadBacklog(root) {
+  const projectDirs = (await listDir(root)).filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
+  const parts = await Promise.all(projectDirs.map((entry) => loadProjectDir(join8(root, entry.name), entry.name)));
+  return {
+    projects: parts.flatMap((part) => part.projects).sort((a, b) => a.id.localeCompare(b.id)),
+    tasks: parts.flatMap((part) => part.tasks).sort((a, b) => compareIds(a.id, b.id)),
+    errors: parts.flatMap((part) => part.errors).sort((a, b) => a.path.localeCompare(b.path))
+  };
+}
+async function loadProjectDir(dir, projectId) {
+  const projectPath = join8(dir, PROJECT_FILE);
+  const projectText = await readTextOrNull(projectPath);
+  if (projectText === null) return { projects: [], tasks: [], errors: [] };
+  const project = parseProjectFile(projectText, { id: projectId, path: projectPath });
+  if (!project.ok) return { projects: [], tasks: [], errors: [{ path: projectPath, projectId, problems: project.problems }] };
+  const taskPaths = (await listDir(dir)).filter((entry) => entry.isFile() && isTaskFileName(entry.name)).map((entry) => join8(dir, entry.name));
+  const loaded = await Promise.all(taskPaths.map(async (path) => ({ path, result: await loadTaskFile(path, project.value) })));
+  return {
+    projects: [project.value],
+    tasks: loaded.flatMap(({ result }) => result?.ok ? [result.value] : []),
+    errors: loaded.flatMap(({ path, result }) => result && !result.ok ? [{ path, projectId, problems: result.problems }] : [])
+  };
+}
+async function loadTaskFile(path, project) {
+  const text = await readTextOrNull(path);
+  if (text === null) return null;
+  const parsed = parseTaskFile(text, { projectId: project.id, path, version: contentVersion(text) });
+  if (!parsed.ok) return parsed;
+  const stem = basename4(path, ".md");
+  if (parsed.value.id !== stem) return { ok: false, problems: [{ code: "id-mismatch", id: parsed.value.id, file: stem }] };
+  if (parseId(stem)?.prefix !== project.prefix) {
+    return { ok: false, problems: [{ code: "prefix-mismatch", file: stem, prefix: project.prefix }] };
+  }
+  return parsed;
+}
+function isTaskFileName(name) {
+  return name.endsWith(".md") && ID_PATTERN.test(name.slice(0, -".md".length));
+}
+
+// src/core/store/projects.ts
+import { rm as rm3 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+var NOT_FOUND = { ok: false, reason: "not-found" };
+async function setProjectActive(root, id, active) {
+  const dir = projectDir(root, id);
+  if (dir === null) return NOT_FOUND;
+  return editProjectFile({ id, path: join9(dir, PROJECT_FILE) }, (project) => ({ ...project, active }));
+}
+async function reserveIssuedUpTo(project, number) {
+  const edited = await editProjectFile(project, (current) => {
+    const issuedUpTo = Math.max(current.issuedUpTo ?? 0, number);
+    return issuedUpTo === current.issuedUpTo ? current : { ...current, issuedUpTo };
+  });
+  return edited.ok;
+}
+async function editProjectFile({ id, path }, edit) {
+  const text = await readTextOrNull(path);
+  if (text === null) return NOT_FOUND;
+  const parsed = parseProjectFile(text, { id, path });
+  if (!parsed.ok) return { ok: false, reason: "invalid", problems: parsed.problems };
+  const project = edit(parsed.value);
+  if (project !== parsed.value) await writeFileAtomic(path, serializeProject(project));
+  return { ok: true, project };
+}
+async function deleteProject(root, id) {
+  const dir = projectDir(root, id);
+  if (dir === null || await readTextOrNull(join9(dir, PROJECT_FILE)) === null) return NOT_FOUND;
+  await rm3(dir, { recursive: true, force: true });
+  return { ok: true };
+}
+
+// src/core/store/references.ts
+function referenceCleanup(task, isGone) {
+  const blockedBy = task.blockedBy.filter((id) => !isGone(id));
+  const related = task.related.filter((id) => !isGone(id));
+  const epicGone = task.epic !== void 0 && isGone(task.epic);
+  const untouched = blockedBy.length === task.blockedBy.length && related.length === task.related.length && !epicGone;
+  if (untouched) return null;
+  return epicGone ? { blockedBy, related, epic: null } : { blockedBy, related };
+}
+
+// src/core/store/update.ts
+import { dirname as dirname3 } from "node:path";
+
+// src/core/model/integrity.ts
+function integrityErrors(candidate, index) {
+  const resolve = (id) => id === candidate.id ? candidate : index.byId.get(id);
+  const errors = [];
+  if (candidate.blockedBy.includes(candidate.id)) errors.push({ code: "self-block" });
+  if (candidate.related.includes(candidate.id)) errors.push({ code: "self-related" });
+  errors.push(...epicProblems(candidate, resolve));
+  const children = (index.childrenOf.get(candidate.id) ?? []).filter((task) => task.id !== candidate.id);
+  if (candidate.type === "task" && children.length > 0) {
+    errors.push({ code: "referenced-as-epic", children: children.map((task) => task.id) });
+  }
+  const cycle = findBlockerCycle(candidate, resolve);
+  if (cycle) errors.push({ code: "blocker-cycle", cycle });
+  if (candidate.resolution !== void 0 && candidate.status !== RESOLUTION_STATUS[candidate.resolution]) {
+    errors.push({ code: "resolution-needs-status", resolution: candidate.resolution, status: RESOLUTION_STATUS[candidate.resolution] });
+  }
+  if (candidate.reason !== void 0 && candidate.resolution === void 0) errors.push({ code: "reason-without-resolution" });
+  return errors;
+}
+function epicProblems(candidate, resolve) {
+  if (candidate.epic === void 0) return [];
+  const problems3 = [];
+  if (candidate.epic === candidate.id) {
+    problems3.push({ code: "epic-self" });
+  } else {
+    const epic = resolve(candidate.epic);
+    if (!epic) problems3.push({ code: "epic-missing", epic: candidate.epic });
+    else if (epic.type !== "epic") problems3.push({ code: "epic-not-epic", epic: candidate.epic });
+  }
+  if (candidate.type === "epic") problems3.push({ code: "epic-in-epic" });
+  return problems3;
+}
+function findBlockerCycle(start, resolve) {
+  const visited = /* @__PURE__ */ new Set();
+  const walk = (task, path) => {
+    for (const blockerId of task.blockedBy) {
+      if (blockerId === start.id) return [...path, blockerId];
+      if (visited.has(blockerId)) continue;
+      visited.add(blockerId);
+      const blocker = resolve(blockerId);
+      const cycle = blocker ? walk(blocker, [...path, blockerId]) : null;
+      if (cycle) return cycle;
+    }
+    return null;
+  };
+  const withoutSelfBlock = { ...start, blockedBy: start.blockedBy.filter((id) => id !== start.id) };
+  return walk(withoutSelfBlock, [start.id]);
+}
+
+// src/core/store/task-text.ts
+function taskText(draft) {
+  const parsed = parseTaskFile(serializeTask(draft), { projectId: draft.projectId, path: draft.path, version: "" });
+  if (!parsed.ok) return parsed;
+  const text = serializeTask(parsed.value);
+  return { ok: true, value: { text, task: { ...parsed.value, version: contentVersion(text) } } };
+}
+
+// src/core/store/write-result.ts
+function invalid(errors) {
+  return { ok: false, reason: "invalid", errors };
+}
+
+// src/core/store/update.ts
+var CHANGE_FIELDS = ["title", "type", "priority", "tags", "blockedBy", "related", "body", "source", "verified"];
+async function updateTaskInIndex(index, { id, changes, expectedVersion, now, closure, via }) {
+  const current = index.byId.get(id);
+  if (!current) return { ok: false, reason: "not-found" };
+  if (expectedVersion !== void 0 && expectedVersion !== current.version) return { ok: false, reason: "conflict", current };
+  const normalized = taskText(applyChanges(current, changes, now, closure));
+  if (!normalized.ok) return invalid(normalized.problems);
+  const { text, task } = normalized.value;
+  const errors = integrityErrors(task, index);
+  if (errors.length > 0) return invalid(errors);
+  return withFileLock(current.path, async () => {
+    const changedOnDisk = expectedVersion === void 0 ? null : await diskChange(current, expectedVersion);
+    if (changedOnDisk !== null) return changedOnDisk;
+    await writeFileAtomic(current.path, text);
+    await appendJournal(dirname3(current.path), changeEvents(current, task, now, via));
+    return { ok: true, task };
+  });
+}
+async function diskChange(snapshot, expectedVersion) {
+  const text = await readTextOrNull(snapshot.path);
+  if (text === null) return { ok: false, reason: "not-found" };
+  const version = contentVersion(text);
+  if (version === expectedVersion) return null;
+  const fresh = parseTaskFile(text, { projectId: snapshot.projectId, path: snapshot.path, version });
+  return { ok: false, reason: "conflict", current: fresh.ok ? fresh.value : snapshot };
+}
+function applyChanges(task, changes, now, closure) {
+  const edited = {
+    ...task,
+    ...pickDefined(changes, CHANGE_FIELDS),
+    epic: nextOptional(task.epic, changes.epic),
+    category: nextOptional(task.category, changes.category),
+    anchor: nextAnchor(task, changes)
+  };
+  const moved = changes.status === void 0 ? edited : changeStatus(edited, changes.status, now, closure);
+  return settleLifecycle(moved, now);
+}
+function nextAnchor(task, changes) {
+  if (changes.anchor !== void 0) return changes.anchor ?? void 0;
+  const sourceMoved = changes.source !== void 0 && changes.source !== task.source;
+  return sourceMoved ? void 0 : task.anchor;
+}
+function pickDefined(source, keys) {
+  const picked = {};
+  for (const key of keys) {
+    const value = source[key];
+    if (value !== void 0) picked[key] = value;
+  }
+  return picked;
+}
+function nextOptional(current, change) {
+  if (change === null) return void 0;
+  return change ?? current;
+}
+
+// src/core/store/sweep.ts
+async function sweepClosed(root, now, messages) {
+  const initial = await loadBacklog(root);
+  const epics = await closeCompletedEpics(initial, now, messages);
+  const { projects, tasks } = epics.closed.length > 0 ? await loadBacklog(root) : initial;
+  const waitsForEpic = (task) => task.epic !== void 0 && epics.leftOpen.has(task.epic);
+  const expired = tasks.filter((task) => isExpired(task, now) && !waitsForEpic(task));
+  const reserved = await reserveNumbers(projects, expired);
+  const removable = expired.filter((task) => reserved.has(task.projectId));
+  const updates = await repairRemainingTasks(tasks, removable, now);
+  const removal = await removeExpired(removable.filter((task) => !updates.stillReferenced.has(task.id)), now);
+  return {
+    closedEpics: epics.closed,
+    blockingFiles: epics.blockingFiles,
+    deleted: removal.deleted,
+    ...failureLists([...epics.failures, ...updates.failures, ...removal.failures], messages)
+  };
+}
+async function closeCompletedEpics(loaded, now, messages) {
+  const plan = planEpicClosing(loaded.tasks, loaded.errors);
+  const index = buildIndex(loaded.tasks);
+  const closed = [];
+  const failures = [];
+  for (const { epic, childIds } of plan.close) {
+    const closure = epicDoneClosure(childIds, messages);
+    const result = await updateTaskInIndex(index, { id: epic.id, changes: { status: "done" }, expectedVersion: epic.version, now, closure, via: "sweep" });
+    if (result.ok) closed.push(epic.id);
+    else failures.push(sweepFailure(epic.id, result));
+  }
+  const leftOpen = /* @__PURE__ */ new Set([...plan.waiting.map(({ epic }) => epic.id), ...failures.map(({ id }) => id)]);
+  const waitingProjects = new Set(plan.waiting.map(({ epic }) => epic.projectId));
+  const blockingFiles = loaded.errors.filter((error) => waitingProjects.has(error.projectId)).map((error) => error.path);
+  return { closed, failures, leftOpen, blockingFiles };
+}
+async function repairRemainingTasks(tasks, expired, now) {
+  const index = buildIndex(tasks);
+  const expiredIds = new Set(expired.map((task) => task.id));
+  const failures = [];
+  const stillReferenced = /* @__PURE__ */ new Set();
+  for (const task of tasks.filter((candidate) => !expiredIds.has(candidate.id))) {
+    const cleanup = referenceCleanup(task, (id) => expiredIds.has(id));
+    if (cleanup === null && !lacksClosedDate(task)) continue;
+    const result = await updateTaskInIndex(index, { id: task.id, changes: cleanup ?? {}, expectedVersion: task.version, now, via: "sweep" });
+    if (result.ok) continue;
+    failures.push(sweepFailure(task.id, result));
+    for (const id of referencedIds(task)) if (expiredIds.has(id)) stillReferenced.add(id);
+  }
+  return { failures, stillReferenced };
+}
+function referencedIds(task) {
+  return [...task.epic === void 0 ? [] : [task.epic], ...task.blockedBy, ...task.related];
+}
+async function removeExpired(expired, now) {
+  const deleted = [];
+  const failures = [];
+  for (const task of expired) {
+    if (await withFileLock(task.path, () => removeIfUnchanged(task.path, task.version))) {
+      deleted.push(task.id);
+      await appendJournal(dirname4(task.path), [deletedEvent(task, now, "sweep")]);
+    } else failures.push({ id: task.id, reason: "conflict" });
+  }
+  return { deleted, failures };
+}
+function sweepFailure(id, failure) {
+  switch (failure.reason) {
+    case "invalid":
+      return { id, reason: "invalid", errors: failure.errors };
+    case "conflict":
+    case "not-found":
+      return { id, reason: "conflict" };
+  }
+}
+function failureLists(failures, messages) {
+  const firstPerTask = failures.filter((failure, position) => failures.findIndex(({ id }) => id === failure.id) === position);
+  return {
+    conflicts: firstPerTask.filter((failure) => failure.reason === "conflict").map(({ id }) => id),
+    invalid: firstPerTask.flatMap((failure) => failure.reason === "invalid" ? [{ id: failure.id, errors: failure.errors.map(messages.problem) }] : [])
+  };
+}
+function lacksClosedDate(task) {
+  return isClosed(task.status) && task.closed === void 0;
+}
+async function reserveNumbers(projects, expired) {
+  const reserved = /* @__PURE__ */ new Set();
+  for (const project of projects) {
+    const numbers = expired.filter((task) => task.projectId === project.id).flatMap((task) => parseId(task.id)?.number ?? []);
+    if (numbers.length === 0 || await reserveIssuedUpTo(project, Math.max(...numbers))) reserved.add(project.id);
+  }
+  return reserved;
+}
+
+// src/server/app.ts
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono as Hono3 } from "hono";
+import { join as join14 } from "node:path";
+
+// src/server/api.ts
+import { Hono as Hono2 } from "hono";
+import { streamSSE } from "hono/streaming";
+
+// src/core/api/contract.ts
+import { z as z8 } from "zod";
+var idList = z8.array(taskIdSchema);
+var taskChangesSchema = z8.strictObject({
+  title: z8.string().optional(),
+  type: z8.enum(TASK_TYPES).optional(),
+  status: z8.enum(TASK_STATUSES).optional(),
+  priority: z8.enum(PRIORITIES).optional(),
+  tags: z8.array(z8.string()).optional(),
+  epic: taskIdSchema.nullable().optional(),
+  blockedBy: idList.optional(),
+  related: idList.optional(),
+  body: z8.string().optional(),
+  category: z8.enum(TASK_CATEGORIES).nullable().optional()
+});
+var projectActiveSchema = z8.strictObject({ active: z8.boolean() });
+var projectDeleteSchema = z8.strictObject({ confirm: z8.string() });
+var settingsSchema2 = z8.strictObject({ language: z8.enum(LANGUAGES) });
+var updateTaskRequestSchema = z8.strictObject({
+  version: z8.string().min(1),
+  changes: taskChangesSchema
+});
+
+// src/core/check/graph-health.ts
+import { join as join12 } from "node:path";
+
+// src/core/graph/code-graph.ts
+import { existsSync, realpathSync } from "node:fs";
+import { join as join10 } from "node:path";
+var GRAPH_FILE = join10(".code-review-graph", "graph.db");
+function hasCodeGraph(repo) {
+  return existsSync(join10(repo, GRAPH_FILE));
+}
+var SUPPORTED_SCHEMA = "13";
+function openCodeGraph(repo) {
+  let db = null;
+  try {
+    const { DatabaseSync: SqliteDatabase } = process.getBuiltinModule("node:sqlite");
+    db = new SqliteDatabase(join10(repo, GRAPH_FILE), { readOnly: true });
+    const meta = readMetadata(db);
+    const root = meta.get("repo_root");
+    if (meta.get("schema_version") !== SUPPORTED_SCHEMA || root === void 0 || realpathSync(root) !== realpathSync(repo)) {
+      db.close();
+      return null;
+    }
+    return codeGraph(db, root);
+  } catch {
+    closeQuietly(db);
+    return null;
+  }
+}
+function readMetadata(db) {
+  const rows = db.prepare("select key, value from metadata").all();
+  return new Map(rows.map((row) => [row.key, row.value]));
+}
+function codeGraph(db, repo) {
+  const fileNode = db.prepare("select file_hash from nodes where kind = 'File' and file_path = ?");
+  const enclosing = db.prepare(
+    "select qualified_name, line_start, line_end from nodes where file_path = ? and kind != 'File' and line_start <= ? and line_end >= ? order by line_end - line_start asc limit 1"
+  );
+  const fileState = (path, fileHash2) => {
+    const row = ask(fileNode, (statement) => statement.get(join10(repo, path)), void 0);
+    if (row === void 0) return "absent";
+    return row.file_hash === fileHash2 ? "fresh" : "changed";
+  };
+  return {
+    fileState,
+    symbolAt(path, line, fileHash2) {
+      if (fileState(path, fileHash2) !== "fresh") return null;
+      const file = join10(repo, path);
+      const row = ask(enclosing, (statement) => statement.get(file, line, line), void 0);
+      return row === void 0 ? null : { qualifiedName: row.qualified_name, from: row.line_start, to: row.line_end };
+    },
+    close() {
+      closeQuietly(db);
+    }
+  };
+}
+function ask(statement, run, fallback) {
+  try {
+    return run(statement);
+  } catch {
+    return fallback;
+  }
+}
+function closeQuietly(db) {
+  try {
+    db?.close();
+  } catch {
+    return;
+  }
+}
+
+// src/core/check/anchor.ts
+var LINE_CONTEXT = 2;
+function sourceRange(source) {
+  const span = source === void 0 ? null : sourceSpan(source);
+  return span === null ? null : { from: span.first, to: span.last };
+}
+function sourceSpan(source) {
+  const match = SOURCE_LINES.exec(source);
+  if (match === null) return null;
+  const first = Number(match[1]);
+  return match[2] === void 0 ? { first, last: first, context: LINE_CONTEXT } : { first, last: Number(match[2]), context: 0 };
+}
+
+// src/core/model/query.ts
+var STALE_LOW_DAYS = 30;
+function staleLowTasks(tasks, now) {
+  const cutoff = now.getTime() - STALE_LOW_DAYS * DAY_MS;
+  return tasks.filter((task) => task.type === "task" && task.status === "backlog" && task.priority === "low" && Date.parse(task.created) < cutoff).sort((a, b) => Date.parse(a.created) - Date.parse(b.created));
+}
+
+// src/core/check/candidates.ts
+function isReviewable(task) {
+  return task.type === "task" && (task.status === "backlog" || task.status === "blocked");
+}
+function sourcePath(source) {
+  return source.replace(SOURCE_LINES, "").replace(/^\.\//, "").replace(/\/+$/, "");
+}
+
+// src/core/check/project-repo.ts
+import { access, readFile as readFile2 } from "node:fs/promises";
+
+// src/core/git/run.ts
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+
+// src/core/git/limit.ts
+function createLimiter(maxRunning) {
+  let running = 0;
+  const waiting = [];
+  const release = () => {
+    const next = waiting.shift();
+    if (next === void 0) running--;
+    else next();
+  };
+  const acquire2 = () => {
+    if (running < maxRunning) {
+      running++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => waiting.push(resolve));
+  };
+  return async (task) => {
+    await acquire2();
+    try {
+      return await task();
+    } finally {
+      release();
+    }
+  };
+}
+
+// src/core/git/run.ts
+var RECORD = "";
+var FIELD = "";
+var runFile = promisify(execFile);
+var GIT_OUTPUT_LIMIT = 64 * 1024 * 1024;
+var GREP_NO_MATCH_EXIT = 1;
+var GIT_PROCESS_LIMIT = 8;
+var gitProcessSlot = createLimiter(GIT_PROCESS_LIMIT);
+var runGit = (repo, args, input) => gitProcessSlot(async () => {
+  try {
+    const running = runFile("git", gitArgs(repo, args), { maxBuffer: GIT_OUTPUT_LIMIT });
+    running.child.stdin?.on("error", ignoreStdinOfExitedGit).end(input);
+    const { stdout } = await running;
+    return stdout;
+  } catch (error) {
+    return args[0] === "grep" && exitCodeOf(error) === GREP_NO_MATCH_EXIT ? "" : null;
+  }
+});
+function gitArgs(repo, args) {
+  return ["-C", repo, "--no-optional-locks", "-c", "core.quotePath=false", ...args];
+}
+async function resolveCommits(git, repo, revisions) {
+  if (revisions.length === 0) return /* @__PURE__ */ new Map();
+  const output = await git(repo, ["cat-file", "--batch-check"], revisions.map((revision) => `${revision}^{commit}
+`).join(""));
+  if (output === null) return null;
+  const lines = output.split("\n");
+  return new Map(
+    revisions.flatMap((revision, index) => {
+      const [objectName = "", objectType] = lines[index]?.split(" ") ?? [];
+      return objectType === "commit" ? [[revision, objectName]] : [];
+    })
+  );
+}
+function ignoreStdinOfExitedGit() {
+  return void 0;
+}
+function exitCodeOf(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
+
+// src/core/check/project-repo.ts
+async function findRepo(project, home2) {
+  for (const repo of project.repos.map((path) => expandHome(path, home2))) {
+    if (await access(repo).then(() => true, () => false)) return repo;
+  }
+  return void 0;
+}
+
+// src/core/check/symbol-filter.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join as join11 } from "node:path";
+function symbolLookup(repo, graph) {
+  if (graph === null) return () => null;
+  const known = /* @__PURE__ */ new Map();
+  return (task) => {
+    const cached = known.get(task.id);
+    if (cached !== void 0) return cached;
+    const symbol = lookUp(repo, graph, task);
+    known.set(task.id, symbol);
+    return symbol;
+  };
+}
+function lookUp(repo, graph, task) {
+  const range = sourceRange(task.source);
+  if (task.source === void 0 || range === null) return null;
+  const path = sourcePath(task.source);
+  const hash = fileHash(join11(repo, path));
+  return hash === null ? null : graph.symbolAt(path, range.from, hash);
+}
+function fileHash(path) {
+  try {
+    return createHash2("sha256").update(readFileSync(path)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+
+// src/core/check/graph-health.ts
+async function projectGraphHealth(project, tasks, home2) {
+  return graphHealth(await findRepo(project, home2), tasks.filter((task) => task.projectId === project.id));
+}
+function graphHealth(repo, tasks) {
+  const pinned = tasks.filter((task) => isReviewable(task) && sourceRange(task.source) !== null);
+  const unusable = (state) => ({ state, pinned: pinned.length, resolved: 0 });
+  if (repo === void 0 || !hasCodeGraph(repo)) return unusable("none");
+  const graph = openCodeGraph(repo);
+  if (graph === null) return unusable("unreadable");
+  try {
+    const symbolOf = symbolLookup(repo, graph);
+    const resolved = pinned.filter((task) => symbolOf(task) !== null).length;
+    return { state: isStale(repo, graph, pinned) ? "stale" : "fresh", pinned: pinned.length, resolved };
+  } finally {
+    graph.close();
+  }
+}
+function isStale(repo, graph, pinned) {
+  const paths = [...new Set(pinned.flatMap((task) => task.source === void 0 ? [] : [sourcePath(task.source)]))];
+  const states = paths.map((path) => {
+    const hash = fileHash(join12(repo, path));
+    return hash === null ? "absent" : graph.fileState(path, hash);
+  });
+  const count3 = (state) => states.filter((candidate) => candidate === state).length;
+  return count3("changed") > count3("fresh");
+}
+
+// src/server/messages.en.ts
+var serverEn = {
+  taskNotFound: (id) => `Task ${id} not found`,
+  taskChangedOnDisk: "The task changed on disk",
+  projectNotFound: (id) => `Project ${id} not found`,
+  confirmMismatch: "Confirmation does not match the project id",
+  bodyNotParsed: "Request body could not be parsed: JSON expected",
+  unknownRoute: (path) => `Unknown API route: ${path}`,
+  hostRejected: (host) => `Requests from host ${host} are not accepted`,
+  jsonContentTypeExpected: "Content-Type: application/json is expected",
+  runsTrimFailed: (detail) => `Could not trim the run log: ${detail}`,
+  serverStarted: (port, root) => `p-backlog: http://localhost:${port}
+Backlog directory: ${root}
+`,
+  settingsFileInvalid: (path) => `${path} could not be parsed, the language for this run was detected automatically. The file was not changed \u2014 fix it manually.`,
+  sweepFailed: (detail) => `Could not delete closed tasks: ${detail}`,
+  closedEpics: (ids) => `Closed completed epics: ${ids}`,
+  epicsBlockedByFiles: (paths) => `Epics will not close until these files are fixed: ${paths}`,
+  deletedClosedTasks: (ids) => `Deleted closed tasks: ${ids}`,
+  conflictedDuringSweep: (ids) => `Tasks changed during the sweep, will retry next time: ${ids}`,
+  invalidAfterSweep: (detail) => `Could not update tasks, fix the files: ${detail}`,
+  transcriptsScanFailed: (detail) => `Could not read Claude Code transcripts: ${detail}`,
+  watcherError: (root, detail) => `Watcher for directory ${root}: ${detail}`,
+  listenFailed: (reason) => `p-backlog failed to start: ${reason}`,
+  portBusy: (port) => `port ${port} is already in use`,
+  codeCacheReadFailed: (detail) => `Could not read the git cache: ${detail}`,
+  codeCacheWriteFailed: (detail) => `Could not save the git cache: ${detail}`
+};
+
+// src/server/messages.ts
+function serverMessages(language) {
+  return language === "ru" ? serverRu : serverEn;
+}
+function serverLanguage(root) {
+  return settledLanguage(root, process.env).then((settled) => settled.language);
+}
+
+// src/server/report-cache.ts
+function createReportCache({ ttlMs, now }) {
+  let entries = /* @__PURE__ */ new Map();
+  return {
+    get: (key, compute) => {
+      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));
+      return value;
+    },
+    clear: () => {
+      entries = /* @__PURE__ */ new Map();
+    }
+  };
+}
+
+// src/server/stats-api.ts
+import { Hono } from "hono";
+
+// src/core/code/code-cache.ts
+import { join as join13 } from "node:path";
+import { z as z9 } from "zod";
+var CODE_CACHE_FILE = ".code-cache.json";
+var CODE_CACHE_VERSION = 1;
+var repoCodeSchema = z9.object({
+  commits: z9.array(z9.array(z9.string())),
+  lines: z9.array(z9.object({ path: z9.string(), lines: z9.number() })),
+  units: z9.array(z9.object({ date: z9.string(), lines: z9.number() }))
+});
+var fixCommitSchema = z9.object({ date: z9.string(), byAgent: z9.boolean(), lines: z9.number(), testLines: z9.number() });
+var snapshotSchema = z9.object({
+  version: z9.literal(CODE_CACHE_VERSION),
+  repos: z9.record(z9.string(), z9.object({ key: z9.string(), code: repoCodeSchema })),
+  fixes: z9.record(z9.string(), fixCommitSchema)
+});
+function emptyCodeCache() {
+  return { repos: {}, fixes: {} };
+}
+function createCodeCacheFile(root) {
+  const path = join13(root, CODE_CACHE_FILE);
+  return {
+    read: async () => {
+      const snapshot = await readJsonFile(path, snapshotSchema);
+      return snapshot === null ? emptyCodeCache() : { repos: snapshot.repos, fixes: snapshot.fixes };
+    },
+    write: (snapshot) => writeFileAtomic(path, JSON.stringify({ version: CODE_CACHE_VERSION, ...snapshot }))
+  };
+}
+
+// src/core/stats/history.ts
+function taskHistories(tasks, journals) {
+  const known = /* @__PURE__ */ new Map();
+  const entry = (id, projectId) => {
+    const existing = known.get(id);
+    if (existing) return existing;
+    const created = { projectId, categoryEvents: [], transitions: [], candidates: [], verifications: [], filtered: [] };
+    known.set(id, created);
+    return created;
+  };
+  for (const task of tasks) entry(task.id, task.projectId).final = task;
+  for (const { projectId, events } of journals) {
+    for (const event of events) {
+      const item = entry(event.task, projectId);
+      if (event.kind === "created") item.created = event;
+      if (event.kind === "deleted") item.final ??= event.snapshot;
+      if (event.kind === "category") item.categoryEvents.push({ at: Date.parse(event.at), to: event.to });
+      if (event.kind === "status") {
+        item.transitions.push({ at: Date.parse(event.at), from: event.from, to: event.to, resolution: event.resolution, via: event.via });
+      }
+      if (event.kind === "candidate") item.candidates.push({ at: Date.parse(event.at), evidence: event.evidence, method: recordedMethodOf(event), match: event.match ?? "unknown" });
+      if (event.kind === "candidate-filtered") item.filtered.push(Date.parse(event.at));
+      if (event.kind === "verified") item.verifications.push(Date.parse(event.at));
+    }
+  }
+  return [...known.entries()].flatMap(([id, item]) => historyOf(id, item));
+}
+function isOpenAt(history, moment) {
+  if (history.createdAt > moment) return false;
+  const last = history.transitions.filter((transition) => transition.at <= moment).at(-1);
+  if (last !== void 0) return !isClosed(last.to);
+  const first = history.transitions[0];
+  return first?.from === void 0 || !isClosed(first.from);
+}
+function isClosing(transition) {
+  return isClosed(transition.to) && (transition.from === void 0 || !isClosed(transition.from));
+}
+function closingsOf(history) {
+  return history.transitions.filter(isClosing);
+}
+function isFixedNow(history) {
+  return isClosed(history.finalStatus) && closingsOf(history).at(-1)?.resolution === "fixed";
+}
+function reopeningsOf(history) {
+  return history.transitions.filter((transition) => transition.from !== void 0 && isClosed(transition.from) && !isClosed(transition.to));
+}
+function historyOf(id, { projectId, final, created, categoryEvents, transitions, candidates, verifications, filtered }) {
+  const createdIso = final?.created ?? created?.at;
+  const type = final?.type ?? created?.type;
+  if (createdIso === void 0 || type === void 0) return [];
+  const ordered = [...transitions].sort((a, b) => a.at - b.at);
+  return [
+    {
+      id,
+      projectId,
+      type,
+      createdAt: Date.parse(createdIso),
+      source: final?.source ?? created?.source,
+      reason: final?.reason,
+      finalStatus: final?.status ?? "cancelled",
+      transitions: [...ordered, ...restoredTransitions(final, ordered, Date.parse(createdIso))],
+      category: categoryOf(final, created, categoryEvents),
+      found: created?.found,
+      branch: created?.origin?.branch,
+      candidates: [...candidates].sort((a, b) => a.at - b.at),
+      verifications: [...verifications].sort((a, b) => a - b),
+      filtered: [...filtered].sort((a, b) => a - b)
+    }
+  ];
+}
+function categoryOf(final, created, categoryEvents) {
+  if (final !== void 0) return final.category;
+  const lastCategoryEvent = [...categoryEvents].sort((a, b) => a.at - b.at).at(-1);
+  return lastCategoryEvent !== void 0 ? lastCategoryEvent.to : created?.category;
+}
+function restoredTransitions(final, ordered, createdAt) {
+  const last = ordered.at(-1);
+  const lastClosed = last !== void 0 && isClosed(last.to);
+  if (final === void 0) return lastClosed ? [] : [{ at: last?.at ?? createdAt, to: "cancelled", via: "unknown" }];
+  if (isClosed(final.status)) {
+    if (lastClosed) return [];
+    const at = final.closed === void 0 ? last?.at ?? createdAt : Date.parse(final.closed);
+    return [{ at, to: final.status, resolution: final.resolution, via: "unknown" }];
+  }
+  if (!lastClosed || last === void 0) return [];
+  return [{ at: last.at + 1, from: last.to, to: final.status, via: "unknown" }];
+}
+
+// src/core/stats/code/fixes.ts
+var HASH_PATTERN = /(?<![\p{L}\p{N}])[0-9a-f]{7,40}(?![\p{L}\p{N}])/gu;
+function reasonHashes(reason) {
+  return reason === void 0 ? [] : [...reason.matchAll(HASH_PATTERN)].map((match) => match[0]);
+}
+function fixKey(projectId, hash) {
+  return `${projectId} ${hash}`;
+}
+function fixRequests(histories, period2) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const history of fixedWithin(histories, period2)) {
+    const hashes = byProject.get(history.projectId) ?? /* @__PURE__ */ new Set();
+    for (const hash of reasonHashes(history.reason)) hashes.add(hash);
+    byProject.set(history.projectId, hashes);
+  }
+  return [...byProject.entries()].filter(([, hashes]) => hashes.size > 0).map(([projectId, hashes]) => ({ projectId, hashes: [...hashes] }));
+}
+function fixCommitEntry(history, commits) {
+  return reasonHashes(history.reason).map((hash) => ({ key: fixKey(history.projectId, hash), commit: commits.get(fixKey(history.projectId, hash)) })).flatMap(({ key, commit }) => commit === void 0 ? [] : [{ key, commit }]).at(0);
+}
+function fixedWithin(histories, period2) {
+  return histories.filter((history) => {
+    const closing = closingsOf(history).at(-1);
+    return isFixedNow(history) && closing !== void 0 && period2.contains(closing.at);
+  });
+}
+
+// src/core/code/code-window.ts
+var CHURN_DAYS = 90;
+
+// src/core/stats/numbers.ts
+var TAIL_FRACTION = 0.9;
+function median(values) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 1) return sorted[middle] ?? null;
+  return ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2;
+}
+function nearestRank(values, fraction) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.ceil(fraction * sorted.length) - 1] ?? null;
+}
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function smallest(values) {
+  return values.reduce((least, value) => least === null || value < least ? value : least, null);
+}
+function daysBetween(from, to) {
+  return (to - from) / DAY_MS;
+}
+function groupBy(items, keyOf) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyOf(item);
+    const group = groups.get(key);
+    if (group === void 0) groups.set(key, [item]);
+    else group.push(item);
+  }
+  return groups;
+}
+function countBy(items, keyOf, amountOf = () => 1) {
+  const totals2 = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyOf(item);
+    totals2.set(key, (totals2.get(key) ?? 0) + amountOf(item));
+  }
+  return totals2;
+}
+
+// src/core/code/test-paths.ts
+var TEST_DIRECTORIES = /* @__PURE__ */ new Set(["test", "tests", "__tests__", "e2e", "spec"]);
+var TEST_FILE_NAMES = [/\.(test|spec)\.[^.]+$/, /_test\.[^.]+$/, /^test_.+\.py$/];
+function isTestPath(numstatPath) {
+  const segments = currentPath(numstatPath).split("/");
+  const fileName = segments.at(-1) ?? "";
+  return segments.slice(0, -1).some((segment) => TEST_DIRECTORIES.has(segment)) || TEST_FILE_NAMES.some((pattern) => pattern.test(fileName));
+}
+function currentPath(numstatPath) {
+  return numstatPath.replace(/\{[^}]* => ([^}]*)\}/g, "$1").replace(/^.* => /, "").replace(/\/\//g, "/");
+}
+
+// src/core/code/git-code.ts
+var LOCK_FILES = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml"];
+var LOCK_EXCLUDES = LOCK_FILES.map((name) => `:!*${name}`);
+var NON_CODE_EXTENSIONS = [".md", ".mdx", ".svg"];
+var CHURN_EXCLUDES = [...LOCK_EXCLUDES, ...NON_CODE_EXTENSIONS.map((ext) => `:!*${ext}`)];
+var HEAD = "HEAD";
+var MAIN_REFS = ["origin/HEAD", "main", "master"];
+var AGENT_TRAILER = /^claude/i;
+var GREP_PREFIX = "HEAD:";
+async function readRefs(git, repo) {
+  const commits = await resolveCommits(git, repo, [HEAD, ...MAIN_REFS]) ?? /* @__PURE__ */ new Map();
+  const head = commits.get(HEAD) ?? null;
+  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 [log, 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)
+  ]);
+  if (log === null || grep === null) return null;
+  return { commits: parseCommits(log), lines: parseLines(grep), units };
+}
+async function readFixCommits(git, repo, hashes) {
+  const fullHashes = await resolveCommits(git, repo, hashes);
+  if (fullHashes === null) return null;
+  return fullHashes.size === 0 ? /* @__PURE__ */ new Map() : readFixBatch(git, repo, fullHashes);
+}
+async function readFixBatch(git, repo, fullHashes) {
+  const commits = [...new Set(fullHashes.values())];
+  const [headers, stats] = await Promise.all([
+    git(repo, ["log", "--no-walk=unsorted", ...commits, `--format=tformat:${RECORD}%H${FIELD}%cI${FIELD}%(trailers:key=Co-authored-by,valueonly,separator=${FIELD})`, "--"]),
+    git(repo, ["log", "--no-walk=unsorted", ...commits, `--format=tformat:${RECORD}%H`, "--numstat", "--diff-merges=first-parent", "--relative", "--", ".", ...CHURN_EXCLUDES])
+  ]);
+  if (headers === null || stats === null) return null;
+  const changedLines = new Map(parseFixStats(stats));
+  const byFullHash = new Map(parseFixHeaders(headers, changedLines));
+  return new Map(
+    [...fullHashes].flatMap(([hash, full]) => {
+      const commit = byFullHash.get(full);
+      return commit === void 0 ? [] : [[hash, commit]];
+    })
+  );
+}
+function parseFixHeaders(output, changedLines) {
+  return records(output).map((record) => {
+    const [full = "", date = "", ...trailers] = record.split("\n")[0]?.split(FIELD) ?? [];
+    const changed = changedLines.get(full) ?? { lines: 0, testLines: 0 };
+    return [full, { date, byAgent: trailers.some((trailer) => AGENT_TRAILER.test(trailer.trim())), ...changed }];
+  });
+}
+function parseFixStats(output) {
+  return records(output).map((record) => {
+    const [full = "", ...rows] = record.split("\n");
+    return [full.trim(), { lines: numstatLines(rows), testLines: numstatLines(rows.filter((row) => isTestPath(row.split("	")[2] ?? ""))) }];
+  });
+}
+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)));
+}
+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");
+    return { path, lines: Number(count3) };
+  });
+}
+
+// src/core/code/code-source.ts
+function createCodeSource({ home: home2, git = runGit, store, onError = () => {
+} }) {
+  const repoCache = /* @__PURE__ */ new Map();
+  const fixCache = /* @__PURE__ */ new Map();
+  let changed = false;
+  let restored = 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);
+    });
+    return restored;
+  };
+  const dropStaleFixes = (now, requested) => {
+    const oldest = now.getTime() - CHURN_DAYS * DAY_MS;
+    for (const [key, commit] of fixCache) {
+      if (requested.has(key) || Date.parse(commit.date) >= oldest) continue;
+      fixCache.delete(key);
+      changed = true;
+    }
+  };
+  const persist = async () => {
+    if (store === void 0 || !changed) return;
+    changed = false;
+    await store.write({ repos: Object.fromEntries(repoCache), fixes: Object.fromEntries(fixCache) }).catch((error) => onError("write", error));
+  };
+  const inFlight = /* @__PURE__ */ new Map();
+  const repoCode = (repo, now) => {
+    const running = inFlight.get(repo);
+    if (running !== void 0) return running;
+    const started = readRepoOnce(repo, now).finally(() => inFlight.delete(repo));
+    inFlight.set(repo, started);
+    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 });
+    changed = true;
+    return { key, code };
+  };
+  const fixCommitsOf = async (repo, hashes) => {
+    const unknown = hashes.filter((hash) => !fixCache.has(`${repo} ${hash}`));
+    if (unknown.length === 0) return;
+    const found = await readFixCommits(git, repo, unknown);
+    for (const [hash, commit] of found ?? []) {
+      fixCache.set(`${repo} ${hash}`, commit);
+      changed = true;
+    }
+  };
+  const fixReposOf = async (projects, now) => {
+    const refsOf = /* @__PURE__ */ new Map();
+    const refsOnce = (repo) => {
+      const known = refsOf.get(repo) ?? readRefs(git, repo);
+      refsOf.set(repo, known);
+      return known;
+    };
+    const entries = await Promise.all(
+      projects.map(async (project) => {
+        const repos = await Promise.all(
+          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) }];
+          })
+        );
+        return [project.id, repos.flat()];
+      })
+    );
+    return new Map(entries);
+  };
+  return {
+    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))}`));
+      return states.join(" ");
+    },
+    collect: async (projects, now) => {
+      await restore();
+      const unavailableRepos = [];
+      const projectCodes = [];
+      const seenUnavailable = /* @__PURE__ */ new Set();
+      const scanned = await Promise.all(
+        projects.map(async (project) => ({
+          project,
+          repos: await Promise.all(project.repos.map(async (repo) => ({ repo, read: await repoCode(expandHome(repo, home2), now) })))
+        }))
+      );
+      for (const { project, repos } of scanned) {
+        const readable = [];
+        for (const { repo, read } of repos) {
+          if (read !== null) {
+            readable.push(read.code);
+          } else if (!seenUnavailable.has(repo)) {
+            seenUnavailable.add(repo);
+            unavailableRepos.push(repo);
+          }
+        }
+        projectCodes.push({ projectId: project.id, name: project.name, repos: readable });
+      }
+      await persist();
+      return { projects: projectCodes, unavailableRepos };
+    },
+    fixCommits: async (projects, requests, now) => {
+      await restore();
+      const reposOf = await fixReposOf(projects, now);
+      await Promise.all(requests.flatMap(({ projectId, hashes }) => (reposOf.get(projectId) ?? []).map(({ repo }) => fixCommitsOf(repo, 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}`);
+          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);
+        }
+      }
+      dropStaleFixes(now, requested);
+      await persist();
+      return found;
+    }
+  };
+}
+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();
+  } catch (error) {
+    onError(error);
+    return emptyCodeCache();
+  }
+}
+
+// src/core/stats/scope.ts
+function statsScope({ tasks, journals, projectId }) {
+  const inScope = (candidate) => projectId === void 0 || candidate === projectId;
+  const scopedJournals = journals.filter((journal) => inScope(journal.projectId));
+  const scopedTasks = tasks.filter((task) => inScope(task.projectId));
+  const journalStart = smallest(scopedJournals.flatMap((journal) => journal.events.map((event) => Date.parse(event.at))));
+  return {
+    tasks: scopedTasks,
+    histories: taskHistories(scopedTasks, scopedJournals).filter((history) => inScope(history.projectId)),
+    journalStart,
+    journalSince: journalStart === null ? null : formatLocalIso(new Date(journalStart)),
+    invalidJournalLines: sum(scopedJournals.map((journal) => journal.invalidLines))
+  };
+}
+function reportBase(input) {
+  const scope = statsScope(input);
+  const histories = scope.histories.filter((history) => history.type === "task");
+  const tasks = scope.tasks.filter((task) => task.type === "task");
+  return {
+    scope,
+    histories,
+    tasks,
+    openTasks: tasks.filter((task) => !isClosed(task.status)),
+    head: { taskCount: histories.length, journalSince: scope.journalSince, invalidJournalLines: scope.invalidJournalLines }
+  };
+}
+
+// src/core/stats/period.ts
+function period(from, to) {
+  return { from, to, contains: (moment) => moment >= from && moment <= to };
+}
+function consecutivePeriods(starts, lastTo) {
+  return starts.map((start, index) => period(start.getTime(), (starts[index + 1]?.getTime() ?? lastTo + 1) - 1));
+}
+
+// src/core/stats/weeks.ts
+var STATS_WEEKS = 12;
+var DAYS_PER_WEEK = 7;
+var WEEK_MS = DAYS_PER_WEEK * DAY_MS;
+var MONDAY = 1;
+function weekStarts(now, count3) {
+  const monday = new Date(now.getFullYear(), now.getMonth(), now.getDate() - (now.getDay() + DAYS_PER_WEEK - MONDAY) % DAYS_PER_WEEK);
+  return Array.from({ length: count3 }, (_, index) => new Date(monday.getFullYear(), monday.getMonth(), monday.getDate() - DAYS_PER_WEEK * (count3 - 1 - index)));
+}
+function statsPeriod(now) {
+  return period(weekStarts(now, STATS_WEEKS)[0]?.getTime() ?? now.getTime(), now.getTime());
+}
+function weekWindows(now, count3 = STATS_WEEKS) {
+  return consecutivePeriods(weekStarts(now, count3), now.getTime());
+}
+function weeklyFlow(histories, now) {
+  const closings = histories.flatMap(closingsOf);
+  return weekWindows(now).map((week) => ({
+    start: formatLocalIso(new Date(week.from)),
+    created: histories.filter((history) => week.contains(history.createdAt)).length,
+    closed: closings.filter((closing) => week.contains(closing.at)).length,
+    openAtEnd: histories.filter((history) => isOpenAt(history, week.to)).length
+  }));
+}
+
+// src/core/stats/format.ts
+function projectLabel(projectId, label, withProject) {
+  return withProject ? `${projectId} \xB7 ${label}` : label;
+}
+
+// src/core/stats/breakdowns.ts
+var HOTSPOT_LIMIT = 8;
+var STALE_URGENT_DAYS = 7;
+var AGE_LIMITS = [
+  { bucket: "week", belowDays: DAYS_PER_WEEK },
+  { bucket: "month", belowDays: 30 },
+  { bucket: "quarter", belowDays: 90 },
+  { bucket: "older", belowDays: Number.POSITIVE_INFINITY }
+];
+function folderOf(source) {
+  const path = source.replace(/(:\d+)+$/, "");
+  const slash = path.lastIndexOf("/");
+  return slash === -1 ? path : path.slice(0, slash);
+}
+function hotspots(openTasks, withProject) {
+  const folders = openTasks.flatMap((task) => {
+    if (task.source === void 0) return [];
+    const folder = folderOf(task.source);
+    return [projectLabel(task.projectId, folder, withProject)];
+  });
+  return {
+    folders: topCounts(folders).map(([label, count3]) => ({ label, count: count3 })),
+    tags: topCounts(openTasks.flatMap((task) => task.tags)).map(([tag, count3]) => ({ tag, count: count3 }))
+  };
+}
+function ageBreakdown(openTasks, now) {
+  const ageOf = (task) => daysBetween(Date.parse(task.created), now.getTime());
+  const bucketOf = (task) => AGE_LIMITS.find(({ belowDays }) => ageOf(task) < belowDays)?.bucket ?? "older";
+  return {
+    buckets: AGE_LIMITS.map(({ bucket }) => ({ bucket, byPriority: priorityCounts(openTasks.filter((task) => bucketOf(task) === bucket)) })),
+    urgentStale: urgentStaleCount(openTasks, now)
+  };
+}
+function urgentStaleCount(openTasks, now) {
+  return openTasks.filter((task) => (task.priority === "critical" || task.priority === "high") && daysBetween(Date.parse(task.created), now.getTime()) >= STALE_URGENT_DAYS).length;
+}
+function closingBreakdown(histories, period2) {
+  const closings = histories.flatMap(closingsOf).filter((closing) => period2.contains(closing.at));
+  const created = histories.filter((history) => period2.contains(history.createdAt));
+  const byReason = { done: 0, fixed: 0, obsolete: 0, duplicate: 0, cancelled: 0 };
+  for (const closing of closings) byReason[closingReason(closing)] += 1;
+  return {
+    byReason,
+    duplicateShare: closings.length === 0 ? null : byReason.duplicate / closings.length,
+    withoutSourceShare: created.length === 0 ? null : created.filter((history) => history.source === void 0).length / created.length,
+    reopened: histories.flatMap(reopeningsOf).filter((reopening) => period2.contains(reopening.at)).length
+  };
+}
+function closingReason(closing) {
+  if (closing.resolution === "fixed" || closing.resolution === "obsolete" || closing.resolution === "duplicate") return closing.resolution;
+  return closing.to === "cancelled" ? "cancelled" : "done";
+}
+function priorityCounts(tasks) {
+  return Object.fromEntries(PRIORITIES.map((priority) => [priority, tasks.filter((task) => task.priority === priority).length]));
+}
+function topCounts(values) {
+  const counts = countBy(values, (value) => value);
+  return [...counts.entries()].sort(([a, countA], [b, countB]) => countB - countA || a.localeCompare(b)).slice(0, HOTSPOT_LIMIT);
+}
+
+// src/core/stats/weights.ts
+var PRIORITY_WEIGHT = { critical: 8, high: 4, medium: 2, low: 1 };
+
+// src/core/stats/code/churn.ts
+var CHURN_LIMIT = 8;
+function churn(openTasks, projects, withProject) {
+  return projects.flatMap((project) => {
+    const commits = folderCommits(project);
+    const debt = folderDebt(openTasks.filter((task) => task.projectId === project.projectId));
+    return [...debt.entries()].map(([folder, { tasks, weight }]) => {
+      const folderChanges = commits.get(folder) ?? 0;
+      return { label: projectLabel(project.projectId, folder, withProject), commits: folderChanges, tasks, weight, score: folderChanges * weight };
+    });
+  }).filter((row) => row.score > 0).sort((a, b) => b.score - a.score || a.label.localeCompare(b.label)).slice(0, CHURN_LIMIT);
+}
+function folderCommits(project) {
+  const touched = project.repos.flatMap((repo) => repo.commits).flatMap((files) => [...new Set(files.map(folderOf))]);
+  return countBy(touched, (folder) => folder);
+}
+function folderDebt(tasks) {
+  const debt = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (task.source === void 0) continue;
+    const folder = folderOf(task.source);
+    const current = debt.get(folder) ?? { tasks: 0, weight: 0 };
+    debt.set(folder, { tasks: current.tasks + 1, weight: current.weight + PRIORITY_WEIGHT[task.priority] });
+  }
+  return debt;
+}
+
+// src/core/stats/code/density.ts
+var FOLDER_LIMIT = 8;
+var MIN_FOLDER_LINES = 500;
+var LINES_PER_UNIT = 1e3;
+function density(openTasks, projects, projectId) {
+  const projectRows = projects.filter((project) => project.repos.length > 0).map((project) => {
+    const lines = sum(project.repos.flatMap((repo) => repo.lines).map((file) => file.lines));
+    return { projectId: project.projectId, name: project.name, ...densityRow(lines, openTasks.filter((task) => task.projectId === project.projectId).length) };
+  }).sort((a, b) => byDensity(a, b) || a.projectId.localeCompare(b.projectId));
+  const scoped = projectId === void 0 ? void 0 : projects.find((project) => project.projectId === projectId);
+  return { projects: projectRows, folders: scoped === void 0 ? [] : folderRows(scoped, openTasks) };
+}
+function folderRows(project, openTasks) {
+  const lines = countBy(
+    project.repos.flatMap((repo) => repo.lines),
+    (file) => folderOf(file.path),
+    (file) => file.lines
+  );
+  const ownSources = openTasks.flatMap((task) => task.projectId === project.projectId && task.source !== void 0 ? [task.source] : []);
+  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, 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);
+}
+
+// src/core/stats/code/code-report.ts
+function codeReport({ code, ...input }, base = reportBase(input)) {
+  const { projectId } = input;
+  const { openTasks } = base;
+  const projects = code.projects.filter((project) => projectId === void 0 || project.projectId === projectId);
+  return {
+    ...base.head,
+    unavailableRepos: code.unavailableRepos,
+    churn: churn(openTasks, projects, projectId === void 0),
+    density: density(openTasks, projects, projectId)
+  };
+}
+function codeFixRequests(input, base = reportBase(input)) {
+  return fixRequests(base.histories, statsPeriod(input.now));
+}
+
+// src/core/stats/cost/hook-signature.ts
+var HOOK_STOP_EVENT = "stop";
+var HOOK_STOP_COMMAND = `hook ${HOOK_STOP_EVENT}`;
+var STOP_HOOK_FEEDBACK_PREFIX = "Stop hook feedback:";
+function isBacklogHookFeedback(text) {
+  return text.startsWith(STOP_HOOK_FEEDBACK_PREFIX) && LANGUAGES.some((language) => text.includes(`${coreMessages(language).hookMark} `));
+}
+
+// src/core/stats/cost/pricing.ts
+var FAST_PRICED_MODEL = "claude-opus-5";
+var FAST_MODEL_MARKER = ":fast";
+var FAST_PRICE_FACTOR = 2;
+var CACHE_WRITE_5M_FACTOR = 1.25;
+var CACHE_WRITE_1H_FACTOR = 2;
+var PRICE_TABLE = {
+  "claude-fable-5-1": { input: 10, output: 50, cacheRead: 0.25 },
+  "claude-mythos-5-1": { input: 10, output: 50, cacheRead: 0.25 },
+  "claude-fable-5": { input: 10, output: 50, cacheRead: 1 },
+  "claude-mythos-5": { input: 10, output: 50, cacheRead: 1 },
+  [FAST_PRICED_MODEL]: { input: 5, output: 25, cacheRead: 0.5 },
+  "claude-opus-4-8": { input: 5, output: 25, cacheRead: 0.5 },
+  "claude-opus-4-7": { input: 5, output: 25, cacheRead: 0.5 },
+  "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5 },
+  "claude-sonnet-5": { input: 2, output: 10, cacheRead: 0.2 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1 }
+};
+var PRICE_KEYS_BY_LENGTH_DESC = Object.keys(PRICE_TABLE).sort((a, b) => b.length - a.length);
+var DATED_SUFFIX = /-\d{8}$/;
+var BRACKET_SUFFIX = /\[[^\]]*\]$/;
+function baseModelId(model) {
+  return model.replace(BRACKET_SUFFIX, "").replace(DATED_SUFFIX, "");
+}
+function fastModel(model) {
+  return `${model}${FAST_MODEL_MARKER}`;
+}
+function splitFastModel(modelKey) {
+  const fast = modelKey.endsWith(FAST_MODEL_MARKER);
+  return { model: fast ? modelKey.slice(0, -FAST_MODEL_MARKER.length) : modelKey, fast };
+}
+function priceOf(modelKey) {
+  const { model, fast } = splitFastModel(modelKey);
+  const stripped = baseModelId(model);
+  const key = PRICE_KEYS_BY_LENGTH_DESC.find((candidate) => stripped.startsWith(candidate));
+  const price = key ? PRICE_TABLE[key] : void 0;
+  if (!price) return null;
+  if (fast && key === FAST_PRICED_MODEL) return { input: price.input * FAST_PRICE_FACTOR, output: price.output * FAST_PRICE_FACTOR, cacheRead: price.cacheRead * FAST_PRICE_FACTOR };
+  return price;
+}
+function costOf(model, tokens) {
+  const price = priceOf(model);
+  if (!price) return null;
+  const { input, cacheWrite5m, cacheWrite1h, cacheRead, output } = tokens;
+  const total = input * price.input + cacheWrite5m * price.input * CACHE_WRITE_5M_FACTOR + cacheWrite1h * price.input * CACHE_WRITE_1H_FACTOR + cacheRead * price.cacheRead + output * price.output;
+  return total / 1e6;
+}
+
+// src/core/stats/days.ts
+var STATS_DAYS = 30;
+function dayRange(now, count3) {
+  return dayStarts(now, count3).map(formatLocalDay);
+}
+function dailyIntake(histories, now) {
+  const created = /* @__PURE__ */ new Map();
+  for (const history of histories) {
+    const day = formatLocalDay(new Date(history.createdAt));
+    created.set(day, (created.get(day) ?? 0) + 1);
+  }
+  return dayRange(now, STATS_DAYS).map((day) => ({ day, created: created.get(day) ?? 0 }));
+}
+function dayWindows(now, count3 = STATS_DAYS) {
+  return consecutivePeriods(dayStarts(now, count3), now.getTime());
+}
+function dayStarts(now, count3) {
+  return Array.from({ length: count3 }, (_, index) => new Date(now.getFullYear(), now.getMonth(), now.getDate() - (count3 - 1 - index)));
+}
+
+// src/core/stats/cost/cost-report.ts
+var COST_REPORT_DAYS = 30;
+var COST_TOTALS_DAYS = 7;
+function costReport({ buckets, runs, projectOf, projectId, now, scan }) {
+  const projectOfCwd = memoizedByCwd(projectOf);
+  const inScope = (cwd) => projectId === void 0 || projectOfCwd(cwd) === projectId;
+  const scopedBuckets = buckets.filter((bucket) => inScope(bucket.cwd));
+  const scopedRuns = runs.filter((run) => inScope(run.cwd));
+  const days3 = dayRange(now, COST_REPORT_DAYS);
+  const bucketsByDay = groupBy(scopedBuckets, (bucket) => localDay(bucket.slot));
+  const runsByDay = groupBy(scopedRuns, (run) => localDay(run.at));
+  const inDays = (byDay, window) => window.flatMap((day) => byDay.get(day) ?? []);
+  const totalsDays = days3.slice(-COST_TOTALS_DAYS);
+  return {
+    scan,
+    since: sinceOf(scopedBuckets),
+    totals: totalsOf(inDays(bucketsByDay, totalsDays), inDays(runsByDay, totalsDays)),
+    days: days3.map((day) => dayRow(day, bucketsByDay.get(day) ?? [], runsByDay.get(day) ?? [])),
+    models: modelsOf(scopedBuckets),
+    commands: commandsOf(inDays(runsByDay, days3))
+  };
+}
+function memoizedByCwd(projectOf) {
+  const known = /* @__PURE__ */ new Map();
+  return (cwd) => {
+    if (!known.has(cwd)) known.set(cwd, projectOf(cwd));
+    return known.get(cwd) ?? null;
+  };
+}
+function localDay(at) {
+  const moment = Date.parse(at);
+  return Number.isNaN(moment) ? "" : formatLocalDay(new Date(moment));
+}
+function tokenSum(tokens) {
+  return tokens.input + tokens.cacheWrite5m + tokens.cacheWrite1h + tokens.cacheRead + tokens.output;
+}
+function tokensTotalOf(buckets) {
+  return sum(buckets.map((bucket) => tokenSum(bucket.tokens)));
+}
+function costOfBuckets(buckets) {
+  if (tokensTotalOf(buckets) === 0) return 0;
+  const priced = buckets.flatMap((bucket) => {
+    const cost = costOf(bucket.model, bucket.tokens);
+    return cost === null ? [] : [{ cost, tokens: tokenSum(bucket.tokens) }];
+  });
+  return sum(priced.map((entry) => entry.tokens)) === 0 ? null : sum(priced.map((entry) => entry.cost));
+}
+function sinceOf(buckets) {
+  const days3 = buckets.map((bucket) => localDay(bucket.slot)).filter((day) => day !== "");
+  return days3.length === 0 ? null : days3.reduce((earliest, day) => day < earliest ? day : earliest);
+}
+function totalsOf(buckets, runs) {
+  return {
+    tokens: tokensTotalOf(buckets),
+    cost: costOfBuckets(buckets),
+    hasUnpricedTokens: buckets.some((bucket) => tokenSum(bucket.tokens) > 0 && costOf(bucket.model, bucket.tokens) === null),
+    hookTurns: sum(buckets.map((bucket) => bucket.hookTurns)),
+    cliRuns: runs.filter((run) => run.command !== HOOK_STOP_COMMAND).length,
+    hookRuns: runs.filter((run) => run.command === HOOK_STOP_COMMAND).length
+  };
+}
+function dayRow(day, dayBuckets, dayRuns) {
+  const hookBuckets = dayBuckets.filter((bucket) => bucket.kind === "hook");
+  const cliBuckets = dayBuckets.filter((bucket) => bucket.kind === "cli" || bucket.kind === "skill");
+  return {
+    day,
+    hookTokens: tokensTotalOf(hookBuckets),
+    cliTokens: tokensTotalOf(cliBuckets),
+    cost: costOfBuckets(dayBuckets),
+    hookTurns: sum(dayBuckets.map((bucket) => bucket.hookTurns)),
+    cliRuns: dayRuns.filter((run) => run.command !== HOOK_STOP_COMMAND).length,
+    hookRuns: dayRuns.filter((run) => run.command === HOOK_STOP_COMMAND).length
+  };
+}
+function modelsOf(buckets) {
+  return [...groupBy(buckets, (bucket) => bucket.model).entries()].map(([key, modelBuckets]) => ({ ...splitFastModel(key), tokens: tokensTotalOf(modelBuckets), cost: costOfBuckets(modelBuckets) })).filter((row) => row.tokens > 0).sort((a, b) => b.tokens - a.tokens);
+}
+function commandsOf(runs) {
+  return [...groupBy(runs, (run) => run.command).entries()].map(([command, commandRuns]) => ({
+    command,
+    runs: commandRuns.length,
+    avgMs: average(commandRuns.map((run) => run.ms)),
+    avgRssMb: average(commandRuns.map((run) => run.rssMb)),
+    maxRssMb: commandRuns.reduce((most, run) => Math.max(most, run.rssMb), 0)
+  })).sort((a, b) => b.runs - a.runs);
+}
+function average(values) {
+  return sum(values) / values.length;
+}
+
+// src/core/stats/effect/effect-report.ts
+var MIN_FIXES_FOR_ESTIMATE = 5;
+function effectReport({ code, ...input }, base = reportBase(input), wholeBacklog = input.projectId === void 0 ? base : reportBase({ ...input, projectId: void 0 })) {
+  const { now, projectId } = input;
+  const { histories } = base;
+  const reportPeriod = statsPeriod(now);
+  const projects = code.projects.filter((project) => project.repos.length > 0 && (projectId === void 0 || project.projectId === projectId));
+  const deferred = buildDeferred(histories.filter((history) => reportPeriod.contains(history.createdAt)), histories, code);
+  const estimate = estimator(estimateSamples(wholeBacklog.histories, code));
+  const adoptionStart = (id) => {
+    const firstCreated = smallest(histories.filter((history) => history.projectId === id).map((history) => history.createdAt));
+    return firstCreated === null ? reportPeriod.from : Math.max(reportPeriod.from, firstCreated);
+  };
+  const unitsOf = (project) => project.repos.flatMap((repo) => repo.units);
+  const unitsForTotals = (id) => projects.filter((project) => id === void 0 || project.projectId === id).flatMap((project) => {
+    const adopted = period(adoptionStart(project.projectId), reportPeriod.to);
+    return unitsOf(project).filter((unit) => adopted.contains(Date.parse(unit.date)));
+  });
+  const periodUnits = projects.flatMap(unitsOf).filter((unit) => reportPeriod.contains(Date.parse(unit.date)));
+  return {
+    ...base.head,
+    unavailableRepos: code.unavailableRepos,
+    totals: totalsOf2(deferred, unitsForTotals(), estimate),
+    weeks: bucketsOf(weekWindows(now), deferred, periodUnits, estimate),
+    days: bucketsOf(dayWindows(now), deferred, periodUnits, estimate),
+    projects: projects.map((project) => {
+      const own = totalsOf2(deferred.filter((item) => item.history.projectId === project.projectId), unitsForTotals(project.projectId), estimate);
+      return {
+        projectId: project.projectId,
+        name: project.name,
+        realLines: own.realLines,
+        deferredTasks: own.fixedTasks + own.openTasks,
+        fixedLines: own.fixedLines,
+        estimatedLines: own.estimatedLines,
+        noiseShare: own.noiseShare
+      };
+    })
+  };
+}
+function fixEntryOf(history, code) {
+  return isFixedNow(history) ? fixCommitEntry(history, code.fixCommits) : void 0;
+}
+function buildDeferred(candidates, histories, code) {
+  const sharersByCommit = countBy(
+    histories.flatMap((history) => fixEntryOf(history, code)?.key ?? []),
+    (key) => key
+  );
+  return candidates.flatMap((history) => {
+    if (!isClosed(history.finalStatus)) return [{ history, fixedLines: null, fixedTestLines: 0, fixedAt: null }];
+    const entry = fixEntryOf(history, code);
+    if (entry === void 0) return [];
+    const sharers = sharersByCommit.get(entry.key) ?? 1;
+    return [{ history, fixedLines: entry.commit.lines / sharers, fixedTestLines: entry.commit.testLines / sharers, fixedAt: Date.parse(entry.commit.date) }];
+  });
+}
+function estimateSamples(histories, code) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const history of histories) {
+    const entry = fixEntryOf(history, code);
+    if (entry === void 0 || seen.has(entry.key)) continue;
+    seen.set(entry.key, { category: history.category, lines: entry.commit.lines, testLines: entry.commit.testLines });
+  }
+  return [...seen.values()];
+}
+function estimator(samples) {
+  const overall = sizeOf(samples);
+  return (category) => {
+    if (category === void 0) return overall;
+    return sizeOf(samples.filter((sample) => sample.category === category)) ?? overall;
+  };
+}
+function sizeOf(samples) {
+  const lines = samples.length < MIN_FIXES_FOR_ESTIMATE ? null : median(samples.map((sample) => sample.lines));
+  if (lines === null) return null;
+  const totalLines = sum(samples.map((sample) => sample.lines));
+  const testShare = totalLines === 0 ? 0 : sum(samples.map((sample) => sample.testLines)) / totalLines;
+  return { lines, testLines: lines * testShare };
+}
+function totalsOf2(deferred, units, estimate) {
+  const fixed = deferred.flatMap((item) => item.fixedLines === null ? [] : [item.fixedLines]);
+  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);
+  const deferredLines = fixedLines + (estimatedLines ?? 0);
+  const denominator = realLines + (estimatedLines ?? 0);
+  return {
+    realLines,
+    fixedTasks: fixed.length,
+    fixedLines,
+    openTasks: open2.length,
+    estimatedLines,
+    deferredLines,
+    deferredTestLines: sum(deferred.map((item) => item.fixedTestLines)) + (estimated?.testLines ?? 0),
+    noiseShare: realLines === 0 || estimatedLines === null && open2.length > 0 ? null : Math.min(1, deferredLines / denominator)
+  };
+}
+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)) };
+}
+function bucketsOf(windows, deferred, periodUnits, estimate) {
+  return windows.map((span) => {
+    const rawRealLines = sum(periodUnits.filter((unit) => span.contains(Date.parse(unit.date))).map((unit) => unit.lines));
+    const fixedInWindow = deferred.filter((item) => item.fixedAt !== null && span.contains(item.fixedAt));
+    const openInWindow = deferred.filter((item) => item.fixedLines === null && span.contains(item.history.createdAt));
+    const fixedLinesInWindow = sum(fixedInWindow.map((item) => item.fixedLines ?? 0));
+    const estimatedInWindow = estimatedSizeOf(openInWindow, estimate);
+    const deferredLines = fixedLinesInWindow + (estimatedInWindow?.lines ?? 0);
+    return {
+      start: formatLocalIso(new Date(span.from)),
+      onTopicLines: Math.max(0, rawRealLines - fixedLinesInWindow),
+      deferredLines,
+      deferredTestLines: sum(fixedInWindow.map((item) => item.fixedTestLines)) + (estimatedInWindow?.testLines ?? 0),
+      deferredTasks: fixedInWindow.length + openInWindow.length
+    };
+  });
+}
+
+// src/core/stats/quality/accuracy.ts
+function accuracy(histories, period2) {
+  const episodes = histories.flatMap(
+    (history) => history.candidates.filter((candidate) => period2.contains(candidate.at)).map((candidate) => ({ evidence: candidate.evidence, outcome: outcomeAfter(history, candidate.at) }))
+  );
+  if (episodes.length === 0) return [];
+  const byEvidence = CANDIDATE_EVIDENCE.flatMap((evidence) => {
+    const own = episodes.filter((episode) => episode.evidence === evidence);
+    return own.length === 0 ? [] : [{ evidence, ...outcomeCounts(own) }];
+  });
+  return [...byEvidence, { evidence: "total", ...outcomeCounts(episodes) }];
+}
+function accuracyWeeks(histories, now) {
+  return weekWindows(now).map((week) => {
+    const decided = histories.flatMap(
+      (history) => history.candidates.filter((candidate) => week.contains(candidate.at) && candidate.evidence !== "no-source").map((candidate) => outcomeAfter(history, candidate.at)).filter((outcome) => outcome !== "open")
+    );
+    const closed = decided.filter((outcome) => outcome === "closed").length;
+    return { start: formatLocalIso(new Date(week.from)), decided: decided.length, precision: decided.length === 0 ? null : closed / decided.length };
+  });
+}
+function methodAccuracy(histories, period2) {
+  return splitAccuracy(histories, period2, { evidence: "source-changed", keys: RECORDED_METHODS, keyOf: (candidate) => candidate.method });
+}
+function matchAccuracy(histories, period2) {
+  return splitAccuracy(histories, period2, { evidence: "duplicate", keys: RECORDED_MATCHES, keyOf: (candidate) => candidate.match });
+}
+function splitAccuracy(histories, period2, { evidence, keys, keyOf }) {
+  const episodes = histories.flatMap(
+    (history) => history.candidates.filter((candidate) => candidate.evidence === evidence && period2.contains(candidate.at)).map((candidate) => ({ by: keyOf(candidate), outcome: outcomeAfter(history, candidate.at) }))
+  );
+  return keys.flatMap((by) => {
+    const own = episodes.filter((episode) => episode.by === by);
+    return own.length === 0 ? [] : [{ by, ...outcomeCounts(own) }];
+  });
+}
+function outcomeAfter(history, moment) {
+  const closedAt2 = closingsOf(history).find((closing) => closing.at > moment)?.at;
+  const verifiedAt = history.verifications.find((verification) => verification > moment);
+  if (closedAt2 === void 0) return verifiedAt === void 0 ? "open" : "verified";
+  return verifiedAt !== void 0 && verifiedAt < closedAt2 ? "verified" : "closed";
+}
+function outcomeCounts(episodes) {
+  const count3 = (outcome) => episodes.filter((episode) => episode.outcome === outcome).length;
+  const closed = count3("closed");
+  const verified = count3("verified");
+  return { candidates: episodes.length, closed, verified, open: count3("open"), precision: closed + verified === 0 ? null : closed / (closed + verified) };
+}
+
+// src/core/stats/quality/categories.ts
+function categoryBreakdown(openTasks, histories, period2) {
+  const rows = /* @__PURE__ */ new Map();
+  const row = (category) => {
+    const key = category ?? null;
+    const existing = rows.get(key);
+    if (existing !== void 0) return existing;
+    const created = { category: key, open: 0, weight: 0, created: 0, closed: 0 };
+    rows.set(key, created);
+    return created;
+  };
+  for (const task of openTasks) {
+    const target = row(task.category);
+    target.open += 1;
+    target.weight += PRIORITY_WEIGHT[task.priority];
+  }
+  for (const history of histories) {
+    if (period2.contains(history.createdAt)) row(history.category).created += 1;
+    row(history.category).closed += closingsOf(history).filter((closing) => period2.contains(closing.at)).length;
+  }
+  return [...rows.values()].filter((entry) => entry.open + entry.created + entry.closed > 0).sort(
+    (a, b) => Number(a.category === null) - Number(b.category === null) || b.weight - a.weight || b.created - a.created || (a.category ?? "").localeCompare(b.category ?? "")
+  );
+}
+
+// src/core/stats/quality/graph-filter.ts
+var SILENT_CLOSINGS = /* @__PURE__ */ new Set(["fixed", "obsolete"]);
+function graphFilterEffect(histories, period2) {
+  const outcomes = histories.flatMap(
+    (history) => history.filtered.flatMap((at, index) => period2.contains(at) ? [outcomeAfter2(history, at, history.filtered[index + 1] ?? Number.POSITIVE_INFINITY)] : [])
+  );
+  const count3 = (outcome) => outcomes.filter((candidate) => candidate === outcome).length;
+  return { filtered: outcomes.length, caught: count3("caught"), missed: count3("missed"), quiet: count3("quiet") };
+}
+function outcomeAfter2(history, from, until) {
+  const within = (at) => at > from && at <= until;
+  const candidate = history.candidates.find((seen) => seen.evidence === "source-changed" && within(seen.at));
+  const closing = closingsOf(history).find((transition) => within(transition.at));
+  if (candidate !== void 0 && (closing === void 0 || candidate.at <= closing.at)) return "caught";
+  if (closing === void 0 || !SILENT_CLOSINGS.has(closing.resolution)) return "quiet";
+  const taken = history.transitions.some((transition) => transition.to === "in-progress" && transition.at > from && transition.at < closing.at);
+  return taken ? "quiet" : "missed";
+}
+
+// src/core/stats/quality/origin.ts
+var BRANCH_LIMIT = 8;
+var FOUND_ORDER = [...FOUND_HOW, null];
+function foundBreakdown(histories, period2) {
+  const created = createdIn(histories, period2);
+  return FOUND_ORDER.map((found) => {
+    const own = created.filter((history) => (history.found ?? null) === found);
+    return {
+      found,
+      created: own.length,
+      open: own.filter(isOpenNow).length,
+      fixed: own.filter(isFixedNow).length
+    };
+  });
+}
+function branchBreakdown(histories, period2, withProject) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const history of createdIn(histories, period2)) {
+    if (history.branch === void 0) continue;
+    const label = projectLabel(history.projectId, history.branch, withProject);
+    const current = rows.get(label) ?? { label, created: 0, open: 0 };
+    rows.set(label, { label, created: current.created + 1, open: current.open + (isOpenNow(history) ? 1 : 0) });
+  }
+  return [...rows.values()].sort((a, b) => b.created - a.created || a.label.localeCompare(b.label)).slice(0, BRANCH_LIMIT);
+}
+function createdIn(histories, period2) {
+  return histories.filter((history) => period2.contains(history.createdAt));
+}
+function isOpenNow(history) {
+  return !isClosed(history.finalStatus);
+}
+
+// src/core/stats/quality/quality-report.ts
+function qualityReport(input, base = reportBase(input), graphs = []) {
+  const { now, projectId } = input;
+  const { histories, openTasks } = base;
+  const period2 = statsPeriod(now);
+  return {
+    ...base.head,
+    accuracy: accuracy(histories, period2),
+    accuracyWeeks: accuracyWeeks(histories, now),
+    methodAccuracy: methodAccuracy(histories, period2),
+    matchAccuracy: matchAccuracy(histories, period2),
+    graph: { projects: graphs, filter: graphFilterEffect(histories, period2) },
+    categories: categoryBreakdown(openTasks, histories, period2),
+    found: foundBreakdown(histories, period2),
+    branches: branchBreakdown(histories, period2, projectId === void 0)
+  };
+}
+
+// src/core/stats/report.ts
+var STALE_DAYS = 30;
+function statsReport(input, base = reportBase(input)) {
+  const { now, projectId } = input;
+  const { histories, openTasks } = base;
+  const period2 = statsPeriod(now);
+  return {
+    ...base.head,
+    totals: totals(openTasks, histories, now, period2, base.scope.journalStart),
+    weeks: weeklyFlow(histories, now),
+    days: dailyIntake(histories, now),
+    hotspots: hotspots(openTasks, projectId === void 0),
+    age: ageBreakdown(openTasks, now),
+    closing: closingBreakdown(histories, period2)
+  };
+}
+function totals(openTasks, histories, now, period2, journalStart) {
+  const nowMs = now.getTime();
+  const inLastWeek = (moment) => moment > nowMs - WEEK_MS && moment <= nowMs;
+  const ages = openTasks.map((task) => daysBetween(Date.parse(task.created), nowMs));
+  const leadTimes = histories.flatMap(
+    (history) => closingsOf(history).filter((closing) => period2.contains(closing.at)).map((closing) => daysBetween(history.createdAt, closing.at))
+  );
+  const today = formatLocalDay(now);
+  return {
+    open: openTasks.length,
+    createdToday: histories.filter((history) => formatLocalDay(new Date(history.createdAt)) === today).length,
+    closedToday: histories.flatMap(closingsOf).filter((closing) => formatLocalDay(new Date(closing.at)) === today).length,
+    openWeight: sum(openTasks.map((task) => PRIORITY_WEIGHT[task.priority])),
+    createdLastWeek: histories.filter((history) => inLastWeek(history.createdAt)).length,
+    closedLastWeek: histories.flatMap(closingsOf).filter((closing) => inLastWeek(closing.at)).length,
+    ageMedianDays: median(ages),
+    olderThan30Days: ages.filter((age) => age >= STALE_DAYS).length,
+    leadTimeMedianDays: median(leadTimes),
+    leadTimeP90Days: nearestRank(leadTimes, TAIL_FRACTION),
+    previous: previousTotals(histories, nowMs, journalStart)
+  };
+}
+function previousTotals(histories, nowMs, journalStart) {
+  const weekAgo = nowMs - WEEK_MS;
+  if (journalStart === null || journalStart > weekAgo) return null;
+  const inWeekBefore = (moment) => moment > weekAgo - WEEK_MS && moment <= weekAgo;
+  const openThen = histories.filter((history) => isOpenAt(history, weekAgo));
+  const closedThen = histories.flatMap(closingsOf).filter((closing) => inWeekBefore(closing.at));
+  const leadTimes = histories.flatMap((history) => closingsOf(history).filter((closing) => inWeekBefore(closing.at)).map((closing) => daysBetween(history.createdAt, closing.at)));
+  return {
+    open: openThen.length,
+    net: histories.filter((history) => inWeekBefore(history.createdAt)).length - closedThen.length,
+    ageMedianDays: median(openThen.map((history) => daysBetween(history.createdAt, weekAgo))),
+    leadTimeMedianDays: median(leadTimes)
+  };
+}
+
+// src/core/stats/flow/current.ts
+function inWorkTasks(tasks, histories, now) {
+  const nowMs = now.getTime();
+  const historyById = new Map(histories.map((history) => [history.id, history]));
+  return tasks.flatMap((task) => isWorkStatus(task.status) ? [{ task, status: task.status }] : []).map(({ task, status }) => {
+    const entered = historyById.get(task.id)?.transitions.filter((transition) => transition.to === status && transition.at <= nowMs).at(-1)?.at;
+    return {
+      id: task.id,
+      projectId: task.projectId,
+      title: task.title,
+      status,
+      days: daysBetween(entered ?? Date.parse(task.created), nowMs),
+      atLeast: entered === void 0
+    };
+  }).sort((a, b) => b.days - a.days || compareIds(a.id, b.id));
+}
+function isWorkStatus(status) {
+  return status === "in-progress" || status === "blocked";
+}
+
+// src/core/stats/signals/signals.ts
+var GROWTH_WEEKS = 3;
+var STUCK_IN_PROGRESS_DAYS = 7;
+var STUCK_BLOCKED_DAYS = 14;
+var NOISY_MIN_DECIDED = 10;
+var NOISY_MAX_PERCENT = 20;
+var NOISY_WINDOW_DAYS = 14;
+function statsSignals(input, base = reportBase(input)) {
+  const { now } = input;
+  return [
+    ...debtGrowing(weeklyFlow(base.histories, now)),
+    ...urgentStale(urgentStaleCount(base.openTasks, now)),
+    ...stuck(base, now),
+    ...noisyChecks(base, now),
+    ...staleLow(base, now)
+  ];
+}
+function debtGrowing(weeks) {
+  const recent = weeks.slice(-GROWTH_WEEKS);
+  if (recent.length < GROWTH_WEEKS || !recent.every((week) => week.created > week.closed)) return [];
+  const created = sum(recent.map((week) => week.created));
+  const closed = sum(recent.map((week) => week.closed));
+  return [{ kind: "debt-growing", params: { weeks: GROWTH_WEEKS, created, closed } }];
+}
+function urgentStale(count3) {
+  return count3 === 0 ? [] : [{ kind: "urgent-stale", params: { days: STALE_URGENT_DAYS, count: count3 } }];
+}
+function stuck({ scope, tasks }, now) {
+  const stuckTasks = inWorkTasks(tasks, scope.histories, now).filter(
+    (item) => item.days > (item.status === "blocked" ? STUCK_BLOCKED_DAYS : STUCK_IN_PROGRESS_DAYS)
+  );
+  const longest = stuckTasks[0];
+  if (longest === void 0) return [];
+  return [{ kind: "stuck", params: { count: stuckTasks.length, id: longest.id, days: longest.days } }];
+}
+function staleLow({ scope }, now) {
+  const stale = staleLowTasks(scope.tasks, now);
+  return stale.length === 0 ? [] : [{ kind: "stale-low", params: { days: STALE_LOW_DAYS, count: stale.length } }];
+}
+function noisyChecks({ histories }, now) {
+  return checkGauges(histories, period(now.getTime() - NOISY_WINDOW_DAYS * DAY_MS, now.getTime())).flatMap((gauge) => {
+    const decided = gauge.closed + gauge.verified;
+    if (decided < NOISY_MIN_DECIDED || gauge.precision === null) return [];
+    const percent = Math.round(gauge.precision * 100);
+    if (percent >= NOISY_MAX_PERCENT) return [];
+    return [{ kind: "noisy-check", params: { evidence: gauge.evidence, method: gauge.method, percent, decided, windowDays: NOISY_WINDOW_DAYS } }];
+  });
+}
+function checkGauges(histories, window) {
+  const byEvidence = accuracy(histories, window).filter((row) => measuredByClosing(row.evidence) && row.evidence !== "source-changed").map((row) => ({ ...row, method: null }));
+  const byFile = methodAccuracy(histories, window).flatMap(
+    (row) => row.by === "file" ? [{ ...row, evidence: "source-changed", method: "file" }] : []
+  );
+  return [...byFile, ...byEvidence];
+}
+function measuredByClosing(evidence) {
+  return evidence !== "total" && evidence !== "no-source";
+}
+
+// src/core/store/resolve-project.ts
+import { realpathSync as realpathSync2 } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { isAbsolute, relative, sep } from "node:path";
+var REPO_ROOT_TTL_MS = 6e4;
+var SHOW_TOP_LEVEL = ["rev-parse", "--show-toplevel"];
+function cachedRepoRoots({ ttlMs = REPO_ROOT_TTL_MS, now = Date.now } = {}) {
+  const known = /* @__PURE__ */ new Map();
+  return (dir) => {
+    const cached = known.get(dir);
+    if (cached !== void 0 && now() - cached.checkedAt < ttlMs) return cached.root;
+    const root = repoRootOrNull(dir);
+    known.set(dir, { root, checkedAt: now() });
+    return root;
+  };
+}
+async function repoRootOrNull(dir) {
+  const topLevel = topLevelOf(await runGit(dir, SHOW_TOP_LEVEL));
+  return realpath(topLevel ?? dir).catch(() => null);
+}
+function topLevelOf(output) {
+  const topLevel = output?.trim() ?? "";
+  return topLevel === "" ? null : topLevel;
+}
+function findProjectForRepoRoot(projects, root, home2) {
+  const matches = projects.flatMap(
+    (project) => project.repos.flatMap((repo) => {
+      const repoPath = realpathOrNull(expandHome(repo, home2));
+      return repoPath !== null && isSameOrInside(root, repoPath) ? [{ project, repoPath }] : [];
+    })
+  );
+  return matches.sort((a, b) => b.repoPath.length - a.repoPath.length)[0]?.project;
+}
+function isSameOrInside(path, container) {
+  const relation = relative(container, path);
+  return relation === "" || !isAbsolute(relation) && relation.split(sep)[0] !== "..";
+}
+function realpathOrNull(path) {
+  try {
+    return realpathSync2(path);
+  } catch {
+    return null;
+  }
+}
+
+// src/server/stats-api.ts
+var REPORT_TTL_MS = 5 * 60 * 1e3;
+function createStatsApi({ root, now, home: home2, usage, memory, backlog }) {
+  const routes = new Hono();
+  const reports = createReportCache({ ttlMs: REPORT_TTL_MS, now: () => now().getTime() });
+  const onCodeSourceError = (kind, error) => void serverLanguage(root).then((language) => {
+    const messages = serverMessages(language);
+    const text = kind === "read" ? messages.codeCacheReadFailed(errorText(error)) : messages.codeCacheWriteFailed(errorText(error));
+    process.stderr.write(`${text}
+`);
+  });
+  const codeSource = createCodeSource({ home: home2, store: createCodeCacheFile(root), onError: onCodeSourceError });
+  const lookupRepoRoot = cachedRepoRoots();
+  const statsScopeOf = async (c, { wholeBacklog }) => {
+    const projectId = c.req.query("project") || void 0;
+    const { projects, tasks } = await backlog();
+    if (projectId !== void 0 && !projects.some((project) => project.id === projectId)) {
+      return c.json({ errors: [serverMessages(await serverLanguage(root)).projectNotFound(projectId)] }, 404);
+    }
+    const included = (project) => projectId === void 0 ? project.active : wholeBacklog || project.id === projectId;
+    const scoped = projects.filter(included);
+    const scopedIds = new Set(scoped.map((project) => project.id));
+    return { projectId, projects: scoped, tasks: tasks.filter((task) => scopedIds.has(task.projectId)) };
+  };
+  const scopedStats = (name, report, { sourceKey, wholeBacklog = false } = {}) => async (c) => {
+    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 input = { tasks: scope.tasks, journals, now: moment, projectId: scope.projectId };
+      return report(input, reportBase(input), scope.projects);
+    });
+    return c.json(result);
+  };
+  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 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 projectOf = (cwd) => {
+      const repoRoot = repoRoots.get(cwd) ?? null;
+      return repoRoot === null ? null : findProjectForRepoRoot(projects, repoRoot, home2)?.id ?? null;
+    };
+    return costReport({ buckets, runs, projectOf, projectId, now: now(), scan });
+  };
+  const codeState = { sourceKey: (projects) => codeSource.stateKey(projects) };
+  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/cost", async (c) => {
+    const scope = await statsScopeOf(c, { wholeBacklog: true });
+    return scope instanceof Response ? scope : c.json(await statsOfCost(scope.projectId, scope.projects));
+  });
+  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) }))
+  );
+}
+function bucketsOf2(cache) {
+  return Object.values(cache.files).flatMap((entry) => entry.buckets);
+}
+async function resolveRepoRoots(lookupRepoRoot, cwds) {
+  const unique = [...new Set(cwds)];
+  return new Map(await Promise.all(unique.map(async (cwd) => [cwd, await lookupRepoRoot(cwd)])));
+}
+
+// src/server/api.ts
+var GRAPH_STATE_TTL_MS = 60 * 1e3;
+function createApi({ root, changes, now, home: home2, usage, memory }) {
+  const api = new Hono2();
+  let snapshot = null;
+  const readLanguage = () => serverLanguage(root);
+  const backlog = () => {
+    snapshot ??= loadSnapshot(root).catch((error) => {
+      snapshot = null;
+      throw error;
+    });
+    return snapshot;
+  };
+  const stats = createStatsApi({ root, now, home: home2, usage, memory, backlog });
+  const graphStates = createReportCache({ ttlMs: GRAPH_STATE_TTL_MS, now: () => now().getTime() });
+  const forgetBacklog = () => {
+    snapshot = null;
+    stats.forget();
+  };
+  changes.subscribe(forgetBacklog);
+  api.get("/projects", async (c) => {
+    const { projects, tasks } = await backlog();
+    const withGraph = async (project) => {
+      const codeGraph2 = await graphStates.get(project.id, async () => (await projectGraphHealth(project, tasks, home2)).state);
+      return { ...project, codeGraph: codeGraph2 };
+    };
+    return c.json(await Promise.all(projects.map(withGraph)));
+  });
+  api.get("/tasks", async (c) => {
+    const [{ tasks, errors }, language] = await Promise.all([backlog(), readLanguage()]);
+    const messages = coreMessages(language);
+    return c.json({ tasks, errors: errors.map(({ problems: problems3, ...error }) => ({ ...error, message: messages.problems(problems3) })) });
+  });
+  api.route("/", stats.routes);
+  api.get("/settings", async (c) => c.json({ language: await readLanguage() }));
+  api.patch("/settings", async (c) => {
+    const body = await readBody(c, settingsSchema2, readLanguage);
+    if (!body.ok) return body.response;
+    await writeSettings(root, body.data);
+    return c.json({ language: body.data.language });
+  });
+  api.patch("/tasks/:id", async (c) => {
+    const body = await readBody(c, updateTaskRequestSchema, readLanguage);
+    if (!body.ok) return body.response;
+    const id = c.req.param("id");
+    const { index } = await backlog();
+    const result = await updateTaskInIndex(index, { id, changes: body.data.changes, expectedVersion: body.data.version, now: now(), via: "web" });
+    forgetBacklog();
+    if (result.ok) return c.json(result.task);
+    const messages = serverMessages(body.language);
+    if (result.reason === "not-found") return c.json({ errors: [messages.taskNotFound(id)] }, 404);
+    if (result.reason === "conflict") return c.json({ errors: [messages.taskChangedOnDisk], current: result.current }, 409);
+    return invalidResponse(c, result, coreMessages(body.language));
+  });
+  api.patch("/projects/:id", async (c) => {
+    const body = await readBody(c, projectActiveSchema, readLanguage);
+    if (!body.ok) return body.response;
+    const id = c.req.param("id");
+    const result = await setProjectActive(root, id, body.data.active);
+    forgetBacklog();
+    if (result.ok) return c.json(result.project);
+    if (result.reason === "invalid") return c.json({ errors: [coreMessages(body.language).problems(result.problems)] }, 422);
+    return c.json({ errors: [serverMessages(body.language).projectNotFound(id)] }, 404);
+  });
+  api.delete("/projects/:id", async (c) => {
+    const body = await readBody(c, projectDeleteSchema, readLanguage);
+    if (!body.ok) return body.response;
+    const id = c.req.param("id");
+    const messages = serverMessages(body.language);
+    if (body.data.confirm !== id) return c.json({ errors: [messages.confirmMismatch] }, 422);
+    const result = await deleteProject(root, id);
+    forgetBacklog();
+    return result.ok ? c.json({ deleted: id }) : c.json({ errors: [messages.projectNotFound(id)] }, 404);
+  });
+  api.get(
+    "/events",
+    (c) => streamSSE(c, async (stream) => {
+      const unsubscribe = changes.subscribe(() => void stream.writeSSE({ event: "change", data: "" }));
+      await new Promise((resolve) => {
+        stream.onAbort(() => {
+          unsubscribe();
+          resolve();
+        });
+      });
+    })
+  );
+  return api;
+}
+async function loadSnapshot(root) {
+  const loaded = await loadBacklog(root);
+  return { ...loaded, index: buildIndex(loaded.tasks) };
+}
+function invalidResponse(c, result, messages) {
+  return c.json({ errors: result.errors.map(messages.problem) }, 422);
+}
+async function readBody(c, schema, readLanguage) {
+  const [body, language] = await Promise.all([readJson(c), readLanguage()]);
+  if (body.ok === false) return { ok: false, response: c.json({ errors: [serverMessages(language).bodyNotParsed] }, 400) };
+  const parsed = parseWithLocale(schema, body.value, language);
+  return parsed.ok ? { ok: true, data: parsed.value, language } : { ok: false, response: c.json({ errors: parsed.errors }, 422) };
+}
+async function readJson(c) {
+  try {
+    return { ok: true, value: await c.req.json() };
+  } catch {
+    return { ok: false };
+  }
+}
+
+// src/server/guards.ts
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PATCH", "PUT", "DELETE"]);
+function localHosts(port) {
+  return /* @__PURE__ */ new Set([`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`]);
+}
+function allowLocalHostsOnly(allowedHosts, root) {
+  return async (c, next) => {
+    const { host } = new URL(c.req.url);
+    if (!allowedHosts.has(host)) {
+      const messages = serverMessages(await serverLanguage(root));
+      return c.json({ errors: [messages.hostRejected(host)] }, 403);
+    }
+    await next();
+    return void 0;
+  };
+}
+function requireJsonBody(root) {
+  return async (c, next) => {
+    if (MUTATING_METHODS.has(c.req.method) && !c.req.header("content-type")?.startsWith("application/json")) {
+      const messages = serverMessages(await serverLanguage(root));
+      return c.json({ errors: [messages.jsonContentTypeExpected] }, 415);
+    }
+    await next();
+    return void 0;
+  };
+}
+
+// src/server/app.ts
+function createApp({ root, changes, allowedHosts, home: home2, usage, memory, staticDir, now = () => /* @__PURE__ */ new Date() }) {
+  const app = new Hono3();
+  app.use("*", allowLocalHostsOnly(allowedHosts, root));
+  app.use("/api/*", requireJsonBody(root));
+  app.route("/api", createApi({ root, changes, now, home: home2, usage, memory }));
+  app.all("/api/*", async (c) => c.json({ errors: [serverMessages(await serverLanguage(root)).unknownRoute(new URL(c.req.url).pathname)] }, 404));
+  app.onError(async (error, c) => {
+    const text = error instanceof FileBusyError ? coreMessages(await serverLanguage(root)).fileBusy(error.path, error.lock, error.seconds) : errorText(error);
+    return c.json({ errors: [text] }, 500);
+  });
+  if (staticDir !== void 0) {
+    app.use("*", serveStatic({ root: staticDir }));
+    app.get("*", serveStatic({ path: join14(staticDir, "index.html") }));
+  }
+  return app;
+}
+
+// src/server/change-feed.ts
+import { relative as relative2, sep as sep2 } from "node:path";
+import { watch } from "chokidar";
+var CHANGE_DEBOUNCE_MS = 100;
+function createDebouncer(delayMs, run) {
+  let timer;
+  return {
+    schedule: () => {
+      clearTimeout(timer);
+      timer = setTimeout(run, delayMs);
+    },
+    cancel: () => clearTimeout(timer)
+  };
+}
+function isHiddenPath(root, path) {
+  return relative2(root, path).split(sep2).some((segment) => segment.startsWith("."));
+}
+function createChangeFeed(root, debounceMs = CHANGE_DEBOUNCE_MS, messages = () => Promise.resolve(serverRu)) {
+  const listeners = /* @__PURE__ */ new Set();
+  const debouncer = createDebouncer(debounceMs, () => {
+    for (const listener of listeners) listener();
+  });
+  const watcher = watch(root, { ignoreInitial: true, ignored: (path) => isHiddenPath(root, path) });
+  watcher.on("all", () => debouncer.schedule());
+  watcher.on("error", (error) => {
+    void messages().then((texts) => process.stderr.write(`${texts.watcherError(root, errorText(error))}
+`));
+  });
+  return {
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    close: async () => {
+      debouncer.cancel();
+      listeners.clear();
+      await watcher.close();
+    }
+  };
+}
+
+// src/core/api/memory.ts
+var MEMORY_SAMPLE_INTERVAL_MS = 5e3;
+var MEMORY_HISTORY_MS = 60 * 60 * 1e3;
+function megabytesOf(bytes) {
+  return Math.round(bytes / 1024 / 1024 * 10) / 10;
+}
+
+// src/server/memory-sampler.ts
+var DEFAULT_CAPACITY = MEMORY_HISTORY_MS / MEMORY_SAMPLE_INTERVAL_MS;
+function createMemorySampler({ intervalMs = MEMORY_SAMPLE_INTERVAL_MS, capacity = DEFAULT_CAPACITY, now = () => /* @__PURE__ */ new Date() } = {}) {
+  let points = [];
+  let timer = null;
+  const sample = () => {
+    const usage = process.memoryUsage();
+    const point = { at: formatLocalIso(now()), rssMb: megabytesOf(usage.rss), heapUsedMb: megabytesOf(usage.heapUsed) };
+    points = [...points, point].slice(-capacity);
+  };
+  return {
+    start: () => {
+      sample();
+      timer = setInterval(sample, intervalMs);
+    },
+    stop: () => {
+      if (timer !== null) clearInterval(timer);
+      timer = null;
+    },
+    sample,
+    samples: () => points
+  };
+}
+
+// src/server/sweeper.ts
+function startSweeper({ sweep, intervalMs, log, warn, messages = () => Promise.resolve(serverRu) }) {
+  let current = Promise.resolve();
+  const run = async () => {
+    let texts = serverRu;
+    try {
+      texts = await messages();
+      logReport(await sweep(), texts, log);
+    } catch (error) {
+      warn(texts.sweepFailed(errorText(error)));
+    }
+  };
+  const trigger = () => {
+    current = run();
+  };
+  trigger();
+  const timer = setInterval(trigger, intervalMs);
+  return () => {
+    clearInterval(timer);
+    return current;
+  };
+}
+function logReport({ closedEpics, blockingFiles, deleted, conflicts, invalid: invalid2 }, messages, log) {
+  if (closedEpics.length > 0) log(messages.closedEpics(closedEpics.join(", ")));
+  if (blockingFiles.length > 0) log(messages.epicsBlockedByFiles(blockingFiles.join(", ")));
+  if (deleted.length > 0) log(messages.deletedClosedTasks(deleted.join(", ")));
+  if (conflicts.length > 0) log(messages.conflictedDuringSweep(conflicts.join(", ")));
+  if (invalid2.length > 0) {
+    log(messages.invalidAfterSweep(invalid2.map(({ id, errors }) => `${id} (${errors.join("; ")})`).join(", ")));
+  }
+}
+
+// src/core/usage/transcripts.ts
+import { createHash as createHash3 } from "node:crypto";
+import { open, stat as stat2 } from "node:fs/promises";
+import { join as join16 } from "node:path";
+
+// src/core/stats/cost/attribute.ts
+import { z as z10 } from "zod";
+var FAST_SPEED = "fast";
+var CHARS_PER_TOKEN = 3;
+var PENDING_TOOL_LIMIT = 64;
+var ZONE_OFFSET_STEP_MS = 15 * 60 * 1e3;
+var BACKLOG_COMMAND = /(?:^|&&|\|\||;|\||\n)\s*(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*backlog(?=\s|$)/;
+var ZERO_TOKENS = { input: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0, output: 0 };
+var usageSchema = z10.object({
+  input_tokens: z10.number().optional(),
+  output_tokens: z10.number().optional(),
+  cache_read_input_tokens: z10.number().optional(),
+  cache_creation_input_tokens: z10.number().optional(),
+  speed: z10.string().optional(),
+  cache_creation: z10.object({ ephemeral_5m_input_tokens: z10.number().optional(), ephemeral_1h_input_tokens: z10.number().optional() }).passthrough().optional()
+}).passthrough();
+var assistantMessageSchema = z10.object({ id: z10.string().optional(), model: z10.string().optional(), usage: usageSchema.optional(), content: z10.array(z10.unknown()).optional() }).passthrough();
+var userMessageSchema = z10.object({ content: z10.unknown().optional() }).passthrough();
+var toolUseBlockSchema = z10.object({ type: z10.literal("tool_use"), id: z10.string(), name: z10.string(), input: z10.unknown().optional() }).passthrough();
+var toolResultBlockSchema = z10.object({ type: z10.literal("tool_result"), tool_use_id: z10.string().optional(), content: z10.unknown().optional() }).passthrough();
+var textBlockSchema = z10.object({ type: z10.literal("text"), text: z10.string() }).passthrough();
+var bashInputSchema = z10.object({ command: z10.string() }).passthrough();
+var lineSchema = z10.object({ type: z10.string().optional(), timestamp: z10.string().optional(), cwd: z10.string().optional(), isMeta: z10.boolean().optional(), message: z10.unknown().optional() }).passthrough();
+function newTranscriptState() {
+  return { hookOpen: false, lastModel: null, lastMessageId: null, pending: {}, pendingEstimates: [] };
+}
+function attributeLine(line, state) {
+  const parsed = lineSchema.safeParse(line);
+  if (!parsed.success) return [];
+  const { type, timestamp, cwd, isMeta, message } = parsed.data;
+  const context = { slot: typeof timestamp === "string" ? slotOf(timestamp) : "", cwd: cwd ?? "" };
+  if (type === "assistant") return attributeAssistant(message, state, context);
+  if (type === "user") return attributeUser(message, isMeta === true, state, context);
+  return [];
+}
+function attributeAssistant(rawMessage, state, context) {
+  const message = assistantMessageSchema.safeParse(rawMessage);
+  if (!message.success) return [];
+  const { id, model, usage, content } = message.data;
+  const buckets = [];
+  const repeatOfCountedMessage = id !== void 0 && id === state.lastMessageId;
+  if (model && model !== "<synthetic>" && usage && !repeatOfCountedMessage) {
+    const pricedModel = usage.speed === FAST_SPEED ? fastModel(model) : model;
+    state.lastModel = pricedModel;
+    state.lastMessageId = id ?? null;
+    const tokens = tokensFrom(usage);
+    if (state.hookOpen) buckets.push({ ...context, model: pricedModel, kind: "hook", tokens, hookTurns: 0 });
+    buckets.push(...drainEstimates(state, pricedModel));
+  }
+  if (content) for (const block of content) registerToolUseBlock(block, state);
+  return buckets;
+}
+function attributeUser(rawMessage, isMeta, state, context) {
+  const message = userMessageSchema.safeParse(rawMessage);
+  const content = message.success ? message.data.content : void 0;
+  if (isToolResultOnly(content)) {
+    resolveToolResults(content, state, context);
+    return [];
+  }
+  if (isMeta) {
+    const text = textOf(content);
+    if (isBacklogHookFeedback(text)) {
+      state.hookOpen = true;
+      return [{ ...context, model: state.lastModel ?? "unknown", kind: "hook", tokens: ZERO_TOKENS, hookTurns: 1 }];
+    }
+    if (!state.hookOpen && text.startsWith("Base directory for this skill:") && text.includes("/skills/backlog")) {
+      state.pendingEstimates.push({ kind: "skill", chars: text.length, ...context });
+    }
+    return [];
+  }
+  state.hookOpen = false;
+  return [];
+}
+function resolveToolResults(blocks, state, context) {
+  for (const raw of blocks) {
+    const block = toolResultBlockSchema.safeParse(raw);
+    if (!block.success || !block.data.tool_use_id) continue;
+    const kind = state.pending[block.data.tool_use_id];
+    if (!kind) continue;
+    if (!state.hookOpen) state.pendingEstimates.push({ kind, chars: textOf(block.data.content).length, ...context });
+    Reflect.deleteProperty(state.pending, block.data.tool_use_id);
+  }
+}
+function registerToolUseBlock(raw, state) {
+  const block = toolUseBlockSchema.safeParse(raw);
+  if (!block.success) return;
+  if (block.data.name === "Bash") {
+    const input = bashInputSchema.safeParse(block.data.input);
+    if (!input.success || !BACKLOG_COMMAND.test(input.data.command)) return;
+    state.pending[block.data.id] = "cli";
+    forgetOldestPending(state);
+  }
+}
+function forgetOldestPending(state) {
+  const ids = Object.keys(state.pending);
+  for (const id of ids.slice(0, Math.max(0, ids.length - PENDING_TOOL_LIMIT))) Reflect.deleteProperty(state.pending, id);
+}
+function flushEstimates(state) {
+  return state.lastModel === null ? [] : drainEstimates(state, state.lastModel);
+}
+function drainEstimates(state, model) {
+  const buckets = state.pendingEstimates.map(
+    (estimate) => ({
+      slot: estimate.slot,
+      cwd: estimate.cwd,
+      model,
+      kind: estimate.kind,
+      tokens: { ...ZERO_TOKENS, cacheWrite5m: Math.ceil(estimate.chars / CHARS_PER_TOKEN) },
+      hookTurns: 0
+    })
+  );
+  state.pendingEstimates = [];
+  return buckets;
+}
+function isToolResultOnly(content) {
+  return Array.isArray(content) && content.length > 0 && content.every((block) => toolResultBlockSchema.safeParse(block).success);
+}
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => {
+    const parsed = textBlockSchema.safeParse(block);
+    return parsed.success ? parsed.data.text : "";
+  }).join("");
+}
+function tokensFrom(usage) {
+  const creation = usage.cache_creation;
+  const cacheWrite5m = creation ? creation.ephemeral_5m_input_tokens ?? 0 : usage.cache_creation_input_tokens ?? 0;
+  const cacheWrite1h = creation ? creation.ephemeral_1h_input_tokens ?? 0 : 0;
+  return { input: usage.input_tokens ?? 0, cacheWrite5m, cacheWrite1h, cacheRead: usage.cache_read_input_tokens ?? 0, output: usage.output_tokens ?? 0 };
+}
+function slotOf(timestamp) {
+  const moment = Date.parse(timestamp);
+  return Number.isNaN(moment) ? "" : new Date(moment - moment % ZONE_OFFSET_STEP_MS).toISOString();
+}
+
+// src/core/usage/usage-cache.ts
+import { mkdir as mkdir2 } from "node:fs/promises";
+import { join as join15 } from "node:path";
+import { z as z11 } from "zod";
+var USAGE_CACHE_FILE = ".usage-cache.json";
+var USAGE_CACHE_VERSION = 6;
+var tokenCountsSchema = z11.object({
+  input: z11.number(),
+  cacheWrite5m: z11.number(),
+  cacheWrite1h: z11.number(),
+  cacheRead: z11.number(),
+  output: z11.number()
+});
+var usageBucketSchema = z11.object({
+  slot: z11.string(),
+  cwd: z11.string(),
+  model: z11.string(),
+  kind: z11.enum(["hook", "cli", "skill"]),
+  tokens: tokenCountsSchema,
+  hookTurns: z11.number()
+});
+var pendingEstimateSchema = z11.object({
+  kind: z11.enum(["cli", "skill"]),
+  chars: z11.number(),
+  slot: z11.string(),
+  cwd: z11.string()
+});
+var transcriptStateSchema = z11.object({
+  hookOpen: z11.boolean(),
+  lastModel: z11.string().nullable(),
+  lastMessageId: z11.string().nullable(),
+  pending: z11.record(z11.string(), z11.enum(["cli", "skill"])),
+  pendingEstimates: z11.array(pendingEstimateSchema)
+});
+var usageCacheEntrySchema = z11.object({
+  size: z11.number(),
+  offset: z11.number(),
+  fingerprint: z11.string(),
+  state: transcriptStateSchema,
+  buckets: z11.array(usageBucketSchema)
+});
+var usageCacheSchema = z11.object({
+  version: z11.literal(USAGE_CACHE_VERSION),
+  files: z11.record(z11.string(), usageCacheEntrySchema)
+});
+function emptyUsageCache() {
+  return { version: USAGE_CACHE_VERSION, files: {} };
+}
+async function readUsageCache(root) {
+  return await readJsonFile(join15(root, USAGE_CACHE_FILE), usageCacheSchema) ?? emptyUsageCache();
+}
+async function writeUsageCache(root, cache) {
+  await mkdir2(root, { recursive: true });
+  await writeFileAtomic(join15(root, USAGE_CACHE_FILE), JSON.stringify(cache));
+}
+
+// src/core/usage/transcripts.ts
+var NEWLINE = 10;
+var FINGERPRINT_BYTES = 256;
+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 = join16(claudeProjectsDir2, projectEntry.name);
+    for (const entry of await listDir(projectDir2)) {
+      const entryPath = join16(projectDir2, entry.name);
+      if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push(...await withSize(entryPath));
+        continue;
+      }
+      if (!entry.isDirectory()) continue;
+      for (const subagentEntry of await listDir(join16(entryPath, "subagents"), { recursive: true })) {
+        if (subagentEntry.isFile() && subagentEntry.name.endsWith(".jsonl")) files.push(...await withSize(join16(subagentEntry.parentPath, subagentEntry.name)));
+      }
+    }
+  }
+  return files;
+}
+async function withSize(path) {
+  try {
+    return [{ path, size: (await stat2(path)).size }];
+  } catch {
+    return [];
+  }
+}
+async function scanTranscripts({ files, cache, byteBudget }) {
+  let remainingBudget = byteBudget;
+  const resultFiles = {};
+  for (const file of files) {
+    const previous = cache.files[file.path];
+    const resumable = previous !== void 0 && file.size >= previous.size && await fingerprintOf(file.path, previous.offset) === previous.fingerprint;
+    const start = resumable ? { offset: previous.offset, state: structuredClone(previous.state), buckets: previous.buckets } : { offset: 0, state: newTranscriptState(), buckets: [] };
+    const chunkSize = Math.min(file.size - start.offset, remainingBudget);
+    const scanned = await scanChunk(file, start, chunkSize, byteBudget);
+    const unmoved = resumable && scanned.offset === previous.offset;
+    resultFiles[file.path] = { ...scanned, fingerprint: unmoved ? previous.fingerprint : await fingerprintOf(file.path, scanned.offset) };
+    if (chunkSize > 0) remainingBudget -= chunkSize;
+    await yieldToEventLoop();
+  }
+  return {
+    cache: { version: USAGE_CACHE_VERSION, files: resultFiles },
+    bytesRead: byteBudget - remainingBudget,
+    bytesLeft: sum(Object.values(resultFiles).map((entry) => entry.size - entry.offset)),
+    filesDone: Object.values(resultFiles).filter((entry) => entry.offset === entry.size).length
+  };
+}
+async function scanChunk(file, start, chunkSize, longestReadableLine) {
+  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 lastNewline = chunk.lastIndexOf(NEWLINE);
+  if (lastNewline === -1) {
+    const lineTooLong = chunk.length >= longestReadableLine;
+    return { size: file.size, offset: start.offset + (lineTooLong ? chunk.length : 0), state: start.state, buckets: start.buckets };
+  }
+  const bucketsByKey = new Map(start.buckets.map((bucket) => [bucketKey(bucket), bucket]));
+  for (const line of chunk.subarray(0, lastNewline).toString("utf8").split("\n")) {
+    if (!COUNTED_LINE_MARKERS.some((marker) => line.includes(marker))) continue;
+    const parsed = parseLineOrNull(line);
+    if (parsed === null) continue;
+    for (const addition of attributeLine(parsed, start.state)) addBucket(bucketsByKey, addition);
+  }
+  const offset = start.offset + lastNewline + 1;
+  if (offset === file.size) for (const addition of flushEstimates(start.state)) addBucket(bucketsByKey, addition);
+  return { size: file.size, offset, state: start.state, buckets: [...bucketsByKey.values()] };
+}
+async function fingerprintOf(path, offset) {
+  const edge = Math.min(FINGERPRINT_BYTES, offset);
+  const [head, tail] = await Promise.all([readChunk(path, 0, edge), readChunk(path, offset - edge, edge)]);
+  return createHash3("sha1").update(head).update(tail).digest("hex");
+}
+async function readChunk(path, position, length) {
+  const handle = await open(path, "r");
+  try {
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, position);
+    return buffer.subarray(0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+function parseLineOrNull(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function yieldToEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function addBucket(buckets, addition) {
+  const key = bucketKey(addition);
+  const existing = buckets.get(key);
+  buckets.set(key, existing === void 0 ? addition : combineBuckets(existing, addition));
+}
+function bucketKey(bucket) {
+  return JSON.stringify([bucket.slot, bucket.cwd, bucket.model, bucket.kind]);
+}
+function combineBuckets(existing, addition) {
+  return { ...existing, tokens: combineTokens(existing.tokens, addition.tokens), hookTurns: existing.hookTurns + addition.hookTurns };
+}
+function combineTokens(a, b) {
+  return { input: a.input + b.input, cacheWrite5m: a.cacheWrite5m + b.cacheWrite5m, cacheWrite1h: a.cacheWrite1h + b.cacheWrite1h, cacheRead: a.cacheRead + b.cacheRead, output: a.output + b.output };
+}
+
+// src/server/usage-scanner.ts
+var DEFAULT_BYTE_BUDGET = 16 * 1024 * 1024;
+var DEFAULT_INTERVAL_MS = 6e4;
+var CATCH_UP_DELAY_MS = 100;
+var NOT_LISTED = { listed: false, filesTotal: 0, filesDone: 0, bytesLeft: 0 };
+function createUsageScanner({
+  root,
+  claudeProjectsDir: claudeProjectsDir2,
+  byteBudget = DEFAULT_BYTE_BUDGET,
+  intervalMs = DEFAULT_INTERVAL_MS,
+  messages = () => Promise.resolve(serverRu)
+}) {
+  let cache = null;
+  let scan = NOT_LISTED;
+  let inFlight = null;
+  let timer = null;
+  let running = false;
+  let budgetExhausted = false;
+  const runPass = async () => {
+    const current = cache ?? await readUsageCache(root);
+    const files = await listTranscripts(claudeProjectsDir2);
+    scan = progressBefore(files, current);
+    const result = await scanTranscripts({ files, cache: current, byteBudget });
+    cache = result.cache;
+    scan = { listed: true, filesTotal: files.length, filesDone: result.filesDone, bytesLeft: result.bytesLeft };
+    budgetExhausted = result.bytesRead >= byteBudget;
+    if (result.bytesRead > 0) await writeUsageCache(root, result.cache);
+  };
+  const scanOnce = () => {
+    inFlight ??= runPass().catch(async (error) => {
+      budgetExhausted = false;
+      process.stderr.write(`${(await messages()).transcriptsScanFailed(errorText(error))}
+`);
+    }).finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  };
+  const tick = async () => {
+    await scanOnce();
+    if (running) timer = setTimeout(() => void tick(), budgetExhausted ? CATCH_UP_DELAY_MS : intervalMs);
+  };
+  return {
+    start: () => {
+      running = true;
+      void tick();
+    },
+    stop: () => {
+      running = false;
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+      return inFlight ?? Promise.resolve();
+    },
+    scanOnce,
+    ensureStarted: () => {
+      if (!scan.listed && inFlight === null) void scanOnce();
+    },
+    snapshot: () => ({ cache: cache ?? emptyUsageCache(), scan })
+  };
+}
+function progressBefore(files, cache) {
+  const offsetOf = (file) => {
+    const cached = cache.files[file.path];
+    return cached !== void 0 && file.size >= cached.size ? cached.offset : 0;
+  };
+  return {
+    listed: true,
+    filesTotal: files.length,
+    filesDone: files.filter((file) => offsetOf(file) === file.size).length,
+    bytesLeft: sum(files.map((file) => file.size - offsetOf(file)))
+  };
+}
+
+// src/server/start.ts
+var SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
+async function startServer({ root, port, home: home2, env, pidFile }) {
+  await mkdir3(root, { recursive: true });
+  const settled = await settledLanguage(root, env);
+  const startupMessages = serverMessages(settled.language);
+  if (settled.invalidSettingsFile) process.stderr.write(`${startupMessages.settingsFileInvalid(settingsFilePath(root))}
+`);
+  const readMessages = () => serverLanguage(root).then(serverMessages);
+  const usage = createUsageScanner({ root, claudeProjectsDir: claudeProjectsDir(env, home2), messages: readMessages });
+  const memory = createMemorySampler();
+  const changes = createChangeFeed(root, CHANGE_DEBOUNCE_MS, readMessages);
+  const hostsForActualPort = /* @__PURE__ */ new Set();
+  const app = createApp({ root, changes, allowedHosts: hostsForActualPort, home: home2, usage, memory, staticDir: join17(import.meta.dirname, "web") });
+  const sweepAll = async (now) => {
+    const language = await serverLanguage(root);
+    await trimRuns(root, now).catch((error) => process.stderr.write(`${serverMessages(language).runsTrimFailed(errorText(error))}
+`));
+    return sweepClosed(root, now, coreMessages(language));
+  };
+  let stopSweeper = () => Promise.resolve();
+  const startBackground = () => {
+    usage.start();
+    memory.start();
+    stopSweeper = startSweeper({
+      sweep: () => sweepAll(/* @__PURE__ */ new Date()),
+      intervalMs: SWEEP_INTERVAL_MS,
+      log: (line) => process.stdout.write(`${line}
+`),
+      warn: (line) => process.stderr.write(`${line}
+`),
+      messages: readMessages
+    });
+  };
+  const stopBackground = async () => {
+    await usage.stop();
+    memory.stop();
+    await stopSweeper();
+  };
+  return new Promise((resolve, reject) => {
+    let listening = false;
+    let decided = false;
+    const closeServer = () => new Promise((resolveClose, rejectClose) => server.close((error) => error ? rejectClose(error) : resolveClose()));
+    const teardown = async () => {
+      await stopBackground();
+      await changes.close();
+      if (pidFile !== void 0) await rm4(pidFile, { force: true });
+      if (listening) await closeServer();
+    };
+    const finish = async (actualPort) => {
+      if (pidFile !== void 0) await writeFile3(pidFile, String(process.pid));
+      if (decided) return;
+      decided = true;
+      resolve({ port: actualPort, close: teardown });
+    };
+    const failStartup = async (error) => {
+      decided = true;
+      await teardown();
+      reject(error);
+    };
+    const reportErrorAfterStartup = (error) => {
+      process.stderr.write(`${errorText(error)}
+`);
+    };
+    const onPidFileError = (error) => {
+      if (decided) reportErrorAfterStartup(error);
+      else void failStartup(error);
+    };
+    const onSocketError = (error) => {
+      if (decided) reportErrorAfterStartup(error);
+      else void failStartup(new Error(listenFailure(error, port, startupMessages)));
+    };
+    const server = serve({ fetch: app.fetch, hostname: "127.0.0.1", port }, (info) => {
+      listening = true;
+      for (const host of localHosts(info.port)) hostsForActualPort.add(host);
+      startBackground();
+      process.stdout.write(startupMessages.serverStarted(info.port, root));
+      void finish(info.port).catch(onPidFileError);
+    });
+    server.on("error", onSocketError);
+  });
+}
+
+// src/server/main.ts
+suppressSqliteExperimentalWarning();
+var home = homedir();
+try {
+  await startServer({
+    root: resolveBacklogRoot(process.env, home),
+    port: readPort(process.env.PORT),
+    home,
+    env: process.env,
+    pidFile: process.env.P_BACKLOG_PID_FILE
+  });
+} catch (error) {
+  process.stderr.write(`${errorText(error)}
+`);
+  process.exit(1);
+}