caveat-cli 0.17.3 → 0.17.4

package/dist/index.js

@@ -38,14 +38,18 @@ import {
   get,
   hasAnyStruggleSignal,
   initOwnSync,
+  isPrivateOwnerStat,
+  isWindows,
   listRecent,
   listStale,
   loadConfig,
   logHookQueryMiss,
   markHit,
   maybeSweepPendingDirs,
+  nodeExecutableNames,
   observeRuntimeError,
   openDb,
+  powershellCallPrefix,
   prewarmSealedKeys,
   publishOwn,
   readCodexSessionSignals,
@@ -72,7 +76,7 @@ import {
   userPromptSubmitReminderText,
   writeDigestMarker,
   writeUserConfigPatch
-} from "./chunk-TRIQ5WFY.js";
+} from "./chunk-ZBHCOA6R.js";
 
 // ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -6885,25 +6889,67 @@ var stdoutLogger = {
 
 // src/commands/init.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, renameSync, rmdirSync, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+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";
 
 // src/claudeInstall.ts
 import { spawnSync } from "node:child_process";
-import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync as readFileSync2, realpathSync, statSync, writeFileSync } from "node:fs";
-import { dirname as dirname2, isAbsolute, join as join3 } from "node:path";
+import { constants, existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/installShared.ts
+import { accessSync, copyFileSync, existsSync, mkdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, isAbsolute } from "node:path";
+function quoteIfSpaces(p) {
+  return p.includes(" ") ? `"${p}"` : p;
+}
+function commandTokens(command) {
+  const tokens = [];
+  const pattern = /"([^"]*)"|([^\s"]+)/g;
+  let end = 0;
+  let match;
+  while ((match = pattern.exec(command)) !== null) {
+    if (command.slice(end, match.index).trim()) return null;
+    tokens.push(match[1] ?? match[2]);
+    end = pattern.lastIndex;
+  }
+  return command.slice(end).trim() ? null : tokens;
+}
+function isCanonicalAsset(path, expectedPath, mode) {
+  if (typeof path !== "string" || !isAbsolute(path) || !isAbsolute(expectedPath)) return false;
+  try {
+    accessSync(path, mode);
+    return statSync(path).isFile() && realpathSync(path) === realpathSync(expectedPath);
+  } catch {
+    return false;
+  }
+}
+function writeFileWithBackup(path, text) {
+  const dir = dirname2(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  let backupPath = "";
+  if (existsSync(path)) {
+    backupPath = `${path}.caveat-backup-${Date.now()}`;
+    copyFileSync(path, backupPath);
+  }
+  writeFileSync(path, text, "utf-8");
+  return backupPath;
+}
+function writeJsonWithBackup(path, value) {
+  return writeFileWithBackup(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+
+// src/claudeInstall.ts
 var EVENT_USER_PROMPT_SUBMIT = "UserPromptSubmit";
 var EVENT_POST_TOOL_USE = "PostToolUse";
 var EVENT_POST_TOOL_USE_FAILURE = "PostToolUseFailure";
 var EVENT_STOP = "Stop";
-function quote(p) {
-  return p.includes(" ") ? `"${p}"` : p;
-}
 function mcpArgs(cliScriptPath) {
   return ["--disable-warning=ExperimentalWarning", cliScriptPath, "mcp-server"];
 }
 function hookCommand(nodePath, cliScriptPath, event) {
-  return `${quote(nodePath)} ${quote(cliScriptPath)} hook ${event}`;
+  return `${quoteIfSpaces(nodePath)} ${quoteIfSpaces(cliScriptPath)} hook ${event}`;
 }
 function upsertHook(settings, event, command) {
   settings.hooks ??= {};
@@ -6951,27 +6997,6 @@ function isCaveatClaudeHookCommand(actual, event) {
   const lower = actual.toLowerCase();
   return !isEnvPrefixedCommand(actual) && lower.includes("caveat") && actual.includes(`hook ${event}`);
 }
-function commandTokens(command) {
-  const tokens = [];
-  const pattern = /"([^"]*)"|([^\s"]+)/g;
-  let end = 0;
-  let match;
-  while ((match = pattern.exec(command)) !== null) {
-    if (command.slice(end, match.index).trim()) return null;
-    tokens.push(match[1] ?? match[2]);
-    end = pattern.lastIndex;
-  }
-  return command.slice(end).trim() ? null : tokens;
-}
-function isCanonicalAsset(path, expectedPath, mode) {
-  if (typeof path !== "string" || !isAbsolute(path) || !isAbsolute(expectedPath)) return false;
-  try {
-    accessSync(path, mode);
-    return statSync(path).isFile() && realpathSync(path) === realpathSync(expectedPath);
-  } catch {
-    return false;
-  }
-}
 function isCanonicalCaveatClaudeHookCommand(actual, event, nodePath, cliScriptPath) {
   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;
@@ -6982,19 +7007,11 @@ function isCaveatClaudeMcpRegistration(value, nodePath, cliScriptPath) {
   return Object.keys(server).length === 4 && ["args", "command", "env", "type"].every((key) => Object.hasOwn(server, key)) && server.type === "stdio" && isCanonicalAsset(server.command, nodePath, constants.X_OK) && Array.isArray(server.args) && server.args.length === 3 && server.args[0] === "--disable-warning=ExperimentalWarning" && isCanonicalAsset(server.args[1], cliScriptPath, constants.R_OK) && server.args[2] === "mcp-server" && server.env !== null && typeof server.env === "object" && !Array.isArray(server.env) && Object.keys(server.env).length === 0;
 }
 function readSettings(path) {
-  if (!existsSync(path)) return {};
+  if (!existsSync2(path)) return {};
   return JSON.parse(readFileSync2(path, "utf-8"));
 }
 function writeSettings(path, settings) {
-  const dir = dirname2(path);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  let backupPath = "";
-  if (existsSync(path)) {
-    backupPath = `${path}.caveat-backup-${Date.now()}`;
-    copyFileSync(path, backupPath);
-  }
-  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-  return backupPath;
+  return writeJsonWithBackup(path, settings);
 }
 var CLAUDE_BIN = "claude";
 function shellQuote(s) {
@@ -7112,51 +7129,32 @@ function uninstallClaudeIntegration(opts) {
 }
 
 // src/codexHookInstall.ts
-import { accessSync as accessSync2, constants as constants2, copyFileSync as copyFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, realpathSync as realpathSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4 } from "node:path";
+import { constants as constants2, existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
 import { parse as parseToml } from "smol-toml";
-function quote2(p) {
-  return p.includes(" ") ? `"${p}"` : p;
-}
 function hookCommand2(nodePath, cliScriptPath, event, platform = process.platform) {
-  const prefix = platform === "win32" ? "& " : "";
-  return `${prefix}${quote2(nodePath)} ${quote2(cliScriptPath)} codex-hook ${event}`;
+  return `${powershellCallPrefix(platform)}${quoteIfSpaces(nodePath)} ${quoteIfSpaces(cliScriptPath)} codex-hook ${event}`;
 }
 function eventCommandFragment(event) {
   return `codex-hook ${event}`;
 }
 function isSameHookCommand2(actual, expected) {
-  return actual === expected || actual.endsWith(` ${expected}`);
+  const normalizedTokens = (command) => {
+    const parsed = commandTokens(command);
+    return parsed?.[0] === "&" ? parsed.slice(1) : parsed;
+  };
+  const actualTokens = normalizedTokens(actual);
+  const expectedTokens = normalizedTokens(expected);
+  return actualTokens !== null && expectedTokens !== null && actualTokens.length === expectedTokens.length && actualTokens.every((token, index) => token === expectedTokens[index]);
 }
 function isCaveatCodexHookCommand(actual, event) {
   const lower = actual.toLowerCase();
   return lower.includes("caveat") && actual.includes(eventCommandFragment(event));
 }
-function commandTokens2(command) {
-  const tokens = [];
-  const pattern = /"([^"]*)"|([^\s"]+)/g;
-  let end = 0;
-  let match;
-  while ((match = pattern.exec(command)) !== null) {
-    if (command.slice(end, match.index).trim()) return null;
-    tokens.push(match[1] ?? match[2]);
-    end = pattern.lastIndex;
-  }
-  return command.slice(end).trim() ? null : tokens;
-}
-function isCanonicalAsset2(path, expectedPath, mode) {
-  if (typeof path !== "string" || !isAbsolute2(path) || !isAbsolute2(expectedPath)) return false;
-  try {
-    accessSync2(path, mode);
-    return statSync2(path).isFile() && realpathSync2(path) === realpathSync2(expectedPath);
-  } catch {
-    return false;
-  }
-}
 function isCanonicalCaveatCodexHookCommand(actual, event, nodePath, cliScriptPath) {
-  const parsed = commandTokens2(actual);
+  const parsed = commandTokens(actual);
   const tokens = parsed?.[0] === "&" ? parsed.slice(1) : parsed;
-  return tokens?.length === 4 && isCanonicalAsset2(tokens[0], nodePath, constants2.X_OK) && isCanonicalAsset2(tokens[1], cliScriptPath, constants2.R_OK) && tokens[2] === "codex-hook" && tokens[3] === event;
+  return tokens?.length === 4 && isCanonicalAsset(tokens[0], nodePath, constants2.X_OK) && isCanonicalAsset(tokens[1], cliScriptPath, constants2.R_OK) && tokens[2] === "codex-hook" && tokens[3] === event;
 }
 function isCanonicalCaveatCodexHookEntry(value, event, nodePath, cliScriptPath) {
   if (!isPlainRecord(value) || typeof value.type !== "string" || typeof value.command !== "string") return false;
@@ -7168,21 +7166,9 @@ function hasCaveatHook(hooksJson, event, fragment) {
   ) ?? false;
 }
 function readHooks(path) {
-  if (!existsSync2(path)) return {};
+  if (!existsSync3(path)) return {};
   return JSON.parse(readFileSync3(path, "utf-8"));
 }
-function writeJsonWithBackup(path, value) {
-  const dir = dirname3(path);
-  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
-  let backupPath = "";
-  if (existsSync2(path)) {
-    backupPath = `${path}.caveat-backup-${Date.now()}`;
-    copyFileSync2(path, backupPath);
-  }
-  writeFileSync2(path, `${JSON.stringify(value, null, 2)}
-`, "utf-8");
-  return backupPath;
-}
 function upsertHook2(hooksJson, event, command, subcommand) {
   hooksJson.hooks ??= {};
   const list = hooksJson.hooks[event] ??= [];
@@ -7404,21 +7390,10 @@ function maskTomlStringsAndComments(raw) {
   }
   return output;
 }
-function writeConfigWithBackup(path, text) {
-  const dir = dirname3(path);
-  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
-  let backupPath = "";
-  if (existsSync2(path)) {
-    backupPath = `${path}.caveat-backup-${Date.now()}`;
-    copyFileSync2(path, backupPath);
-  }
-  writeFileSync2(path, text, "utf-8");
-  return backupPath;
-}
 function installCodexHooks(opts) {
   const hooksPath = join4(opts.codexHome, "hooks.json");
   const configPath = join4(opts.codexHome, "config.toml");
-  const rawConfig = existsSync2(configPath) ? readFileSync3(configPath, "utf-8") : "";
+  const rawConfig = existsSync3(configPath) ? readFileSync3(configPath, "utf-8") : "";
   const enabled = enableCodexHooksFeature(rawConfig);
   if (enabled.status === "blocked") {
     return {
@@ -7458,7 +7433,7 @@ function installCodexHooks(opts) {
       if (backup) backupPath = backup;
     }
     if (enabled.changed) {
-      const backup = writeConfigWithBackup(configPath, enabled.text);
+      const backup = writeFileWithBackup(configPath, enabled.text);
       if (backup) configBackupPath = backup;
     }
   }
@@ -7582,9 +7557,9 @@ function askOnce(question) {
 }
 
 // src/nodePath.ts
-import { existsSync as existsSync3, realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync4, realpathSync as realpathSync2 } from "node:fs";
 import { delimiter, join as join5 } from "node:path";
-var defaultRealpath = (path) => realpathSync3.native(path);
+var defaultRealpath = (path) => realpathSync2.native(path);
 function safeRealpath(path, realpath = defaultRealpath) {
   try {
     return realpath(path);
@@ -7596,12 +7571,12 @@ function resolveHookNodePath({
   env = process.env,
   execPath = process.execPath,
   platform = process.platform,
-  exists = existsSync3,
+  exists = existsSync4,
   realpath = defaultRealpath
 } = {}) {
   const execRealpath = safeRealpath(execPath, realpath);
   const pathEnv = env.PATH ?? env.Path ?? "";
-  const names = platform === "win32" ? ["node.exe", "node.cmd", "node.bat", "node"] : ["node"];
+  const names = nodeExecutableNames(platform);
   for (const dir of pathEnv.split(delimiter).filter(Boolean)) {
     for (const name of names) {
       const candidate = join5(dir, name);
@@ -7616,12 +7591,12 @@ function resolveHookNodePath({
 }
 
 // src/commands/publish.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { join as join7 } from "node:path";
 
 // src/commands/codexSidecarAdvisory.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join6 } from "node:path";
 var DEFAULT_HOOK_SIDECAR_TIMEOUT_MS = 12e4;
@@ -7684,7 +7659,7 @@ function runCodexSidecarAdvisory(input) {
     args.push("--save-result", resultFile);
     if (input.additionalContext) {
       const additionalContextFile = join6(resultDir, "hook-signal.json");
-      writeFileSync3(additionalContextFile, JSON.stringify({ context: [input.additionalContext] }) + "\n", { encoding: "utf-8", mode: 384, flag: "wx" });
+      writeFileSync2(additionalContextFile, JSON.stringify({ context: [input.additionalContext] }) + "\n", { encoding: "utf-8", mode: 384, flag: "wx" });
       args.push("--additional-context-file", additionalContextFile);
     }
     const nodeCli = process.env.CAVEAT_CODEX_SIDECAR_NODE_CLI;
@@ -7779,7 +7754,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) => existsSync4(join7(root, ".codex-sidecar.yml")));
+    const hasCodexSidecarConfig = dependencies.hasCodexSidecarConfig ?? ((root) => existsSync5(join7(root, ".codex-sidecar.yml")));
     const publishAdvisory = hasCodexSidecarConfig(projectRoot) ? (changes) => {
       try {
         return dependencies.runCodexSidecarAdvisory?.(changes, projectRoot) ?? formatCodexSidecarAdvisory(runCodexSidecarAdvisory({
@@ -7838,22 +7813,22 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
   let codexHookState = "not-installed";
   ensureUserConfig(ctx.userConfigPath);
   ctx.logger.info(`user config: ${ctx.userConfigPath}`);
-  if (!existsSync5(ctx.paths.knowledgeRepo)) {
-    mkdirSync3(ctx.paths.knowledgeRepo, { recursive: true });
-    mkdirSync3(ctx.paths.entriesDir, { recursive: true });
+  if (!existsSync6(ctx.paths.knowledgeRepo)) {
+    mkdirSync2(ctx.paths.knowledgeRepo, { recursive: true });
+    mkdirSync2(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 (!existsSync5(gitignorePath)) {
-    writeFileSync4(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
+  if (!existsSync6(gitignorePath)) {
+    writeFileSync3(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
     ctx.logger.info(`.gitignore created: ${gitignorePath}`);
   }
   if (!opts.dryRun) {
-    const dbDir = dirname4(ctx.paths.dbPath);
-    if (!existsSync5(dbDir)) mkdirSync3(dbDir, { recursive: true });
+    const dbDir = dirname3(ctx.paths.dbPath);
+    if (!existsSync6(dbDir)) mkdirSync2(dbDir, { recursive: true });
     const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
     const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
     for (const failure of failures) {
@@ -8031,7 +8006,7 @@ function reportEnvironmentSummary(ctx, publishTarget, codexHookState, 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 = existsSync5(ctx.paths.communityDir) ? readdirSync(ctx.paths.communityDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).length : 0;
+  const communityCount = existsSync6(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"}`);
@@ -8046,14 +8021,14 @@ function migrateLegacyCommunityDir(ctx) {
   const legacy = join8(ctx.paths.knowledgeRepo, "community");
   const current = ctx.paths.communityDir;
   if (legacy === current) return;
-  if (!existsSync5(legacy)) return;
-  if (existsSync5(current)) {
+  if (!existsSync6(legacy)) return;
+  if (existsSync6(current)) {
     ctx.logger.warn(
       `legacy community dir still exists at ${legacy} \u2014 remove manually (new location in use)`
     );
     return;
   }
-  mkdirSync3(current, { recursive: true });
+  mkdirSync2(current, { recursive: true });
   for (const entry of readdirSync(legacy, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     renameSync(join8(legacy, entry.name), join8(current, entry.name));
@@ -8118,11 +8093,11 @@ function reportInstallResult(ctx, result, dryRun) {
 }
 
 // src/commands/indexCmd.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
 async function runIndex(ctx, opts) {
-  const dbDir = dirname5(ctx.paths.dbPath);
-  if (!existsSync6(dbDir)) mkdirSync4(dbDir, { recursive: true });
+  const dbDir = dirname4(ctx.paths.dbPath);
+  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) {
@@ -8306,7 +8281,7 @@ function runStats(ctx) {
 
 // src/commands/serve.ts
 async function runServe(opts) {
-  const { startServer } = await import("./server-FUWTRVRZ.js");
+  const { startServer } = await import("./server-GBVHOF67.js");
   const { port, host } = startServer({ port: opts.port });
   process.stdout.write(`[caveat] web portal: http://${host}:${port}/
 `);
@@ -32546,12 +32521,12 @@ function handleListRecent(ctx, args) {
 }
 
 // ../mcp/dist/tools/pull.js
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 var pullInputShape = {};
 async function handlePull(ctx, _args = {}) {
   const pulled = [];
   const indexed = [];
-  if (existsSync7(ctx.paths.communityDir)) {
+  if (existsSync8(ctx.paths.communityDir)) {
     const results = await communityPull({
       communityDir: ctx.paths.communityDir,
       logger: ctx.logger
@@ -32707,28 +32682,28 @@ async function runMcpServer() {
 import { spawn as spawn2 } from "node:child_process";
 import {
   chmodSync,
-  existsSync as existsSync9,
+  existsSync as existsSync11,
   lstatSync,
   mkdtempSync as mkdtempSync2,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync5,
-  realpathSync as realpathSync4,
+  readFileSync as readFileSync6,
+  realpathSync as realpathSync3,
   rmSync as rmSync2,
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename, dirname as dirname6, join as join11 } from "node:path";
-import { createHash, randomBytes } from "node:crypto";
+import { basename, dirname as dirname5, join as join12 } from "node:path";
+import { randomBytes } from "node:crypto";
 
 // src/autoReindexTrigger.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { join as join10 } from "node:path";
 function maybeTriggerAutoReindex(ctx) {
   if (process.env.CAVEAT_INDEX_AUTOSYNC === "off") return;
-  if (!existsSync8(ctx.paths.dbPath)) return;
-  if (existsSync8(join10(ctx.caveatHome, "index", ".reindex-lock"))) return;
+  if (!existsSync9(ctx.paths.dbPath)) return;
+  if (existsSync9(join10(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;
@@ -32753,18 +32728,22 @@ function maybeTriggerAutoSync(ctx, debounceMs = AUTO_SYNC_DEBOUNCE_MS) {
   });
 }
 
-// src/commands/hookCmd.ts
-var silentLogger = {
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: (m) => process.stderr.write(`[caveat:hook] ${m}
+// 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 { 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:";
+function hookSilentLogger(host) {
+  return {
+    info: () => {
+    },
+    warn: () => {
+    },
+    error: (m) => process.stderr.write(`[${host.stderrTag}] ${m}
 `)
-};
-var CLAUDE_MAX_CONTEXT_BLOCKS = 3;
-var CLAUDE_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:";
-var CLAUDE_STOP_STATE_DIR = "claude-stop-state";
+  };
+}
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -32772,34 +32751,32 @@ async function readStdin() {
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
-function parsePayload(raw) {
+function errorMessage4(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function reportHookError(host, phase, err) {
+  observeRuntimeError(host.errorCode, { version: CAVEAT_VERSION });
+  process.stderr.write(`[${host.stderrTag}] ${phase}: ${errorMessage4(err)}
+`);
+}
+function parsePayload(host, raw) {
   if (!raw) return {};
   try {
     return JSON.parse(raw);
   } catch (err) {
-    observeRuntimeError("CAVEAT.CLAUDE_HOOK_FAILED", { version: CAVEAT_VERSION });
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:hook] json parse error: ${msg}
-`);
+    reportHookError(host, "json parse error", err);
     return {};
   }
 }
-function getSessionId(payload) {
-  const v = payload.session_id ?? payload.sessionId;
-  return typeof v === "string" && v.length > 0 ? v : "_unknown";
-}
-function buildContextSafely() {
+function buildContextSafely(host) {
   try {
-    return buildContext(silentLogger);
+    return buildContext(hookSilentLogger(host));
   } catch (err) {
-    observeRuntimeError("CAVEAT.CLAUDE_HOOK_FAILED", { version: CAVEAT_VERSION });
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:hook] context error: ${msg}
-`);
+    reportHookError(host, "context error", err);
     return null;
   }
 }
-function searchCaveatsSafely(input) {
+function searchCaveatsSafely(host, input) {
   const inputs = Array.isArray(input) ? input : [input];
   const queryForLog = inputs.map((item) => item.surface === "user_prompt" ? item.topicText || item.failureText : item.failureText).filter(Boolean).join("\n");
   if (inputs.length === 0 || inputs.every((item) => !item.topicText && !item.failureText)) return [];
@@ -32807,8 +32784,8 @@ function searchCaveatsSafely(input) {
   let caveatHome;
   let hits;
   try {
-    const ctx = buildContextSafely();
-    if (!ctx || !existsSync9(ctx.paths.dbPath)) return [];
+    const ctx = buildContextSafely(host);
+    if (!ctx || !existsSync10(ctx.paths.dbPath)) return [];
     caveatHome = ctx.caveatHome;
     db = openDb({ path: ctx.paths.dbPath });
     const searchOptions = {
@@ -32816,29 +32793,20 @@ function searchCaveatsSafely(input) {
     };
     hits = inputs.length === 1 ? findCaveatsForHook(db, inputs[0], searchOptions) : findCaveatsForHookSegments(db, inputs, searchOptions);
   } catch (err) {
-    observeRuntimeError("CAVEAT.CLAUDE_HOOK_FAILED", { version: CAVEAT_VERSION });
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:hook] search error: ${msg}
-`);
+    reportHookError(host, "search error", err);
     return [];
   }
   if (hits.length > 0) {
     try {
       markHit(db, hits);
     } catch (err) {
-      observeRuntimeError("CAVEAT.CLAUDE_HOOK_FAILED", { version: CAVEAT_VERSION });
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[caveat:hook] markHit error: ${msg}
-`);
+      reportHookError(host, "markHit error", err);
     }
   } else {
     try {
-      logHookQueryMiss({ caveatHome, agent: "claude", surface: inputs[0].surface, query: queryForLog });
+      logHookQueryMiss({ caveatHome, agent: host.agent, surface: inputs[0].surface, query: queryForLog });
     } catch (err) {
-      observeRuntimeError("CAVEAT.CLAUDE_HOOK_FAILED", { version: CAVEAT_VERSION });
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[caveat:hook] query log error: ${msg}
-`);
+      reportHookError(host, "query log error", err);
     }
   }
   try {
@@ -32847,50 +32815,37 @@ function searchCaveatsSafely(input) {
     db?.close();
   }
 }
-function loadSignalsSafely(path) {
-  try {
-    return readSessionSignals(path);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:hook] transcript read error: ${msg}
-`);
-    return null;
-  }
-}
-function systemReminderOutput(text) {
-  return `<system-reminder>${text.replace(/</g, "\u2039").replace(/>/g, "\u203A")}</system-reminder>`;
-}
-function claudePendingCleanupFailureText() {
-  return "[caveat:hook] pending reminder cleanup failed";
+function pendingCleanupFailureText(host) {
+  return `[${host.stderrTag}] pending reminder cleanup failed`;
 }
-function drainForSession(sessionId) {
-  const ctx = buildContextSafely();
+function drainForSession(host, sessionId) {
+  const ctx = buildContextSafely(host);
   if (!ctx) return [];
   const local = drainPendingRemindersDetailed(ctx.caveatHome, sessionId);
   const global = drainPendingRemindersDetailed(ctx.caveatHome, "_global");
   for (const _failure of [...local.cleanupFailures, ...global.cleanupFailures]) {
-    process.stderr.write(`${claudePendingCleanupFailureText()}
+    process.stderr.write(`${pendingCleanupFailureText(host)}
 `);
   }
   return [...local.reminders, ...global.reminders];
 }
-function claudeContextDedupeKey(text) {
-  if (text.startsWith(CLAUDE_STOP_REMINDER_PREFIX)) return "claude-stop-reminder";
+function contextDedupeKey(host, text) {
+  if (text.startsWith(STOP_REMINDER_PREFIX)) return host.stopDedupeKey;
   return text.trim();
 }
-function compactClaudeContexts(contexts) {
+function compactContexts(host, contexts) {
   const selected = [];
   const seen = /* @__PURE__ */ new Set();
   for (let i = contexts.length - 1; i >= 0; i -= 1) {
     const text = contexts[i]?.trim();
     if (!text) continue;
-    const key = claudeContextDedupeKey(text);
+    const key = contextDedupeKey(host, text);
     if (seen.has(key)) continue;
     seen.add(key);
     selected.push(text);
   }
   selected.reverse();
-  const limited = selected.slice(-CLAUDE_MAX_CONTEXT_BLOCKS);
+  const limited = selected.slice(-MAX_CONTEXT_BLOCKS);
   const omitted = selected.length - limited.length;
   if (omitted > 0) {
     limited.push(
@@ -32899,7 +32854,7 @@ function compactClaudeContexts(contexts) {
   }
   return limited;
 }
-function sanitizeClaudeStateId(raw) {
+function sanitizeStateId(raw) {
   const clean = raw.replace(/[^A-Za-z0-9_-]/g, "");
   return clean.length > 0 ? clean : "_unknown";
 }
@@ -32915,59 +32870,59 @@ function stopSignalKey(signals, related) {
   });
   return createHash("sha256").update(body).digest("hex");
 }
-function stopStatePath(caveatHome, sessionId) {
-  return join11(caveatHome, CLAUDE_STOP_STATE_DIR, `${sanitizeClaudeStateId(sessionId)}.txt`);
+function stopStatePath(host, caveatHome, sessionId) {
+  return join11(caveatHome, host.stopStateDir, `${sanitizeStateId(sessionId)}.txt`);
 }
-function wasStopReminderQueued(caveatHome, sessionId, key) {
-  const path = stopStatePath(caveatHome, sessionId);
+function wasStopReminderQueued(host, caveatHome, sessionId, key) {
+  const path = stopStatePath(host, caveatHome, sessionId);
   try {
     return readFileSync5(path, "utf-8") === key;
   } catch {
     return false;
   }
 }
-function markStopReminderQueued(caveatHome, sessionId, key) {
-  const path = stopStatePath(caveatHome, sessionId);
-  mkdirSync5(join11(caveatHome, CLAUDE_STOP_STATE_DIR), { recursive: true });
-  writeFileSync5(path, key, "utf-8");
+function markStopReminderQueued(host, caveatHome, sessionId, key) {
+  const path = stopStatePath(host, caveatHome, sessionId);
+  mkdirSync4(join11(caveatHome, host.stopStateDir), { recursive: true });
+  writeFileSync4(path, key, "utf-8");
 }
-function queueStopForSession(sessionId, signals, related) {
-  const ctx = buildContextSafely();
+function queueStopForSession(host, sessionId, signals, related, buildText) {
+  const ctx = buildContextSafely(host);
   if (!ctx) return;
   const key = stopSignalKey(signals, related);
-  if (wasStopReminderQueued(ctx.caveatHome, sessionId, key)) return;
+  if (wasStopReminderQueued(host, ctx.caveatHome, sessionId, key)) return;
   let result;
   try {
     result = buildAndPublishPendingReminder(ctx.caveatHome, sessionId, buildPendingSemanticKey({
-      agent: "claude",
+      agent: host.agent,
       surface: "stop",
       refs: related,
       stopSignalDigest: key
-    }), () => buildStopReminder(signals, related));
+    }), buildText);
   } catch {
-    process.stderr.write("[caveat:hook] pending reminder build or publish failed\n");
+    process.stderr.write(`[${host.stderrTag}] pending reminder build or publish failed
+`);
     return;
   }
   if (!result.ran) return;
   try {
-    markStopReminderQueued(ctx.caveatHome, sessionId, key);
+    markStopReminderQueued(host, ctx.caveatHome, sessionId, key);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:hook] pending reminder write error: ${msg}
+    process.stderr.write(`[${host.stderrTag}] pending reminder write error: ${errorMessage4(err)}
 `);
   }
 }
 function extractToolResponseText(response) {
   if (typeof response === "string") return response;
   if (Array.isArray(response)) {
-    const parts = [];
-    for (const item of response) {
-      if (typeof item === "string") parts.push(item);
-      else if (item !== null && typeof item === "object" && typeof item.text === "string") {
-        parts.push(item.text);
+    return response.map((item) => {
+      if (typeof item === "string") return item;
+      if (item !== null && typeof item === "object") {
+        const text = item.text;
+        return typeof text === "string" ? text : "";
       }
-    }
-    return parts.join(" ");
+      return "";
+    }).filter(Boolean).join(" ");
   }
   if (response !== null && typeof response === "object") {
     const r = response;
@@ -32980,6 +32935,32 @@ function extractToolResponseText(response) {
   }
   return "";
 }
+
+// src/commands/hookCmd.ts
+var CLAUDE_HOST = {
+  agent: "claude",
+  stderrTag: "caveat:hook",
+  errorCode: "CAVEAT.CLAUDE_HOOK_FAILED",
+  stopStateDir: "claude-stop-state",
+  stopDedupeKey: "claude-stop-reminder"
+};
+var silentLogger = hookSilentLogger(CLAUDE_HOST);
+function getSessionId(payload) {
+  const v = payload.session_id ?? payload.sessionId;
+  return typeof v === "string" && v.length > 0 ? v : "_unknown";
+}
+function loadSignalsSafely(path) {
+  try {
+    return readSessionSignals(path);
+  } catch (err) {
+    process.stderr.write(`[caveat:hook] transcript read error: ${errorMessage4(err)}
+`);
+    return null;
+  }
+}
+function systemReminderOutput(text) {
+  return `<system-reminder>${text.replace(/</g, "\u2039").replace(/>/g, "\u203A")}</system-reminder>`;
+}
 function toolTopicText(payload) {
   const parts = [];
   const toolName = payload.tool_name ?? payload.toolName;
@@ -33014,15 +32995,14 @@ function spawnWorker(job) {
   try {
     root = workerRoot();
     sweepStaleWorkerDirs(Date.now(), root);
-    workDir = mkdtempSync2(join11(root, "job-"));
+    workDir = mkdtempSync2(join12(root, "job-"));
     chmodSync(workDir, 448);
-    workFile = join11(workDir, `${randomBytes(4).toString("hex")}.json`);
+    workFile = join12(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) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:hook] worker writefile error: ${msg}
+    process.stderr.write(`[caveat:hook] worker writefile error: ${errorMessage4(err)}
 `);
-    cleanupWorkerDir(workDir, workDir ? dirname6(workDir) : void 0);
+    cleanupWorkerDir(workDir, workDir ? dirname5(workDir) : void 0);
     return;
   }
   const cliScript = process.argv[1];
@@ -33038,8 +33018,7 @@ function spawnWorker(job) {
     );
     child.unref();
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:hook] worker spawn error: ${msg}
+    process.stderr.write(`[caveat:hook] worker spawn error: ${errorMessage4(err)}
 `);
     try {
       cleanupWorkerDir(workDir, root);
@@ -33050,11 +33029,11 @@ function spawnWorker(job) {
 async function runWorker(workFile) {
   let raw;
   try {
-    raw = readFileSync5(workFile, "utf-8");
+    raw = readFileSync6(workFile, "utf-8");
   } catch {
     process.exit(0);
   }
-  cleanupWorkerDir(dirname6(workFile), dirname6(dirname6(workFile)));
+  cleanupWorkerDir(dirname5(workFile), dirname5(dirname5(workFile)));
   let job;
   try {
     job = JSON.parse(raw);
@@ -33062,13 +33041,13 @@ async function runWorker(workFile) {
     process.exit(0);
   }
   if (!job.failureText || !job.sessionId) process.exit(0);
-  const hits = searchCaveatsSafely({
+  const hits = searchCaveatsSafely(CLAUDE_HOST, {
     topicText: job.topicText,
     failureText: job.failureText,
     surface: "tool_error"
   });
   if (hits.length === 0) process.exit(0);
-  const ctx = buildContextSafely();
+  const ctx = buildContextSafely(CLAUDE_HOST);
   if (!ctx) process.exit(0);
   let result;
   try {
@@ -33095,11 +33074,11 @@ function isOwnedWorkerDir(path, root = workerRoot()) {
   try {
     const inputStat = lstatSync(path);
     if (inputStat.isSymbolicLink()) return false;
-    const tmpRoot = realpathSync4(root);
-    const resolved = realpathSync4(path);
+    const tmpRoot = realpathSync3(root);
+    const resolved = realpathSync3(path);
     const stat = lstatSync(resolved);
     const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
-    return dirname6(resolved) === tmpRoot && basename(resolved).startsWith("job-") && stat.isDirectory() && !stat.isSymbolicLink() && hasPrivateOwnership(stat, uid);
+    return dirname5(resolved) === tmpRoot && basename(resolved).startsWith("job-") && stat.isDirectory() && !stat.isSymbolicLink() && hasPrivateOwnership(stat, uid);
   } catch {
     return false;
   }
@@ -33114,7 +33093,7 @@ function sweepStaleWorkerDirs(now = Date.now(), root = workerRoot()) {
   }
   for (const entry of entries) {
     if (!entry.startsWith("job-")) continue;
-    const path = join11(root, entry);
+    const path = join12(root, entry);
     try {
       if (!isOwnedWorkerDir(path, root)) continue;
       const stat = lstatSync(path);
@@ -33126,32 +33105,32 @@ function sweepStaleWorkerDirs(now = Date.now(), root = workerRoot()) {
   }
 }
 function workerRoot(base = tmpdir2()) {
-  const root = join11(base, WORKER_ROOT);
+  const root = join12(base, WORKER_ROOT);
   mkdirSync5(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 = join11(root, WORKER_MARKER);
+  const marker = join12(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) || readFileSync5(marker, "utf-8") !== "caveat-worker/v1\n") throw new Error("worker root marker is invalid");
+  if (!markerStat.isFile() || markerStat.isSymbolicLink() || !hasPrivateOwnership(markerStat, uid) || readFileSync6(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 = join11(path, entries[0]);
+  const file2 = join12(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(readFileSync5(file2, "utf-8")));
+  return isKnownStaleWorkerJob(JSON.parse(readFileSync6(file2, "utf-8")));
 }
 function hasPrivateOwnership(stat, uid) {
-  return process.platform === "win32" || (stat.mode & 63) === 0 && (uid === void 0 || stat.uid === uid);
+  return isPrivateOwnerStat(stat, uid);
 }
 function isWorkerJob(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
@@ -33170,23 +33149,19 @@ function isKnownStaleWorkerJob(value) {
 }
 function writeLastReindex(caveatHome, value) {
   try {
-    writeFileSync5(join11(caveatHome, "index", ".last-reindex.json"), JSON.stringify(value), "utf-8");
+    writeFileSync5(join12(caveatHome, "index", ".last-reindex.json"), JSON.stringify(value), "utf-8");
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:hook] reindex status write error: ${msg}
+    process.stderr.write(`[caveat:hook] reindex status write error: ${errorMessage4(err)}
 `);
   }
 }
-function errorMessage4(err) {
-  return err instanceof Error ? err.message : String(err);
-}
 async function runReindexWorker() {
   if (process.env.CAVEAT_INDEX_AUTOSYNC === "off") {
     process.stderr.write("[caveat:hook] auto reindex disabled by CAVEAT_INDEX_AUTOSYNC=off\n");
     return;
   }
-  const ctx = buildContextSafely();
-  if (!ctx || !existsSync9(ctx.paths.dbPath)) {
+  const ctx = buildContextSafely(CLAUDE_HOST);
+  if (!ctx || !existsSync11(ctx.paths.dbPath)) {
     process.stderr.write("[caveat:hook] auto reindex skipped: index database does not exist\n");
     return;
   }
@@ -33211,7 +33186,7 @@ async function runReindexWorker() {
       perSource: result.perSource
     });
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+    const msg = errorMessage4(err);
     process.stderr.write(`[caveat:hook] reindex error: ${msg}
 `);
     writeLastReindex(ctx.caveatHome, {
@@ -33224,8 +33199,7 @@ async function runReindexWorker() {
     try {
       releaseReindexLock(lock);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[caveat:hook] reindex lock release error: ${msg}
+      process.stderr.write(`[caveat:hook] reindex lock release error: ${errorMessage4(err)}
 `);
     }
   }
@@ -33235,7 +33209,7 @@ async function runAutoSyncWorker() {
     process.stderr.write("[caveat:hook] auto sync disabled by CAVEAT_AUTO_SYNC=off\n");
     return;
   }
-  const ctx = buildContextSafely();
+  const ctx = buildContextSafely(CLAUDE_HOST);
   if (!ctx) return;
   try {
     await runAutoSync({
@@ -33254,7 +33228,7 @@ function buildToolErrorReminder(job, hits) {
   const mode = hookCodexSidecarMode();
   if (mode === "off") return base;
   const projectRoot = process.cwd();
-  const hasSidecarConfig = existsSync9(join11(projectRoot, ".codex-sidecar.yml"));
+  const hasSidecarConfig = existsSync11(join12(projectRoot, ".codex-sidecar.yml"));
   if (mode === "auto" && !hasSidecarConfig) return base;
   const advisory = runCodexSidecarAdvisory({
     searchText: job.failureText,
@@ -33290,7 +33264,7 @@ function buildStopReminder(signals, related) {
   const mode = hookCodexSidecarMode();
   if (mode === "off") return base;
   const projectRoot = process.cwd();
-  const hasSidecarConfig = existsSync9(join11(projectRoot, ".codex-sidecar.yml"));
+  const hasSidecarConfig = existsSync11(join12(projectRoot, ".codex-sidecar.yml"));
   if (mode === "auto" && !hasSidecarConfig) return base;
   const advisory = runCodexSidecarAdvisory({
     searchText: struggleSearchText(signals),
@@ -33347,21 +33321,20 @@ async function runHook(name, arg) {
   try {
     raw = await readStdin();
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:hook] stdin read error: ${msg}
+    process.stderr.write(`[caveat:hook] stdin read error: ${errorMessage4(err)}
 `);
     process.exit(0);
   }
-  const payload = parsePayload(raw);
+  const payload = parsePayload(CLAUDE_HOST, raw);
   const sessionId = getSessionId(payload);
-  const contexts = name === "stop" ? [] : drainForSession(sessionId);
+  const contexts = name === "stop" ? [] : drainForSession(CLAUDE_HOST, sessionId);
   if (name === "user-prompt-submit") {
     const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
-    const hits = searchCaveatsSafely({ topicText: prompt, failureText: prompt, surface: "user_prompt" });
+    const hits = searchCaveatsSafely(CLAUDE_HOST, { topicText: prompt, failureText: prompt, surface: "user_prompt" });
     if (hits.length > 0) {
       contexts.push(userPromptSubmitReminderText(hits));
     }
-    const compacted = compactClaudeContexts(contexts);
+    const compacted = compactContexts(CLAUDE_HOST, contexts);
     if (compacted.length > 0) {
       process.stdout.write(`${systemReminderOutput(compacted.join("\n\n"))}
 `);
@@ -33369,7 +33342,7 @@ async function runHook(name, arg) {
     process.exit(0);
   }
   if (name === "post-tool-use") {
-    const compacted = compactClaudeContexts(contexts);
+    const compacted = compactContexts(CLAUDE_HOST, contexts);
     if (compacted.length > 0) {
       process.stdout.write(`${systemReminderOutput(compacted.join("\n\n"))}
 `);
@@ -33391,27 +33364,24 @@ async function runHook(name, arg) {
     process.exit(0);
   }
   if (name === "stop") {
-    const ctx = buildContextSafely();
+    const ctx = buildContextSafely(CLAUDE_HOST);
     if (ctx) {
       try {
         maybeSweepPendingDirs(ctx.caveatHome);
       } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[caveat:hook] pending sweep error: ${msg}
+        process.stderr.write(`[caveat:hook] pending sweep error: ${errorMessage4(err)}
 `);
       }
       try {
         maybeTriggerAutoReindex(ctx);
       } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[caveat:hook] auto reindex trigger error: ${msg}
+        process.stderr.write(`[caveat:hook] auto reindex trigger error: ${errorMessage4(err)}
 `);
       }
       try {
         maybeTriggerAutoSync(ctx);
       } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[caveat:hook] auto sync trigger error: ${msg}
+        process.stderr.write(`[caveat:hook] auto sync trigger error: ${errorMessage4(err)}
 `);
       }
     }
@@ -33419,12 +33389,12 @@ async function runHook(name, arg) {
     const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : "";
     const signals = transcriptPath ? loadSignalsSafely(transcriptPath) : null;
     if (!signals || !hasAnyStruggleSignal(signals)) process.exit(0);
-    const related = searchCaveatsSafely(signals.errorSnippets.map((failureText) => ({
+    const related = searchCaveatsSafely(CLAUDE_HOST, signals.errorSnippets.map((failureText) => ({
       topicText: "",
       failureText,
       surface: "stop"
     })));
-    queueStopForSession(sessionId, signals, related);
+    queueStopForSession(CLAUDE_HOST, sessionId, signals, related, () => buildStopReminder(signals, related));
     process.exit(0);
   }
   process.stderr.write(`[caveat:hook] unknown hook name: ${name}
@@ -33434,105 +33404,22 @@ async function runHook(name, arg) {
 
 // src/commands/codexHookCmd.ts
 import { spawn as spawn3, spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir3 } from "node:os";
-import { join as join12 } from "node:path";
-import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
-var silentLogger2 = {
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: (m) => process.stderr.write(`[caveat:codex-hook] ${m}
-`)
+import { join as join13 } from "node:path";
+import { randomBytes as randomBytes2 } from "node:crypto";
+var CODEX_HOST = {
+  agent: "codex",
+  stderrTag: "caveat:codex-hook",
+  errorCode: "CAVEAT.CODEX_HOOK_FAILED",
+  stopStateDir: "codex-stop-state",
+  stopDedupeKey: "codex-stop-reminder"
 };
-var CODEX_MAX_CONTEXT_BLOCKS = 3;
-var CODEX_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:";
-var CODEX_STOP_STATE_DIR = "codex-stop-state";
-async function readStdin2() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-  }
-  return Buffer.concat(chunks).toString("utf-8");
-}
-function parsePayload2(raw) {
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch (err) {
-    observeRuntimeError("CAVEAT.CODEX_HOOK_FAILED", { version: CAVEAT_VERSION });
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:codex-hook] json parse error: ${msg}
-`);
-    return {};
-  }
-}
-function buildContextSafely2() {
-  try {
-    return buildContext(silentLogger2);
-  } catch (err) {
-    observeRuntimeError("CAVEAT.CODEX_HOOK_FAILED", { version: CAVEAT_VERSION });
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:codex-hook] context error: ${msg}
-`);
-    return null;
-  }
-}
-function searchCaveatsSafely2(input) {
-  const inputs = Array.isArray(input) ? input : [input];
-  const queryForLog = inputs.map((item) => item.surface === "user_prompt" ? item.topicText || item.failureText : item.failureText).filter(Boolean).join("\n");
-  if (inputs.length === 0 || inputs.every((item) => !item.topicText && !item.failureText)) return [];
-  let db;
-  let caveatHome;
-  let hits;
-  try {
-    const ctx = buildContextSafely2();
-    if (!ctx || !existsSync10(ctx.paths.dbPath)) return [];
-    caveatHome = ctx.caveatHome;
-    db = openDb({ path: ctx.paths.dbPath });
-    const searchOptions = {
-      selfIdentity: defaultSelfIdentityTokens()
-    };
-    hits = inputs.length === 1 ? findCaveatsForHook(db, inputs[0], searchOptions) : findCaveatsForHookSegments(db, inputs, searchOptions);
-  } catch (err) {
-    observeRuntimeError("CAVEAT.CODEX_HOOK_FAILED", { version: CAVEAT_VERSION });
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:codex-hook] search error: ${msg}
-`);
-    return [];
-  }
-  if (hits.length > 0) {
-    try {
-      markHit(db, hits);
-    } catch (err) {
-      observeRuntimeError("CAVEAT.CODEX_HOOK_FAILED", { version: CAVEAT_VERSION });
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[caveat:codex-hook] markHit error: ${msg}
-`);
-    }
-  } else {
-    try {
-      logHookQueryMiss({ caveatHome, agent: "codex", surface: inputs[0].surface, query: queryForLog });
-    } catch (err) {
-      observeRuntimeError("CAVEAT.CODEX_HOOK_FAILED", { version: CAVEAT_VERSION });
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[caveat:codex-hook] query log error: ${msg}
-`);
-    }
-  }
-  try {
-    return hits;
-  } finally {
-    db?.close();
-  }
-}
 function loadSignalsSafely2(path) {
   try {
     return readCodexSessionSignals(path);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:codex-hook] transcript read error: ${msg}
+    process.stderr.write(`[caveat:codex-hook] transcript read error: ${errorMessage4(err)}
 `);
     return null;
   }
@@ -33541,29 +33428,6 @@ function codexSessionId(payload) {
   const v = payload.session_id ?? payload.sessionId;
   return typeof v === "string" && v.length > 0 ? v : null;
 }
-function extractToolResponseText2(response) {
-  if (typeof response === "string") return response;
-  if (Array.isArray(response)) {
-    return response.map((item) => {
-      if (typeof item === "string") return item;
-      if (item !== null && typeof item === "object") {
-        const text = item.text;
-        return typeof text === "string" ? text : "";
-      }
-      return "";
-    }).filter(Boolean).join(" ");
-  }
-  if (response !== null && typeof response === "object") {
-    const r = response;
-    if (typeof r.content === "string") return r.content;
-    if (Array.isArray(r.content)) return extractToolResponseText2(r.content);
-    if (typeof r.output === "string") return r.output;
-    if (typeof r.stdout === "string" || typeof r.stderr === "string") {
-      return [r.stdout, r.stderr].filter((x) => typeof x === "string").join(" ");
-    }
-  }
-  return "";
-}
 function numericExitCode(v) {
   return typeof v === "number" && Number.isInteger(v) ? v : null;
 }
@@ -33572,10 +33436,10 @@ function processExitCodeFromText(text) {
   return m ? Number(m[1]) : null;
 }
 function transcriptToolOutput(transcriptPath, toolUseId) {
-  if (!transcriptPath || !toolUseId || !existsSync10(transcriptPath)) return null;
+  if (!transcriptPath || !toolUseId || !existsSync12(transcriptPath)) return null;
   let raw = "";
   try {
-    raw = readFileSync6(transcriptPath, "utf-8");
+    raw = readFileSync7(transcriptPath, "utf-8");
   } catch {
     return null;
   }
@@ -33629,7 +33493,7 @@ function isCodexToolError(payload) {
     const exit2 = numericExitCode(r.exit_code ?? r.exitCode);
     if (exit2 !== null) return exit2 !== 0;
   }
-  const responseExit = processExitCodeFromText(extractToolResponseText2(resp));
+  const responseExit = processExitCodeFromText(extractToolResponseText(resp));
   if (responseExit !== null) return responseExit !== 0;
   const transcriptExit = transcriptExitCode(payload);
   if (transcriptExit !== null) return transcriptExit !== 0;
@@ -33640,7 +33504,7 @@ function buildCodexPostToolUseWorkerJob(payload) {
   if (!sessionId) return null;
   const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : void 0;
   const toolUseId = typeof payload.tool_use_id === "string" ? payload.tool_use_id : void 0;
-  const responseText = extractToolResponseText2(payload.tool_response ?? payload.toolResponse);
+  const responseText = extractToolResponseText(payload.tool_response ?? payload.toolResponse);
   const inputText = toolInputText(payload.tool_input);
   const transcriptOutput = transcriptPath && toolUseId ? transcriptToolOutput(transcriptPath, toolUseId) : null;
   const topicText = inputText.trim();
@@ -33670,101 +33534,6 @@ function codexContextOutput(text, eventName = "UserPromptSubmit") {
     }
   });
 }
-function codexPendingCleanupFailureText() {
-  return "[caveat:codex-hook] pending reminder cleanup failed";
-}
-function drainForSession2(sessionId) {
-  const ctx = buildContextSafely2();
-  if (!ctx) return [];
-  const local = drainPendingRemindersDetailed(ctx.caveatHome, sessionId);
-  const global = drainPendingRemindersDetailed(ctx.caveatHome, "_global");
-  for (const _failure of [...local.cleanupFailures, ...global.cleanupFailures]) {
-    process.stderr.write(`${codexPendingCleanupFailureText()}
-`);
-  }
-  return [...local.reminders, ...global.reminders];
-}
-function codexContextDedupeKey(text) {
-  if (text.startsWith(CODEX_STOP_REMINDER_PREFIX)) return "codex-stop-reminder";
-  return text.trim();
-}
-function compactCodexContexts(contexts) {
-  const selected = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (let i = contexts.length - 1; i >= 0; i -= 1) {
-    const text = contexts[i]?.trim();
-    if (!text) continue;
-    const key = codexContextDedupeKey(text);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    selected.push(text);
-  }
-  selected.reverse();
-  const limited = selected.slice(-CODEX_MAX_CONTEXT_BLOCKS);
-  const omitted = selected.length - limited.length;
-  if (omitted > 0) {
-    limited.push(`[caveat] pending reminder ${omitted} \u4EF6\u3092\u91CD\u8907\u307E\u305F\u306F\u4E0A\u9650\u306B\u3088\u308A\u7701\u7565\u3057\u307E\u3057\u305F\u3002`);
-  }
-  return limited;
-}
-function sanitizeCodexStateId(raw) {
-  const clean = raw.replace(/[^A-Za-z0-9_-]/g, "");
-  return clean.length > 0 ? clean : "_unknown";
-}
-function stopSignalKey2(signals, related) {
-  const body = JSON.stringify({
-    toolFailureCount: signals.toolFailureCount,
-    fileEditCounts: signals.fileEditCounts.map((e) => [e.path, e.count]),
-    webSearchCount: signals.webSearchCount,
-    webFetchCount: signals.webFetchCount,
-    bashRetryCount: signals.bashRetryCount,
-    searchQueries: signals.searchQueries,
-    related: related.map((h) => [h.source, h.id])
-  });
-  return createHash2("sha256").update(body).digest("hex");
-}
-function stopStatePath2(caveatHome, sessionId) {
-  return join12(caveatHome, CODEX_STOP_STATE_DIR, `${sanitizeCodexStateId(sessionId)}.txt`);
-}
-function wasStopReminderQueued2(caveatHome, sessionId, key) {
-  const path = stopStatePath2(caveatHome, sessionId);
-  try {
-    return readFileSync6(path, "utf-8") === key;
-  } catch {
-    return false;
-  }
-}
-function markStopReminderQueued2(caveatHome, sessionId, key) {
-  const path = stopStatePath2(caveatHome, sessionId);
-  mkdirSync6(join12(caveatHome, CODEX_STOP_STATE_DIR), { recursive: true });
-  writeFileSync6(path, key, "utf-8");
-}
-function queueStopForSession2(sessionId, signals, related) {
-  const ctx = buildContextSafely2();
-  if (!ctx) return;
-  const key = stopSignalKey2(signals, related);
-  if (wasStopReminderQueued2(ctx.caveatHome, sessionId, key)) return;
-  let result;
-  try {
-    result = buildAndPublishPendingReminder(ctx.caveatHome, sessionId, buildPendingSemanticKey({
-      agent: "codex",
-      surface: "stop",
-      refs: related,
-      stopSignalDigest: key
-    }), () => stopReminderText(signals, related));
-  } catch {
-    process.stderr.write("[caveat:codex-hook] pending reminder build or publish failed\n");
-    return;
-  }
-  if (!result.ran) return;
-  try {
-    markStopReminderQueued2(ctx.caveatHome, sessionId, key);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:codex-hook] pending reminder write error: ${msg}
-`);
-  }
-}
 async function waitForTranscriptOutput(transcriptPath, toolUseId) {
   const deadline = Date.now() + 2e3;
   while (Date.now() <= deadline) {
@@ -33790,13 +33559,13 @@ async function processCodexWorkerJob(job, opts = { waitForTranscript: true }) {
     }
   }
   if (!knownError && job.allowSymptomOnly !== true) return;
-  const hits = searchCaveatsSafely2({
+  const hits = searchCaveatsSafely(CODEX_HOST, {
     topicText: job.topicText,
     failureText,
     surface: "tool_error"
   });
   if (hits.length === 0) return;
-  const ctx = buildContextSafely2();
+  const ctx = buildContextSafely(CODEX_HOST);
   if (!ctx) return;
   let result;
   try {
@@ -33814,7 +33583,7 @@ async function processCodexWorkerJob(job, opts = { waitForTranscript: true }) {
 async function runCodexWorker(workFile) {
   let raw;
   try {
-    raw = readFileSync6(workFile, "utf-8");
+    raw = readFileSync7(workFile, "utf-8");
   } catch {
     process.exit(0);
   }
@@ -33831,7 +33600,7 @@ async function runCodexWorker(workFile) {
   await processCodexWorkerJob(job);
   process.exit(0);
 }
-function runDiagnostics(codexHome = process.env.CODEX_HOME ?? join12(homedir3(), ".codex")) {
+function runDiagnostics(codexHome = process.env.CODEX_HOME ?? join13(homedir3(), ".codex")) {
   const features = spawnSync5("codex", ["features", "list"], {
     encoding: "utf-8",
     maxBuffer: 1024 * 1024,
@@ -33869,24 +33638,23 @@ async function runCodexHook(name, arg) {
   }
   let raw = "";
   try {
-    raw = await readStdin2();
+    raw = await readStdin();
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[caveat:codex-hook] stdin read error: ${msg}
+    process.stderr.write(`[caveat:codex-hook] stdin read error: ${errorMessage4(err)}
 `);
     process.exit(0);
   }
-  const payload = parsePayload2(raw);
+  const payload = parsePayload(CODEX_HOST, raw);
   const sessionId = codexSessionId(payload);
   if (!sessionId) process.stderr.write("[caveat:codex-hook] missing session_id; pending drain disabled\n");
   if (name === "user-prompt-submit") {
-    const contexts = sessionId ? drainForSession2(sessionId) : [];
+    const contexts = sessionId ? drainForSession(CODEX_HOST, sessionId) : [];
     const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
-    const hits = searchCaveatsSafely2({ topicText: prompt, failureText: prompt, surface: "user_prompt" });
+    const hits = searchCaveatsSafely(CODEX_HOST, { topicText: prompt, failureText: prompt, surface: "user_prompt" });
     if (hits.length > 0) {
       contexts.push(userPromptSubmitReminderText(hits));
     }
-    const compacted = compactCodexContexts(contexts);
+    const compacted = compactContexts(CODEX_HOST, contexts);
     if (compacted.length > 0) {
       process.stdout.write(`${codexContextOutput(compacted.join("\n\n"))}
 `);
@@ -33900,39 +33668,36 @@ async function runCodexHook(name, arg) {
   }
   if (name === "stop") {
     try {
-      const ctx = buildContextSafely2();
+      const ctx = buildContextSafely(CODEX_HOST);
       if (ctx) {
         try {
           maybeSweepPendingDirs(ctx.caveatHome);
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          process.stderr.write(`[caveat:codex-hook] pending sweep error: ${msg}
+          process.stderr.write(`[caveat:codex-hook] pending sweep error: ${errorMessage4(err)}
 `);
         }
         maybeTriggerAutoReindex(ctx);
         try {
           maybeTriggerAutoSync(ctx);
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          process.stderr.write(`[caveat:codex-hook] auto sync trigger error: ${msg}
+          process.stderr.write(`[caveat:codex-hook] auto sync trigger error: ${errorMessage4(err)}
 `);
         }
       }
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[caveat:codex-hook] auto reindex trigger error: ${msg}
+      process.stderr.write(`[caveat:codex-hook] auto reindex 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 ? loadSignalsSafely2(transcriptPath) : null;
     if (!signals || !hasAnyStruggleSignal(signals)) process.exit(0);
-    const related = searchCaveatsSafely2(signals.errorSnippets.map((failureText) => ({
+    const related = searchCaveatsSafely(CODEX_HOST, signals.errorSnippets.map((failureText) => ({
       topicText: "",
       failureText,
       surface: "stop"
     })));
-    if (sessionId) queueStopForSession2(sessionId, signals, related);
+    if (sessionId) queueStopForSession(CODEX_HOST, sessionId, signals, related, () => stopReminderText(signals, related));
     process.exit(0);
   }
   process.stderr.write(`[caveat:codex-hook] unknown hook name: ${name}
@@ -33941,9 +33706,9 @@ async function runCodexHook(name, arg) {
 }
 
 // src/commands/pull.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 async function runPull(ctx) {
-  const hasCommunityDir = existsSync11(ctx.paths.communityDir);
+  const hasCommunityDir = existsSync13(ctx.paths.communityDir);
   if (!hasCommunityDir) {
     ctx.logger.info(
       "no community repos yet \u2014 add one with `caveat community add <github-url>`."
@@ -34043,9 +33808,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 mkdirSync7, mkdtempSync as mkdtempSync3, openSync, readSync as readSync2, realpathSync as realpathSync5, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "node:fs";
+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 { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename2, dirname as dirname7, join as join13 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join14 } from "node:path";
 import { cwd, exit } from "node:process";
 function runCodexSidecarDiagnostics(logger, opts) {
   const plan = buildCodexSidecarDiagnosticsCommand({
@@ -34077,8 +33842,8 @@ function runCodexSidecarWithCaveats(ctx, workflow, prompt, opts) {
     process.stdout.write(JSON.stringify({ status: "skipped", decision }, null, 2) + "\n");
     exit(0);
   }
-  const contextDir = mkdtempSync3(join13(tmpdir4(), "caveat-sidecar-context-"));
-  const contextFile = join13(contextDir, "context.json");
+  const contextDir = mkdtempSync3(join14(tmpdir4(), "caveat-sidecar-context-"));
+  const contextFile = join14(contextDir, "context.json");
   let status2 = 1;
   try {
     const blocks = collectCaveatContextBlocks(ctx, {
@@ -34143,16 +33908,16 @@ function readHookSignalAdditionalContextFile(path, testProbe) {
   return [block];
 }
 function assertPrivateRegular(stat, uid, platform) {
-  const privateOwner = platform === "win32" || (stat.mode & 63) === 0 && (uid === void 0 || stat.uid === uid);
+  const privateOwner = isPrivateOwnerStat(stat, uid, platform);
   if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_ADDITIONAL_CONTEXT_BYTES || !privateOwner) throw new Error("additional context file must be a private owner-only regular file within 4096 bytes");
 }
 function assertWindowsPrivateTempContainer(path, platform) {
-  if (platform !== "win32") return;
-  const parent = dirname7(path);
+  if (!isWindows(platform)) return;
+  const parent = dirname6(path);
   const parentStat = lstatSync2(parent);
-  const resolvedParent = realpathSync5(parent);
-  const resolvedTemp = realpathSync5(tmpdir4());
-  if (parentStat.isSymbolicLink() || !parentStat.isDirectory() || dirname7(resolvedParent) !== resolvedTemp || !basename2(resolvedParent).startsWith("caveat-")) {
+  const resolvedParent = realpathSync4(parent);
+  const resolvedTemp = realpathSync4(tmpdir4());
+  if (parentStat.isSymbolicLink() || !parentStat.isDirectory() || dirname6(resolvedParent) !== resolvedTemp || !basename2(resolvedParent).startsWith("caveat-")) {
     throw new Error("additional context file must be inside a reserved per-user Caveat temporary directory");
   }
 }
@@ -34241,7 +34006,7 @@ function executePlan(logger, command, args, options = {}) {
 }
 function saveStructuredResult(path, stdout) {
   const parsed = JSON.parse(stdout);
-  mkdirSync7(dirname7(path), { recursive: true });
+  mkdirSync6(dirname6(path), { recursive: true });
   writeFileSync7(path, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
 }
 function shellDisplayQuote(value) {
@@ -34330,8 +34095,8 @@ function runCommunityRemove(ctx, handle, opts) {
 
 // src/commands/factoryDiagnostics.ts
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync7 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync8 } from "node:fs";
+import { join as join15 } 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 });
@@ -34343,10 +34108,10 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function claudeRegistration(home, nodePath, cliScriptPath) {
-  const path = join14(home, ".claude.json");
-  if (!existsSync12(path)) return status(false, "not_registered");
+  const path = join15(home, ".claude.json");
+  if (!existsSync14(path)) return status(false, "not_registered");
   try {
-    const value = JSON.parse(readFileSync7(path, "utf8"));
+    const value = JSON.parse(readFileSync8(path, "utf8"));
     if (!isRecord2(value) || !isRecord2(value.mcpServers)) return status(false, "not_registered");
     return status(isCaveatClaudeMcpRegistration(value.mcpServers.caveat, nodePath, cliScriptPath), "not_registered");
   } catch {
@@ -34355,7 +34120,7 @@ function claudeRegistration(home, nodePath, cliScriptPath) {
 }
 function claudeHooks(home, nodePath, cliScriptPath) {
   try {
-    const settings = JSON.parse(readFileSync7(join14(home, ".claude", "settings.json"), "utf8"));
+    const settings = JSON.parse(readFileSync8(join15(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 {
@@ -34377,7 +34142,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 (!existsSync12(path)) return { status: "not_ready", reason_code: "missing", schema_version: null, supported_schema_version: 3, migration_status: "unverified" };
+  if (!existsSync14(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 {
@@ -34402,10 +34167,10 @@ function database(path) {
   }
 }
 function codexFeature(codexHome) {
-  const path = join14(codexHome, "config.toml");
-  if (!existsSync12(path)) return status(false, "feature_disabled");
+  const path = join15(codexHome, "config.toml");
+  if (!existsSync14(path)) return status(false, "feature_disabled");
   try {
-    const config2 = parseToml2(readFileSync7(path, "utf8"));
+    const config2 = parseToml2(readFileSync8(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");
@@ -34414,7 +34179,7 @@ function codexFeature(codexHome) {
   }
 }
 function codexHooks(codexHome, nodePath, cliScriptPath) {
-  const value = JSON.parse(readFileSync7(join14(codexHome, "hooks.json"), "utf8"));
+  const value = JSON.parse(readFileSync8(join15(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)));
@@ -34449,7 +34214,7 @@ function sync(own) {
     return unverified("upstream_unavailable");
   }
 }
-function factoryDiagnostics(ctx, codexHome = process.env.CODEX_HOME ?? join14(ctx.userHome, ".codex")) {
+function factoryDiagnostics(ctx, codexHome = process.env.CODEX_HOME ?? join15(ctx.userHome, ".codex")) {
   const nodePath = process.execPath;
   const cliScriptPath = process.argv[1] ?? "";
   const db = database(ctx.paths.dbPath);