p-backlog 0.3.0 → 0.5.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) };
 }
@@ -544,7 +555,7 @@ var cliEn = {
   runNotRecorded: (error) => `Could not record the run: ${error}`,
   runsNotTrimmed: (error) => `Could not trim the run log: ${error}`,
   settingsFileInvalid: (path) => `${path} could not be parsed, the language for this run was detected automatically. The file was not changed \u2014 fix it manually.`,
-  optionLabel: { status: "status", category: "category", priority: "priority", language: "language" },
+  optionLabel: { status: "status", category: "category", priority: "priority", language: "language", agent: "agent" },
   skillForeign: (target) => `${target} is a foreign directory, the skill link was not moved`,
   installSkillLinked: (target, source) => `Skill installed: ${target} \u2192 ${source}`,
   installSkillKept: (target) => `Skill already installed: ${target}`,
@@ -552,8 +563,25 @@ var cliEn = {
   installSkillLinkFailed: (target, detail) => `Could not create the symlink ${target} (${detail}).`,
   installHookExists: (settingsPath) => `Stop hook is already present in ${settingsPath}`,
   installHookAdded: (settingsPath) => `Stop hook added to ${settingsPath}`,
+  installHookUpdated: (settingsPath) => `Stop hook updated in ${settingsPath}`,
+  codexHookApproval: "approve the hook in Codex: /hooks",
   installSettingsUnreadable: (settingsPath, detail) => `Could not read ${settingsPath} (${detail}), Stop hook not added.`,
   installSettingsInvalid: (settingsPath) => `${settingsPath} is not a JSON object, Stop hook not added. Fix the file and try again.`,
+  agentNotFound: (dir) => `not found (${dir})`,
+  pluginManages: (plugin) => `the ${plugin} plugin provides the skill and the hook. Remove the manual ones with: backlog setup --remove-manual`,
+  pluginLanguageHint: (installed, wanted) => `the skill comes from the ${installed} plugin; for this language switch plugins: /plugin uninstall ${installed}, then /plugin install ${wanted}`,
+  removeManualWithService: "--remove-manual cannot be combined with --service: remove the service with backlog service uninstall",
+  manualSkillRemoval: {
+    removed: (target) => `skill link removed: ${target}`,
+    absent: (target) => `no skill link: ${target}`,
+    foreign: (target) => `${target} is not a p-backlog link, left as is`
+  },
+  manualHookRemoval: {
+    removed: (path) => `Stop hook removed from ${path}`,
+    absent: (path) => `no p-backlog Stop hook in ${path}`
+  },
+  hookConfigUnreadable: (path, detail) => `Could not read ${path} (${detail}), the hook was not removed.`,
+  hookConfigInvalid: (path) => `${path} is not a JSON object, the hook was not removed. Fix the file and try again.`,
   serviceInstalled: (file) => `Service installed: ${file}`,
   serviceLogs: (path) => `Logs: ${path}`,
   serviceUninstalled: "Service removed",
@@ -648,11 +676,12 @@ var cliEn = {
   alreadyInStatus: (id, status) => `${id} is already ${status}`,
   blockedByOpenTasks: (id) => `${id} is blocked by open tasks:`,
   noTakeableInProject: (id) => `Project ${id} has no tasks that can be taken`,
-  hookUsage: (stopEvent) => `${stopEvent}   (for the Stop hook in Claude Code, reads the event from stdin)`,
+  hookUsage: (stopEvent, agents) => `${stopEvent} [--agent ${agents.join("|")}]   (for the Stop hook in Claude Code, Codex or Cursor, reads the event from stdin)`,
   sessionShownReadFailed: (error) => `Could not read the tasks already shown this session: ${error}`,
   sessionShownWriteFailed: (error) => `Could not remember the tasks shown this session: ${error}`,
   alertsComputeFailed: (error) => `Could not compute alerts: ${error}`,
   alertsShownWriteFailed: (error) => `Could not save the shown alerts: ${error}`,
+  hookTurnClaimFailed: (error) => `Could not record the turn for the double-hook guard: ${error}`,
   newUsage: (types, priorities, found) => [
     `--title <title> [--type ${types}] [--priority ${priorities}] [--tags a,b]`,
     `--category <category> (required for tasks) [--found ${found}]`,
@@ -702,7 +731,7 @@ var cliRu = {
   runNotRecorded: (error) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0438\u0441\u0430\u0442\u044C \u0437\u0430\u043F\u0443\u0441\u043A: ${error}`,
   runsNotTrimmed: (error) => `\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: ${error}`,
   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.`,
-  optionLabel: { status: "\u0441\u0442\u0430\u0442\u0443\u0441", category: "\u043A\u0430\u0442\u0435\u0433\u043E\u0440\u0438\u044F", priority: "\u043F\u0440\u0438\u043E\u0440\u0438\u0442\u0435\u0442", language: "\u044F\u0437\u044B\u043A" },
+  optionLabel: { status: "\u0441\u0442\u0430\u0442\u0443\u0441", category: "\u043A\u0430\u0442\u0435\u0433\u043E\u0440\u0438\u044F", priority: "\u043F\u0440\u0438\u043E\u0440\u0438\u0442\u0435\u0442", language: "\u044F\u0437\u044B\u043A", agent: "\u0430\u0433\u0435\u043D\u0442" },
   skillForeign: (target) => `${target} \u2014 \u0447\u0443\u0436\u043E\u0439 \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u0441\u043A\u0438\u043B\u043B \u043D\u0435 \u043F\u0435\u0440\u0435\u0441\u0442\u0430\u0432\u043B\u0435\u043D`,
   installSkillLinked: (target, source) => `\u0421\u043A\u0438\u043B\u043B \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D: ${target} \u2192 ${source}`,
   installSkillKept: (target) => `\u0421\u043A\u0438\u043B\u043B \u0443\u0436\u0435 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D: ${target}`,
@@ -710,8 +739,25 @@ var cliRu = {
   installSkillLinkFailed: (target, detail) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0441\u043E\u0437\u0434\u0430\u0442\u044C \u0441\u0441\u044B\u043B\u043A\u0443 ${target} (${detail}).`,
   installHookExists: (settingsPath) => `\u0425\u0443\u043A Stop \u0443\u0436\u0435 \u0435\u0441\u0442\u044C \u0432 ${settingsPath}`,
   installHookAdded: (settingsPath) => `\u0425\u0443\u043A Stop \u0434\u043E\u0431\u0430\u0432\u043B\u0435\u043D \u0432 ${settingsPath}`,
+  installHookUpdated: (settingsPath) => `\u0425\u0443\u043A Stop \u043E\u0431\u043D\u043E\u0432\u043B\u0451\u043D \u0432 ${settingsPath}`,
+  codexHookApproval: "\u043E\u0434\u043E\u0431\u0440\u0438\u0442\u0435 \u0445\u0443\u043A \u0432 Codex: /hooks",
   installSettingsUnreadable: (settingsPath, detail) => `${settingsPath} \u043D\u0435 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u0442\u044C (${detail}), \u0445\u0443\u043A Stop \u043D\u0435 \u0434\u043E\u0431\u0430\u0432\u043B\u0435\u043D.`,
   installSettingsInvalid: (settingsPath) => `${settingsPath} \u2014 \u043D\u0435 \u043E\u0431\u044A\u0435\u043A\u0442 JSON, \u0445\u0443\u043A Stop \u043D\u0435 \u0434\u043E\u0431\u0430\u0432\u043B\u0435\u043D. \u0418\u0441\u043F\u0440\u0430\u0432\u044C\u0442\u0435 \u0444\u0430\u0439\u043B \u0438 \u043F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0435.`,
+  agentNotFound: (dir) => `\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D (${dir})`,
+  pluginManages: (plugin) => `\u0441\u043A\u0438\u043B\u043B \u0438 \u0445\u0443\u043A \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0430\u0435\u0442 \u043F\u043B\u0430\u0433\u0438\u043D ${plugin}. \u0420\u0443\u0447\u043D\u044B\u0435 \u043C\u043E\u0436\u043D\u043E \u0443\u0431\u0440\u0430\u0442\u044C: backlog setup --remove-manual`,
+  pluginLanguageHint: (installed, wanted) => `\u0441\u043A\u0438\u043B\u043B \u0434\u0430\u0451\u0442 \u043F\u043B\u0430\u0433\u0438\u043D ${installed}; \u0434\u043B\u044F \u044D\u0442\u043E\u0433\u043E \u044F\u0437\u044B\u043A\u0430 \u043F\u043E\u0441\u0442\u0430\u0432\u044C\u0442\u0435 \u0434\u0440\u0443\u0433\u043E\u0439: /plugin uninstall ${installed}, \u0437\u0430\u0442\u0435\u043C /plugin install ${wanted}`,
+  removeManualWithService: "--remove-manual \u043D\u0435 \u0441\u043E\u0447\u0435\u0442\u0430\u0435\u0442\u0441\u044F \u0441 --service: \u0441\u043B\u0443\u0436\u0431\u0443 \u0441\u043D\u0438\u043C\u0430\u0435\u0442 backlog service uninstall",
+  manualSkillRemoval: {
+    removed: (target) => `\u0441\u0441\u044B\u043B\u043A\u0430 \u043D\u0430 \u0441\u043A\u0438\u043B\u043B \u0441\u043D\u044F\u0442\u0430: ${target}`,
+    absent: (target) => `\u0441\u0441\u044B\u043B\u043A\u0438 \u043D\u0430 \u0441\u043A\u0438\u043B\u043B \u043D\u0435\u0442: ${target}`,
+    foreign: (target) => `${target} \u2014 \u043D\u0435 \u0441\u0441\u044B\u043B\u043A\u0430 p-backlog, \u043D\u0435 \u0442\u0440\u043E\u043D\u0443\u0442`
+  },
+  manualHookRemoval: {
+    removed: (path) => `\u0445\u0443\u043A Stop \u0441\u043D\u044F\u0442 \u0438\u0437 ${path}`,
+    absent: (path) => `\u0445\u0443\u043A\u0430 Stop p-backlog \u0432 ${path} \u043D\u0435\u0442`
+  },
+  hookConfigUnreadable: (path, detail) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u0442\u044C ${path} (${detail}), \u0445\u0443\u043A \u043D\u0435 \u0441\u043D\u044F\u0442.`,
+  hookConfigInvalid: (path) => `${path} \u2014 \u043D\u0435 \u043E\u0431\u044A\u0435\u043A\u0442 JSON, \u0445\u0443\u043A \u043D\u0435 \u0441\u043D\u044F\u0442. \u0418\u0441\u043F\u0440\u0430\u0432\u044C\u0442\u0435 \u0444\u0430\u0439\u043B \u0438 \u043F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0435.`,
   serviceInstalled: (file) => `\u0421\u043B\u0443\u0436\u0431\u0430 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0430: ${file}`,
   serviceLogs: (path) => `\u041B\u043E\u0433\u0438: ${path}`,
   serviceUninstalled: "\u0421\u043B\u0443\u0436\u0431\u0430 \u0443\u0434\u0430\u043B\u0435\u043D\u0430",
@@ -818,11 +864,12 @@ var cliRu = {
   alreadyInStatus: (id, status) => `${id} \u0443\u0436\u0435 \u0432 \u0441\u0442\u0430\u0442\u0443\u0441\u0435 ${status}`,
   blockedByOpenTasks: (id) => `${id} \u0437\u0430\u0431\u043B\u043E\u043A\u0438\u0440\u043E\u0432\u0430\u043D\u0430 \u043E\u0442\u043A\u0440\u044B\u0442\u044B\u043C\u0438 \u0437\u0430\u0434\u0430\u0447\u0430\u043C\u0438:`,
   noTakeableInProject: (id) => `\u0412 \u043F\u0440\u043E\u0435\u043A\u0442\u0435 ${id} \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u0447, \u043A\u043E\u0442\u043E\u0440\u044B\u0435 \u043C\u043E\u0436\u043D\u043E \u0432\u0437\u044F\u0442\u044C \u0432 \u0440\u0430\u0431\u043E\u0442\u0443`,
-  hookUsage: (stopEvent) => `${stopEvent}   (\u0434\u043B\u044F \u0445\u0443\u043A\u0430 Stop \u0432 Claude Code, \u0441\u043E\u0431\u044B\u0442\u0438\u0435 \u0447\u0438\u0442\u0430\u0435\u0442\u0441\u044F \u0438\u0437 stdin)`,
+  hookUsage: (stopEvent, agents) => `${stopEvent} [--agent ${agents.join("|")}]   (\u0434\u043B\u044F \u0445\u0443\u043A\u0430 Stop \u0432 Claude Code, Codex \u0438\u043B\u0438 Cursor, \u0441\u043E\u0431\u044B\u0442\u0438\u0435 \u0447\u0438\u0442\u0430\u0435\u0442\u0441\u044F \u0438\u0437 stdin)`,
   sessionShownReadFailed: (error) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u0442\u044C \u043F\u043E\u043A\u0430\u0437\u0430\u043D\u043D\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u0441\u0435\u0441\u0441\u0438\u0438: ${error}`,
   sessionShownWriteFailed: (error) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u043E\u043C\u043D\u0438\u0442\u044C \u043F\u043E\u043A\u0430\u0437\u0430\u043D\u043D\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u0441\u0435\u0441\u0441\u0438\u0438: ${error}`,
   alertsComputeFailed: (error) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u043E\u0441\u0447\u0438\u0442\u0430\u0442\u044C \u0442\u0440\u0435\u0432\u043E\u0433\u0438: ${error}`,
   alertsShownWriteFailed: (error) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u043F\u043E\u043A\u0430\u0437\u0430\u043D\u043D\u044B\u0435 \u0442\u0440\u0435\u0432\u043E\u0433\u0438: ${error}`,
+  hookTurnClaimFailed: (error) => `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0442\u043C\u0435\u0442\u0438\u0442\u044C \u0445\u043E\u0434 \u0432 \u0437\u0430\u0449\u0438\u0442\u0435 \u043E\u0442 \u0434\u0432\u043E\u0439\u043D\u043E\u0433\u043E \u0445\u0443\u043A\u0430: ${error}`,
   newUsage: (types, priorities, found) => [
     `--title <\u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043E\u043A> [--type ${types}] [--priority ${priorities}] [--tags a,b]`,
     `--category <\u043A\u0430\u0442\u0435\u0433\u043E\u0440\u0438\u044F> (\u0434\u043B\u044F \u0437\u0430\u0434\u0430\u0447 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u0435\u043D) [--found ${found}]`,
@@ -936,18 +983,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 +1087,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 +1176,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 +1215,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 +1267,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 +1299,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 +1321,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 +1535,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 +1569,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 +1768,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 +1802,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 +2082,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 +2116,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 +2216,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 +2320,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 +2331,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 +2350,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 +2595,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 +2617,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 +3498,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 +3521,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]];
@@ -3788,7 +3910,11 @@ async function fixCommitFound(loaded, task, reason, io) {
 }
 
 // src/cli/commands/config.ts
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
+
+// src/cli/agents/agent.ts
+import { stat as stat4 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 
 // src/core/claude-dir.ts
 import { join as join15 } from "node:path";
@@ -3805,18 +3931,67 @@ function claudeProjectsDir(env, home2) {
   return join15(claudeDir(env, home2), "projects");
 }
 
+// src/cli/agents/agent.ts
+var AGENTS = ["claude", "codex", "cursor"];
+var AGENT_LABELS = { claude: "Claude Code", codex: "Codex", cursor: "Cursor" };
+function agentHomeDir(agent, env, home2) {
+  if (agent === "claude") return claudeDir(env, home2);
+  if (agent === "codex") return env.CODEX_HOME || join16(home2, ".codex");
+  return join16(home2, ".cursor");
+}
+function agentSkillsDir(agent, env, home2) {
+  if (agent === "claude") return claudeSkillsDir(env, home2);
+  if (agent === "codex") return join16(home2, ".agents", "skills");
+  return join16(agentHomeDir(agent, env, home2), "skills");
+}
+function legacySkillsDirs(agent, env, home2) {
+  return agent === "codex" ? [join16(agentHomeDir(agent, env, home2), "skills")] : [];
+}
+async function detectAgents(env, home2) {
+  const detection = { found: [], missing: [] };
+  for (const agent of AGENTS) {
+    const dir = agentHomeDir(agent, env, home2);
+    const present = agent === "claude" || ((await stat4(dir).catch(() => null))?.isDirectory() ?? false);
+    if (present) detection.found.push(agent);
+    else detection.missing.push({ agent, dir });
+  }
+  return detection;
+}
+
+// src/cli/agents/claude-plugin.ts
+import { z as z8 } from "zod";
+var PLUGIN_BY_LANGUAGE = { en: "p-backlog", ru: "p-backlog-ru" };
+var PLUGIN_NAMES = new Set(Object.values(PLUGIN_BY_LANGUAGE));
+var MARKETPLACE_SEPARATOR = "@";
+var enabledPluginsSchema = z8.object({ enabledPlugins: z8.record(z8.string(), z8.unknown()).optional() });
+async function agentPlugin(agent, env, home2) {
+  if (agent !== "claude") return null;
+  const settings = await readJsonFile(claudeSettingsPath(env, home2), enabledPluginsSchema);
+  const enabled = Object.entries(settings?.enabledPlugins ?? {}).find(([id, on]) => on === true && PLUGIN_NAMES.has(pluginName(id)));
+  return enabled?.[0] ?? null;
+}
+function pluginToSwitchTo(pluginId, language) {
+  const wanted = PLUGIN_BY_LANGUAGE[language];
+  if (pluginName(pluginId) === wanted) return null;
+  const marketplace = pluginId.slice(pluginId.indexOf(MARKETPLACE_SEPARATOR) + 1);
+  return `${wanted}${MARKETPLACE_SEPARATOR}${marketplace}`;
+}
+function pluginName(pluginId) {
+  return pluginId.split(MARKETPLACE_SEPARATOR)[0] ?? pluginId;
+}
+
 // src/cli/skill-link.ts
 import { lstat, mkdir as mkdir4, readlink, symlink, unlink } from "node:fs/promises";
-import { basename as basename8, dirname as dirname5, join as join16, resolve as resolve3 } from "node:path";
-import { z as z8 } from "zod";
+import { basename as basename8, dirname as dirname5, join as join17, resolve as resolve3 } from "node:path";
+import { z as z9 } from "zod";
 var SKILL_VARIANTS = /* @__PURE__ */ new Set(["backlog", "backlog-en"]);
-var packageManifestSchema = z8.object({ name: z8.string() });
+var packageManifestSchema = z9.object({ name: z9.string() });
 function skillSourceDir(packageRoot2, language) {
-  return join16(packageRoot2, "skill", language === "ru" ? "backlog" : "backlog-en");
+  return join17(packageRoot2, "skill", language === "ru" ? "backlog" : "backlog-en");
 }
 async function isPBacklogSkill(path) {
   if (!SKILL_VARIANTS.has(basename8(path)) || basename8(dirname5(path)) !== "skill") return false;
-  const manifest = await readTextOrNull(join16(dirname5(dirname5(path)), "package.json"));
+  const manifest = await readTextOrNull(join17(dirname5(dirname5(path)), "package.json"));
   if (manifest !== null) return parseJson(manifest, packageManifestSchema)?.name === "p-backlog";
   return !await pathExists(path);
 }
@@ -3824,7 +3999,7 @@ async function pathExists(path) {
   return await lstat(path).catch(() => null) !== null;
 }
 async function linkSkillFor(language, { skillsDir, packageRoot: packageRoot2, platform }) {
-  const target = join16(skillsDir, "backlog");
+  const target = join17(skillsDir, "backlog");
   const source = skillSourceDir(packageRoot2, language);
   const existing = await lstat(target).catch(() => null);
   if (existing !== null && !existing.isSymbolicLink()) return "foreign";
@@ -3838,6 +4013,18 @@ async function linkSkillFor(language, { skillsDir, packageRoot: packageRoot2, pl
   await symlink(source, target, platform === "win32" ? "junction" : "dir");
   return "linked";
 }
+async function relinkExistingSkill(language, options) {
+  if (!await pathExists(join17(options.skillsDir, "backlog"))) return "absent";
+  return linkSkillFor(language, options);
+}
+async function unlinkOurSkill(skillsDir) {
+  const target = join17(skillsDir, "backlog");
+  const existing = await lstat(target).catch(() => null);
+  if (existing === null) return "absent";
+  if (!existing.isSymbolicLink() || !await isPBacklogSkill(resolve3(skillsDir, await readlink(target)))) return "foreign";
+  await unlink(target);
+  return "removed";
+}
 
 // src/cli/commands/config.ts
 var configCommand = {
@@ -3861,11 +4048,29 @@ async function runLanguage(positionals, io) {
   const language = parseChoice(io.language, value, LANGUAGES, cliMessages(io.language).optionLabel.language);
   await writeSettings(io.backlogRoot, { language });
   io.print(`${io.language} \u2192 ${language}`);
-  const skillsDir = claudeSkillsDir(io.env, io.home);
-  const result = await linkSkillFor(language, { skillsDir, packageRoot: io.packageRoot, platform: io.platform });
-  if (result === "foreign") io.warn(cliMessages(language).skillForeign(join17(skillsDir, "backlog")));
+  const { found } = await detectAgents(io.env, io.home);
+  for (const agent of found) await relinkSkill(agent, language, io);
   return EXIT.ok;
 }
+async function relinkSkill(agent, language, io) {
+  const messages = cliMessages(language);
+  const label = AGENT_LABELS[agent];
+  const plugin = await agentPlugin(agent, io.env, io.home);
+  if (plugin !== null) {
+    const wanted = pluginToSwitchTo(plugin, language);
+    if (wanted !== null) io.print(`${label}: ${messages.pluginLanguageHint(plugin, wanted)}`);
+    return;
+  }
+  const skillsDir = agentSkillsDir(agent, io.env, io.home);
+  const target = join18(skillsDir, "backlog");
+  const options = { skillsDir, packageRoot: io.packageRoot, platform: io.platform };
+  try {
+    const result = agent === "claude" ? await linkSkillFor(language, options) : await relinkExistingSkill(language, options);
+    if (result === "foreign") io.warn(`${label}: ${messages.skillForeign(target)}`);
+  } catch (error) {
+    io.warn(`${label}: ${messages.installSkillLinkFailed(target, errorCodeOrText(error))}`);
+  }
+}
 
 // src/cli/apply-all.ts
 async function applyAll(items, apply) {
@@ -3918,31 +4123,47 @@ function epicWord(cli, epic) {
 
 // src/cli/commands/hook.ts
 import { dirname as dirname6 } from "node:path";
-import { z as z11 } from "zod";
+
+// src/core/store/hook-turns.ts
+import { join as join19 } from "node:path";
+import { z as z10 } from "zod";
+var HOOK_TURNS_FILE = ".hook-turns.json";
+var CLAIM_WINDOW_MS = 6e4;
+var hookTurnsSchema = z10.record(z10.string(), z10.iso.datetime({ offset: true }));
+async function claimHookTurn(backlogRoot2, turnKey, now) {
+  const path = join19(backlogRoot2, HOOK_TURNS_FILE);
+  return withFileLock(path, async () => {
+    const turns = await readJsonFile(path, hookTurnsSchema) ?? {};
+    const claimed = Object.entries(turns).filter(([, at]) => now.getTime() - Date.parse(at) < CLAIM_WINDOW_MS);
+    if (claimed.some(([key]) => key === turnKey)) return false;
+    await writeJsonFile(path, { ...Object.fromEntries(claimed), [turnKey]: now.toISOString() });
+    return true;
+  });
+}
 
 // src/core/store/signals-shown.ts
-import { join as join18 } from "node:path";
-import { z as z9 } from "zod";
+import { join as join20 } from "node:path";
+import { z as z11 } from "zod";
 var SIGNALS_SHOWN_FILE = ".signals-shown.json";
-var shownSchema = z9.record(z9.string(), z9.string());
+var shownSchema = z11.record(z11.string(), z11.string());
 async function readSignalsShown(projectDir2) {
-  return await readJsonFile(join18(projectDir2, SIGNALS_SHOWN_FILE), shownSchema) ?? {};
+  return await readJsonFile(join20(projectDir2, SIGNALS_SHOWN_FILE), shownSchema) ?? {};
 }
 async function writeSignalsShown(projectDir2, shown) {
-  await writeJsonFile(join18(projectDir2, SIGNALS_SHOWN_FILE), shown);
+  await writeJsonFile(join20(projectDir2, SIGNALS_SHOWN_FILE), shown);
 }
 
 // src/core/store/session-shown.ts
-import { join as join19 } from "node:path";
-import { z as z10 } from "zod";
+import { join as join21 } from "node:path";
+import { z as z12 } from "zod";
 var SESSION_SHOWN_FILE = ".candidates-shown.json";
 var SESSION_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
-var sessionsShownSchema = z10.record(z10.string(), z10.object({ tasks: z10.array(z10.string()), at: z10.iso.datetime({ offset: true }) }));
+var sessionsShownSchema = z12.record(z12.string(), z12.object({ tasks: z12.array(z12.string()), at: z12.iso.datetime({ offset: true }) }));
 async function readSessionShown(projectDir2, session) {
   return (await readSessions(projectDir2))[session]?.tasks ?? [];
 }
 async function rememberSessionShown(projectDir2, session, taskIds, now) {
-  const path = join19(projectDir2, SESSION_SHOWN_FILE);
+  const path = join21(projectDir2, SESSION_SHOWN_FILE);
   await withFileLock(path, async () => {
     const sessions = await readSessions(projectDir2);
     const recent = Object.entries(sessions).filter(([, shown]) => now.getTime() - Date.parse(shown.at) < SESSION_RETENTION_MS);
@@ -3951,7 +4172,7 @@ async function rememberSessionShown(projectDir2, session, taskIds, now) {
   });
 }
 async function readSessions(projectDir2) {
-  return await readJsonFile(join19(projectDir2, SESSION_SHOWN_FILE), sessionsShownSchema) ?? {};
+  return await readJsonFile(join21(projectDir2, SESSION_SHOWN_FILE), sessionsShownSchema) ?? {};
 }
 
 // src/core/stats/numbers.ts
@@ -4229,6 +4450,56 @@ function markShown(shown, signals, today) {
   return { ...shown, ...Object.fromEntries(signals.map((signal3) => [signal3.kind, today])) };
 }
 
+// src/cli/agents/stop-event.ts
+import { createHash as createHash4 } from "node:crypto";
+import { z as z13 } from "zod";
+var STOP_PROTOCOL = { claude: "claude", codex: "claude", cursor: "cursor" };
+var TURN_DIGEST_LENGTH = 16;
+var CURSOR_COMPLETED = "completed";
+var claudeEventSchema = z13.object({
+  cwd: z13.string(),
+  session_id: z13.string().optional(),
+  turn_id: z13.string().optional(),
+  stop_hook_active: z13.boolean().optional(),
+  last_assistant_message: z13.string().nullish()
+});
+var cursorEventSchema = z13.object({
+  workspace_roots: z13.tuple([z13.string()], z13.string()),
+  conversation_id: z13.string().optional(),
+  generation_id: z13.string().optional(),
+  status: z13.string().optional(),
+  loop_count: z13.number().optional()
+});
+function parseStopEvent(agent, text) {
+  return STOP_PROTOCOL[agent] === "cursor" ? parseCursorEvent(text) : parseClaudeEvent(text);
+}
+function carriesSystemMessage(agent) {
+  return STOP_PROTOCOL[agent] === "claude";
+}
+function formatStopAnswer(agent, answer) {
+  if (STOP_PROTOCOL[agent] === "cursor") return answer.reason === null ? null : JSON.stringify({ followup_message: answer.reason });
+  const response = {
+    ...answer.reason !== null ? { decision: "block", reason: answer.reason } : {},
+    ...answer.systemMessage !== null ? { systemMessage: answer.systemMessage } : {}
+  };
+  return Object.keys(response).length > 0 ? JSON.stringify(response) : null;
+}
+function parseClaudeEvent(text) {
+  const event = parseJson(text, claudeEventSchema);
+  if (event === null) return null;
+  return { cwd: event.cwd, session: event.session_id, turn: event.turn_id ?? digest(event.last_assistant_message), skip: event.stop_hook_active === true };
+}
+function parseCursorEvent(text) {
+  const event = parseJson(text, cursorEventSchema);
+  if (event === null) return null;
+  const followsOurFollowUp = (event.loop_count ?? 0) > 0;
+  const interrupted = (event.status ?? CURSOR_COMPLETED) !== CURSOR_COMPLETED;
+  return { cwd: event.workspace_roots[0], session: event.conversation_id, turn: event.generation_id, skip: followsOurFollowUp || interrupted };
+}
+function digest(text) {
+  return text ? createHash4("sha256").update(text).digest("hex").slice(0, TURN_DIGEST_LENGTH) : void 0;
+}
+
 // src/cli/stop-reason.ts
 var STOP_REASON_LIMIT = 500;
 function stopReason(language, projectId, candidates) {
@@ -4257,37 +4528,50 @@ function briefEvidence(cli, candidate) {
 }
 
 // src/cli/commands/hook.ts
-var stopEventSchema = z11.object({ cwd: z11.string(), session_id: z11.string().optional(), stop_hook_active: z11.boolean().optional() });
+var DEFAULT_AGENT = "claude";
 var hookCommand = {
   name: "hook",
-  usage: (language) => [cliMessages(language).hookUsage(HOOK_STOP_EVENT)],
+  usage: (language) => [cliMessages(language).hookUsage(HOOK_STOP_EVENT, AGENTS)],
   run: runHook,
   failureExit: EXIT.ok
 };
 async function runHook(args, io) {
-  if (args.length !== 1 || args[0] !== HOOK_STOP_EVENT) throw usageError(hookCommand, io.language);
-  const event = parseJson(await io.readStdin(), stopEventSchema);
-  if (event === null || event.stop_hook_active === true) return EXIT.ok;
+  const { values, positionals } = parseCommandArgs(io.language, args, { agent: { type: "string" } });
+  if (positionals.length !== 1 || positionals[0] !== HOOK_STOP_EVENT) throw usageError(hookCommand, io.language);
+  const agent = values.agent === void 0 ? DEFAULT_AGENT : parseChoice(io.language, values.agent, AGENTS, cliMessages(io.language).optionLabel.agent);
+  const event = parseStopEvent(agent, await io.readStdin());
+  if (event === null || event.skip) return EXIT.ok;
   const loaded = await loadBacklog(io.backlogRoot);
   const project = findProjectForDir(loaded.projects, event.cwd, io.home);
   if (!project) return EXIT.ok;
+  if (!await isFirstHookOfTurn(agent, event, io)) return EXIT.ok;
   const messages = coreMessages(io.language);
   const { candidates } = await checkBacklog(io.backlogRoot, loaded, { projectIds: [project.id], mode: "changed", now: io.now(), home: io.home, messages, workingDir: event.cwd });
   const lowPriority = new Set(loaded.tasks.filter((task) => task.priority === "low").map((task) => task.id));
   const worthTelling = candidates.filter((candidate) => !lowPriority.has(candidate.task.id));
   const lowCount = candidates.length - worthTelling.length;
-  const session = await sessionMemory(project, event.session_id, io);
+  const session = await sessionMemory(project, event.session, io);
   const blocking = worthTelling.filter((candidate) => !session.told.has(candidate.task.id));
-  const signals = await freshSignals(project, loaded.tasks.filter((task) => task.projectId === project.id), lowChangedSignals(lowCount), io);
-  const response = {
-    ...blocking.length > 0 ? { decision: "block", reason: stopReason(io.language, project.id, blocking) } : {},
-    ...signals.fresh.length > 0 ? { systemMessage: hookMessage(io.language, project.id, signals.fresh.map((signal3) => messages.signal(signal3)).join("; ")) } : {}
-  };
-  if (Object.keys(response).length > 0) io.print(JSON.stringify(response));
+  const signals = carriesSystemMessage(agent) ? await freshSignals(project, loaded.tasks.filter((task) => task.projectId === project.id), lowChangedSignals(lowCount), io) : NO_SIGNALS;
+  const answer = formatStopAnswer(agent, {
+    reason: blocking.length > 0 ? stopReason(io.language, project.id, blocking) : null,
+    systemMessage: signals.fresh.length > 0 ? hookMessage(io.language, project.id, signals.fresh.map((signal3) => messages.signal(signal3)).join("; ")) : null
+  });
+  if (answer !== null) io.print(answer);
   await signals.remember();
   await session.remember(blocking.map((candidate) => candidate.task.id));
   return EXIT.ok;
 }
+async function isFirstHookOfTurn(agent, event, io) {
+  if (event.session === void 0 || event.turn === void 0) return true;
+  try {
+    return await claimHookTurn(io.backlogRoot, `${agent}:${event.session}:${event.turn}`, io.now());
+  } catch (error) {
+    if (error instanceof FileBusyError) return false;
+    io.warn(cliMessages(io.language).hookTurnClaimFailed(errorText(error)));
+    return true;
+  }
+}
 async function sessionMemory(project, session, io) {
   if (session === void 0) return { told: /* @__PURE__ */ new Set(), remember: () => Promise.resolve() };
   const projectDir2 = dirname6(project.path);
@@ -4303,6 +4587,7 @@ async function sessionMemory(project, session, io) {
     return { told: /* @__PURE__ */ new Set(), remember: () => Promise.resolve() };
   }
 }
+var NO_SIGNALS = { fresh: [], remember: () => Promise.resolve() };
 function lowChangedSignals(count3) {
   if (count3 === 0) return [];
   return [{ kind: "low-changed", params: { count: count3 } }];
@@ -4603,6 +4888,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 +4905,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 +4926,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 +4943,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}`,
@@ -4686,30 +4987,33 @@ function listenFailure(error, port, messages) {
 // src/server/start.ts
 import { serve } from "@hono/node-server";
 import { mkdir as mkdir6, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { join as join27 } from "node:path";
 
 // src/core/store/sweep.ts
-import { dirname as dirname7, join as join20 } from "node:path";
+import { dirname as dirname7, join as join22 } 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) {
   const cutoff = new Date(now.getTime() - DAY_MS);
-  const projectDirs = (await listDir(root)).filter((entry) => entry.isDirectory()).map((entry) => join20(root, entry.name));
+  const projectDirs = (await listDir(root)).filter((entry) => entry.isDirectory()).map((entry) => join22(root, entry.name));
   for (const dir of [root, ...projectDirs]) await removeTemporariesBefore(dir, cutoff);
 }
 async function removeWithReferences(tasks, removable, now) {
@@ -4735,6 +5039,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);
@@ -4822,34 +5137,51 @@ async function reserveNumbers(projects, expired) {
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono as Hono3 } from "hono";
 import { secureHeaders } from "hono/secure-headers";
-import { join as join22 } from "node:path";
+import { join as join24 } 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 z12 } from "zod";
-var idList = z12.array(taskIdSchema);
-var taskChangesSchema = z12.strictObject({
-  title: z12.string().optional(),
-  type: z12.enum(TASK_TYPES).optional(),
-  status: z12.enum(TASK_STATUSES).optional(),
-  priority: z12.enum(PRIORITIES).optional(),
-  tags: z12.array(z12.string()).optional(),
+import { z as z14 } from "zod";
+var idList = z14.array(taskIdSchema);
+var taskChangesSchema = z14.strictObject({
+  title: z14.string().optional(),
+  type: z14.enum(TASK_TYPES).optional(),
+  status: z14.enum(TASK_STATUSES).optional(),
+  priority: z14.enum(PRIORITIES).optional(),
+  tags: z14.array(z14.string()).optional(),
   epic: taskIdSchema.nullable().optional(),
   blockedBy: idList.optional(),
   related: idList.optional(),
-  body: z12.string().optional(),
-  category: z12.enum(TASK_CATEGORIES).nullable().optional()
+  body: z14.string().optional(),
+  category: z14.enum(TASK_CATEGORIES).nullable().optional()
 });
-var projectActiveSchema = z12.strictObject({ active: z12.boolean() });
-var projectDeleteSchema = z12.strictObject({ confirm: z12.string() });
-var settingsRequestSchema = z12.strictObject(settingsSchema.shape);
-var updateTaskRequestSchema = z12.strictObject({
-  version: z12.string().min(1),
+var projectActiveSchema = z14.strictObject({ active: z14.boolean() });
+var projectDeleteSchema = z14.strictObject({ confirm: z14.string() });
+var settingsRequestSchema = z14.strictObject(settingsSchema.shape);
+var updateTaskRequestSchema = z14.strictObject({
+  version: z14.string().min(1),
   changes: taskChangesSchema
 });
+var batchPreviousSchema = z14.strictObject({
+  status: z14.enum(TASK_STATUSES),
+  priority: z14.enum(PRIORITIES),
+  epic: taskIdSchema.nullable(),
+  resolution: z14.enum(RESOLUTIONS).nullable(),
+  reason: z14.string().nullable()
+});
+var BATCH_TASKS_LIMIT = 500;
+var batchRequestSchema = z14.strictObject({
+  tasks: z14.array(z14.strictObject({ id: taskIdSchema, version: z14.string().min(1) })).min(1).max(BATCH_TASKS_LIMIT).refine((tasks) => new Set(tasks.map((task) => task.id)).size === tasks.length),
+  action: z14.discriminatedUnion("kind", [
+    z14.strictObject({ kind: z14.literal("close"), reason: z14.string().transform((reason) => reason.replace(/\s*\n\s*/g, " ").trim()).pipe(z14.string().min(1)) }),
+    z14.strictObject({ kind: z14.literal("priority"), priority: z14.enum(PRIORITIES) }),
+    z14.strictObject({ kind: z14.literal("epic"), epic: taskIdSchema.nullable() }),
+    z14.strictObject({ kind: z14.literal("restore"), changes: z14.record(taskIdSchema, batchPreviousSchema) })
+  ])
+});
 
 // src/core/check/graph-health.ts
 async function projectGraphHealth(project, tasks, home2) {
@@ -4879,6 +5211,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,30 +5282,68 @@ function createReportCache({ ttlMs, now }) {
   };
 }
 
+// src/server/revisions.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { stat as stat5 } 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), stat5(path).catch(() => null)]);
+  return text === null || stats === null ? null : { version: contentVersion(text), mtimeMs: stats.mtimeMs };
+}
+
 // src/server/stats-api.ts
 import { Hono } from "hono";
 
 // src/core/code/code-cache.ts
-import { join as join21 } from "node:path";
-import { z as z13 } from "zod";
+import { join as join23 } from "node:path";
+import { z as z15 } from "zod";
 var CODE_CACHE_FILE = ".code-cache.json";
 var CODE_CACHE_VERSION = 1;
-var repoCodeSchema = z13.object({
-  commits: z13.array(z13.array(z13.string())),
-  lines: z13.array(z13.object({ path: z13.string(), lines: z13.number() })),
-  units: z13.array(z13.object({ date: z13.string(), lines: z13.number() }))
+var repoCodeSchema = z15.object({
+  commits: z15.array(z15.array(z15.string())),
+  lines: z15.array(z15.object({ path: z15.string(), lines: z15.number() })),
+  units: z15.array(z15.object({ date: z15.string(), lines: z15.number() }))
 });
-var fixCommitSchema = z13.object({ date: z13.string(), landedAt: z13.string().optional(), byAgent: z13.boolean(), lines: z13.number(), testLines: z13.number() });
-var snapshotSchema = z13.object({
-  version: z13.literal(CODE_CACHE_VERSION),
-  repos: z13.record(z13.string(), z13.object({ key: z13.string(), code: repoCodeSchema })),
-  fixes: z13.record(z13.string(), fixCommitSchema)
+var fixCommitSchema = z15.object({ date: z15.string(), landedAt: z15.string().optional(), byAgent: z15.boolean(), lines: z15.number(), testLines: z15.number() });
+var snapshotSchema = z15.object({
+  version: z15.literal(CODE_CACHE_VERSION),
+  repos: z15.record(z15.string(), z15.object({ key: z15.string(), code: repoCodeSchema })),
+  fixes: z15.record(z15.string(), fixCommitSchema)
 });
 function emptyCodeCache() {
   return { repos: {}, fixes: {} };
 }
 function createCodeCacheFile(root) {
-  const path = join21(root, CODE_CACHE_FILE);
+  const path = join23(root, CODE_CACHE_FILE);
   return {
     read: async () => {
       const snapshot = await readJsonFile(path, snapshotSchema);
@@ -5318,13 +5740,13 @@ function codeFixRequests(input, base = reportBase(input)) {
 }
 
 // src/core/stats/cost/token-counts.ts
-import { z as z14 } from "zod";
-var tokenCountsSchema = z14.object({
-  input: z14.number(),
-  cacheWrite5m: z14.number(),
-  cacheWrite1h: z14.number(),
-  cacheRead: z14.number(),
-  output: z14.number()
+import { z as z16 } from "zod";
+var tokenCountsSchema = z16.object({
+  input: z16.number(),
+  cacheWrite5m: z16.number(),
+  cacheWrite1h: z16.number(),
+  cacheRead: z16.number(),
+  output: z16.number()
 });
 var ZERO_TOKENS = { input: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0, output: 0 };
 function addTokens(a, b) {
@@ -5339,24 +5761,24 @@ function totalTokens(tokens) {
 }
 
 // src/core/stats/cost/usage-state.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 var COST_REPORT_DAYS = 30;
-var estimatedKindSchema = z15.enum(["cli", "skill"]);
-var usageBucketSchema = z15.object({
-  slot: z15.string(),
-  cwd: z15.string(),
-  model: z15.string(),
-  kind: z15.enum(["hook", ...estimatedKindSchema.options]),
+var estimatedKindSchema = z17.enum(["cli", "skill"]);
+var usageBucketSchema = z17.object({
+  slot: z17.string(),
+  cwd: z17.string(),
+  model: z17.string(),
+  kind: z17.enum(["hook", ...estimatedKindSchema.options]),
   tokens: tokenCountsSchema,
-  hookTurns: z15.number()
+  hookTurns: z17.number()
 });
-var transcriptStateSchema = z15.object({
-  hookOpen: z15.boolean(),
-  lastModel: z15.string().nullable(),
-  lastMessageId: z15.string().nullable(),
+var transcriptStateSchema = z17.object({
+  hookOpen: z17.boolean(),
+  lastModel: z17.string().nullable(),
+  lastMessageId: z17.string().nullable(),
   lastMessageTokens: tokenCountsSchema.nullable().optional(),
-  pending: z15.record(z15.string(), estimatedKindSchema),
-  pendingEstimates: z15.array(z15.object({ kind: estimatedKindSchema, chars: z15.number(), slot: z15.string(), cwd: z15.string() }))
+  pending: z17.record(z17.string(), estimatedKindSchema),
+  pendingEstimates: z17.array(z17.object({ kind: estimatedKindSchema, chars: z17.number(), slot: z17.string(), cwd: z17.string() }))
 });
 
 // src/core/stats/cost/pricing.ts
@@ -5880,9 +6302,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 +6318,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 +6356,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 +6399,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) };
@@ -6036,7 +6488,7 @@ function createApp({ root, readLanguage: readLanguage2, changes, allowedHosts, h
   });
   if (staticDir !== void 0) {
     app.use("*", serveStatic({ root: staticDir }));
-    app.get("*", serveStatic({ path: join22(staticDir, "index.html") }));
+    app.get("*", serveStatic({ path: join24(staticDir, "index.html") }));
   }
   return app;
 }
@@ -6061,11 +6513,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 +6588,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(", ")));
@@ -6141,12 +6600,12 @@ 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 { createHash as createHash5 } from "node:crypto";
+import { open as open2, stat as stat6 } from "node:fs/promises";
+import { basename as basename10, join as join26 } from "node:path";
 
 // src/core/stats/cost/attribute.ts
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 
 // src/core/stats/cost/shell-commands.ts
 var SEPARATORS = ["&&", "||", ";", "|", "&", "\n", "`"];
@@ -6339,21 +6798,21 @@ var FAST_SPEED = "fast";
 var CHARS_PER_TOKEN = 3;
 var PENDING_TOOL_LIMIT = 64;
 var ZONE_OFFSET_STEP_MS = 15 * 60 * 1e3;
-var usageSchema = z16.object({
-  input_tokens: z16.number().optional(),
-  output_tokens: z16.number().optional(),
-  cache_read_input_tokens: z16.number().optional(),
-  cache_creation_input_tokens: z16.number().optional(),
-  speed: z16.string().optional(),
-  cache_creation: z16.object({ ephemeral_5m_input_tokens: z16.number().optional(), ephemeral_1h_input_tokens: z16.number().optional() }).passthrough().optional()
+var usageSchema = z18.object({
+  input_tokens: z18.number().optional(),
+  output_tokens: z18.number().optional(),
+  cache_read_input_tokens: z18.number().optional(),
+  cache_creation_input_tokens: z18.number().optional(),
+  speed: z18.string().optional(),
+  cache_creation: z18.object({ ephemeral_5m_input_tokens: z18.number().optional(), ephemeral_1h_input_tokens: z18.number().optional() }).passthrough().optional()
 }).passthrough();
-var assistantMessageSchema = z16.object({ id: z16.string().optional(), model: z16.string().optional(), usage: usageSchema.optional(), content: z16.array(z16.unknown()).optional() }).passthrough();
-var userMessageSchema = z16.object({ content: z16.unknown().optional() }).passthrough();
-var toolUseBlockSchema = z16.object({ type: z16.literal("tool_use"), id: z16.string(), name: z16.string(), input: z16.unknown().optional() }).passthrough();
-var toolResultBlockSchema = z16.object({ type: z16.literal("tool_result"), tool_use_id: z16.string().optional(), content: z16.unknown().optional() }).passthrough();
-var textBlockSchema = z16.object({ type: z16.literal("text"), text: z16.string() }).passthrough();
-var bashInputSchema = z16.object({ command: z16.string() }).passthrough();
-var lineSchema = z16.object({ type: z16.string().optional(), timestamp: z16.string().optional(), cwd: z16.string().optional(), isMeta: z16.boolean().optional(), message: z16.unknown().optional() }).passthrough();
+var assistantMessageSchema = z18.object({ id: z18.string().optional(), model: z18.string().optional(), usage: usageSchema.optional(), content: z18.array(z18.unknown()).optional() }).passthrough();
+var userMessageSchema = z18.object({ content: z18.unknown().optional() }).passthrough();
+var toolUseBlockSchema = z18.object({ type: z18.literal("tool_use"), id: z18.string(), name: z18.string(), input: z18.unknown().optional() }).passthrough();
+var toolResultBlockSchema = z18.object({ type: z18.literal("tool_result"), tool_use_id: z18.string().optional(), content: z18.unknown().optional() }).passthrough();
+var textBlockSchema = z18.object({ type: z18.literal("text"), text: z18.string() }).passthrough();
+var bashInputSchema = z18.object({ command: z18.string() }).passthrough();
+var lineSchema = z18.object({ type: z18.string().optional(), timestamp: z18.string().optional(), cwd: z18.string().optional(), isMeta: z18.boolean().optional(), message: z18.unknown().optional() }).passthrough();
 function newTranscriptState() {
   return { hookOpen: false, lastModel: null, lastMessageId: null, lastMessageTokens: null, pending: {}, pendingEstimates: [] };
 }
@@ -6477,53 +6936,53 @@ function slotOf(timestamp) {
 
 // src/core/usage/usage-cache.ts
 import { mkdir as mkdir5 } from "node:fs/promises";
-import { join as join23 } from "node:path";
-import { z as z17 } from "zod";
+import { join as join25 } from "node:path";
+import { z as z19 } from "zod";
 var USAGE_CACHE_FILE = ".usage-cache.json";
 var USAGE_CACHE_VERSION = 6;
-var usageCacheEntrySchema = z17.object({
-  size: z17.number(),
-  mtimeMs: z17.number().optional(),
-  offset: z17.number(),
-  fingerprint: z17.string(),
+var usageCacheEntrySchema = z19.object({
+  size: z19.number(),
+  mtimeMs: z19.number().optional(),
+  offset: z19.number(),
+  fingerprint: z19.string(),
   state: transcriptStateSchema,
-  buckets: z17.array(usageBucketSchema)
+  buckets: z19.array(usageBucketSchema)
 });
-var usageCacheSchema = z17.object({
-  version: z17.literal(USAGE_CACHE_VERSION),
-  files: z17.record(z17.string(), usageCacheEntrySchema)
+var usageCacheSchema = z19.object({
+  version: z19.literal(USAGE_CACHE_VERSION),
+  files: z19.record(z19.string(), usageCacheEntrySchema)
 });
 function emptyUsageCache() {
   return { version: USAGE_CACHE_VERSION, files: {} };
 }
 async function readUsageCache(root) {
-  return await readJsonFile(join23(root, USAGE_CACHE_FILE), usageCacheSchema) ?? emptyUsageCache();
+  return await readJsonFile(join25(root, USAGE_CACHE_FILE), usageCacheSchema) ?? emptyUsageCache();
 }
 async function writeUsageCache(root, cache) {
   await mkdir5(root, { recursive: true });
-  await writeFileAtomic(join23(root, USAGE_CACHE_FILE), JSON.stringify(cache));
+  await writeFileAtomic(join25(root, USAGE_CACHE_FILE), JSON.stringify(cache));
 }
 
 // src/core/usage/transcripts.ts
 var NEWLINE = 10;
 var FINGERPRINT_BYTES = 256;
 var ABANDONED_LINE_MS = 10 * 60 * 1e3;
-var EMPTY_FINGERPRINT = createHash4("sha1").digest("hex");
+var EMPTY_FINGERPRINT = createHash5("sha1").digest("hex");
 var COUNTED_LINE_MARKERS = ['"type":"assistant"', '"type":"user"'];
 async function listTranscripts(claudeProjectsDir2) {
   const files = [];
   for (const projectEntry of await listDir(claudeProjectsDir2)) {
     if (!projectEntry.isDirectory()) continue;
-    const projectDir2 = join24(claudeProjectsDir2, projectEntry.name);
+    const projectDir2 = join26(claudeProjectsDir2, projectEntry.name);
     for (const entry of await listDir(projectDir2)) {
-      const entryPath = join24(projectDir2, entry.name);
+      const entryPath = join26(projectDir2, entry.name);
       if (entry.isFile() && entry.name.endsWith(".jsonl")) {
         files.push(...await listedFile(entryPath));
         continue;
       }
       if (!entry.isDirectory()) continue;
-      for (const subagentEntry of await listDir(join24(entryPath, "subagents"), { recursive: true })) {
-        if (subagentEntry.isFile() && subagentEntry.name.endsWith(".jsonl")) files.push(...await listedFile(join24(subagentEntry.parentPath, subagentEntry.name)));
+      for (const subagentEntry of await listDir(join26(entryPath, "subagents"), { recursive: true })) {
+        if (subagentEntry.isFile() && subagentEntry.name.endsWith(".jsonl")) files.push(...await listedFile(join26(subagentEntry.parentPath, subagentEntry.name)));
       }
     }
   }
@@ -6531,7 +6990,7 @@ async function listTranscripts(claudeProjectsDir2) {
 }
 async function listedFile(path) {
   try {
-    const { size, mtimeMs } = await stat4(path);
+    const { size, mtimeMs } = await stat6(path);
     return [{ path, size, mtimeMs }];
   } catch {
     return [];
@@ -6560,9 +7019,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 }) {
@@ -6596,7 +7055,7 @@ async function fingerprintOf(path, offset) {
   return withFile(path, async (handle) => {
     const head = await readAt(handle, 0, edge);
     const tail = await readAt(handle, offset - edge, edge);
-    return createHash4("sha1").update(head).update(tail).digest("hex");
+    return createHash5("sha1").update(head).update(tail).digest("hex");
   });
 }
 function readChunk(path, position, length) {
@@ -6714,7 +7173,7 @@ function progressBefore(files, cache) {
 // src/server/start.ts
 var SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
 var STOP_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
-var BUNDLED_WEB_DIR = join25(import.meta.dirname, "web");
+var BUNDLED_WEB_DIR = join27(import.meta.dirname, "web");
 var log = (line) => void process.stdout.write(`${line}
 `);
 var warn = (line) => void process.stderr.write(`${line}
@@ -6815,7 +7274,7 @@ async function runServe(args, io) {
 
 // src/cli/service/launchd.ts
 import { mkdir as mkdir7, rm as rm5, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname8, join as join26, posix } from "node:path";
+import { dirname as dirname8, join as join28, posix } from "node:path";
 import { setTimeout as sleep3 } from "node:timers/promises";
 
 // src/cli/service/service.ts
@@ -6888,7 +7347,7 @@ ${entries}
 `;
 }
 function launchdManager(context, delay = sleep3) {
-  const file = join26(context.home, "Library/LaunchAgents", `${LABEL}.plist`);
+  const file = join28(context.home, "Library/LaunchAgents", `${LABEL}.plist`);
   const domain = `gui/${context.uid}`;
   const bootout = () => context.exec("launchctl", ["bootout", `${domain}/${LABEL}`]);
   const bootstrap = () => context.exec("launchctl", ["bootstrap", domain, file]);
@@ -6923,7 +7382,7 @@ function launchdManager(context, delay = sleep3) {
 
 // src/cli/service/startup-folder.ts
 import { mkdir as mkdir8, rm as rm6, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname9, join as join27, win32 } from "node:path";
+import { dirname as dirname9, join as join29, win32 } from "node:path";
 var SCRIPT_NAME = "p-backlog.vbs";
 var COMMAND_LINE_ARGUMENT = /"[^"]*"|\S+/g;
 var PROCESS_QUERY_TIMEOUT_MS = 15e3;
@@ -6931,16 +7390,16 @@ function vbsString(value) {
   return `"${value.replaceAll('"', '""')}"`;
 }
 function appDataDir(context) {
-  return join27(context.env.LOCALAPPDATA ?? join27(context.home, "AppData", "Local"), "p-backlog");
+  return join29(context.env.LOCALAPPDATA ?? join29(context.home, "AppData", "Local"), "p-backlog");
 }
 function startupFolder(context) {
-  return join27(context.env.APPDATA ?? join27(context.home, "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+  return join29(context.env.APPDATA ?? join29(context.home, "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
 }
 function logPath2(context) {
-  return join27(appDataDir(context), "p-backlog.log");
+  return join29(appDataDir(context), "p-backlog.log");
 }
 function pidFilePath(context) {
-  return join27(appDataDir(context), "server.pid");
+  return join29(appDataDir(context), "server.pid");
 }
 var NODE_PATH_ENV = "P_BACKLOG_NODE";
 var CLI_PATH_ENV = "P_BACKLOG_CLI";
@@ -6991,7 +7450,7 @@ function sameWindowsPath(left, right) {
   return win32.normalize(left).toLowerCase() === win32.normalize(right).toLowerCase();
 }
 function startupFolderManager(context) {
-  const file = join27(startupFolder(context), SCRIPT_NAME);
+  const file = join29(startupFolder(context), SCRIPT_NAME);
   return {
     file,
     logs: logPath2(context),
@@ -7018,7 +7477,7 @@ function startupFolderManager(context) {
 
 // src/cli/service/systemd.ts
 import { mkdir as mkdir9, rm as rm7, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname10, join as join28 } from "node:path";
+import { dirname as dirname10, join as join30 } from "node:path";
 var UNIT = "p-backlog.service";
 function quoted(value) {
   return `"${value.replace(/[\\"]/g, "\\$&").replaceAll("%", "%%")}"`;
@@ -7052,7 +7511,7 @@ async function systemctlSteps(exec, steps) {
   return "done";
 }
 function systemdManager(context) {
-  const file = join28(context.home, ".config/systemd/user", UNIT);
+  const file = join30(context.home, ".config/systemd/user", UNIT);
   return {
     file,
     logs: "journalctl --user -u p-backlog",
@@ -7170,50 +7629,43 @@ function reportFailure({ failed, code, output }, io) {
 }
 
 // src/cli/commands/setup.ts
-import { join as join29 } from "node:path";
+import { join as join32 } 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";
+// src/cli/agents/agent-hooks.ts
+import { join as join31 } from "node:path";
+
+// src/cli/agents/grouped-stop-hooks.ts
+import { z as z20 } from "zod";
+
+// src/cli/agents/json-config.ts
+import { mkdir as mkdir10, readFile as readFile5, readlink as readlink2, realpath as realpath2, stat as stat7 } 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";
-var POWERSHELL_COMMAND = "if (Get-Command backlog.cmd -ErrorAction SilentlyContinue) { backlog.cmd hook stop }";
 var MAX_LINK_HOPS = 40;
-var stopHookGroupSchema = z18.object({ hooks: z18.array(z18.unknown()).optional() }).passthrough();
-var settingsSchema2 = z18.object({ hooks: z18.object({ Stop: z18.array(stopHookGroupSchema).optional() }).passthrough().optional() }).passthrough();
-function stopHookFor(platform) {
-  return platform === "win32" ? { type: "command", shell: "powershell", command: POWERSHELL_COMMAND } : { type: "command", command: POSIX_COMMAND };
-}
-function isOurStopHook(hook) {
-  if (typeof hook !== "object" || hook === null) return false;
-  const command = hook.command;
-  return command === POSIX_COMMAND || command === POWERSHELL_COMMAND;
-}
-async function addStopHook(settingsPath, platform) {
-  const text = await readSettingsText(settingsPath);
+async function readJsonConfig(path, schema) {
+  const text = await readConfigText(path);
   if (typeof text !== "string") return text;
-  const settings = validatedSettings(text);
-  if (settings === null) return { failed: "invalid" };
-  const hooks = settings.hooks ??= {};
-  const stopGroups = hooks.Stop ??= [];
-  const installed = stopGroups.some((group) => group.hooks?.some(isOurStopHook) ?? false);
-  if (installed) return "exists";
-  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);
-  await writeFileAtomic(target, `${JSON.stringify(settings, null, 2)}
-`, mode);
-  return "added";
-}
-function validatedSettings(text) {
   let value;
   try {
     value = JSON.parse(text);
   } catch {
-    return null;
+    return { failed: "invalid" };
+  }
+  return schema.safeParse(value).success ? { config: value } : { failed: "invalid" };
+}
+async function writeJsonConfig(path, config) {
+  await mkdir10(dirname11(path), { recursive: true });
+  const target = await writeTargetOf(path);
+  const mode = await stat7(target).then(({ mode: mode2 }) => mode2 & 511, () => void 0);
+  await writeFileAtomic(target, `${JSON.stringify(config, null, 2)}
+`, mode);
+}
+async function readConfigText(path) {
+  try {
+    return await readFile5(path, "utf8");
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) return "{}";
+    return { failed: "unreadable", code: errorCodeOrText(error) };
   }
-  return settingsSchema2.safeParse(value).success ? value : null;
 }
 async function writeTargetOf(path) {
   try {
@@ -7232,62 +7684,240 @@ async function danglingLinkTarget(path) {
   }
   return current;
 }
-async function readSettingsText(settingsPath) {
-  try {
-    return await readFile5(settingsPath, "utf8");
-  } catch (error) {
-    if (hasErrorCode(error, "ENOENT")) return "{}";
-    return { failed: "unreadable", code: errorCodeOrText(error) };
+
+// src/cli/agents/grouped-stop-hooks.ts
+var stopGroupSchema = z20.object({ hooks: z20.array(z20.unknown()).optional() }).passthrough();
+var groupedConfigSchema = z20.object({ hooks: z20.object({ Stop: z20.array(stopGroupSchema).optional() }).passthrough().optional() }).passthrough();
+function refreshOurHook(lists, hook, { isOurs, isCurrent }) {
+  const ours = lists.flatMap((list) => list.flatMap((entry, index) => isOurs(entry) ? [{ list, index, entry }] : []));
+  if (ours.some(({ entry }) => isCurrent(entry))) return "exists";
+  const stale = ours[0];
+  if (stale === void 0) return "missing";
+  stale.list[stale.index] = { ...stale.entry, ...hook };
+  return "updated";
+}
+async function addGroupedStopHook(path, hook, ourHook) {
+  const read = await readJsonConfig(path, groupedConfigSchema);
+  if (!("config" in read)) return read;
+  const stopGroups = (read.config.hooks ??= {}).Stop ??= [];
+  const refreshed = refreshOurHook(stopGroups.flatMap((group) => group.hooks === void 0 ? [] : [group.hooks]), hook, ourHook);
+  if (refreshed === "exists") return "exists";
+  if (refreshed === "missing") stopGroups.push({ hooks: [hook] });
+  await writeJsonConfig(path, read.config);
+  return refreshed === "missing" ? "added" : "updated";
+}
+async function removeGroupedStopHook(path, isOurs) {
+  const read = await readJsonConfig(path, groupedConfigSchema);
+  if (!("config" in read)) return read;
+  const hooks = read.config.hooks;
+  if (hooks?.Stop === void 0 || !hooks.Stop.some((group) => hasOurHook(group, isOurs))) return "absent";
+  const kept = hooks.Stop.flatMap((group) => {
+    if (!hasOurHook(group, isOurs)) return [group];
+    const others = (group.hooks ?? []).filter((hook) => !isOurs(hook));
+    return others.length > 0 ? [{ ...group, hooks: others }] : [];
+  });
+  if (kept.length > 0) hooks.Stop = kept;
+  else delete hooks.Stop;
+  await writeJsonConfig(path, read.config);
+  return "removed";
+}
+function hasOurHook(group, isOurs) {
+  return group.hooks?.some(isOurs) ?? false;
+}
+
+// src/cli/stop-hook.ts
+var POSIX_COMMAND = "command -v backlog >/dev/null && backlog hook stop || true";
+var POWERSHELL_COMMAND = "if (Get-Command backlog.cmd -ErrorAction SilentlyContinue) { backlog.cmd hook stop }";
+function stopHookFor(platform) {
+  return platform === "win32" ? { type: "command", shell: "powershell", command: POWERSHELL_COMMAND } : { type: "command", command: POSIX_COMMAND };
+}
+function isOurStopHook(hook) {
+  if (typeof hook !== "object" || hook === null) return false;
+  const command = hook.command;
+  return command === POSIX_COMMAND || command === POWERSHELL_COMMAND;
+}
+function addStopHook(settingsPath, platform) {
+  return addGroupedStopHook(settingsPath, stopHookFor(platform), { isOurs: isOurStopHook, isCurrent: isOurStopHook });
+}
+function removeStopHook(settingsPath) {
+  return removeGroupedStopHook(settingsPath, isOurStopHook);
+}
+
+// src/cli/agents/cursor-hooks.ts
+import { z as z21 } from "zod";
+var CURSOR_HOOKS_VERSION = 1;
+var cursorConfigSchema = z21.object({ version: z21.number().optional(), hooks: z21.object({ stop: z21.array(z21.unknown()).optional() }).passthrough().optional() }).passthrough();
+async function addCursorStopHook(path, hook, ourHook) {
+  const read = await readJsonConfig(path, cursorConfigSchema);
+  if (!("config" in read)) return read;
+  const stop = (read.config.hooks ??= {}).stop ??= [];
+  const refreshed = refreshOurHook([stop], hook, ourHook);
+  if (refreshed === "exists") return "exists";
+  if (refreshed === "missing") stop.push(hook);
+  read.config.version ??= CURSOR_HOOKS_VERSION;
+  await writeJsonConfig(path, read.config);
+  return refreshed === "missing" ? "added" : "updated";
+}
+async function removeCursorStopHook(path, isOurs) {
+  const read = await readJsonConfig(path, cursorConfigSchema);
+  if (!("config" in read)) return read;
+  const hooks = read.config.hooks;
+  if (hooks?.stop === void 0 || !hooks.stop.some(isOurs)) return "absent";
+  const kept = hooks.stop.filter((hook) => !isOurs(hook));
+  if (kept.length > 0) hooks.stop = kept;
+  else delete hooks.stop;
+  await writeJsonConfig(path, read.config);
+  return "removed";
+}
+
+// src/cli/agents/agent-hooks.ts
+var CODEX_HOOK_TIMEOUT_SECONDS = 30;
+var AGENT_HOOKS_FILE = "hooks.json";
+function agentHookConfigPath(agent, env, home2) {
+  return agent === "claude" ? claudeSettingsPath(env, home2) : join31(agentHomeDir(agent, env, home2), AGENT_HOOKS_FILE);
+}
+function installAgentHook(agent, site) {
+  const path = agentHookConfigPath(agent, site.env, site.home);
+  switch (agent) {
+    case "claude":
+      return addStopHook(path, site.platform);
+    case "codex": {
+      const hook = { type: "command", command: posixCommand(agent), commandWindows: windowsCommand(agent, site.cliPath), timeout: CODEX_HOOK_TIMEOUT_SECONDS };
+      return addGroupedStopHook(path, hook, ourCurrentHook(agent, site.cliPath, hook));
+    }
+    case "cursor": {
+      const hook = { command: site.platform === "win32" ? windowsCommand(agent, site.cliPath) : posixCommand(agent) };
+      return addCursorStopHook(path, hook, ourCurrentHook(agent, site.cliPath, hook));
+    }
   }
 }
+function removeAgentHook(agent, site) {
+  const path = agentHookConfigPath(agent, site.env, site.home);
+  switch (agent) {
+    case "claude":
+      return removeStopHook(path);
+    case "codex":
+      return removeGroupedStopHook(path, ourHookOf(agent));
+    case "cursor":
+      return removeCursorStopHook(path, ourHookOf(agent));
+  }
+}
+function agentStopCommand(agent) {
+  return `${HOOK_STOP_COMMAND} --agent ${agent}`;
+}
+function posixCommand(agent) {
+  return `command -v backlog >/dev/null && backlog ${agentStopCommand(agent)} || true`;
+}
+function windowsCommand(agent, cliPath2) {
+  return `node "${cliPath2}" ${agentStopCommand(agent)}`;
+}
+function windowsCommandPattern(agent) {
+  return new RegExp(`^node "[^"]*cli\\.js" ${agentStopCommand(agent)}$`);
+}
+function ourHookOf(agent, cliPath2) {
+  return (hook) => {
+    const command = typeof hook === "object" && hook !== null ? hook.command : void 0;
+    if (typeof command !== "string") return false;
+    return command === posixCommand(agent) || cliPath2 !== void 0 && command === windowsCommand(agent, cliPath2) || windowsCommandPattern(agent).test(command);
+  };
+}
+function ourCurrentHook(agent, cliPath2, wanted) {
+  return {
+    isOurs: ourHookOf(agent, cliPath2),
+    isCurrent: (hook) => Object.entries(wanted).every(([key, value]) => hook[key] === value)
+  };
+}
 
 // src/cli/commands/setup.ts
 var setupCommand = {
   name: "setup",
-  usage: () => ["[--service]"],
+  usage: () => [`[--agent ${AGENTS.join("|")}] [--service]`, `--remove-manual [--agent ${AGENTS.join("|")}]`],
   run: runSetup
 };
 async function runSetup(args, io) {
-  const { service } = parseOptions(io.language, args, { service: { type: "boolean" } });
-  const setupDone = await runSetupSteps(io);
-  const serviceCode = service ? await installService(io) : EXIT.ok;
-  return setupDone ? serviceCode : EXIT.failed;
+  const options = parseOptions(io.language, args, { service: { type: "boolean" }, agent: { type: "string" }, "remove-manual": { type: "boolean" } });
+  if (options["remove-manual"] && options.service) throw new UsageError(cliMessages(io.language).removeManualWithService);
+  const agents = await targetAgents(options.agent, io);
+  const step = options["remove-manual"] ? removeManualSetup : setUpAgent;
+  const outcomes = [];
+  for (const agent of agents) outcomes.push(await step(agent, io));
+  const serviceCode = options.service ? await installService(io) : EXIT.ok;
+  return outcomes.every(Boolean) ? serviceCode : EXIT.failed;
+}
+async function targetAgents(option, io) {
+  const messages = cliMessages(io.language);
+  if (option !== void 0) return [parseChoice(io.language, option, AGENTS, messages.optionLabel.agent)];
+  const detection = await detectAgents(io.env, io.home);
+  for (const { agent, dir } of detection.missing) agentVoice(agent, io).print(messages.agentNotFound(dir));
+  return detection.found;
+}
+function agentVoice(agent, io) {
+  const label = AGENT_LABELS[agent];
+  return { print: (line) => io.print(`${label}: ${line}`), warn: (line) => io.warn(`${label}: ${line}`) };
+}
+async function setUpAgent(agent, io) {
+  const voice = agentVoice(agent, io);
+  const plugin = await agentPlugin(agent, io.env, io.home);
+  if (plugin !== null) {
+    voice.print(cliMessages(io.language).pluginManages(plugin));
+    return true;
+  }
+  if (!await linkAgentSkill(agent, io, voice)) return false;
+  const hook = await installAgentHook(agent, io);
+  const reported = reportHook(hook, agentHookConfigPath(agent, io.env, io.home), io, voice);
+  if (agent === "codex" && (hook === "added" || hook === "updated")) voice.print(cliMessages(io.language).codexHookApproval);
+  return reported;
 }
-async function runSetupSteps(io) {
+async function linkAgentSkill(agent, io, voice) {
   const messages = cliMessages(io.language);
-  const skillsDir = claudeSkillsDir(io.env, io.home);
-  const target = join29(skillsDir, "backlog");
+  const skillsDir = agentSkillsDir(agent, io.env, io.home);
+  const target = join32(skillsDir, "backlog");
   const source = skillSourceDir(io.packageRoot, io.language);
   let link2;
   try {
     link2 = await linkSkillFor(io.language, { skillsDir, packageRoot: io.packageRoot, platform: io.platform });
   } catch (error) {
-    io.warn(messages.installSkillLinkFailed(target, errorCodeOrText(error)));
+    voice.warn(messages.installSkillLinkFailed(target, errorCodeOrText(error)));
     return false;
   }
   if (link2 === "foreign") {
-    io.warn(messages.installSkillForeign(target, source));
+    voice.warn(messages.installSkillForeign(target, source));
     return false;
   }
-  io.print(link2 === "linked" ? messages.installSkillLinked(target, source) : messages.installSkillKept(target));
-  const settingsPath = claudeSettingsPath(io.env, io.home);
-  return reportHook(await addStopHook(settingsPath, io.platform), settingsPath, io);
+  voice.print(link2 === "linked" ? messages.installSkillLinked(target, source) : messages.installSkillKept(target));
+  return true;
 }
-function reportHook(result, settingsPath, io) {
+function reportHook(result, configPath, io, voice) {
   const messages = cliMessages(io.language);
-  if (result === "added") {
-    io.print(messages.installHookAdded(settingsPath));
-    return true;
-  }
-  if (result === "exists") {
-    io.print(messages.installHookExists(settingsPath));
+  if (typeof result === "string") {
+    const report = { added: messages.installHookAdded, exists: messages.installHookExists, updated: messages.installHookUpdated }[result];
+    voice.print(report(configPath));
     return true;
   }
   if (result.failed === "unreadable") {
-    io.warn(messages.installSettingsUnreadable(settingsPath, result.code));
+    voice.warn(messages.installSettingsUnreadable(configPath, result.code));
     return false;
   }
-  io.warn(messages.installSettingsInvalid(settingsPath));
+  voice.warn(messages.installSettingsInvalid(configPath));
+  return false;
+}
+async function removeManualSetup(agent, io) {
+  const voice = agentVoice(agent, io);
+  const messages = cliMessages(io.language);
+  const skillsDir = agentSkillsDir(agent, io.env, io.home);
+  voice.print(messages.manualSkillRemoval[await unlinkOurSkill(skillsDir)](join32(skillsDir, "backlog")));
+  for (const legacyDir of legacySkillsDirs(agent, io.env, io.home)) {
+    if (await unlinkOurSkill(legacyDir) === "removed") voice.print(messages.manualSkillRemoval.removed(join32(legacyDir, "backlog")));
+  }
+  return reportHookRemoval(await removeAgentHook(agent, io), agentHookConfigPath(agent, io.env, io.home), io, voice);
+}
+function reportHookRemoval(result, configPath, io, voice) {
+  const messages = cliMessages(io.language);
+  if (result === "removed" || result === "absent") {
+    voice.print(messages.manualHookRemoval[result](configPath));
+    return true;
+  }
+  voice.warn(result.failed === "unreadable" ? messages.hookConfigUnreadable(configPath, result.code) : messages.hookConfigInvalid(configPath));
   return false;
 }