caveat-cli 0.17.7 → 0.18.0

package/dist/index.js

@@ -76,7 +76,7 @@ import {
   userPromptSubmitReminderText,
   writeDigestMarker,
   writeUserConfigPatch
-} from "./chunk-ZBHCOA6R.js";
+} from "./chunk-KAULUIC4.js";
 
 // ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -455,11 +455,11 @@ var require_codegen = __commonJS({
         const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
         return `${varKind} ${this.name}${rhs};` + _n;
       }
-      optimizeNames(names, constants4) {
+      optimizeNames(names, constants5) {
         if (!names[this.name.str])
           return;
         if (this.rhs)
-          this.rhs = optimizeExpr(this.rhs, names, constants4);
+          this.rhs = optimizeExpr(this.rhs, names, constants5);
         return this;
       }
       get names() {
@@ -476,10 +476,10 @@ var require_codegen = __commonJS({
       render({ _n }) {
         return `${this.lhs} = ${this.rhs};` + _n;
       }
-      optimizeNames(names, constants4) {
+      optimizeNames(names, constants5) {
         if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
           return;
-        this.rhs = optimizeExpr(this.rhs, names, constants4);
+        this.rhs = optimizeExpr(this.rhs, names, constants5);
         return this;
       }
       get names() {
@@ -540,8 +540,8 @@ var require_codegen = __commonJS({
       optimizeNodes() {
         return `${this.code}` ? this : void 0;
       }
-      optimizeNames(names, constants4) {
-        this.code = optimizeExpr(this.code, names, constants4);
+      optimizeNames(names, constants5) {
+        this.code = optimizeExpr(this.code, names, constants5);
         return this;
       }
       get names() {
@@ -570,12 +570,12 @@ var require_codegen = __commonJS({
         }
         return nodes.length > 0 ? this : void 0;
       }
-      optimizeNames(names, constants4) {
+      optimizeNames(names, constants5) {
         const { nodes } = this;
         let i = nodes.length;
         while (i--) {
           const n = nodes[i];
-          if (n.optimizeNames(names, constants4))
+          if (n.optimizeNames(names, constants5))
             continue;
           subtractNames(names, n.names);
           nodes.splice(i, 1);
@@ -628,12 +628,12 @@ var require_codegen = __commonJS({
           return void 0;
         return this;
       }
-      optimizeNames(names, constants4) {
+      optimizeNames(names, constants5) {
         var _a3;
-        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants4);
-        if (!(super.optimizeNames(names, constants4) || this.else))
+        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants5);
+        if (!(super.optimizeNames(names, constants5) || this.else))
           return;
-        this.condition = optimizeExpr(this.condition, names, constants4);
+        this.condition = optimizeExpr(this.condition, names, constants5);
         return this;
       }
       get names() {
@@ -656,10 +656,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.iteration})` + super.render(opts);
       }
-      optimizeNames(names, constants4) {
-        if (!super.optimizeNames(names, constants4))
+      optimizeNames(names, constants5) {
+        if (!super.optimizeNames(names, constants5))
           return;
-        this.iteration = optimizeExpr(this.iteration, names, constants4);
+        this.iteration = optimizeExpr(this.iteration, names, constants5);
         return this;
       }
       get names() {
@@ -695,10 +695,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
       }
-      optimizeNames(names, constants4) {
-        if (!super.optimizeNames(names, constants4))
+      optimizeNames(names, constants5) {
+        if (!super.optimizeNames(names, constants5))
           return;
-        this.iterable = optimizeExpr(this.iterable, names, constants4);
+        this.iterable = optimizeExpr(this.iterable, names, constants5);
         return this;
       }
       get names() {
@@ -740,11 +740,11 @@ var require_codegen = __commonJS({
         (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
         return this;
       }
-      optimizeNames(names, constants4) {
+      optimizeNames(names, constants5) {
         var _a3, _b;
-        super.optimizeNames(names, constants4);
-        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants4);
-        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants4);
+        super.optimizeNames(names, constants5);
+        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants5);
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants5);
         return this;
       }
       get names() {
@@ -1045,7 +1045,7 @@ var require_codegen = __commonJS({
     function addExprNames(names, from) {
       return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
     }
-    function optimizeExpr(expr, names, constants4) {
+    function optimizeExpr(expr, names, constants5) {
       if (expr instanceof code_1.Name)
         return replaceName(expr);
       if (!canOptimize(expr))
@@ -1060,14 +1060,14 @@ var require_codegen = __commonJS({
         return items;
       }, []));
       function replaceName(n) {
-        const c = constants4[n.str];
+        const c = constants5[n.str];
         if (c === void 0 || names[n.str] !== 1)
           return n;
         delete names[n.str];
         return c;
       }
       function canOptimize(e) {
-        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants4[c.str] !== void 0);
+        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants5[c.str] !== void 0);
       }
     }
     function subtractNames(names, from) {
@@ -6889,8 +6889,8 @@ var stdoutLogger = {
 
 // src/commands/init.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync, renameSync, rmdirSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync, renameSync, rmdirSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, join as join9 } from "node:path";
 
 // src/claudeInstall.ts
 import { spawnSync } from "node:child_process";
@@ -6998,9 +6998,10 @@ function isCaveatClaudeHookCommand(actual, event) {
   return lower.includes("caveat") && actual.includes(`hook ${event}`);
 }
 function isCanonicalCaveatClaudeHookCommand(actual, event, nodePath, cliScriptPath) {
-  if (actual !== hookCommand(nodePath, cliScriptPath, event)) return false;
   const tokens = commandTokens(actual);
-  return tokens?.length === 4 && isCanonicalAsset(tokens[0], nodePath, constants.X_OK) && isCanonicalAsset(tokens[1], cliScriptPath, constants.R_OK) && tokens[2] === "hook" && tokens[3] === event;
+  if (tokens?.length !== 4 || tokens[2] !== "hook" || tokens[3] !== event) return false;
+  if (actual !== hookCommand(tokens[0], tokens[1], event)) return false;
+  return isCanonicalAsset(tokens[0], nodePath, constants.X_OK) && isCanonicalAsset(tokens[1], cliScriptPath, constants.R_OK);
 }
 function isCaveatClaudeMcpRegistration(value, nodePath, cliScriptPath) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
@@ -7511,6 +7512,150 @@ function detectCodexHookInstallation(codexHome) {
   };
 }
 
+// src/cursorInstall.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "node:fs";
+import { join as join5 } from "node:path";
+import { constants as constants3 } from "node:fs";
+var TIMEOUT_SEC = 10;
+function hookCommand3(nodePath, cliScriptPath, event) {
+  return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} cursor-hook ${event}`;
+}
+function eventCommandFragment2(event) {
+  return `cursor-hook ${event}`;
+}
+function isCaveatCursorHookCommand(actual, event) {
+  const lower = actual.toLowerCase();
+  return lower.includes("caveat") && actual.includes(eventCommandFragment2(event));
+}
+function readHooks2(path) {
+  if (!existsSync4(path)) return { version: 1, hooks: {} };
+  const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${path} \u306F object \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`);
+  }
+  const file2 = parsed;
+  if (file2.hooks == null) file2.hooks = {};
+  if (typeof file2.hooks !== "object" || Array.isArray(file2.hooks)) {
+    throw new Error(`${path} \u306E hooks \u306F object \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`);
+  }
+  return file2;
+}
+function listFor(file2, event) {
+  const current = file2.hooks?.[event];
+  if (Array.isArray(current)) return current;
+  return [];
+}
+function isSameCommand(actual, expected) {
+  const left = commandTokens(actual);
+  const right = commandTokens(expected);
+  return left !== null && right !== null && left.length === right.length && left.every((token, index) => token === right[index]);
+}
+function upsertHook3(file2, event, command, subcommand) {
+  file2.hooks ??= {};
+  const list = listFor(file2, event);
+  for (const entry of list) {
+    if (typeof entry.command !== "string") continue;
+    if (isSameCommand(entry.command, command) && entry.timeout === TIMEOUT_SEC) {
+      return "unchanged";
+    }
+    if (isSameCommand(entry.command, command) || isCaveatCursorHookCommand(entry.command, subcommand)) {
+      entry.command = command;
+      entry.timeout = TIMEOUT_SEC;
+      file2.hooks[event] = list;
+      return "added";
+    }
+  }
+  list.push({ command, timeout: TIMEOUT_SEC });
+  file2.hooks[event] = list;
+  return "added";
+}
+function removeHook3(file2, event, command, subcommand) {
+  const list = listFor(file2, event);
+  if (list.length === 0) return false;
+  const kept = list.filter((entry) => {
+    if (typeof entry.command !== "string") return true;
+    return !(isSameCommand(entry.command, command) || isCaveatCursorHookCommand(entry.command, subcommand));
+  });
+  if (kept.length === list.length) return false;
+  if (!file2.hooks) return true;
+  if (kept.length > 0) file2.hooks[event] = kept;
+  else delete file2.hooks[event];
+  return true;
+}
+function hasCaveatHook2(file2, event, fragment) {
+  return listFor(file2, event).some(
+    (entry) => typeof entry.command === "string" && entry.command.includes(fragment)
+  );
+}
+function persist(opts, file2, changed) {
+  const hooksPath = join5(opts.cursorDir, "hooks.json");
+  if (opts.dryRun) {
+    opts.logger.info(`[dry-run] would write Cursor hooks to ${hooksPath}`);
+    return void 0;
+  }
+  if (!changed) return void 0;
+  mkdirSync2(opts.cursorDir, { recursive: true });
+  file2.version = 1;
+  const backup = writeJsonWithBackup(hooksPath, file2);
+  return backup || void 0;
+}
+function installCursorHooks(opts) {
+  const hooksPath = join5(opts.cursorDir, "hooks.json");
+  const file2 = readHooks2(hooksPath);
+  const promptCmd = hookCommand3(opts.nodePath, opts.cliScriptPath, "user-prompt-submit");
+  const toolCmd = hookCommand3(opts.nodePath, opts.cliScriptPath, "post-tool-use");
+  const stopCmd = hookCommand3(opts.nodePath, opts.cliScriptPath, "stop");
+  const hooks = {
+    beforeSubmitPrompt: upsertHook3(file2, "beforeSubmitPrompt", promptCmd, "user-prompt-submit"),
+    postToolUse: upsertHook3(file2, "postToolUse", toolCmd, "post-tool-use"),
+    postToolUseFailure: upsertHook3(file2, "postToolUseFailure", toolCmd, "post-tool-use"),
+    stop: upsertHook3(file2, "stop", stopCmd, "stop")
+  };
+  const changed = Object.values(hooks).some((status2) => status2 === "added");
+  const backupPath = persist(opts, file2, changed);
+  return { hooks, backupPath };
+}
+function uninstallCursorHooks(opts) {
+  const hooksPath = join5(opts.cursorDir, "hooks.json");
+  const file2 = readHooks2(hooksPath);
+  const promptCmd = hookCommand3(opts.nodePath, opts.cliScriptPath, "user-prompt-submit");
+  const toolCmd = hookCommand3(opts.nodePath, opts.cliScriptPath, "post-tool-use");
+  const stopCmd = hookCommand3(opts.nodePath, opts.cliScriptPath, "stop");
+  const removed = {
+    beforeSubmitPrompt: removeHook3(file2, "beforeSubmitPrompt", promptCmd, "user-prompt-submit"),
+    postToolUse: removeHook3(file2, "postToolUse", toolCmd, "post-tool-use"),
+    postToolUseFailure: removeHook3(file2, "postToolUseFailure", toolCmd, "post-tool-use"),
+    stop: removeHook3(file2, "stop", stopCmd, "stop")
+  };
+  const changed = Object.values(removed).some(Boolean);
+  const backupPath = persist(opts, file2, changed);
+  return {
+    hooks: {
+      beforeSubmitPrompt: removed.beforeSubmitPrompt ? "added" : "unchanged",
+      postToolUse: removed.postToolUse ? "added" : "unchanged",
+      postToolUseFailure: removed.postToolUseFailure ? "added" : "unchanged",
+      stop: removed.stop ? "added" : "unchanged"
+    },
+    backupPath
+  };
+}
+function detectCursorHookInstallation(cursorDir) {
+  const hooksPath = join5(cursorDir, "hooks.json");
+  const file2 = existsSync4(hooksPath) ? readHooks2(hooksPath) : { version: 1, hooks: {} };
+  const hooks = {
+    beforeSubmitPrompt: hasCaveatHook2(file2, "beforeSubmitPrompt", eventCommandFragment2("user-prompt-submit")),
+    postToolUse: hasCaveatHook2(file2, "postToolUse", eventCommandFragment2("post-tool-use")),
+    postToolUseFailure: hasCaveatHook2(file2, "postToolUseFailure", eventCommandFragment2("post-tool-use")),
+    stop: hasCaveatHook2(file2, "stop", eventCommandFragment2("stop"))
+  };
+  const count = Object.values(hooks).filter(Boolean).length;
+  return {
+    installation: count === 0 ? "not-installed" : count === 4 ? "installed" : "partial",
+    hooksPath,
+    hooks
+  };
+}
+
 // src/ghSetup.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { readSync } from "node:fs";
@@ -7558,8 +7703,8 @@ function askOnce(question) {
 }
 
 // src/nodePath.ts
-import { existsSync as existsSync4, realpathSync as realpathSync2 } from "node:fs";
-import { delimiter, join as join5 } from "node:path";
+import { existsSync as existsSync5, realpathSync as realpathSync2 } from "node:fs";
+import { delimiter, join as join6 } from "node:path";
 var defaultRealpath = (path) => realpathSync2.native(path);
 function safeRealpath(path, realpath = defaultRealpath) {
   try {
@@ -7572,7 +7717,7 @@ function resolveHookNodePath({
   env = process.env,
   execPath = process.execPath,
   platform = process.platform,
-  exists = existsSync4,
+  exists = existsSync5,
   realpath = defaultRealpath
 } = {}) {
   const execRealpath = safeRealpath(execPath, realpath);
@@ -7580,7 +7725,7 @@ function resolveHookNodePath({
   const names = nodeExecutableNames(platform);
   for (const dir of pathEnv.split(delimiter).filter(Boolean)) {
     for (const name of names) {
-      const candidate = join5(dir, name);
+      const candidate = join6(dir, name);
       if (!exists(candidate)) continue;
       const candidateRealpath = safeRealpath(candidate, realpath);
       if (execRealpath && candidateRealpath && candidateRealpath === execRealpath) {
@@ -7592,14 +7737,14 @@ function resolveHookNodePath({
 }
 
 // src/commands/publish.ts
-import { existsSync as existsSync5 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // src/commands/codexSidecarAdvisory.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { mkdtempSync, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var DEFAULT_HOOK_SIDECAR_TIMEOUT_MS = 12e4;
 var MAX_HOOK_SIDECAR_TIMEOUT_MS = 24e4;
 function resolveHookSidecarTimeoutMs(raw) {
@@ -7655,11 +7800,11 @@ function runCodexSidecarAdvisory(input) {
   let resultDir;
   let advisory;
   try {
-    resultDir = mkdtempSync(join6(tmpdir(), "caveat-codex-advisory-"));
-    const resultFile = join6(resultDir, "result.json");
+    resultDir = mkdtempSync(join7(tmpdir(), "caveat-codex-advisory-"));
+    const resultFile = join7(resultDir, "result.json");
     args.push("--save-result", resultFile);
     if (input.additionalContext) {
-      const additionalContextFile = join6(resultDir, "hook-signal.json");
+      const additionalContextFile = join7(resultDir, "hook-signal.json");
       writeFileSync2(additionalContextFile, JSON.stringify({ context: [input.additionalContext] }) + "\n", { encoding: "utf-8", mode: 384, flag: "wx" });
       args.push("--additional-context-file", additionalContextFile);
     }
@@ -7687,7 +7832,7 @@ function runCodexSidecarAdvisory(input) {
         message: `sidecar command failed: ${sidecarFailureDetail(detail)}`
       };
     } else {
-      const parsed = JSON.parse(readFileSync4(resultFile, "utf-8"));
+      const parsed = JSON.parse(readFileSync5(resultFile, "utf-8"));
       if (parsed.status !== "ok" || typeof parsed.summary !== "string") {
         advisory = {
           status: "failed",
@@ -7755,7 +7900,7 @@ async function runPublish(ctx, opts, dependencies = {}) {
     const isTty = dependencies.isTty ?? (() => Boolean(process.stdin.isTTY));
     const confirm = dependencies.confirm ?? askOnce;
     const projectRoot = process.cwd();
-    const hasCodexSidecarConfig = dependencies.hasCodexSidecarConfig ?? ((root) => existsSync5(join7(root, ".codex-sidecar.yml")));
+    const hasCodexSidecarConfig = dependencies.hasCodexSidecarConfig ?? ((root) => existsSync6(join8(root, ".codex-sidecar.yml")));
     const publishAdvisory = hasCodexSidecarConfig(projectRoot) ? (changes) => {
       try {
         return dependencies.runCodexSidecarAdvisory?.(changes, projectRoot) ?? formatCodexSidecarAdvisory(runCodexSidecarAdvisory({
@@ -7812,24 +7957,25 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
   const ghRunner = dependencies.ghRunner ?? runGh;
   let publishTarget = ctx.config.publishTarget;
   let codexHookState = "not-installed";
+  let cursorHookState = "not-installed";
   ensureUserConfig(ctx.userConfigPath);
   ctx.logger.info(`user config: ${ctx.userConfigPath}`);
-  if (!existsSync6(ctx.paths.knowledgeRepo)) {
-    mkdirSync2(ctx.paths.knowledgeRepo, { recursive: true });
-    mkdirSync2(ctx.paths.entriesDir, { recursive: true });
+  if (!existsSync7(ctx.paths.knowledgeRepo)) {
+    mkdirSync3(ctx.paths.knowledgeRepo, { recursive: true });
+    mkdirSync3(ctx.paths.entriesDir, { recursive: true });
     ctx.logger.info(`knowledge repo scaffolded: ${ctx.paths.knowledgeRepo}`);
   } else {
     ctx.logger.info(`knowledge repo: ${ctx.paths.knowledgeRepo}`);
   }
   migrateLegacyCommunityDir(ctx);
-  const gitignorePath = join8(ctx.paths.knowledgeRepo, ".gitignore");
-  if (!existsSync6(gitignorePath)) {
+  const gitignorePath = join9(ctx.paths.knowledgeRepo, ".gitignore");
+  if (!existsSync7(gitignorePath)) {
     writeFileSync3(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
     ctx.logger.info(`.gitignore created: ${gitignorePath}`);
   }
   if (!opts.dryRun) {
     const dbDir = dirname3(ctx.paths.dbPath);
-    if (!existsSync6(dbDir)) mkdirSync2(dbDir, { recursive: true });
+    if (!existsSync7(dbDir)) mkdirSync3(dbDir, { recursive: true });
     const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
     const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
     for (const failure of failures) {
@@ -7943,7 +8089,7 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
       ctx.logger.warn("cannot determine CLI script path; skipping Claude integration");
     } else {
       const result = installClaudeIntegration({
-        claudeDir: join8(ctx.userHome, ".claude"),
+        claudeDir: join9(ctx.userHome, ".claude"),
         cliScriptPath,
         nodePath: resolveHookNodePath(),
         dryRun: opts.dryRun,
@@ -7961,7 +8107,7 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
       codexHookState = "skipped";
       ctx.logger.warn("cannot determine CLI script path; skipping Codex hook integration");
     } else {
-      const codexHome = join8(ctx.userHome, ".codex");
+      const codexHome = join9(ctx.userHome, ".codex");
       const result = installCodexHooks({
         codexHome,
         cliScriptPath,
@@ -7972,7 +8118,7 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
       if (result.feature === "blocked") {
         codexHookState = "skipped";
         ctx.logger.warn(
-          `${result.blockedReason}; preserving explicit consent. Set \`hooks = true\` in ${join8(codexHome, "config.toml")}, then rerun \`caveat init\`.`
+          `${result.blockedReason}; preserving explicit consent. Set \`hooks = true\` in ${join9(codexHome, "config.toml")}, then rerun \`caveat init\`.`
         );
       } else if (opts.dryRun) {
         codexHookState = "skipped";
@@ -7982,7 +8128,35 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
       }
     }
   }
-  reportEnvironmentSummary(ctx, publishTarget, codexHookState, opts.dryRun);
+  if (opts.skipCursorHook) {
+    cursorHookState = "skipped";
+    ctx.logger.info("Cursor hook integration skipped (--skip-cursor-hook)");
+  } else if (existsSync7(join9(ctx.userHome, ".cursor"))) {
+    const cliScriptPath = process.argv[1];
+    if (!cliScriptPath) {
+      cursorHookState = "skipped";
+      ctx.logger.warn("cannot determine CLI script path; skipping Cursor hook integration");
+    } else {
+      const cursorDir = join9(ctx.userHome, ".cursor");
+      const result = installCursorHooks({
+        cursorDir,
+        cliScriptPath,
+        nodePath: resolveHookNodePath(),
+        dryRun: opts.dryRun,
+        logger: ctx.logger
+      });
+      if (opts.dryRun) {
+        cursorHookState = "skipped";
+        ctx.logger.info("[dry-run] would install Cursor hooks");
+      } else {
+        cursorHookState = detectCursorHookInstallation(cursorDir).installation;
+        ctx.logger.info(`Cursor beforeSubmitPrompt hook: ${result.hooks.beforeSubmitPrompt}`);
+        ctx.logger.info(`Cursor postToolUse hook: ${result.hooks.postToolUse}`);
+        ctx.logger.info(`Cursor stop hook: ${result.hooks.stop}`);
+      }
+    }
+  }
+  reportEnvironmentSummary(ctx, publishTarget, codexHookState, cursorHookState, opts.dryRun);
 }
 function detectCodexAvailability() {
   const result = spawnSync4("codex --version", {
@@ -8003,36 +8177,37 @@ function gitOutput(args) {
   const result = spawnSync4("git", args, { encoding: "utf-8" });
   return result.status === 0 && typeof result.stdout === "string" ? result.stdout.trim() : null;
 }
-function reportEnvironmentSummary(ctx, publishTarget, codexHookState, dryRun) {
+function reportEnvironmentSummary(ctx, publishTarget, codexHookState, cursorHookState, dryRun) {
   const prefix = dryRun ? "[dry-run] would have " : "";
   const isRepo = gitOutput(["-C", ctx.paths.knowledgeRepo, "rev-parse", "--is-inside-work-tree"]) === "true";
   const remote = isRepo ? gitOutput(["-C", ctx.paths.knowledgeRepo, "config", "--get", "remote.origin.url"]) : null;
-  const communityCount = existsSync6(ctx.paths.communityDir) ? readdirSync(ctx.paths.communityDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).length : 0;
+  const communityCount = existsSync7(ctx.paths.communityDir) ? readdirSync(ctx.paths.communityDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).length : 0;
   ctx.logger.info(`${prefix}environment summary:`);
   ctx.logger.info(`  own git: ${isRepo ? "repository" : "not initialized"}`);
   ctx.logger.info(`  private remote: ${remote || "not configured"}`);
   ctx.logger.info(`  publish target: ${publishTarget || "not configured"}`);
   ctx.logger.info(`  community sources: ${communityCount}`);
   ctx.logger.info(`  codex hook: ${codexHookState}`);
+  ctx.logger.info(`  cursor hook: ${cursorHookState}`);
 }
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function migrateLegacyCommunityDir(ctx) {
-  const legacy = join8(ctx.paths.knowledgeRepo, "community");
+  const legacy = join9(ctx.paths.knowledgeRepo, "community");
   const current = ctx.paths.communityDir;
   if (legacy === current) return;
-  if (!existsSync6(legacy)) return;
-  if (existsSync6(current)) {
+  if (!existsSync7(legacy)) return;
+  if (existsSync7(current)) {
     ctx.logger.warn(
       `legacy community dir still exists at ${legacy} \u2014 remove manually (new location in use)`
     );
     return;
   }
-  mkdirSync2(current, { recursive: true });
+  mkdirSync3(current, { recursive: true });
   for (const entry of readdirSync(legacy, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    renameSync(join8(legacy, entry.name), join8(current, entry.name));
+    renameSync(join9(legacy, entry.name), join9(current, entry.name));
   }
   try {
     rmdirSync(legacy);
@@ -8047,7 +8222,7 @@ function runUninstall(ctx, opts) {
     process.exit(1);
   }
   const result = uninstallClaudeIntegration({
-    claudeDir: join8(ctx.userHome, ".claude"),
+    claudeDir: join9(ctx.userHome, ".claude"),
     cliScriptPath,
     nodePath: resolveHookNodePath(),
     dryRun: opts.dryRun,
@@ -8094,11 +8269,11 @@ function reportInstallResult(ctx, result, dryRun) {
 }
 
 // src/commands/indexCmd.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
 async function runIndex(ctx, opts) {
   const dbDir = dirname4(ctx.paths.dbPath);
-  if (!existsSync7(dbDir)) mkdirSync3(dbDir, { recursive: true });
+  if (!existsSync8(dbDir)) mkdirSync4(dbDir, { recursive: true });
   const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
   const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
   for (const failure of failures) {
@@ -8282,7 +8457,7 @@ function runStats(ctx) {
 
 // src/commands/serve.ts
 async function runServe(opts) {
-  const { startServer } = await import("./server-GBVHOF67.js");
+  const { startServer } = await import("./server-HKXLHXNN.js");
   const { port, host } = startServer({ port: opts.port });
   process.stdout.write(`[caveat] web portal: http://${host}:${port}/
 `);
@@ -32354,7 +32529,7 @@ var StdioServerTransport = class {
 
 // ../mcp/dist/context.js
 import { homedir as homedir2 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 
 // ../mcp/dist/autoSyncTrigger.js
 function triggerAutoSyncAfterWrite(caveatHome, logger) {
@@ -32373,7 +32548,7 @@ function triggerAutoSyncAfterWrite(caveatHome, logger) {
 function buildMcpContext(overrides = {}) {
   const userHome = overrides.userHome ?? homedir2();
   const caveatHome = overrides.caveatHome ?? findCaveatHome(userHome);
-  const userConfigPath = join9(userHome, ".caveatrc.json");
+  const userConfigPath = join10(userHome, ".caveatrc.json");
   const logger = overrides.logger ?? stderrLogger;
   const config2 = loadConfig(userConfigPath);
   const paths = resolvePaths(caveatHome, config2.knowledgeRepo, userHome);
@@ -32522,12 +32697,12 @@ function handleListRecent(ctx, args) {
 }
 
 // ../mcp/dist/tools/pull.js
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 var pullInputShape = {};
 async function handlePull(ctx, _args = {}) {
   const pulled = [];
   const indexed = [];
-  if (existsSync8(ctx.paths.communityDir)) {
+  if (existsSync9(ctx.paths.communityDir)) {
     const results = await communityPull({
       communityDir: ctx.paths.communityDir,
       logger: ctx.logger
@@ -32683,28 +32858,28 @@ async function runMcpServer() {
 import { spawn as spawn2 } from "node:child_process";
 import {
   chmodSync,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   lstatSync,
   mkdtempSync as mkdtempSync2,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   realpathSync as realpathSync3,
   rmSync as rmSync2,
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename, dirname as dirname5, join as join12 } from "node:path";
+import { basename, dirname as dirname5, join as join13 } from "node:path";
 import { randomBytes } from "node:crypto";
 
 // src/autoReindexTrigger.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join11 } from "node:path";
 function maybeTriggerAutoReindex(ctx) {
   if (process.env.CAVEAT_INDEX_AUTOSYNC === "off") return;
-  if (!existsSync9(ctx.paths.dbPath)) return;
-  if (existsSync9(join10(ctx.caveatHome, "index", ".reindex-lock"))) return;
+  if (!existsSync10(ctx.paths.dbPath)) return;
+  if (existsSync10(join11(ctx.caveatHome, "index", ".reindex-lock"))) return;
   const current = computeEntriesDigest(ctx.paths);
   const marker = readDigestMarker(ctx.caveatHome);
   if (marker?.digest === current.digest && marker.fileCount === current.fileCount) return;
@@ -32730,8 +32905,8 @@ function maybeTriggerAutoSync(ctx, debounceMs = AUTO_SYNC_DEBOUNCE_MS) {
 }
 
 // src/hookShared.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join12 } from "node:path";
 import { createHash } from "node:crypto";
 var MAX_CONTEXT_BLOCKS = 3;
 var STOP_REMINDER_PREFIX = "[caveat] \u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3067\u5916\u90E8\u4ED5\u69D8\u306E\u7F60\u306B\u5F53\u305F\u3063\u305F\u53EF\u80FD\u6027\u3092\u793A\u3059\u30B7\u30B0\u30CA\u30EB:";
@@ -32786,7 +32961,7 @@ function searchCaveatsSafely(host, input) {
   let hits;
   try {
     const ctx = buildContextSafely(host);
-    if (!ctx || !existsSync10(ctx.paths.dbPath)) return [];
+    if (!ctx || !existsSync11(ctx.paths.dbPath)) return [];
     caveatHome = ctx.caveatHome;
     db = openDb({ path: ctx.paths.dbPath });
     const searchOptions = {
@@ -32872,19 +33047,19 @@ function stopSignalKey(signals, related) {
   return createHash("sha256").update(body).digest("hex");
 }
 function stopStatePath(host, caveatHome, sessionId) {
-  return join11(caveatHome, host.stopStateDir, `${sanitizeStateId(sessionId)}.txt`);
+  return join12(caveatHome, host.stopStateDir, `${sanitizeStateId(sessionId)}.txt`);
 }
 function wasStopReminderQueued(host, caveatHome, sessionId, key) {
   const path = stopStatePath(host, caveatHome, sessionId);
   try {
-    return readFileSync5(path, "utf-8") === key;
+    return readFileSync6(path, "utf-8") === key;
   } catch {
     return false;
   }
 }
 function markStopReminderQueued(host, caveatHome, sessionId, key) {
   const path = stopStatePath(host, caveatHome, sessionId);
-  mkdirSync4(join11(caveatHome, host.stopStateDir), { recursive: true });
+  mkdirSync5(join12(caveatHome, host.stopStateDir), { recursive: true });
   writeFileSync4(path, key, "utf-8");
 }
 function queueStopForSession(host, sessionId, signals, related, buildText) {
@@ -32996,9 +33171,9 @@ function spawnWorker(job) {
   try {
     root = workerRoot();
     sweepStaleWorkerDirs(Date.now(), root);
-    workDir = mkdtempSync2(join12(root, "job-"));
+    workDir = mkdtempSync2(join13(root, "job-"));
     chmodSync(workDir, 448);
-    workFile = join12(workDir, `${randomBytes(4).toString("hex")}.json`);
+    workFile = join13(workDir, `${randomBytes(4).toString("hex")}.json`);
     writeFileSync5(workFile, JSON.stringify({ ...job, schemaVersion: "caveat-worker-job/v2" }), { encoding: "utf-8", mode: 384, flag: "wx" });
   } catch (err) {
     process.stderr.write(`[caveat:hook] worker writefile error: ${errorMessage4(err)}
@@ -33030,7 +33205,7 @@ function spawnWorker(job) {
 async function runWorker(workFile) {
   let raw;
   try {
-    raw = readFileSync6(workFile, "utf-8");
+    raw = readFileSync7(workFile, "utf-8");
   } catch {
     process.exit(0);
   }
@@ -33094,7 +33269,7 @@ function sweepStaleWorkerDirs(now = Date.now(), root = workerRoot()) {
   }
   for (const entry of entries) {
     if (!entry.startsWith("job-")) continue;
-    const path = join12(root, entry);
+    const path = join13(root, entry);
     try {
       if (!isOwnedWorkerDir(path, root)) continue;
       const stat = lstatSync(path);
@@ -33106,29 +33281,29 @@ function sweepStaleWorkerDirs(now = Date.now(), root = workerRoot()) {
   }
 }
 function workerRoot(base = tmpdir2()) {
-  const root = join12(base, WORKER_ROOT);
-  mkdirSync5(root, { recursive: true, mode: 448 });
+  const root = join13(base, WORKER_ROOT);
+  mkdirSync6(root, { recursive: true, mode: 448 });
   const stat = lstatSync(root);
   const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
   if (!stat.isDirectory() || stat.isSymbolicLink() || !hasPrivateOwnership(stat, uid)) throw new Error("worker root is unsafe");
-  const marker = join12(root, WORKER_MARKER);
+  const marker = join13(root, WORKER_MARKER);
   try {
     writeFileSync5(marker, "caveat-worker/v1\n", { mode: 384, flag: "wx" });
   } catch (error51) {
     if (!(error51 && typeof error51 === "object" && "code" in error51 && error51.code === "EEXIST")) throw error51;
   }
   const markerStat = lstatSync(marker);
-  if (!markerStat.isFile() || markerStat.isSymbolicLink() || !hasPrivateOwnership(markerStat, uid) || readFileSync6(marker, "utf-8") !== "caveat-worker/v1\n") throw new Error("worker root marker is invalid");
+  if (!markerStat.isFile() || markerStat.isSymbolicLink() || !hasPrivateOwnership(markerStat, uid) || readFileSync7(marker, "utf-8") !== "caveat-worker/v1\n") throw new Error("worker root marker is invalid");
   return root;
 }
 function isStaleWorkerJobDir(path) {
   const entries = readdirSync2(path);
   if (entries.length !== 1 || !entries[0].endsWith(".json")) return false;
-  const file2 = join12(path, entries[0]);
+  const file2 = join13(path, entries[0]);
   const stat = lstatSync(file2);
   const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
   if (!stat.isFile() || stat.isSymbolicLink() || !hasPrivateOwnership(stat, uid)) return false;
-  return isKnownStaleWorkerJob(JSON.parse(readFileSync6(file2, "utf-8")));
+  return isKnownStaleWorkerJob(JSON.parse(readFileSync7(file2, "utf-8")));
 }
 function hasPrivateOwnership(stat, uid) {
   return isPrivateOwnerStat(stat, uid);
@@ -33150,7 +33325,7 @@ function isKnownStaleWorkerJob(value) {
 }
 function writeLastReindex(caveatHome, value) {
   try {
-    writeFileSync5(join12(caveatHome, "index", ".last-reindex.json"), JSON.stringify(value), "utf-8");
+    writeFileSync5(join13(caveatHome, "index", ".last-reindex.json"), JSON.stringify(value), "utf-8");
   } catch (err) {
     process.stderr.write(`[caveat:hook] reindex status write error: ${errorMessage4(err)}
 `);
@@ -33162,7 +33337,7 @@ async function runReindexWorker() {
     return;
   }
   const ctx = buildContextSafely(CLAUDE_HOST);
-  if (!ctx || !existsSync11(ctx.paths.dbPath)) {
+  if (!ctx || !existsSync12(ctx.paths.dbPath)) {
     process.stderr.write("[caveat:hook] auto reindex skipped: index database does not exist\n");
     return;
   }
@@ -33229,7 +33404,7 @@ function buildToolErrorReminder(job, hits) {
   const mode = hookCodexSidecarMode();
   if (mode === "off") return base;
   const projectRoot = process.cwd();
-  const hasSidecarConfig = existsSync11(join12(projectRoot, ".codex-sidecar.yml"));
+  const hasSidecarConfig = existsSync12(join13(projectRoot, ".codex-sidecar.yml"));
   if (mode === "auto" && !hasSidecarConfig) return base;
   const advisory = runCodexSidecarAdvisory({
     searchText: job.failureText,
@@ -33265,7 +33440,7 @@ function buildStopReminder(signals, related) {
   const mode = hookCodexSidecarMode();
   if (mode === "off") return base;
   const projectRoot = process.cwd();
-  const hasSidecarConfig = existsSync11(join12(projectRoot, ".codex-sidecar.yml"));
+  const hasSidecarConfig = existsSync12(join13(projectRoot, ".codex-sidecar.yml"));
   if (mode === "auto" && !hasSidecarConfig) return base;
   const advisory = runCodexSidecarAdvisory({
     searchText: struggleSearchText(signals),
@@ -33405,9 +33580,9 @@ async function runHook(name, arg) {
 
 // src/commands/codexHookCmd.ts
 import { spawn as spawn3, spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir3 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { randomBytes as randomBytes2 } from "node:crypto";
 var CODEX_HOST = {
   agent: "codex",
@@ -33437,10 +33612,10 @@ function processExitCodeFromText(text) {
   return m ? Number(m[1]) : null;
 }
 function transcriptToolOutput(transcriptPath, toolUseId) {
-  if (!transcriptPath || !toolUseId || !existsSync12(transcriptPath)) return null;
+  if (!transcriptPath || !toolUseId || !existsSync13(transcriptPath)) return null;
   let raw = "";
   try {
-    raw = readFileSync7(transcriptPath, "utf-8");
+    raw = readFileSync8(transcriptPath, "utf-8");
   } catch {
     return null;
   }
@@ -33584,7 +33759,7 @@ async function processCodexWorkerJob(job, opts = { waitForTranscript: true }) {
 async function runCodexWorker(workFile) {
   let raw;
   try {
-    raw = readFileSync7(workFile, "utf-8");
+    raw = readFileSync8(workFile, "utf-8");
   } catch {
     process.exit(0);
   }
@@ -33601,7 +33776,7 @@ async function runCodexWorker(workFile) {
   await processCodexWorkerJob(job);
   process.exit(0);
 }
-function runDiagnostics(codexHome = process.env.CODEX_HOME ?? join13(homedir3(), ".codex")) {
+function runDiagnostics(codexHome = process.env.CODEX_HOME ?? join14(homedir3(), ".codex")) {
   const features = spawnSync5("codex", ["features", "list"], {
     encoding: "utf-8",
     maxBuffer: 1024 * 1024,
@@ -33706,10 +33881,151 @@ async function runCodexHook(name, arg) {
   process.exit(0);
 }
 
+// src/commands/cursorHookCmd.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join15 } from "node:path";
+var CURSOR_HOST = {
+  agent: "cursor",
+  stderrTag: "caveat:cursor-hook",
+  errorCode: "CAVEAT.CURSOR_HOOK_FAILED",
+  stopStateDir: "cursor-stop-state",
+  stopDedupeKey: "cursor-stop-reminder"
+};
+function cursorContextOutput(text) {
+  return JSON.stringify({ additional_context: text });
+}
+function cursorSessionId(payload) {
+  for (const key of ["conversation_id", "session_id", "sessionId"]) {
+    const value = payload[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return "_unknown";
+}
+function cursorPrompt(payload) {
+  return typeof payload.prompt === "string" ? payload.prompt : "";
+}
+function isCursorToolError(payload) {
+  if (payload.hook_event_name === "postToolUseFailure") return true;
+  if (payload.is_error === true) return true;
+  if (typeof payload.error === "string" && payload.error.length > 0) return true;
+  const resp = payload.tool_response ?? payload.toolResponse;
+  if (resp !== null && typeof resp === "object" && !Array.isArray(resp)) {
+    if (resp.is_error === true) return true;
+  }
+  return false;
+}
+function loadSignalsSafely3(path) {
+  try {
+    return readSessionSignals(path);
+  } catch (err) {
+    process.stderr.write(`[caveat:cursor-hook] transcript read error: ${errorMessage4(err)}
+`);
+    return null;
+  }
+}
+function runDiagnostics2(cursorDir = join15(homedir4(), ".cursor")) {
+  const installation = detectCursorHookInstallation(cursorDir);
+  process.stdout.write(`${JSON.stringify({
+    installation: installation.installation,
+    cursorDir,
+    hooksPath: installation.hooksPath,
+    installedHooks: installation.hooks
+  }, null, 2)}
+`);
+}
+async function runCursorHook(name, arg) {
+  if (name === "diagnostics") {
+    runDiagnostics2(arg);
+    return;
+  }
+  let raw = "";
+  try {
+    raw = await readStdin();
+  } catch (err) {
+    process.stderr.write(`[caveat:cursor-hook] stdin read error: ${errorMessage4(err)}
+`);
+    process.exit(0);
+  }
+  const payload = parsePayload(CURSOR_HOST, raw);
+  const sessionId = cursorSessionId(payload);
+  const contexts = name === "stop" ? [] : drainForSession(CURSOR_HOST, sessionId);
+  if (name === "user-prompt-submit") {
+    const prompt = cursorPrompt(payload);
+    const hits = searchCaveatsSafely(CURSOR_HOST, {
+      topicText: prompt,
+      failureText: prompt,
+      surface: "user_prompt"
+    });
+    if (hits.length > 0) contexts.push(userPromptSubmitReminderText(hits));
+    const compacted = compactContexts(CURSOR_HOST, contexts);
+    if (compacted.length > 0) {
+      process.stdout.write(`${cursorContextOutput(compacted.join("\n\n"))}
+`);
+    }
+    process.exit(0);
+  }
+  if (name === "post-tool-use") {
+    if (isCursorToolError(payload)) {
+      const errText = extractToolResponseText(
+        payload.tool_response ?? payload.toolResponse ?? payload.error ?? payload
+      );
+      const hits = searchCaveatsSafely(CURSOR_HOST, {
+        topicText: errText,
+        failureText: errText,
+        surface: "tool_error"
+      });
+      if (hits.length > 0) contexts.push(toolErrorReminderText(hits));
+    }
+    const compacted = compactContexts(CURSOR_HOST, contexts);
+    if (compacted.length > 0) {
+      process.stdout.write(`${cursorContextOutput(compacted.join("\n\n"))}
+`);
+    }
+    process.exit(0);
+  }
+  if (name === "stop") {
+    const ctx = buildContextSafely(CURSOR_HOST);
+    if (ctx) {
+      try {
+        maybeSweepPendingDirs(ctx.caveatHome);
+      } catch (err) {
+        process.stderr.write(`[caveat:cursor-hook] pending sweep error: ${errorMessage4(err)}
+`);
+      }
+      try {
+        maybeTriggerAutoReindex(ctx);
+      } catch (err) {
+        process.stderr.write(`[caveat:cursor-hook] auto reindex trigger error: ${errorMessage4(err)}
+`);
+      }
+      try {
+        maybeTriggerAutoSync(ctx);
+      } catch (err) {
+        process.stderr.write(`[caveat:cursor-hook] auto sync trigger error: ${errorMessage4(err)}
+`);
+      }
+    }
+    if (payload.stop_hook_active === true) process.exit(0);
+    const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : "";
+    const signals = transcriptPath ? loadSignalsSafely3(transcriptPath) : null;
+    if (!signals || !hasAnyStruggleSignal(signals)) process.exit(0);
+    const related = searchCaveatsSafely(CURSOR_HOST, signals.errorSnippets.map((failureText) => ({
+      topicText: "",
+      failureText,
+      surface: "stop"
+    })));
+    queueStopForSession(CURSOR_HOST, sessionId, signals, related, () => stopReminderText(signals, related));
+    process.exit(0);
+  }
+  process.stderr.write(`[caveat:cursor-hook] unknown hook name: ${name}
+`);
+  process.exit(0);
+}
+
 // src/commands/pull.ts
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 async function runPull(ctx) {
-  const hasCommunityDir = existsSync13(ctx.paths.communityDir);
+  const hasCommunityDir = existsSync14(ctx.paths.communityDir);
   if (!hasCommunityDir) {
     ctx.logger.info(
       "no community repos yet \u2014 add one with `caveat community add <github-url>`."
@@ -33809,9 +34125,9 @@ async function runSync(ctx, opts, dependencies = {}) {
 
 // src/commands/codexSidecar.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { closeSync, constants as constants3, fstatSync, lstatSync as lstatSync2, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync3, openSync, readSync as readSync2, realpathSync as realpathSync4, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "node:fs";
+import { closeSync, constants as constants4, fstatSync, lstatSync as lstatSync2, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, openSync, readSync as readSync2, realpathSync as realpathSync4, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename2, dirname as dirname6, join as join14 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join16 } from "node:path";
 import { cwd, exit } from "node:process";
 function runCodexSidecarDiagnostics(logger, opts) {
   const plan = buildCodexSidecarDiagnosticsCommand({
@@ -33843,8 +34159,8 @@ function runCodexSidecarWithCaveats(ctx, workflow, prompt, opts) {
     process.stdout.write(JSON.stringify({ status: "skipped", decision }, null, 2) + "\n");
     exit(0);
   }
-  const contextDir = mkdtempSync3(join14(tmpdir4(), "caveat-sidecar-context-"));
-  const contextFile = join14(contextDir, "context.json");
+  const contextDir = mkdtempSync3(join16(tmpdir4(), "caveat-sidecar-context-"));
+  const contextFile = join16(contextDir, "context.json");
   let status2 = 1;
   try {
     const blocks = collectCaveatContextBlocks(ctx, {
@@ -33877,7 +34193,7 @@ function readHookSignalAdditionalContextFile(path, testProbe) {
   const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
   assertPrivateRegular(before, uid, platform);
   testProbe?.afterLstat?.();
-  const fd = openSync(path, constants3.O_RDONLY | constants3.O_NONBLOCK | (constants3.O_NOFOLLOW ?? 0));
+  const fd = openSync(path, constants4.O_RDONLY | constants4.O_NONBLOCK | (constants4.O_NOFOLLOW ?? 0));
   let raw;
   try {
     const opened = fstatSync(fd);
@@ -34007,7 +34323,7 @@ function executePlan(logger, command, args, options = {}) {
 }
 function saveStructuredResult(path, stdout) {
   const parsed = JSON.parse(stdout);
-  mkdirSync6(dirname6(path), { recursive: true });
+  mkdirSync7(dirname6(path), { recursive: true });
   writeFileSync7(path, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
 }
 function shellDisplayQuote(value) {
@@ -34096,8 +34412,8 @@ function runCommunityRemove(ctx, handle, opts) {
 
 // src/commands/factoryDiagnostics.ts
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync8 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync9 } from "node:fs";
+import { join as join17 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { parse as parseToml2 } from "smol-toml";
 var status = (ok, reason) => ({ status: ok ? "ready" : "not_ready", reason_code: ok ? "ready" : reason });
@@ -34109,10 +34425,10 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function claudeRegistration(home, nodePath, cliScriptPath) {
-  const path = join15(home, ".claude.json");
-  if (!existsSync14(path)) return status(false, "not_registered");
+  const path = join17(home, ".claude.json");
+  if (!existsSync15(path)) return status(false, "not_registered");
   try {
-    const value = JSON.parse(readFileSync8(path, "utf8"));
+    const value = JSON.parse(readFileSync9(path, "utf8"));
     if (!isRecord2(value) || !isRecord2(value.mcpServers)) return status(false, "not_registered");
     return status(isCaveatClaudeMcpRegistration(value.mcpServers.caveat, nodePath, cliScriptPath), "not_registered");
   } catch {
@@ -34121,7 +34437,7 @@ function claudeRegistration(home, nodePath, cliScriptPath) {
 }
 function claudeHooks(home, nodePath, cliScriptPath) {
   try {
-    const settings = JSON.parse(readFileSync8(join15(home, ".claude", "settings.json"), "utf8"));
+    const settings = JSON.parse(readFileSync9(join17(home, ".claude", "settings.json"), "utf8"));
     const present = (event, subcommand) => settings.hooks?.[event]?.some((entry) => entry.hooks?.some((item) => typeof item.command === "string" && isCanonicalCaveatClaudeHookCommand(item.command, subcommand, nodePath, cliScriptPath))) ?? false;
     return { user_prompt_submit: hook(present("UserPromptSubmit", "user-prompt-submit")), post_tool_use: hook(present("PostToolUse", "post-tool-use")), post_tool_use_failure: hook(present("PostToolUseFailure", "post-tool-use")), stop: hook(present("Stop", "stop")) };
   } catch {
@@ -34143,7 +34459,7 @@ function strictSearchSchema(db) {
   return columns.map((column) => `${column.name}:${column.hidden}`).join(",") === "id:0,title:0,body:0,tags:0,entries_fts:1,rank:1";
 }
 function database(path) {
-  if (!existsSync14(path)) return { status: "not_ready", reason_code: "missing", schema_version: null, supported_schema_version: 3, migration_status: "unverified" };
+  if (!existsSync15(path)) return { status: "not_ready", reason_code: "missing", schema_version: null, supported_schema_version: 3, migration_status: "unverified" };
   try {
     const db = new DatabaseSync(path, { readOnly: true });
     try {
@@ -34168,10 +34484,10 @@ function database(path) {
   }
 }
 function codexFeature(codexHome) {
-  const path = join15(codexHome, "config.toml");
-  if (!existsSync14(path)) return status(false, "feature_disabled");
+  const path = join17(codexHome, "config.toml");
+  if (!existsSync15(path)) return status(false, "feature_disabled");
   try {
-    const config2 = parseToml2(readFileSync8(path, "utf8"));
+    const config2 = parseToml2(readFileSync9(path, "utf8"));
     if (!isRecord2(config2.features)) return status(false, "feature_disabled");
     const features = config2.features;
     return status(features.hooks === true && features.codex_hooks === void 0, "feature_disabled");
@@ -34180,7 +34496,7 @@ function codexFeature(codexHome) {
   }
 }
 function codexHooks(codexHome, nodePath, cliScriptPath) {
-  const value = JSON.parse(readFileSync8(join15(codexHome, "hooks.json"), "utf8"));
+  const value = JSON.parse(readFileSync9(join17(codexHome, "hooks.json"), "utf8"));
   if (!isRecord2(value) || !isRecord2(value.hooks)) throw Error("config_unreadable");
   const hooks = value.hooks;
   const present = (event, subcommand) => Array.isArray(hooks[event]) && hooks[event].some((entry) => isRecord2(entry) && Array.isArray(entry.hooks) && entry.hooks.some((item) => isCanonicalCaveatCodexHookEntry(item, subcommand, nodePath, cliScriptPath)));
@@ -34215,7 +34531,7 @@ function sync(own) {
     return unverified("upstream_unavailable");
   }
 }
-function factoryDiagnostics(ctx, codexHome = process.env.CODEX_HOME ?? join15(ctx.userHome, ".codex")) {
+function factoryDiagnostics(ctx, codexHome = process.env.CODEX_HOME ?? join17(ctx.userHome, ".codex")) {
   const nodePath = process.execPath;
   const cliScriptPath = process.argv[1] ?? "";
   const db = database(ctx.paths.dbPath);
@@ -34290,7 +34606,7 @@ for (const action of ["resolve", "reopen"]) runtimeErrors.command(`${action} <fi
 });
 program.command("init").description(
   "Initialize ~/.caveatrc.json, ~/.caveat/, and register Claude Code integration. Add knowledge sources later with `caveat community add <github-url>`."
-).option("--skip-claude", "skip Claude Code MCP + hook registration", false).option("--sync [url]", "initialize private sync (optionally with its URL)").option("--publish-target [url]", "configure the sealed public mirror target").option("--yes", "approve creating conventional GitHub repositories", false).option("--skip-codex-hook", "skip Codex hook installation", false).option("--dry-run", "show planned changes without writing", false).option(
+).option("--skip-claude", "skip Claude Code MCP + hook registration", false).option("--sync [url]", "initialize private sync (optionally with its URL)").option("--publish-target [url]", "configure the sealed public mirror target").option("--yes", "approve creating conventional GitHub repositories", false).option("--skip-codex-hook", "skip Codex hook installation", false).option("--skip-cursor-hook", "skip Cursor hook installation", false).option("--dry-run", "show planned changes without writing", false).option(
   "--pending-stale-days <days>",
   "sweep `<caveatHome>/pending/<sessionId>/` whose newest entry is older than this (default 7)",
   (raw) => {
@@ -34310,7 +34626,8 @@ program.command("init").description(
       sync: opts.sync,
       publishTarget: opts.publishTarget,
       yes: opts.yes,
-      skipCodexHook: opts.skipCodexHook
+      skipCodexHook: opts.skipCodexHook,
+      skipCursorHook: opts.skipCursorHook
     });
   }
 );
@@ -34438,6 +34755,57 @@ codexHook.command("stop").description("Run the Codex Stop hook").action(async ()
 codexHook.command("worker <workFile>").description("Run the detached Codex hook worker").action(async (workFile) => {
   await runCodexHook("worker", workFile);
 });
+var cursorHook = program.command("cursor-hook").description("Install or run Cursor hooks for Caveat");
+cursorHook.command("install").description("Install Caveat hooks into ~/.cursor/hooks.json (factory hooks are kept)").option("--dry-run", "show planned changes without writing", false).option("--cursor-dir <path>", "Cursor home directory", `${process.env.HOME}/.cursor`).action((opts) => {
+  const cliScriptPath = process.argv[1];
+  if (!cliScriptPath) {
+    process.stderr.write("[caveat:error] cannot determine CLI script path\n");
+    process.exit(1);
+  }
+  const result = installCursorHooks({
+    cursorDir: opts.cursorDir,
+    cliScriptPath,
+    nodePath: resolveHookNodePath(),
+    dryRun: opts.dryRun,
+    logger: stdoutLogger
+  });
+  stdoutLogger.info(`beforeSubmitPrompt hook: ${result.hooks.beforeSubmitPrompt}`);
+  stdoutLogger.info(`postToolUse hook: ${result.hooks.postToolUse}`);
+  stdoutLogger.info(`postToolUseFailure hook: ${result.hooks.postToolUseFailure}`);
+  stdoutLogger.info(`stop hook: ${result.hooks.stop}`);
+  if (result.backupPath) stdoutLogger.info(`hooks.json backed up: ${result.backupPath}`);
+});
+cursorHook.command("uninstall").description("Remove Caveat-owned Cursor hooks from ~/.cursor/hooks.json").option("--dry-run", "show planned changes without writing", false).option("--cursor-dir <path>", "Cursor home directory", `${process.env.HOME}/.cursor`).action((opts) => {
+  const cliScriptPath = process.argv[1];
+  if (!cliScriptPath) {
+    process.stderr.write("[caveat:error] cannot determine CLI script path\n");
+    process.exit(1);
+  }
+  const result = uninstallCursorHooks({
+    cursorDir: opts.cursorDir,
+    cliScriptPath,
+    nodePath: resolveHookNodePath(),
+    dryRun: opts.dryRun,
+    logger: stdoutLogger
+  });
+  stdoutLogger.info(`beforeSubmitPrompt hook: ${result.hooks.beforeSubmitPrompt === "added" ? "removed" : "not present"}`);
+  stdoutLogger.info(`postToolUse hook: ${result.hooks.postToolUse === "added" ? "removed" : "not present"}`);
+  stdoutLogger.info(`postToolUseFailure hook: ${result.hooks.postToolUseFailure === "added" ? "removed" : "not present"}`);
+  stdoutLogger.info(`stop hook: ${result.hooks.stop === "added" ? "removed" : "not present"}`);
+  if (result.backupPath) stdoutLogger.info(`hooks.json backed up: ${result.backupPath}`);
+});
+cursorHook.command("diagnostics").description("Check local Cursor hook installation").option("--cursor-dir <path>", "Cursor home directory", `${process.env.HOME}/.cursor`).action(async (opts) => {
+  await runCursorHook("diagnostics", opts.cursorDir);
+});
+cursorHook.command("user-prompt-submit").description("Run the Cursor beforeSubmitPrompt hook").action(async () => {
+  await runCursorHook("user-prompt-submit");
+});
+cursorHook.command("post-tool-use").description("Run the Cursor postToolUse / postToolUseFailure hook").action(async () => {
+  await runCursorHook("post-tool-use");
+});
+cursorHook.command("stop").description("Run the Cursor stop hook").action(async () => {
+  await runCursorHook("stop");
+});
 var codexSidecar = program.command("codex-sidecar").description("Check Codex sidecar availability for the current repository");
 codexSidecar.command("diagnostics").description("Run codex-sidecar diagnostics for this repository").option("--project <path>", "repository root to check").option("--preset <preset>", "codex-sidecar preset", "review").option("--command <command>", "codex-sidecar executable", "codex-sidecar").option("--node-cli <path>", "development path to codex-sidecar CLI JS").option("--save-result <path>", "write structured SidecarResult JSON to this path").action((opts) => {
   runCodexSidecarDiagnostics(stdoutLogger, opts);