p-backlog 0.4.0 → 0.5.1

package/dist/cli.js

@@ -127,6 +127,10 @@ function percent(part, total) {
 // src/core/model/lifecycle.ts
 var RETENTION_DAYS = 7;
 var DAY_MS = 24 * 60 * 60 * 1e3;
+var DAYS_PER_WEEK = 7;
+var WEEK_MS = DAYS_PER_WEEK * DAY_MS;
+var STATS_WEEKS = 12;
+var STATS_HISTORY_DAYS = STATS_WEEKS * DAYS_PER_WEEK;
 var RESOLUTION_STATUS = {
   fixed: "done",
   obsolete: "cancelled",
@@ -251,7 +255,7 @@ async function listDir(path, { recursive = false } = {}) {
     throw error;
   }
 }
-var REPLACE_RETRY_DELAYS_MS = [10, 20, 40, 80, 160, 320, 640];
+var REPLACE_RETRY_DELAYS_MS = [10, 20, 40, 80, 160, 320, 640, 1e3, 1e3, 1e3, 1e3];
 var REPLACE_BLOCKED_CODES = ["EPERM", "EACCES", "EBUSY"];
 async function writeFileAtomic(path, content, mode) {
   await viaTemporaryFile(path, content, (temporary) => replaceFile(temporary, path), mode);
@@ -382,7 +386,7 @@ async function release({ lock, token }) {
 
 // src/core/store/runs.ts
 var RUNS_FILE = ".runs.jsonl";
-var RUNS_KEPT_DAYS = 30;
+var RUNS_KEPT_DAYS = STATS_HISTORY_DAYS;
 var STALE_RUN_SLACK_DAYS = 1;
 var FIRST_LINE_BYTES = 4096;
 var cliRunSchema = z.object({
@@ -555,7 +559,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}`,
@@ -563,8 +567,26 @@ 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}`,
-  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.`,
+  installHookUpdated: (settingsPath) => `Stop hook updated in ${settingsPath}`,
+  codexHookApproval: "approve the hook in Codex: /hooks",
+  installHookConfigUnreadable: (path, detail) => `Could not read ${path} (${detail}), Stop hook not added.`,
+  installHookConfigInvalid: (path) => `${path} 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`
+  },
+  manualSkillShared: (target, agent) => `skill link kept, ${agent} uses it: ${target}`,
+  manualHookRemoval: {
+    removed: (path) => `Stop hook removed from ${path}`,
+    absent: (path) => `no p-backlog Stop hook in ${path}`
+  },
+  removeHookConfigUnreadable: (path, detail) => `Could not read ${path} (${detail}), the hook was not removed.`,
+  removeHookConfigInvalid: (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",
@@ -659,11 +681,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}]`,
@@ -713,7 +736,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}`,
@@ -721,8 +744,26 @@ 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}`,
-  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.`,
+  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",
+  installHookConfigUnreadable: (path, detail) => `${path} \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.`,
+  installHookConfigInvalid: (path) => `${path} \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`
+  },
+  manualSkillShared: (target, agent) => `\u0441\u0441\u044B\u043B\u043A\u0430 \u043D\u0430 \u0441\u043A\u0438\u043B\u043B \u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D\u0430, \u0435\u044E \u043F\u043E\u043B\u044C\u0437\u0443\u0435\u0442\u0441\u044F ${agent}: ${target}`,
+  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`
+  },
+  removeHookConfigUnreadable: (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.`,
+  removeHookConfigInvalid: (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",
@@ -829,11 +870,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}]`,
@@ -1321,9 +1363,6 @@ function consecutivePeriods(starts, lastTo) {
 }
 
 // src/core/stats/weeks.ts
-var STATS_WEEKS = 12;
-var DAYS_PER_WEEK = 7;
-var WEEK_MS = DAYS_PER_WEEK * DAY_MS;
 var MONDAY = 1;
 function weekStarts(now, count3) {
   const monday = new Date(now.getFullYear(), now.getMonth(), now.getDate() - (now.getDay() + DAYS_PER_WEEK - MONDAY) % DAYS_PER_WEEK);
@@ -1335,15 +1374,18 @@ function statsPeriod(now) {
 function weekWindows(now, count3 = STATS_WEEKS) {
   return consecutivePeriods(weekStarts(now, count3), now.getTime());
 }
-function weeklyFlow(histories, now) {
+function flowOver(periods, histories) {
   const closings = histories.flatMap(closingsOf);
-  return weekWindows(now).map((week) => ({
-    start: formatLocalIso(new Date(week.from)),
-    created: histories.filter((history) => week.contains(history.createdAt)).length,
-    closed: closings.filter((closing) => week.contains(closing.at)).length,
-    openAtEnd: histories.filter((history) => isOpenAt(history, week.to)).length
+  return periods.map((span) => ({
+    start: formatLocalIso(new Date(span.from)),
+    created: histories.filter((history) => span.contains(history.createdAt)).length,
+    closed: closings.filter((closing) => span.contains(closing.at)).length,
+    openAtEnd: histories.filter((history) => isOpenAt(history, span.to)).length
   }));
 }
+function weeklyFlow(histories, now) {
+  return flowOver(weekWindows(now), histories);
+}
 
 // src/core/messages/zod.ts
 var TYPE_WITNESSES = {
@@ -3874,7 +3916,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";
@@ -3891,18 +3937,65 @@ 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, home: 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, places) {
+  return agent === "claude" ? claudeSkillsDir(places.env, places.home) : join16(places.home, ".agents", "skills");
+}
+function legacySkillsDirs(agent, places) {
+  return agent === "claude" ? [] : [join16(agentHomeDir(agent, places), "skills")];
+}
+async function detectAgents(places) {
+  const detection = { found: [], missing: [] };
+  for (const agent of AGENTS) {
+    const dir = agentHomeDir(agent, places);
+    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, home: 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);
 }
@@ -3910,7 +4003,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";
@@ -3924,6 +4017,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 = {
@@ -3947,11 +4052,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);
+  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);
+  if (plugin !== null) {
+    const wanted = pluginToSwitchTo(plugin, language);
+    if (wanted !== null) io.print(`${label}: ${messages.pluginLanguageHint(plugin, wanted)}`);
+    return;
+  }
+  const skillsDir = agentSkillsDir(agent, io);
+  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) {
@@ -4004,31 +4127,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);
@@ -4037,7 +4176,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
@@ -4163,6 +4302,21 @@ function isWorkStatus(status) {
   return status === "in-progress" || status === "blocked";
 }
 
+// src/core/stats/days.ts
+var STATS_DAYS = 30;
+function dayRange(now, count3) {
+  return dayStarts(now, count3).map(formatLocalDay);
+}
+function dailyFlow(histories, now) {
+  return flowOver(dayWindows(now), histories);
+}
+function dayWindows(now, count3 = STATS_DAYS) {
+  return consecutivePeriods(dayStarts(now, count3), now.getTime());
+}
+function dayStarts(now, count3) {
+  return Array.from({ length: count3 }, (_, index) => new Date(now.getFullYear(), now.getMonth(), now.getDate() - (count3 - 1 - index)));
+}
+
 // src/core/stats/quality/accuracy.ts
 function accuracy(histories, period2) {
   const episodes = histories.flatMap(
@@ -4175,15 +4329,21 @@ function accuracy(histories, period2) {
   });
   return [...byEvidence, { evidence: "total", ...outcomeCounts(episodes) }];
 }
-function accuracyWeeks(histories, now) {
-  return weekWindows(now).map((week) => {
+function accuracyOver(periods, histories) {
+  return periods.map((span) => {
     const decided = histories.flatMap(
-      (history) => history.candidates.filter((candidate) => week.contains(candidate.at) && candidate.evidence !== "no-source").map((candidate) => outcomeAfter(history, candidate.at)).filter((outcome) => outcome !== "open")
+      (history) => history.candidates.filter((candidate) => span.contains(candidate.at) && candidate.evidence !== "no-source").map((candidate) => outcomeAfter(history, candidate.at)).filter((outcome) => outcome !== "open")
     );
     const closed = decided.filter((outcome) => outcome === "closed").length;
-    return { start: formatLocalIso(new Date(week.from)), decided: decided.length, precision: decided.length === 0 ? null : closed / decided.length };
+    return { start: formatLocalIso(new Date(span.from)), decided: decided.length, precision: decided.length === 0 ? null : closed / decided.length };
   });
 }
+function accuracyWeeks(histories, now) {
+  return accuracyOver(weekWindows(now), histories);
+}
+function accuracyDays(histories, now) {
+  return accuracyOver(dayWindows(now), histories);
+}
 function methodAccuracy(histories, period2) {
   return splitAccuracy(histories, period2, { evidence: "source-changed", keys: RECORDED_METHODS, keyOf: (candidate) => candidate.method });
 }
@@ -4315,6 +4475,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) {
@@ -4343,37 +4553,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);
@@ -4389,6 +4612,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 } }];
@@ -4788,10 +5012,10 @@ 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);
@@ -4814,7 +5038,7 @@ async function sweepClosed(root, now, 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) {
@@ -4938,49 +5162,49 @@ 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 = z12.strictObject({
-  status: z12.enum(TASK_STATUSES),
-  priority: z12.enum(PRIORITIES),
+var batchPreviousSchema = z14.strictObject({
+  status: z14.enum(TASK_STATUSES),
+  priority: z14.enum(PRIORITIES),
   epic: taskIdSchema.nullable(),
-  resolution: z12.enum(RESOLUTIONS).nullable(),
-  reason: z12.string().nullable()
+  resolution: z14.enum(RESOLUTIONS).nullable(),
+  reason: z14.string().nullable()
 });
 var BATCH_TASKS_LIMIT = 500;
-var batchRequestSchema = z12.strictObject({
-  tasks: z12.array(z12.strictObject({ id: taskIdSchema, version: z12.string().min(1) })).min(1).max(BATCH_TASKS_LIMIT).refine((tasks) => new Set(tasks.map((task) => task.id)).size === tasks.length),
-  action: z12.discriminatedUnion("kind", [
-    z12.strictObject({ kind: z12.literal("close"), reason: z12.string().transform((reason) => reason.replace(/\s*\n\s*/g, " ").trim()).pipe(z12.string().min(1)) }),
-    z12.strictObject({ kind: z12.literal("priority"), priority: z12.enum(PRIORITIES) }),
-    z12.strictObject({ kind: z12.literal("epic"), epic: taskIdSchema.nullable() }),
-    z12.strictObject({ kind: z12.literal("restore"), changes: z12.record(taskIdSchema, batchPreviousSchema) })
+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) })
   ])
 });
 
@@ -5085,7 +5309,7 @@ function createReportCache({ ttlMs, now }) {
 
 // src/server/revisions.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { stat as stat4 } from "node:fs/promises";
+import { stat as stat5 } from "node:fs/promises";
 import { basename as basename9 } from "node:path";
 function createRevisions(boot = randomUUID3()) {
   let seq = 0;
@@ -5117,7 +5341,7 @@ function createRevisions(boot = randomUUID3()) {
   };
 }
 async function markOf(path) {
-  const [text, stats] = await Promise.all([readTextOrNull(path), stat4(path).catch(() => null)]);
+  const [text, stats] = await Promise.all([readTextOrNull(path), stat5(path).catch(() => null)]);
   return text === null || stats === null ? null : { version: contentVersion(text), mtimeMs: stats.mtimeMs };
 }
 
@@ -5125,26 +5349,26 @@ async function markOf(path) {
 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);
@@ -5541,13 +5765,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) {
@@ -5562,24 +5786,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
@@ -5631,26 +5855,6 @@ function costOf(model, tokens) {
   return total / 1e6;
 }
 
-// src/core/stats/days.ts
-var STATS_DAYS = 30;
-function dayRange(now, count3) {
-  return dayStarts(now, count3).map(formatLocalDay);
-}
-function dailyIntake(histories, now) {
-  const created = /* @__PURE__ */ new Map();
-  for (const history of histories) {
-    const day = formatLocalDay(new Date(history.createdAt));
-    created.set(day, (created.get(day) ?? 0) + 1);
-  }
-  return dayRange(now, STATS_DAYS).map((day) => ({ day, created: created.get(day) ?? 0 }));
-}
-function dayWindows(now, count3 = STATS_DAYS) {
-  return consecutivePeriods(dayStarts(now, count3), now.getTime());
-}
-function dayStarts(now, count3) {
-  return Array.from({ length: count3 }, (_, index) => new Date(now.getFullYear(), now.getMonth(), now.getDate() - (count3 - 1 - index)));
-}
-
 // src/core/stats/cost/cost-report.ts
 var COST_TOTALS_DAYS = 7;
 function costReport({ buckets, runs, projectOf: projectOf2, projectId, now, scan }) {
@@ -5668,6 +5872,10 @@ function costReport({ buckets, runs, projectOf: projectOf2, projectId, now, scan
     since: sinceOf(scopedBuckets),
     totals: totalsOf(inDays(bucketsByDay, totalsDays), inDays(runsByDay, totalsDays)),
     days: days3.map((day) => dayRow(day, bucketsByDay.get(day) ?? [], runsByDay.get(day) ?? [])),
+    weeks: weekWindows(now).map((week) => {
+      const weekDays = daysOf(week);
+      return periodRow(formatLocalIso(new Date(week.from)), inDays(bucketsByDay, weekDays), inDays(runsByDay, weekDays));
+    }),
     models: modelsOf(scopedBuckets),
     commands: commandsOf(inDays(runsByDay, days3))
   };
@@ -5679,6 +5887,10 @@ function memoizedByCwd(projectOf2) {
     return known.get(cwd) ?? null;
   };
 }
+function daysOf(week) {
+  const monday = new Date(week.from);
+  return dayRange(new Date(monday.getFullYear(), monday.getMonth(), monday.getDate() + DAYS_PER_WEEK - 1), DAYS_PER_WEEK);
+}
 function localDay(at) {
   const moment = Date.parse(at);
   return Number.isNaN(moment) ? "" : formatLocalDay(new Date(moment));
@@ -5714,19 +5926,24 @@ function runCounts(runs) {
   const hookRuns = runs.filter((run) => run.command === HOOK_STOP_COMMAND).length;
   return { cliRuns: runs.length - hookRuns, hookRuns };
 }
-function dayRow(day, dayBuckets, dayRuns) {
-  const hookBuckets = dayBuckets.filter((bucket) => bucket.kind === "hook");
-  const cliBuckets = dayBuckets.filter((bucket) => bucket.kind === "cli" || bucket.kind === "skill");
+function costRowNumbers(buckets, runs) {
+  const hookBuckets = buckets.filter((bucket) => bucket.kind === "hook");
+  const cliBuckets = buckets.filter((bucket) => bucket.kind === "cli" || bucket.kind === "skill");
   return {
-    day,
     hookTokens: tokensTotalOf(hookBuckets),
     cliTokens: tokensTotalOf(cliBuckets),
-    cost: costOfBuckets(dayBuckets),
-    hasUnpricedTokens: hasUnpricedTokens(dayBuckets),
-    hookTurns: sum(dayBuckets.map((bucket) => bucket.hookTurns)),
-    ...runCounts(dayRuns)
+    cost: costOfBuckets(buckets),
+    hasUnpricedTokens: hasUnpricedTokens(buckets),
+    hookTurns: sum(buckets.map((bucket) => bucket.hookTurns)),
+    ...runCounts(runs)
   };
 }
+function dayRow(day, dayBuckets, dayRuns) {
+  return { day, ...costRowNumbers(dayBuckets, dayRuns) };
+}
+function periodRow(start, periodBuckets, periodRuns) {
+  return { start, ...costRowNumbers(periodBuckets, periodRuns) };
+}
 function modelsOf(buckets) {
   return [...groupBy(buckets, (bucket) => bucket.model).entries()].map(([key, modelBuckets]) => ({ ...splitFastModel(key), tokens: tokensTotalOf(modelBuckets), cost: costOfBuckets(modelBuckets) })).filter((row) => row.tokens > 0).sort((a, b) => b.tokens - a.tokens);
 }
@@ -5950,6 +6167,7 @@ function qualityReport(input, base = reportBase(input), graphs = []) {
     ...base.head,
     accuracy: accuracy(histories, period2),
     accuracyWeeks: accuracyWeeks(histories, now),
+    accuracyDays: accuracyDays(histories, now),
     methodAccuracy: methodAccuracy(histories, period2),
     matchAccuracy: matchAccuracy(histories, period2),
     graph: { projects: graphs, filter: graphFilterEffect(histories, period2) },
@@ -5969,7 +6187,7 @@ function statsReport(input, base = reportBase(input)) {
     ...base.head,
     totals: totals(histories, now, period2, base.scope.journalStart),
     weeks: weeklyFlow(histories, now),
-    days: dailyIntake(histories, now),
+    days: dailyFlow(histories, now),
     hotspots: hotspots(openTasks, scopeLabel(projectId)),
     age: ageBreakdown(openTasks, now),
     closing: closingBreakdown(histories, period2)
@@ -6289,7 +6507,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;
 }
@@ -6401,12 +6619,12 @@ function logReport({ closedEpics, reopenedEpics, blockingFiles, deleted, conflic
 }
 
 // src/core/usage/transcripts.ts
-import { createHash as createHash4 } from "node:crypto";
-import { open as open2, stat as stat5 } from "node:fs/promises";
-import { basename as basename10, 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", "`"];
@@ -6599,21 +6817,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: [] };
 }
@@ -6737,53 +6955,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)));
       }
     }
   }
@@ -6791,7 +7009,7 @@ async function listTranscripts(claudeProjectsDir2) {
 }
 async function listedFile(path) {
   try {
-    const { size, mtimeMs } = await stat5(path);
+    const { size, mtimeMs } = await stat6(path);
     return [{ path, size, mtimeMs }];
   } catch {
     return [];
@@ -6819,7 +7037,7 @@ async function scanTranscripts({ files, cache, byteBudget, now }) {
   };
 }
 function deletedStillReported(cache, listedFiles, now) {
-  const reportStart = now.getTime() - COST_REPORT_DAYS * DAY_MS;
+  const reportStart = now.getTime() - STATS_HISTORY_DAYS * DAY_MS;
   const listedSessions = new Set(Object.keys(listedFiles).map((path) => basename10(path)));
   return Object.fromEntries(
     Object.entries(cache.files).filter(([path, entry]) => !listedSessions.has(basename10(path)) && entry.buckets.some((bucket) => Date.parse(bucket.slot) >= reportStart))
@@ -6856,7 +7074,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) {
@@ -6974,7 +7192,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}
@@ -7075,7 +7293,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
@@ -7148,7 +7366,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]);
@@ -7183,7 +7401,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;
@@ -7191,16 +7409,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";
@@ -7251,7 +7469,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),
@@ -7278,7 +7496,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("%", "%%")}"`;
@@ -7312,7 +7530,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",
@@ -7430,50 +7648,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 stat6 } 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 stat6(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 {
@@ -7492,62 +7703,256 @@ 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 = guardedPosixCommand(HOOK_STOP_COMMAND);
+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 guardedPosixCommand(backlogArgs) {
+  return `command -v backlog >/dev/null && backlog ${backlogArgs} || true`;
+}
+function hookCommand2(hook) {
+  const command = typeof hook === "object" && hook !== null ? hook.command : void 0;
+  return typeof command === "string" ? command : void 0;
+}
+function isOurStopHook(hook) {
+  const command = hookCommand2(hook);
+  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, places) {
+  return agent === "claude" ? claudeSettingsPath(places.env, places.home) : join31(agentHomeDir(agent, places), AGENT_HOOKS_FILE);
+}
+function installAgentHook(agent, site) {
+  const path = agentHookConfigPath(agent, site);
+  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);
+  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 guardedPosixCommand(agentStopCommand(agent));
+}
+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 = hookCommand2(hook);
+    if (command === void 0) 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 outcomes = [];
+  for (const agent of agents) outcomes.push(options["remove-manual"] ? await removeManualSetup(agent, agents, io) : await setUpAgent(agent, io));
+  const serviceCode = options.service ? await installService(io) : EXIT.ok;
+  return outcomes.every(Boolean) ? serviceCode : EXIT.failed;
 }
-async function runSetupSteps(io) {
+async function targetAgents(option, io) {
   const messages = cliMessages(io.language);
-  const skillsDir = claudeSkillsDir(io.env, io.home);
-  const target = join29(skillsDir, "backlog");
+  if (option !== void 0) return [parseChoice(io.language, option, AGENTS, messages.optionLabel.agent)];
+  const detection = await detectAgents(io);
+  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);
+  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), io, voice);
+  if (agent === "codex" && (hook === "added" || hook === "updated")) voice.print(cliMessages(io.language).codexHookApproval);
+  return reported;
+}
+async function linkAgentSkill(agent, io, voice) {
+  const messages = cliMessages(io.language);
+  const skillsDir = agentSkillsDir(agent, io);
+  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));
+  await removeLegacySkillLinks(agent, io, voice);
+  return true;
 }
-function reportHook(result, settingsPath, io) {
-  const messages = cliMessages(io.language);
-  if (result === "added") {
-    io.print(messages.installHookAdded(settingsPath));
-    return true;
+async function removeLegacySkillLinks(agent, io, voice) {
+  for (const legacyDir of legacySkillsDirs(agent, io)) {
+    if (await unlinkOurSkill(legacyDir) === "removed") voice.print(cliMessages(io.language).manualSkillRemoval.removed(join32(legacyDir, "backlog")));
   }
-  if (result === "exists") {
-    io.print(messages.installHookExists(settingsPath));
+}
+function reportHook(result, configPath, io, voice) {
+  const messages = cliMessages(io.language);
+  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.installHookConfigUnreadable(configPath, result.code));
     return false;
   }
-  io.warn(messages.installSettingsInvalid(settingsPath));
+  voice.warn(messages.installHookConfigInvalid(configPath));
+  return false;
+}
+async function removeManualSetup(agent, removing, io) {
+  const voice = agentVoice(agent, io);
+  const messages = cliMessages(io.language);
+  const skillsDir = agentSkillsDir(agent, io);
+  const target = join32(skillsDir, "backlog");
+  const sharer = await remainingSkillDirUser(agent, removing, io);
+  voice.print(sharer === null ? messages.manualSkillRemoval[await unlinkOurSkill(skillsDir)](target) : messages.manualSkillShared(target, AGENT_LABELS[sharer]));
+  await removeLegacySkillLinks(agent, io, voice);
+  return reportHookRemoval(await removeAgentHook(agent, io), agentHookConfigPath(agent, io), io, voice);
+}
+async function remainingSkillDirUser(agent, removing, io) {
+  const skillsDir = agentSkillsDir(agent, io);
+  const { found } = await detectAgents(io);
+  return found.find((other) => !removing.includes(other) && agentSkillsDir(other, io) === skillsDir) ?? null;
+}
+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.removeHookConfigUnreadable(configPath, result.code) : messages.removeHookConfigInvalid(configPath));
   return false;
 }