caveat-cli 0.15.0 → 0.16.1

package/dist/index.js

@@ -2,7 +2,11 @@
 import { createRequire as __caveat_createRequire } from 'node:module';
 const require = __caveat_createRequire(import.meta.url);
 import {
+  AUTO_SYNC_DEBOUNCE_MS,
+  CAVEAT_AUTO_SYNC_ENV,
   KNOWLEDGE_GITIGNORE,
+  PublishScanError,
+  SyncError,
   __commonJS,
   __export,
   __toESM,
@@ -11,6 +15,7 @@ import {
   buildCodexSidecarDiagnosticsCommand,
   buildCodexSidecarReadOnlySmokeCommand,
   buildCodexSidecarRunCommand,
+  buildHookSignalSidecarContextBlock,
   caveatEntriesToSidecarContextBlocks,
   cleanupStalePendingDirs,
   communityAdd,
@@ -18,8 +23,10 @@ import {
   communityPull,
   communityRemove,
   computeEntriesDigest,
+  createKeyserverKeyProvider,
   decideCodexSidecarExecution,
   defaultSelfIdentityTokens,
+  drainGlobalPendingReminders,
   drainPendingReminders,
   ensureUserConfig,
   findCaveatHome,
@@ -30,9 +37,11 @@ import {
   listRecent,
   listStale,
   loadConfig,
+  logHookQueryMiss,
   markHit,
   maybeSweepPendingDirs,
   openDb,
+  prewarmSealedKeys,
   publishOwn,
   readCodexSessionSignals,
   readDigestMarker,
@@ -41,8 +50,9 @@ import {
   recordEntry,
   reindexAllSources,
   releaseReindexLock,
+  resetAutoSyncFailureState,
   resolvePaths,
-  scanSource,
+  runAutoSync,
   search,
   stderrLogger,
   stopReminderText,
@@ -53,7 +63,7 @@ import {
   userPromptSubmitReminderText,
   writeDigestMarker,
   writeUserConfigPatch
-} from "./chunk-Z2XLYCR3.js";
+} from "./chunk-HCLEIAGO.js";
 
 // ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -432,11 +442,11 @@ var require_codegen = __commonJS({
         const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
         return `${varKind} ${this.name}${rhs};` + _n;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         if (!names[this.name.str])
           return;
         if (this.rhs)
-          this.rhs = optimizeExpr(this.rhs, names, constants);
+          this.rhs = optimizeExpr(this.rhs, names, constants2);
         return this;
       }
       get names() {
@@ -453,10 +463,10 @@ var require_codegen = __commonJS({
       render({ _n }) {
         return `${this.lhs} = ${this.rhs};` + _n;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
           return;
-        this.rhs = optimizeExpr(this.rhs, names, constants);
+        this.rhs = optimizeExpr(this.rhs, names, constants2);
         return this;
       }
       get names() {
@@ -517,8 +527,8 @@ var require_codegen = __commonJS({
       optimizeNodes() {
         return `${this.code}` ? this : void 0;
       }
-      optimizeNames(names, constants) {
-        this.code = optimizeExpr(this.code, names, constants);
+      optimizeNames(names, constants2) {
+        this.code = optimizeExpr(this.code, names, constants2);
         return this;
       }
       get names() {
@@ -547,12 +557,12 @@ var require_codegen = __commonJS({
         }
         return nodes.length > 0 ? this : void 0;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         const { nodes } = this;
         let i = nodes.length;
         while (i--) {
           const n = nodes[i];
-          if (n.optimizeNames(names, constants))
+          if (n.optimizeNames(names, constants2))
             continue;
           subtractNames(names, n.names);
           nodes.splice(i, 1);
@@ -605,12 +615,12 @@ var require_codegen = __commonJS({
           return void 0;
         return this;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         var _a3;
-        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants);
-        if (!(super.optimizeNames(names, constants) || this.else))
+        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants2);
+        if (!(super.optimizeNames(names, constants2) || this.else))
           return;
-        this.condition = optimizeExpr(this.condition, names, constants);
+        this.condition = optimizeExpr(this.condition, names, constants2);
         return this;
       }
       get names() {
@@ -633,10 +643,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.iteration})` + super.render(opts);
       }
-      optimizeNames(names, constants) {
-        if (!super.optimizeNames(names, constants))
+      optimizeNames(names, constants2) {
+        if (!super.optimizeNames(names, constants2))
           return;
-        this.iteration = optimizeExpr(this.iteration, names, constants);
+        this.iteration = optimizeExpr(this.iteration, names, constants2);
         return this;
       }
       get names() {
@@ -672,10 +682,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
       }
-      optimizeNames(names, constants) {
-        if (!super.optimizeNames(names, constants))
+      optimizeNames(names, constants2) {
+        if (!super.optimizeNames(names, constants2))
           return;
-        this.iterable = optimizeExpr(this.iterable, names, constants);
+        this.iterable = optimizeExpr(this.iterable, names, constants2);
         return this;
       }
       get names() {
@@ -717,11 +727,11 @@ var require_codegen = __commonJS({
         (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
         return this;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         var _a3, _b;
-        super.optimizeNames(names, constants);
-        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants);
-        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants);
+        super.optimizeNames(names, constants2);
+        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants2);
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants2);
         return this;
       }
       get names() {
@@ -1022,7 +1032,7 @@ var require_codegen = __commonJS({
     function addExprNames(names, from) {
       return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
     }
-    function optimizeExpr(expr, names, constants) {
+    function optimizeExpr(expr, names, constants2) {
       if (expr instanceof code_1.Name)
         return replaceName(expr);
       if (!canOptimize(expr))
@@ -1037,14 +1047,14 @@ var require_codegen = __commonJS({
         return items;
       }, []));
       function replaceName(n) {
-        const c = constants[n.str];
+        const c = constants2[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 && constants[c.str] !== void 0);
+        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants2[c.str] !== void 0);
       }
     }
     function subtractNames(names, from) {
@@ -6865,8 +6875,9 @@ var stdoutLogger = {
 };
 
 // src/commands/init.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, renameSync, rmdirSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
+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";
 
 // src/claudeInstall.ts
 import { spawnSync } from "node:child_process";
@@ -7061,9 +7072,438 @@ function uninstallClaudeIntegration(opts) {
   };
 }
 
+// src/codexHookInstall.ts
+import { copyFileSync as copyFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, 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) {
+  return `${quote2(nodePath)} ${quote2(cliScriptPath)} codex-hook ${event}`;
+}
+function eventCommandFragment(event) {
+  return `codex-hook ${event}`;
+}
+function isSameHookCommand2(actual, expected) {
+  return actual === expected || actual.endsWith(` ${expected}`);
+}
+function isCaveatCodexHookCommand(actual, event) {
+  const lower = actual.toLowerCase();
+  return lower.includes("caveat") && actual.includes(eventCommandFragment(event));
+}
+function hasCaveatHook(hooksJson, event, fragment) {
+  return hooksJson.hooks?.[event]?.some(
+    (entry) => entry.hooks?.some((h) => h.command.includes(fragment))
+  ) ?? false;
+}
+function readHooks(path) {
+  if (!existsSync2(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] ??= [];
+  for (const entry of list) {
+    for (const hook of entry.hooks ?? []) {
+      if (isSameHookCommand2(hook.command, command)) return "unchanged";
+      if (isCaveatCodexHookCommand(hook.command, subcommand)) {
+        hook.command = command;
+        hook.timeoutSec = 5;
+        hook.async = false;
+        hook.statusMessage = null;
+        return "added";
+      }
+    }
+  }
+  list.push({
+    hooks: [
+      {
+        type: "command",
+        command,
+        timeoutSec: 5,
+        async: false,
+        statusMessage: null
+      }
+    ]
+  });
+  return "added";
+}
+function removeHook2(hooksJson, event, command, subcommand) {
+  const list = hooksJson.hooks?.[event];
+  if (!list) return false;
+  const before = list.length;
+  const filtered = list.filter(
+    (entry) => !entry.hooks?.some(
+      (h) => isSameHookCommand2(h.command, command) || isCaveatCodexHookCommand(h.command, subcommand)
+    )
+  );
+  if (filtered.length === before) return false;
+  hooksJson.hooks[event] = filtered;
+  return true;
+}
+function enableCodexHooksFeature(raw) {
+  let parsed;
+  try {
+    parsed = parseToml(raw);
+  } catch {
+    return {
+      status: "blocked",
+      text: raw,
+      changed: false,
+      reason: "config.toml is invalid TOML; fix it before installing Caveat hooks"
+    };
+  }
+  const featureValue = parsed.features;
+  if (featureValue !== void 0 && !isPlainRecord(featureValue)) {
+    return {
+      status: "blocked",
+      text: raw,
+      changed: false,
+      reason: "config.toml features value is not a table"
+    };
+  }
+  const features = featureValue;
+  const canonicalValue = features?.hooks;
+  const legacyValue = features?.codex_hooks;
+  if (canonicalValue !== void 0 && typeof canonicalValue !== "boolean") {
+    return { status: "blocked", text: raw, changed: false, reason: "[features].hooks must be boolean" };
+  }
+  if (legacyValue !== void 0 && typeof legacyValue !== "boolean") {
+    return { status: "blocked", text: raw, changed: false, reason: "[features].codex_hooks must be boolean" };
+  }
+  if (canonicalValue === false) {
+    return { status: "blocked", text: raw, changed: false, reason: "[features].hooks is explicitly false" };
+  }
+  if (legacyValue === false) {
+    return {
+      status: "blocked",
+      text: raw,
+      changed: false,
+      reason: canonicalValue === true ? "[features].hooks conflicts with the deprecated codex_hooks alias" : "[features].codex_hooks is explicitly false"
+    };
+  }
+  if (canonicalValue === true && legacyValue === void 0) {
+    return { status: "enabled", text: raw, changed: false };
+  }
+  const lines = raw.split(/\r?\n/);
+  const codeLines = maskTomlStringsAndComments(raw).split(/\r?\n/);
+  const featureHeaders = codeLines.map((line, index) => /^\s*\[\s*features\s*]\s*$/.test(line) ? index : -1).filter((index) => index >= 0);
+  if (featureValue === void 0) {
+    const prefix = raw.trimEnd();
+    const text = `${prefix}${prefix ? "\n\n" : ""}[features]
+hooks = true
+`;
+    return { status: "enabled", text, changed: true };
+  }
+  if (featureHeaders.length !== 1) {
+    return {
+      status: "blocked",
+      text: raw,
+      changed: false,
+      reason: "config.toml uses a features table shape that Caveat will not rewrite safely"
+    };
+  }
+  const featuresStart = featureHeaders[0];
+  const assignments = [];
+  for (let i = featuresStart + 1; i < lines.length; i += 1) {
+    if (/^\s*\[\[?/.test(codeLines[i])) {
+      break;
+    }
+    const assignment = /^\s*(hooks|codex_hooks)\s*=/.exec(codeLines[i]);
+    if (assignment) {
+      assignments.push({ index: i, key: assignment[1] });
+    }
+  }
+  const canonical = assignments.filter((assignment) => assignment.key === "hooks");
+  const legacy = assignments.filter((assignment) => assignment.key === "codex_hooks");
+  if (canonicalValue !== void 0 && canonical.length !== 1 || legacyValue !== void 0 && legacy.length !== 1) {
+    return {
+      status: "blocked",
+      text: raw,
+      changed: false,
+      reason: "[features].hooks uses a key shape that Caveat will not rewrite safely"
+    };
+  }
+  const current = canonical[0];
+  const deprecated = legacy[0];
+  if (canonicalValue === true && legacyValue === true && current && deprecated) {
+    const inlineComment = /(#.*)$/.exec(lines[deprecated.index])?.[1];
+    lines.splice(deprecated.index, 1);
+    if (inlineComment) {
+      const canonicalIndex = current.index > deprecated.index ? current.index - 1 : current.index;
+      lines.splice(canonicalIndex + 1, 0, inlineComment);
+    }
+    return { status: "enabled", text: `${lines.join("\n").trimEnd()}
+`, changed: true };
+  }
+  if (legacyValue === true && canonicalValue === void 0 && deprecated) {
+    lines[deprecated.index] = lines[deprecated.index].replace(/\bcodex_hooks\b/, "hooks");
+    return { status: "enabled", text: `${lines.join("\n").trimEnd()}
+`, changed: true };
+  }
+  lines.splice(featuresStart + 1, 0, "hooks = true");
+  return { status: "enabled", text: `${lines.join("\n").trimEnd()}
+`, changed: true };
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function maskTomlStringsAndComments(raw) {
+  let state = "code";
+  let output = "";
+  for (let i = 0; i < raw.length; i += 1) {
+    const char = raw[i];
+    const triple = raw.slice(i, i + 3);
+    if (char === "\n") {
+      output += "\n";
+      if (state === "comment") state = "code";
+      continue;
+    }
+    if (state === "comment") {
+      output += " ";
+      continue;
+    }
+    if (state === "basic") {
+      output += " ";
+      if (char === "\\" && i + 1 < raw.length) {
+        output += raw[i + 1] === "\n" ? "\n" : " ";
+        i += 1;
+      } else if (char === '"') state = "code";
+      continue;
+    }
+    if (state === "literal") {
+      output += " ";
+      if (char === "'") state = "code";
+      continue;
+    }
+    if (state === "multi-basic") {
+      if (triple === '"""') {
+        output += "   ";
+        i += 2;
+        state = "code";
+      } else {
+        output += " ";
+        if (char === "\\" && i + 1 < raw.length) {
+          output += raw[i + 1] === "\n" ? "\n" : " ";
+          i += 1;
+        }
+      }
+      continue;
+    }
+    if (state === "multi-literal") {
+      if (triple === "'''") {
+        output += "   ";
+        i += 2;
+        state = "code";
+      } else output += " ";
+      continue;
+    }
+    if (char === "#") {
+      output += " ";
+      state = "comment";
+    } else if (triple === '"""') {
+      output += "   ";
+      i += 2;
+      state = "multi-basic";
+    } else if (triple === "'''") {
+      output += "   ";
+      i += 2;
+      state = "multi-literal";
+    } else if (char === '"') {
+      output += " ";
+      state = "basic";
+    } else if (char === "'") {
+      output += " ";
+      state = "literal";
+    } else output += char;
+  }
+  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 enabled = enableCodexHooksFeature(rawConfig);
+  if (enabled.status === "blocked") {
+    return {
+      hooks: { userPromptSubmit: "skipped", postToolUse: "skipped", stop: "skipped" },
+      feature: "blocked",
+      blockedReason: enabled.reason
+    };
+  }
+  const hooksJson = readHooks(hooksPath);
+  const userPromptSubmit = upsertHook2(
+    hooksJson,
+    "UserPromptSubmit",
+    hookCommand2(opts.nodePath, opts.cliScriptPath, "user-prompt-submit"),
+    "user-prompt-submit"
+  );
+  const postToolUse = upsertHook2(
+    hooksJson,
+    "PostToolUse",
+    hookCommand2(opts.nodePath, opts.cliScriptPath, "post-tool-use"),
+    "post-tool-use"
+  );
+  const stop = upsertHook2(
+    hooksJson,
+    "Stop",
+    hookCommand2(opts.nodePath, opts.cliScriptPath, "stop"),
+    "stop"
+  );
+  const anyHookAdded = userPromptSubmit === "added" || postToolUse === "added" || stop === "added";
+  let backupPath;
+  let configBackupPath;
+  if (opts.dryRun) {
+    opts.logger.info(`[dry-run] would update ${hooksPath}`);
+    opts.logger.info(`[dry-run] would ensure [features].hooks = true in ${configPath}`);
+  } else {
+    if (anyHookAdded) {
+      const backup = writeJsonWithBackup(hooksPath, hooksJson);
+      if (backup) backupPath = backup;
+    }
+    if (enabled.changed) {
+      const backup = writeConfigWithBackup(configPath, enabled.text);
+      if (backup) configBackupPath = backup;
+    }
+  }
+  return {
+    hooks: { userPromptSubmit, postToolUse, stop },
+    feature: enabled.changed ? "enabled" : "unchanged",
+    backupPath,
+    configBackupPath
+  };
+}
+function uninstallCodexHooks(opts) {
+  const hooksPath = join4(opts.codexHome, "hooks.json");
+  const hooksJson = readHooks(hooksPath);
+  const userPromptSubmitRemoved = removeHook2(
+    hooksJson,
+    "UserPromptSubmit",
+    hookCommand2(opts.nodePath, opts.cliScriptPath, "user-prompt-submit"),
+    "user-prompt-submit"
+  );
+  const postToolUseRemoved = removeHook2(
+    hooksJson,
+    "PostToolUse",
+    hookCommand2(opts.nodePath, opts.cliScriptPath, "post-tool-use"),
+    "post-tool-use"
+  );
+  const stopRemoved = removeHook2(
+    hooksJson,
+    "Stop",
+    hookCommand2(opts.nodePath, opts.cliScriptPath, "stop"),
+    "stop"
+  );
+  let backupPath;
+  if (opts.dryRun) {
+    opts.logger.info(`[dry-run] would remove Caveat Codex hooks from ${hooksPath}`);
+  } else if (userPromptSubmitRemoved || postToolUseRemoved || stopRemoved) {
+    const backup = writeJsonWithBackup(hooksPath, hooksJson);
+    if (backup) backupPath = backup;
+  }
+  return {
+    hooks: {
+      userPromptSubmit: userPromptSubmitRemoved ? "added" : "unchanged",
+      postToolUse: postToolUseRemoved ? "added" : "unchanged",
+      stop: stopRemoved ? "added" : "unchanged"
+    },
+    feature: "unchanged",
+    backupPath
+  };
+}
+function detectCodexHookInstallation(codexHome) {
+  const hooksPath = join4(codexHome, "hooks.json");
+  const hooksJson = readHooks(hooksPath);
+  const hooks = {
+    userPromptSubmit: hasCaveatHook(
+      hooksJson,
+      "UserPromptSubmit",
+      eventCommandFragment("user-prompt-submit")
+    ),
+    postToolUse: hasCaveatHook(hooksJson, "PostToolUse", eventCommandFragment("post-tool-use")),
+    stop: hasCaveatHook(hooksJson, "Stop", eventCommandFragment("stop"))
+  };
+  const count = Object.values(hooks).filter(Boolean).length;
+  return {
+    installation: count === 0 ? "not-installed" : count === 3 ? "installed" : "partial",
+    hooksPath,
+    hooks
+  };
+}
+
+// src/ghSetup.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { readSync } from "node:fs";
+function runGh(args) {
+  const result = spawnSync2("gh", args, { encoding: "utf-8" });
+  return { status: result.status, stdout: typeof result.stdout === "string" ? result.stdout : "", stderr: typeof result.stderr === "string" ? result.stderr : "" };
+}
+function commandError(result, fallback) {
+  return new Error((result.stderr || result.stdout || fallback).trim());
+}
+function defaultGitHubRepoUrl(opts) {
+  const version2 = opts.ghRunner(["--version"]);
+  if (version2.status !== 0) {
+    throw new Error(
+      `gh is not available. create a ${opts.visibility} repository named ${opts.repositoryName} on GitHub, then run:
+  ${opts.retryCommand}
+  # or install gh and retry`
+    );
+  }
+  const user = opts.ghRunner(["api", "user", "-q", ".login"]);
+  if (user.status !== 0 || !user.stdout.trim()) {
+    throw new Error(`gh is not authenticated; run \`gh auth login\`, then retry \`${opts.retryCommand}\``);
+  }
+  const login = user.stdout.trim();
+  const qualifiedName = `${login}/${opts.repositoryName}`;
+  const view = opts.ghRunner(["repo", "view", qualifiedName]);
+  if (view.status !== 0) {
+    const question = `create ${opts.visibility} repo github.com/${qualifiedName}? [y/N]`;
+    if (!opts.yes) {
+      if (!opts.isTty()) {
+        throw new Error(`${question}; rerun with --yes to approve non-interactively`);
+      }
+      if (!opts.confirm(question)) throw new Error(`${opts.visibility} repository creation cancelled`);
+    }
+    const create = opts.ghRunner(["repo", "create", opts.repositoryName, `--${opts.visibility}`]);
+    if (create.status !== 0) throw commandError(create, "gh repo create failed");
+  }
+  return `https://github.com/${qualifiedName}.git`;
+}
+function askOnce(question) {
+  process.stdout.write(`${question} `);
+  const buf = Buffer.alloc(256);
+  const bytes = readSync(0, buf, 0, buf.length, null);
+  return /^(?:y|yes)$/i.test(buf.toString("utf-8", 0, bytes).trim());
+}
+
 // src/nodePath.ts
-import { existsSync as existsSync2, realpathSync } from "node:fs";
-import { delimiter, join as join4 } from "node:path";
+import { existsSync as existsSync3, realpathSync } from "node:fs";
+import { delimiter, join as join5 } from "node:path";
 var defaultRealpath = (path) => realpathSync.native(path);
 function safeRealpath(path, realpath = defaultRealpath) {
   try {
@@ -7076,7 +7516,7 @@ function resolveHookNodePath({
   env = process.env,
   execPath = process.execPath,
   platform = process.platform,
-  exists = existsSync2,
+  exists = existsSync3,
   realpath = defaultRealpath
 } = {}) {
   const execRealpath = safeRealpath(execPath, realpath);
@@ -7084,7 +7524,7 @@ function resolveHookNodePath({
   const names = platform === "win32" ? ["node.exe", "node.cmd", "node.bat", "node"] : ["node"];
   for (const dir of pathEnv.split(delimiter).filter(Boolean)) {
     for (const name of names) {
-      const candidate = join4(dir, name);
+      const candidate = join5(dir, name);
       if (!exists(candidate)) continue;
       const candidateRealpath = safeRealpath(candidate, realpath);
       if (execRealpath && candidateRealpath && candidateRealpath === execRealpath) {
@@ -7095,29 +7535,241 @@ function resolveHookNodePath({
   return execPath;
 }
 
+// src/commands/publish.ts
+import { existsSync as existsSync4 } 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 { tmpdir } from "node:os";
+import { join as join6 } from "node:path";
+function compactFailureMessage(message) {
+  const singleLine = message.replace(/\s+/g, " ").trim();
+  if (!singleLine) return "unknown error";
+  return singleLine.length > 220 ? `${singleLine.slice(0, 220)}...` : singleLine;
+}
+function formatCodexSidecarAdvisoryUnavailable(error51) {
+  const message = error51 instanceof Error ? error51.message : String(error51);
+  return `[caveat:codex-sidecar] advisory unavailable: ${compactFailureMessage(message)}`;
+}
+function sidecarFailureDetail(output) {
+  const protocol = output.match(/PROTOCOL_ERROR:[^"\r\n]+/);
+  if (protocol) return compactFailureMessage(protocol[0]);
+  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const diagnostic = lines.find(
+    (line) => !line.startsWith("[caveat] [codex-sidecar] codex-sidecar ")
+  );
+  return compactFailureMessage(diagnostic ?? output);
+}
+function runCodexSidecarAdvisory(input) {
+  const cliScript = process.argv[1];
+  if (!cliScript) {
+    return { status: "failed", message: "current Caveat CLI script path is unavailable" };
+  }
+  const args = [
+    ...process.execArgv,
+    "--disable-warning=ExperimentalWarning",
+    cliScript,
+    "codex-sidecar",
+    "run",
+    "explore",
+    input.prompt,
+    "--preset",
+    "advisory",
+    "--query",
+    input.searchText,
+    "--limit",
+    String(Math.max(1, input.limit)),
+    "--host-agent",
+    "claude",
+    "--availability",
+    "operational"
+  ];
+  let resultDir;
+  let advisory;
+  try {
+    resultDir = mkdtempSync(join6(tmpdir(), "caveat-codex-advisory-"));
+    const resultFile = join6(resultDir, "result.json");
+    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" });
+      args.push("--additional-context-file", additionalContextFile);
+    }
+    const nodeCli = process.env.CAVEAT_CODEX_SIDECAR_NODE_CLI;
+    if (nodeCli) {
+      args.push("--node-cli", nodeCli);
+    } else {
+      const command = process.env.CAVEAT_CODEX_SIDECAR_COMMAND;
+      if (command) args.push("--command", command);
+    }
+    const result = spawnSync3(process.execPath, args, {
+      cwd: input.projectRoot,
+      encoding: "utf-8",
+      timeout: Number(process.env.CAVEAT_HOOK_CODEX_SIDECAR_TIMEOUT_MS ?? 12e4),
+      maxBuffer: 10 * 1024 * 1024
+    });
+    if (result.error) {
+      advisory = { status: "failed", message: compactFailureMessage(result.error.message) };
+    } else if (result.status !== 0) {
+      const detail = (result.stderr || result.stdout || `exit ${result.status}`).trim();
+      advisory = {
+        status: "failed",
+        message: `sidecar command failed: ${sidecarFailureDetail(detail)}`
+      };
+    } else {
+      const parsed = JSON.parse(readFileSync4(resultFile, "utf-8"));
+      if (parsed.status !== "ok" || typeof parsed.summary !== "string") {
+        advisory = {
+          status: "failed",
+          message: compactFailureMessage(`unexpected SidecarResult status: ${String(parsed.status)}`)
+        };
+      } else {
+        advisory = {
+          status: "ok",
+          summary: parsed.summary,
+          ...typeof parsed.rawEventLogRef === "string" ? { rawEventLogRef: parsed.rawEventLogRef } : {}
+        };
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    advisory = {
+      status: "failed",
+      message: compactFailureMessage(`invalid SidecarResult JSON: ${msg}`)
+    };
+  } finally {
+    if (resultDir) {
+      try {
+        rmSync(resultDir, { recursive: true });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        advisory = {
+          status: "failed",
+          message: compactFailureMessage(`sidecar advisory cleanup failed: ${msg}`)
+        };
+      }
+    }
+  }
+  return advisory;
+}
+function formatCodexSidecarAdvisory(advisory) {
+  if (advisory.status === "ok") {
+    return [
+      "[caveat:codex-sidecar] Codex advisory:",
+      advisory.summary,
+      advisory.rawEventLogRef ? `rawEventLogRef: ${advisory.rawEventLogRef}` : ""
+    ].filter(Boolean).join("\n");
+  }
+  return `[caveat:codex-sidecar] advisory unavailable: ${advisory.message}`;
+}
+
+// src/commands/publish.ts
+var HTTPS_TARGET_RE = /^https:\/\/github\.com\/[^/]+\/[^/]+?(?:\.git)?\/?$/;
+var SCP_TARGET_RE = /^git@github\.com:[^/]+\/[^/]+?(?:\.git)?$/;
+function validatePublishTarget(url2) {
+  if (!HTTPS_TARGET_RE.test(url2) && !SCP_TARGET_RE.test(url2)) throw new Error("invalid publish target: use https://github.com/<org>/<repo>(.git) or git@github.com:<org>/<repo>(.git)");
+  return url2;
+}
+async function defaultPublicRepoUrl(opts, deps) {
+  return defaultGitHubRepoUrl({
+    repositoryName: "Caveat-Public",
+    visibility: "public",
+    yes: opts.yes,
+    retryCommand: "caveat publish --init <url>",
+    ...deps
+  });
+}
+async function runPublish(ctx, opts, dependencies = {}) {
+  try {
+    const ghRunner = dependencies.ghRunner ?? runGh;
+    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 publishAdvisory = hasCodexSidecarConfig(projectRoot) ? (changes) => {
+      try {
+        return dependencies.runCodexSidecarAdvisory?.(changes, projectRoot) ?? formatCodexSidecarAdvisory(runCodexSidecarAdvisory({
+          searchText: changes.lines.join("\n"),
+          limit: Math.max(changes.lines.length, 1),
+          projectRoot,
+          prompt: "A public Caveat publish is pending. Use Caveat context to give concise advice about privacy or secret risk. Advisory only: do not authorize or block this publish."
+        }));
+      } catch (err) {
+        return formatCodexSidecarAdvisoryUnavailable(err);
+      }
+    } : void 0;
+    let target = ctx.config.publishTarget;
+    if (opts.init !== void 0) {
+      target = validatePublishTarget(opts.init);
+      writeUserConfigPatch(ctx.userConfigPath, { publishTarget: target });
+    }
+    if (!target) {
+      target = await defaultPublicRepoUrl(opts, { ghRunner, isTty, confirm });
+      writeUserConfigPatch(ctx.userConfigPath, { publishTarget: target });
+    }
+    const result = await publishOwn({
+      paths: ctx.paths,
+      config: { ...ctx.config, publishTarget: target },
+      logger: ctx.logger,
+      confirmImpl: confirm,
+      isTty,
+      dryRun: opts.dryRun,
+      yes: opts.yes,
+      allow: opts.allow,
+      saveAllow: opts.save,
+      advisory: publishAdvisory
+    });
+    if (result.dryRun) ctx.logger.info(`[dry-run] ${result.fileCount} public entry(ies) ready to publish`);
+    else if (result.changed) ctx.logger.info(`published ${result.fileCount} public entry(ies)`);
+  } catch (err) {
+    if (err instanceof PublishScanError) {
+      for (const finding of err.findings) {
+        ctx.logger.error(`${finding.relPath}:${finding.line} ${finding.rule} ${finding.excerpt}`);
+        ctx.logger.error(`  --allow ${finding.matchDigest}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    ctx.logger.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  }
+}
+
 // src/commands/init.ts
-async function runInit(ctx, opts = { skipClaude: false, dryRun: false }) {
+async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, dependencies = {}) {
+  const isTty = dependencies.isTty ?? (() => Boolean(process.stdin.isTTY));
+  const confirm = dependencies.confirm ?? askOnce;
+  const ghRunner = dependencies.ghRunner ?? runGh;
+  let publishTarget = ctx.config.publishTarget;
+  let codexHookState = "not-installed";
   ensureUserConfig(ctx.userConfigPath);
   ctx.logger.info(`user config: ${ctx.userConfigPath}`);
-  if (!existsSync3(ctx.paths.knowledgeRepo)) {
-    mkdirSync2(ctx.paths.knowledgeRepo, { recursive: true });
-    mkdirSync2(ctx.paths.entriesDir, { recursive: true });
+  if (!existsSync5(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 = join5(ctx.paths.knowledgeRepo, ".gitignore");
-  if (!existsSync3(gitignorePath)) {
-    writeFileSync2(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
+  const gitignorePath = join8(ctx.paths.knowledgeRepo, ".gitignore");
+  if (!existsSync5(gitignorePath)) {
+    writeFileSync4(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
     ctx.logger.info(`.gitignore created: ${gitignorePath}`);
   }
   if (!opts.dryRun) {
-    const dbDir = dirname3(ctx.paths.dbPath);
-    if (!existsSync3(dbDir)) mkdirSync2(dbDir, { recursive: true });
+    const dbDir = dirname4(ctx.paths.dbPath);
+    if (!existsSync5(dbDir)) mkdirSync3(dbDir, { recursive: true });
+    const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
+    const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
+    for (const failure of failures) {
+      ctx.logger.warn(`${failure.source}: sealed key prewarm failed: ${errorMessage(failure.error)}`);
+    }
     const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
     try {
-      reindexAllSources({ db, paths: ctx.paths, logger: ctx.logger });
+      reindexAllSources({ db, paths: ctx.paths, logger: ctx.logger, keyProvider });
       writeDigestMarker(ctx.caveatHome, computeEntriesDigest(ctx.paths));
     } finally {
       db.close();
@@ -7140,39 +7792,179 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }) {
   ctx.logger.info(
     "tip: subscribe to a group repo with `caveat community add <github-url>`, then `caveat pull`."
   );
+  let syncRequested = opts.sync !== void 0 && opts.sync !== false;
+  let syncNudgeAccepted = false;
+  if (opts.sync === void 0 && isTty()) {
+    syncNudgeAccepted = confirm("private \u540C\u671F\u3092\u4ECA\u3059\u3050\u8A2D\u5B9A\u3059\u308B\uFF1F [y/N]");
+    syncRequested = syncNudgeAccepted;
+  }
+  if (syncRequested) {
+    try {
+      if (opts.dryRun) {
+        const target = typeof opts.sync === "string" ? opts.sync : "<user>/Caveat-Private";
+        ctx.logger.info(`[dry-run] would initialize private sync: ${target}`);
+      } else {
+        const url2 = typeof opts.sync === "string" ? opts.sync : defaultGitHubRepoUrl({
+          repositoryName: "Caveat-Private",
+          visibility: "private",
+          yes: (opts.yes ?? false) || syncNudgeAccepted,
+          retryCommand: "caveat init --sync <url>",
+          ghRunner,
+          isTty,
+          confirm
+        });
+        const result = await initOwnSync({
+          ownDir: ctx.paths.knowledgeRepo,
+          url: url2,
+          caveatHome: ctx.caveatHome,
+          paths: ctx.paths,
+          logger: ctx.logger,
+          // file: remotes are governed by local filesystem permissions and have
+          // no anonymous HTTP surface for the remote-visibility probe to inspect.
+          trustRemotePrivate: isFileRemote(url2)
+        });
+        ctx.logger.info(
+          result.remoteWasEmpty ? `initialized private sync remote: ${url2}` : `checked out existing private remote: ${url2} (branch ${result.branch})`
+        );
+      }
+    } catch (err) {
+      if (err instanceof SyncError && err.code === "OWN_REPO_EXISTS") {
+        ctx.logger.info("private sync already configured (own repo exists); skipped");
+      } else {
+        ctx.logger.warn(`private sync setup skipped: ${errorMessage(err)}`);
+      }
+    }
+  }
+  let publishRequested = opts.publishTarget !== void 0 && opts.publishTarget !== false;
+  let publishNudgeAccepted = false;
+  if (opts.publishTarget === void 0 && isTty()) {
+    publishNudgeAccepted = confirm("\u516C\u958B repo\uFF08\u5C01\u7DD8\u30DF\u30E9\u30FC\uFF09\u3082\u8A2D\u5B9A\u3059\u308B\uFF1F [y/N]");
+    publishRequested = publishNudgeAccepted;
+  }
+  if (publishRequested) {
+    try {
+      const requested = typeof opts.publishTarget === "string" ? validatePublishTarget(opts.publishTarget) : publishTarget;
+      const target = requested ?? (opts.dryRun ? "<user>/Caveat-Public" : defaultGitHubRepoUrl({
+        repositoryName: "Caveat-Public",
+        visibility: "public",
+        yes: (opts.yes ?? false) || publishNudgeAccepted,
+        retryCommand: "caveat init --publish-target <url>",
+        ghRunner,
+        isTty,
+        confirm
+      }));
+      if (opts.dryRun) {
+        ctx.logger.info(`[dry-run] would configure publish target: ${target}`);
+        publishTarget = target;
+      } else if (target === publishTarget) {
+        ctx.logger.info(`publish target already configured: ${target}`);
+      } else {
+        writeUserConfigPatch(ctx.userConfigPath, { publishTarget: target });
+        publishTarget = target;
+        ctx.logger.info(`publish target configured: ${target}`);
+      }
+    } catch (err) {
+      ctx.logger.warn(`publish target setup skipped: ${errorMessage(err)}`);
+    }
+  }
   if (opts.skipClaude) {
     ctx.logger.info("Claude Code integration skipped (--skip-claude)");
-    return;
+  } else {
+    const cliScriptPath = process.argv[1];
+    if (!cliScriptPath) {
+      ctx.logger.warn("cannot determine CLI script path; skipping Claude integration");
+    } else {
+      const result = installClaudeIntegration({
+        claudeDir: join8(ctx.userHome, ".claude"),
+        cliScriptPath,
+        nodePath: resolveHookNodePath(),
+        dryRun: opts.dryRun,
+        logger: ctx.logger
+      });
+      reportInstallResult(ctx, result, opts.dryRun);
+    }
   }
-  const cliScriptPath = process.argv[1];
-  if (!cliScriptPath) {
-    ctx.logger.warn("cannot determine CLI script path; skipping Claude integration");
-    return;
+  if (opts.skipCodexHook) {
+    codexHookState = "skipped";
+    ctx.logger.info("Codex hook integration skipped (--skip-codex-hook)");
+  } else if ((dependencies.codexAvailable ?? detectCodexAvailability)()) {
+    const cliScriptPath = process.argv[1];
+    if (!cliScriptPath) {
+      codexHookState = "skipped";
+      ctx.logger.warn("cannot determine CLI script path; skipping Codex hook integration");
+    } else {
+      const codexHome = join8(ctx.userHome, ".codex");
+      const result = installCodexHooks({
+        codexHome,
+        cliScriptPath,
+        nodePath: resolveHookNodePath(),
+        dryRun: opts.dryRun,
+        logger: ctx.logger
+      });
+      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\`.`
+        );
+      } else if (opts.dryRun) {
+        codexHookState = "skipped";
+        ctx.logger.info("[dry-run] would install Codex hooks");
+      } else {
+        codexHookState = detectCodexHookInstallation(codexHome).installation;
+      }
+    }
   }
-  const result = installClaudeIntegration({
-    claudeDir: join5(ctx.userHome, ".claude"),
-    cliScriptPath,
-    nodePath: resolveHookNodePath(),
-    dryRun: opts.dryRun,
-    logger: ctx.logger
+  reportEnvironmentSummary(ctx, publishTarget, codexHookState, opts.dryRun);
+}
+function detectCodexAvailability() {
+  const result = spawnSync4("codex --version", {
+    shell: true,
+    encoding: "utf-8",
+    stdio: "ignore"
   });
-  reportInstallResult(ctx, result, opts.dryRun);
+  return !result.error && result.status === 0;
+}
+function isFileRemote(url2) {
+  try {
+    return new URL(url2).protocol === "file:";
+  } catch {
+    return false;
+  }
+}
+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) {
+  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;
+  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}`);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
 }
 function migrateLegacyCommunityDir(ctx) {
-  const legacy = join5(ctx.paths.knowledgeRepo, "community");
+  const legacy = join8(ctx.paths.knowledgeRepo, "community");
   const current = ctx.paths.communityDir;
   if (legacy === current) return;
-  if (!existsSync3(legacy)) return;
-  if (existsSync3(current)) {
+  if (!existsSync5(legacy)) return;
+  if (existsSync5(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(join5(legacy, entry.name), join5(current, entry.name));
+    renameSync(join8(legacy, entry.name), join8(current, entry.name));
   }
   try {
     rmdirSync(legacy);
@@ -7187,7 +7979,7 @@ function runUninstall(ctx, opts) {
     process.exit(1);
   }
   const result = uninstallClaudeIntegration({
-    claudeDir: join5(ctx.userHome, ".claude"),
+    claudeDir: join8(ctx.userHome, ".claude"),
     cliScriptPath,
     nodePath: resolveHookNodePath(),
     dryRun: opts.dryRun,
@@ -7234,18 +8026,23 @@ function reportInstallResult(ctx, result, dryRun) {
 }
 
 // src/commands/indexCmd.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
-function runIndex(ctx, opts) {
-  const dbDir = dirname4(ctx.paths.dbPath);
-  if (!existsSync4(dbDir)) mkdirSync3(dbDir, { recursive: true });
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+async function runIndex(ctx, opts) {
+  const dbDir = dirname5(ctx.paths.dbPath);
+  if (!existsSync6(dbDir)) mkdirSync4(dbDir, { recursive: true });
+  const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
+  const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
+  for (const failure of failures) {
+    ctx.logger.warn(`${failure.source}: sealed key prewarm failed: ${errorMessage2(failure.error)}`);
+  }
   const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
   try {
     if (opts.full) {
       ctx.logger.info("full rebuild: DELETE FROM entries");
       rebuildAll(db);
     }
-    const result = reindexAllSources({ db, paths: ctx.paths, logger: ctx.logger });
+    const result = reindexAllSources({ db, paths: ctx.paths, logger: ctx.logger, keyProvider });
     for (const [source, scan] of Object.entries(result.perSource)) {
       if (source === "own") {
         ctx.logger.info(`own: +${scan.added} ~${scan.updated} -${scan.deleted}`);
@@ -7258,6 +8055,9 @@ function runIndex(ctx, opts) {
     db.close();
   }
 }
+function errorMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 
 // src/commands/search.ts
 function runSearch(ctx, opts) {
@@ -7405,7 +8205,7 @@ function runStats(ctx) {
 
 // src/commands/serve.ts
 async function runServe(opts) {
-  const { startServer } = await import("./server-DCE3ODHI.js");
+  const { startServer } = await import("./server-EASKBCNK.js");
   const { port, host } = startServer({ port: opts.port });
   process.stdout.write(`[caveat] web portal: http://${host}:${port}/
 `);
@@ -7784,15 +8584,15 @@ var makeIssue = (params) => {
       message: issueData.message
     };
   }
-  let errorMessage = "";
+  let errorMessage6 = "";
   const maps = errorMaps.filter((m) => !!m).slice().reverse();
   for (const map2 of maps) {
-    errorMessage = map2(fullIssue, { data, defaultError: errorMessage }).message;
+    errorMessage6 = map2(fullIssue, { data, defaultError: errorMessage6 }).message;
   }
   return {
     ...issueData,
     path: fullPath,
-    message: errorMessage
+    message: errorMessage6
   };
 };
 function addIssueToContext(ctx, issueData) {
@@ -27584,19 +28384,19 @@ var getRefs = (options) => {
 };
 
 // ../../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@4.4.3/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-function addErrorMessage(res, key, errorMessage, refs) {
+function addErrorMessage(res, key, errorMessage6, refs) {
   if (!refs?.errorMessages)
     return;
-  if (errorMessage) {
+  if (errorMessage6) {
     res.errorMessage = {
       ...res.errorMessage,
-      [key]: errorMessage
+      [key]: errorMessage6
     };
   }
 }
-function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+function setResponseValueAndErrors(res, key, value, errorMessage6, refs) {
   res[key] = value;
-  addErrorMessage(res, key, errorMessage, refs);
+  addErrorMessage(res, key, errorMessage6, refs);
 }
 
 // ../../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@4.4.3/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
@@ -28907,8 +29707,8 @@ var Protocol = class {
                   if (queuedMessage.type === "response") {
                     resolver(message);
                   } else {
-                    const errorMessage = message;
-                    const error51 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data);
+                    const errorMessage6 = message;
+                    const error51 = new McpError(errorMessage6.error.code, errorMessage6.error.message, errorMessage6.error.data);
                     resolver(error51);
                   }
                 } else {
@@ -30208,23 +31008,23 @@ var Server = class extends Protocol {
       const wrappedHandler = async (request, extra) => {
         const validatedRequest = safeParse2(CallToolRequestSchema, request);
         if (!validatedRequest.success) {
-          const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+          const errorMessage6 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage6}`);
         }
         const { params } = validatedRequest.data;
         const result = await Promise.resolve(handler(request, extra));
         if (params.task) {
           const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
           if (!taskValidationResult.success) {
-            const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+            const errorMessage6 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage6}`);
           }
           return taskValidationResult.data;
         }
         const validationResult = safeParse2(CallToolResultSchema, result);
         if (!validationResult.success) {
-          const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+          const errorMessage6 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage6}`);
         }
         return validationResult.data;
       };
@@ -30718,12 +31518,12 @@ var McpServer = class {
    * @param errorMessage - The error message.
    * @returns The tool error result.
    */
-  createToolError(errorMessage) {
+  createToolError(errorMessage6) {
     return {
       content: [
         {
           type: "text",
-          text: errorMessage
+          text: errorMessage6
         }
       ],
       isError: true
@@ -30741,8 +31541,8 @@ var McpServer = class {
     const parseResult = await safeParseAsync2(schemaToParse, args);
     if (!parseResult.success) {
       const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-      const errorMessage = getParseErrorMessage(error51);
-      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+      const errorMessage6 = getParseErrorMessage(error51);
+      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage6}`);
     }
     return parseResult.data;
   }
@@ -30766,8 +31566,8 @@ var McpServer = class {
     const parseResult = await safeParseAsync2(outputObj, result.structuredContent);
     if (!parseResult.success) {
       const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-      const errorMessage = getParseErrorMessage(error51);
-      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+      const errorMessage6 = getParseErrorMessage(error51);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage6}`);
     }
   }
   /**
@@ -30979,8 +31779,8 @@ var McpServer = class {
         const parseResult = await safeParseAsync2(argsObj, request.params.arguments);
         if (!parseResult.success) {
           const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-          const errorMessage = getParseErrorMessage(error51);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
+          const errorMessage6 = getParseErrorMessage(error51);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage6}`);
         }
         const args = parseResult.data;
         const cb = prompt.callback;
@@ -31477,11 +32277,11 @@ var StdioServerTransport = class {
 
 // ../mcp/dist/context.js
 import { homedir as homedir2 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join9 } from "node:path";
 function buildMcpContext(overrides = {}) {
   const userHome = overrides.userHome ?? homedir2();
   const caveatHome = overrides.caveatHome ?? findCaveatHome(userHome);
-  const userConfigPath = join6(userHome, ".caveatrc.json");
+  const userConfigPath = join9(userHome, ".caveatrc.json");
   const logger = overrides.logger ?? stderrLogger;
   const config2 = loadConfig(userConfigPath);
   const paths = resolvePaths(caveatHome, config2.knowledgeRepo, userHome);
@@ -31494,7 +32294,9 @@ var sourceFilter = external_exports.enum(["own", "community", "all"]);
 var confidenceSchema = external_exports.enum(["confirmed", "reproduced", "tentative"]);
 var visibilityFilter = external_exports.enum(["public", "private", "all"]);
 var searchInputShape = {
-  query: external_exports.string().describe("FTS query (3+ chars for trigram). Empty string lists without text filter."),
+  query: external_exports.string().describe(
+    "FTS query (3+ chars for trigram). Empty string lists without text filter. If a search returns 0 hits, retry with synonyms and Japanese/English paraphrases. Use plain tokens only; FTS operators are not supported."
+  ),
   filters: external_exports.object({
     tags: external_exports.array(external_exports.string()).optional(),
     confidence: external_exports.array(confidenceSchema).optional(),
@@ -31543,7 +32345,9 @@ var outcomeSchema = external_exports.enum(["resolved", "impossible"]);
 var visibilitySchema = external_exports.enum(["public", "private"]);
 var recordInputShape = {
   title: external_exports.string().min(1),
-  symptom: external_exports.string().min(1),
+  symptom: external_exports.string().min(1).describe(
+    "Describe the observed failure. Preserve raw errors and exact error strings verbatim; when a stable translation is known, also include the main symptom keywords in Japanese and English to improve retrieval. Do not force a full translation or guess at uncertain wording."
+  ),
   cause: external_exports.string().optional(),
   resolution: external_exports.string().optional(),
   evidence: external_exports.string().optional(),
@@ -31592,14 +32396,19 @@ var patchFrontmatterSchema = external_exports.object({
 });
 var updateInputShape = {
   id: external_exports.string(),
-  source: external_exports.string().optional(),
+  source: external_exports.string().optional().describe("Only own entries may be updated. community entries are subscriptions; edit them upstream."),
   patch: external_exports.object({
     frontmatter: patchFrontmatterSchema.optional(),
-    sections: external_exports.record(external_exports.string(), external_exports.string()).optional()
+    sections: external_exports.record(external_exports.string(), external_exports.string()).optional().describe(
+      "Patch H2 sections by heading. When changing the Symptom section, preserve raw errors and exact error strings verbatim; when a stable translation is known, also include the main symptom keywords in Japanese and English to improve retrieval. Do not force a full translation or guess at uncertain wording."
+    )
   })
 };
 function handleUpdate(ctx, args) {
   const source = args.source ?? "own";
+  if (source !== "own") {
+    throw new Error("community \u30A8\u30F3\u30C8\u30EA\u306F\u8CFC\u8AAD\u7269\u3067\u3059; \u7DE8\u96C6\u306F\u4E0A\u6D41\u3067\u884C\u3063\u3066\u304F\u3060\u3055\u3044");
+  }
   return updateEntry(args.id, args.patch, {
     db: ctx.db,
     entriesRoot: ctx.paths.entriesDir,
@@ -31616,13 +32425,12 @@ function handleListRecent(ctx, args) {
 }
 
 // ../mcp/dist/tools/pull.js
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
 var pullInputShape = {};
 async function handlePull(ctx, _args = {}) {
   const pulled = [];
   const indexed = [];
-  if (existsSync5(ctx.paths.communityDir)) {
+  if (existsSync7(ctx.paths.communityDir)) {
     const results = await communityPull({
       communityDir: ctx.paths.communityDir,
       logger: ctx.logger
@@ -31631,23 +32439,25 @@ async function handlePull(ctx, _args = {}) {
       pulled.push({ handle: r.handle, status: r.status, message: r.message });
     }
   }
-  rebuildAll(ctx.db);
-  if (existsSync5(ctx.paths.entriesDir)) {
-    const own = scanSource({ db: ctx.db, source: "own", entriesRoot: ctx.paths.entriesDir });
-    indexed.push({ source: "own", ...own });
+  const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
+  const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
+  for (const failure of failures) {
+    ctx.logger.warn(`${failure.source}: sealed key prewarm failed: ${errorMessage3(failure.error)}`);
   }
-  if (existsSync5(ctx.paths.communityDir)) {
-    for (const entry of readdirSync2(ctx.paths.communityDir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const source = `community/${entry.name}`;
-      const root = join7(ctx.paths.communityDir, entry.name, "entries");
-      if (!existsSync5(root)) continue;
-      const scan = scanSource({ db: ctx.db, source, entriesRoot: root });
-      indexed.push({ source, ...scan });
-    }
+  const result = reindexAllSources({
+    db: ctx.db,
+    paths: ctx.paths,
+    logger: ctx.logger,
+    keyProvider
+  });
+  for (const [source, scan] of Object.entries(result.perSource)) {
+    indexed.push({ source, ...scan });
   }
   return { pulled, indexed };
 }
+function errorMessage3(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 
 // ../mcp/dist/registerTools.js
 function jsonResult(data) {
@@ -31665,7 +32475,7 @@ function registerAllTools(server, ctx) {
     "caveat_search",
     {
       title: "caveat_search",
-      description: 'Search the "caveats" knowledge base \u2014 records of time-wasting traps in EXTERNAL specs (GPU/driver/CUDA versions, native-module builds, IDE/shell quirks, platform-specific behavior, library version incompatibilities) that someone already diagnosed. Call this FIRST when a problem smells environmental rather than a logic bug \u2014 before reading stack traces top-to-bottom or trying fixes. Query: 3+ chars, plain tokens only (no OR/NEAR/other FTS5 operators). Returns summary rows including `{id, source}` \u2014 pass BOTH to caveat_get for the full body.',
+      description: 'Search the "caveats" knowledge base \u2014 records of time-wasting traps someone already diagnosed, including external-spec issues (GPU/driver/CUDA versions, native-module builds, IDE/shell quirks, platform-specific behavior, library version incompatibilities) and reusable repo-specific context. Call this FIRST when a problem smells like a known trap \u2014 before reading stack traces top-to-bottom or trying fixes. Query: 3+ chars, plain tokens only (no OR/NEAR/other FTS5 operators). If it returns 0 hits, retry with synonyms and Japanese/English paraphrases. Returns summary rows including `{id, source}` \u2014 pass BOTH to caveat_get for the full body.',
       inputSchema: searchInputShape
     },
     async (args) => jsonResult(handleSearch(ctx, args))
@@ -31683,7 +32493,7 @@ function registerAllTools(server, ctx) {
     "caveat_record",
     {
       title: "caveat_record",
-      description: "Create a new caveat: a record of an external-spec trap that wasted real time (wrong driver, version mismatch, platform bug, IDE quirk, native-module issue, etc.) so future sessions can find it via caveat_search. REQUIRED BEFORE CALLING: (1) run caveat_search first to avoid duplicates, (2) ASK THE USER whether this should be `public` (shareable to the community DB) or `private` (kept local only) \u2014 never auto-classify visibility; the user owns the knowledge and decides its reach. Qualifies: specific symptom + diagnosed cause (or `outcome: impossible` verdict) + environment fingerprint. Does NOT qualify: project-internal bugs, user preferences, session summaries, ephemeral task notes. Auto-fills source_session and environment defaults; source_project is left null by design (shared knowledge must not leak per-user project names).",
+      description: "Create a new caveat: a reusable record of a time-wasting trap (wrong driver, version mismatch, platform bug, IDE quirk, native-module issue, or repo-specific context) so future sessions can find it via caveat_search. REQUIRED BEFORE CALLING: run caveat_search first to avoid duplicates. Set visibility using this binary criterion: `public` if a third party could reproduce it; `private` if it is repo/workflow-specific or depends on intentional local design; when unclear, prefer `private`; follow an explicit user visibility choice. Qualifies: specific symptom + diagnosed cause (or `outcome: impossible` verdict) + environment fingerprint. Does NOT qualify: ordinary project-internal logic bugs, user preferences, session summaries, or ephemeral task notes; reusable repo-specific traps may be `private`. Auto-fills source_session and environment defaults; source_project is left null by design (shared knowledge must not leak per-user project names).",
       inputSchema: recordInputShape
     },
     async (args) => jsonResult(handleRecord(ctx, args))
@@ -31692,7 +32502,7 @@ function registerAllTools(server, ctx) {
     "caveat_update",
     {
       title: "caveat_update",
-      description: "Patch an existing caveat \u2014 use when newer evidence extends or corrects one that already exists. Frontmatter shallow-merges, but array fields (tags etc.) REPLACE rather than append \u2014 to add one tag, read the current list first, then patch with the full new array. Sections match by case-insensitive H2 heading. Immutable keys: id, created_at, source_session, source_project. Common uses: bump `last_verified` after re-confirming, add a resolution when it was `tentative`, flip `outcome` to `impossible`.",
+      description: "Patch an existing caveat \u2014 use when newer evidence extends or corrects one that already exists. Frontmatter shallow-merges, but array fields (tags etc.) REPLACE rather than append \u2014 to add one tag, read the current list first, then patch with the full new array. Sections match by case-insensitive H2 heading. When changing `Symptom`, preserve raw errors verbatim and add stable Japanese/English symptom keywords when known; do not force or guess translations. Immutable keys: id, created_at, source_session, source_project. Common uses: bump `last_verified` after re-confirming, add a resolution when it was `tentative`, flip `outcome` to `impossible`.",
       inputSchema: updateInputShape
     },
     async (args) => jsonResult(handleUpdate(ctx, args))
@@ -31754,28 +32564,31 @@ async function runMcpServer() {
 }
 
 // src/commands/hookCmd.ts
-import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync4,
-  mkdtempSync,
-  readFileSync as readFileSync3,
-  rmSync,
-  unlinkSync,
-  writeFileSync as writeFileSync3
+  chmodSync,
+  existsSync as existsSync10,
+  lstatSync,
+  mkdtempSync as mkdtempSync2,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync5,
+  realpathSync as realpathSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync5
 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join9 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { basename, dirname as dirname6, join as join12 } from "node:path";
 import { createHash, randomBytes } from "node:crypto";
 
 // src/autoReindexTrigger.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join10 } from "node:path";
 function maybeTriggerAutoReindex(ctx) {
   if (process.env.CAVEAT_INDEX_AUTOSYNC === "off") return;
-  if (!existsSync6(ctx.paths.dbPath)) return;
-  if (existsSync6(join8(ctx.caveatHome, "index", ".reindex-lock"))) return;
+  if (!existsSync8(ctx.paths.dbPath)) return;
+  if (existsSync8(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;
@@ -31791,6 +32604,28 @@ function maybeTriggerAutoReindex(ctx) {
   child.unref();
 }
 
+// src/autoSyncTrigger.ts
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync9, statSync } from "node:fs";
+import { join as join11 } from "node:path";
+function maybeTriggerAutoSync(ctx) {
+  if (process.env[CAVEAT_AUTO_SYNC_ENV] === "off") return;
+  const statePath = join11(ctx.caveatHome, "sync", ".last-autosync.json");
+  const debounceMs = Number(process.env.CAVEAT_AUTO_SYNC_DEBOUNCE_MS ?? AUTO_SYNC_DEBOUNCE_MS);
+  try {
+    if (existsSync9(statePath) && Date.now() - statSync(statePath).mtimeMs < debounceMs) return;
+  } catch {
+  }
+  const cliScript = process.argv[1];
+  if (!cliScript) throw new Error("current Caveat CLI script path is unavailable");
+  const child = spawn2(
+    process.execPath,
+    [...process.execArgv, "--disable-warning=ExperimentalWarning", cliScript, "hook", "autosync"],
+    { detached: true, stdio: "ignore", windowsHide: true }
+  );
+  child.unref();
+}
+
 // src/commands/hookCmd.ts
 var silentLogger = {
   info: () => {
@@ -31835,31 +32670,44 @@ function buildContextSafely() {
     return null;
   }
 }
-function searchCaveatsFromTextSafely(text) {
+function searchCaveatsFromTextSafely(text, surface) {
   if (!text) return [];
   let db;
+  let caveatHome;
+  let hits;
   try {
     const ctx = buildContextSafely();
-    if (!ctx || !existsSync7(ctx.paths.dbPath)) return [];
+    if (!ctx || !existsSync10(ctx.paths.dbPath)) return [];
+    caveatHome = ctx.caveatHome;
     db = openDb({ path: ctx.paths.dbPath });
-    const hits = findCaveatsForPrompt(db, text, {
+    hits = findCaveatsForPrompt(db, text, {
       selfIdentity: defaultSelfIdentityTokens()
     });
-    if (hits.length > 0) {
-      try {
-        markHit(db, hits);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[caveat:hook] markHit error: ${msg}
-`);
-      }
-    }
-    return hits;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[caveat:hook] search error: ${msg}
 `);
     return [];
+  }
+  if (hits.length > 0) {
+    try {
+      markHit(db, hits);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[caveat:hook] markHit error: ${msg}
+`);
+    }
+  } else {
+    try {
+      logHookQueryMiss({ caveatHome, agent: "claude", surface, query: text });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[caveat:hook] query log error: ${msg}
+`);
+    }
+  }
+  try {
+    return hits;
   } finally {
     db?.close();
   }
@@ -31875,12 +32723,15 @@ function loadSignalsSafely(path) {
   }
 }
 function systemReminderOutput(text) {
-  return `<system-reminder>${text}</system-reminder>`;
+  return `<system-reminder>${text.replace(/</g, "\u2039").replace(/>/g, "\u203A")}</system-reminder>`;
 }
 function drainForSession(sessionId) {
   const ctx = buildContextSafely();
   if (!ctx) return [];
-  return drainPendingReminders(ctx.caveatHome, sessionId);
+  return [
+    ...drainPendingReminders(ctx.caveatHome, sessionId),
+    ...drainGlobalPendingReminders(ctx.caveatHome)
+  ];
 }
 function claudeContextDedupeKey(text) {
   if (text.startsWith(CLAUDE_STOP_REMINDER_PREFIX)) return "claude-stop-reminder";
@@ -31924,20 +32775,20 @@ function stopSignalKey(signals, related) {
   return createHash("sha256").update(body).digest("hex");
 }
 function stopStatePath(caveatHome, sessionId) {
-  return join9(caveatHome, CLAUDE_STOP_STATE_DIR, `${sanitizeClaudeStateId(sessionId)}.txt`);
+  return join12(caveatHome, CLAUDE_STOP_STATE_DIR, `${sanitizeClaudeStateId(sessionId)}.txt`);
 }
 function wasStopReminderQueued(caveatHome, sessionId, key) {
   const path = stopStatePath(caveatHome, sessionId);
   try {
-    return readFileSync3(path, "utf-8") === key;
+    return readFileSync5(path, "utf-8") === key;
   } catch {
     return false;
   }
 }
 function markStopReminderQueued(caveatHome, sessionId, key) {
   const path = stopStatePath(caveatHome, sessionId);
-  mkdirSync4(join9(caveatHome, CLAUDE_STOP_STATE_DIR), { recursive: true });
-  writeFileSync3(path, key, "utf-8");
+  mkdirSync5(join12(caveatHome, CLAUDE_STOP_STATE_DIR), { recursive: true });
+  writeFileSync5(path, key, "utf-8");
 }
 function queueStopForSession(sessionId, signals, related) {
   const ctx = buildContextSafely();
@@ -31986,23 +32837,34 @@ function isToolError(payload) {
   if (typeof payload.error === "string" && payload.error.length > 0) return true;
   return false;
 }
+var WORKER_STALE_MS = 24 * 60 * 60 * 1e3;
+var WORKER_ROOT = "caveat-worker-v1";
+var WORKER_MARKER = ".caveat-worker-schema-v1";
 function spawnWorker(job) {
-  const workFile = join9(
-    tmpdir(),
-    `caveat-worker-${Date.now()}-${randomBytes(4).toString("hex")}.json`
-  );
+  let root;
+  let workDir;
+  let workFile;
   try {
-    writeFileSync3(workFile, JSON.stringify(job), "utf-8");
+    root = workerRoot();
+    sweepStaleWorkerDirs(Date.now(), root);
+    workDir = mkdtempSync2(join12(root, "job-"));
+    chmodSync(workDir, 448);
+    workFile = join12(workDir, `${randomBytes(4).toString("hex")}.json`);
+    writeFileSync5(workFile, JSON.stringify({ ...job, schemaVersion: "caveat-worker-job/v1" }), { 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}
 `);
+    cleanupWorkerDir(workDir, workDir ? dirname6(workDir) : void 0);
     return;
   }
   const cliScript = process.argv[1];
-  if (!cliScript) return;
+  if (!cliScript) {
+    cleanupWorkerDir(workDir, root);
+    return;
+  }
   try {
-    const child = spawn2(
+    const child = spawn3(
       process.execPath,
       ["--disable-warning=ExperimentalWarning", cliScript, "hook", "worker", workFile],
       { detached: true, stdio: "ignore", windowsHide: true }
@@ -32013,7 +32875,7 @@ function spawnWorker(job) {
     process.stderr.write(`[caveat:hook] worker spawn error: ${msg}
 `);
     try {
-      unlinkSync(workFile);
+      cleanupWorkerDir(workDir, root);
     } catch {
     }
   }
@@ -32021,14 +32883,11 @@ function spawnWorker(job) {
 async function runWorker(workFile) {
   let raw;
   try {
-    raw = readFileSync3(workFile, "utf-8");
+    raw = readFileSync5(workFile, "utf-8");
   } catch {
     process.exit(0);
   }
-  try {
-    unlinkSync(workFile);
-  } catch {
-  }
+  cleanupWorkerDir(dirname6(workFile), dirname6(dirname6(workFile)));
   let job;
   try {
     job = JSON.parse(raw);
@@ -32036,7 +32895,7 @@ async function runWorker(workFile) {
     process.exit(0);
   }
   if (!job.searchText || !job.sessionId) process.exit(0);
-  const hits = searchCaveatsFromTextSafely(job.searchText);
+  const hits = searchCaveatsFromTextSafely(job.searchText, "tool_error");
   if (hits.length === 0) process.exit(0);
   const ctx = buildContextSafely();
   if (!ctx) process.exit(0);
@@ -32046,22 +32905,101 @@ async function runWorker(workFile) {
   }
   process.exit(0);
 }
+function cleanupWorkerDir(workDir, root) {
+  if (!workDir || !root || !isOwnedWorkerDir(workDir, root)) return;
+  try {
+    rmSync2(workDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function isOwnedWorkerDir(path, root = workerRoot()) {
+  try {
+    const inputStat = lstatSync(path);
+    if (inputStat.isSymbolicLink()) return false;
+    const tmpRoot = realpathSync2(root);
+    const resolved = realpathSync2(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);
+  } catch {
+    return false;
+  }
+}
+function sweepStaleWorkerDirs(now = Date.now(), root = workerRoot()) {
+  let entries;
+  try {
+    entries = readdirSync2(root);
+  } catch {
+    process.stderr.write("[caveat:hook] worker stale cleanup failed\n");
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("job-")) continue;
+    const path = join12(root, entry);
+    try {
+      if (!isOwnedWorkerDir(path, root)) continue;
+      const stat = lstatSync(path);
+      if (now - stat.mtimeMs <= WORKER_STALE_MS || !isStaleWorkerJobDir(path)) continue;
+      rmSync2(path, { recursive: true, force: true });
+    } catch {
+      process.stderr.write("[caveat:hook] worker stale cleanup failed\n");
+    }
+  }
+}
+function workerRoot(base = tmpdir2()) {
+  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 = 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");
+  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 stat = lstatSync(file2);
+  const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+  if (!stat.isFile() || stat.isSymbolicLink() || !hasPrivateOwnership(stat, uid)) return false;
+  return isWorkerJob(JSON.parse(readFileSync5(file2, "utf-8")));
+}
+function hasPrivateOwnership(stat, uid) {
+  return process.platform === "win32" || (stat.mode & 63) === 0 && (uid === void 0 || stat.uid === uid);
+}
+function isWorkerJob(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const job = value;
+  const keys = Object.keys(job).sort();
+  if (!(keys.length === 3 && keys.join(",") === "schemaVersion,searchText,sessionId") && !(keys.length === 4 && keys.join(",") === "additionalContext,schemaVersion,searchText,sessionId")) return false;
+  return job.schemaVersion === "caveat-worker-job/v1" && typeof job.sessionId === "string" && typeof job.searchText === "string" && (job.additionalContext === void 0 || job.additionalContext !== null && typeof job.additionalContext === "object" && !Array.isArray(job.additionalContext));
+}
 function writeLastReindex(caveatHome, value) {
   try {
-    writeFileSync3(join9(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}
 `);
   }
 }
-function runReindexWorker() {
+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 || !existsSync7(ctx.paths.dbPath)) {
+  if (!ctx || !existsSync10(ctx.paths.dbPath)) {
     process.stderr.write("[caveat:hook] auto reindex skipped: index database does not exist\n");
     return;
   }
@@ -32071,8 +33009,14 @@ function runReindexWorker() {
   let db;
   try {
     const digest = computeEntriesDigest(ctx.paths);
+    const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
+    const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
+    for (const failure of failures) {
+      process.stderr.write(`[caveat:hook] ${failure.source}: sealed key prewarm failed: ${errorMessage4(failure.error)}
+`);
+    }
     db = openDb({ path: ctx.paths.dbPath, logger: silentLogger });
-    const result = reindexAllSources({ db, paths: ctx.paths, logger: silentLogger });
+    const result = reindexAllSources({ db, paths: ctx.paths, logger: silentLogger, keyProvider });
     writeDigestMarker(ctx.caveatHome, digest);
     writeLastReindex(ctx.caveatHome, {
       startedAt,
@@ -32099,12 +33043,31 @@ function runReindexWorker() {
     }
   }
 }
+async function runAutoSyncWorker() {
+  if (process.env[CAVEAT_AUTO_SYNC_ENV] === "off") {
+    process.stderr.write("[caveat:hook] auto sync disabled by CAVEAT_AUTO_SYNC=off\n");
+    return;
+  }
+  const ctx = buildContextSafely();
+  if (!ctx) return;
+  try {
+    await runAutoSync({
+      caveatHome: ctx.caveatHome,
+      ownDir: ctx.paths.knowledgeRepo,
+      paths: ctx.paths,
+      logger: silentLogger
+    });
+  } catch (err) {
+    process.stderr.write(`[caveat:hook] auto sync error: ${errorMessage4(err)}
+`);
+  }
+}
 function buildToolErrorReminder(job, hits) {
   const base = toolErrorReminderText(hits);
   const mode = hookCodexSidecarMode();
   if (mode === "off") return base;
   const projectRoot = process.cwd();
-  const hasSidecarConfig = existsSync7(join9(projectRoot, ".codex-sidecar.yml"));
+  const hasSidecarConfig = existsSync10(join12(projectRoot, ".codex-sidecar.yml"));
   if (mode === "auto" && !hasSidecarConfig) return base;
   const advisory = runCodexSidecarAdvisory({
     searchText: job.searchText,
@@ -32114,21 +33077,20 @@ function buildToolErrorReminder(job, hits) {
       "A Claude Code tool just returned an error.",
       "Use the provided Caveat context to give concise next-step advice.",
       "Do not tell Claude to search Caveat again unless the context is insufficient."
-    ].join(" ")
+    ].join(" "),
+    additionalContext: job.additionalContext
   });
   if (advisory.status === "ok") {
     return [
       base,
       "",
-      "[caveat:codex-sidecar] Codex advisory:",
-      advisory.summary,
-      advisory.rawEventLogRef ? `rawEventLogRef: ${advisory.rawEventLogRef}` : ""
+      formatCodexSidecarAdvisory(advisory)
     ].filter(Boolean).join("\n");
   }
   return [
     base,
     "",
-    `[caveat:codex-sidecar] advisory unavailable: ${advisory.message}`
+    formatCodexSidecarAdvisory(advisory)
   ].join("\n");
 }
 function hookCodexSidecarMode() {
@@ -32141,7 +33103,7 @@ function buildStopReminder(signals, related) {
   const mode = hookCodexSidecarMode();
   if (mode === "off") return base;
   const projectRoot = process.cwd();
-  const hasSidecarConfig = existsSync7(join9(projectRoot, ".codex-sidecar.yml"));
+  const hasSidecarConfig = existsSync10(join12(projectRoot, ".codex-sidecar.yml"));
   if (mode === "auto" && !hasSidecarConfig) return base;
   const advisory = runCodexSidecarAdvisory({
     searchText: struggleSearchText(signals),
@@ -32149,115 +33111,44 @@ function buildStopReminder(signals, related) {
     projectRoot,
     prompt: [
       "A Claude Code session is ending after objective struggle signals.",
-      "Use the provided Caveat context and the signal text to advise whether Claude should update an existing caveat or record a new one.",
+      "Use the provided Caveat context and structured hook signal context to advise whether Claude should update an existing caveat or record a new one.",
       "Be concise and preserve Caveat visibility rules."
-    ].join(" ")
+    ].join(" "),
+    additionalContext: buildHookSignalSidecarContextBlock({
+      type: "stop",
+      toolFailureCount: signals.toolFailureCount,
+      reeditedFileCount: signals.fileEditCounts.length,
+      webSearchCount: signals.webSearchCount,
+      webFetchCount: signals.webFetchCount,
+      bashRetryCount: signals.bashRetryCount,
+      durationMinutes: signals.durationMinutes
+    })
   });
   if (advisory.status === "ok") {
     return [
       base,
       "",
-      "[caveat:codex-sidecar] Codex advisory:",
-      advisory.summary,
-      advisory.rawEventLogRef ? `rawEventLogRef: ${advisory.rawEventLogRef}` : ""
+      formatCodexSidecarAdvisory(advisory)
     ].filter(Boolean).join("\n");
   }
   return [
     base,
     "",
-    `[caveat:codex-sidecar] advisory unavailable: ${advisory.message}`
+    formatCodexSidecarAdvisory(advisory)
   ].join("\n");
 }
-function compactFailureMessage(message) {
-  const singleLine = message.replace(/\s+/g, " ").trim();
-  if (!singleLine) return "unknown error";
-  return singleLine.length > 220 ? `${singleLine.slice(0, 220)}...` : singleLine;
-}
-function sidecarFailureDetail(output) {
-  const protocol = output.match(/PROTOCOL_ERROR:[^"\r\n]+/);
-  if (protocol) return compactFailureMessage(protocol[0]);
-  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  const diagnostic = lines.find(
-    (line) => !line.startsWith("[caveat] [codex-sidecar] codex-sidecar ")
-  );
-  return compactFailureMessage(diagnostic ?? output);
-}
-function runCodexSidecarAdvisory(input) {
-  const cliScript = process.argv[1];
-  if (!cliScript) {
-    return { status: "failed", message: "current Caveat CLI script path is unavailable" };
-  }
-  const args = [
-    ...process.execArgv,
-    "--disable-warning=ExperimentalWarning",
-    cliScript,
-    "codex-sidecar",
-    "run",
-    "explore",
-    input.prompt,
-    "--preset",
-    "advisory",
-    "--query",
-    input.searchText,
-    "--limit",
-    String(Math.max(1, input.limit)),
-    "--host-agent",
-    "claude",
-    "--availability",
-    "operational"
-  ];
-  const resultDir = mkdtempSync(join9(tmpdir(), "caveat-codex-advisory-"));
-  const resultFile = join9(resultDir, "result.json");
-  args.push("--save-result", resultFile);
-  const nodeCli = process.env.CAVEAT_CODEX_SIDECAR_NODE_CLI;
-  if (nodeCli) {
-    args.push("--node-cli", nodeCli);
-  } else {
-    const command = process.env.CAVEAT_CODEX_SIDECAR_COMMAND;
-    if (command) args.push("--command", command);
-  }
+async function runHook(name, arg) {
   try {
-    const result = spawnSync2(process.execPath, args, {
-      cwd: input.projectRoot,
-      encoding: "utf-8",
-      timeout: Number(process.env.CAVEAT_HOOK_CODEX_SIDECAR_TIMEOUT_MS ?? 12e4),
-      maxBuffer: 10 * 1024 * 1024
-    });
-    if (result.error) {
-      return { status: "failed", message: compactFailureMessage(result.error.message) };
-    }
-    if (result.status !== 0) {
-      const detail = (result.stderr || result.stdout || `exit ${result.status}`).trim();
-      return {
-        status: "failed",
-        message: `sidecar command failed: ${sidecarFailureDetail(detail)}`
-      };
-    }
-    const parsed = JSON.parse(readFileSync3(resultFile, "utf-8"));
-    if (parsed.status !== "ok" || typeof parsed.summary !== "string") {
-      return {
-        status: "failed",
-        message: compactFailureMessage(`unexpected SidecarResult status: ${String(parsed.status)}`)
-      };
-    }
-    return {
-      status: "ok",
-      summary: parsed.summary,
-      ...typeof parsed.rawEventLogRef === "string" ? { rawEventLogRef: parsed.rawEventLogRef } : {}
-    };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return {
-      status: "failed",
-      message: compactFailureMessage(`invalid SidecarResult JSON: ${msg}`)
-    };
-  } finally {
-    rmSync(resultDir, { recursive: true, force: true });
+    sweepStaleWorkerDirs();
+  } catch {
+    process.stderr.write("[caveat:hook] worker stale cleanup failed\n");
   }
-}
-async function runHook(name, arg) {
   if (name === "reindex") {
-    runReindexWorker();
+    await runReindexWorker();
+    process.exit(0);
+  }
+  if (name === "autosync") {
+    await runAutoSyncWorker();
     process.exit(0);
   }
   if (name === "worker") {
@@ -32279,7 +33170,7 @@ async function runHook(name, arg) {
   const contexts = name === "stop" ? [] : drainForSession(sessionId);
   if (name === "user-prompt-submit") {
     const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
-    const hits = searchCaveatsFromTextSafely(prompt);
+    const hits = searchCaveatsFromTextSafely(prompt, "user_prompt");
     if (hits.length > 0) {
       contexts.push(userPromptSubmitReminderText(hits));
     }
@@ -32301,7 +33192,13 @@ async function runHook(name, arg) {
       payload.tool_response ?? payload.toolResponse ?? payload.error ?? payload
     );
     if (errText) {
-      spawnWorker({ sessionId, searchText: errText });
+      const failureKind = payload.hook_event_name === "PostToolUseFailure" ? "post-tool-use-failure" : "error-bearing-post-tool-use";
+      const additionalContext = buildHookSignalSidecarContextBlock({
+        type: "tool-error",
+        toolName: payload.tool_name ?? payload.toolName,
+        failureKind
+      });
+      spawnWorker({ sessionId, searchText: errText, ...additionalContext ? { additionalContext } : {} });
     }
     process.exit(0);
   }
@@ -32320,6 +33217,13 @@ async function runHook(name, arg) {
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         process.stderr.write(`[caveat:hook] auto reindex trigger error: ${msg}
+`);
+      }
+      try {
+        maybeTriggerAutoSync(ctx);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[caveat:hook] auto sync trigger error: ${msg}
 `);
       }
     }
@@ -32327,7 +33231,7 @@ 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 = searchCaveatsFromTextSafely(struggleSearchText(signals));
+    const related = searchCaveatsFromTextSafely(struggleSearchText(signals), "stop");
     queueStopForSession(sessionId, signals, related);
     process.exit(0);
   }
@@ -32337,236 +33241,11 @@ async function runHook(name, arg) {
 }
 
 // src/commands/codexHookCmd.ts
-import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
-import { join as join11 } from "node:path";
+import { spawn as spawn4, spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync6, 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 { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
-
-// src/codexHookInstall.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname5, join as join10 } from "node:path";
-function quote2(p) {
-  return p.includes(" ") ? `"${p}"` : p;
-}
-function hookCommand2(nodePath, cliScriptPath, event) {
-  return `${quote2(nodePath)} ${quote2(cliScriptPath)} codex-hook ${event}`;
-}
-function eventCommandFragment(event) {
-  return `codex-hook ${event}`;
-}
-function isSameHookCommand2(actual, expected) {
-  return actual === expected || actual.endsWith(` ${expected}`);
-}
-function isCaveatCodexHookCommand(actual, event) {
-  const lower = actual.toLowerCase();
-  return lower.includes("caveat") && actual.includes(eventCommandFragment(event));
-}
-function hasCaveatHook(hooksJson, event, fragment) {
-  return hooksJson.hooks?.[event]?.some(
-    (entry) => entry.hooks?.some((h) => h.command.includes(fragment))
-  ) ?? false;
-}
-function readHooks(path) {
-  if (!existsSync8(path)) return {};
-  return JSON.parse(readFileSync4(path, "utf-8"));
-}
-function writeJsonWithBackup(path, value) {
-  const dir = dirname5(path);
-  if (!existsSync8(dir)) mkdirSync5(dir, { recursive: true });
-  let backupPath = "";
-  if (existsSync8(path)) {
-    backupPath = `${path}.caveat-backup-${Date.now()}`;
-    copyFileSync2(path, backupPath);
-  }
-  writeFileSync4(path, `${JSON.stringify(value, null, 2)}
-`, "utf-8");
-  return backupPath;
-}
-function upsertHook2(hooksJson, event, command, subcommand) {
-  hooksJson.hooks ??= {};
-  const list = hooksJson.hooks[event] ??= [];
-  for (const entry of list) {
-    for (const hook of entry.hooks ?? []) {
-      if (isSameHookCommand2(hook.command, command)) return "unchanged";
-      if (isCaveatCodexHookCommand(hook.command, subcommand)) {
-        hook.command = command;
-        hook.timeoutSec = 5;
-        hook.async = false;
-        hook.statusMessage = null;
-        return "added";
-      }
-    }
-  }
-  list.push({
-    hooks: [
-      {
-        type: "command",
-        command,
-        timeoutSec: 5,
-        async: false,
-        statusMessage: null
-      }
-    ]
-  });
-  return "added";
-}
-function removeHook2(hooksJson, event, command, subcommand) {
-  const list = hooksJson.hooks?.[event];
-  if (!list) return false;
-  const before = list.length;
-  const filtered = list.filter(
-    (entry) => !entry.hooks?.some(
-      (h) => isSameHookCommand2(h.command, command) || isCaveatCodexHookCommand(h.command, subcommand)
-    )
-  );
-  if (filtered.length === before) return false;
-  hooksJson.hooks[event] = filtered;
-  return true;
-}
-function enableCodexHooksFeature(raw) {
-  if (/^\s*codex_hooks\s*=\s*true\s*$/m.test(raw)) return { text: raw, changed: false };
-  const lines = raw.split(/\r?\n/);
-  const featuresStart = lines.findIndex((line) => /^\s*\[features]\s*$/.test(line));
-  if (featuresStart === -1) {
-    const prefix = raw.trimEnd();
-    const text = `${prefix}${prefix ? "\n\n" : ""}[features]
-codex_hooks = true
-`;
-    return { text, changed: true };
-  }
-  let insertAt = featuresStart + 1;
-  for (let i = featuresStart + 1; i < lines.length; i += 1) {
-    if (/^\s*\[.+]\s*$/.test(lines[i])) {
-      break;
-    }
-    if (/^\s*codex_hooks\s*=/.test(lines[i])) {
-      lines[i] = "codex_hooks = true";
-      return { text: `${lines.join("\n").trimEnd()}
-`, changed: true };
-    }
-  }
-  lines.splice(insertAt, 0, "codex_hooks = true");
-  return { text: `${lines.join("\n").trimEnd()}
-`, changed: true };
-}
-function writeConfigWithBackup(path, text) {
-  const dir = dirname5(path);
-  if (!existsSync8(dir)) mkdirSync5(dir, { recursive: true });
-  let backupPath = "";
-  if (existsSync8(path)) {
-    backupPath = `${path}.caveat-backup-${Date.now()}`;
-    copyFileSync2(path, backupPath);
-  }
-  writeFileSync4(path, text, "utf-8");
-  return backupPath;
-}
-function installCodexHooks(opts) {
-  const hooksPath = join10(opts.codexHome, "hooks.json");
-  const configPath = join10(opts.codexHome, "config.toml");
-  const hooksJson = readHooks(hooksPath);
-  const userPromptSubmit = upsertHook2(
-    hooksJson,
-    "UserPromptSubmit",
-    hookCommand2(opts.nodePath, opts.cliScriptPath, "user-prompt-submit"),
-    "user-prompt-submit"
-  );
-  const postToolUse = upsertHook2(
-    hooksJson,
-    "PostToolUse",
-    hookCommand2(opts.nodePath, opts.cliScriptPath, "post-tool-use"),
-    "post-tool-use"
-  );
-  const stop = upsertHook2(
-    hooksJson,
-    "Stop",
-    hookCommand2(opts.nodePath, opts.cliScriptPath, "stop"),
-    "stop"
-  );
-  const rawConfig = existsSync8(configPath) ? readFileSync4(configPath, "utf-8") : "";
-  const enabled = enableCodexHooksFeature(rawConfig);
-  const anyHookAdded = userPromptSubmit === "added" || postToolUse === "added" || stop === "added";
-  let backupPath;
-  let configBackupPath;
-  if (opts.dryRun) {
-    opts.logger.info(`[dry-run] would update ${hooksPath}`);
-    opts.logger.info(`[dry-run] would ensure [features].codex_hooks = true in ${configPath}`);
-  } else {
-    if (anyHookAdded) {
-      const backup = writeJsonWithBackup(hooksPath, hooksJson);
-      if (backup) backupPath = backup;
-    }
-    if (enabled.changed) {
-      const backup = writeConfigWithBackup(configPath, enabled.text);
-      if (backup) configBackupPath = backup;
-    }
-  }
-  return {
-    hooks: { userPromptSubmit, postToolUse, stop },
-    feature: enabled.changed ? "enabled" : "unchanged",
-    backupPath,
-    configBackupPath
-  };
-}
-function uninstallCodexHooks(opts) {
-  const hooksPath = join10(opts.codexHome, "hooks.json");
-  const hooksJson = readHooks(hooksPath);
-  const userPromptSubmitRemoved = removeHook2(
-    hooksJson,
-    "UserPromptSubmit",
-    hookCommand2(opts.nodePath, opts.cliScriptPath, "user-prompt-submit"),
-    "user-prompt-submit"
-  );
-  const postToolUseRemoved = removeHook2(
-    hooksJson,
-    "PostToolUse",
-    hookCommand2(opts.nodePath, opts.cliScriptPath, "post-tool-use"),
-    "post-tool-use"
-  );
-  const stopRemoved = removeHook2(
-    hooksJson,
-    "Stop",
-    hookCommand2(opts.nodePath, opts.cliScriptPath, "stop"),
-    "stop"
-  );
-  let backupPath;
-  if (opts.dryRun) {
-    opts.logger.info(`[dry-run] would remove Caveat Codex hooks from ${hooksPath}`);
-  } else if (userPromptSubmitRemoved || postToolUseRemoved || stopRemoved) {
-    const backup = writeJsonWithBackup(hooksPath, hooksJson);
-    if (backup) backupPath = backup;
-  }
-  return {
-    hooks: {
-      userPromptSubmit: userPromptSubmitRemoved ? "added" : "unchanged",
-      postToolUse: postToolUseRemoved ? "added" : "unchanged",
-      stop: stopRemoved ? "added" : "unchanged"
-    },
-    feature: "unchanged",
-    backupPath
-  };
-}
-function detectCodexHookInstallation(codexHome) {
-  const hooksPath = join10(codexHome, "hooks.json");
-  const hooksJson = readHooks(hooksPath);
-  const hooks = {
-    userPromptSubmit: hasCaveatHook(
-      hooksJson,
-      "UserPromptSubmit",
-      eventCommandFragment("user-prompt-submit")
-    ),
-    postToolUse: hasCaveatHook(hooksJson, "PostToolUse", eventCommandFragment("post-tool-use")),
-    stop: hasCaveatHook(hooksJson, "Stop", eventCommandFragment("stop"))
-  };
-  const count = Object.values(hooks).filter(Boolean).length;
-  return {
-    installation: count === 0 ? "not-installed" : count === 3 ? "installed" : "partial",
-    hooksPath,
-    hooks
-  };
-}
-
-// src/commands/codexHookCmd.ts
 var silentLogger2 = {
   info: () => {
   },
@@ -32606,31 +33285,44 @@ function buildContextSafely2() {
     return null;
   }
 }
-function searchCaveatsFromTextSafely2(text) {
+function searchCaveatsFromTextSafely2(text, surface) {
   if (!text) return [];
   let db;
+  let caveatHome;
+  let hits;
   try {
     const ctx = buildContextSafely2();
-    if (!ctx || !existsSync9(ctx.paths.dbPath)) return [];
+    if (!ctx || !existsSync11(ctx.paths.dbPath)) return [];
+    caveatHome = ctx.caveatHome;
     db = openDb({ path: ctx.paths.dbPath });
-    const hits = findCaveatsForPrompt(db, text, {
+    hits = findCaveatsForPrompt(db, text, {
       selfIdentity: defaultSelfIdentityTokens()
     });
-    if (hits.length > 0) {
-      try {
-        markHit(db, hits);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[caveat:codex-hook] markHit error: ${msg}
-`);
-      }
-    }
-    return hits;
   } catch (err) {
     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) {
+      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, query: text });
+    } catch (err) {
+      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();
   }
@@ -32680,10 +33372,10 @@ function processExitCodeFromText(text) {
   return m ? Number(m[1]) : null;
 }
 function transcriptToolOutput(transcriptPath, toolUseId) {
-  if (!transcriptPath || !toolUseId || !existsSync9(transcriptPath)) return null;
+  if (!transcriptPath || !toolUseId || !existsSync11(transcriptPath)) return null;
   let raw = "";
   try {
-    raw = readFileSync5(transcriptPath, "utf-8");
+    raw = readFileSync6(transcriptPath, "utf-8");
   } catch {
     return null;
   }
@@ -32779,7 +33471,10 @@ function codexContextOutput(text, eventName = "UserPromptSubmit") {
 function drainForSession2(sessionId) {
   const ctx = buildContextSafely2();
   if (!ctx) return [];
-  return drainPendingReminders(ctx.caveatHome, sessionId);
+  return [
+    ...drainPendingReminders(ctx.caveatHome, sessionId),
+    ...drainGlobalPendingReminders(ctx.caveatHome)
+  ];
 }
 function codexContextDedupeKey(text) {
   if (text.startsWith(CODEX_STOP_REMINDER_PREFIX)) return "codex-stop-reminder";
@@ -32821,20 +33516,20 @@ function stopSignalKey2(signals, related) {
   return createHash2("sha256").update(body).digest("hex");
 }
 function stopStatePath2(caveatHome, sessionId) {
-  return join11(caveatHome, CODEX_STOP_STATE_DIR, `${sanitizeCodexStateId(sessionId)}.txt`);
+  return join13(caveatHome, CODEX_STOP_STATE_DIR, `${sanitizeCodexStateId(sessionId)}.txt`);
 }
 function wasStopReminderQueued2(caveatHome, sessionId, key) {
   const path = stopStatePath2(caveatHome, sessionId);
   try {
-    return readFileSync5(path, "utf-8") === key;
+    return readFileSync6(path, "utf-8") === key;
   } catch {
     return false;
   }
 }
 function markStopReminderQueued2(caveatHome, sessionId, key) {
   const path = stopStatePath2(caveatHome, sessionId);
-  mkdirSync6(join11(caveatHome, CODEX_STOP_STATE_DIR), { recursive: true });
-  writeFileSync5(path, key, "utf-8");
+  mkdirSync6(join13(caveatHome, CODEX_STOP_STATE_DIR), { recursive: true });
+  writeFileSync6(path, key, "utf-8");
 }
 function queueStopForSession2(sessionId, signals, related) {
   const ctx = buildContextSafely2();
@@ -32875,7 +33570,7 @@ async function processCodexWorkerJob(job, opts = { waitForTranscript: true }) {
     }
   }
   if (!knownError && job.allowSymptomOnly !== true) return;
-  const hits = searchCaveatsFromTextSafely2(searchText);
+  const hits = searchCaveatsFromTextSafely2(searchText, "tool_error");
   if (hits.length === 0) return;
   const ctx = buildContextSafely2();
   if (!ctx) return;
@@ -32887,12 +33582,12 @@ async function processCodexWorkerJob(job, opts = { waitForTranscript: true }) {
 async function runCodexWorker(workFile) {
   let raw;
   try {
-    raw = readFileSync5(workFile, "utf-8");
+    raw = readFileSync6(workFile, "utf-8");
   } catch {
     process.exit(0);
   }
   try {
-    unlinkSync2(workFile);
+    unlinkSync(workFile);
   } catch {
   }
   let job;
@@ -32904,13 +33599,14 @@ async function runCodexWorker(workFile) {
   await processCodexWorkerJob(job);
   process.exit(0);
 }
-function runDiagnostics(codexHome = process.env.CODEX_HOME ?? join11(homedir3(), ".codex")) {
-  const features = spawnSync3("codex", ["features", "list"], {
+function runDiagnostics(codexHome = process.env.CODEX_HOME ?? join13(homedir3(), ".codex")) {
+  const features = spawnSync5("codex", ["features", "list"], {
     encoding: "utf-8",
-    maxBuffer: 1024 * 1024
+    maxBuffer: 1024 * 1024,
+    env: codexFeatureListEnv(codexHome)
   });
   const featureOutput = [features.stdout, features.stderr].filter(Boolean).join("\n");
-  const hasHooks = /^codex_hooks\s+\S+\s+true\b/m.test(featureOutput);
+  const hasHooks = /^hooks\s+\S+\s+true\b/m.test(featureOutput);
   const installation = detectCodexHookInstallation(codexHome);
   const result = {
     availability: features.error || features.status !== 0 || !hasHooks ? "unavailable" : "available",
@@ -32920,11 +33616,14 @@ function runDiagnostics(codexHome = process.env.CODEX_HOME ?? join11(homedir3(),
     codexHome,
     hooksPath: installation.hooksPath,
     installedHooks: installation.hooks,
-    evidence: featureOutput.split("\n").find((line) => line.trim().startsWith("codex_hooks")) ?? null
+    evidence: featureOutput.split("\n").find((line) => line.trim().startsWith("hooks")) ?? null
   };
   process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
 }
+function codexFeatureListEnv(codexHome, inherited = process.env) {
+  return { ...inherited, CODEX_HOME: codexHome };
+}
 async function runCodexHook(name, arg) {
   if (name === "diagnostics") {
     runDiagnostics(arg);
@@ -32950,7 +33649,7 @@ async function runCodexHook(name, arg) {
   if (name === "user-prompt-submit") {
     const contexts = sessionId ? drainForSession2(sessionId) : [];
     const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
-    const hits = searchCaveatsFromTextSafely2(prompt);
+    const hits = searchCaveatsFromTextSafely2(prompt, "user_prompt");
     if (hits.length > 0) {
       contexts.push(userPromptSubmitReminderText(hits));
     }
@@ -32969,7 +33668,23 @@ async function runCodexHook(name, arg) {
   if (name === "stop") {
     try {
       const ctx = buildContextSafely2();
-      if (ctx) maybeTriggerAutoReindex(ctx);
+      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}
+`);
+        }
+        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}
+`);
+        }
+      }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`[caveat:codex-hook] auto reindex trigger error: ${msg}
@@ -32979,7 +33694,7 @@ async function runCodexHook(name, arg) {
     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 = searchCaveatsFromTextSafely2(struggleSearchText(signals));
+    const related = searchCaveatsFromTextSafely2(struggleSearchText(signals), "stop");
     if (sessionId) queueStopForSession2(sessionId, signals, related);
     process.exit(0);
   }
@@ -32989,9 +33704,9 @@ async function runCodexHook(name, arg) {
 }
 
 // src/commands/pull.ts
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 async function runPull(ctx) {
-  const hasCommunityDir = existsSync10(ctx.paths.communityDir);
+  const hasCommunityDir = existsSync12(ctx.paths.communityDir);
   if (!hasCommunityDir) {
     ctx.logger.info(
       "no community repos yet \u2014 add one with `caveat community add <github-url>`."
@@ -33007,8 +33722,12 @@ async function runPull(ctx) {
   }
   const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
   try {
-    rebuildAll(db);
-    const result = reindexAllSources({ db, paths: ctx.paths, logger: ctx.logger });
+    const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
+    const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
+    for (const failure of failures) {
+      ctx.logger.warn(`${failure.source}: sealed key prewarm failed: ${errorMessage5(failure.error)}`);
+    }
+    const result = reindexAllSources({ db, paths: ctx.paths, logger: ctx.logger, keyProvider });
     for (const [source, scan] of Object.entries(result.perSource)) {
       ctx.logger.info(`${source}: +${scan.added}`);
     }
@@ -33017,51 +33736,19 @@ async function runPull(ctx) {
     db.close();
   }
 }
-
-// src/ghSetup.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { readSync } from "node:fs";
-function runGh(args) {
-  const result = spawnSync4("gh", args, { encoding: "utf-8" });
-  return { status: result.status, stdout: typeof result.stdout === "string" ? result.stdout : "", stderr: typeof result.stderr === "string" ? result.stderr : "" };
-}
-function commandError(result, fallback) {
-  return new Error((result.stderr || result.stdout || fallback).trim());
-}
-function askOnce(question) {
-  process.stdout.write(`${question} `);
-  const buf = Buffer.alloc(256);
-  const bytes = readSync(0, buf, 0, buf.length, null);
-  return /^(?:y|yes)$/i.test(buf.toString("utf-8", 0, bytes).trim());
+function errorMessage5(err) {
+  return err instanceof Error ? err.message : String(err);
 }
 
 // src/commands/sync.ts
 async function defaultPrivateRepoUrl(opts, deps) {
-  const version2 = deps.ghRunner(["--version"]);
-  if (version2.status !== 0) {
-    throw new Error(
-      "gh is not available. create a private repository named Caveat-Private on GitHub, then run:\n  caveat sync --init <url>\n  # or install gh and run caveat sync --init"
-    );
-  }
-  const user = deps.ghRunner(["api", "user", "-q", ".login"]);
-  if (user.status !== 0 || !user.stdout.trim()) {
-    throw new Error("gh is not authenticated; run `gh auth login`, then retry `caveat sync --init`");
-  }
-  const login = user.stdout.trim();
-  const name = `${login}/Caveat-Private`;
-  const view = deps.ghRunner(["repo", "view", name]);
-  if (view.status !== 0) {
-    const question = `create private repo github.com/${name}? [y/N]`;
-    if (!opts.yes) {
-      if (!deps.isTty()) {
-        throw new Error(`${question}; rerun with --yes to approve non-interactively`);
-      }
-      if (!deps.confirm(question)) throw new Error("private repository creation cancelled");
-    }
-    const create = deps.ghRunner(["repo", "create", "Caveat-Private", "--private"]);
-    if (create.status !== 0) throw commandError(create, "gh repo create failed");
-  }
-  return `https://github.com/${name}.git`;
+  return defaultGitHubRepoUrl({
+    repositoryName: "Caveat-Private",
+    visibility: "private",
+    yes: opts.yes,
+    retryCommand: "caveat sync --init <url>",
+    ...deps
+  });
 }
 async function runSync(ctx, opts, dependencies = {}) {
   try {
@@ -33100,6 +33787,10 @@ async function runSync(ctx, opts, dependencies = {}) {
     } else {
       const rebased = result.pulled ? ", rebased onto remote" : "";
       ctx.logger.info(`synced ${result.branch} \u2192 origin (${result.changedFiles} local change(s)${rebased})`);
+      try {
+        resetAutoSyncFailureState(ctx.caveatHome);
+      } catch {
+      }
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -33108,60 +33799,11 @@ async function runSync(ctx, opts, dependencies = {}) {
   }
 }
 
-// src/commands/publish.ts
-var HTTPS_TARGET_RE = /^https:\/\/github\.com\/[^/]+\/[^/]+?(?:\.git)?\/?$/;
-var SCP_TARGET_RE = /^git@github\.com:[^/]+\/[^/]+?(?:\.git)?$/;
-function validatePublishTarget(url2) {
-  if (!HTTPS_TARGET_RE.test(url2) && !SCP_TARGET_RE.test(url2)) throw new Error("invalid publish target: use https://github.com/<org>/<repo>(.git) or git@github.com:<org>/<repo>(.git)");
-  return url2;
-}
-async function defaultPublicRepoUrl(opts, deps) {
-  const version2 = deps.ghRunner(["--version"]);
-  if (version2.status !== 0) throw new Error("gh is not available. create a public repository named Caveat-Public on GitHub, then run:\n  caveat publish --init <url>\n  # or install gh and run caveat publish");
-  const user = deps.ghRunner(["api", "user", "-q", ".login"]);
-  if (user.status !== 0 || !user.stdout.trim()) throw new Error("gh is not authenticated; run `gh auth login`, then retry `caveat publish`");
-  const login = user.stdout.trim();
-  const name = `${login}/Caveat-Public`;
-  const view = deps.ghRunner(["repo", "view", name]);
-  if (view.status !== 0) {
-    const question = `create public repo github.com/${name}? [y/N]`;
-    if (!opts.yes) {
-      if (!deps.isTty()) throw new Error(`${question}; rerun with --yes to approve non-interactively`);
-      if (!deps.confirm(question)) throw new Error("public repository creation cancelled");
-    }
-    const create = deps.ghRunner(["repo", "create", "Caveat-Public", "--public"]);
-    if (create.status !== 0) throw commandError(create, "gh repo create failed");
-  }
-  return `https://github.com/${name}.git`;
-}
-async function runPublish(ctx, opts, dependencies = {}) {
-  try {
-    const ghRunner = dependencies.ghRunner ?? runGh;
-    const isTty = dependencies.isTty ?? (() => Boolean(process.stdin.isTTY));
-    const confirm = dependencies.confirm ?? askOnce;
-    let target = ctx.config.publishTarget;
-    if (opts.init !== void 0) {
-      target = validatePublishTarget(opts.init);
-      writeUserConfigPatch(ctx.userConfigPath, { publishTarget: target });
-    }
-    if (!target) {
-      target = await defaultPublicRepoUrl(opts, { ghRunner, isTty, confirm });
-      writeUserConfigPatch(ctx.userConfigPath, { publishTarget: target });
-    }
-    const result = await publishOwn({ paths: ctx.paths, config: { ...ctx.config, publishTarget: target }, logger: ctx.logger, confirmImpl: confirm, isTty, dryRun: opts.dryRun, yes: opts.yes });
-    if (result.dryRun) ctx.logger.info(`[dry-run] ${result.fileCount} public entry(ies) ready to publish`);
-    else if (result.changed) ctx.logger.info(`published ${result.fileCount} public entry(ies)`);
-  } catch (err) {
-    ctx.logger.error(err instanceof Error ? err.message : String(err));
-    process.exitCode = 1;
-  }
-}
-
 // src/commands/codexSidecar.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
-import { mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { closeSync, constants, fstatSync, lstatSync as lstatSync2, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, openSync, readSync as readSync2, realpathSync as realpathSync3, 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 join14 } from "node:path";
 import { cwd, exit } from "node:process";
 function runCodexSidecarDiagnostics(logger, opts) {
   const plan = buildCodexSidecarDiagnosticsCommand({
@@ -33193,8 +33835,8 @@ function runCodexSidecarWithCaveats(ctx, workflow, prompt, opts) {
     process.stdout.write(JSON.stringify({ status: "skipped", decision }, null, 2) + "\n");
     exit(0);
   }
-  const contextDir = mkdtempSync2(join12(tmpdir3(), "caveat-sidecar-context-"));
-  const contextFile = join12(contextDir, "context.json");
+  const contextDir = mkdtempSync3(join14(tmpdir4(), "caveat-sidecar-context-"));
+  const contextFile = join14(contextDir, "context.json");
   let status = 1;
   try {
     const blocks = collectCaveatContextBlocks(ctx, {
@@ -33203,7 +33845,8 @@ function runCodexSidecarWithCaveats(ctx, workflow, prompt, opts) {
       source: opts.source,
       visibility: opts.visibility
     });
-    writeFileSync6(contextFile, JSON.stringify({ context: blocks }, null, 2) + "\n", "utf-8");
+    const additionalBlocks = opts.additionalContextFile ? readHookSignalAdditionalContextFile(opts.additionalContextFile) : [];
+    writeFileSync7(contextFile, JSON.stringify({ context: [...blocks, ...additionalBlocks] }, null, 2) + "\n", "utf-8");
     const plan = buildCodexSidecarRunCommand({
       workflow,
       projectRoot: opts.project ?? cwd(),
@@ -33214,10 +33857,94 @@ function runCodexSidecarWithCaveats(ctx, workflow, prompt, opts) {
     });
     status = executePlan(ctx.logger, plan.command, plan.args, { saveResult: opts.saveResult });
   } finally {
-    rmSync2(contextDir, { recursive: true, force: true });
+    rmSync3(contextDir, { recursive: true, force: true });
   }
   exit(status);
 }
+var MAX_ADDITIONAL_CONTEXT_BYTES = 4096;
+function readHookSignalAdditionalContextFile(path, testProbe) {
+  const platform = testProbe?.platform ?? process.platform;
+  assertWindowsPrivateTempContainer(path, platform);
+  const before = lstatSync2(path);
+  const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+  assertPrivateRegular(before, uid, platform);
+  testProbe?.afterLstat?.();
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK | (constants.O_NOFOLLOW ?? 0));
+  let raw;
+  try {
+    const opened = fstatSync(fd);
+    assertPrivateRegular(opened, uid, platform);
+    if (opened.dev !== before.dev || opened.ino !== before.ino) throw new Error("additional context file changed during open");
+    const bytes = Buffer.alloc(MAX_ADDITIONAL_CONTEXT_BYTES + 1);
+    let count = 0;
+    while (count < bytes.length) {
+      const read = readSync2(fd, bytes, count, bytes.length - count, count);
+      if (read === 0) break;
+      count += read;
+    }
+    if (count > MAX_ADDITIONAL_CONTEXT_BYTES) throw new Error(`additional context file exceeds ${MAX_ADDITIONAL_CONTEXT_BYTES} bytes`);
+    const after = fstatSync(fd);
+    assertPrivateRegular(after, uid, platform);
+    if (after.dev !== opened.dev || after.ino !== opened.ino || after.dev !== before.dev || after.ino !== before.ino) throw new Error("additional context file changed during read");
+    raw = bytes.subarray(0, count).toString("utf-8");
+  } finally {
+    closeSync(fd);
+  }
+  const parsed = JSON.parse(raw);
+  if (!isRecord(parsed) || !Array.isArray(parsed.context) || parsed.context.length !== 1) {
+    throw new Error("additional context file must contain exactly one context block");
+  }
+  const block = parsed.context[0];
+  if (!isHookSignalBlock(block)) {
+    throw new Error("additional context file contains an invalid hook signal block");
+  }
+  return [block];
+}
+function assertPrivateRegular(stat, uid, platform) {
+  const privateOwner = platform === "win32" || (stat.mode & 63) === 0 && (uid === void 0 || stat.uid === uid);
+  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);
+  const parentStat = lstatSync2(parent);
+  const resolvedParent = realpathSync3(parent);
+  const resolvedTemp = realpathSync3(tmpdir4());
+  if (parentStat.isSymbolicLink() || !parentStat.isDirectory() || dirname7(resolvedParent) !== resolvedTemp || !basename2(resolvedParent).startsWith("caveat-")) {
+    throw new Error("additional context file must be inside a reserved per-user Caveat temporary directory");
+  }
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isHookSignalBlock(value) {
+  if (!isRecord(value) || !hasExactKeys(value, ["kind", "source", "trust", "summary", "data"]) || value.kind !== "manual_note" || value.source !== "caveat-hook-signal" || value.trust !== "local" || typeof value.summary !== "string" || !isRecord(value.data)) return false;
+  const data = value.data;
+  if (data.type === "tool-error") {
+    if (!hasExactKeys(data, ["type", "tool", "failure_kind"]) || typeof data.tool !== "string" || data.failure_kind !== "post-tool-use-failure" && data.failure_kind !== "error-bearing-post-tool-use") return false;
+    const canonical2 = buildHookSignalFromData(data);
+    return canonical2 !== null && JSON.stringify(value) === JSON.stringify(canonical2);
+  }
+  if (!hasExactKeys(data, ["type", "tool_failure_count", "reedited_file_count", "web_search_count", "web_fetch_count", "bash_retry_count", "duration_minutes"])) return false;
+  const canonical = buildHookSignalFromData(data);
+  return canonical !== null && JSON.stringify(value) === JSON.stringify(canonical);
+}
+function hasExactKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  return actual.length === keys.length && actual.every((key, index) => key === keys.slice().sort()[index]);
+}
+function buildHookSignalFromData(data) {
+  if (data.type === "tool-error") {
+    const validTools = ["bash", "edit", "write", "read", "glob", "grep", "web-search", "web-fetch", "notebook-edit", "other"];
+    if (!validTools.includes(String(data.tool))) return null;
+    const toolNames = { bash: "Bash", edit: "Edit", write: "Write", read: "Read", glob: "Glob", grep: "Grep", "web-search": "WebSearch", "web-fetch": "WebFetch", "notebook-edit": "NotebookEdit", other: "other" };
+    return buildHookSignalSidecarContextBlock({ type: "tool-error", toolName: toolNames[String(data.tool)], failureKind: data.failure_kind });
+  }
+  if (data.type !== "stop") return null;
+  const keys = ["tool_failure_count", "reedited_file_count", "web_search_count", "web_fetch_count", "bash_retry_count", "duration_minutes"];
+  if (!keys.every((key) => typeof data[key] === "number" && Number.isInteger(data[key]) && data[key] >= 0 && data[key] <= 1e4)) return null;
+  return buildHookSignalSidecarContextBlock({ type: "stop", toolFailureCount: data.tool_failure_count, reeditedFileCount: data.reedited_file_count, webSearchCount: data.web_search_count, webFetchCount: data.web_fetch_count, bashRetryCount: data.bash_retry_count, durationMinutes: data.duration_minutes });
+}
 function runCodexSidecarWorkSmoke(ctx, prompt, opts) {
   const plan = buildCodexSidecarRunCommand({
     workflow: "work",
@@ -33258,7 +33985,7 @@ function defaultPreset(workflow) {
 }
 function executePlan(logger, command, args, options = {}) {
   logger.info(`[codex-sidecar] ${command} ${args.map(shellDisplayQuote).join(" ")}`);
-  const result = spawnSync5(command, args, { encoding: "utf-8", stdio: "pipe" });
+  const result = spawnSync6(command, args, { encoding: "utf-8", stdio: "pipe" });
   if (result.stdout) process.stdout.write(result.stdout);
   if (result.stderr) process.stderr.write(result.stderr);
   if (options.saveResult && result.stdout) {
@@ -33272,8 +33999,8 @@ function executePlan(logger, command, args, options = {}) {
 }
 function saveStructuredResult(path, stdout) {
   const parsed = JSON.parse(stdout);
-  mkdirSync7(dirname6(path), { recursive: true });
-  writeFileSync6(path, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+  mkdirSync7(dirname7(path), { recursive: true });
+  writeFileSync7(path, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
 }
 function shellDisplayQuote(value) {
   return /[\s"'$`]/.test(value) ? JSON.stringify(value) : value;
@@ -33361,10 +34088,13 @@ function runCommunityRemove(ctx, handle, opts) {
 
 // src/index.ts
 var program = new Command();
+function collectRepeatable(value, previous) {
+  return [...previous, value];
+}
 program.name("caveat").description("External spec gotcha knowledge base CLI").version(CAVEAT_VERSION);
 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("--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("--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) => {
@@ -33380,7 +34110,11 @@ program.command("init").description(
     await runInit(ctx, {
       skipClaude: opts.skipClaude,
       dryRun: opts.dryRun,
-      pendingStaleDays: opts.pendingStaleDays
+      pendingStaleDays: opts.pendingStaleDays,
+      sync: opts.sync,
+      publishTarget: opts.publishTarget,
+      yes: opts.yes,
+      skipCodexHook: opts.skipCodexHook
     });
   }
 );
@@ -33388,9 +34122,9 @@ program.command("uninstall").description("Remove Claude Code MCP server and hook
   const ctx = buildContext(stdoutLogger);
   runUninstall(ctx, { dryRun: opts.dryRun });
 });
-program.command("index").description("Index knowledge repo entries into SQLite").option("--full", "full rebuild (DELETE all then rescan)", false).action((opts) => {
+program.command("index").description("Index knowledge repo entries into SQLite").option("--full", "full rebuild (DELETE all then rescan)", false).action(async (opts) => {
   const ctx = buildContext(stdoutLogger);
-  runIndex(ctx, { full: opts.full });
+  await runIndex(ctx, { full: opts.full });
 });
 program.command("search").description("Search caveats via FTS").argument("<query>", "FTS query (3+ chars for trigram)").option("--source <source>", "own | community | all").option("--tag <tag...>", "filter by tag (repeatable)").option("--confidence <confidence...>", "filter by confidence (repeatable)").action(
   (query, opts) => {
@@ -33432,7 +34166,7 @@ program.command("sync").description("Sync own Caveat entries to a private git re
   const ctx = buildContext(stdoutLogger);
   await runSync(ctx, opts);
 });
-program.command("publish").description("Mirror own public Caveat entries to a public git repository").option("--init <url>", "set the public mirror target").option("--dry-run", "show public mirror changes without committing or pushing", false).option("--yes", "approve creating a default repository or publishing changes", false).action(async (opts) => {
+program.command("publish").description("Mirror own public Caveat entries to a public git repository").option("--init <url>", "set the public mirror target").option("--dry-run", "show public mirror changes without committing or pushing", false).option("--yes", "approve creating a default repository or publishing changes", false).option("--allow <digest>", "allow a scan finding by its sha256 digest (repeatable)", collectRepeatable, []).option("--save", "persist --allow digests to .caveat-publish-allow.json in the own repo", false).action(async (opts) => {
   const ctx = buildContext(stdoutLogger);
   await runPublish(ctx, opts);
 });
@@ -33443,12 +34177,12 @@ program.command("mcp-server").description("Run the MCP stdio server (registered
   await runMcpServer();
 });
 program.command("hook <name> [arg]").description(
-  "Run a Claude Code hook. name: user-prompt-submit | post-tool-use | stop | worker | reindex"
+  "Run a Claude Code hook. name: user-prompt-submit | post-tool-use | stop | worker | reindex | autosync"
 ).action(async (name, arg) => {
   await runHook(name, arg);
 });
 var codexHook = program.command("codex-hook").description("Install or run Codex hooks for Caveat");
-codexHook.command("install").description("Install Caveat hooks into ~/.codex/hooks.json and enable codex_hooks").option("--dry-run", "show planned changes without writing", false).option("--codex-home <path>", "Codex home directory", process.env.CODEX_HOME ?? `${process.env.HOME}/.codex`).action((opts) => {
+codexHook.command("install").description("Install Caveat hooks into ~/.codex/hooks.json and enable hooks").option("--dry-run", "show planned changes without writing", false).option("--codex-home <path>", "Codex home directory", process.env.CODEX_HOME ?? `${process.env.HOME}/.codex`).action((opts) => {
   const cliScriptPath = process.argv[1];
   if (!cliScriptPath) {
     process.stderr.write("[caveat:error] cannot determine CLI script path\n");
@@ -33464,7 +34198,12 @@ codexHook.command("install").description("Install Caveat hooks into ~/.codex/hoo
   stdoutLogger.info(`UserPromptSubmit hook: ${result.hooks.userPromptSubmit}`);
   stdoutLogger.info(`PostToolUse hook: ${result.hooks.postToolUse}`);
   stdoutLogger.info(`Stop hook: ${result.hooks.stop}`);
-  stdoutLogger.info(`codex_hooks feature: ${result.feature}`);
+  stdoutLogger.info(`hooks feature: ${result.feature}`);
+  if (result.feature === "blocked") {
+    stdoutLogger.warn(
+      `${result.blockedReason}; preserving explicit consent. Set \`hooks = true\` in ${opts.codexHome}/config.toml, then rerun \`caveat codex-hook install\`.`
+    );
+  }
   if (result.backupPath) stdoutLogger.info(`hooks.json backed up: ${result.backupPath}`);
   if (result.configBackupPath) {
     stdoutLogger.info(`config.toml backed up: ${result.configBackupPath}`);
@@ -33510,7 +34249,7 @@ codexSidecar.command("diagnostics").description("Run codex-sidecar diagnostics f
 codexSidecar.command("smoke").description("Run a read-only codex_explore smoke through codex-sidecar").option("--project <path>", "repository root to check").option("--preset <preset>", "codex-sidecar read-only preset", "explore").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) => {
   runCodexSidecarSmoke(stdoutLogger, opts);
 });
-codexSidecar.command("run <workflow> [prompt]").description("Run read-only codex-sidecar with relevant Caveat entries as context").option("--project <path>", "repository root to check").option("--preset <preset>", "codex-sidecar preset").option("--query <query>", "Caveat search query; defaults to prompt text").option("--limit <n>", "maximum caveat entries to pass", (v) => Number(v), 5).option("--source <source>", "own | community | all", "all").option("--visibility <visibility>", "public | private | all", "all").option("--host-agent <agent>", "claude | codex | automation | unknown", "unknown").option("--availability <level>", "disabled | unavailable | configured | operational | work-capable", "operational").option("--sidecar-agent <agent>", "codex | disabled | auto").option("--requires-isolation", "mark the sidecar call as isolation-bounded", false).option("--structured-result-required", "mark structured SidecarResult as the delegation boundary", false).option("--explicit-second-pass", "mark the sidecar call as an explicit second-pass review", false).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(
+codexSidecar.command("run <workflow> [prompt]").description("Run read-only codex-sidecar with relevant Caveat entries as context").option("--project <path>", "repository root to check").option("--preset <preset>", "codex-sidecar preset").option("--query <query>", "Caveat search query; defaults to prompt text").option("--limit <n>", "maximum caveat entries to pass", (v) => Number(v), 5).option("--source <source>", "own | community | all", "all").option("--visibility <visibility>", "public | private | all", "all").option("--host-agent <agent>", "claude | codex | automation | unknown", "unknown").option("--availability <level>", "disabled | unavailable | configured | operational | work-capable", "operational").option("--sidecar-agent <agent>", "codex | disabled | auto").option("--requires-isolation", "mark the sidecar call as isolation-bounded", false).option("--structured-result-required", "mark structured SidecarResult as the delegation boundary", false).option("--explicit-second-pass", "mark the sidecar call as an explicit second-pass review", false).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").option("--additional-context-file <path>", "strictly validated bounded hook-signal context file").action(
   (workflow, prompt, opts) => {
     const normalized = workflow === "risk" ? "risk-check" : workflow;
     if (normalized !== "review" && normalized !== "explore" && normalized !== "opinion" && normalized !== "risk-check") {
@@ -33527,7 +34266,7 @@ codexSidecar.command("work-smoke [prompt]").description("Run codex_work in an is
     runCodexSidecarWorkSmoke(ctx, prompt, opts);
   }
 );
-var community = program.command("community").description("Manage community caveat repos (shallow clones under <knowledgeRepo>/community/)");
+var community = program.command("community").description("Manage community caveat repos (shallow clones under <caveatHome>/community/)");
 community.command("add <url>").description("Shallow-clone a GitHub caveat repo into community/<handle>/").action(async (url2) => {
   const ctx = buildContext(stdoutLogger);
   await runCommunityAdd(ctx, url2);