jev-context

1// Claude Code function hook (early access: CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1).
2// With JEV_CONTEXT_COMPACT=verbatim it answers `session.compact` with the
3// verbatim compaction (src/core/verbatim.mjs) instead of a summary. Answering
4// without next() means core never runs, so the command PreCompact/SessionStart
5// hooks stay out of it. When Jev fails or the history shrinks too little it
6// passes on: the built-in summary runs, and with it the retain hooks.
7// The worker has no Node: settings come from $.env, the log goes through $.fs.
8import { buildJevRequest, parseJevResponse } from '../vendor/jev-pruner/dist/jev.js';
9import { asker } from '../src/core/jev.mjs';
10import { compactVerbatim, MIN_REDUCTION } from '../src/core/verbatim.mjs';
11
12const JEV_TIMEOUT_MS = 20_000;
13const TIMED_OUT = Symbol('timed out');
14
15// $.env.get takes literal names only (Claude Code lists what a module reads).
16async function settings($) {
17  const number = (value, fallback) => (value && Number.isFinite(Number(value)) ? Number(value) : fallback);
18  const apiKey = await $.env.get('TYPESAFE_API_KEY');
19  return {
20    compact: (await $.env.get('JEV_CONTEXT_COMPACT')) || 'summary',
21    // Same defaults as src/core/config.mjs: live whenever a key is in the shell.
22    jev: (await $.env.get('JEV_CONTEXT_JEV')) || (apiKey ? 'live' : 'off'),
23    jevModel: (await $.env.get('JEV_CONTEXT_JEV_MODEL')) || 'jev-latest',
24    retainMaxChars: number(await $.env.get('JEV_CONTEXT_RETAIN_MAX_CHARS'), 6_000),
25    compactMinReduction: number(await $.env.get('JEV_CONTEXT_COMPACT_MIN_REDUCTION'), MIN_REDUCTION),
26    compactTopics: (await $.env.get('JEV_CONTEXT_COMPACT_TOPICS')) || 'on',
27    compactKeep: number(await $.env.get('JEV_CONTEXT_COMPACT_KEEP'), 0.3),
28    compactTopicDrop: number(await $.env.get('JEV_CONTEXT_COMPACT_TOPIC_DROP'), 0.8),
29    log: (await $.env.get('JEV_CONTEXT_LOG')) || `${$.plugin.root}/logs/decisions.jsonl`,
30    apiKey,
31  };
32}
33
34/** A Jev asker over the host's fetch (the worker has no network of its own). */
35function jevFor($, cfg) {
36  if (cfg.jev === 'simulated') return asker(cfg);
37  if (cfg.jev !== 'live' || !cfg.apiKey) return null;
38  const counter = { requests: 0 };
39  return {
40    counter,
41    async ask(state, questions) {
42      counter.requests += 1;
43      const request = buildJevRequest({ apiKey: cfg.apiKey, model: cfg.jevModel }, state, questions);
44      // The losing timer resolves later to nothing; a rejecting one would go unhandled.
45      const timeout = $.clock.sleep(JEV_TIMEOUT_MS).then(() => TIMED_OUT);
46      const response = await Promise.race([$.http.fetch(request.url, { method: request.method, headers: request.headers, body: request.body }), timeout]);
47      if (response === TIMED_OUT) throw new Error('Jev timed out');
48      return parseJevResponse(response.status, response.ok, response.text);
49    },
50  };
51}
52
53/** Same line format as bin/hook.mjs. $.fs writes whole files, so this appends by rewriting. */
54async function log($, cfg, entry) {
55  const line = JSON.stringify({ at: new Date().toISOString(), host: 'claude', hook: 'session-compact', ...entry });
56  $.ui.log(`jev-context ${line}`);
57  try {
58    const before = (await $.fs.exists(cfg.log)) ? await $.fs.read(cfg.log) : '';
59    await $.fs.write(cfg.log, `${before}${line}\n`);
60  } catch {
61    // Logging never changes the compaction.
62  }
63}
64
65export const register = (on) => {
66  on('session.compact', async ($, e, next) => {
67    const cfg = await settings($);
68    if (cfg.compact !== 'verbatim') return next(e);
69    const started = Date.now();
70    const entry = { trigger: e.trigger, session: await $.session.id().catch(() => undefined) };
71    // An ahead-of-time summary would be installed without asking this hook
72    // again; skipping it keeps the real compaction on this path.
73    if (e.trigger === 'precompute') return { skip: 'jev-context: verbatim compaction runs at compaction time' };
74    if (e.agentId) {
75      await log($, cfg, { ...entry, decision: 'subagent_passed' });
76      return next(e);
77    }
78    const jev = jevFor($, cfg);
79    if (!jev) {
80      await log($, cfg, { ...entry, decision: 'fallback_no_jev' });
81      return next(e);
82    }
83    try {
84      const result = await compactVerbatim(cfg, e.messages, jev, { goal: e.instructions ?? '' });
85      Object.assign(entry, result.stats, { elapsedMs: Date.now() - started });
86      if (result.stage !== 'compacted') {
87        await log($, cfg, { ...entry, decision: `fallback_${result.stage}` });
88        return next(e);
89      }
90      await log($, cfg, { ...entry, decision: 'compacted' });
91      return { messages: result.messages };
92    } catch (error) {
93      await log($, cfg, { ...entry, decision: 'fallback_error', error: String(error?.message ?? error).slice(0, 200), jevRequests: jev.counter?.requests, elapsedMs: Date.now() - started });
94      return next(e);
95    }
96  });
97};
98

1import { buildJevRequest, parseJevResponse } from '../../vendor/jev-pruner/dist/jev.js';
2
3/**
4 * A JevAsker for jev-pruner and for this plugin's own questions. `simulated`
5 * is for tests and rehearsals only: fixed scores from a regex, never Jev.
6 */
7export function asker(cfg, counter = { requests: 0 }) {
8  if (cfg.jev === 'simulated') {
9    const needed = /error|warn|fail|BUNDLE|ROLLBACK|completed|sha256|digest|rollback|release/i;
10    return {
11      counter,
12      async ask(state, questions) {
13        counter.requests += 1;
14        const answers = {};
15        for (const id of Object.keys(questions)) {
16          // Verbatim compaction's call-level pair: keep every call, drop every result.
17          if (id.startsWith('call_') || id.startsWith('result_')) {
18            answers[id] = { type: 'noul', noul: id.startsWith('call_') ? 0.99 : 0.01 };
19            continue;
20          }
21          const text = state.chunks?.find((chunk) => chunk.id === id)?.text ?? '';
22          answers[id] = { type: 'noul', noul: needed.test(text) ? 0.99 : 0.01 };
23        }
24        return { answers };
25      },
26    };
27  }
28  if (cfg.jev !== 'live' || !cfg.apiKey) return null;
29  return {
30    counter,
31    async ask(state, questions) {
32      counter.requests += 1;
33      const request = buildJevRequest({ apiKey: cfg.apiKey, model: cfg.jevModel }, state, questions);
34      const response = await fetch(request.url, {
35        method: request.method,
36        headers: request.headers,
37        body: request.body,
38        signal: AbortSignal.timeout(20_000),
39      });
40      return parseJevResponse(response.status, response.ok, await response.text());
41    },
42  };
43}
44

1// Verbatim compaction, from fast-jev-compaction: instead of replacing the
2// conversation with a summary, drop the tool calls and results Jev says are no
3// longer needed and keep every user and assistant text as written. The call
4// decisions are the library's own (pinning, whole-history state, batching).
5// What this plugin changes, so that it shrinks the window about as far as a
6// summary does while keeping the text:
7// - Only the first message and results the assistant has not answered yet are
8//   pinned. The library pins the newest six messages whole, which after a busy
9//   turn kept two 22k-char outputs Jev was never asked about (68% of what was
10//   left, live 2026-09-29).
11// - The result question is this plugin's. The library keeps a result only when
12//   "re-running the tool would not do"; with that premise every result scored
13//   below 0.5, even a file the next step was about to edit (0.15-0.18, live
14//   2026-09-29). Asked whether the next step edits what the call read (naming
15//   the file), Jev scored the file 0.45-0.85 whenever the next step edited it
16//   (0.45 when it was read 25 messages earlier), 0.09 once the edit was done,
17//   and every log 0.17 or below. So a result stays whole from 0.3
18//   (JEV_CONTEXT_COMPACT_KEEP), not the library's 0.5; either mistake is cheap
19//   to undo (a few tokens kept, or one re-read). A wording that also counted
20//   "values found only in the output" kept whole 22k-char logs; values are the
21//   standout rule's job.
22// - A dropped result keeps its standout lines (a value, a failure, a summary).
23//   That is a rule, not Jev: asked per chunk, Jev scored a 31-chunk test log
24//   0.65-0.85 throughout and ranked the failure 7th-8th.
25// - Long inputs of calls whose result goes are cut to their head.
26// - Assistant messages come back without their thinking. After a compaction
27//   no earlier thinking fits the new prefix (preserved thinking), and a summary
28//   drops it as well.
29// - On by default (cfg.compactTopics; JEV_CONTEXT_COMPACT_TOPICS=off stops it): Jev is also asked, per exchange (a
30//   user request and everything up to the next one), whether the user closed
31//   its topic. Only a confident yes (0.8, JEV_CONTEXT_COMPACT_TOPIC_DROP) drops
32//   it: a topic the user explicitly closed scored 0.87-0.93, one they only
33//   moved on from 0.50-0.56, and a dropped exchange cannot be brought back. It
34//   leaves a note with the lines that stood out in its tool output. Asked
35//   instead whether the work "comes back to" a topic, Jev scored both kinds
36//   below 0.5 and a release id went with the closed topic. The first exchange
37//   and those in the newest messages are not asked about.
38// - Jev is asked only when its answer can change the window (ASK_CALL_CHARS,
39//   ASK_EXCHANGE_CHARS); with nothing that large, no request is sent and the
40//   built-in summary runs.
41// Runs inside Claude Code's function-hook worker, so nothing here imports Node.
42import { applyDecisions, batchCalls, messageChars, questionsFor, resolveOptions } from '../../vendor/fast-jev-compaction/dist/compact.js';
43import { noulAnswer } from '../../vendor/fast-jev-compaction/dist/request.js';
44import { collectToolCalls, fitState } from '../../vendor/fast-jev-compaction/dist/state.js';
45import { pickStandouts } from './reduce.mjs';
46
47/** Below this share of characters removed, the built-in summary is used instead. */
48export const MIN_REDUCTION = 0.25;
49/**
50 * Jev is asked only where its answer can change the window: a call whose
51 * result and input together are this long, an exchange holding this much.
52 * Anything smaller stays as it is without a question, and a compaction with
53 * nothing large enough sends no request at all.
54 */
55export const ASK_CALL_CHARS = 1_000;
56export const ASK_EXCHANGE_CHARS = 1_500;
57
58function outputsById(messages) {
59  const outputs = new Map();
60  for (const message of messages) {
61    for (const tool of message.toolUses) if (typeof tool.text === 'string') outputs.set(tool.tool_use_id, tool.text);
62    for (const result of message.toolResults ?? []) outputs.set(result.tool_use_id, result.text);
63  }
64  return outputs;
65}
66
67const sourceOf = (input) => [input?.command, input?.file_path, input?.pattern].find((v) => typeof v === 'string') ?? '';
68
69/** First line only (the command banner, capped at `headChars`), a short note, then the standout lines. */
70function withKeptLines(original, lines, headChars) {
71  const head = original.split('\n', 1)[0].slice(0, headChars);
72  return [
73    head,
74    `[jev-context: ${original.length - head.length} chars dropped at compaction; standout lines kept, re-run for the rest]`,
75    ...lines.filter((line) => !head.includes(line)),
76  ].join('\n');
77}
78
79/** Jev's question about a call's output: will the next step edit what the call read? */
80export function resultQuestion(call) {
81  const source = sourceOf(call.input).replace(/\s+/g, ' ').slice(0, 120);
82  return {
83    type: 'noul',
84    instructions: `The work right after this compaction edits or rewrites what tool call ${call.id} read (${call.tool}${source ? ` ${source}` : ''}, ${call.resultChars} chars), such as a source file or document, so the assistant needs that text exactly as it was read. Logs, listings and command output whose key lines the assistant already reported do not count.`,
85  };
86}
87
88/** Pinned calls stay; a result stays whole from `keep`; otherwise the call stays from 0.5 (the library's call question). */
89function decide(call, answer, keep) {
90  const base = { id: call.id, tool: call.tool, ...answer };
91  if (call.pinned) return { ...base, action: 'keep', reason: 'pinned' };
92  if (answer.keepResult >= keep) return { ...base, action: 'keep', reason: 'kept' };
93  if (answer.keepCall >= 0.5) return { ...base, action: 'drop_result', reason: 'result_dropped' };
94  return { ...base, action: 'drop_call', reason: 'call_dropped' };
95}
96
97/** The library's call question with this plugin's result question. */
98const questionsOf = (call) => ({ ...questionsFor(call), [`result_${call.id}`]: resultQuestion(call) });
99
100/** A result the assistant has already answered in text is no longer pinned; the first message stays pinned. */
101function repin(messages, calls) {
102  const lastText = messages.findLastIndex((m) => m.role === 'assistant' && m.text.trim());
103  return calls.map((call) => (call.pinned && call.callIndex > 0 && call.resultIndex < lastText ? { ...call, pinned: false } : call));
104}
105
106const INPUT_HEAD = 300;
107
108/** An input with its long string fields cut to their head; the same object when nothing is long. */
109function shortInput(input) {
110  let changed = false;
111  const out = {};
112  for (const [key, value] of Object.entries(input ?? {})) {
113    if (typeof value === 'string' && value.length > INPUT_HEAD * 2) {
114      out[key] = `${value.slice(0, INPUT_HEAD)}[… ${value.length - INPUT_HEAD} chars of this input dropped at compaction]`;
115      changed = true;
116    } else out[key] = value;
117  }
118  return changed ? out : input;
119}
120
121/** Assistant messages rebuilt without a handle (so without thinking), with the inputs of result-dropped calls cut. */
122function withoutThinking(messages, cutInputs, cut = { inputs: 0 }) {
123  return messages.flatMap((m) => {
124    if (m.role !== 'assistant') return [m];
125    const toolUses = m.toolUses.map((tool) => {
126      const input = cutInputs.has(tool.tool_use_id) ? shortInput(tool.input) : tool.input;
127      if (input === tool.input) return tool;
128      cut.inputs += 1;
129      const copy = { tool_use_id: tool.tool_use_id, tool: tool.tool, input };
130      if (tool.text !== undefined) copy.text = tool.text;
131      if (tool.isError) copy.isError = true;
132      return copy;
133    });
134    if (!m.text.trim() && toolUses.length === 0) return [];
135    return [{ role: 'assistant', text: m.text, toolUses }];
136  });
137}
138
139/** Exchanges: a user request (not a tool result, not a harness record) up to the next one. */
140function exchangesOf(messages) {
141  const starts = messages.flatMap((m, i) => (m.role === 'user' && m.text.trim() && !m.text.trimStart().startsWith('<') && !(m.toolResults ?? []).length ? [i] : []));
142  return starts.map((start, k) => ({ id: `e${k + 1}`, start, end: (starts[k + 1] ?? messages.length) - 1 }));
143}
144
145/** Exchanges Jev may drop: not the first, not one reaching into the newest messages, none with an unanswered result. */
146function topicCandidates(messages, calls, recent) {
147  const waiting = calls.filter((c) => c.pinned && c.callIndex > 0).map((c) => c.resultIndex);
148  return exchangesOf(messages).filter((e) => e.start > 0 && e.end < messages.length - recent && !waiting.some((i) => i >= e.start && i <= e.end));
149}
150
151const inputChars = (input) => {
152  try {
153    return JSON.stringify(input ?? {}).length;
154  } catch {
155    return 0;
156  }
157};
158const callChars = (call) => call.resultChars + inputChars(call.input);
159const exchangeChars = (messages, t) => messages.slice(t.start, t.end + 1).reduce((sum, m) => sum + messageChars(m), 0);
160
161const opening = (messages, t) => messages[t.start].text.replace(/\s+/g, ' ').trim().slice(0, 200);
162
163/** Jev's question about an exchange: did the user close its topic? */
164export function topicQuestion(t, messages) {
165  return {
166    type: 'noul',
167    instructions: `The user closed the topic of the exchange in history entries ${t.start}-${t.end} (it opens with the user saying: "${opening(messages, t)}"): they said it is finished or set it aside, and the remaining work does not come back to it.`,
168  };
169}
170
171const TOPIC_NOTE_LINES = 600;
172
173/** The note left for a dropped exchange: its opening words and what stood out in its tool output. */
174function topicNote(messages, t) {
175  const outputs = messages.slice(t.start, t.end + 1).flatMap((m) => (m.toolResults ?? []).map((r) => r.text));
176  const lines = pickStandouts(outputs, { budget: TOPIC_NOTE_LINES }).picked.flat();
177  const head = `[jev-context: an earlier exchange was dropped at compaction because the user closed its topic. It opened with: "${opening(messages, t).slice(0, 120)}"`;
178  return lines.length ? `${head}. Lines that stood out in its tool output:\n${lines.join('\n')}]` : `${head}]`;
179}
180
181const count = (decisions, action) => decisions.filter((d) => d.action === action && d.reason !== 'pinned').length;
182
183/**
184 * Compacts `messages` (Claude Code's SessionMessage shape). User messages the
185 * decisions leave alone come back as the same objects, so the engine keeps its
186 * own copy; assistant messages and anything edited come back rebuilt, without
187 * a handle. Throws when Jev fails or the history cannot be fitted: the caller
188 * falls back to the built-in summary.
189 */
190export async function compactVerbatim(cfg, messages, jev, { goal = '' } = {}) {
191  const started = Date.now();
192  const options = resolveOptions({ goal });
193  const collected = collectToolCalls(messages, options.preserveRecentMessages);
194  const collectedPinned = collected.map((c) => c.pinned);
195  const allCalls = repin(messages, collected);
196  const unpinned = allCalls.filter((call) => !call.pinned);
197  const candidates = unpinned.filter((call) => callChars(call) >= ASK_CALL_CHARS);
198  const small = new Set(unpinned.filter((call) => callChars(call) < ASK_CALL_CHARS).map((call) => call.tool_use_id));
199  const exchanges = cfg.compactTopics === 'on' ? topicCandidates(messages, allCalls, options.preserveRecentMessages) : [];
200  const topics = exchanges.filter((t) => exchangeChars(messages, t) >= ASK_EXCHANGE_CHARS);
201  const charsBefore = messages.reduce((sum, m) => sum + messageChars(m), 0);
202  const base = { calls: allCalls.length, charsBefore };
203  if (candidates.length === 0 && topics.length === 0) return { stage: 'no_candidates', messages, stats: { ...base, charsAfter: charsBefore, reduction: 0 } };
204
205  // 1. Questions per call (and per exchange when asked for), with the whole
206  // history (results as notes) as state; the requests run side by side.
207  const fitted = fitState(messages, allCalls, options);
208  const answers = new Map();
209  const topicP = new Map();
210  await Promise.all([
211    ...batchCalls(candidates, fitted.tokens, options).map(async (batch) => {
212      const { answers: got } = await jev.ask(fitted.state, Object.assign({}, ...batch.map(questionsOf)));
213      for (const call of batch) answers.set(call.id, { keepCall: noulAnswer(got, `call_${call.id}`), keepResult: noulAnswer(got, `result_${call.id}`) });
214    }),
215    topics.length > 0 && (async () => {
216      const { answers: got } = await jev.ask(fitted.state, Object.fromEntries(topics.map((t) => [`topic_${t.id}`, topicQuestion(t, messages)])));
217      for (const t of topics) topicP.set(t.id, noulAnswer(got, `topic_${t.id}`));
218    })(),
219  ]);
220  const keep = cfg.compactKeep ?? 0.3;
221  // A call too small to ask about stays as it is.
222  const decisionOf = new Map(allCalls.map((call) => [call.tool_use_id, small.has(call.tool_use_id)
223    ? { id: call.id, tool: call.tool, keepCall: 1, keepResult: 1, action: 'keep', reason: 'small' }
224    : decide(call, answers.get(call.id) ?? { keepCall: 1, keepResult: 1 }, keep)]));
225
226  // 2. Exchanges whose topic the user closed go whole; the next kept request
227  // carries a note that they existed. Calls are then collected again over
228  // what is left, with the answers they already got.
229  const gone = topics.filter((t) => topicP.get(t.id) >= (cfg.compactTopicDrop ?? 0.8));
230  const dropIndex = new Set(gone.flatMap((t) => Array.from({ length: t.end - t.start + 1 }, (_, k) => t.start + k)));
231  const notes = new Map();
232  for (const t of gone) {
233    let next = t.end + 1;
234    while (dropIndex.has(next)) next += 1;
235    const opener = messages[next];
236    if (opener) notes.set(opener, [...(notes.get(opener) ?? []), topicNote(messages, t)]);
237  }
238  const left = messages.filter((_, i) => !dropIndex.has(i));
239  const calls = gone.length ? repin(left, collectToolCalls(left, options.preserveRecentMessages)) : allCalls;
240  let decisions = calls.map((call) => (call.pinned ? { id: call.id, tool: call.tool, keepCall: 1, keepResult: 1, action: 'keep', reason: 'pinned' } : { ...decisionOf.get(call.tool_use_id), id: call.id }));
241
242  // 3. What each dropped result held that looked like nothing else in it.
243  const byId = new Map(calls.map((call) => [call.id, call]));
244  const outputs = outputsById(left);
245  const dropped = decisions.filter((d) => d.action !== 'keep').map((d) => byId.get(d.id));
246  const texts = dropped.map((call) => outputs.get(call.tool_use_id) ?? '');
247  const { picked, chars: rescuedChars } = pickStandouts(texts, {
248    budget: cfg.retainMaxChars ?? 6_000,
249    skip: (i, line) => texts[i].slice(0, options.truncateHeadChars).includes(line),
250  });
251  const kept = new Map(dropped.flatMap((call, i) => (picked[i].length ? [[call.tool_use_id, picked[i]]] : [])));
252  // A call whose output still holds needed lines is not dropped whole.
253  decisions = decisions.map((d) => (d.action === 'drop_call' && kept.has(byId.get(d.id).tool_use_id) ? { ...d, action: 'drop_result', reason: 'result_dropped', rescued: true } : d));
254
255  // 4. Rebuild. applyDecisions hands back fresh copies for what it truncated;
256  // only those get the kept lines, so the engine's own objects stay untouched.
257  const originals = new Set(left.flatMap((m) => [m, ...m.toolUses, ...(m.toolResults ?? [])]));
258  const applied = applyDecisions(left, decisions, calls, options.truncateHeadChars);
259  for (const message of applied) {
260    if (originals.has(message)) continue;
261    for (const item of [...message.toolUses, ...(message.toolResults ?? [])]) {
262      if (originals.has(item) || !kept.has(item.tool_use_id)) continue;
263      item.text = withKeptLines(outputs.get(item.tool_use_id) ?? '', kept.get(item.tool_use_id), options.truncateHeadChars);
264    }
265  }
266  const cutInputs = new Set(decisions.filter((d) => d.action === 'drop_result').map((d) => byId.get(d.id).tool_use_id));
267  const cut = { inputs: 0 };
268  const out = withoutThinking(applied, cutInputs, cut).map((m) => {
269    const lines = notes.get(m);
270    if (!lines) return m;
271    const noted = { role: m.role, text: `${lines.join('\n')}\n\n${m.text}`, toolUses: m.toolUses };
272    if (m.toolResults) noted.toolResults = m.toolResults;
273    return noted;
274  });
275  const charsAfter = out.reduce((sum, m) => sum + messageChars(m), 0);
276  const reduction = charsBefore === 0 ? 0 : (charsBefore - charsAfter) / charsBefore;
277  return {
278    stage: reduction >= (cfg.compactMinReduction ?? MIN_REDUCTION) ? 'compacted' : 'below_min',
279    messages: out,
280    decisions,
281    topics: topics.map((t) => ({ ...t, p: topicP.get(t.id), dropped: gone.includes(t) })),
282    stats: {
283      ...base,
284      charsAfter,
285      reduction: Math.round(reduction * 1000) / 1000,
286      messagesBefore: messages.length,
287      messagesAfter: out.length,
288      kept: count(decisions, 'keep'),
289      resultsDropped: count(decisions, 'drop_result'),
290      callsDropped: count(decisions, 'drop_call'),
291      pinned: decisions.filter((d) => d.reason === 'pinned').length,
292      unpinnedRecent: allCalls.filter((c, i) => !c.pinned && collectedPinned[i]).length,
293      inputsCut: cut.inputs,
294      rescuedResults: kept.size,
295      rescuedLines: [...kept.values()].reduce((n, lines) => n + lines.length, 0),
296      rescuedChars,
297      callsAsked: candidates.length,
298      callsTooSmall: small.size,
299      topicsAsked: topics.length,
300      topicsTooSmall: exchanges.length - topics.length,
301      topicsDropped: gone.length,
302      topicP: topics.map((t) => Math.round((topicP.get(t.id) ?? 1) * 100) / 100),
303      stateTokens: fitted.tokens,
304      stateStage: fitted.stage,
305      jevRequests: jev.counter?.requests,
306      ms: Date.now() - started,
307    },
308  };
309}
310

1// Deterministic reduction of command output. Nothing here guesses what the
2// task needs: it only folds what is structurally repetitive, and it never
3// folds a line jev-pruner treats as a diagnostic or a result.
4import { isProtectedLine } from '../../vendor/jev-pruner/dist/retention.js';
5
6const ANSI = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
7const MIN_RUN = 6;
8const FOLD_MARK = /^\[… \d+ similar lines …\]$/;
9const SIMILARITY = 0.7;
10
11/** A line's shape: words kept, numbers and long hex runs abstracted. */
12function shape(line) {
13  return line
14    .toLowerCase()
15    .replace(/[0-9a-f]{6,}/g, '<h>')
16    .replace(/\d+/g, '#')
17    .split(/[^a-z#<>]+/)
18    .filter(Boolean);
19}
20
21function similar(a, b) {
22  if (a.length === 0 || b.length === 0) return false;
23  let same = 0;
24  for (let i = 0; i < Math.min(a.length, b.length); i += 1) if (a[i] === b[i]) same += 1;
25  return same / Math.max(a.length, b.length) >= SIMILARITY;
26}
27
28/** Only the final state of a line rewritten with carriage returns (progress bars). */
29function settle(line) {
30  if (!line.includes('\r')) return line;
31  const parts = line.split('\r').filter((part) => part.length > 0);
32  return parts.at(-1) ?? '';
33}
34
35/**
36 * Folds runs of at least MIN_RUN similar lines to their first two and last
37 * line plus a count, strips ANSI codes, settles progress bars, squeezes blank
38 * runs. Returns the text and how many lines were folded away.
39 */
40export function reduceOutput(text) {
41  const lines = text.replace(ANSI, '').split('\n').map(settle);
42  const out = [];
43  let folded = 0;
44  let i = 0;
45  while (i < lines.length) {
46    const line = lines[i];
47    if (!line.trim()) {
48      if (out.at(-1)?.trim() !== '' || out.length === 0) out.push('');
49      else folded += 1;
50      i += 1;
51      continue;
52    }
53    if (isProtectedLine(line)) {
54      out.push(line);
55      i += 1;
56      continue;
57    }
58    const head = shape(line);
59    let j = i + 1;
60    while (j < lines.length && lines[j].trim() && !isProtectedLine(lines[j]) && similar(head, shape(lines[j]))) j += 1;
61    const run = j - i;
62    if (run >= MIN_RUN) {
63      out.push(lines[i], lines[i + 1], `[… ${run - 3} similar lines …]`, lines[j - 1]);
64      folded += run - 3;
65    } else {
66      out.push(...lines.slice(i, j));
67    }
68    i = j;
69  }
70  return { text: out.join('\n'), folded };
71}
72
73/** A coarser shape than folding uses: any word is `w`, any number `#`, any hex run `h`. */
74const outline = (line) => line.trim().replace(/\b[0-9a-f]{4,}\b/gi, 'h').replace(/[A-Za-z]+/g, 'w').replace(/\d+/g, '#').replace(/w(?:[ _-]w)+/g, 'w+');
75
76/**
77 * The lines that look like nothing else in their output: in a long log the
78 * value, the failure and the summary usually do. The first line (the command
79 * banner) is left out. Output where many lines stand out (code, prose, a
80 * table of distinct rows) has no standouts by this measure and returns none.
81 */
82export function standoutLines(text, { minLines = 20, maxShare = 0.05 } = {}) {
83  const lines = text.replace(ANSI, '').split('\n').map(settle).filter((line) => line.trim());
84  // Output reduceOutput already folded was long, and its repeats are gone:
85  // judge what is left however short it is, leaving out the fold markers.
86  const folded = lines.some((line) => FOLD_MARK.test(line));
87  if (lines.length < (folded ? 1 : minLines)) return [];
88  const counts = new Map();
89  for (const line of lines) counts.set(outline(line), (counts.get(outline(line)) ?? 0) + 1);
90  const rare = lines.slice(1).filter((line) => !FOLD_MARK.test(line) && counts.get(outline(line)) <= 2);
91  return rare.length <= Math.max(5, lines.length * (folded ? 0.5 : maxShare)) ? rare : [];
92}
93
94/**
95 * Standout lines of several outputs, newest (last) first, within a total and a
96 * per-output budget. `skip(i, line)` leaves out lines already kept elsewhere.
97 */
98export function pickStandouts(texts, { budget, perOutput = 1_500, skip = () => false }) {
99  const picked = texts.map(() => []);
100  let used = 0;
101  for (let i = texts.length - 1; i >= 0; i -= 1) {
102    let size = 0;
103    for (const line of standoutLines(texts[i])) {
104      if (skip(i, line) || size + line.length > perOutput || used + size + line.length > budget) continue;
105      picked[i].push(line);
106      size += line.length + 1;
107    }
108    used += size;
109  }
110  return { picked, chars: used };
111}
112