caveat-cli 0.14.2 → 0.14.4

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   toolErrorReminderText,
   updateEntry,
   userPromptSubmitReminderText
-} from "./chunk-CSXD73IX.js";
+} from "./chunk-EH3S6X6X.js";
 
 // ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -7345,7 +7345,7 @@ function runStats(ctx) {
 
 // src/commands/serve.ts
 async function runServe(opts) {
-  const { startServer } = await import("./server-BP54BTEL.js");
+  const { startServer } = await import("./server-P4FQZD2N.js");
   const { port, host } = startServer({ port: opts.port });
   process.stdout.write(`[caveat] web portal: http://${host}:${port}/
 `);
@@ -21846,6 +21846,7 @@ async function runMcpServer() {
 import { spawn, spawnSync as spawnSync2 } from "node:child_process";
 import {
   existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
   mkdtempSync,
   readFileSync as readFileSync3,
   rmSync,
@@ -21854,7 +21855,7 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join8 } from "node:path";
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 var silentLogger = {
   info: () => {
   },
@@ -21863,6 +21864,9 @@ var silentLogger = {
   error: (m) => process.stderr.write(`[caveat:hook] ${m}
 `)
 };
+var CLAUDE_MAX_CONTEXT_BLOCKS = 3;
+var CLAUDE_STOP_REMINDER_PREFIX = "[caveat] \u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3067\u5916\u90E8\u4ED5\u69D8\u306E\u7F60\u306B\u5F53\u305F\u3063\u305F\u53EF\u80FD\u6027\u3092\u793A\u3059\u30B7\u30B0\u30CA\u30EB:";
+var CLAUDE_STOP_STATE_DIR = "claude-stop-state";
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -21934,12 +21938,82 @@ function loadSignalsSafely(path) {
     return null;
   }
 }
+function systemReminderOutput(text) {
+  return `<system-reminder>${text}</system-reminder>`;
+}
 function drainForSession(sessionId) {
+  const ctx = buildContextSafely();
+  if (!ctx) return [];
+  return drainPendingReminders(ctx.caveatHome, sessionId);
+}
+function claudeContextDedupeKey(text) {
+  if (text.startsWith(CLAUDE_STOP_REMINDER_PREFIX)) return "claude-stop-reminder";
+  return text.trim();
+}
+function compactClaudeContexts(contexts) {
+  const selected = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = contexts.length - 1; i >= 0; i -= 1) {
+    const text = contexts[i]?.trim();
+    if (!text) continue;
+    const key = claudeContextDedupeKey(text);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    selected.push(text);
+  }
+  selected.reverse();
+  const limited = selected.slice(-CLAUDE_MAX_CONTEXT_BLOCKS);
+  const omitted = contexts.filter((t) => t.trim().length > 0).length - limited.length;
+  if (omitted > 0) {
+    limited.push(
+      `[caveat] pending reminder ${omitted} \u4EF6\u3092\u91CD\u8907\u307E\u305F\u306F\u4E0A\u9650\u306B\u3088\u308A\u7701\u7565\u3057\u307E\u3057\u305F\u3002`
+    );
+  }
+  return limited;
+}
+function sanitizeClaudeStateId(raw) {
+  const clean = raw.replace(/[^A-Za-z0-9_-]/g, "");
+  return clean.length > 0 ? clean : "_unknown";
+}
+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])
+  });
+  return createHash("sha256").update(body).digest("hex");
+}
+function stopStatePath(caveatHome, sessionId) {
+  return join8(caveatHome, CLAUDE_STOP_STATE_DIR, `${sanitizeClaudeStateId(sessionId)}.txt`);
+}
+function wasStopReminderQueued(caveatHome, sessionId, key) {
+  const path = stopStatePath(caveatHome, sessionId);
+  try {
+    return readFileSync3(path, "utf-8") === key;
+  } catch {
+    return false;
+  }
+}
+function markStopReminderQueued(caveatHome, sessionId, key) {
+  const path = stopStatePath(caveatHome, sessionId);
+  mkdirSync4(join8(caveatHome, CLAUDE_STOP_STATE_DIR), { recursive: true });
+  writeFileSync3(path, key, "utf-8");
+}
+function queueStopForSession(sessionId, signals, related) {
   const ctx = buildContextSafely();
   if (!ctx) return;
-  const reminders = drainPendingReminders(ctx.caveatHome, sessionId);
-  for (const text of reminders) {
-    process.stdout.write(`<system-reminder>${text}</system-reminder>
+  const key = stopSignalKey(signals, related);
+  if (wasStopReminderQueued(ctx.caveatHome, sessionId, key)) return;
+  try {
+    appendPendingReminder(ctx.caveatHome, sessionId, buildStopReminder(signals, related));
+    markStopReminderQueued(ctx.caveatHome, sessionId, key);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[caveat:hook] pending reminder write error: ${msg}
 `);
   }
 }
@@ -22105,6 +22179,20 @@ function buildStopReminder(signals, related) {
     `[caveat:codex-sidecar] advisory unavailable: ${advisory.message}`
   ].join("\n");
 }
+function compactFailureMessage(message) {
+  const singleLine = message.replace(/\s+/g, " ").trim();
+  if (!singleLine) return "unknown error";
+  return singleLine.length > 220 ? `${singleLine.slice(0, 220)}...` : singleLine;
+}
+function sidecarFailureDetail(output) {
+  const protocol = output.match(/PROTOCOL_ERROR:[^"\r\n]+/);
+  if (protocol) return compactFailureMessage(protocol[0]);
+  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const diagnostic = lines.find(
+    (line) => !line.startsWith("[caveat] [codex-sidecar] codex-sidecar ")
+  );
+  return compactFailureMessage(diagnostic ?? output);
+}
 function runCodexSidecarAdvisory(input) {
   const cliScript = process.argv[1];
   if (!cliScript) {
@@ -22144,15 +22232,21 @@ function runCodexSidecarAdvisory(input) {
       maxBuffer: 10 * 1024 * 1024
     });
     if (result.error) {
-      return { status: "failed", message: result.error.message };
+      return { status: "failed", message: compactFailureMessage(result.error.message) };
     }
     if (result.status !== 0) {
       const detail = (result.stderr || result.stdout || `exit ${result.status}`).trim();
-      return { status: "failed", message: detail.slice(0, 500) };
+      return {
+        status: "failed",
+        message: `sidecar command failed: ${sidecarFailureDetail(detail)}`
+      };
     }
     const parsed = JSON.parse(readFileSync3(resultFile, "utf-8"));
     if (parsed.status !== "ok" || typeof parsed.summary !== "string") {
-      return { status: "failed", message: `unexpected SidecarResult status: ${String(parsed.status)}` };
+      return {
+        status: "failed",
+        message: compactFailureMessage(`unexpected SidecarResult status: ${String(parsed.status)}`)
+      };
     }
     return {
       status: "ok",
@@ -22161,7 +22255,10 @@ function runCodexSidecarAdvisory(input) {
     };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return { status: "failed", message: `invalid SidecarResult JSON: ${msg}` };
+    return {
+      status: "failed",
+      message: compactFailureMessage(`invalid SidecarResult JSON: ${msg}`)
+    };
   } finally {
     rmSync(resultDir, { recursive: true, force: true });
   }
@@ -22183,19 +22280,26 @@ async function runHook(name, arg) {
   }
   const payload = parsePayload(raw);
   const sessionId = getSessionId(payload);
-  drainForSession(sessionId);
+  const contexts = name === "stop" ? [] : drainForSession(sessionId);
   if (name === "user-prompt-submit") {
     const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
     const hits = searchCaveatsFromTextSafely(prompt);
     if (hits.length > 0) {
-      process.stdout.write(
-        `<system-reminder>${userPromptSubmitReminderText(hits)}</system-reminder>
-`
-      );
+      contexts.push(userPromptSubmitReminderText(hits));
+    }
+    const compacted = compactClaudeContexts(contexts);
+    if (compacted.length > 0) {
+      process.stdout.write(`${systemReminderOutput(compacted.join("\n\n"))}
+`);
     }
     process.exit(0);
   }
   if (name === "post-tool-use") {
+    const compacted = compactClaudeContexts(contexts);
+    if (compacted.length > 0) {
+      process.stdout.write(`${systemReminderOutput(compacted.join("\n\n"))}
+`);
+    }
     if (!isToolError(payload)) process.exit(0);
     const errText = extractToolResponseText(
       payload.tool_response ?? payload.toolResponse ?? payload.error ?? payload
@@ -22211,8 +22315,7 @@ async function runHook(name, arg) {
     const signals = transcriptPath ? loadSignalsSafely(transcriptPath) : null;
     if (!signals || !hasAnyStruggleSignal(signals)) process.exit(0);
     const related = searchCaveatsFromTextSafely(struggleSearchText(signals));
-    process.stdout.write(`<system-reminder>${buildStopReminder(signals, related)}</system-reminder>
-`);
+    queueStopForSession(sessionId, signals, related);
     process.exit(0);
   }
   process.stderr.write(`[caveat:hook] unknown hook name: ${name}
@@ -22222,13 +22325,13 @@ async function runHook(name, arg) {
 
 // src/commands/codexHookCmd.ts
 import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
 import { join as join10 } from "node:path";
-import { randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
 
 // src/codexHookInstall.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname5, join as join9 } from "node:path";
 function quote2(p) {
   return p.includes(" ") ? `"${p}"` : p;
@@ -22253,7 +22356,7 @@ function readHooks(path) {
 }
 function writeJsonWithBackup(path, value) {
   const dir = dirname5(path);
-  if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
+  if (!existsSync6(dir)) mkdirSync5(dir, { recursive: true });
   let backupPath = "";
   if (existsSync6(path)) {
     backupPath = `${path}.caveat-backup-${Date.now()}`;
@@ -22322,7 +22425,7 @@ codex_hooks = true
 }
 function writeConfigWithBackup(path, text) {
   const dir = dirname5(path);
-  if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
+  if (!existsSync6(dir)) mkdirSync5(dir, { recursive: true });
   let backupPath = "";
   if (existsSync6(path)) {
     backupPath = `${path}.caveat-backup-${Date.now()}`;
@@ -22439,6 +22542,9 @@ var silentLogger2 = {
   error: (m) => process.stderr.write(`[caveat:codex-hook] ${m}
 `)
 };
+var CODEX_MAX_CONTEXT_BLOCKS = 3;
+var CODEX_STOP_REMINDER_PREFIX = "[caveat] \u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3067\u5916\u90E8\u4ED5\u69D8\u306E\u7F60\u306B\u5F53\u305F\u3063\u305F\u53EF\u80FD\u6027\u3092\u793A\u3059\u30B7\u30B0\u30CA\u30EB:";
+var CODEX_STOP_STATE_DIR = "codex-stop-state";
 async function readStdin2() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -22637,18 +22743,77 @@ function codexContextOutput(text, eventName = "UserPromptSubmit") {
     }
   });
 }
-function codexStopOutput(text) {
-  return JSON.stringify({
-    decision: "block",
-    reason: text
+function drainForSession2(sessionId) {
+  const ctx = buildContextSafely2();
+  if (!ctx) return [];
+  return drainPendingReminders(ctx.caveatHome, sessionId);
+}
+function codexContextDedupeKey(text) {
+  if (text.startsWith(CODEX_STOP_REMINDER_PREFIX)) return "codex-stop-reminder";
+  return text.trim();
+}
+function compactCodexContexts(contexts) {
+  const selected = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = contexts.length - 1; i >= 0; i -= 1) {
+    const text = contexts[i]?.trim();
+    if (!text) continue;
+    const key = codexContextDedupeKey(text);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    selected.push(text);
+  }
+  selected.reverse();
+  const limited = selected.slice(-CODEX_MAX_CONTEXT_BLOCKS);
+  const omitted = contexts.filter((t) => t.trim().length > 0).length - limited.length;
+  if (omitted > 0) {
+    limited.push(`[caveat] pending reminder ${omitted} \u4EF6\u3092\u91CD\u8907\u307E\u305F\u306F\u4E0A\u9650\u306B\u3088\u308A\u7701\u7565\u3057\u307E\u3057\u305F\u3002`);
+  }
+  return limited;
+}
+function sanitizeCodexStateId(raw) {
+  const clean = raw.replace(/[^A-Za-z0-9_-]/g, "");
+  return clean.length > 0 ? clean : "_unknown";
+}
+function stopSignalKey2(signals, related) {
+  const body = JSON.stringify({
+    toolFailureCount: signals.toolFailureCount,
+    fileEditCounts: signals.fileEditCounts.map((e) => [e.path, e.count]),
+    webSearchCount: signals.webSearchCount,
+    webFetchCount: signals.webFetchCount,
+    bashRetryCount: signals.bashRetryCount,
+    searchQueries: signals.searchQueries,
+    related: related.map((h) => [h.source, h.id])
   });
+  return createHash2("sha256").update(body).digest("hex");
+}
+function stopStatePath2(caveatHome, sessionId) {
+  return join10(caveatHome, CODEX_STOP_STATE_DIR, `${sanitizeCodexStateId(sessionId)}.txt`);
 }
-function drainForSession2(sessionId, eventName = "UserPromptSubmit") {
+function wasStopReminderQueued2(caveatHome, sessionId, key) {
+  const path = stopStatePath2(caveatHome, sessionId);
+  try {
+    return readFileSync5(path, "utf-8") === key;
+  } catch {
+    return false;
+  }
+}
+function markStopReminderQueued2(caveatHome, sessionId, key) {
+  const path = stopStatePath2(caveatHome, sessionId);
+  mkdirSync6(join10(caveatHome, CODEX_STOP_STATE_DIR), { recursive: true });
+  writeFileSync5(path, key, "utf-8");
+}
+function queueStopForSession2(sessionId, signals, related) {
   const ctx = buildContextSafely2();
   if (!ctx) return;
-  const reminders = drainPendingReminders(ctx.caveatHome, sessionId);
-  for (const text of reminders) {
-    process.stdout.write(`${codexContextOutput(text, eventName)}
+  const key = stopSignalKey2(signals, related);
+  if (wasStopReminderQueued2(ctx.caveatHome, sessionId, key)) return;
+  try {
+    appendPendingReminder(ctx.caveatHome, sessionId, stopReminderText(signals, related));
+    markStopReminderQueued2(ctx.caveatHome, sessionId, key);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[caveat:codex-hook] pending reminder write error: ${msg}
 `);
   }
 }
@@ -22748,13 +22913,17 @@ async function runCodexHook(name, arg) {
   }
   const payload = parsePayload2(raw);
   const sessionId = codexSessionId(payload);
-  if (sessionId && name === "user-prompt-submit") drainForSession2(sessionId);
-  else if (!sessionId) process.stderr.write("[caveat:codex-hook] missing session_id; pending drain disabled\n");
+  if (!sessionId) process.stderr.write("[caveat:codex-hook] missing session_id; pending drain disabled\n");
   if (name === "user-prompt-submit") {
+    const contexts = sessionId ? drainForSession2(sessionId) : [];
     const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
     const hits = searchCaveatsFromTextSafely2(prompt);
     if (hits.length > 0) {
-      process.stdout.write(`${codexContextOutput(userPromptSubmitReminderText(hits))}
+      contexts.push(userPromptSubmitReminderText(hits));
+    }
+    const compacted = compactCodexContexts(contexts);
+    if (compacted.length > 0) {
+      process.stdout.write(`${codexContextOutput(compacted.join("\n\n"))}
 `);
     }
     process.exit(0);
@@ -22770,8 +22939,7 @@ async function runCodexHook(name, arg) {
     const signals = transcriptPath ? loadSignalsSafely2(transcriptPath) : null;
     if (!signals || !hasAnyStruggleSignal(signals)) process.exit(0);
     const related = searchCaveatsFromTextSafely2(struggleSearchText(signals));
-    process.stdout.write(`${codexStopOutput(stopReminderText(signals, related))}
-`);
+    if (sessionId) queueStopForSession2(sessionId, signals, related);
     process.exit(0);
   }
   process.stderr.write(`[caveat:codex-hook] unknown hook name: ${name}
@@ -22822,7 +22990,7 @@ async function runPull(ctx) {
 
 // src/commands/codexSidecar.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { mkdirSync as mkdirSync5, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname6, join as join12 } from "node:path";
 import { cwd, exit } from "node:process";
@@ -22935,7 +23103,7 @@ function executePlan(logger, command, args, options = {}) {
 }
 function saveStructuredResult(path, stdout) {
   const parsed = JSON.parse(stdout);
-  mkdirSync5(dirname6(path), { recursive: true });
+  mkdirSync7(dirname6(path), { recursive: true });
   writeFileSync6(path, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
 }
 function shellDisplayQuote(value) {