@delt/claude-jev-advisor 0.1.1 → 0.2.0

package/dist/context-hook.js

@@ -8,13 +8,15 @@ import fs from "fs";
 import path2 from "path";
 
 // src/config-shape.ts
+var CONFIG_VERSION = 2;
 var DEFAULT_CONFIG = {
   lang: "ko",
   keyFile: null,
   display: "mod",
-  context: { enabled: true, minTokens: 1e5, compactMinTokens: 2e5, redRemainingPct: 20, unitDoneYes: 0.7, goalDoneYes: 0.8 },
+  context: { enabled: true, minTokens: 25e4, compactMinTokens: 25e4, redRemainingPct: 20, unitDoneYes: 0.6, phaseDoneYes: 0.6 },
   rm: { enabled: true, jev: true, throwawayYes: 0.8, maxDirFiles: 50 }
 };
+var LEGACY_CONTEXT_DEFAULTS = { minTokens: 1e5, compactMinTokens: 2e5, unitDoneYes: 0.7 };
 var LANGS = ["ko", "en"];
 var DISPLAYS = ["mod", "statusline", "message"];
 function isRecord(value) {
@@ -28,13 +30,17 @@ function mergeSection(defaults, raw) {
   }
   return out;
 }
+function withoutLegacyDefaults(context) {
+  if (!isRecord(context)) return context;
+  return Object.fromEntries(Object.entries(context).filter(([key, value]) => LEGACY_CONTEXT_DEFAULTS[key] !== value));
+}
 function normalizeConfig(raw) {
   const r = isRecord(raw) ? raw : {};
   return {
     lang: typeof r.lang === "string" && LANGS.includes(r.lang) ? r.lang : DEFAULT_CONFIG.lang,
     keyFile: typeof r.keyFile === "string" && r.keyFile !== "" ? r.keyFile : null,
     display: typeof r.display === "string" && DISPLAYS.includes(r.display) ? r.display : DEFAULT_CONFIG.display,
-    context: mergeSection(DEFAULT_CONFIG.context, r.context),
+    context: mergeSection(DEFAULT_CONFIG.context, r.version === CONFIG_VERSION ? r.context : withoutLegacyDefaults(r.context)),
     rm: mergeSection(DEFAULT_CONFIG.rm, r.rm)
   };
 }
@@ -75,6 +81,11 @@ function formatSize(tokens) {
 function remainingPct(size, threshold) {
   return Math.max(0, Math.round((threshold - size) / threshold * 100));
 }
+function adviceKind(size, judgment, config) {
+  if (size === null || size < config.context.minTokens || !judgment || judgment.phase === "working") return null;
+  if (judgment.clear) return "clear";
+  return size >= config.context.compactMinTokens ? "compact" : null;
+}
 function adviceLine({ size, threshold, judgment, config }) {
   if (size === null) return "";
   const k = formatSize(size);
@@ -87,10 +98,8 @@ function adviceLine({ size, threshold, judgment, config }) {
     return `${head} \xB7 ${counted.clear ? phrases.clear : phrases.compact}`;
   }
   if (!counted) return k;
-  if (counted.phase === "working") return `\u{1F7E2} ${k}`;
-  if (counted.clear) return `\u{1F7E1} ${k} ${phrases.clear}`;
-  if (size >= config.context.compactMinTokens) return `\u{1F7E1} ${k} ${phrases.compact}`;
-  return `\u{1F7E2} ${k}`;
+  const kind = adviceKind(size, counted, config);
+  return kind ? `\u{1F7E1} ${k} ${phrases[kind]}` : `\u{1F7E2} ${k}`;
 }
 
 // src/jev.ts
@@ -112,6 +121,12 @@ function readJevKey(env, keyFile) {
   const key = line?.slice(KEY_PREFIX.length).trim().replace(/^["']|["']$/g, "");
   return key || null;
 }
+function jevKeys(env, keyFile) {
+  return [...new Set([readJevKey(env, keyFile), readJevKey({}, keyFile)].filter((key) => Boolean(key)))];
+}
+function withoutKeys(text, keys) {
+  return keys.reduce((out, key) => out.split(key).join("[redacted]"), text);
+}
 async function callJev(request, opts) {
   const now = opts.now ?? Date.now;
   const fetchFn = opts.fetchFn ?? fetch;
@@ -196,10 +211,15 @@ function removeState(home, sessionId) {
 function logFile(home, now) {
   return path3.join(logDir(home), `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}.jsonl`);
 }
-function appendLog(home, now, record) {
+function appendLog(home, now, record, secrets = []) {
   const file = logFile(home, now);
   fs3.mkdirSync(path3.dirname(file), { recursive: true });
-  fs3.appendFileSync(file, `${JSON.stringify({ at: now.toISOString(), ...record })}
+  let line = JSON.stringify({ at: now.toISOString(), ...record });
+  for (const secret of secrets) {
+    if (!secret) continue;
+    for (const form of [secret, JSON.stringify(secret).slice(1, -1)]) line = line.split(form).join("[redacted]");
+  }
+  fs3.appendFileSync(file, `${line}
 `);
 }
 
@@ -208,18 +228,26 @@ var REPLY_EDGE_CHARS = 1500;
 var QUESTIONS = {
   unit_done: {
     type: "noul",
-    instructions: "Has the work asked for in `recent_requests` reached a natural stopping point in `last_assistant_reply`?",
+    instructions: "Has Claude finished or handed back the work the user asked for in `recent_requests`, so that `last_assistant_reply` is a natural break before the user's next instruction?",
     criteria: {
-      true: "The requested work is finished, verified or handed over; anything still mentioned is optional.",
-      false: "The work is still in progress: the reply asks a question it needs answered to continue, says what it will do next, or reports something still running or failing."
+      true: "The asked-for work is done, checked, reported or handed back. It still counts as done when the reply also lists unverified points, risks or follow-ups, offers optional extras, or asks the user to choose or approve what comes next.",
+      false: "Claude stopped partway through the asked-for work: it needs information to continue it, is waiting for background work that belongs to it, reports a failure it has not resolved, or says it will now go on with the next step of the same request."
     }
   },
-  goal_done: {
+  phase_done: {
     type: "noul",
-    instructions: "Does `last_assistant_reply` wrap up the overall goal behind `recent_requests`, with no further steps on that goal left to take next?",
+    instructions: "Does `last_assistant_reply` close a whole stage of the work, so that what comes next is a new stage that can start from the saved results (commits, documents, a release) rather than from this conversation?",
     criteria: {
-      true: "The goal is finished: the reply hands over the result or reports a commit, release or completion, and plans or proposes no further work toward the same goal.",
-      false: "Steps toward the same goal remain: the next task of a plan, a proposed follow-up, or a review, test or decision the user still has to make."
+      true: [
+        "A whole plan, feature, fix or multi-step job is finished and merged, pushed, released, deployed, installed or put into operation.",
+        "An investigation or analysis is finished and its final conclusion is reported or saved as a document.",
+        "A design or implementation plan is written and saved as a document, ready for review or for the next stage to work from."
+      ],
+      false: [
+        "Only one task, step or part of a larger stage is done, and the same stage goes on (for example the next task of the same plan).",
+        "The reply answers a single small request or question, or makes a small edit, without closing a larger stage.",
+        "Work is still going on, failed, or is waiting for information it needs to continue."
+      ]
     }
   }
 };
@@ -231,19 +259,26 @@ ${text.slice(-edge)}`;
 function jevRequest(requests, lastReply) {
   return {
     state: { recent_requests: requests, last_assistant_reply: cutReply(lastReply) },
-    questions: { unit_done: QUESTIONS.unit_done, goal_done: QUESTIONS.goal_done }
+    questions: { unit_done: QUESTIONS.unit_done, phase_done: QUESTIONS.phase_done }
   };
 }
 function judgmentFrom(answers, config) {
   const unit = answers.unit_done;
   if (typeof unit !== "number") return null;
-  if (unit < config.context.unitDoneYes) return { phase: "working", clear: false };
-  const goal = answers.goal_done;
-  return { phase: "unit_done", clear: typeof goal === "number" && goal >= config.context.goalDoneYes };
+  const stage = answers.phase_done;
+  if (typeof stage === "number" && stage >= config.context.phaseDoneYes) return { phase: "unit_done", clear: true };
+  return unit >= config.context.unitDoneYes ? { phase: "unit_done", clear: false } : { phase: "working", clear: false };
 }
-function hasBackgroundTasks(value) {
-  if (Array.isArray(value)) return value.length > 0;
-  return typeof value === "object" && value !== null && Object.keys(value).length > 0;
+var OWN_BACKGROUND_WORK = /* @__PURE__ */ new Set(["subagent", "workflow"]);
+function backgroundTypes(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((task) => {
+    const type = typeof task === "object" && task !== null ? task.type : void 0;
+    return typeof type === "string" ? type : "unknown";
+  });
+}
+function busyInBackground(types) {
+  return types.some((type) => OWN_BACKGROUND_WORK.has(type));
 }
 
 // src/context/transcript.ts
@@ -252,7 +287,7 @@ var TAIL_START_BYTES = 1024 * 1024;
 var TAIL_MAX_BYTES = 8 * 1024 * 1024;
 var REQUEST_COUNT = 3;
 var REQUEST_MAX_CHARS = 1e3;
-var REQUEST_ORIGINS = /* @__PURE__ */ new Set(["human", "channel"]);
+var REQUEST_ORIGINS = /* @__PURE__ */ new Set(["human", "channel", "peer"]);
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -294,38 +329,66 @@ function contextSize(entries) {
   }
   return null;
 }
-function requestText(content) {
+function messageText(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
   return content.filter((block) => isRecord2(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
 }
-function recentRequests(entries, count = REQUEST_COUNT, maxChars = REQUEST_MAX_CHARS) {
+function isRequest(entry) {
+  return entry.type === "user" && entry.isSidechain !== true && isRecord2(entry.origin) && REQUEST_ORIGINS.has(String(entry.origin.kind));
+}
+function requestText(entry) {
+  return messageText(isRecord2(entry.message) ? entry.message.content : void 0).trim();
+}
+function recentRequests(entries, count = REQUEST_COUNT, maxChars = REQUEST_MAX_CHARS, clean = (text) => text) {
   const found = [];
   for (let i = entries.length - 1; i >= 0 && found.length < count; i--) {
-    const entry = entries[i];
-    if (entry.type !== "user" || entry.isSidechain === true || !isRecord2(entry.origin) || !REQUEST_ORIGINS.has(String(entry.origin.kind))) continue;
-    const text = requestText(isRecord2(entry.message) ? entry.message.content : void 0).trim();
-    if (text) found.push(text.slice(0, maxChars));
+    if (!isRequest(entries[i])) continue;
+    const text = requestText(entries[i]);
+    if (text) found.push(clean(text).slice(0, maxChars));
   }
   return found.reverse();
 }
-function readTranscript(file, limits = { start: TAIL_START_BYTES, max: TAIL_MAX_BYTES }) {
+function replyWritten(entries, reply) {
+  const wanted = reply.trim();
+  if (!wanted) return true;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (isRequest(entry)) return false;
+    if (entry.type !== "assistant" || entry.isSidechain === true || !isRecord2(entry.message)) continue;
+    const text = messageText(entry.message.content).trim();
+    if (text && wanted.endsWith(text)) return true;
+  }
+  return false;
+}
+function readTranscript(file, reply = "", limits = { start: TAIL_START_BYTES, max: TAIL_MAX_BYTES }, clean = (text) => text) {
   for (let bytes = limits.start; ; bytes *= 2) {
     const { entries, whole } = readTail(file, Math.min(bytes, limits.max));
     const size = contextSize(entries);
-    const requests = recentRequests(entries);
-    if (size !== null && requests.length >= REQUEST_COUNT || whole || bytes >= limits.max) return { size, requests };
+    const requests = recentRequests(entries, REQUEST_COUNT, REQUEST_MAX_CHARS, clean);
+    if (size !== null && requests.length >= REQUEST_COUNT || whole || bytes >= limits.max) {
+      return { size, requests, replySeen: replyWritten(entries, reply) };
+    }
   }
 }
 
 // src/context/run.ts
-var ADVICE = /\/(clear|compact)$/;
-function factsOf(transcriptPath) {
-  if (!transcriptPath) return { size: null, requests: [] };
+var REPLY_WAIT_MS = 3e3;
+var REPLY_POLL_MS = 100;
+var pause2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function readFacts(transcriptPath, reply, clean) {
   try {
-    return readTranscript(transcriptPath);
+    return readTranscript(transcriptPath, reply, void 0, clean);
   } catch {
-    return { size: null, requests: [] };
+    return { size: null, requests: [], replySeen: false };
+  }
+}
+async function factsAfterReply(transcriptPath, reply, clean, sleep) {
+  if (!transcriptPath) return { size: null, requests: [], replySeen: false, waitedMs: 0 };
+  for (let waitedMs = 0; ; waitedMs += REPLY_POLL_MS) {
+    const facts = readFacts(transcriptPath, reply, clean);
+    if (facts.replySeen || waitedMs >= REPLY_WAIT_MS) return { ...facts, waitedMs };
+    await sleep(REPLY_POLL_MS);
   }
 }
 async function runContextHook(event, raw, deps) {
@@ -341,7 +404,11 @@ async function runContextHook(event, raw, deps) {
   }
   if (input.stop_hook_active === true) return null;
   const transcriptPath = typeof input.transcript_path === "string" ? input.transcript_path : null;
-  const { size, requests } = factsOf(transcriptPath);
+  const reply = typeof input.last_assistant_message === "string" ? input.last_assistant_message : "";
+  const keys = jevKeys(deps.env, config.keyFile);
+  const clean = (text) => withoutKeys(text, keys);
+  const { size, requests, replySeen, waitedMs } = await factsAfterReply(transcriptPath, reply, clean, deps.sleep ?? pause2);
+  const background = backgroundTypes(input.background_tasks);
   let judgment = null;
   let reason = null;
   let jev = null;
@@ -349,7 +416,7 @@ async function runContextHook(event, raw, deps) {
     reason = "unknown_size";
   } else if (size < config.context.minTokens) {
     reason = "below_min";
-  } else if (hasBackgroundTasks(input.background_tasks)) {
+  } else if (busyInBackground(background)) {
     reason = "background_tasks";
     judgment = { phase: "working", clear: false };
   } else {
@@ -357,7 +424,7 @@ async function runContextHook(event, raw, deps) {
     if (!key) {
       reason = "no_key";
     } else {
-      const request = jevRequest(requests, typeof input.last_assistant_message === "string" ? input.last_assistant_message : "");
+      const request = jevRequest(requests, clean(reply));
       const result = await callJev(request, { key, fetchFn: deps.fetchFn });
       jev = { state: request.state, ...result };
       if ("error" in result) {
@@ -374,10 +441,10 @@ async function runContextHook(event, raw, deps) {
     writeState(deps.home, state);
   } catch {
   }
-  appendLog(deps.home, at, { helper: "context", event: "stop", sessionId, transcriptPath, size, reason, judgment, jev });
-  if (config.display !== "message") return null;
-  const line = adviceLine({ size, threshold: null, judgment, config });
-  return ADVICE.test(line) ? JSON.stringify({ systemMessage: line }) : null;
+  const advice = adviceKind(size, judgment, config);
+  appendLog(deps.home, at, { helper: "context", event: "stop", sessionId, transcriptPath, size, replySeen, waitedMs, background, reason, judgment, advice, jev }, keys);
+  if (config.display !== "message" || !advice) return null;
+  return JSON.stringify({ systemMessage: adviceLine({ size, threshold: null, judgment, config }) });
 }
 
 // src/context/hook.ts