caveat-cli 0.19.8 → 0.19.10

package/dist/index.js

@@ -37,6 +37,8 @@ import {
   isPrivateOwnerStat,
   isWindows,
   isWindowsEnv,
+  jevObservationId,
+  listJevObservations,
   listRecent,
   listStale,
   loadConfig,
@@ -59,6 +61,7 @@ import {
   releaseReindexLock,
   resetAutoSyncFailureState,
   resolvePaths,
+  reviewJevObservation,
   runAutoSync,
   runWindowsAcl,
   runtimeErrorsDiagnostics,
@@ -71,10 +74,12 @@ import {
   toolErrorReminderText,
   triggerAutoSync,
   updateEntry,
+  updateJevDelivery,
   userPromptSubmitReminderText,
   writeDigestMarker,
+  writeJevObservation,
   writeUserConfigPatch
-} from "./chunk-ITQLGM4K.js";
+} from "./chunk-PFYFYJNS.js";
 
 // ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -8390,7 +8395,7 @@ function runStats(ctx) {
 
 // src/commands/serve.ts
 async function runServe(opts) {
-  const { startServer } = await import("./server-H4BWLLZ2.js");
+  const { startServer } = await import("./server-JXBPTQNU.js");
   const { port, host } = startServer({ port: opts.port });
   process.stdout.write(`[caveat] web portal: http://${host}:${port}/
 `);
@@ -33210,6 +33215,7 @@ var API_URL = "https://api.typesafe.ai/v1/systemone";
 var STRUGGLE_THRESHOLD = 0.85;
 var MATCH_THRESHOLD = 0.8;
 var MAX_TERMS = 48;
+var MAX_SEARCH_TERMS = 3;
 var MAX_CANDIDATES = 20;
 async function callJev(key, state, questions, fetcher = fetch) {
   const response = await fetcher(API_URL, {
@@ -33232,9 +33238,16 @@ function noul(answer) {
   }
   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 searchTermChoices(answer, terms) {
+  if (answer?.type !== "choice" || !isRecord(answer.probabilities)) throw new Error("jev_choice_invalid");
+  const keys = terms.map((_, index) => `term_${index}`);
+  const allowed = /* @__PURE__ */ new Set([...keys, "none"]);
+  if (!allowed.has(answer.choice) || Object.keys(answer.probabilities).length !== allowed.size || Object.entries(answer.probabilities).some(([key, probability]) => !allowed.has(key) || typeof probability !== "number" || !Number.isFinite(probability) || probability < 0 || probability > 1)) {
+    throw new Error("jev_choice_invalid");
+  }
+  if (answer.choice === "none") return [];
+  const noneProbability = answer.probabilities.none;
+  return keys.map((key, index) => ({ index, probability: answer.probabilities[key] })).filter(({ probability }) => probability > noneProbability).sort((a, b) => b.probability - a.probability || a.index - b.index).slice(0, MAX_SEARCH_TERMS).map(({ index }) => terms[index]);
 }
 function candidateTerms(turns) {
   const found = /* @__PURE__ */ new Map();
@@ -33262,17 +33275,27 @@ async function judgeStruggle(key, turns, ask = callJev) {
   };
   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.",
+    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. The search will use up to three of your highest-ranked terms together as an AND query.",
     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 };
+  const repeatedProblem = noul(response.answers.repeated_problem);
+  const clearlyStuck = noul(response.answers.clearly_stuck);
+  const struggling = repeatedProblem >= STRUGGLE_THRESHOLD && clearlyStuck >= STRUGGLE_THRESHOLD;
+  const choice = terms.length > 0 ? response.answers.search_term : void 0;
+  const selected = terms.length > 0 ? searchTermChoices(choice, terms) : [];
+  const termChoices = terms.map((term, index) => ({ term, probability: choice.probabilities[`term_${index}`] }));
+  return {
+    struggling,
+    terms: struggling ? selected : [],
+    repeatedProblem,
+    clearlyStuck,
+    termChoices,
+    noneProbability: choice ? choice.probabilities.none : null
+  };
 }
 async function rankKnowledge(key, turns, candidates, ask = callJev) {
-  if (candidates.length === 0) return null;
+  if (candidates.length === 0) return { selected: null, scores: [] };
   const state = {
     turns,
     currentHostOs: fingerprint().os,
@@ -33295,14 +33318,16 @@ async function rankKnowledge(key, turns, candidates, ask = callJev) {
   const response = await ask(key, state, questions);
   let best = null;
   let bestScore = MATCH_THRESHOLD;
+  const scores = [];
   for (let index = 0; index < candidates.length; index++) {
     const score = noul(response.answers[`candidate_${index}`]);
+    scores.push(score);
     if (score >= MATCH_THRESHOLD && (best === null || score > bestScore)) {
       best = candidates[index];
       bestScore = score;
     }
   }
-  return best;
+  return { selected: best, scores };
 }
 function quotePowerShell(value) {
   return `'${value.replaceAll("'", "''")}'`;
@@ -33367,39 +33392,88 @@ async function runJevStruggle(ctx, host, payload, deps = {}) {
   const key = (deps.readKey ?? readJevKey)(ctx.caveatHome);
   const ask = deps.ask ?? callJev;
   const judgment = await judgeStruggle(key, context.turns, ask);
+  const observationId = jevObservationId(host, sessionId, turnKey);
+  const base = {
+    schema: "caveat.jev_observation.v1",
+    id: observationId,
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    host,
+    sessionId,
+    projectRoot,
+    transcriptPath,
+    turns: context.turns.map(({ originSessionId, turnNumber, truncated }) => ({ originSessionId, turnNumber, truncated })),
+    thinkingAvailable: context.thinkingAvailable,
+    model: MODEL,
+    repeatedProblem: judgment.repeatedProblem,
+    clearlyStuck: judgment.clearlyStuck,
+    struggleThreshold: STRUGGLE_THRESHOLD,
+    struggling: judgment.struggling,
+    termChoices: judgment.termChoices,
+    noneProbability: judgment.noneProbability,
+    selectedTerms: judgment.terms,
+    query: judgment.terms.join(" "),
+    matchThreshold: MATCH_THRESHOLD,
+    review: null
+  };
   state.lastTurn = turnKey;
   if (!judgment.struggling) {
+    writeJevObservation(ctx.caveatHome, {
+      ...base,
+      ftsHits: [],
+      candidates: [],
+      selectedRef: null,
+      noticeText: null,
+      decision: "below_struggle_threshold",
+      delivery: "none"
+    });
     saveState(ctx.caveatHome, sessionId, state);
     return null;
   }
   let candidates = [];
-  if (judgment.term) {
+  const query = judgment.terms.join(" ");
+  let ftsHits = [];
+  if (query) {
     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));
+      const hits = search(db, { query, limit: MAX_CANDIDATES });
+      ftsHits = hits.map((hit) => `${hit.source}/${hit.id}`);
+      candidates = hits.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 ranked = await rankKnowledge(key, context.turns, candidates, ask);
+  const selected = ranked.selected;
   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)) {
+  const term = query || "_none";
+  const suppressed = Boolean(id && (state.deliveredIds.includes(id) || wasHitDelivered(ctx.caveatHome, sessionId, id)) || !id && state.notifiedTerms.includes(term));
+  const noticeText = reminder(selected);
+  writeJevObservation(ctx.caveatHome, {
+    ...base,
+    ftsHits,
+    candidates: candidates.map((candidate, index) => ({ ref: `${candidate.hit.source}/${candidate.hit.id}`, score: ranked.scores[index] })),
+    selectedRef: id,
+    noticeText: suppressed ? null : noticeText,
+    decision: id ? "matched" : !query ? "no_terms" : candidates.length === 0 ? "no_candidates" : "below_match_threshold",
+    delivery: suppressed ? "suppressed" : "pending"
+  });
+  if (suppressed) {
     saveState(ctx.caveatHome, sessionId, state);
     return null;
   }
   return {
-    text: reminder(selected),
+    text: noticeText,
     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);
+      updateJevDelivery(ctx.caveatHome, observationId);
       saveState(ctx.caveatHome, sessionId, current);
       if (selected) {
         const db = openDb({ path: ctx.paths.dbPath });
@@ -34681,6 +34755,15 @@ function jevStatus(ctx) {
   })}
 `);
 }
+function listJevCases(ctx) {
+  process.stdout.write(`${JSON.stringify({ schema: "caveat.jev_cases.v1", cases: listJevObservations(ctx.caveatHome) })}
+`);
+}
+function reviewJevCase(ctx, id, verdict, note) {
+  const item = reviewJevObservation(ctx.caveatHome, id, verdict, note);
+  process.stdout.write(`${JSON.stringify({ id: item.id, review: item.review })}
+`);
+}
 
 // src/index.ts
 var program = new Command();
@@ -34709,6 +34792,13 @@ jev.command("disable").action(() => {
 jev.command("status").action(() => {
   jevStatus(buildContext(stdoutLogger));
 });
+jev.command("cases").requiredOption("--json", "emit case records").action(() => {
+  listJevCases(buildContext(stdoutLogger));
+});
+jev.command("review <id> <verdict>").description("Review one case: correct | incorrect | missed | none | unclear").option("--note <text>", "short reason for the verdict", "").action((id, verdict, opts) => {
+  if (!["correct", "incorrect", "missed", "none", "unclear"].includes(verdict)) throw new Error("jev_review_verdict_invalid");
+  reviewJevCase(buildContext(stdoutLogger), id, verdict, opts.note);
+});
 var parseLimit = (value) => {
   const parsed = parseCursor(value);
   if (parsed < 1 || parsed > 256) throw Error("invalid_limit");