p-backlog 0.3.0 → 0.4.0

package/dist/cli.js

@@ -170,6 +170,17 @@ function completedEpicChildren(task, index) {
   const complete = children.length > 0 && children.every((child) => isClosed(child.status));
   return complete ? children.map((child) => child.id) : null;
 }
+function isAutoClosedEpic(task) {
+  return task.type === "epic" && isClosed(task.status) && task.resolution === "epic-done";
+}
+function planEpicReopening(tasks) {
+  const index = buildIndex(tasks);
+  return tasks.flatMap((epic) => {
+    if (!isAutoClosedEpic(epic)) return [];
+    const openChildIds = epicChildren(epic, index).flatMap((child) => isClosed(child.status) ? [] : [child.id]);
+    return openChildIds.length === 0 ? [] : [{ epic, childIds: openChildIds }];
+  });
+}
 function epicDoneClosure(childIds, messages) {
   return { resolution: "epic-done", reason: messages.epicDoneReason(childIds) };
 }
@@ -936,18 +947,18 @@ function compareIds(a, b) {
   if (!left || !right) return a.localeCompare(b);
   return left.prefix === right.prefix ? left.number - right.number : left.prefix.localeCompare(right.prefix);
 }
-function derivePrefix(basename10, taken) {
-  const base = prefixBase(basename10);
+function derivePrefix(basename11, taken) {
+  const base = prefixBase(basename11);
   return firstFree(base, taken, (n) => `${base}${n}`);
 }
-function deriveProjectId(basename10, taken) {
-  const slug = basename10.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+function deriveProjectId(basename11, taken) {
+  const slug = basename11.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   const base = slug === "" ? "project" : slug;
   return firstFree(base, taken, (n) => `${base}-${n}`);
 }
 var PREFIX_BASE_LENGTH = 4;
-function prefixBase(basename10) {
-  const words = basename10.split(/[^A-Za-z0-9]+/).filter(Boolean);
+function prefixBase(basename11) {
+  const words = basename11.split(/[^A-Za-z0-9]+/).filter(Boolean);
   const letters = words.length > 1 ? words.map((word) => word.charAt(0)).join("") : words[0] ?? "";
   const prefix = letters.slice(0, PREFIX_BASE_LENGTH).toUpperCase();
   if (prefix === "") return "PROJ";
@@ -1040,7 +1051,7 @@ function recordedMethodOf({ method, bySymbol, byAnchor }) {
   if (method !== void 0) return method;
   return bySymbol === true || byAnchor === true ? checkMethodOf({ bySymbol, byAnchor }) : "unknown";
 }
-var eventBase = { at: z4.iso.datetime({ offset: true }), task: z4.string().min(1), via: recordedEnum(CHANGE_SOURCES) };
+var eventBase = { at: z4.iso.datetime({ offset: true }), task: z4.string().min(1), via: recordedEnum(CHANGE_SOURCES), undo: z4.literal(true).optional().catch(void 0) };
 var taskSnapshotSchema = taskFrontmatterSchema.extend({
   priority: recordedEnum(PRIORITIES),
   category: recordedEnum(TASK_CATEGORIES).optional(),
@@ -1129,6 +1140,10 @@ function changeEvents(before, after, now, via) {
   }
   return events;
 }
+function statusBeforeAutoClose(journal, epicId) {
+  const autoClose = journal.findLast((event) => event.task === epicId && event.kind === "status" && event.resolution === "epic-done");
+  return autoClose?.kind === "status" && !isClosed(autoClose.from) ? autoClose.from : "backlog";
+}
 function deletedEvent(task, now, via) {
   return { at: formatLocalIso(now), task: task.id, via, kind: "deleted", snapshot: snapshotOf(task) };
 }
@@ -1164,13 +1179,26 @@ function candidateGoneEvents(sightings, tasks, states, now, checked = CANDIDATE_
 }
 function episodeStates(journal) {
   const states = /* @__PURE__ */ new Map();
+  const beforeClosing = /* @__PURE__ */ new Map();
   for (const event of journal) {
     if (event.kind === "candidate") states.set(episodeKey(event.task, event.evidence), "open");
     else if (event.kind === "candidate-gone") states.set(episodeKey(event.task, event.evidence), "ended");
-    else if (endsEpisodes(event)) for (const evidence2 of CANDIDATE_EVIDENCE) states.set(episodeKey(event.task, evidence2), "ended");
+    else if (undoesClosing(event)) {
+      for (const [key, state] of beforeClosing.get(event.task) ?? []) {
+        if (state === void 0) states.delete(key);
+        else states.set(key, state);
+      }
+    } else if (endsEpisodes(event)) {
+      const keys = CANDIDATE_EVIDENCE.map((evidence2) => episodeKey(event.task, evidence2));
+      if (event.kind === "status") beforeClosing.set(event.task, keys.map((key) => [key, states.get(key)]));
+      for (const key of keys) states.set(key, "ended");
+    }
   }
   return states;
 }
+function undoesClosing(event) {
+  return event.kind === "status" && event.undo === true && isClosed(event.from) && !isClosed(event.to);
+}
 function endsEpisodes(event) {
   if (event.kind === "verified" || event.kind === "deleted") return true;
   return event.kind === "status" && isClosed(event.to);
@@ -1203,7 +1231,7 @@ function taskHistories(tasks, journals, unparsedIds = /* @__PURE__ */ new Set())
       if (event.kind === "category") item.categoryEvents.push({ at: Date.parse(event.at), to: event.to });
       if (event.kind === "priority") item.priorityEvents.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 });
+        item.transitions.push({ at: Date.parse(event.at), from: event.from, to: event.to, resolution: event.resolution, via: event.via, undo: event.undo });
       }
       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));
@@ -1235,7 +1263,7 @@ function historyOf(id, { projectId, final, created, categoryEvents, priorityEven
   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);
+  const ordered = withoutUndoneClosings([...transitions].sort((a, b) => a.at - b.at));
   const fateUnknown = final === void 0 && unparsed;
   return [
     {
@@ -1257,6 +1285,15 @@ function historyOf(id, { projectId, final, created, categoryEvents, priorityEven
     }
   ];
 }
+function withoutUndoneClosings(ordered) {
+  const kept = [];
+  for (const transition of ordered) {
+    const lastKept = kept.at(-1);
+    if (transition.undo === true && lastKept !== void 0 && isClosing(lastKept) && transition.from === lastKept.to) kept.pop();
+    else kept.push(transition);
+  }
+  return kept;
+}
 function categoryOf(final, created, categoryEvents) {
   if (final !== void 0) return final.category;
   const lastCategoryEvent = [...categoryEvents].sort((a, b) => a.at - b.at).at(-1);
@@ -1462,6 +1499,8 @@ function problem(p) {
       return `epic ${p.epic} not found`;
     case "epic-not-epic":
       return `${p.epic} is not an epic`;
+    case "epic-foreign-project":
+      return `epic ${p.epic} belongs to another project \u2014 clear the epic or pick one from this project`;
     case "epic-in-epic":
       return "an epic cannot belong to another epic";
     case "reference-missing":
@@ -1494,6 +1533,8 @@ function checkFix(fix) {
       return `${fix.taskId}: removed references to missing tasks: ${fix.ids.join(", ")}`;
     case "epic-closed":
       return `${fix.taskId}: epic closed \u2014 ${epicDoneReason(fix.childIds)}`;
+    case "epic-reopened":
+      return `${fix.taskId}: epic reopened \u2014 it has open tasks: ${fix.childIds.join(", ")}`;
     case "source-moved":
       return `${fix.taskId}: source moved ${lineSuffix(fix.from)} \u2192 ${lineSuffix(fix.to)}`;
   }
@@ -1691,6 +1732,8 @@ function problem2(p) {
       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-foreign-project":
+      return `\u044D\u043F\u0438\u043A ${p.epic} \u0438\u0437 \u0434\u0440\u0443\u0433\u043E\u0433\u043E \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u2014 \u0441\u043D\u0438\u043C\u0438\u0442\u0435 \u044D\u043F\u0438\u043A \u0438\u043B\u0438 \u0432\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u044D\u043F\u0438\u043A \u044D\u0442\u043E\u0433\u043E \u043F\u0440\u043E\u0435\u043A\u0442\u0430`;
     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":
@@ -1723,6 +1766,8 @@ function checkFix2(fix) {
       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 "epic-reopened":
+      return `${fix.taskId}: \u044D\u043F\u0438\u043A \u0441\u043D\u043E\u0432\u0430 \u043E\u0442\u043A\u0440\u044B\u0442 \u2014 \u0432 \u043D\u0451\u043C \u043E\u0442\u043A\u0440\u044B\u0442\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438: ${fix.childIds.join(", ")}`;
     case "source-moved":
       return `${fix.taskId}: source \u0441\u0434\u0432\u0438\u043D\u0443\u043B\u0441\u044F ${lineSuffix(fix.from)} \u2192 ${lineSuffix(fix.to)}`;
   }
@@ -2001,7 +2046,7 @@ function isTaskFileName(name) {
 }
 
 // src/cli/lookups.ts
-import { basename as basename6, dirname as dirname3, relative as relative2, sep as sep2 } from "node:path";
+import { basename as basename6, dirname as dirname4, relative as relative2, sep as sep2 } from "node:path";
 
 // src/core/store/create.ts
 import { mkdir as mkdir3 } from "node:fs/promises";
@@ -2035,6 +2080,7 @@ function epicProblems(candidate, resolve7) {
     const epic = resolve7(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 });
+    else if (epic.projectId !== candidate.projectId) problems3.push({ code: "epic-foreign-project", epic: candidate.epic });
   }
   if (candidate.type === "epic") problems3.push({ code: "epic-in-epic" });
   return problems3;
@@ -2134,11 +2180,93 @@ function taskText(draft) {
   return { ok: true, value: { text, task: { ...parsed.value, version: contentVersion(text) } } };
 }
 
+// src/core/store/update.ts
+import { dirname as dirname3 } from "node:path";
+
 // 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, request) {
+  const before = index.byId.get(request.id);
+  const result = await writeChanges(index, request);
+  if (result.ok) await reopenEpicOfOpenedTask(index, { before, after: result.task, now: request.now, via: request.via, undo: request.undo });
+  return result;
+}
+async function statusToReopen(epic) {
+  const { events } = await readJournal(dirname3(epic.path), epic.projectId);
+  return statusBeforeAutoClose(events, epic.id);
+}
+async function reopenEpicOfOpenedTask(index, { before, after, now, via, undo }) {
+  if (after.epic === void 0 || isClosed(after.status)) return;
+  const becameOpenInEpic = before === void 0 || isClosed(before.status) || before.epic !== after.epic;
+  const epic = index.byId.get(after.epic);
+  if (!becameOpenInEpic || epic === void 0 || !isAutoClosedEpic(epic)) return;
+  try {
+    if (await diskChange(epic, epic.version) !== null) return;
+    await writeChanges(index, { id: epic.id, changes: { status: await statusToReopen(epic) }, expectedVersion: epic.version, now, via, undo });
+  } catch (error) {
+    if (!(error instanceof FileBusyError)) console.error(`${epic.path}: ${errorText(error)}`);
+  }
+}
+async function writeChanges(index, { id, changes, expectedVersion, now, closure, via, undo = false }) {
+  const current = index.byId.get(id);
+  if (!current) return { ok: false, reason: "not-found" };
+  if (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 = await diskChange(current, expectedVersion);
+    if (changedOnDisk !== null) return changedOnDisk;
+    await writeFileAtomic(current.path, text);
+    const events = changeEvents(current, task, now, via);
+    await appendJournal(dirname3(current.path), undo ? events.map((event) => ({ ...event, undo: true })) : events);
+    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/create.ts
 var MAX_ID_ATTEMPTS = 20;
 async function createTask(root, request) {
@@ -2156,6 +2284,7 @@ async function createTask(root, request) {
     try {
       await createFileAtomic(path, text);
       await appendJournal(dir, [createdEvent(task, request.now, request.via, request.provenance)]);
+      await reopenEpicOfOpenedTask(index, { before: void 0, after: task, now: request.now, via: request.via });
       return { ok: true, task };
     } catch (error) {
       if (!hasErrorCode(error, "EEXIST")) throw error;
@@ -2166,7 +2295,8 @@ async function createTask(root, request) {
 async function createProject(root, repoRoot, existingProjects) {
   const name = basename5(repoRoot);
   const entries = await listDir(root);
-  const id = deriveProjectId(name, new Set(entries.map((entry) => entry.name)));
+  const joinable = await Promise.all(entries.map((entry) => entry.isDirectory() && isJoinableProjectDir(join9(root, entry.name), repoRoot)));
+  const id = deriveProjectId(name, new Set(entries.filter((_, index) => !joinable[index]).map((entry) => entry.name)));
   const prefixesOnDisk = await Promise.all(entries.filter((entry) => entry.isDirectory()).map((entry) => takenPrefixes(join9(root, entry.name))));
   const prefix = derivePrefix(name, /* @__PURE__ */ new Set([...existingProjects.map((project) => project.prefix), ...prefixesOnDisk.flat()]));
   const dir = join9(root, id);
@@ -2184,6 +2314,11 @@ async function createProject(root, repoRoot, existingProjects) {
   if (!parsed.ok) throw new Error(`${path}: ${parsed.problems.map((problem3) => problem3.code).join(", ")}`);
   return parsed.value;
 }
+async function isJoinableProjectDir(dir, repoRoot) {
+  const path = join9(dir, PROJECT_FILE);
+  if (await readTextOrNull(path) !== null) return await projectOfRepo(basename5(dir), path, repoRoot) !== null;
+  return (await listDir(dir)).every((entry) => !entry.name.endsWith(".md"));
+}
 async function projectOfRepo(id, path, repoRoot) {
   const parsed = await readProjectFile({ id, path });
   return parsed?.ok === true && parsed.value.repos.includes(repoRoot) ? parsed.value : null;
@@ -2424,7 +2559,7 @@ async function brokenProjectFilesOf(loaded, roots, home2) {
   const ownId = deriveProjectId(basename6(roots.main), /* @__PURE__ */ new Set());
   const broken = loaded.errors.filter((error) => basename6(error.path) === PROJECT_FILE);
   const texts = await Promise.all(broken.map(async (error) => await readTextOrNull(error.path) ?? ""));
-  return broken.filter((error, position) => basename6(dirname3(error.path)) === ownId || repoPaths.some((path) => mentionsPath(texts[position] ?? "", path)));
+  return broken.filter((error, position) => basename6(dirname4(error.path)) === ownId || repoPaths.some((path) => mentionsPath(texts[position] ?? "", path)));
 }
 var PATH_BOUNDARY = /[\s"',[\]]/;
 var TRAILING_SEPARATORS = /^[\\/]*/;
@@ -2446,63 +2581,6 @@ function findProject(loaded, io, explicitId) {
   return explicitId === void 0 ? findProjectForDir(loaded.projects, io.cwd, io.home) : loaded.projects.find((project) => project.id === explicitId);
 }
 
-// src/core/store/update.ts
-import { dirname as dirname4 } from "node:path";
-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 !== 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 = await diskChange(current, expectedVersion);
-    if (changedOnDisk !== null) return changedOnDisk;
-    await writeFileAtomic(current.path, text);
-    await appendJournal(dirname4(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/cli/update-failure.ts
 function reportUpdateFailure(io, id, result) {
   switch (result.reason) {
@@ -3384,14 +3462,12 @@ function sightingOf(candidate) {
 }
 async function applyFixes(loaded, inScope, { now, messages }) {
   const isGone = goneTaskCheck(loaded);
-  const epicClosures = new Map(
-    planEpicClosing(loaded.tasks, loaded.errors).close.map(({ epic, childIds }) => [epic.id, { closure: epicDoneClosure(childIds, messages), childIds }])
-  );
+  const epicFixes = await epicStatusFixes(loaded, inScope, messages);
   const index = buildIndex(loaded.tasks);
   const fixed = [];
   const failed = [];
   for (const task of loaded.tasks.filter((candidate) => inScope(candidate.projectId))) {
-    const fix = planFix(task, isGone, epicClosures.get(task.id));
+    const fix = planFix(task, isGone, epicFixes.get(task.id));
     if (fix === null) continue;
     const result = await updateTaskInIndex(index, { id: task.id, changes: fix.changes, expectedVersion: task.version, now, closure: fix.closure, via: "check" });
     if (result.ok) fixed.push(...fix.done);
@@ -3409,14 +3485,24 @@ function fixFailure(taskId, failure) {
       return { kind: "fix-failed", taskId, cause: "gone-during-check" };
   }
 }
-function planFix(task, isGone, epicClosing) {
+async function epicStatusFixes(loaded, inScope, messages) {
+  const closing = planEpicClosing(loaded.tasks, loaded.errors).close.map(({ epic, childIds }) => [
+    epic.id,
+    { status: "done", closure: epicDoneClosure(childIds, messages), done: { kind: "epic-closed", taskId: epic.id, childIds } }
+  ]);
+  const reopenable = planEpicReopening(loaded.tasks).filter(({ epic }) => inScope(epic.projectId));
+  const reopening = await Promise.all(
+    reopenable.map(async ({ epic, childIds }) => [epic.id, { status: await statusToReopen(epic), done: { kind: "epic-reopened", taskId: epic.id, childIds } }])
+  );
+  return new Map([...closing, ...reopening]);
+}
+function planFix(task, isGone, epicFix) {
   const cleanup = referenceCleanup(task, isGone);
-  if (cleanup === null && epicClosing === void 0) return null;
+  if (cleanup === null && epicFix === void 0) return null;
   const done = [];
   if (cleanup !== null) done.push({ kind: "references-removed", taskId: task.id, ids: goneReferences(task, isGone) });
-  if (epicClosing === void 0) return { changes: cleanup ?? {}, done };
-  done.push({ kind: "epic-closed", taskId: task.id, childIds: epicClosing.childIds });
-  return { changes: { ...cleanup, status: "done" }, closure: epicClosing.closure, done };
+  if (epicFix === void 0) return { changes: cleanup ?? {}, done };
+  return { changes: { ...cleanup, status: epicFix.status }, closure: epicFix.closure, done: [...done, epicFix.done] };
 }
 function goneReferences(task, isGone) {
   const references = [...task.blockedBy, ...task.related, ...task.epic === void 0 ? [] : [task.epic]];
@@ -4603,6 +4689,13 @@ var serverEn = {
   projectNotFound: (id) => `Project ${id} not found`,
   confirmMismatch: "Confirmation does not match the project id",
   bodyNotParsed: "Request body could not be parsed: JSON expected",
+  batchSkipped: {
+    changed: (id) => `${id} changed on disk`,
+    "not-found": (id) => `${id} not found`,
+    "already-closed": (id) => `${id} is already closed`,
+    invalid: (id) => `${id}: the action doesn't apply to it`,
+    busy: (id) => `${id} is busy in another process`
+  },
   unknownRoute: (path) => `Unknown API route: ${path}`,
   hostRejected: (host) => `Requests from host ${host} are not accepted`,
   jsonContentTypeExpected: "Content-Type: application/json is expected",
@@ -4613,6 +4706,7 @@ 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}`,
+  reopenedEpics: (ids) => `Reopened epics that got an open task again: ${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}`,
@@ -4633,6 +4727,13 @@ var serverRu = {
   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",
+  batchSkipped: {
+    changed: (id) => `${id} \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u0430\u0441\u044C \u043D\u0430 \u0434\u0438\u0441\u043A\u0435`,
+    "not-found": (id) => `${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430`,
+    "already-closed": (id) => `${id} \u0443\u0436\u0435 \u0437\u0430\u043A\u0440\u044B\u0442\u0430`,
+    invalid: (id) => `${id}: \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0435 \u043A \u043D\u0435\u0439 \u043D\u0435 \u043F\u043E\u0434\u0445\u043E\u0434\u0438\u0442`,
+    busy: (id) => `${id} \u0437\u0430\u043D\u044F\u0442\u0430 \u0434\u0440\u0443\u0433\u0438\u043C \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u043E\u043C`
+  },
   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",
@@ -4643,6 +4744,7 @@ var serverRu = {
   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}`,
+  reopenedEpics: (ids) => `\u0421\u043D\u043E\u0432\u0430 \u043E\u0442\u043A\u0440\u044B\u0442\u044B \u044D\u043F\u0438\u043A\u0438, \u0432 \u043A\u043E\u0442\u043E\u0440\u044B\u0445 \u043E\u0442\u043A\u0440\u044B\u043B\u0438 \u0437\u0430\u0434\u0430\u0447\u0443: ${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}`,
@@ -4692,19 +4794,22 @@ import { join as join25 } from "node:path";
 import { dirname as dirname7, join as join20 } from "node:path";
 async function sweepClosed(root, now, messages) {
   const initial = await loadBacklog(root);
+  const reopening = await reopenEpicsWithOpenTasks(initial, now);
   const epics = await closeCompletedEpics(initial, now, messages);
-  const { projects, tasks } = epics.closed.length > 0 ? await loadBacklog(root) : initial;
+  const { projects, tasks } = epics.closed.length > 0 || reopening.reopened.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 stillHoldsOpenTasks = new Set(planEpicReopening(tasks).map(({ epic }) => epic.id));
+  const expired = tasks.filter((task) => isExpired(task, now) && !waitsForEpic(task) && !stillHoldsOpenTasks.has(task.id));
   const reserved = await reserveNumbers(projects, expired);
   const removable = expired.filter((task) => reserved.has(task.projectId));
   const removal = await removeWithReferences(tasks, removable, now);
   await removeAbandonedTemporaries(root, now);
   return {
     closedEpics: epics.closed,
+    reopenedEpics: reopening.reopened,
     blockingFiles: epics.blockingFiles,
     deleted: removal.deleted,
-    ...failureLists([...epics.failures, ...removal.failures], messages)
+    ...failureLists([...reopening.failures, ...epics.failures, ...removal.failures], messages)
   };
 }
 async function removeAbandonedTemporaries(root, now) {
@@ -4735,6 +4840,17 @@ async function unchangedOnDisk(tasks) {
   );
   return tasks.filter((_, position) => checked[position]);
 }
+async function reopenEpicsWithOpenTasks(loaded, now) {
+  const index = buildIndex(loaded.tasks);
+  const reopened = [];
+  const failures = [];
+  for (const { epic } of planEpicReopening(loaded.tasks)) {
+    const failure = await repairFailure(index, epic, { status: await statusToReopen(epic) }, now);
+    if (failure === null) reopened.push(epic.id);
+    else failures.push(failure);
+  }
+  return { reopened, failures };
+}
 async function closeCompletedEpics(loaded, now, messages) {
   const plan = planEpicClosing(loaded.tasks, loaded.errors);
   const index = buildIndex(loaded.tasks);
@@ -4850,6 +4966,23 @@ var updateTaskRequestSchema = z12.strictObject({
   version: z12.string().min(1),
   changes: taskChangesSchema
 });
+var batchPreviousSchema = z12.strictObject({
+  status: z12.enum(TASK_STATUSES),
+  priority: z12.enum(PRIORITIES),
+  epic: taskIdSchema.nullable(),
+  resolution: z12.enum(RESOLUTIONS).nullable(),
+  reason: z12.string().nullable()
+});
+var BATCH_TASKS_LIMIT = 500;
+var batchRequestSchema = z12.strictObject({
+  tasks: z12.array(z12.strictObject({ id: taskIdSchema, version: z12.string().min(1) })).min(1).max(BATCH_TASKS_LIMIT).refine((tasks) => new Set(tasks.map((task) => task.id)).size === tasks.length),
+  action: z12.discriminatedUnion("kind", [
+    z12.strictObject({ kind: z12.literal("close"), reason: z12.string().transform((reason) => reason.replace(/\s*\n\s*/g, " ").trim()).pipe(z12.string().min(1)) }),
+    z12.strictObject({ kind: z12.literal("priority"), priority: z12.enum(PRIORITIES) }),
+    z12.strictObject({ kind: z12.literal("epic"), epic: taskIdSchema.nullable() }),
+    z12.strictObject({ kind: z12.literal("restore"), changes: z12.record(taskIdSchema, batchPreviousSchema) })
+  ])
+});
 
 // src/core/check/graph-health.ts
 async function projectGraphHealth(project, tasks, home2) {
@@ -4879,6 +5012,58 @@ function isStale(graph, pinned, hashOf) {
   return count3("changed") > count3("fresh");
 }
 
+// src/core/store/batch.ts
+async function applyBatch(index, { tasks, action, now }) {
+  const ordered = [...tasks].sort((left, right) => compareIds(left.id, right.id));
+  const outcomes = [];
+  for (const task of ordered) outcomes.push(await applyOne(index, task, action, now));
+  return outcomes;
+}
+async function applyOne(index, { id, version }, action, now) {
+  const current = index.byId.get(id);
+  if (!current) return { id, outcome: "skipped", reason: "not-found" };
+  const plan = planFor(current, action);
+  if ("skip" in plan) return { id, outcome: "skipped", reason: plan.skip };
+  const result = await updateUnlessBusy(index, { id, changes: plan.changes, closure: plan.closure, expectedVersion: version, now, via: "web", undo: action.kind === "restore" });
+  if (result === "busy") return { id, outcome: "skipped", reason: "busy" };
+  if (result.ok) return { id, outcome: "done", task: result.task, previous: previousOf(current) };
+  if (result.reason === "conflict") return { id, outcome: "skipped", reason: "changed" };
+  if (result.reason === "not-found") return { id, outcome: "skipped", reason: "not-found" };
+  return { id, outcome: "skipped", reason: "invalid", problems: result.errors };
+}
+async function updateUnlessBusy(index, request) {
+  try {
+    return await updateTaskInIndex(index, request);
+  } catch (error) {
+    if (error instanceof FileBusyError) return "busy";
+    throw error;
+  }
+}
+function planFor(current, action) {
+  switch (action.kind) {
+    case "close":
+      return isClosed(current.status) ? { skip: "already-closed" } : { changes: { status: "cancelled" }, closure: { resolution: "obsolete", reason: action.reason } };
+    case "priority":
+      return { changes: { priority: action.priority } };
+    case "epic":
+      return epicPlan(current, action.epic);
+    case "restore":
+      return restorePlan(current, action.changes[current.id]);
+  }
+}
+function epicPlan(current, epic) {
+  return current.type === "epic" ? { skip: "invalid" } : { changes: { epic } };
+}
+function restorePlan(current, previous) {
+  if (!previous) return { skip: "invalid" };
+  const wouldClose = previous.status !== current.status && isClosed(previous.status);
+  if (wouldClose) return { skip: "invalid" };
+  return { changes: { status: previous.status, priority: previous.priority, epic: previous.epic } };
+}
+function previousOf(task) {
+  return { status: task.status, priority: task.priority, epic: task.epic ?? null, resolution: task.resolution ?? null, reason: task.reason ?? null };
+}
+
 // src/server/report-cache.ts
 function createReportCache({ ttlMs, now }) {
   let entries = /* @__PURE__ */ new Map();
@@ -4898,6 +5083,44 @@ function createReportCache({ ttlMs, now }) {
   };
 }
 
+// src/server/revisions.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { stat as stat4 } from "node:fs/promises";
+import { basename as basename9 } from "node:path";
+function createRevisions(boot = randomUUID3()) {
+  let seq = 0;
+  const ownMarks = /* @__PURE__ */ new Map();
+  const isOwn = async (path) => {
+    if (basename9(path) === JOURNAL_FILE) return true;
+    const expected = ownMarks.get(path);
+    ownMarks.delete(path);
+    if (expected === void 0) return false;
+    const actual = await markOf(path);
+    return actual !== null && actual.version === expected.version && actual.mtimeMs === expected.mtimeMs;
+  };
+  return {
+    current: () => ({ boot, seq }),
+    recordOwnWrites: async (writes) => {
+      const marks = await Promise.all(writes.map(async ({ path }) => ({ path, mark: await markOf(path) })));
+      seq += 1;
+      marks.forEach(({ path, mark }, index) => {
+        if (mark !== null && mark.version === writes[index]?.version) ownMarks.set(path, mark);
+        else ownMarks.delete(path);
+      });
+    },
+    settle: async (paths) => {
+      const own = paths.length > 0 && (await Promise.all(paths.map((path) => isOwn(path).catch(() => false)))).every(Boolean);
+      if (own) return "own";
+      seq += 1;
+      return "foreign";
+    }
+  };
+}
+async function markOf(path) {
+  const [text, stats] = await Promise.all([readTextOrNull(path), stat4(path).catch(() => null)]);
+  return text === null || stats === null ? null : { version: contentVersion(text), mtimeMs: stats.mtimeMs };
+}
+
 // src/server/stats-api.ts
 import { Hono } from "hono";
 
@@ -5880,9 +6103,10 @@ async function resolveRepoRoots(lookupRepoRoot, cwds) {
 var GRAPH_STATE_TTL_MS = 60 * 1e3;
 function createApi({ root, readLanguage: readLanguage2, changes, now, home: home2, usage, memory, warn: warn2 }) {
   const api = new Hono2();
+  const revisions = createRevisions();
   let snapshot = null;
   const backlog = () => {
-    snapshot ??= loadSnapshot(root).catch((error) => {
+    snapshot ??= loadSnapshot(root, revisions.current()).catch((error) => {
       snapshot = null;
       throw error;
     });
@@ -5895,19 +6119,29 @@ function createApi({ root, readLanguage: readLanguage2, changes, now, home: home
     stats.forget();
     graphStates.clear();
   };
-  changes.subscribe(forgetBacklog);
+  const recordOwnWrites = async (writes) => {
+    if (writes.length > 0) await revisions.recordOwnWrites(writes);
+    forgetBacklog();
+  };
+  const streams = /* @__PURE__ */ new Set();
+  changes.subscribe(async (paths) => {
+    if (await revisions.settle(paths) === "foreign") forgetBacklog();
+    else stats.forget();
+    const revision = revisions.current();
+    for (const send of streams) send(revision);
+  });
   api.get("/projects", async (c) => {
-    const { projects, tasks } = await backlog();
+    const { projects, tasks, revision } = await backlog();
     const withGraph = async (project) => {
       const codeGraph2 = await graphStates.get(project.id, async () => (await projectGraphHealth(project, tasks, home2)).state);
       return { ...project, codeGraph: codeGraph2 };
     };
-    return c.json(await Promise.all(projects.map(withGraph)));
+    return c.json({ projects: await Promise.all(projects.map(withGraph)), revision });
   });
   api.get("/tasks", async (c) => {
-    const [{ tasks, errors }, language] = await Promise.all([backlog(), readLanguage2()]);
+    const [{ tasks, errors, revision }, language] = await Promise.all([backlog(), readLanguage2()]);
     const messages = coreMessages(language);
-    return c.json({ tasks, errors: errors.map(({ problems: problems3, ...error }) => ({ ...error, message: messages.problems(problems3) })) });
+    return c.json({ tasks, errors: errors.map(({ problems: problems3, ...error }) => ({ ...error, message: messages.problems(problems3) })), revision });
   });
   api.route("/", stats.routes);
   api.get("/settings", async (c) => c.json({ language: await readLanguage2() }));
@@ -5923,13 +6157,26 @@ function createApi({ root, readLanguage: readLanguage2, changes, now, home: home
     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();
+    await recordOwnWrites(result.ok ? [result.task] : []);
     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.post("/tasks/batch", async (c) => {
+    const body = await readBody(c, batchRequestSchema, readLanguage2);
+    if (!body.ok) return body.response;
+    const { index } = await backlog();
+    const outcomes = await applyBatch(index, { ...body.data, now: now() }).catch((error) => {
+      forgetBacklog();
+      throw error;
+    });
+    await recordOwnWrites(outcomes.flatMap((outcome) => outcome.outcome === "done" ? [outcome.task] : []));
+    const messages = serverMessages(body.language);
+    const core = coreMessages(body.language);
+    return c.json({ results: outcomes.map((outcome) => viewOf(outcome, messages, core)) });
+  });
   api.patch("/projects/:id", async (c) => {
     const body = await readBody(c, projectActiveSchema, readLanguage2);
     if (!body.ok) return body.response;
@@ -5953,21 +6200,27 @@ function createApi({ root, readLanguage: readLanguage2, changes, now, home: home
   api.get(
     "/events",
     (c) => streamSSE(c, async (stream) => {
-      const unsubscribe = changes.subscribe(() => void stream.writeSSE({ event: "change", data: "" }));
+      const send = (revision) => void stream.writeSSE({ event: "change", data: JSON.stringify(revision) });
+      streams.add(send);
       const clientGone = new Promise((resolve7) => stream.onAbort(resolve7));
       await Promise.race([clientGone, changes.closed]);
-      unsubscribe();
+      streams.delete(send);
     })
   );
   return api;
 }
-async function loadSnapshot(root) {
+async function loadSnapshot(root, revision) {
   const loaded = await loadBacklog(root);
-  return { ...loaded, index: buildIndex(loaded.tasks) };
+  return { ...loaded, index: buildIndex(loaded.tasks), revision };
 }
 function invalidResponse(c, result, messages) {
   return c.json({ errors: result.errors.map(messages.problem) }, 422);
 }
+function viewOf(outcome, messages, core) {
+  if (outcome.outcome === "done") return { id: outcome.id, outcome: "done", version: outcome.task.version, previous: outcome.previous };
+  const message = outcome.reason === "invalid" && outcome.problems ? core.problems(outcome.problems) : messages.batchSkipped[outcome.reason](outcome.id);
+  return { id: outcome.id, outcome: "skipped", reason: outcome.reason, message };
+}
 async function readBody(c, schema, readLanguage2) {
   const [body, language] = await Promise.all([readJson(c), readLanguage2()]);
   if (body.ok === false) return { ok: false, response: c.json({ errors: [serverMessages(language).bodyNotParsed] }, 400) };
@@ -6061,11 +6314,17 @@ function isHiddenPath(root, path) {
 function createChangeFeed({ root, debounceMs, messages, warn: warn2 }) {
   const listeners = /* @__PURE__ */ new Set();
   const { promise: closed, resolve: markClosed } = Promise.withResolvers();
+  const changedPaths = /* @__PURE__ */ new Set();
   const debouncer = createDebouncer(debounceMs, () => {
-    for (const listener of listeners) listener();
+    const paths = [...changedPaths];
+    changedPaths.clear();
+    for (const listener of listeners) void listener(paths);
   });
   const watcher = watch(root, { ignoreInitial: true, ignored: (path) => isHiddenPath(root, path) });
-  watcher.on("all", () => debouncer.schedule());
+  watcher.on("all", (_event, path) => {
+    changedPaths.add(path);
+    debouncer.schedule();
+  });
   watcher.on("error", (error) => {
     void messages().then((texts) => warn2(texts.watcherError(root, errorText(error))));
   });
@@ -6130,8 +6389,9 @@ function startSweeper({ sweep, intervalMs, log: log2, warn: warn2, messages }) {
     return current;
   };
 }
-function logReport({ closedEpics, blockingFiles, deleted, conflicts, invalid: invalid2 }, messages, log2) {
+function logReport({ closedEpics, reopenedEpics, blockingFiles, deleted, conflicts, invalid: invalid2 }, messages, log2) {
   if (closedEpics.length > 0) log2(messages.closedEpics(closedEpics.join(", ")));
+  if (reopenedEpics.length > 0) log2(messages.reopenedEpics(reopenedEpics.join(", ")));
   if (blockingFiles.length > 0) log2(messages.epicsBlockedByFiles(blockingFiles.join(", ")));
   if (deleted.length > 0) log2(messages.deletedClosedTasks(deleted.join(", ")));
   if (conflicts.length > 0) log2(messages.conflictedDuringSweep(conflicts.join(", ")));
@@ -6142,8 +6402,8 @@ function logReport({ closedEpics, blockingFiles, deleted, conflicts, invalid: in
 
 // src/core/usage/transcripts.ts
 import { createHash as createHash4 } from "node:crypto";
-import { open as open2, stat as stat4 } from "node:fs/promises";
-import { basename as basename9, join as join24 } from "node:path";
+import { open as open2, stat as stat5 } from "node:fs/promises";
+import { basename as basename10, join as join24 } from "node:path";
 
 // src/core/stats/cost/attribute.ts
 import { z as z16 } from "zod";
@@ -6531,7 +6791,7 @@ async function listTranscripts(claudeProjectsDir2) {
 }
 async function listedFile(path) {
   try {
-    const { size, mtimeMs } = await stat4(path);
+    const { size, mtimeMs } = await stat5(path);
     return [{ path, size, mtimeMs }];
   } catch {
     return [];
@@ -6560,9 +6820,9 @@ async function scanTranscripts({ files, cache, byteBudget, now }) {
 }
 function deletedStillReported(cache, listedFiles, now) {
   const reportStart = now.getTime() - COST_REPORT_DAYS * DAY_MS;
-  const listedSessions = new Set(Object.keys(listedFiles).map((path) => basename9(path)));
+  const listedSessions = new Set(Object.keys(listedFiles).map((path) => basename10(path)));
   return Object.fromEntries(
-    Object.entries(cache.files).filter(([path, entry]) => !listedSessions.has(basename9(path)) && entry.buckets.some((bucket) => Date.parse(bucket.slot) >= reportStart))
+    Object.entries(cache.files).filter(([path, entry]) => !listedSessions.has(basename10(path)) && entry.buckets.some((bucket) => Date.parse(bucket.slot) >= reportStart))
   );
 }
 async function scanChunk(file, start, chunkSize, { longestReadableLine, now }) {
@@ -7173,7 +7433,7 @@ function reportFailure({ failed, code, output }, io) {
 import { join as join29 } from "node:path";
 
 // src/cli/stop-hook.ts
-import { mkdir as mkdir10, readFile as readFile5, readlink as readlink2, realpath as realpath2, stat as stat5 } from "node:fs/promises";
+import { mkdir as mkdir10, readFile as readFile5, readlink as readlink2, realpath as realpath2, stat as stat6 } from "node:fs/promises";
 import { dirname as dirname11, resolve as resolve4 } from "node:path";
 import { z as z18 } from "zod";
 var POSIX_COMMAND = "command -v backlog >/dev/null && backlog hook stop || true";
@@ -7201,7 +7461,7 @@ async function addStopHook(settingsPath, platform) {
   stopGroups.push({ hooks: [stopHookFor(platform)] });
   await mkdir10(dirname11(settingsPath), { recursive: true });
   const target = await writeTargetOf(settingsPath);
-  const mode = await stat5(target).then(({ mode: mode2 }) => mode2 & 511, () => void 0);
+  const mode = await stat6(target).then(({ mode: mode2 }) => mode2 & 511, () => void 0);
   await writeFileAtomic(target, `${JSON.stringify(settings, null, 2)}
 `, mode);
   return "added";