caveat-cli 0.19.2 → 0.19.5

package/dist/index.js

@@ -10,15 +10,11 @@ import {
   __commonJS,
   __export,
   __toESM,
+  acknowledgePendingReminders,
   acknowledgeRuntimeErrors,
   acquireReindexLock,
   buildAndPublishPendingReminder,
-  buildCodexSidecarDiagnosticsCommand,
-  buildCodexSidecarReadOnlySmokeCommand,
-  buildCodexSidecarRunCommand,
-  buildHookSignalSidecarContextBlock,
   buildPendingSemanticKey,
-  caveatEntriesToSidecarContextBlocks,
   cleanupStalePendingDirs,
   communityAdd,
   communityList,
@@ -27,18 +23,20 @@ import {
   compactRuntimeErrors,
   computeEntriesDigest,
   createKeyserverKeyProvider,
-  decideCodexSidecarExecution,
   defaultSelfIdentityTokens,
-  drainPendingRemindersDetailed,
   ensureUserConfig,
+  environmentAppliesToTask,
+  extractPromptCandidates,
   findCaveatHome,
   findCaveatsForHook,
   findCaveatsForHookSegments,
+  fingerprint,
   get,
   hasAnyStruggleSignal,
   initOwnSync,
   isPrivateOwnerStat,
   isWindows,
+  isWindowsEnv,
   listRecent,
   listStale,
   loadConfig,
@@ -48,6 +46,7 @@ import {
   nodeExecutableNames,
   observeRuntimeError,
   openDb,
+  peekPendingRemindersDetailed,
   powershellCallPrefix,
   prewarmSealedKeys,
   publishOwn,
@@ -61,13 +60,13 @@ import {
   resetAutoSyncFailureState,
   resolvePaths,
   runAutoSync,
+  runWindowsAcl,
   runtimeErrorsDiagnostics,
   runtimeErrorsSnapshot,
   search,
   setRuntimeErrorStatus,
   stderrLogger,
   stopReminderText,
-  struggleSearchText,
   syncOwn,
   toolErrorReminderText,
   triggerAutoSync,
@@ -75,7 +74,7 @@ import {
   userPromptSubmitReminderText,
   writeDigestMarker,
   writeUserConfigPatch
-} from "./chunk-NZD3FHU6.js";
+} from "./chunk-EMGYSGFX.js";
 
 // ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -454,11 +453,11 @@ var require_codegen = __commonJS({
         const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
         return `${varKind} ${this.name}${rhs};` + _n;
       }
-      optimizeNames(names, constants5) {
+      optimizeNames(names, constants4) {
         if (!names[this.name.str])
           return;
         if (this.rhs)
-          this.rhs = optimizeExpr(this.rhs, names, constants5);
+          this.rhs = optimizeExpr(this.rhs, names, constants4);
         return this;
       }
       get names() {
@@ -475,10 +474,10 @@ var require_codegen = __commonJS({
       render({ _n }) {
         return `${this.lhs} = ${this.rhs};` + _n;
       }
-      optimizeNames(names, constants5) {
+      optimizeNames(names, constants4) {
         if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
           return;
-        this.rhs = optimizeExpr(this.rhs, names, constants5);
+        this.rhs = optimizeExpr(this.rhs, names, constants4);
         return this;
       }
       get names() {
@@ -539,8 +538,8 @@ var require_codegen = __commonJS({
       optimizeNodes() {
         return `${this.code}` ? this : void 0;
       }
-      optimizeNames(names, constants5) {
-        this.code = optimizeExpr(this.code, names, constants5);
+      optimizeNames(names, constants4) {
+        this.code = optimizeExpr(this.code, names, constants4);
         return this;
       }
       get names() {
@@ -569,12 +568,12 @@ var require_codegen = __commonJS({
         }
         return nodes.length > 0 ? this : void 0;
       }
-      optimizeNames(names, constants5) {
+      optimizeNames(names, constants4) {
         const { nodes } = this;
         let i = nodes.length;
         while (i--) {
           const n = nodes[i];
-          if (n.optimizeNames(names, constants5))
+          if (n.optimizeNames(names, constants4))
             continue;
           subtractNames(names, n.names);
           nodes.splice(i, 1);
@@ -627,12 +626,12 @@ var require_codegen = __commonJS({
           return void 0;
         return this;
       }
-      optimizeNames(names, constants5) {
+      optimizeNames(names, constants4) {
         var _a3;
-        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants5);
-        if (!(super.optimizeNames(names, constants5) || this.else))
+        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants4);
+        if (!(super.optimizeNames(names, constants4) || this.else))
           return;
-        this.condition = optimizeExpr(this.condition, names, constants5);
+        this.condition = optimizeExpr(this.condition, names, constants4);
         return this;
       }
       get names() {
@@ -655,10 +654,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.iteration})` + super.render(opts);
       }
-      optimizeNames(names, constants5) {
-        if (!super.optimizeNames(names, constants5))
+      optimizeNames(names, constants4) {
+        if (!super.optimizeNames(names, constants4))
           return;
-        this.iteration = optimizeExpr(this.iteration, names, constants5);
+        this.iteration = optimizeExpr(this.iteration, names, constants4);
         return this;
       }
       get names() {
@@ -694,10 +693,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
       }
-      optimizeNames(names, constants5) {
-        if (!super.optimizeNames(names, constants5))
+      optimizeNames(names, constants4) {
+        if (!super.optimizeNames(names, constants4))
           return;
-        this.iterable = optimizeExpr(this.iterable, names, constants5);
+        this.iterable = optimizeExpr(this.iterable, names, constants4);
         return this;
       }
       get names() {
@@ -739,11 +738,11 @@ var require_codegen = __commonJS({
         (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
         return this;
       }
-      optimizeNames(names, constants5) {
+      optimizeNames(names, constants4) {
         var _a3, _b;
-        super.optimizeNames(names, constants5);
-        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants5);
-        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants5);
+        super.optimizeNames(names, constants4);
+        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants4);
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants4);
         return this;
       }
       get names() {
@@ -1044,7 +1043,7 @@ var require_codegen = __commonJS({
     function addExprNames(names, from) {
       return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
     }
-    function optimizeExpr(expr, names, constants5) {
+    function optimizeExpr(expr, names, constants4) {
       if (expr instanceof code_1.Name)
         return replaceName(expr);
       if (!canOptimize(expr))
@@ -1059,14 +1058,14 @@ var require_codegen = __commonJS({
         return items;
       }, []));
       function replaceName(n) {
-        const c = constants5[n.str];
+        const c = constants4[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 && constants5[c.str] !== void 0);
+        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants4[c.str] !== void 0);
       }
     }
     function subtractNames(names, from) {
@@ -6887,9 +6886,9 @@ var stdoutLogger = {
 };
 
 // src/commands/init.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync, renameSync, rmdirSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join10 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync, renameSync, rmdirSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join8 } from "node:path";
 
 // src/claudeInstall.ts
 import { constants, existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
@@ -7796,148 +7795,6 @@ function resolveHookNodePath({
   return execPath;
 }
 
-// src/commands/publish.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join9 } from "node:path";
-
-// src/commands/codexSidecarAdvisory.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { mkdtempSync, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join8 } from "node:path";
-var DEFAULT_HOOK_SIDECAR_TIMEOUT_MS = 12e4;
-var MAX_HOOK_SIDECAR_TIMEOUT_MS = 24e4;
-function resolveHookSidecarTimeoutMs(raw) {
-  if (raw === void 0) return DEFAULT_HOOK_SIDECAR_TIMEOUT_MS;
-  const value = Number(raw);
-  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_HOOK_SIDECAR_TIMEOUT_MS) {
-    throw new Error(`CAVEAT_HOOK_CODEX_SIDECAR_TIMEOUT_MS must be an integer from 1 to ${MAX_HOOK_SIDECAR_TIMEOUT_MS}`);
-  }
-  return value;
-}
-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(join8(tmpdir(), "caveat-codex-advisory-"));
-    const resultFile = join8(resultDir, "result.json");
-    args.push("--save-result", resultFile);
-    if (input.additionalContext) {
-      const additionalContextFile = join8(resultDir, "hook-signal.json");
-      writeFileSync2(additionalContextFile, JSON.stringify({ context: [input.additionalContext] }) + "\n", { encoding: "utf-8", mode: 384, flag: "wx" });
-      args.push("--additional-context-file", additionalContextFile);
-    }
-    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 = spawnSync2(process.execPath, args, {
-      cwd: input.projectRoot,
-      encoding: "utf-8",
-      // Keep at least one minute between the longest supported model call and
-      // the pending single-flight claim TTL (five minutes).
-      timeout: resolveHookSidecarTimeoutMs(process.env.CAVEAT_HOOK_CODEX_SIDECAR_TIMEOUT_MS),
-      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(readFileSync6(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)?$/;
@@ -7959,20 +7816,6 @@ async function runPublish(ctx, opts, dependencies = {}) {
     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) => existsSync7(join9(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);
@@ -7991,8 +7834,7 @@ async function runPublish(ctx, opts, dependencies = {}) {
       dryRun: opts.dryRun,
       yes: opts.yes,
       allow: opts.allow,
-      saveAllow: opts.save,
-      advisory: publishAdvisory
+      saveAllow: opts.save
     });
     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)`);
@@ -8023,7 +7865,7 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
   let cursorHookState = "not-installed";
   if (!opts.dryRun) ensureUserConfig(ctx.userConfigPath);
   ctx.logger.info(`user config: ${ctx.userConfigPath}`);
-  if (!existsSync8(ctx.paths.knowledgeRepo)) {
+  if (!existsSync7(ctx.paths.knowledgeRepo)) {
     if (!opts.dryRun) {
       mkdirSync3(ctx.paths.knowledgeRepo, { recursive: true });
       mkdirSync3(ctx.paths.entriesDir, { recursive: true });
@@ -8033,14 +7875,14 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
     ctx.logger.info(`knowledge repo: ${ctx.paths.knowledgeRepo}`);
   }
   if (!opts.dryRun) migrateLegacyCommunityDir(ctx);
-  const gitignorePath = join10(ctx.paths.knowledgeRepo, ".gitignore");
-  if (!existsSync8(gitignorePath)) {
-    if (!opts.dryRun) writeFileSync3(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
+  const gitignorePath = join8(ctx.paths.knowledgeRepo, ".gitignore");
+  if (!existsSync7(gitignorePath)) {
+    if (!opts.dryRun) writeFileSync2(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
     ctx.logger.info(`${opts.dryRun ? "[dry-run] would create .gitignore" : ".gitignore created"}: ${gitignorePath}`);
   }
   if (!opts.dryRun) {
     const dbDir = dirname3(ctx.paths.dbPath);
-    if (!existsSync8(dbDir)) mkdirSync3(dbDir, { recursive: true });
+    if (!existsSync7(dbDir)) mkdirSync3(dbDir, { recursive: true });
     const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
     const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
     for (const failure of failures) {
@@ -8083,8 +7925,8 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
         const target = typeof opts.sync === "string" ? opts.sync : "<user>/Caveat-Private";
         ctx.logger.info(`[dry-run] would initialize private sync: ${target}`);
       } else {
-        const ownGit = join10(ctx.paths.knowledgeRepo, ".git");
-        if (existsSync8(ownGit)) {
+        const ownGit = join8(ctx.paths.knowledgeRepo, ".git");
+        if (existsSync7(ownGit)) {
           const remote = gitOutput(["-C", ctx.paths.knowledgeRepo, "remote", "get-url", "origin"]);
           const result = await syncOwn({
             ownDir: ctx.paths.knowledgeRepo,
@@ -8196,7 +8038,7 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
       if (result.feature === "blocked") {
         codexHookState = "skipped";
         ctx.logger.warn(
-          `${result.blockedReason}; preserving explicit consent. Set \`hooks = true\` in ${join10(codexHome, "config.toml")}, then rerun \`caveat init\`.`
+          `${result.blockedReason}; preserving explicit consent. Set \`hooks = true\` in ${join8(codexHome, "config.toml")}, then rerun \`caveat init\`.`
         );
       } else if (opts.dryRun) {
         codexHookState = "skipped";
@@ -8209,7 +8051,7 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
   if (opts.skipCursorHook) {
     cursorHookState = "skipped";
     ctx.logger.info("Cursor hook integration skipped (--skip-cursor-hook)");
-  } else if (existsSync8(cursorDir)) {
+  } else if (existsSync7(cursorDir)) {
     const cliScriptPath2 = process.argv[1];
     if (!cliScriptPath2) {
       cursorHookState = "skipped";
@@ -8236,9 +8078,9 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
   const cliScriptPath = process.argv[1];
   if (!cliScriptPath) throw new Error("mcp_setup_failed: CLI\u306E\u5B9F\u884C\u30D1\u30B9\u3092\u53D6\u5F97\u3067\u304D\u307E\u305B\u3093");
   for (const [client, configPath, available] of [
-    ["codex", join10(codexHome, "config.toml"), codexAvailable || existsSync8(codexHome)],
-    ["grok", join10(grokHome, "config.toml"), existsSync8(grokHome)],
-    ["cursor", join10(cursorDir, "mcp.json"), existsSync8(cursorDir)]
+    ["codex", join8(codexHome, "config.toml"), codexAvailable || existsSync7(codexHome)],
+    ["grok", join8(grokHome, "config.toml"), existsSync7(grokHome)],
+    ["cursor", join8(cursorDir, "mcp.json"), existsSync7(cursorDir)]
   ]) {
     if (!available) continue;
     const action = installMcpClient({ client, configPath, cliScriptPath, nodePath: resolveHookNodePath(), dryRun: opts.dryRun });
@@ -8247,7 +8089,7 @@ async function runInit(ctx, opts = { skipClaude: false, dryRun: false }, depende
   reportEnvironmentSummary(ctx, publishTarget, codexHookState, cursorHookState, opts.dryRun);
 }
 function detectCodexAvailability() {
-  const result = spawnSync3("codex --version", {
+  const result = spawnSync2("codex --version", {
     shell: true,
     encoding: "utf-8",
     stdio: "ignore"
@@ -8262,14 +8104,14 @@ function isFileRemote(url2) {
   }
 }
 function gitOutput(args) {
-  const result = spawnSync3("git", args, { encoding: "utf-8" });
+  const result = spawnSync2("git", args, { encoding: "utf-8" });
   return result.status === 0 && typeof result.stdout === "string" ? result.stdout.trim() : null;
 }
 function reportEnvironmentSummary(ctx, publishTarget, codexHookState, cursorHookState, dryRun) {
   const prefix = dryRun ? "[dry-run] would have " : "";
   const isRepo = gitOutput(["-C", ctx.paths.knowledgeRepo, "rev-parse", "--is-inside-work-tree"]) === "true";
   const remote = isRepo ? gitOutput(["-C", ctx.paths.knowledgeRepo, "config", "--get", "remote.origin.url"]) : null;
-  const communityCount = existsSync8(ctx.paths.communityDir) ? readdirSync(ctx.paths.communityDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).length : 0;
+  const communityCount = existsSync7(ctx.paths.communityDir) ? readdirSync(ctx.paths.communityDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).length : 0;
   ctx.logger.info(`${prefix}environment summary:`);
   ctx.logger.info(`  own git: ${isRepo ? "repository" : "not initialized"}`);
   ctx.logger.info(`  private remote: ${remote || "not configured"}`);
@@ -8282,11 +8124,11 @@ function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function migrateLegacyCommunityDir(ctx) {
-  const legacy = join10(ctx.paths.knowledgeRepo, "community");
+  const legacy = join8(ctx.paths.knowledgeRepo, "community");
   const current = ctx.paths.communityDir;
   if (legacy === current) return;
-  if (!existsSync8(legacy)) return;
-  if (existsSync8(current)) {
+  if (!existsSync7(legacy)) return;
+  if (existsSync7(current)) {
     ctx.logger.warn(
       `legacy community dir still exists at ${legacy} \u2014 remove manually (new location in use)`
     );
@@ -8295,7 +8137,7 @@ function migrateLegacyCommunityDir(ctx) {
   mkdirSync3(current, { recursive: true });
   for (const entry of readdirSync(legacy, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    renameSync(join10(legacy, entry.name), join10(current, entry.name));
+    renameSync(join8(legacy, entry.name), join8(current, entry.name));
   }
   try {
     rmdirSync(legacy);
@@ -8360,11 +8202,11 @@ function reportInstallResult(ctx, result, dryRun) {
 }
 
 // src/commands/indexCmd.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
 async function runIndex(ctx, opts) {
   const dbDir = dirname4(ctx.paths.dbPath);
-  if (!existsSync9(dbDir)) mkdirSync4(dbDir, { recursive: true });
+  if (!existsSync8(dbDir)) mkdirSync4(dbDir, { recursive: true });
   const keyProvider = createKeyserverKeyProvider({ caveatHome: ctx.caveatHome });
   const failures = await prewarmSealedKeys({ paths: ctx.paths, keyProvider });
   for (const failure of failures) {
@@ -8548,7 +8390,7 @@ function runStats(ctx) {
 
 // src/commands/serve.ts
 async function runServe(opts) {
-  const { startServer } = await import("./server-VOEJV4WH.js");
+  const { startServer } = await import("./server-RSDQNLWE.js");
   const { port, host } = startServer({ port: opts.port });
   process.stdout.write(`[caveat] web portal: http://${host}:${port}/
 `);
@@ -32620,7 +32462,7 @@ var StdioServerTransport = class {
 
 // ../mcp/dist/context.js
 import { homedir as homedir3 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join9 } from "node:path";
 
 // ../mcp/dist/autoSyncTrigger.js
 function triggerAutoSyncAfterWrite(caveatHome, logger) {
@@ -32639,7 +32481,7 @@ function triggerAutoSyncAfterWrite(caveatHome, logger) {
 function buildMcpContext(overrides = {}) {
   const userHome = overrides.userHome ?? homedir3();
   const caveatHome = overrides.caveatHome ?? findCaveatHome(userHome);
-  const userConfigPath = join11(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);
@@ -32788,12 +32630,12 @@ function handleListRecent(ctx, args) {
 }
 
 // ../mcp/dist/tools/pull.js
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 var pullInputShape = {};
 async function handlePull(ctx, _args = {}) {
   const pulled = [];
   const indexed = [];
-  if (existsSync10(ctx.paths.communityDir)) {
+  if (existsSync9(ctx.paths.communityDir)) {
     const results = await communityPull({
       communityDir: ctx.paths.communityDir,
       logger: ctx.logger
@@ -32949,28 +32791,28 @@ async function runMcpServer() {
 import { spawn as spawn2 } from "node:child_process";
 import {
   chmodSync,
-  existsSync as existsSync13,
-  lstatSync,
-  mkdtempSync as mkdtempSync2,
-  mkdirSync as mkdirSync6,
+  existsSync as existsSync15,
+  lstatSync as lstatSync2,
+  mkdtempSync,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync10,
   realpathSync as realpathSync3,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync5
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { basename, dirname as dirname5, join as join14 } from "node:path";
-import { randomBytes } from "node:crypto";
+import { tmpdir } from "node:os";
+import { basename, dirname as dirname5, join as join15 } from "node:path";
+import { randomBytes as randomBytes4 } from "node:crypto";
 
 // src/autoReindexTrigger.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync11 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join10 } from "node:path";
 function maybeTriggerAutoReindex(ctx) {
   if (process.env.CAVEAT_INDEX_AUTOSYNC === "off") return;
-  if (!existsSync11(ctx.paths.dbPath)) return;
-  if (existsSync11(join12(ctx.caveatHome, "index", ".reindex-lock"))) return;
+  if (!existsSync10(ctx.paths.dbPath)) return;
+  if (existsSync10(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;
@@ -32995,11 +32837,69 @@ function maybeTriggerAutoSync(ctx, debounceMs = AUTO_SYNC_DEBOUNCE_MS) {
   });
 }
 
-// src/hookShared.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+// src/jevStruggle.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { createHash as createHash3, randomBytes as randomBytes3 } from "node:crypto";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync as renameSync4, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join14 } from "node:path";
+
+// src/jevCredential.ts
+import { randomBytes } from "node:crypto";
+import { existsSync as existsSync11, lstatSync, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join11 } from "node:path";
+var KEY_FILE = "typesafe.key";
+function jevKeyPath(caveatHome) {
+  return join11(caveatHome, "credentials", KEY_FILE);
+}
+function assertPrivate(path, directory) {
+  const info = lstatSync(path);
+  if (info.isSymbolicLink() || (directory ? !info.isDirectory() : !info.isFile())) throw new Error("jev_credential_unsafe");
+  if (isWindowsEnv(process.env)) runWindowsAcl(path, directory, false);
+  else if (!isPrivateOwnerStat(info, typeof process.getuid === "function" ? process.getuid() : void 0)) {
+    throw new Error("jev_credential_unsafe");
+  }
+}
+function readJevKey(caveatHome) {
+  const directory = join11(caveatHome, "credentials");
+  const path = jevKeyPath(caveatHome);
+  assertPrivate(directory, true);
+  assertPrivate(path, false);
+  const key = readFileSync6(path, "utf8").trim();
+  if (!key || /[\r\n]/u.test(key)) throw new Error("jev_credential_invalid");
+  return key;
+}
+function writeJevKey(caveatHome, value) {
+  const key = value.trim();
+  if (!key || /[\r\n]/u.test(key)) throw new Error("jev_credential_invalid");
+  const directory = join11(caveatHome, "credentials");
+  const created = !existsSync11(directory);
+  mkdirSync5(directory, { recursive: true, mode: 448 });
+  if (created && isWindowsEnv(process.env)) runWindowsAcl(directory, true, true);
+  assertPrivate(directory, true);
+  const path = jevKeyPath(caveatHome);
+  if (existsSync11(path)) assertPrivate(path, false);
+  const temporary = join11(directory, `.typesafe-${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    writeFileSync3(temporary, `${key}
+`, { encoding: "utf8", mode: 384, flag: "wx" });
+    if (isWindowsEnv(process.env)) runWindowsAcl(temporary, false, true);
+    assertPrivate(temporary, false);
+    renameSync2(temporary, path);
+    assertPrivate(path, false);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+
+// src/hookDelivery.ts
+import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join13 } from "node:path";
+
+// src/hookShared.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join12 } from "node:path";
 import { createHash } from "node:crypto";
-var MAX_CONTEXT_BLOCKS = 3;
 var STOP_REMINDER_PREFIX = "[caveat] \u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3067\u5916\u90E8\u4ED5\u69D8\u306E\u7F60\u306B\u5F53\u305F\u3063\u305F\u53EF\u80FD\u6027\u3092\u793A\u3059\u30B7\u30B0\u30CA\u30EB:";
 function hookSilentLogger(host) {
   return {
@@ -33058,7 +32958,10 @@ function searchCaveatsSafely(host, input) {
     const searchOptions = {
       selfIdentity: defaultSelfIdentityTokens()
     };
-    hits = inputs.length === 1 ? findCaveatsForHook(db, inputs[0], searchOptions) : findCaveatsForHookSegments(db, inputs, searchOptions);
+    const found = inputs.length === 1 ? findCaveatsForHook(db, inputs[0], searchOptions) : findCaveatsForHookSegments(db, inputs, searchOptions);
+    const taskText = inputs.map(({ topicText, failureText }) => `${topicText}
+${failureText}`).join("\n");
+    hits = found.filter((hit) => environmentAppliesToTask(hit.environment, taskText, fingerprint().os));
   } catch (err) {
     reportHookError(host, "search error", err);
     return [];
@@ -33085,41 +32988,39 @@ function searchCaveatsSafely(host, input) {
 function pendingCleanupFailureText(host) {
   return `[${host.stderrTag}] pending reminder cleanup failed`;
 }
-function drainForSession(host, sessionId) {
+function peekForSession(host, sessionId) {
   const ctx = buildContextSafely(host);
-  if (!ctx) return [];
-  const local = drainPendingRemindersDetailed(ctx.caveatHome, sessionId);
-  const global = drainPendingRemindersDetailed(ctx.caveatHome, "_global");
-  for (const _failure of [...local.cleanupFailures, ...global.cleanupFailures]) {
+  if (!ctx) return { contexts: [], paths: [], caveatHome: null };
+  const local = peekPendingRemindersDetailed(ctx.caveatHome, sessionId);
+  const global = peekPendingRemindersDetailed(ctx.caveatHome, "_global");
+  for (const _failure of [...local.readFailures, ...global.readFailures]) {
     process.stderr.write(`${pendingCleanupFailureText(host)}
 `);
   }
-  return [...local.reminders, ...global.reminders];
+  const reminders = [...local.reminders, ...global.reminders];
+  return { contexts: reminders.map(({ text }) => text), paths: reminders.map(({ path }) => path), caveatHome: ctx.caveatHome };
 }
-function contextDedupeKey(host, text) {
-  if (text.startsWith(STOP_REMINDER_PREFIX)) return host.stopDedupeKey;
-  return text.trim();
+function acknowledgeSessionReminders(host, peeked) {
+  if (!peeked.caveatHome || peeked.paths.length === 0) return;
+  try {
+    acknowledgePendingReminders(peeked.caveatHome, peeked.paths);
+  } catch (error51) {
+    process.stderr.write(`[${host.stderrTag}] pending reminder cleanup failed: ${errorMessage4(error51)}
+`);
+  }
 }
-function compactContexts(host, contexts) {
-  const selected = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (let i = contexts.length - 1; i >= 0; i -= 1) {
-    const text = contexts[i]?.trim();
-    if (!text) continue;
-    const key = contextDedupeKey(host, text);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    selected.push(text);
-  }
-  selected.reverse();
-  const limited = selected.slice(-MAX_CONTEXT_BLOCKS);
-  const omitted = selected.length - limited.length;
-  if (omitted > 0) {
-    limited.push(
-      `[caveat] pending reminder ${omitted} \u4EF6\u3092\u91CD\u8907\u307E\u305F\u306F\u4E0A\u9650\u306B\u3088\u308A\u7701\u7565\u3057\u307E\u3057\u305F\u3002`
-    );
+async function emitHookContext(host, output) {
+  try {
+    await new Promise((resolve, reject) => process.stdout.write(
+      output,
+      (error51) => error51 ? reject(error51) : resolve()
+    ));
+    return true;
+  } catch (error51) {
+    process.stderr.write(`[${host.stderrTag}] stdout write failed: ${errorMessage4(error51)}
+`);
+    return false;
   }
-  return limited;
 }
 function sanitizeStateId(raw) {
   const clean = raw.replace(/[^A-Za-z0-9_-]/g, "");
@@ -33127,18 +33028,19 @@ function sanitizeStateId(raw) {
 }
 function stopSignalKey(signals, related) {
   const body = JSON.stringify({
-    toolFailureCount: signals.toolFailureCount,
-    fileEditCounts: signals.fileEditCounts.map((e) => [e.path, e.count]),
-    webSearchCount: signals.webSearchCount,
-    webFetchCount: signals.webFetchCount,
-    bashRetryCount: signals.bashRetryCount,
-    searchQueries: signals.searchQueries,
-    related: related.map((h) => [h.source, h.id])
+    signalKinds: [
+      signals.toolFailureCount > 0 && "tool_failure",
+      signals.fileEditCounts.length > 0 && "reedit",
+      signals.webSearchCount > 0 && "web_search",
+      signals.webFetchCount > 0 && "web_fetch",
+      signals.bashRetryCount > 0 && "bash_retry"
+    ].filter(Boolean),
+    related: related.map((h) => [h.source, h.id]).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)))
   });
   return createHash("sha256").update(body).digest("hex");
 }
 function stopStatePath(host, caveatHome, sessionId) {
-  return join13(caveatHome, host.stopStateDir, `${sanitizeStateId(sessionId)}.txt`);
+  return join12(caveatHome, host.stopStateDir, `${sanitizeStateId(sessionId)}.txt`);
 }
 function wasStopReminderQueued(host, caveatHome, sessionId, key) {
   const path = stopStatePath(host, caveatHome, sessionId);
@@ -33150,7 +33052,7 @@ function wasStopReminderQueued(host, caveatHome, sessionId, key) {
 }
 function markStopReminderQueued(host, caveatHome, sessionId, key) {
   const path = stopStatePath(host, caveatHome, sessionId);
-  mkdirSync5(join13(caveatHome, host.stopStateDir), { recursive: true });
+  mkdirSync6(join12(caveatHome, host.stopStateDir), { recursive: true });
   writeFileSync4(path, key, "utf-8");
 }
 function queueStopForSession(host, sessionId, signals, related, buildText) {
@@ -33203,6 +33105,313 @@ function extractToolResponseText(response) {
   return "";
 }
 
+// src/hookDelivery.ts
+function statePath(caveatHome, sessionId) {
+  return join13(caveatHome, "hook-delivery", `${createHash2("sha256").update(sessionId).digest("hex")}.json`);
+}
+function readState(caveatHome, sessionId) {
+  const path = statePath(caveatHome, sessionId);
+  if (!existsSync13(path)) return { ids: [], signals: [] };
+  const value = JSON.parse(readFileSync8(path, "utf8"));
+  if (!value || typeof value !== "object" || !("ids" in value) || !("signals" in value) || !Array.isArray(value.ids) || !value.ids.every((item) => typeof item === "string") || !Array.isArray(value.signals) || !value.signals.every((item) => typeof item === "string")) {
+    throw new Error("hook_delivery_state_invalid");
+  }
+  return value;
+}
+function writeState(caveatHome, sessionId, state) {
+  const path = statePath(caveatHome, sessionId);
+  mkdirSync7(join13(caveatHome, "hook-delivery"), { recursive: true, mode: 448 });
+  const temporary = `${path}.${randomBytes2(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync5(temporary, `${JSON.stringify(state)}
+`, { encoding: "utf8", mode: 384, flag: "wx" });
+    renameSync3(temporary, path);
+  } finally {
+    rmSync2(temporary, { force: true });
+  }
+}
+function wasHitDelivered(caveatHome, sessionId, ref) {
+  return readState(caveatHome, sessionId).ids.includes(ref);
+}
+var SIGNAL_LINES = [
+  [/^- tool failure:/u, "tool_failure", "\u30C4\u30FC\u30EB\u5931\u6557"],
+  [/^- 同一ファイル複数編集:/u, "reedit", "\u540C\u4E00\u30D5\u30A1\u30A4\u30EB\u306E\u518D\u7DE8\u96C6"],
+  [/^- WebSearch:/u, "web_search", "Web\u691C\u7D22"],
+  [/^- WebFetch:/u, "web_fetch", "Web\u53D6\u5F97"],
+  [/^- 同一 Bash コマンドの再実行:/u, "bash_retry", "\u540C\u4E00\u30B3\u30DE\u30F3\u30C9\u306E\u518D\u5B9F\u884C"]
+];
+function prepareSessionDelivery(caveatHome, sessionId, contexts, additionallyDeliveredIds = []) {
+  const state = readState(caveatHome, sessionId);
+  const seenIds = /* @__PURE__ */ new Set([...state.ids, ...additionallyDeliveredIds]);
+  const seenSignals = new Set(state.signals);
+  const addedIds = [];
+  const addedSignals = [];
+  const hitLines = [];
+  const signalLabels = [];
+  const others = [];
+  for (const context of contexts) {
+    const text = context.trim();
+    if (!text) continue;
+    const lines = text.split("\n");
+    const isStop = text.startsWith(STOP_REMINDER_PREFIX);
+    let hasHit = false;
+    for (const line of lines) {
+      const hit = /^\d+\. ([^\s]+) \(([^)]+)\) — (.+)$/u.exec(line);
+      if (hit) {
+        hasHit = true;
+        const ref = `${hit[2]}/${hit[1]}`;
+        if (seenIds.has(ref)) continue;
+        seenIds.add(ref);
+        addedIds.push(ref);
+        hitLines.push(`${hit[1]} (${hit[2]}) \u2014 ${hit[3]}`);
+      }
+      if (isStop) {
+        for (const [pattern, kind, label] of SIGNAL_LINES) {
+          if (pattern.test(line) && !seenSignals.has(kind)) {
+            seenSignals.add(kind);
+            addedSignals.push(kind);
+            signalLabels.push(label);
+          }
+        }
+      }
+    }
+    if (isStop || hasHit) continue;
+    if (!others.includes(text)) others.push(text);
+  }
+  const texts = [...others];
+  if (signalLabels.length > 0) texts.push(`[caveat] \u65B0\u3057\u3044\u82E6\u6226\u30B7\u30B0\u30CA\u30EB: ${signalLabels.join("\u3001")}\u3002\u5FC5\u8981\u306A\u3089Caveat\u3067\u77E5\u898B\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002`);
+  if (hitLines.length > 0) texts.push(`[caveat] \u65B0\u3057\u304F\u8A72\u5F53\u3057\u305F\u7F60:
+${hitLines.map((line) => `- ${line}`).join("\n")}
+\u8A73\u7D30\u306FCaveat\u3067\u53D6\u5F97\u3057\u3001\u9069\u7528\u6761\u4EF6\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002`);
+  return {
+    texts,
+    delivered: () => {
+      if (addedIds.length === 0 && addedSignals.length === 0 && additionallyDeliveredIds.length === 0) return;
+      const latest = readState(caveatHome, sessionId);
+      writeState(caveatHome, sessionId, {
+        ids: [.../* @__PURE__ */ new Set([...latest.ids, ...addedIds, ...additionallyDeliveredIds])],
+        signals: [.../* @__PURE__ */ new Set([...latest.signals, ...addedSignals])]
+      });
+    }
+  };
+}
+
+// src/jevStruggle.ts
+var MODEL = "jev-1.13.0";
+var API_URL = "https://api.typesafe.ai/v1/systemone";
+var STRUGGLE_THRESHOLD = 0.85;
+var MATCH_THRESHOLD = 0.85;
+var MAX_TERMS = 48;
+var MAX_CANDIDATES = 20;
+async function callJev(key, state, questions, fetcher = fetch) {
+  const response = await fetcher(API_URL, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ state, model: MODEL, questions }),
+    signal: AbortSignal.timeout(1500)
+  });
+  if (!response.ok) throw new Error(`jev_http_${response.status}`);
+  const body = await response.json();
+  if (!isRecord(body) || !isRecord(body.answers)) throw new Error("jev_response_invalid");
+  return body;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function noul(answer) {
+  if (answer?.type !== "noul" || typeof answer.noul !== "number" || !Number.isFinite(answer.noul) || answer.noul < 0 || answer.noul > 1) {
+    throw new Error("jev_noul_invalid");
+  }
+  return answer.noul;
+}
+function choice(answer, allowed) {
+  if (answer?.type !== "choice" || !allowed.has(answer.choice)) throw new Error("jev_choice_invalid");
+  return answer.choice;
+}
+function candidateTerms(turns) {
+  const seen = /* @__PURE__ */ new Set();
+  const terms = [];
+  const groups = [...turns].reverse().map((turn) => [turn.user, turn.thinking, turn.assistant].flatMap((part) => extractPromptCandidates(
+    part.replace(/(?<=[A-Za-z0-9])(?=[\u3040-\u30ff\u3400-\u9fff])|(?<=[\u3040-\u30ff\u3400-\u9fff])(?=[A-Za-z0-9])/gu, " ")
+  )));
+  const add = (term) => {
+    const key = term.toLocaleLowerCase();
+    if (seen.has(key) || terms.length >= MAX_TERMS) return;
+    seen.add(key);
+    terms.push(term);
+  };
+  for (const group of groups) {
+    let added = 0;
+    for (const term of group) {
+      const before = terms.length;
+      add(term);
+      if (terms.length > before) added++;
+      if (added === 12) break;
+    }
+  }
+  for (const group of groups) for (const term of group) add(term);
+  return terms;
+}
+async function judgeStruggle(key, turns, ask = callJev) {
+  const terms = candidateTerms(turns);
+  const options = Object.fromEntries(terms.map((term, index) => [`term_${index}`, term]));
+  const questions = {
+    repeated_problem: { type: "noul", instructions: "Across these three ordered turns, is the coding agent repeatedly correcting attempts at the same unresolved task or problem? Judge the meaning of its dialogue and Thinking, not the number of tool calls." },
+    clearly_stuck: { type: "noul", instructions: "At the end of turn 3, is the agent clearly struggling with an unresolved problem rather than making a brief, ordinary correction or verification?" }
+  };
+  if (terms.length > 0) questions.search_term = {
+    type: "choice",
+    instructions: "If the agent is struggling, which exact term from these options would best retrieve a useful Caveat knowledge entry about the concrete unresolved problem? Select none when no option identifies it.",
+    criteria: { ...options, none: "No listed term would retrieve useful knowledge about this problem." }
+  };
+  const response = await ask(key, { turns }, questions);
+  const struggling = noul(response.answers.repeated_problem) >= STRUGGLE_THRESHOLD && noul(response.answers.clearly_stuck) >= STRUGGLE_THRESHOLD;
+  if (!struggling || terms.length === 0) return { struggling, term: null };
+  const selected = choice(response.answers.search_term, /* @__PURE__ */ new Set([...Object.keys(options), "none"]));
+  return { struggling, term: selected === "none" ? null : terms[Number(selected.slice(5))] ?? null };
+}
+async function rankKnowledge(key, turns, candidates, ask = callJev) {
+  if (candidates.length === 0) return null;
+  const state = {
+    turns,
+    currentHostOs: fingerprint().os,
+    candidates: candidates.map(({ hit, entry }) => {
+      const { applies_to_os: appliesToOs = null, ...recordedEnvironment } = hit.environment;
+      return {
+        title: hit.title,
+        symptom: hit.symptomExcerpt,
+        cause: entry.sections.Cause?.slice(0, 300) ?? "",
+        resolution: entry.sections.Resolution?.slice(0, 600) ?? "",
+        recordedEnvironment,
+        appliesToOs
+      };
+    })
+  };
+  const questions = Object.fromEntries(candidates.map((_, index) => [`candidate_${index}`, {
+    type: "noul",
+    instructions: `Does candidates[${index}] directly apply to the unresolved problem shown in the turns and offer a useful resolution? A recordedEnvironment value is where the entry was observed, not a restriction. Only appliesToOs restricts the target OS; null means any OS. currentHostOs may differ from the task's target OS.`
+  }]));
+  const response = await ask(key, state, questions);
+  let best = null;
+  let bestScore = MATCH_THRESHOLD;
+  for (let index = 0; index < candidates.length; index++) {
+    const score = noul(response.answers[`candidate_${index}`]);
+    if (score >= MATCH_THRESHOLD && (best === null || score > bestScore)) {
+      best = candidates[index];
+      bestScore = score;
+    }
+  }
+  return best;
+}
+function quotePowerShell(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function readThroughlineContext(host, sessionId, projectRoot, transcriptPath) {
+  const sourceId = host === "codex" && !sessionId.startsWith("codex:") ? `codex:${sessionId}` : sessionId;
+  const args = ["caveat-context", "--session", sourceId, "--project", projectRoot, "--host", host, "--transcript", transcriptPath, "--json"];
+  const invocation = isWindows() ? { command: "pwsh.exe", args: ["-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(`& throughline.cmd ${args.map(quotePowerShell).join(" ")}; exit $LASTEXITCODE`, "utf16le").toString("base64")] } : { command: "throughline", args };
+  const result = spawnSync3(invocation.command, invocation.args, { encoding: "utf8", timeout: 1500, maxBuffer: 128 * 1024, windowsHide: true });
+  if (result.error || result.status !== 0) throw new Error("throughline_context_failed");
+  const value = JSON.parse(result.stdout);
+  if (!isRecord(value) || value.schema !== "throughline.caveat_context.v1" || typeof value.status !== "string" || !Array.isArray(value.turns)) {
+    throw new Error("throughline_context_invalid");
+  }
+  return value;
+}
+function statePath2(caveatHome, sessionId) {
+  const digest = createHash3("sha256").update(sessionId).digest("hex");
+  return join14(caveatHome, "jev-sessions", `${digest}.json`);
+}
+function loadState(caveatHome, sessionId) {
+  const path = statePath2(caveatHome, sessionId);
+  if (!existsSync14(path)) return { lastTurn: null, deliveredIds: [], notifiedTerms: [] };
+  const value = JSON.parse(readFileSync9(path, "utf8"));
+  if (!isRecord(value) || value.lastTurn !== null && typeof value.lastTurn !== "string" || !Array.isArray(value.deliveredIds) || !value.deliveredIds.every((item) => typeof item === "string") || !Array.isArray(value.notifiedTerms) || !value.notifiedTerms.every((item) => typeof item === "string")) throw new Error("jev_state_invalid");
+  return value;
+}
+function saveState(caveatHome, sessionId, state) {
+  const path = statePath2(caveatHome, sessionId);
+  mkdirSync8(join14(caveatHome, "jev-sessions"), { recursive: true, mode: 448 });
+  const temporary = `${path}.${randomBytes3(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync6(temporary, `${JSON.stringify(state)}
+`, { encoding: "utf8", mode: 384, flag: "wx" });
+    renameSync4(temporary, path);
+  } finally {
+    rmSync3(temporary, { force: true });
+  }
+}
+function reminder(hit) {
+  if (!hit) return "[caveat] \u540C\u3058\u554F\u984C\u3078\u306E\u8A66\u884C\u304C\u7D9A\u304D\u3001\u307E\u3060\u89E3\u6C7A\u3057\u3066\u3044\u306A\u3044\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002\u5FC5\u8981\u306B\u3088\u308ACaveat\u3067\u691C\u7D22\u3057\u3066\u307F\u3066\u304F\u3060\u3055\u3044\u3002";
+  const resolution = hit.entry.sections.Resolution?.replace(/\s+/g, " ").trim().slice(0, 500) ?? "";
+  return `[caveat] \u540C\u3058\u554F\u984C\u3078\u306E\u8A66\u884C\u304C\u7D9A\u3044\u3066\u3044\u307E\u3059\u3002\u95A2\u9023\u77E5\u898B: ${hit.hit.title} (${hit.hit.source}/${hit.hit.id})
+\u5BFE\u51E6: ${resolution}
+\u3053\u306E\u56DE\u7B54\u3067\u89E3\u6C7A\u3057\u306A\u3044\u5834\u5408\u3001\u5FC5\u8981\u306B\u3088\u308ACaveat\u3067\u691C\u7D22\u3057\u3066\u307F\u3066\u304F\u3060\u3055\u3044\u3002`;
+}
+async function runJevStruggle(ctx, host, payload, deps = {}) {
+  if (!ctx.config.jevEnabled) return null;
+  const sessionId = payload.session_id ?? payload.sessionId;
+  const transcriptPath = payload.transcript_path ?? payload.transcriptPath;
+  if (typeof sessionId !== "string" || !sessionId || typeof transcriptPath !== "string" || !transcriptPath) {
+    throw new Error("jev_hook_context_missing");
+  }
+  const projectRoot = typeof payload.cwd === "string" && payload.cwd ? payload.cwd : process.cwd();
+  const context = (deps.readContext ?? readThroughlineContext)(host, sessionId, projectRoot, transcriptPath);
+  if (["unavailable", "incomplete", "projection_pending"].includes(context.status)) return null;
+  if (context.status !== "ready" || context.turns.length !== 3) throw new Error(`throughline_context_${context.status}`);
+  const latest = context.turns[2];
+  const turnKey = `${latest.originSessionId}:${latest.turnNumber}`;
+  const state = loadState(ctx.caveatHome, sessionId);
+  if (state.lastTurn === turnKey) return null;
+  const key = (deps.readKey ?? readJevKey)(ctx.caveatHome);
+  const ask = deps.ask ?? callJev;
+  const judgment = await judgeStruggle(key, context.turns, ask);
+  state.lastTurn = turnKey;
+  if (!judgment.struggling) {
+    saveState(ctx.caveatHome, sessionId, state);
+    return null;
+  }
+  let candidates = [];
+  if (judgment.term) {
+    if (!existsSync14(ctx.paths.dbPath)) throw new Error("jev_knowledge_index_missing");
+    const db = openDb({ path: ctx.paths.dbPath });
+    try {
+      const taskText = context.turns.map((turn) => `${turn.user}
+${turn.assistant}
+${turn.thinking}`).join("\n");
+      candidates = search(db, { query: judgment.term, limit: MAX_CANDIDATES }).filter((hit) => environmentAppliesToTask(hit.environment, taskText, fingerprint().os)).map((hit) => ({ hit, entry: get(db, hit.id, hit.source) })).filter((item) => item.entry !== null).filter((item) => Boolean(item.entry.sections.Resolution));
+    } finally {
+      db.close();
+    }
+  }
+  const selected = await rankKnowledge(key, context.turns, candidates, ask);
+  const id = selected ? `${selected.hit.source}/${selected.hit.id}` : null;
+  const term = judgment.term ?? "_none";
+  if (id && (state.deliveredIds.includes(id) || wasHitDelivered(ctx.caveatHome, sessionId, id)) || !id && state.notifiedTerms.includes(term)) {
+    saveState(ctx.caveatHome, sessionId, state);
+    return null;
+  }
+  return {
+    text: reminder(selected),
+    ref: id,
+    delivered: () => {
+      const current = loadState(ctx.caveatHome, sessionId);
+      current.lastTurn = turnKey;
+      if (id && !current.deliveredIds.includes(id)) current.deliveredIds.push(id);
+      if (!id && !current.notifiedTerms.includes(term)) current.notifiedTerms.push(term);
+      saveState(ctx.caveatHome, sessionId, current);
+      if (selected) {
+        const db = openDb({ path: ctx.paths.dbPath });
+        try {
+          markHit(db, [selected.hit]);
+        } finally {
+          db.close();
+        }
+      }
+    }
+  };
+}
+
 // src/commands/hookCmd.ts
 var CLAUDE_HOST = {
   agent: "claude",
@@ -33262,10 +33471,10 @@ function spawnWorker(job) {
   try {
     root = workerRoot();
     sweepStaleWorkerDirs(Date.now(), root);
-    workDir = mkdtempSync2(join14(root, "job-"));
+    workDir = mkdtempSync(join15(root, "job-"));
     chmodSync(workDir, 448);
-    workFile = join14(workDir, `${randomBytes(4).toString("hex")}.json`);
-    writeFileSync5(workFile, JSON.stringify({ ...job, schemaVersion: "caveat-worker-job/v2" }), { encoding: "utf-8", mode: 384, flag: "wx" });
+    workFile = join15(workDir, `${randomBytes4(4).toString("hex")}.json`);
+    writeFileSync7(workFile, JSON.stringify({ ...job, schemaVersion: "caveat-worker-job/v2" }), { encoding: "utf-8", mode: 384, flag: "wx" });
   } catch (err) {
     process.stderr.write(`[caveat:hook] worker writefile error: ${errorMessage4(err)}
 `);
@@ -33296,7 +33505,7 @@ function spawnWorker(job) {
 async function runWorker(workFile) {
   let raw;
   try {
-    raw = readFileSync8(workFile, "utf-8");
+    raw = readFileSync10(workFile, "utf-8");
   } catch {
     process.exit(0);
   }
@@ -33322,7 +33531,7 @@ async function runWorker(workFile) {
       agent: "claude",
       surface: "tool_error",
       refs: hits
-    }), () => buildToolErrorReminder(job, hits));
+    }), () => toolErrorReminderText(hits));
   } catch {
     process.stderr.write("[caveat:hook] pending reminder build or publish failed\n");
     process.exit(0);
@@ -33333,17 +33542,17 @@ async function runWorker(workFile) {
 function cleanupWorkerDir(workDir, root) {
   if (!workDir || !root || !isOwnedWorkerDir(workDir, root)) return;
   try {
-    rmSync2(workDir, { recursive: true, force: true });
+    rmSync4(workDir, { recursive: true, force: true });
   } catch {
   }
 }
 function isOwnedWorkerDir(path, root = workerRoot()) {
   try {
-    const inputStat = lstatSync(path);
+    const inputStat = lstatSync2(path);
     if (inputStat.isSymbolicLink()) return false;
     const tmpRoot = realpathSync3(root);
     const resolved = realpathSync3(path);
-    const stat = lstatSync(resolved);
+    const stat = lstatSync2(resolved);
     const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
     return dirname5(resolved) === tmpRoot && basename(resolved).startsWith("job-") && stat.isDirectory() && !stat.isSymbolicLink() && hasPrivateOwnership(stat, uid);
   } catch {
@@ -33360,41 +33569,41 @@ function sweepStaleWorkerDirs(now = Date.now(), root = workerRoot()) {
   }
   for (const entry of entries) {
     if (!entry.startsWith("job-")) continue;
-    const path = join14(root, entry);
+    const path = join15(root, entry);
     try {
       if (!isOwnedWorkerDir(path, root)) continue;
-      const stat = lstatSync(path);
+      const stat = lstatSync2(path);
       if (now - stat.mtimeMs <= WORKER_STALE_MS || !isStaleWorkerJobDir(path)) continue;
-      rmSync2(path, { recursive: true, force: true });
+      rmSync4(path, { recursive: true, force: true });
     } catch {
       process.stderr.write("[caveat:hook] worker stale cleanup failed\n");
     }
   }
 }
-function workerRoot(base = tmpdir2()) {
-  const root = join14(base, WORKER_ROOT);
-  mkdirSync6(root, { recursive: true, mode: 448 });
-  const stat = lstatSync(root);
+function workerRoot(base = tmpdir()) {
+  const root = join15(base, WORKER_ROOT);
+  mkdirSync9(root, { recursive: true, mode: 448 });
+  const stat = lstatSync2(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 = join14(root, WORKER_MARKER);
+  const marker = join15(root, WORKER_MARKER);
   try {
-    writeFileSync5(marker, "caveat-worker/v1\n", { mode: 384, flag: "wx" });
+    writeFileSync7(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) || readFileSync8(marker, "utf-8") !== "caveat-worker/v1\n") throw new Error("worker root marker is invalid");
+  const markerStat = lstatSync2(marker);
+  if (!markerStat.isFile() || markerStat.isSymbolicLink() || !hasPrivateOwnership(markerStat, uid) || readFileSync10(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 = join14(path, entries[0]);
-  const stat = lstatSync(file2);
+  const file2 = join15(path, entries[0]);
+  const stat = lstatSync2(file2);
   const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
   if (!stat.isFile() || stat.isSymbolicLink() || !hasPrivateOwnership(stat, uid)) return false;
-  return isKnownStaleWorkerJob(JSON.parse(readFileSync8(file2, "utf-8")));
+  return isKnownStaleWorkerJob(JSON.parse(readFileSync10(file2, "utf-8")));
 }
 function hasPrivateOwnership(stat, uid) {
   return isPrivateOwnerStat(stat, uid);
@@ -33416,7 +33625,7 @@ function isKnownStaleWorkerJob(value) {
 }
 function writeLastReindex(caveatHome, value) {
   try {
-    writeFileSync5(join14(caveatHome, "index", ".last-reindex.json"), JSON.stringify(value), "utf-8");
+    writeFileSync7(join15(caveatHome, "index", ".last-reindex.json"), JSON.stringify(value), "utf-8");
   } catch (err) {
     process.stderr.write(`[caveat:hook] reindex status write error: ${errorMessage4(err)}
 `);
@@ -33428,7 +33637,7 @@ async function runReindexWorker() {
     return;
   }
   const ctx = buildContextSafely(CLAUDE_HOST);
-  if (!ctx || !existsSync13(ctx.paths.dbPath)) {
+  if (!ctx || !existsSync15(ctx.paths.dbPath)) {
     process.stderr.write("[caveat:hook] auto reindex skipped: index database does not exist\n");
     return;
   }
@@ -33490,81 +33699,6 @@ async function runAutoSyncWorker() {
 `);
   }
 }
-function buildToolErrorReminder(job, hits) {
-  const base = toolErrorReminderText(hits);
-  const mode = hookCodexSidecarMode();
-  if (mode === "off") return base;
-  const projectRoot = process.cwd();
-  const hasSidecarConfig = existsSync13(join14(projectRoot, ".codex-sidecar.yml"));
-  if (mode === "auto" && !hasSidecarConfig) return base;
-  const advisory = runCodexSidecarAdvisory({
-    searchText: job.failureText,
-    limit: hits.length,
-    projectRoot,
-    prompt: [
-      "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(" "),
-    additionalContext: job.additionalContext
-  });
-  if (advisory.status === "ok") {
-    return [
-      base,
-      "",
-      formatCodexSidecarAdvisory(advisory)
-    ].filter(Boolean).join("\n");
-  }
-  return [
-    base,
-    "",
-    formatCodexSidecarAdvisory(advisory)
-  ].join("\n");
-}
-function hookCodexSidecarMode() {
-  const raw = process.env.CAVEAT_HOOK_CODEX_SIDECAR;
-  if (raw === "off" || raw === "auto" || raw === "require") return raw;
-  return "auto";
-}
-function buildStopReminder(signals, related) {
-  const base = stopReminderText(signals, related);
-  const mode = hookCodexSidecarMode();
-  if (mode === "off") return base;
-  const projectRoot = process.cwd();
-  const hasSidecarConfig = existsSync13(join14(projectRoot, ".codex-sidecar.yml"));
-  if (mode === "auto" && !hasSidecarConfig) return base;
-  const advisory = runCodexSidecarAdvisory({
-    searchText: struggleSearchText(signals),
-    limit: Math.max(related.length, 1),
-    projectRoot,
-    prompt: [
-      "A Claude Code session is ending after objective struggle signals.",
-      "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(" "),
-    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,
-      "",
-      formatCodexSidecarAdvisory(advisory)
-    ].filter(Boolean).join("\n");
-  }
-  return [
-    base,
-    "",
-    formatCodexSidecarAdvisory(advisory)
-  ].join("\n");
-}
 async function runHook(name, arg) {
   try {
     sweepStaleWorkerDirs();
@@ -33594,39 +33728,65 @@ async function runHook(name, arg) {
   }
   const payload = parsePayload(CLAUDE_HOST, raw);
   const sessionId = getSessionId(payload);
-  const contexts = name === "stop" ? [] : drainForSession(CLAUDE_HOST, sessionId);
+  const pending = name === "stop" ? null : peekForSession(CLAUDE_HOST, sessionId);
+  const contexts = pending?.contexts ?? [];
   if (name === "user-prompt-submit") {
+    const ctx = buildContextSafely(CLAUDE_HOST);
+    let jevNotice = null;
+    if (ctx?.config.jevEnabled) {
+      try {
+        jevNotice = await runJevStruggle(ctx, "claude", payload);
+        if (jevNotice) contexts.push(jevNotice.text);
+      } catch (err) {
+        process.stderr.write(`[caveat:hook] Jev\u5224\u5B9A\u306B\u5931\u6557: ${errorMessage4(err)}
+`);
+      }
+    }
     const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
     const hits = searchCaveatsSafely(CLAUDE_HOST, { topicText: prompt, failureText: prompt, surface: "user_prompt" });
     if (hits.length > 0) {
       contexts.push(userPromptSubmitReminderText(hits));
     }
-    const compacted = compactContexts(CLAUDE_HOST, contexts);
-    if (compacted.length > 0) {
-      process.stdout.write(`${systemReminderOutput(compacted.join("\n\n"))}
+    if (ctx) {
+      try {
+        const prepared = prepareSessionDelivery(ctx.caveatHome, sessionId, contexts, jevNotice?.ref ? [jevNotice.ref] : []);
+        const sent = prepared.texts.length === 0 || await emitHookContext(CLAUDE_HOST, `${systemReminderOutput(prepared.texts.join("\n\n"))}
 `);
+        if (sent) {
+          prepared.delivered();
+          if (jevNotice && prepared.texts.includes(jevNotice.text)) jevNotice.delivered();
+          if (pending) acknowledgeSessionReminders(CLAUDE_HOST, pending);
+        }
+      } catch (err) {
+        process.stderr.write(`[caveat:hook] \u914D\u9001\u306B\u5931\u6557: ${errorMessage4(err)}
+`);
+      }
     }
     process.exit(0);
   }
   if (name === "post-tool-use") {
-    const compacted = compactContexts(CLAUDE_HOST, contexts);
-    if (compacted.length > 0) {
-      process.stdout.write(`${systemReminderOutput(compacted.join("\n\n"))}
+    const ctx = buildContextSafely(CLAUDE_HOST);
+    if (ctx) {
+      try {
+        const prepared = prepareSessionDelivery(ctx.caveatHome, sessionId, contexts);
+        const sent = prepared.texts.length === 0 || await emitHookContext(CLAUDE_HOST, `${systemReminderOutput(prepared.texts.join("\n\n"))}
 `);
+        if (sent) {
+          prepared.delivered();
+          if (pending) acknowledgeSessionReminders(CLAUDE_HOST, pending);
+        }
+      } catch (err) {
+        process.stderr.write(`[caveat:hook] \u914D\u9001\u306B\u5931\u6557: ${errorMessage4(err)}
+`);
+      }
     }
     if (!isToolError(payload)) process.exit(0);
     const errText = extractToolResponseText(
       payload.tool_response ?? payload.toolResponse ?? payload.error ?? payload
     );
     if (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
-      });
       const topicText = toolTopicText(payload);
-      spawnWorker({ sessionId, topicText, failureText: errText, ...additionalContext ? { additionalContext } : {} });
+      spawnWorker({ sessionId, topicText, failureText: errText });
     }
     process.exit(0);
   }
@@ -33653,6 +33813,7 @@ async function runHook(name, arg) {
       }
     }
     if (payload.stop_hook_active === true) process.exit(0);
+    if (ctx?.config.jevEnabled) process.exit(0);
     const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : "";
     const signals = transcriptPath ? loadSignalsSafely(transcriptPath) : null;
     if (!signals || !hasAnyStruggleSignal(signals)) process.exit(0);
@@ -33661,7 +33822,7 @@ async function runHook(name, arg) {
       failureText,
       surface: "stop"
     })));
-    queueStopForSession(CLAUDE_HOST, sessionId, signals, related, () => buildStopReminder(signals, related));
+    queueStopForSession(CLAUDE_HOST, sessionId, signals, related, () => stopReminderText(signals, related));
     process.exit(0);
   }
   process.stderr.write(`[caveat:hook] unknown hook name: ${name}
@@ -33671,10 +33832,10 @@ async function runHook(name, arg) {
 
 // src/commands/codexHookCmd.ts
 import { spawn as spawn3, spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync9, unlinkSync, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir4, tmpdir as tmpdir3 } from "node:os";
-import { join as join15 } from "node:path";
-import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync16, readFileSync as readFileSync11, unlinkSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { homedir as homedir4, tmpdir as tmpdir2 } from "node:os";
+import { join as join16 } from "node:path";
+import { randomBytes as randomBytes5 } from "node:crypto";
 var CODEX_HOST = {
   agent: "codex",
   stderrTag: "caveat:codex-hook",
@@ -33703,10 +33864,10 @@ function processExitCodeFromText(text) {
   return m ? Number(m[1]) : null;
 }
 function transcriptToolOutput(transcriptPath, toolUseId) {
-  if (!transcriptPath || !toolUseId || !existsSync14(transcriptPath)) return null;
+  if (!transcriptPath || !toolUseId || !existsSync16(transcriptPath)) return null;
   let raw = "";
   try {
-    raw = readFileSync9(transcriptPath, "utf-8");
+    raw = readFileSync11(transcriptPath, "utf-8");
   } catch {
     return null;
   }
@@ -33749,26 +33910,28 @@ function toolInputText(input) {
   const command = r.command ?? r.cmd;
   return typeof command === "string" ? command : "";
 }
-function isCodexToolError(payload) {
-  if (payload.is_error === true) return true;
-  const topExit = numericExitCode(payload.exit_code ?? payload.exitCode);
-  if (topExit !== null) return topExit !== 0;
+function codexToolStatus(payload) {
+  if (payload.is_error === true) return "failed";
   const resp = payload.tool_response ?? payload.toolResponse;
+  if (resp !== null && typeof resp === "object" && !Array.isArray(resp) && resp.is_error === true) return "failed";
+  const topExit = numericExitCode(payload.exit_code ?? payload.exitCode);
+  if (topExit !== null) return topExit === 0 ? "succeeded" : "failed";
   if (resp !== null && typeof resp === "object" && !Array.isArray(resp)) {
     const r = resp;
-    if (r.is_error === true) return true;
-    const exit2 = numericExitCode(r.exit_code ?? r.exitCode);
-    if (exit2 !== null) return exit2 !== 0;
+    const exit = numericExitCode(r.exit_code ?? r.exitCode);
+    if (exit !== null) return exit === 0 ? "succeeded" : "failed";
   }
   const responseExit = processExitCodeFromText(extractToolResponseText(resp));
-  if (responseExit !== null) return responseExit !== 0;
+  if (responseExit !== null) return responseExit === 0 ? "succeeded" : "failed";
   const transcriptExit = transcriptExitCode(payload);
-  if (transcriptExit !== null) return transcriptExit !== 0;
-  return false;
+  if (transcriptExit !== null) return transcriptExit === 0 ? "succeeded" : "failed";
+  return "unknown";
 }
 function buildCodexPostToolUseWorkerJob(payload) {
   const sessionId = codexSessionId(payload);
   if (!sessionId) return null;
+  const status2 = codexToolStatus(payload);
+  if (status2 === "succeeded") return null;
   const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : void 0;
   const toolUseId = typeof payload.tool_use_id === "string" ? payload.tool_use_id : void 0;
   const responseText = extractToolResponseText(payload.tool_response ?? payload.toolResponse);
@@ -33776,8 +33939,7 @@ function buildCodexPostToolUseWorkerJob(payload) {
   const transcriptOutput = transcriptPath && toolUseId ? transcriptToolOutput(transcriptPath, toolUseId) : null;
   const topicText = inputText.trim();
   const failureText = [responseText, transcriptOutput ?? ""].map((s) => s.trim()).filter(Boolean).join("\n");
-  const knownError = isCodexToolError(payload);
-  if (knownError) {
+  if (status2 === "failed") {
     return { sessionId, topicText, failureText, knownError: true, transcriptPath, toolUseId };
   }
   if (transcriptPath && toolUseId && isShellLikeTool(payload) && (topicText || failureText)) {
@@ -33817,9 +33979,9 @@ async function processCodexWorkerJob(job, opts = { waitForTranscript: true }) {
   if (opts.waitForTranscript && job.transcriptPath && job.toolUseId) {
     const transcriptOutput = await waitForTranscriptOutput(job.transcriptPath, job.toolUseId);
     if (transcriptOutput) {
-      const exit2 = processExitCodeFromText(transcriptOutput);
-      if (exit2 !== null) {
-        if (exit2 === 0) return;
+      const exit = processExitCodeFromText(transcriptOutput);
+      if (exit !== null) {
+        if (exit === 0) return;
         knownError = true;
       }
       failureText = [failureText, transcriptOutput].filter(Boolean).join("\n");
@@ -33850,7 +34012,7 @@ async function processCodexWorkerJob(job, opts = { waitForTranscript: true }) {
 async function runCodexWorker(workFile) {
   let raw;
   try {
-    raw = readFileSync9(workFile, "utf-8");
+    raw = readFileSync11(workFile, "utf-8");
   } catch {
     process.exit(0);
   }
@@ -33867,7 +34029,7 @@ async function runCodexWorker(workFile) {
   await processCodexWorkerJob(job);
   process.exit(0);
 }
-function runDiagnostics(codexHome = process.env.CODEX_HOME ?? join15(homedir4(), ".codex")) {
+function runDiagnostics(codexHome = process.env.CODEX_HOME ?? join16(homedir4(), ".codex")) {
   const features = spawnSync4("codex", ["features", "list"], {
     encoding: "utf-8",
     maxBuffer: 1024 * 1024,
@@ -33915,16 +34077,38 @@ async function runCodexHook(name, arg) {
   const sessionId = codexSessionId(payload);
   if (!sessionId) process.stderr.write("[caveat:codex-hook] missing session_id; pending drain disabled\n");
   if (name === "user-prompt-submit") {
-    const contexts = sessionId ? drainForSession(CODEX_HOST, sessionId) : [];
+    const pending = sessionId ? peekForSession(CODEX_HOST, sessionId) : null;
+    const contexts = pending?.contexts ?? [];
+    const ctx = buildContextSafely(CODEX_HOST);
+    let jevNotice = null;
+    if (ctx?.config.jevEnabled) {
+      try {
+        jevNotice = await runJevStruggle(ctx, "codex", payload);
+        if (jevNotice) contexts.push(jevNotice.text);
+      } catch (err) {
+        process.stderr.write(`[caveat:codex-hook] Jev\u5224\u5B9A\u306B\u5931\u6557: ${errorMessage4(err)}
+`);
+      }
+    }
     const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
     const hits = searchCaveatsSafely(CODEX_HOST, { topicText: prompt, failureText: prompt, surface: "user_prompt" });
     if (hits.length > 0) {
       contexts.push(userPromptSubmitReminderText(hits, "native-cli"));
     }
-    const compacted = compactContexts(CODEX_HOST, contexts);
-    if (compacted.length > 0) {
-      process.stdout.write(`${codexContextOutput(compacted.join("\n\n"))}
+    if (ctx) {
+      try {
+        const prepared = prepareSessionDelivery(ctx.caveatHome, sessionId ?? "_unknown", contexts, jevNotice?.ref ? [jevNotice.ref] : []);
+        const sent = prepared.texts.length === 0 || await emitHookContext(CODEX_HOST, `${codexContextOutput(prepared.texts.join("\n\n"))}
+`);
+        if (sent) {
+          prepared.delivered();
+          if (jevNotice && prepared.texts.includes(jevNotice.text)) jevNotice.delivered();
+          if (pending) acknowledgeSessionReminders(CODEX_HOST, pending);
+        }
+      } catch (err) {
+        process.stderr.write(`[caveat:codex-hook] \u914D\u9001\u306B\u5931\u6557: ${errorMessage4(err)}
 `);
+      }
     }
     process.exit(0);
   }
@@ -33956,6 +34140,7 @@ async function runCodexHook(name, arg) {
 `);
     }
     if (payload.stop_hook_active === true) process.exit(0);
+    if (buildContextSafely(CODEX_HOST)?.config.jevEnabled) process.exit(0);
     const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : "";
     const signals = transcriptPath ? loadSignalsSafely2(transcriptPath) : null;
     if (!signals || !hasAnyStruggleSignal(signals)) process.exit(0);
@@ -33974,7 +34159,7 @@ async function runCodexHook(name, arg) {
 
 // src/commands/cursorHookCmd.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 var CURSOR_HOST = {
   agent: "cursor",
   stderrTag: "caveat:cursor-hook",
@@ -34014,7 +34199,7 @@ function loadSignalsSafely3(path) {
     return null;
   }
 }
-function runDiagnostics2(cursorDir = join16(homedir5(), ".cursor")) {
+function runDiagnostics2(cursorDir = join17(homedir5(), ".cursor")) {
   const installation = detectCursorHookInstallation(cursorDir);
   process.stdout.write(`${JSON.stringify({
     installation: installation.installation,
@@ -34039,7 +34224,24 @@ async function runCursorHook(name, arg) {
   }
   const payload = parsePayload(CURSOR_HOST, raw);
   const sessionId = cursorSessionId(payload);
-  const contexts = name === "stop" ? [] : drainForSession(CURSOR_HOST, sessionId);
+  const pending = name === "stop" ? null : peekForSession(CURSOR_HOST, sessionId);
+  const contexts = pending?.contexts ?? [];
+  const deliver = async () => {
+    const ctx = buildContextSafely(CURSOR_HOST);
+    if (!ctx) return;
+    try {
+      const prepared = prepareSessionDelivery(ctx.caveatHome, sessionId, contexts);
+      const sent = prepared.texts.length === 0 || await emitHookContext(CURSOR_HOST, `${cursorContextOutput(prepared.texts.join("\n\n"))}
+`);
+      if (sent) {
+        prepared.delivered();
+        if (pending) acknowledgeSessionReminders(CURSOR_HOST, pending);
+      }
+    } catch (err) {
+      process.stderr.write(`[caveat:cursor-hook] \u914D\u9001\u306B\u5931\u6557: ${errorMessage4(err)}
+`);
+    }
+  };
   if (name === "user-prompt-submit") {
     const prompt = cursorPrompt(payload);
     const hits = searchCaveatsSafely(CURSOR_HOST, {
@@ -34048,11 +34250,7 @@ async function runCursorHook(name, arg) {
       surface: "user_prompt"
     });
     if (hits.length > 0) contexts.push(userPromptSubmitReminderText(hits, "native-cli"));
-    const compacted = compactContexts(CURSOR_HOST, contexts);
-    if (compacted.length > 0) {
-      process.stdout.write(`${cursorContextOutput(compacted.join("\n\n"))}
-`);
-    }
+    await deliver();
     process.exit(0);
   }
   if (name === "post-tool-use") {
@@ -34067,11 +34265,7 @@ async function runCursorHook(name, arg) {
       });
       if (hits.length > 0) contexts.push(toolErrorReminderText(hits, "native-cli"));
     }
-    const compacted = compactContexts(CURSOR_HOST, contexts);
-    if (compacted.length > 0) {
-      process.stdout.write(`${cursorContextOutput(compacted.join("\n\n"))}
-`);
-    }
+    await deliver();
     process.exit(0);
   }
   if (name === "stop") {
@@ -34114,9 +34308,9 @@ async function runCursorHook(name, arg) {
 }
 
 // src/commands/pull.ts
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 async function runPull(ctx) {
-  const hasCommunityDir = existsSync15(ctx.paths.communityDir);
+  const hasCommunityDir = existsSync17(ctx.paths.communityDir);
   if (!hasCommunityDir) {
     ctx.logger.info(
       "no community repos yet \u2014 add one with `caveat community add <github-url>`."
@@ -34214,213 +34408,6 @@ async function runSync(ctx, opts, dependencies = {}) {
   }
 }
 
-// src/commands/codexSidecar.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
-import { closeSync, constants as constants4, fstatSync, lstatSync as lstatSync2, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, openSync, readSync as readSync2, realpathSync as realpathSync4, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename2, dirname as dirname6, join as join17 } from "node:path";
-import { cwd, exit } from "node:process";
-function runCodexSidecarDiagnostics(logger, opts) {
-  const plan = buildCodexSidecarDiagnosticsCommand({
-    projectRoot: opts.project ?? cwd(),
-    preset: opts.preset ?? "review",
-    cli: cliSpec(opts)
-  });
-  exit(executePlan(logger, plan.command, plan.args, { saveResult: opts.saveResult }));
-}
-function runCodexSidecarSmoke(logger, opts) {
-  const plan = buildCodexSidecarReadOnlySmokeCommand({
-    projectRoot: opts.project ?? cwd(),
-    preset: opts.preset === "review" || opts.preset === "opinion" || opts.preset === "risk" ? opts.preset : "explore",
-    cli: cliSpec(opts)
-  });
-  exit(executePlan(logger, plan.command, plan.args, { saveResult: opts.saveResult }));
-}
-function runCodexSidecarWithCaveats(ctx, workflow, prompt, opts) {
-  const decision = decideCodexSidecarExecution({
-    hostAgent: opts.hostAgent ?? "unknown",
-    availability: opts.availability ?? "operational",
-    workflow,
-    sidecarAgent: opts.sidecarAgent,
-    requiresIsolation: opts.requiresIsolation,
-    structuredResultRequired: opts.structuredResultRequired,
-    explicitSecondPass: opts.explicitSecondPass
-  });
-  if (!decision.useSidecar) {
-    process.stdout.write(JSON.stringify({ status: "skipped", decision }, null, 2) + "\n");
-    exit(0);
-  }
-  const contextDir = mkdtempSync3(join17(tmpdir4(), "caveat-sidecar-context-"));
-  const contextFile = join17(contextDir, "context.json");
-  let status2 = 1;
-  try {
-    const blocks = collectCaveatContextBlocks(ctx, {
-      query: opts.query ?? prompt ?? "",
-      limit: opts.limit ?? 5,
-      source: opts.source,
-      visibility: opts.visibility
-    });
-    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(),
-      preset: opts.preset ?? defaultPreset(workflow),
-      prompt,
-      contextFile,
-      cli: cliSpec(opts)
-    });
-    status2 = executePlan(ctx.logger, plan.command, plan.args, { saveResult: opts.saveResult });
-  } finally {
-    rmSync3(contextDir, { recursive: true, force: true });
-  }
-  exit(status2);
-}
-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, constants4.O_RDONLY | constants4.O_NONBLOCK | (constants4.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 = isPrivateOwnerStat(stat, uid, platform);
-  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_ADDITIONAL_CONTEXT_BYTES || !privateOwner) throw new Error("additional context file must be a private owner-only regular file within 4096 bytes");
-}
-function assertWindowsPrivateTempContainer(path, platform) {
-  if (!isWindows(platform)) return;
-  const parent = dirname6(path);
-  const parentStat = lstatSync2(parent);
-  const resolvedParent = realpathSync4(parent);
-  const resolvedTemp = realpathSync4(tmpdir4());
-  if (parentStat.isSymbolicLink() || !parentStat.isDirectory() || dirname6(resolvedParent) !== resolvedTemp || !basename2(resolvedParent).startsWith("caveat-")) {
-    throw new Error("additional context file must be inside a reserved per-user Caveat temporary directory");
-  }
-}
-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",
-    projectRoot: opts.project ?? cwd(),
-    preset: opts.preset ?? "work",
-    prompt: prompt ?? [
-      "Create docs/codex-sidecar-work-smoke.md with one sentence:",
-      '"codex_work smoke succeeded in an isolated worktree."',
-      "Do not edit any other file."
-    ].join(" "),
-    preserveWorktree: false,
-    cli: cliSpec(opts)
-  });
-  exit(executePlan(ctx.logger, plan.command, plan.args, { saveResult: opts.saveResult }));
-}
-function cliSpec(opts) {
-  if (opts.nodeCli) {
-    return { command: process.execPath, argsPrefix: [opts.nodeCli] };
-  }
-  return { command: opts.command ?? "codex-sidecar" };
-}
-function collectCaveatContextBlocks(ctx, opts) {
-  const filters = {};
-  if (opts.source) filters.source = opts.source;
-  if (opts.visibility) filters.visibility = opts.visibility;
-  const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
-  try {
-    const hits = search(db, { query: opts.query, filters, limit: opts.limit });
-    if (hits.length > 0) markHit(db, hits);
-    const entries = hits.map((hit) => get(db, hit.id, hit.source)).filter((entry) => entry !== null);
-    return caveatEntriesToSidecarContextBlocks(entries);
-  } finally {
-    db.close();
-  }
-}
-function defaultPreset(workflow) {
-  return workflow === "risk-check" ? "risk" : 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" });
-  if (result.stdout) process.stdout.write(result.stdout);
-  if (result.stderr) process.stderr.write(result.stderr);
-  if (options.saveResult && result.stdout) {
-    saveStructuredResult(options.saveResult, result.stdout);
-  }
-  if (result.error) {
-    logger.error(`[codex-sidecar] ${result.error.message}`);
-    return 1;
-  }
-  return result.status ?? 1;
-}
-function saveStructuredResult(path, stdout) {
-  const parsed = JSON.parse(stdout);
-  mkdirSync7(dirname6(path), { recursive: true });
-  writeFileSync7(path, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
-}
-function shellDisplayQuote(value) {
-  return /[\s"'$`]/.test(value) ? JSON.stringify(value) : value;
-}
-
 // src/commands/community.ts
 async function runCommunityAdd(ctx, url2) {
   try {
@@ -34503,7 +34490,7 @@ function runCommunityRemove(ctx, handle, opts) {
 
 // src/commands/factoryDiagnostics.ts
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "node:fs";
 import { join as join18 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { parse as parseToml2 } from "smol-toml";
@@ -34516,9 +34503,9 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function claudeRegistration(path, nodePath, cliScriptPath) {
-  if (!existsSync16(path)) return status(false, "not_registered");
+  if (!existsSync18(path)) return status(false, "not_registered");
   try {
-    const value = JSON.parse(readFileSync10(path, "utf8"));
+    const value = JSON.parse(readFileSync12(path, "utf8"));
     if (!isRecord2(value) || !isRecord2(value.mcpServers)) return status(false, "not_registered");
     return status(isCaveatClaudeMcpRegistration(value.mcpServers.caveat, nodePath, cliScriptPath), "not_registered");
   } catch {
@@ -34527,7 +34514,7 @@ function claudeRegistration(path, nodePath, cliScriptPath) {
 }
 function claudeHooks(claudeDir, nodePath, cliScriptPath) {
   try {
-    const settings = JSON.parse(readFileSync10(join18(claudeDir, "settings.json"), "utf8"));
+    const settings = JSON.parse(readFileSync12(join18(claudeDir, "settings.json"), "utf8"));
     const present = (event, subcommand) => settings.hooks?.[event]?.some((entry) => entry.hooks?.some((item) => typeof item.command === "string" && isCanonicalCaveatClaudeHookCommand(item.command, subcommand, nodePath, cliScriptPath))) ?? false;
     return { user_prompt_submit: hook(present("UserPromptSubmit", "user-prompt-submit")), post_tool_use: hook(present("PostToolUse", "post-tool-use")), post_tool_use_failure: hook(present("PostToolUseFailure", "post-tool-use")), stop: hook(present("Stop", "stop")) };
   } catch {
@@ -34549,7 +34536,7 @@ function strictSearchSchema(db) {
   return columns.map((column) => `${column.name}:${column.hidden}`).join(",") === "id:0,title:0,body:0,tags:0,entries_fts:1,rank:1";
 }
 function database(path) {
-  if (!existsSync16(path)) return { status: "not_ready", reason_code: "missing", schema_version: null, supported_schema_version: 3, migration_status: "unverified" };
+  if (!existsSync18(path)) return { status: "not_ready", reason_code: "missing", schema_version: null, supported_schema_version: 3, migration_status: "unverified" };
   try {
     const db = new DatabaseSync(path, { readOnly: true });
     try {
@@ -34575,9 +34562,9 @@ function database(path) {
 }
 function codexFeature(codexHome) {
   const path = join18(codexHome, "config.toml");
-  if (!existsSync16(path)) return status(false, "feature_disabled");
+  if (!existsSync18(path)) return status(false, "feature_disabled");
   try {
-    const config2 = parseToml2(readFileSync10(path, "utf8"));
+    const config2 = parseToml2(readFileSync12(path, "utf8"));
     if (!isRecord2(config2.features)) return status(false, "feature_disabled");
     const features = config2.features;
     return status(features.hooks === true && (features.codex_hooks === void 0 || features.codex_hooks === true), "feature_disabled");
@@ -34586,7 +34573,7 @@ function codexFeature(codexHome) {
   }
 }
 function codexHooks(codexHome, nodePath, cliScriptPath) {
-  const value = JSON.parse(readFileSync10(join18(codexHome, "hooks.json"), "utf8"));
+  const value = JSON.parse(readFileSync12(join18(codexHome, "hooks.json"), "utf8"));
   if (!isRecord2(value) || !isRecord2(value.hooks)) throw Error("config_unreadable");
   const hooks = value.hooks;
   const present = (event, subcommand) => Array.isArray(hooks[event]) && hooks[event].some((entry) => isRecord2(entry) && Array.isArray(entry.hooks) && entry.hooks.some((item) => isCanonicalCaveatCodexHookEntry(item, subcommand, nodePath, cliScriptPath)));
@@ -34662,6 +34649,32 @@ function parseCursor(value) {
   return parsed;
 }
 
+// src/commands/jev.ts
+import { existsSync as existsSync19 } from "node:fs";
+async function enableJev(ctx) {
+  const key = (await readStdin()).trim();
+  if (!key) throw new Error("Jev API key was not provided on stdin");
+  const response = await callJev(key, { purpose: "Caveat connection check" }, {
+    probe: { type: "noul", instructions: "Is this a connection check?" }
+  });
+  if (response.answers.probe?.type !== "noul") throw new Error("Jev connection check returned an invalid answer");
+  writeJevKey(ctx.caveatHome, key);
+  writeUserConfigPatch(ctx.userConfigPath, { jevEnabled: true });
+  process.stdout.write("Jev\u306B\u3088\u308B\u82E6\u6226\u5224\u5B9A\u3092\u6709\u52B9\u306B\u3057\u307E\u3057\u305F\u3002\n");
+}
+function disableJev(ctx) {
+  writeUserConfigPatch(ctx.userConfigPath, { jevEnabled: false });
+  process.stdout.write("Jev\u306B\u3088\u308B\u82E6\u6226\u5224\u5B9A\u3092\u7121\u52B9\u306B\u3057\u307E\u3057\u305F\u3002\n");
+}
+function jevStatus(ctx) {
+  process.stdout.write(`${JSON.stringify({
+    schema: "caveat.jev_status.v1",
+    enabled: ctx.config.jevEnabled,
+    credential: existsSync19(jevKeyPath(ctx.caveatHome)) ? "present" : "missing"
+  })}
+`);
+}
+
 // src/index.ts
 var program = new Command();
 var agentPaths = resolveAgentConfigPaths();
@@ -34679,6 +34692,16 @@ program.command("factory-diagnostics").description("Emit read-only factory diagn
   if (output.overall.status !== "ready") process.exitCode = 1;
 });
 var runtimeErrors = program.command("runtime-errors").description("Inspect Caveat opt-in runtime errors");
+var jev = program.command("jev").description("Configure Jev struggle detection");
+jev.command("enable").requiredOption("--key-stdin", "read the TypeSafe API key from stdin").action(async () => {
+  await enableJev(buildContext(stdoutLogger));
+});
+jev.command("disable").action(() => {
+  disableJev(buildContext(stdoutLogger));
+});
+jev.command("status").action(() => {
+  jevStatus(buildContext(stdoutLogger));
+});
 var parseLimit = (value) => {
   const parsed = parseCursor(value);
   if (parsed < 1 || parsed > 256) throw Error("invalid_limit");
@@ -34696,8 +34719,8 @@ runtimeErrors.command("ack <cursor>").requiredOption("--json", "emit JSON").acti
   process.stdout.write(`${JSON.stringify(runRuntimeErrors("ack", cursor))}
 `);
 });
-for (const action of ["resolve", "reopen"]) runtimeErrors.command(`${action} <fingerprint>`).requiredOption("--json", "emit JSON").action((fingerprint) => {
-  process.stdout.write(`${JSON.stringify(runRuntimeErrors(action, fingerprint))}
+for (const action of ["resolve", "reopen"]) runtimeErrors.command(`${action} <fingerprint>`).requiredOption("--json", "emit JSON").action((fingerprint2) => {
+  process.stdout.write(`${JSON.stringify(runRuntimeErrors(action, fingerprint2))}
 `);
 });
 program.command("init").description(
@@ -34902,30 +34925,6 @@ cursorHook.command("post-tool-use").description("Run the Cursor postToolUse / po
 cursorHook.command("stop").description("Run the Cursor stop hook").action(async () => {
   await runCursorHook("stop");
 });
-var codexSidecar = program.command("codex-sidecar").description("Check Codex sidecar availability for the current repository");
-codexSidecar.command("diagnostics").description("Run codex-sidecar diagnostics for this repository").option("--project <path>", "repository root to check").option("--preset <preset>", "codex-sidecar preset", "review").option("--command <command>", "codex-sidecar executable", "codex-sidecar").option("--node-cli <path>", "development path to codex-sidecar CLI JS").option("--save-result <path>", "write structured SidecarResult JSON to this path").action((opts) => {
-  runCodexSidecarDiagnostics(stdoutLogger, opts);
-});
-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").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") {
-      process.stderr.write("[caveat:error] workflow must be review | explore | opinion | risk-check\n");
-      process.exit(1);
-    }
-    const ctx = buildContext(stdoutLogger);
-    runCodexSidecarWithCaveats(ctx, normalized, prompt, opts);
-  }
-);
-codexSidecar.command("work-smoke [prompt]").description("Run codex_work in an isolated worktree and remove it after verification").option("--project <path>", "repository root to check").option("--preset <preset>", "codex-sidecar work preset", "work").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(
-  (prompt, opts) => {
-    const ctx = buildContext(stdoutLogger);
-    runCodexSidecarWorkSmoke(ctx, prompt, opts);
-  }
-);
 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);