@buoy-gg/agent-core 7.0.41 → 7.0.42

package/lib/module/engine/historyBudget.js

@@ -1,355 +1 @@
-"use strict";
-
-/**
- * How much conversation the model is allowed to be sent, and what gets cut.
- *
- * Lives here, not in `session.ts`, because it is needed in TWO places and used
- * to run in only one. The session trims once per turn, before the loop starts
- * — and a turn is not one request. A twelve-step investigation appends an
- * assistant message and a tool-results message per step, each result capped at
- * 24,000 characters, so a long read chain could add well over a hundred
- * thousand characters AFTER the only check had already happened and walk
- * straight into the provider's context limit. The engine now applies the same
- * budget before every request; the session still applies it when a turn opens.
- */
-
-import { compressedMarker } from "./evidence";
-import { DEFAULT_CHARS_PER_TOKEN } from "./tokenCalibration";
-
-/**
- * A long QA session must not die on the provider's context limit with an
- * opaque error, so the history is kept under a budget.
- *
- * TWO STAGES, AND THE ORDER IS THE POINT. Dropping the oldest rounds was the
- * only stage, and in a QA session the oldest round is usually the SETUP — the
- * override that was armed, the store that was written, the user someone is
- * impersonating. Drop it and the model can no longer explain the screen it is
- * looking at, or that a "wrong" response is its own mock. The reply gets worse
- * in exactly the sessions long enough to need trimming.
- *
- * So: COMPRESS first, DROP only if that was not enough.
- *
- * A tool result is "consumed" once the model has produced an assistant message
- * after seeing it — it has already been reasoned over, and what remains is
- * bulk. Replacing it with a marker keeps the round, its decision and its
- * ordering while giving back nearly all the bytes. Three exemptions carry
- * their weight:
- *
- * - Errors are never compressed. A failure is the diagnostic value.
- * - The newest tool-results message is never compressed. The model is about
- *   to answer from it.
- * - The last read before a WRITE is never compressed: that is the shape the
- *   model matched its edit to, and it is the thing it re-reads when the write
- *   is refused and it has to correct itself.
- *
- * Only if the history is still over budget do whole rounds get dropped, as
- * before — a round starts at a user message, so the assistant/tool-result
- * pairing every provider requires stays intact.
- */
-/**
- * The limits are in TOKENS — the unit the provider enforces — and turned into
- * characters at the ratio the session has measured (engine/tokenCalibration.ts).
- * The `_CHARS` constants below are those limits at the default 4 chars/token,
- * kept for callers that have no calibration in hand (tests, one-shot use).
- */
-export const MAX_HISTORY_TOKENS = 37_500;
-/**
- * The ceiling on a WHOLE request: tools, system prompt, messages and the room
- * reserved for the reply. 100k tokens fits the smallest context Ask Buoy is
- * pointed at in practice (a 128k-token gateway) with headroom, and leaves
- * Anthropic's 200k far from the limit.
- */
-export const MAX_REQUEST_TOKENS = 100_000;
-export const MAX_HISTORY_CHARS = MAX_HISTORY_TOKENS * DEFAULT_CHARS_PER_TOKEN;
-export const MAX_REQUEST_CHARS = MAX_REQUEST_TOKENS * DEFAULT_CHARS_PER_TOKEN;
-const MIN_KEEP_MESSAGES = 4;
-/** Below this a marker costs more than the payload it replaces. */
-const MIN_COMPRESS_CHARS = 400;
-export function messageSize(m) {
-  try {
-    return JSON.stringify(m).length;
-  } catch {
-    return 0;
-  }
-}
-
-/**
- * Replace consumed tool results with a marker. See the note above
- * MAX_HISTORY_CHARS for what "consumed" means and why the exemptions exist.
- */
-export function compressConsumed(messages, exemptNewest = true) {
-  // The newest tool-results message: the model is about to answer from it.
-  // Unless the caller says otherwise — `budgetForRequest` hands in the rounds
-  // BEFORE the current one, whose last result was answered long ago.
-  let newest = messages.length;
-  if (exemptNewest) {
-    newest = -1;
-    for (let i = messages.length - 1; i >= 0; i--) {
-      if (messages[i].role === "tool-results") {
-        newest = i;
-        break;
-      }
-    }
-    if (newest <= 0) return messages;
-  }
-
-  // The reads a later write depended on. An assistant turn that called a
-  // write was matching a shape it read in the round before, and that is the
-  // read it goes back to when the write is refused.
-  const beforeWrite = new Set();
-  for (let i = 0; i < messages.length; i++) {
-    const m = messages[i];
-    if (m.role !== "assistant" || !m.toolCalls?.length) continue;
-    if (!m.toolCalls.some(c => WRITE_ISH.test(JSON.stringify(c.input ?? {}) + c.name))) continue;
-    for (let j = i - 1; j >= 0 && j >= i - 3; j--) {
-      if (messages[j].role === "tool-results") {
-        beforeWrite.add(j);
-        break;
-      }
-    }
-  }
-  let changed = false;
-  const out = messages.map((m, i) => {
-    if (m.role !== "tool-results" || i >= newest || beforeWrite.has(i)) return m;
-    let touched = false;
-    const results = m.results.map(r => {
-      if (r.isError || r.content.length < MIN_COMPRESS_CHARS) return r;
-      if (r.content.startsWith("[earlier result")) return r;
-      touched = true;
-      // The ref survives the compression: the marker names it, and a later
-      // `retrieve` reads the full text back. See engine/evidence.ts.
-      return {
-        ...r,
-        content: compressedMarker(r.content.length, r.ref)
-      };
-    });
-    if (!touched) return m;
-    changed = true;
-    return {
-      ...m,
-      results
-    };
-  });
-  return changed ? out : messages;
-}
-
-/**
- * Heuristic for "this call changed something". Deliberately loose: the cost of
- * a false positive is one uncompressed read, the cost of a false negative is
- * the model losing the shape it was editing.
- */
-const WRITE_ISH = /set|write|dispatch|navigate|tap|override|restore|delete|remove|clear|save|run|impersonat|reload/i;
-
-/**
- * A round: a user message and everything up to the next one. `pinned` when
- * one of its tool calls made a change that is still applied — see
- * `dropRounds`.
- */
-
-function splitRounds(messages, pinnedCallIds) {
-  const rounds = [];
-  for (const m of messages) {
-    if (m.role === "user" || rounds.length === 0) rounds.push({
-      messages: [],
-      size: 0,
-      pinned: false
-    });
-    const round = rounds[rounds.length - 1];
-    round.messages.push(m);
-    round.size += messageSize(m);
-    if (pinnedCallIds?.size && m.role === "assistant" && m.toolCalls?.some(c => pinnedCallIds.has(c.id))) round.pinned = true;
-  }
-  return rounds;
-}
-
-/**
- * Drop whole rounds, oldest first, until `keepSize + dropped` fits — but the
- * PINNED rounds last.
- *
- * Dropping oldest-first was the whole rule, and in a QA session the oldest
- * round is usually the SETUP: the override that was armed, the store that
- * was written, the user someone is impersonating. Lose it and the model can
- * no longer explain the screen it is looking at, or that a "wrong" response
- * is its own mock — and the changes list in the prompt names the change but
- * not the reasoning around it. The ledger knows which changes are still
- * applied, so a round that made one is kept (compressed, like any other) for
- * as long as an unpinned round remains to drop instead. Only when nothing
- * else is left do pinned rounds go, oldest first, and the caller says so.
- * Strands' `pin-message.ts` is the same idea, keyed on message metadata.
- *
- * `minMessages` is the floor the session-level trim keeps (a history that
- * opens mid-exchange is rejected by every provider; the floor is applied on
- * STARTING a drop, so a drop always runs to the next user boundary).
- */
-function dropRounds(rounds, budget, keepSize, minMessages) {
-  const remaining = [...rounds];
-  let size = remaining.reduce((n, r) => n + r.size, 0);
-  let droppedRounds = 0;
-  let droppedPinned = 0;
-  const messageCount = () => remaining.reduce((n, r) => n + r.messages.length, 0);
-  while (remaining.length > 0 && size + keepSize > budget && messageCount() > minMessages) {
-    let i = remaining.findIndex(r => !r.pinned);
-    if (i < 0) {
-      i = 0;
-      droppedPinned += 1;
-    }
-    size -= remaining[i].size;
-    remaining.splice(i, 1);
-    droppedRounds += 1;
-  }
-  return {
-    kept: remaining.flatMap(r => r.messages),
-    droppedRounds,
-    droppedPinned
-  };
-}
-
-/**
- * Trim, and say how many whole rounds were dropped — the number the UI turns
- * into "older messages were trimmed from the agent's memory".
- *
- * A round is a user message and everything up to the next one. Once a drop
- * starts it ALWAYS runs to the next user boundary: the inner loop used to stop
- * at `MIN_KEEP_MESSAGES` as well, so a history could come out starting with an
- * assistant or tool-results message — which every provider rejects. The
- * minimum-keep guard belongs on STARTING a drop, not on finishing one.
- */
-export function trimHistoryReport(messages, charsPerToken = DEFAULT_CHARS_PER_TOKEN, /** Tool-call ids whose change is still applied — their rounds are dropped last. See dropRounds. */
-pinnedCallIds) {
-  const limit = Math.floor(MAX_HISTORY_TOKENS * charsPerToken);
-  let total = 0;
-  for (const m of messages) total += messageSize(m);
-  if (total <= limit) return {
-    messages,
-    droppedRounds: 0,
-    droppedPinned: 0
-  };
-
-  // Compress before dropping — a compressed round still explains the screen.
-  const compressed = compressConsumed(messages);
-  let after = 0;
-  for (const m of compressed) after += messageSize(m);
-  if (after <= limit) return {
-    messages: compressed,
-    droppedRounds: 0,
-    droppedPinned: 0
-  };
-  const {
-    kept,
-    droppedRounds,
-    droppedPinned
-  } = dropRounds(splitRounds(compressed, pinnedCallIds), limit, 0, MIN_KEEP_MESSAGES);
-  return {
-    messages: kept,
-    droppedRounds,
-    droppedPinned
-  };
-}
-
-/** Exported for the history tests; not part of the package surface. */
-export function trimHistory(messages) {
-  return trimHistoryReport(messages).messages;
-}
-
-/**
- * Trim the working history of a turn that is still running.
- *
- * Differs from `trimHistoryReport` in one way that matters: the CURRENT round
- * is never touched. A turn's own user message and the reads it has taken since
- * are the thing being answered, so compressing or dropping them would make the
- * request cheaper and the answer wrong. Everything before the last user
- * message is fair game, in the same order as always — compress, then drop.
- *
- * `reserve` is what the request costs BEFORE any messages: the tool
- * definitions (~8k tokens for a typical install, ~23k with everything
- * installed), the system prompt, and the reply the model is allowed to write.
- * Budgeting messages alone would leave the biggest fixed cost out of the sum.
- */
-export function budgetForRequest(messages, reserve,
-/**
- * A tighter ceiling on the messages than MAX_HISTORY_CHARS — set by the
- * engine after the provider refused a request as too big. The proactive
- * budget is an estimate; the provider's refusal is the truth.
- */
-cap = MAX_HISTORY_CHARS, /** The session's measured ratio; scales the whole-request ceiling. */
-charsPerToken = DEFAULT_CHARS_PER_TOKEN, /** Tool-call ids whose change is still applied — their rounds are dropped last. See dropRounds. */
-pinnedCallIds) {
-  /**
-   * `MAX_HISTORY_CHARS` is a MESSAGES budget and always was — subtracting the
-   * reserve from it is wrong by a wide margin. The tool block alone is ~94,000
-   * characters with every tool installed, and the system prompt another
-   * ~16,000, so `150,000 - reserve` left about 24,000 characters for the
-   * conversation and dropped every earlier round of a two-turn chat. Caught by
-   * the bank, which is exactly what it is for.
-   *
-   * So the messages budget is the smaller of the two ceilings: the one that
-   * has always applied, and whatever is left of the whole-request ceiling once
-   * the fixed cost is counted. In an ordinary install the first wins and
-   * nothing changes; the second only bites when the tools are huge.
-   */
-  const budget = Math.min(cap, Math.floor(MAX_REQUEST_TOKENS * charsPerToken) - reserve);
-  let total = 0;
-  for (const m of messages) total += messageSize(m);
-  if (total <= budget) return {
-    messages,
-    droppedRounds: 0,
-    droppedPinned: 0
-  };
-
-  // Where the current round begins. Nothing from here on is eligible.
-  let currentRound = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === "user") {
-      currentRound = i;
-      break;
-    }
-  }
-  if (currentRound <= 0) {
-    // The whole history is this one round and it is over the limit by
-    // itself. Its consumed results are compressed, the newest kept — see the
-    // last-resort note below; this is the same move with nothing to drop.
-    return {
-      messages: compressConsumed(messages),
-      droppedRounds: 0,
-      droppedPinned: 0
-    };
-  }
-  const earlier = messages.slice(0, currentRound);
-  const current = messages.slice(currentRound);
-  let currentSize = 0;
-  for (const m of current) currentSize += messageSize(m);
-
-  // `false`: the earlier rounds' last result was answered long ago — the
-  // newest-result exemption is about the round being answered NOW.
-  const compressed = compressConsumed(earlier, false);
-  let earlierSize = 0;
-  for (const m of compressed) earlierSize += messageSize(m);
-  if (earlierSize + currentSize <= budget) {
-    return {
-      messages: [...compressed, ...current],
-      droppedRounds: 0,
-      droppedPinned: 0
-    };
-  }
-  const {
-    kept: out,
-    droppedRounds,
-    droppedPinned
-  } = dropRounds(splitRounds(compressed, pinnedCallIds), budget, currentSize, 0);
-  earlierSize = out.reduce((n, m) => n + messageSize(m), 0);
-  /**
-   * LAST RESORT, inside the current round. Everything earlier is gone and the
-   * turn's own reads are still over the limit — a twelve-step investigation
-   * of 24k-character results does that by itself. The consumed ones (an
-   * assistant message came after them) are compressed the same way earlier
-   * rounds were, newest result and the reads before a write still exempt.
-   * Their refs make this lossless for the model: `retrieve` reads them back.
-   */
-  const currentOut = out.length === 0 && earlierSize + currentSize > budget ? compressConsumed(current) : current;
-  return {
-    messages: [...out, ...currentOut],
-    droppedRounds,
-    droppedPinned
-  };
-}
-//# sourceMappingURL=historyBudget.js.map
+"use strict";import{compressedMarker as P}from"./evidence";import{DEFAULT_CHARS_PER_TOKEN as a}from"./tokenCalibration";export const MAX_HISTORY_TOKENS=37500;export const MAX_REQUEST_TOKENS=1e5;export const MAX_HISTORY_CHARS=MAX_HISTORY_TOKENS*a;export const MAX_REQUEST_CHARS=MAX_REQUEST_TOKENS*a;const x=4;const A=400;export function messageSize(e){try{return JSON.stringify(e).length}catch{return 0}}export function compressConsumed(e,c=true){let i=e.length;if(c){i=-1;for(let t=e.length-1;t>=0;t--){if(e[t].role==="tool-results"){i=t;break}}if(i<=0)return e}const d=new Set;for(let t=0;t<e.length;t++){const u=e[t];if(u.role!=="assistant"||!u.toolCalls?.length)continue;if(!u.toolCalls.some(s=>z.test(JSON.stringify(s.input??{})+s.name)))continue;for(let s=t-1;s>=0&&s>=t-3;s--){if(e[s].role==="tool-results"){d.add(s);break}}}let o=false;const l=e.map((t,u)=>{if(t.role!=="tool-results"||u>=i||d.has(u))return t;let s=false;const n=t.results.map(r=>{if(r.isError||r.content.length<A)return r;if(r.content.startsWith("[earlier result"))return r;s=true;return{...r,content:P(r.content.length,r.ref)}});if(!s)return t;o=true;return{...t,results:n}});return o?l:e}const z=/set|write|dispatch|navigate|tap|override|restore|delete|remove|clear|save|run|impersonat|reload/i;function S(e,c){const i=[];for(const d of e){if(d.role==="user"||i.length===0)i.push({messages:[],size:0,pinned:false});const o=i[i.length-1];o.messages.push(d);o.size+=messageSize(d);if(c?.size&&d.role==="assistant"&&d.toolCalls?.some(l=>c.has(l.id)))o.pinned=true}return i}function m(e,c,i,d){const o=[...e];let l=o.reduce((n,r)=>n+r.size,0);let t=0;let u=0;const s=()=>o.reduce((n,r)=>n+r.messages.length,0);while(o.length>0&&l+i>c&&s()>d){let n=o.findIndex(r=>!r.pinned);if(n<0){n=0;u+=1}l-=o[n].size;o.splice(n,1);t+=1}return{kept:o.flatMap(n=>n.messages),droppedRounds:t,droppedPinned:u}}export function trimHistoryReport(e,c=a,i){const d=Math.floor(MAX_HISTORY_TOKENS*c);let o=0;for(const r of e)o+=messageSize(r);if(o<=d)return{messages:e,droppedRounds:0,droppedPinned:0};const l=compressConsumed(e);let t=0;for(const r of l)t+=messageSize(r);if(t<=d)return{messages:l,droppedRounds:0,droppedPinned:0};const{kept:u,droppedRounds:s,droppedPinned:n}=m(S(l,i),d,0,x);return{messages:u,droppedRounds:s,droppedPinned:n}}export function trimHistory(e){return trimHistoryReport(e).messages}export function budgetForRequest(e,c,i=MAX_HISTORY_CHARS,d=a,o){const l=Math.min(i,Math.floor(MAX_REQUEST_TOKENS*d)-c);let t=0;for(const p of e)t+=messageSize(p);if(t<=l)return{messages:e,droppedRounds:0,droppedPinned:0};let u=-1;for(let p=e.length-1;p>=0;p--){if(e[p].role==="user"){u=p;break}}if(u<=0){return{messages:compressConsumed(e),droppedRounds:0,droppedPinned:0}}const s=e.slice(0,u);const n=e.slice(u);let r=0;for(const p of n)r+=messageSize(p);const h=compressConsumed(s,false);let f=0;for(const p of h)f+=messageSize(p);if(f+r<=l){return{messages:[...h,...n],droppedRounds:0,droppedPinned:0}}const{kept:R,droppedRounds:_,droppedPinned:g}=m(S(h,o),l,r,0);f=R.reduce((p,M)=>p+messageSize(M),0);const E=R.length===0&&f+r>l?compressConsumed(n):n;return{messages:[...R,...E],droppedRounds:_,droppedPinned:g}}

package/lib/module/engine/retrieve.js

@@ -1,210 +1 @@
-"use strict";
-
-/**
- * `ask-buoy.retrieve` — read part of a kept result back. See evidence.ts.
- *
- * Four ways in, chosen so the model never needs the whole thing again:
- *
- * - nothing but `ref`   → the SHAPE: top-level keys with type and size, so the
- *                          next call can name a path. Handing back the full
- *                          text would only hit the same cap that cut it.
- * - `path`              → the value at a dotted / slash path ("stats.0.base_stat",
- *                          "/moves/3/move/name"). Arrays index by number.
- * - `slice: [a, b]`     → a window: items of an array, characters of a string.
- *                          Combines with `path`.
- * - `pattern`           → a literal, case-insensitive substring search over the
- *                          pretty-printed text; matching lines with
- *                          `contextLines` (default 2) around each. Not a regex:
- *                          a model that means "height" should not have to
- *                          escape anything, and an executable pattern over a
- *                          store of app data is a surface nobody asked for.
- *
- * Every result is capped at the same size as any other tool result, and the
- * engine never stashes a retrieve result — a retrieve of a retrieve is a loop.
- */
-
-const MAX_MATCHES = 20;
-const MAX_SHAPE_KEYS = 60;
-const DEFAULT_CONTEXT_LINES = 2;
-export function retrieveEvidence(store, params) {
-  if (!store) {
-    return {
-      ok: false,
-      error: "There is no evidence store in this session, so earlier results cannot be re-read. Call the tool again for the current value."
-    };
-  }
-  const entry = store.get(params.ref);
-  if (!entry) {
-    return store.wasEvicted(params.ref) ? {
-      ok: false,
-      error: `${params.ref} was kept but has since been evicted to make room (the store holds the most recent ~4 MB of results). Call the tool again for the current value.`
-    } : {
-      ok: false,
-      error: `No result with ref ${params.ref}. Refs look like ev_12 and appear in [truncated — …] and [earlier result — …] markers.`
-    };
-  }
-  const meta = {
-    ref: entry.ref,
-    from: `${entry.toolId}.${entry.action}`,
-    capturedAt: new Date(entry.capturedAt).toISOString(),
-    totalChars: entry.text.length
-  };
-  let parsed;
-  let isJson = true;
-  try {
-    parsed = JSON.parse(entry.text);
-  } catch {
-    isJson = false;
-  }
-  if (params.pattern !== undefined && params.pattern !== "") {
-    return {
-      ...meta,
-      ...search(isJson ? JSON.stringify(parsed, null, 1) : entry.text, params.pattern, params.contextLines ?? DEFAULT_CONTEXT_LINES)
-    };
-  }
-  if (!isJson) {
-    const text = params.slice ? entry.text.slice(params.slice[0], params.slice[1]) : entry.text;
-    return {
-      ...meta,
-      text
-    };
-  }
-  let value = parsed;
-  let at = "(root)";
-  if (params.path) {
-    const resolved = resolvePath(parsed, params.path);
-    if (!resolved.ok) return {
-      ...meta,
-      ok: false,
-      error: resolved.error
-    };
-    value = resolved.value;
-    at = params.path;
-  }
-  if (params.slice) {
-    const [a, b] = params.slice;
-    if (Array.isArray(value)) return {
-      ...meta,
-      at,
-      sliced: [a, b],
-      of: value.length,
-      value: value.slice(a, b)
-    };
-    if (typeof value === "string") return {
-      ...meta,
-      at,
-      sliced: [a, b],
-      of: value.length,
-      value: value.slice(a, b)
-    };
-    return {
-      ...meta,
-      ok: false,
-      error: `slice applies to an array or a string; the value at ${at} is ${typeOf(value)}.`
-    };
-  }
-  if (!params.path) return {
-    ...meta,
-    shape: shapeOf(parsed),
-    hint: "Pass path (e.g. \"stats.0\") or pattern to read a part."
-  };
-  return {
-    ...meta,
-    at,
-    value
-  };
-}
-
-// ── helpers ──────────────────────────────────────────────────────────────────
-
-function typeOf(v) {
-  if (v === null) return "null";
-  if (Array.isArray(v)) return "array";
-  return typeof v;
-}
-
-/** Top-level keys (or array items) with a type and a size, for choosing a path. */
-function shapeOf(v) {
-  if (Array.isArray(v)) {
-    return {
-      type: "array",
-      length: v.length,
-      first: v.length ? describe(v[0]) : undefined
-    };
-  }
-  if (v && typeof v === "object") {
-    const keys = Object.keys(v);
-    const shown = keys.slice(0, MAX_SHAPE_KEYS);
-    const out = {};
-    for (const k of shown) out[k] = describe(v[k]);
-    return keys.length > shown.length ? {
-      ...out,
-      "…": `${keys.length - shown.length} more keys`
-    } : out;
-  }
-  return describe(v);
-}
-function describe(v) {
-  if (v === null || v === undefined) return String(v);
-  if (Array.isArray(v)) return `array(${v.length})`;
-  if (typeof v === "object") {
-    const keys = Object.keys(v);
-    const size = JSON.stringify(v).length;
-    return `object{${keys.slice(0, 6).join(", ")}${keys.length > 6 ? ", …" : ""}} ~${size.toLocaleString("en-US")} chars`;
-  }
-  if (typeof v === "string") return v.length > 40 ? `string(${v.length})` : JSON.stringify(v);
-  return `${typeof v}: ${String(v)}`;
-}
-function resolvePath(root, path) {
-  const segs = path.replace(/^\/+/, "").split(/[./]/).filter(s => s.length > 0);
-  let cur = root;
-  const walked = [];
-  for (const seg of segs) {
-    if (cur === null || typeof cur !== "object") {
-      return {
-        ok: false,
-        error: `Cannot go into ${walked.join(".") || "(root)"} — it is ${typeOf(cur)}.`
-      };
-    }
-    if (Array.isArray(cur)) {
-      const i = Number(seg);
-      if (!Number.isInteger(i) || i < 0 || i >= cur.length) {
-        return {
-          ok: false,
-          error: `${walked.join(".") || "(root)"} is an array of ${cur.length}; "${seg}" is not an index in it.`
-        };
-      }
-      cur = cur[i];
-    } else {
-      const rec = cur;
-      if (!(seg in rec)) {
-        return {
-          ok: false,
-          error: `No field "${seg}" at ${walked.join(".") || "(root)"}. It has: ${Object.keys(rec).slice(0, 30).join(", ")}.`
-        };
-      }
-      cur = rec[seg];
-    }
-    walked.push(seg);
-  }
-  return {
-    ok: true,
-    value: cur
-  };
-}
-function search(text, pattern, contextLines) {
-  const lines = text.split("\n");
-  const needle = pattern.toLowerCase();
-  const hits = [];
-  for (let i = 0; i < lines.length; i++) if (lines[i].toLowerCase().includes(needle)) hits.push(i);
-  const ctx = Math.max(0, Math.min(10, contextLines));
-  const matches = hits.slice(0, MAX_MATCHES).map(i => ({
-    line: i + 1,
-    text: lines.slice(Math.max(0, i - ctx), i + ctx + 1).join("\n")
-  }));
-  return {
-    matches,
-    totalMatches: hits.length
-  };
-}
-//# sourceMappingURL=retrieve.js.map
+"use strict";const h=20;const g=60;const y=2;export function retrieveEvidence(e,t){if(!e){return{ok:false,error:"There is no evidence store in this session, so earlier results cannot be re-read. Call the tool again for the current value."}}const o=e.get(t.ref);if(!o){return e.wasEvicted(t.ref)?{ok:false,error:`${t.ref} was kept but has since been evicted to make room (the store holds the most recent ~4 MB of results). Call the tool again for the current value.`}:{ok:false,error:`No result with ref ${t.ref}. Refs look like ev_12 and appear in [truncated \u2014 \u2026] and [earlier result \u2014 \u2026] markers.`}}const r={ref:o.ref,from:`${o.toolId}.${o.action}`,capturedAt:new Date(o.capturedAt).toISOString(),totalChars:o.text.length};let l;let s=true;try{l=JSON.parse(o.text)}catch{s=false}if(t.pattern!==void 0&&t.pattern!==""){return{...r,...$(s?JSON.stringify(l,null,1):o.text,t.pattern,t.contextLines??y)}}if(!s){const i=t.slice?o.text.slice(t.slice[0],t.slice[1]):o.text;return{...r,text:i}}let n=l;let c="(root)";if(t.path){const i=k(l,t.path);if(!i.ok)return{...r,ok:false,error:i.error};n=i.value;c=t.path}if(t.slice){const[i,a]=t.slice;if(Array.isArray(n))return{...r,at:c,sliced:[i,a],of:n.length,value:n.slice(i,a)};if(typeof n==="string")return{...r,at:c,sliced:[i,a],of:n.length,value:n.slice(i,a)};return{...r,ok:false,error:`slice applies to an array or a string; the value at ${c} is ${u(n)}.`}}if(!t.path)return{...r,shape:d(l),hint:'Pass path (e.g. "stats.0") or pattern to read a part.'};return{...r,at:c,value:n}}function u(e){if(e===null)return"null";if(Array.isArray(e))return"array";return typeof e}function d(e){if(Array.isArray(e)){return{type:"array",length:e.length,first:e.length?f(e[0]):void 0}}if(e&&typeof e==="object"){const t=Object.keys(e);const o=t.slice(0,g);const r={};for(const l of o)r[l]=f(e[l]);return t.length>o.length?{...r,"\u2026":`${t.length-o.length} more keys`}:r}return f(e)}function f(e){if(e===null||e===void 0)return String(e);if(Array.isArray(e))return`array(${e.length})`;if(typeof e==="object"){const t=Object.keys(e);const o=JSON.stringify(e).length;return`object{${t.slice(0,6).join(", ")}${t.length>6?", \u2026":""}} ~${o.toLocaleString("en-US")} chars`}if(typeof e==="string")return e.length>40?`string(${e.length})`:JSON.stringify(e);return`${typeof e}: ${String(e)}`}function k(e,t){const o=t.replace(/^\/+/,"").split(/[./]/).filter(s=>s.length>0);let r=e;const l=[];for(const s of o){if(r===null||typeof r!=="object"){return{ok:false,error:`Cannot go into ${l.join(".")||"(root)"} \u2014 it is ${u(r)}.`}}if(Array.isArray(r)){const n=Number(s);if(!Number.isInteger(n)||n<0||n>=r.length){return{ok:false,error:`${l.join(".")||"(root)"} is an array of ${r.length}; "${s}" is not an index in it.`}}r=r[n]}else{const n=r;if(!(s in n)){return{ok:false,error:`No field "${s}" at ${l.join(".")||"(root)"}. It has: ${Object.keys(n).slice(0,30).join(", ")}.`}}r=n[s]}l.push(s)}return{ok:true,value:r}}function $(e,t,o){const r=e.split("\n");const l=t.toLowerCase();const s=[];for(let i=0;i<r.length;i++)if(r[i].toLowerCase().includes(l))s.push(i);const n=Math.max(0,Math.min(10,o));const c=s.slice(0,h).map(i=>({line:i+1,text:r.slice(Math.max(0,i-n),i+n+1).join("\n")}));return{matches:c,totalMatches:s.length}}