@chroxify/eunoe 1.2.1 → 1.3.0

package/dist/core/index.js

@@ -0,0 +1,2235 @@
+// src/context/content.ts
+function contentBlocks(content) {
+  if (typeof content === "string")
+    return [{ type: "text", text: content }];
+  return Array.isArray(content) ? content : [];
+}
+function blocks(message) {
+  return contentBlocks(message.content);
+}
+function joinedText(list) {
+  return list.filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join(`
+`);
+}
+function textOf(message) {
+  return joinedText(blocks(message));
+}
+function resultText(block) {
+  return typeof block.content === "string" ? block.content : joinedText(contentBlocks(block.content));
+}
+function withoutCacheControl(block) {
+  if (!("cache_control" in block))
+    return block;
+  const { cache_control: _, ...rest } = block;
+  return rest;
+}
+function clean(message) {
+  return { role: message.role, content: blocks(message).map(withoutCacheControl) };
+}
+var SHA256_ROUNDS = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var utf8 = new TextEncoder;
+var rotate = (x, n) => x >>> n | x << 32 - n;
+function sha256(text) {
+  const data = utf8.encode(text);
+  const size = data.length + 72 >> 6 << 6;
+  const bytes = new Uint8Array(size);
+  bytes.set(data);
+  bytes[data.length] = 128;
+  const view = new DataView(bytes.buffer);
+  view.setUint32(size - 8, Math.floor(data.length / 536870912));
+  view.setUint32(size - 4, data.length << 3 >>> 0);
+  const h = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+  const w = new Uint32Array(64);
+  for (let offset = 0;offset < size; offset += 64) {
+    for (let i = 0;i < 16; i += 1)
+      w[i] = view.getUint32(offset + i * 4);
+    for (let i = 16;i < 64; i += 1)
+      w[i] = w[i - 16] + (rotate(w[i - 15], 7) ^ rotate(w[i - 15], 18) ^ w[i - 15] >>> 3) + w[i - 7] + (rotate(w[i - 2], 17) ^ rotate(w[i - 2], 19) ^ w[i - 2] >>> 10) | 0;
+    let [a, b, c, d, e, f, g, k] = h;
+    for (let i = 0;i < 64; i += 1) {
+      const t1 = k + (rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25)) + (e & f ^ ~e & g) + SHA256_ROUNDS[i] + w[i] | 0;
+      const t2 = (rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+      k = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    h[0] += a;
+    h[1] += b;
+    h[2] += c;
+    h[3] += d;
+    h[4] += e;
+    h[5] += f;
+    h[6] += g;
+    h[7] += k;
+  }
+  return Array.from(h, (x) => x.toString(16).padStart(8, "0")).join("");
+}
+function shortHash(json, chars) {
+  return sha256(json).slice(0, chars);
+}
+function quickHash(text) {
+  let a = 3735928559 ^ text.length;
+  let b = 1103547991 ^ text.length;
+  for (let i = 0;i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    a = Math.imul(a ^ code, 2654435761);
+    b = Math.imul(b ^ code, 1597334677);
+  }
+  const high = Math.imul(a ^ a >>> 16, 2246822507) ^ Math.imul(b ^ b >>> 13, 3266489909);
+  const low = Math.imul(b ^ b >>> 16, 2246822507) ^ Math.imul(high ^ high >>> 13, 3266489909);
+  return `${(low >>> 0).toString(36)}${(high >>> 0).toString(36)}`;
+}
+function truncate(text, max) {
+  const cut = text.slice(0, max);
+  return /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut;
+}
+function clip(value, max) {
+  const text = String(value).replace(/\s+/g, " ").trim();
+  return text.length > max ? `${truncate(text, max)}…` : text;
+}
+function wellFormed(_key, value) {
+  return typeof value === "string" ? value.toWellFormed() : value;
+}
+function describeToolCall(block) {
+  const input = block.input ?? {};
+  if (typeof input.command === "string")
+    return `${block.name} \`${clip(input.command, 100)}\``;
+  if (typeof input.file_path === "string")
+    return `${block.name} ${input.file_path}`;
+  if (typeof input.pattern === "string")
+    return `${block.name} "${clip(input.pattern, 60)}"`;
+  return `${block.name} ${clip(JSON.stringify(input), 60)}`;
+}
+
+// src/context/prompts.ts
+var plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+var SYSTEM_PROMPT = [
+  "# Earlier sessions in this project",
+  "",
+  "eunoe keeps the full record of this project's earlier Claude Code sessions, and the user expects you to use it the way a colleague who was there would. When they point you at one, skipping it is the failure to avoid: you will redo finished work, break rules the user already set, and ask for things they already told you.",
+  "",
+  "## When",
+  "",
+  'A message carrying `{ee:continue:<id>}` already has that session attached to it as a `<handoff>` block: read it as part of the message, nothing to run. Use the commands below when the user names a session without the marker (`eunoe load <id>`), or when they refer to earlier work you have no context for: a plan, a todo, "the thing we talked about", "where we left off". `eunoe sessions <key words>` lists the closest earlier sessions, newest first, each with its first and last request; if one clearly continues into this message, load it, otherwise ask which they mean. Do not go looking for work that is clearly new and unrelated.',
+  "",
+  "## How",
+  "",
+  "1. `eunoe load <id>` writes that whole session to a file and prints its path. Read the file with the Read tool from the first line to the last, in as many Read calls as its length needs, before you act. Do not grep, head, tail or sed it, and do not stop partway: the rules, values and open todos you need are spread across all of it.",
+  "2. Only then start the work. Follow what the record establishes: the user's rules and preferences, decisions made, what was finished and what was left for later. Its values (ids, versions, names, commands) are exact.",
+  "",
+  "`eunoe peek <id> <words>` returns just the excerpts of a session that match, for a single fact such as an error message or a value. It is not a substitute for loading when the message continues that session's work.",
+  "",
+  "Loading or peeking needs no permission and no announcement: run it and carry on with the request."
+].join(`
+`);
+var HANDOFF_PREAMBLE = "What follows is carried over from an earlier session on this project so you can pick the work up without being told again: the user's messages, the key output lines and the agent's replies, in order. Treat the rules and preferences in it as still in force, and the values in it (ids, versions, names, commands) as exact. Its full tool output is not here but stays reachable two ways: when a later message touches it, the matching excerpts are attached to that message as recalled context, labelled with this session's title; and for a specific value you can run `eunoe peek <id> <words>` yourself.";
+function handoffBlock(label, text) {
+  return `<handoff from="${label}">
+${HANDOFF_PREAMBLE}
+
+${text}
+</handoff>`;
+}
+function recalledContext(entries, fromEarlierSessions) {
+  const where = fromEarlierSessions ? "earlier in this session or in an earlier session on this project" : "earlier in this session";
+  return `<recalled-context>
+Excerpts from ${where} that match this message: tool output that is no longer in your context, quoted exactly, oldest first. Where the same thing appears twice, the later turn is current. Use them if they answer what was asked; ignore them otherwise.
+
+${entries.join(`
+`)}
+</recalled-context>`;
+}
+function rerankQuestion(query) {
+  return `Which excerpt contains the exact answer to the developer's question about this coding session: "${query}"?`;
+}
+function toolEvidence(entries) {
+  return `<tool-evidence>
+Key lines of command output from this turn, kept verbatim (the full output is in the transcript):
+${entries.join(`
+`)}
+</tool-evidence>`;
+}
+function interruptedReply(lastWords, calls) {
+  const shown = calls.slice(-20);
+  return [
+    "[This turn was interrupted before a final reply.]",
+    lastWords ? `Last thing you said: ${lastWords.length > 600 ? `${truncate(lastWords, 600)}…` : lastWords}` : "",
+    calls.length > 0 ? `Tool calls (${calls.length}${calls.length > shown.length ? `, last ${shown.length} shown` : ""}): ${shown.join("; ")}` : "",
+    "Their output is in the full transcript."
+  ].filter(Boolean).join(`
+`);
+}
+function clearedOutput(dir) {
+  return `[Output cleared to keep the context within its limit. It is in the full transcript${dir ? ` at ${dir}` : ""}: search there for this call.]`;
+}
+function clearedInput(kept, cleared) {
+  return `${kept}… [${cleared} chars cleared; in the transcript]`;
+}
+function compactionNotice({ omitted, kept, pinned = 0, guide }) {
+  return [
+    "<context-compacted>",
+    "Your context was compacted here, so tool calls and their output from before this point were removed.",
+    omitted > 0 ? `${omitted} of the oldest turns didn't fit and were removed entirely. The ${plural(kept, "turn")} after them are shown as the user's message and your final reply.` : kept > 0 ? "Every earlier turn is shown below as the user's message and your final reply." : "",
+    pinned > 0 ? `${pinned === 1 ? "One earlier turn was" : `${pinned} earlier turns were`} kept whole, with their tool calls and output, because they matter to what comes next.` : "",
+    "The turn that was in progress when the context filled up follows in full. Continue from it.",
+    "Instructions and preferences the user gave in earlier turns still apply: how they want things done, and what to do or not do on your own. Look back over their messages before you act.",
+    "For an exact detail from before this point (an ID, a path, a command, an error, a value, what a tool printed), look it up instead of going from memory. A lookup is cheap; a wrong detail is not. Never say you don't know about something earlier in this session without searching for it first, and if what you remember contradicts what the user says, search before telling them they are wrong.",
+    guide ?? "",
+    "</context-compacted>"
+  ].filter(Boolean).join(`
+
+`);
+}
+function truncationNotice({ omitted, kept, guide }) {
+  return [
+    "<context-truncated>",
+    `${omitted} earlier turn${omitted === 1 ? " was" : "s were"} dropped to fit the context window. What follows is the most recent ${plural(kept, "turn")}, unchanged.`,
+    "Instructions and preferences the user gave in earlier turns still apply.",
+    guide ?? "",
+    "</context-truncated>"
+  ].filter(Boolean).join(`
+
+`);
+}
+function trimInstructions(guide) {
+  return [
+    "# Context between turns",
+    "",
+    "This session trims its context between turns: of every earlier turn you keep only the user's message (with anything that arrived with it) and your final message. Everything in between is gone when the next turn starts: tool calls and their results, files you read, command output, your thinking, and anything you wrote along the way. Within a turn, nothing is trimmed.",
+    "",
+    "So your final message is the only memory you carry forward. End each turn with a final message that lets you pick the work back up cold:",
+    "- What changed: files with their paths, branches, commits, PRs, anything created, moved or deleted.",
+    "- What you found: facts you would otherwise have to dig up again. Where code lives, how something works, the cause of a bug, exact error text, IDs, URLs, the numbers that matter.",
+    "- Decisions and their reasons, including approaches you tried and ruled out.",
+    "- Where things stand: what is done, what is not, what you verified and how, and what is waiting on the user.",
+    "",
+    'It is still your reply to the user, so write it for them, but leave out nothing you will need. State things outright instead of pointing back at tool output: "as shown above" means nothing next turn. One exact line (a path, a command, a value) beats a paragraph describing it. A turn that ends on a question still needs the state written down. A trivial turn (a quick answer, small talk) needs no state.',
+    "",
+    "Instructions and preferences the user gave in earlier turns still apply: how they want things done, and what to do or not do on your own.",
+    ...guide ? [
+      "",
+      "Nothing is lost. What you see of earlier turns is only their outcome. For an exact detail from an earlier turn (an ID, a path, a command you ran, what it printed, a file's earlier content, an error), look it up in the full transcript instead of going from memory or redoing the work. A lookup is cheap; a wrong detail is not.",
+      "",
+      guide,
+      "",
+      "What you read from it stays in context for this turn only. If you will need it again later, put it in your final message."
+    ] : []
+  ].join(`
+`);
+}
+function searchOnlyInstructions(guide) {
+  return [
+    "# The full transcript",
+    "",
+    "Earlier parts of this session may be summarised or missing from your context. The complete record is on disk, and for any exact detail from earlier (an ID, a path, a command you ran, what it printed, an error, a value) you should look it up there rather than answer from memory. A lookup is cheap; a wrong detail is not. Never say you don't know about something earlier in this session without searching for it first.",
+    "",
+    guide
+  ].join(`
+`);
+}
+function searchGuide(ref) {
+  if (ref.mode === "jsonl") {
+    return [
+      `The full transcript is Claude Code's session file: ${ref.jsonl}`,
+      "It is JSONL, one entry per line. Your tool calls are `tool_use` blocks in `assistant` entries; their output is in the `tool_result` blocks of the `user` entries that follow. It is large: search it narrowly and never read it whole. For example:",
+      `  grep -n 'distinctive text' ${ref.jsonl} | cut -c1-400`,
+      `  jq -r 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use") | "\\(.name) \\(.input | tostring | .[0:200])"' ${ref.jsonl}`
+    ].join(`
+`);
+  }
+  const layout = ref.mode === "xml" ? [
+    `The full transcript is a folder with one XML file per turn: ${ref.dir}`,
+    "- `index.md`: one line per turn, what the user asked and how the turn ended. Skim it to find the turn you need.",
+    "- `turn-0001.xml`, …: one turn each, `<turn n>` with `<user>` (the message), `<said>` (what you wrote while working), `<tool n name>` holding `<call>`, `<input>` and `<output>`, and `<final_reply>`.",
+    "- `turn-0001-subagent-1.xml`, …: the whole run of a subagent launched in that turn, same layout. The turn itself only has the subagent's report; what the subagent saw and ran is here."
+  ] : [
+    `The full transcript is a folder of markdown files: ${ref.dir}`,
+    "- `index.md`: one line per turn, what the user asked and how the turn ended. Skim it to find the turn you need.",
+    "- `turn-0001.md`, …: one turn each. `## User` (the message), `### [tool 3/12] Bash: …` for every tool call with `[output of tool 3]` below it, and `## Final reply`.",
+    "- `turn-0001-subagent-1.md`, …: the whole run of a subagent launched in that turn, same layout. The turn itself only has the subagent's report; what the subagent saw and ran is here."
+  ];
+  const habits = "Search for more than one phrasing (the exact term, a synonym, a file or function name, an error string) before you conclude something isn't there. Read the whole turn file around a hit: the answer is often a few calls before or after it.";
+  if (ref.mode === "qmd") {
+    return [
+      ...layout,
+      "It is indexed with qmd. Run qmd from inside that folder:",
+      `  cd ${ref.dir} && qmd query "a natural-language question"   # semantic + keyword, best when you don't know the exact words (5–20s)`,
+      `  cd ${ref.dir} && qmd search "exact words"                 # keyword only, instant`,
+      `  then Read ${ref.dir}/turn-NNNN.md (or qmd get turn-NNNN.md)`,
+      "If qmd isn't ready yet (the index builds in the background), grep the folder instead.",
+      habits
+    ].join(`
+`);
+  }
+  const ext = ref.mode === "xml" ? "xml" : "md";
+  return [
+    ...layout,
+    "To find something:",
+    `  grep -ril 'distinctive words' ${ref.dir}        # which turns mention it`,
+    `  grep -n -i 'distinctive words' ${ref.dir}/*.${ext} | cut -c1-300`,
+    `  then Read ${ref.dir}/turn-NNNN.${ext}`,
+    habits
+  ].join(`
+`);
+}
+
+// src/context/recall/rerank.ts
+var TIMEOUT_MS = 4000;
+function rerankState(chunks, candidates) {
+  return candidates.map((index, n) => {
+    const chunk = chunks[index];
+    return `### ${n}
+[turn ${chunk.turn}] ${chunk.call}
+${chunk.lines.map((l) => l.slice(0, 240)).join(`
+`)}`;
+  }).join(`
+
+`);
+}
+function orderByProbability(candidates, probabilities) {
+  return candidates.map((_, n) => n).sort((a, b) => (probabilities[String(b)] ?? 0) - (probabilities[String(a)] ?? 0) || a - b).map((n) => candidates[n]);
+}
+function failureReason(error) {
+  if (!(error instanceof Error))
+    return String(error);
+  return error.name === "TimeoutError" ? `timeout after ${TIMEOUT_MS}ms` : error.message;
+}
+function jevReranker(model, key, endpoint = "https://api.typesafe.ai/v1/systemone", onError) {
+  return async (query, chunks, candidates) => {
+    if (candidates.length < 2)
+      return candidates;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+        body: JSON.stringify({
+          model,
+          state: rerankState(chunks, candidates),
+          questions: {
+            where: {
+              type: "choice",
+              instructions: rerankQuestion(query),
+              criteria: Object.fromEntries(candidates.map((_, n) => [String(n), null]))
+            }
+          }
+        })
+      });
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        onError?.(`${response.status} ${/error_type"\s*:\s*"([^"]+)/.exec(body)?.[1] ?? body.slice(0, 60)}`.trim());
+        return candidates;
+      }
+      const probabilities = (await response.json()).answers?.where?.probabilities;
+      return probabilities && typeof probabilities === "object" ? orderByProbability(candidates, probabilities) : candidates;
+    } catch (error) {
+      onError?.(failureReason(error));
+      return candidates;
+    }
+  };
+}
+// src/core/config.ts
+var CORE_DEFAULTS = {
+  mode: "default",
+  compactAt: 0.9,
+  keepTurns: "all",
+  keep: 3,
+  budget: 1e5,
+  turnCap: 1e5
+};
+// src/context/fold/evidence.ts
+var REREADABLE_TOOLS = new Set(["Read", "Grep", "Glob", "LS", "NotebookRead", "WebFetch", "WebSearch", "TodoWrite", "Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var ERROR_LINE = /\b(?:error|errors|fail|fails|failed|failure|fatal|exception|panic|denied|refused|timed? ?out|traceback|cannot|unable to)\b/i;
+var ERROR_CODE = /\b[A-Z][A-Z0-9]*_[A-Z0-9_]{2,}\b|\bSIG[A-Z]{2,}\d*\b|\b[A-Z]{2,}\d{2,}\b|\bE(?:NOENT|ACCES|PERM|EXIST|CONN(?:REFUSED|RESET|ABORTED)|PIPE|ADDRINUSE|TIMEDOUT|NOTFOUND|INVAL|BUSY|MFILE|AGAIN|HOSTUNREACH|NOTDIR|ISDIR|BADF|NOSPC|AI_[A-Z]+)\b/;
+var VALUE_TOKEN = /\b[a-z]{2,}[_-](?=[a-z0-9]*\d)[a-z0-9]{6,}\b|\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,}\b|https?:\/\/[^\s)"']+|\b\d{4,}\b|\b\d{6,}_[a-z0-9_]{3,}\b|\bv?\d+\.\d+\.\d+\b|\b\d+(?:\.\d+)?\s?(?:ms|s|[KMGT]i?B|kB|%)(?![a-z])|\bsha\d*:[0-9a-f]+|@[a-z][\w-]+|--[a-z][\w-]*=\S+|\b\d+ (?:pass(?:ed|ing)?|fail(?:ed|ing)?|tests?|files? changed|insertions?|deletions?|rows?|errors?|warnings?)\b|[$€£]\d+(?:[.,]\d+)?|\b(?:status|HTTP\/\d(?:\.\d)?)\s*[:=]?\s*[45]\d{2}\b|\bexit(?: code| status)?\s*[:=]?\s*(?!0\b)\d{1,3}\b/i;
+var ID_TOKEN = /\b[a-z]{2,}[_-](?=[a-z0-9]*\d)[a-z0-9]{6,}\b|\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,}\b|https?:\/\/[^\s)"']+|\b\d{6,}_[a-z0-9_]{3,}\b|\bv?\d+\.\d+\.\d+\b|\bsha\d*:[0-9a-f]+|@[a-z][\w-]+|--[a-z][\w-]*=\S+/i;
+var KEY_VALUE = /^[\w .\-/()]{2,48}[:=]\s*\S/;
+var VALUE_LABEL = /\b(?:ids?|hash|sha(?:256)?|checksum|trace|deploy(?:ment)?|preview|url|version|rows|p9[59]|exit(?: code)?|signal|request[_-]?id|job|migration|applied|bundle|build|status|took|updated|created)\b/i;
+function resolved(options) {
+  return {
+    linesPerCall: options.linesPerCall ?? 12,
+    lineChars: options.lineChars ?? 220,
+    turnChars: options.turnChars ?? 4000,
+    scanLines: options.scanLines ?? 1e6,
+    minScore: options.minScore ?? 2,
+    ranked: options.ranked ?? true,
+    labels: options.labels ?? true,
+    callFloor: options.callFloor ?? 2
+  };
+}
+var isError = (line) => ERROR_LINE.test(line) || ERROR_CODE.test(line);
+function isSalient(line) {
+  return isError(line) || VALUE_TOKEN.test(line);
+}
+function scoreLines(text, options) {
+  const { scanLines, lineChars, minScore, labels } = resolved(options);
+  const scored = text.split(`
+`).slice(0, scanLines).flatMap((raw, index) => {
+    const line = raw.trim();
+    if (line.length < 4)
+      return [];
+    const error = isError(line);
+    const value = VALUE_TOKEN.test(line);
+    if (!error && !value)
+      return [];
+    const score = (error ? 3 : 0) + (value ? ID_TOKEN.test(line) ? 3 : 2 : 0) + (KEY_VALUE.test(line) ? 1 : 0) + (line.length < 120 ? 1 : 0) + (labels && VALUE_LABEL.test(line) ? 1 : 0);
+    return score >= minScore ? [{ index, line: clip(line, lineChars), score }] : [];
+  });
+  const seen = new Set;
+  return scored.sort((a, b) => b.score - a.score || a.index - b.index).filter((s) => !seen.has(s.line) && seen.add(s.line));
+}
+function salientLines(text, options = {}) {
+  return scoreLines(text, options).slice(0, resolved(options).linesPerCall).sort((a, b) => a.index - b.index).map((s) => s.line);
+}
+function toolPairs(turn) {
+  const results = new Map;
+  for (const message of turn) {
+    if (message.role !== "user")
+      continue;
+    for (const block of blocks(message))
+      if (block.type === "tool_result")
+        results.set(block.tool_use_id, block);
+  }
+  return turn.filter((m) => m.role === "assistant").flatMap((m) => blocks(m).filter((b) => b.type === "tool_use")).flatMap((call) => {
+    const result = results.get(call.id);
+    return result ? [{ call, result }] : [];
+  });
+}
+function render(entries) {
+  const shown = entries.filter((e) => e.lines.length > 0).map((e) => `- ${e.head}:
+${e.lines.map((l) => `    ${l}`).join(`
+`)}`);
+  return shown.length > 0 ? toolEvidence(shown) : null;
+}
+function inCallOrder(heads, pairs, options) {
+  const { turnChars } = resolved(options);
+  const entries = [];
+  let used = 0;
+  pairs.forEach(({ result }, i) => {
+    const lines = salientLines(resultText(result), options);
+    if (lines.length === 0)
+      return;
+    const size = heads[i].length + 4 + lines.reduce((s, l) => s + l.length + 5, 0);
+    if (used + size > turnChars)
+      return;
+    entries.push({ head: heads[i], lines });
+    used += size;
+  });
+  return entries;
+}
+function byScore(heads, pairs, options) {
+  const { turnChars, linesPerCall, callFloor } = resolved(options);
+  const perCall = pairs.map(({ result }) => scoreLines(resultText(result), options));
+  const chosen = new Map;
+  let used = 0;
+  const take = (call, line) => {
+    const bucket = chosen.get(call) ?? [];
+    const cost = line.line.length + 5 + (bucket.length > 0 ? 0 : heads[call].length + 4);
+    if (bucket.length >= linesPerCall || used + cost > turnChars)
+      return;
+    bucket.push(line);
+    chosen.set(call, bucket);
+    used += cost;
+  };
+  for (const [call, lines] of perCall.entries())
+    for (const line of lines.slice(0, callFloor))
+      take(call, line);
+  const rest = perCall.flatMap((lines, call) => lines.slice(callFloor).map((line) => ({ line, call }))).sort((a, b) => b.line.score - a.line.score || a.call - b.call || a.line.index - b.line.index);
+  for (const { line, call } of rest)
+    take(call, line);
+  return heads.map((head, i) => ({ head, lines: (chosen.get(i) ?? []).sort((a, b) => a.index - b.index).map((s) => s.line) }));
+}
+function turnEvidence(turn, options = {}) {
+  const pairs = toolPairs(turn).filter(({ call }) => options.allTools || !REREADABLE_TOOLS.has(call.name));
+  const heads = pairs.map(({ call, result }) => `${describeToolCall(call)}${result.is_error ? " (failed)" : ""}`);
+  return render(resolved(options).ranked ? byScore(heads, pairs, options) : inCallOrder(heads, pairs, options));
+}
+
+// src/context/fold/turns.ts
+var IMAGE_NOTE = /^\s*\[Image: original \d+x\d+, displayed at \d+x\d+\.[^\]]*\]\s*$/;
+var STALE_NOTE = /changed on disk since you last read it|was modified, either by the user or by a linter/;
+var isStaleNote = (text) => STALE_NOTE.test(String(text ?? ""));
+var isImageNote = (content) => content.length > 0 && content.every((block) => block.type === "text" && IMAGE_NOTE.test(String(block.text ?? "")));
+function isPrompt(message) {
+  if (message.role !== "user")
+    return false;
+  const content = blocks(message);
+  if (isImageNote(content))
+    return false;
+  return !content.some((block) => block.type === "tool_result") && content.some((block) => block.type === "text" || block.type === "image" || block.type === "document");
+}
+function splitTurns(messages) {
+  const preamble = [];
+  const turns = [];
+  for (const message of messages) {
+    const current = turns.at(-1);
+    if (isPrompt(message) && !current?.every((m) => m.role === "user"))
+      turns.push([message]);
+    else if (current)
+      current.push(message);
+    else
+      preamble.push(message);
+  }
+  return { preamble, turns };
+}
+function turnFingerprint(turn) {
+  return shortHash(JSON.stringify(blocks(turn[0]).map(withoutCacheControl)), 24);
+}
+function isHarness(message) {
+  return message.role === "system";
+}
+function hasContent(message) {
+  return blocks(message).some((block) => block.type !== "text" || String(block.text ?? "").trim());
+}
+var hasText = (block) => block.type === "text" && String(block.text ?? "").trim() !== "";
+function mergedHarness(turn) {
+  const seen = new Set;
+  const fresh = (block) => {
+    if (block.type !== "text")
+      return true;
+    const text = String(block.text ?? "");
+    if (isStaleNote(text) || seen.has(text))
+      return false;
+    seen.add(text);
+    return true;
+  };
+  const content = turn.filter((m) => isHarness(m) && hasContent(m)).flatMap((m) => blocks(m).map(withoutCacheControl)).filter(fresh);
+  return content.length > 0 ? [{ role: "system", content }] : [];
+}
+function interrupted(turn) {
+  const assistant = turn.filter((m) => m.role === "assistant");
+  const lastWords = assistant.map((m) => textOf(m).trim()).filter(Boolean).at(-1);
+  const calls = assistant.flatMap((m) => blocks(m).filter((b) => b.type === "tool_use")).map(describeToolCall);
+  return interruptedReply(lastWords, calls);
+}
+function carriedText(messages) {
+  return messages.filter((m) => m.role === "user").flatMap((m) => blocks(m).filter((b) => hasText(b) && !IMAGE_NOTE.test(String(b.text)) && !/^\s*(?:<system-reminder>[\s\S]*?<\/system-reminder>\s*)+$/.test(String(b.text)))).map((b) => ({ type: "text", text: b.text }));
+}
+function reduceTurn(turn, options = {}) {
+  const firstReply = turn.findIndex((m) => m.role === "assistant");
+  const opening = (firstReply === -1 ? turn : turn.slice(0, firstReply)).filter((m) => m.role === "user").map(clean);
+  const carried = carriedText(firstReply === -1 ? [] : turn.slice(firstReply));
+  if (carried.length > 0)
+    opening.push({ role: "user", content: carried });
+  const evidence = options.evidence ? turnEvidence(turn) : null;
+  if (evidence)
+    opening.push({ role: "user", content: [{ type: "text", text: evidence }] });
+  opening.push(...mergedHarness(turn));
+  const last = turn.findLast((m) => m.role !== "system");
+  const content = last?.role === "assistant" ? blocks(last) : [];
+  const text = content.filter(hasText);
+  const final = text.length > 0 && !content.some((b) => b.type === "tool_use") ? text.map((b) => ({ type: "text", text: b.text })) : [{ type: "text", text: interrupted(turn) }];
+  return [...opening, { role: "assistant", content: final }];
+}
+
+// src/context/fold/strategies.ts
+var pinnedBy = ({ pinned }) => (turn) => pinned !== undefined && pinned.size > 0 && pinned.has(turnFingerprint(turn));
+var countPinned = (turns, pinned) => pinned.size > 0 ? turns.filter((turn) => pinned.has(turnFingerprint(turn))).length : 0;
+function trimMessages(messages, options = {}) {
+  const { preamble, turns } = splitTurns(messages);
+  if (turns.length < 2)
+    return messages;
+  return [...preamble, ...turns.slice(0, -1).flatMap((turn) => reduceTurn(turn, options)), ...turns.at(-1) ?? []];
+}
+var CARRIED_CHARS = 80000;
+function carriedHarness(removed) {
+  const texts = removed.filter((m) => isHarness(m) && hasContent(m)).flatMap((m) => blocks(m).filter((b) => b.type === "text")).map((b) => String(b.text ?? "")).filter((text) => text.trim() && !isStaleNote(text));
+  const kept = [];
+  const seen = new Set;
+  let used = 0;
+  for (const text of texts.toReversed()) {
+    if (seen.has(text) || used + text.length > CARRIED_CHARS)
+      continue;
+    seen.add(text);
+    kept.push(text);
+    used += text.length;
+  }
+  return kept.toReversed().map((text) => ({ type: "text", text: `<system-reminder>
+${text}
+</system-reminder>` }));
+}
+var foldsOpening = (opening, keptFrom) => keptFrom === 1 && opening.length > 1;
+function compactMessages(messages, cutIndex, options) {
+  const { preamble, turns } = splitTurns(messages);
+  if (cutIndex <= 0 || cutIndex >= turns.length)
+    return messages;
+  const reduce = options.reduce ?? reduceTurn;
+  const isPinned = pinnedBy(options);
+  const keptFrom = Math.max(1, cutIndex - options.keepTurns);
+  const [first, ...rest] = turns[0];
+  const openingPinned = isPinned(turns[0]);
+  const openingFolded = !openingPinned && foldsOpening(turns[0], keptFrom);
+  const dropped = turns.slice(1, keptFrom);
+  const whole = dropped.filter(isPinned);
+  const pinned = whole.length + turns.slice(keptFrom, cutIndex).filter(isPinned).length + (openingPinned ? 1 : 0);
+  const kept = cutIndex - keptFrom + (openingFolded ? 1 : 0);
+  const notice = compactionNotice({ omitted: dropped.length - whole.length + (options.omittedBefore ?? 0), kept, pinned, guide: options.guide });
+  const removed = [...openingPinned || openingFolded ? [] : rest, ...dropped.filter((turn) => !isPinned(turn)).flat()];
+  const shown = (turn) => isPinned(turn) ? turn.map(clean) : reduce(turn, options);
+  return [
+    ...preamble,
+    first,
+    ...openingPinned ? rest.map(clean) : [],
+    { role: "user", content: [{ type: "text", text: notice }, ...carriedHarness(removed)] },
+    ...openingFolded ? reduce(turns[0], options).slice(1) : [],
+    ...whole.flatMap((turn) => turn.map(clean)),
+    ...turns.slice(keptFrom, cutIndex).flatMap(shown),
+    ...turns.slice(cutIndex).flat()
+  ];
+}
+function capTurns(messages, options) {
+  const { capChars } = options;
+  if (!capChars)
+    return messages;
+  const { preamble, turns } = splitTurns(messages);
+  if (turns.length < 3)
+    return messages;
+  const live = turns.length - 1;
+  const isPinned = pinnedBy(options);
+  const over = (turn, i) => i > 0 && i < live && !isPinned(turn) && JSON.stringify(turn).length > capChars;
+  if (!turns.some(over))
+    return messages;
+  const reduce = options.reduce ?? reduceTurn;
+  return [...preamble, ...turns.flatMap((turn, i) => over(turn, i) ? reduce(turn, options) : turn)];
+}
+function tailMessages(messages, from, guide) {
+  const { preamble, turns } = splitTurns(messages);
+  if (turns.length === 0 || from <= 1)
+    return messages;
+  const notice = truncationNotice({ omitted: from - 1, kept: turns.length - from, guide });
+  return [...preamble, turns[0][0], { role: "user", content: [{ type: "text", text: notice }] }, ...turns.slice(from).flat()];
+}
+function countToolResults(messages, from) {
+  return messages.slice(from).filter((m) => m.role === "user").reduce((total, m) => total + blocks(m).filter((b) => b.type === "tool_result").length, 0);
+}
+function shortenInput(input) {
+  if (typeof input === "string")
+    return input.length > 2000 ? clearedInput(truncate(input, 500), input.length - 500) : input;
+  if (Array.isArray(input))
+    return input.map(shortenInput);
+  if (input && typeof input === "object")
+    return Object.fromEntries(Object.entries(input).map(([k, v]) => [k, shortenInput(v)]));
+  return input;
+}
+function clearToolResults(messages, from, count, placeholder) {
+  let left = count;
+  const cleared = new Set;
+  const clearResult = (b) => {
+    if (b.type !== "tool_result" || left <= 0)
+      return b;
+    left -= 1;
+    cleared.add(b.tool_use_id);
+    return { type: "tool_result", tool_use_id: b.tool_use_id, ...b.is_error ? { is_error: true } : {}, content: placeholder };
+  };
+  const withResultsCleared = messages.map((message, index) => {
+    if (left <= 0 || index < from || message.role !== "user" || typeof message.content === "string")
+      return message;
+    if (!message.content.some((b) => b.type === "tool_result"))
+      return message;
+    return { ...message, content: message.content.map(clearResult) };
+  });
+  const isClearedCall = (b) => b.type === "tool_use" && cleared.has(b.id);
+  return withResultsCleared.map((message) => {
+    if (message.role !== "assistant" || typeof message.content === "string" || !message.content.some(isClearedCall))
+      return message;
+    return { ...message, content: message.content.map((b) => isClearedCall(b) ? { ...b, input: shortenInput(b.input) } : b) };
+  });
+}
+function appendSystem(system, text) {
+  const list = typeof system === "string" ? [{ type: "text", text: system }] : [...system ?? []];
+  const lastCached = list.findLastIndex((b) => b.cache_control);
+  const cacheControl = lastCached >= 0 ? list[lastCached].cache_control : undefined;
+  if (lastCached >= 0)
+    list[lastCached] = withoutCacheControl(list[lastCached]);
+  list.push({ type: "text", text, ...cacheControl ? { cache_control: cacheControl } : {} });
+  return list;
+}
+
+// src/context/recall/index.ts
+var SHOWN_LINES = 8;
+var BM25_K1 = 1.2;
+var BM25_B = 0.75;
+var STOPWORDS = new Set("the and for with that this what which when where who how was were did does done from into onto have has had you your our out not but are can could would should will just then than them they there their its it's about after before again also any each other some such only own same very more most over under while because been being into".split(" "));
+function terms(text) {
+  return (text.toLowerCase().match(/[a-z0-9_@$][a-z0-9_.:/@$-]*[a-z0-9_]|[a-z0-9]/g) ?? []).flatMap((term) => /[._:/-]/.test(term) ? [term, ...term.split(/[._:/-]+/)] : [term]).filter((term) => term.length >= 3 && !STOPWORDS.has(term));
+}
+function windows(lines, size) {
+  const out = [];
+  for (let start = 0;start < lines.length; start += size)
+    out.push(lines.slice(start, start + size));
+  return out;
+}
+var CHUNK_CACHE_TERMS = 8000000;
+var chunked = new Map;
+var chunkedTerms = 0;
+var termCount = (chunks) => chunks.reduce((sum, chunk) => sum + chunk.terms.length, 0);
+function forget(key) {
+  const known = chunked.get(key);
+  if (!known)
+    return;
+  chunked.delete(key);
+  chunkedTerms -= termCount(known.chunks);
+}
+function chunksOf(key, text, head, turn, build) {
+  if (key === null)
+    return build();
+  const known = chunked.get(key);
+  if (known && known.text === text && known.head === head) {
+    chunked.delete(key);
+    chunked.set(key, known);
+    if (known.turn !== turn) {
+      known.turn = turn;
+      known.chunks = known.chunks.map((chunk) => ({ ...chunk, turn }));
+    }
+    return known.chunks;
+  }
+  forget(key);
+  const chunks = build();
+  chunked.set(key, { text, head, turn, chunks });
+  chunkedTerms += termCount(chunks);
+  for (const oldest of chunked.keys()) {
+    if (chunkedTerms <= CHUNK_CACHE_TERMS || oldest === key)
+      break;
+    forget(oldest);
+  }
+  return chunks;
+}
+function recallChunks(messages, keptIds, options = {}) {
+  const size = options.windowLines ?? 6;
+  const weight = Math.max(1, options.callWeight ?? 1);
+  const chunks = [];
+  splitTurns(messages).turns.slice(0, -1).forEach((turn, turnIndex) => {
+    for (const { call, result } of toolPairs(turn)) {
+      const text = resultText(result);
+      if (keptIds.get(call.id) === text || !text.trim())
+        continue;
+      const head = describeToolCall(call);
+      const key = typeof call.id === "string" && call.id ? `${size}|${weight}|${call.id}` : null;
+      const built = chunksOf(key, text, head, turnIndex + 1, () => {
+        const headTerms = Array.from({ length: weight }, () => terms(head)).flat();
+        return windows(text.split(`
+`), size).map((window) => ({ turn: turnIndex + 1, call: head, lines: window, terms: [...headTerms, ...terms(window.join(`
+`))] }));
+      });
+      for (const chunk of built)
+        chunks.push(chunk);
+    }
+    if (!(options.narrative ?? true))
+      return;
+    const said = turn.slice(1, -1).filter((m) => m.role === "assistant").flatMap((m) => blocks(m).filter((b) => b.type === "text").map((b) => String(b.text ?? "").trim())).filter(Boolean).join(`
+`);
+    if (!said)
+      return;
+    const built = chunksOf(`${size}|said|${turnIndex}|${said}`, said, "agent", turnIndex + 1, () => windows(said.split(`
+`), size).map((window) => ({ turn: turnIndex + 1, call: "agent", lines: window, terms: terms(window.join(`
+`)) })));
+    for (const chunk of built)
+      chunks.push(chunk);
+  });
+  return chunks;
+}
+var INDEXED_FROM = 2000;
+var KEPT_INDEXES = 6;
+var SAMPLED = 32;
+var indexes = [];
+function addToIndex(index, chunk) {
+  index.members.add(chunk);
+  const counts = new Map;
+  for (const term of chunk.terms)
+    counts.set(term, (counts.get(term) ?? 0) + 1);
+  for (const [term, count] of counts) {
+    const postings = index.postings.get(term);
+    if (postings) {
+      postings.chunks.push(chunk);
+      postings.counts.push(count);
+    } else
+      index.postings.set(term, { chunks: [chunk], counts: [count] });
+  }
+}
+function overlap(index, chunks) {
+  const step = Math.max(1, Math.floor(chunks.length / SAMPLED));
+  let found = 0;
+  let sampled = 0;
+  for (let i = 0;i < chunks.length; i += step) {
+    sampled += 1;
+    if (index.members.has(chunks[i]))
+      found += 1;
+  }
+  return found / Math.max(1, sampled);
+}
+function indexFor(chunks) {
+  let best = null;
+  let bestOverlap = 0.5;
+  for (const index of indexes) {
+    const shared = overlap(index, chunks);
+    if (shared >= bestOverlap) {
+      best = index;
+      bestOverlap = shared;
+    }
+  }
+  let present = 0;
+  if (best) {
+    for (const chunk of chunks)
+      if (best.members.has(chunk))
+        present += 1;
+  }
+  if (!best || best.members.size - present > chunks.length / 2) {
+    if (best)
+      indexes.splice(indexes.indexOf(best), 1);
+    best = { members: new Set, postings: new Map };
+    present = 0;
+  } else
+    indexes.splice(indexes.indexOf(best), 1);
+  indexes.push(best);
+  if (indexes.length > KEPT_INDEXES)
+    indexes.shift();
+  if (present < chunks.length) {
+    for (const chunk of chunks)
+      if (!best.members.has(chunk))
+        addToIndex(best, chunk);
+  }
+  return best;
+}
+function indexedAll(queries, chunks, minTerms) {
+  const position = new Map;
+  let total = 0;
+  chunks.forEach((chunk, i) => {
+    position.set(chunk, i);
+    total += chunk.terms.length;
+  });
+  if (position.size !== chunks.length)
+    return null;
+  const index = indexFor(chunks);
+  const average = total / Math.max(1, chunks.length);
+  const hitsByTerm = new Map;
+  const hitsOf = (term) => {
+    const known = hitsByTerm.get(term);
+    if (known)
+      return known;
+    const hits = [];
+    const postings = index.postings.get(term);
+    if (postings)
+      postings.chunks.forEach((chunk, k) => {
+        const at = position.get(chunk);
+        if (at !== undefined)
+          hits.push([at, postings.counts[k]]);
+      });
+    hitsByTerm.set(term, hits);
+    return hits;
+  };
+  return queries.map((query) => {
+    const lists = [...new Set(query)].map(hitsOf);
+    const needed = Math.max(1, Math.min(minTerms, lists.filter((hits) => hits.length > 0).length));
+    const found = new Map;
+    lists.forEach((hits, k) => {
+      for (const [at, f] of hits) {
+        const mine = found.get(at);
+        if (mine)
+          mine.push([k, f]);
+        else
+          found.set(at, [[k, f]]);
+      }
+    });
+    const scored = [];
+    for (const at of [...found.keys()].sort((a, b) => a - b)) {
+      const mine = found.get(at);
+      if (mine.length < needed)
+        continue;
+      const length = chunks[at].terms.length;
+      let score = 0;
+      for (const [k, f] of mine) {
+        const n = lists[k].length;
+        const idf = Math.log(1 + (chunks.length - n + 0.5) / (n + 0.5));
+        score += idf * (f * (BM25_K1 + 1)) / (f + BM25_K1 * (1 - BM25_B + BM25_B * length / average));
+      }
+      if (score > 0)
+        scored.push({ index: at, score, matched: mine.length });
+    }
+    return scored.sort((a, b) => b.score - a.score);
+  });
+}
+function rankAll(queries, chunks, minTerms = 2) {
+  return chunks.length >= INDEXED_FROM && indexedAll(queries, chunks, minTerms) || scanAll(queries, chunks, minTerms);
+}
+function scanAll(queries, chunks, minTerms) {
+  const ids = new Map;
+  for (const query of queries)
+    for (const term of query)
+      if (!ids.has(term))
+        ids.set(term, ids.size);
+  const df = new Int32Array(ids.size);
+  const counts = new Int32Array(ids.size);
+  const touched = [];
+  const hits = [];
+  let total = 0;
+  chunks.forEach((chunk, index) => {
+    total += chunk.terms.length;
+    touched.length = 0;
+    for (const term of chunk.terms) {
+      const id = ids.get(term);
+      if (id === undefined)
+        continue;
+      if (counts[id] === 0)
+        touched.push(id);
+      counts[id] += 1;
+    }
+    if (touched.length === 0)
+      return;
+    const found = touched.map((id) => {
+      const f = counts[id];
+      counts[id] = 0;
+      df[id] += 1;
+      return [id, f];
+    });
+    hits.push({ index, found });
+  });
+  const average = total / Math.max(1, chunks.length);
+  return queries.map((query) => {
+    const asked = [...new Set(query)].map((term) => ids.get(term) ?? -1);
+    const position = new Int32Array(ids.size).fill(-1);
+    asked.forEach((id, i) => {
+      position[id] = i;
+    });
+    const needed = Math.max(1, Math.min(minTerms, asked.filter((id) => df[id] > 0).length));
+    const scored = [];
+    for (const { index, found } of hits) {
+      const mine = found.filter(([id]) => position[id] >= 0);
+      if (mine.length < needed)
+        continue;
+      if (mine.length > 1)
+        mine.sort((a, b) => position[a[0]] - position[b[0]]);
+      const length = chunks[index].terms.length;
+      let score = 0;
+      for (const [id, f] of mine) {
+        const n = df[id];
+        const idf = Math.log(1 + (chunks.length - n + 0.5) / (n + 0.5));
+        score += idf * (f * (BM25_K1 + 1)) / (f + BM25_K1 * (1 - BM25_B + BM25_B * length / average));
+      }
+      if (score > 0)
+        scored.push({ index, score, matched: mine.length });
+    }
+    return scored.sort((a, b) => b.score - a.score);
+  });
+}
+function excerpt(chunk, query, salient) {
+  const limit = salient ? SHOWN_LINES + 2 : SHOWN_LINES;
+  const shown = new Set;
+  chunk.lines.forEach((line, i) => {
+    if (!terms(line).some((t) => query.has(t)))
+      return;
+    for (const j of [i - 1, i, i + 1])
+      if (j >= 0 && j < chunk.lines.length)
+        shown.add(j);
+  });
+  if (salient) {
+    for (let i = 0;i < chunk.lines.length && shown.size < limit; i += 1)
+      if (isSalient(chunk.lines[i]))
+        shown.add(i);
+  }
+  const ordered = [...shown].sort((a, b) => a - b).slice(0, limit);
+  return (ordered.length > 0 ? ordered : [0]).map((i) => clip(chunk.lines[i], 240)).filter(Boolean);
+}
+function queriesOf(prompt) {
+  const lines = prompt.split(`
+`).map((l) => l.trim()).filter((l) => terms(l).length >= 2);
+  return lines.length > 1 ? lines : [prompt];
+}
+function merged(hits) {
+  const picked = new Map;
+  for (const { query, indices } of hits) {
+    for (const index of indices) {
+      const matched = picked.get(index) ?? new Set;
+      for (const term of query)
+        matched.add(term);
+      picked.set(index, matched);
+    }
+  }
+  return [...picked.entries()].map(([index, query]) => ({ index, query }));
+}
+function rankedLines(prompt, chunks, options, width) {
+  const lines = queriesOf(prompt);
+  const queries = lines.map(terms);
+  const results = rankAll(queries, chunks, options.minTerms);
+  return lines.map((line, i) => ({ line, query: queries[i], indices: results[i].slice(0, width).map((hit) => hit.index) }));
+}
+function pickRecall(prompt, chunks, options) {
+  return merged(rankedLines(prompt, chunks, options, options.perQuery ?? 12));
+}
+var identityReranker = async (_query, _chunks, candidates) => candidates;
+async function pickRecallWith(prompt, chunks, rerank, options = {}) {
+  const hits = [];
+  for (const { line, query, indices } of rankedLines(prompt, chunks, options, options.candidates ?? 30)) {
+    const reordered = await rerank(line, chunks, indices);
+    hits.push({ query, indices: reordered.slice(0, options.perQuery ?? 12) });
+  }
+  return merged(hits);
+}
+function renderRecall(prompt, chunks, picks, options = {}) {
+  if (picks.length === 0)
+    return null;
+  const budget = queriesOf(prompt).length > 1 ? options.maxCharsMulti ?? 30000 : options.maxChars ?? 18000;
+  const entries = [];
+  let used = 0;
+  for (const { index, query } of [...picks].sort((a, b) => chunks[a.index].turn - chunks[b.index].turn || a.index - b.index)) {
+    const chunk = chunks[index];
+    const where = chunk.from ? `${chunk.from}, turn ${chunk.turn}` : `turn ${chunk.turn}`;
+    const lines = excerpt(chunk, query, options.salientExcerpt ?? true).map((l) => `    ${l}`);
+    const entry = `[${where}] ${chunk.call}:
+${lines.join(`
+`)}`;
+    if (used + entry.length > budget)
+      continue;
+    entries.push(entry);
+    used += entry.length;
+  }
+  if (entries.length === 0)
+    return null;
+  return recalledContext(entries, picks.some((p) => Boolean(chunks[p.index].from)));
+}
+function recallFor(prompt, chunks, options = {}) {
+  if (chunks.length === 0)
+    return null;
+  return renderRecall(prompt, chunks, pickRecall(prompt, chunks, options), options);
+}
+async function recallForWith(prompt, chunks, rerank, options = {}) {
+  if (chunks.length === 0)
+    return null;
+  return renderRecall(prompt, chunks, await pickRecallWith(prompt, chunks, rerank, options), options);
+}
+function livePrompt(messages) {
+  const { preamble, turns } = splitTurns(messages);
+  const live = turns.at(-1);
+  if (!live || !isPrompt(live[0]))
+    return null;
+  const index = preamble.length + turns.slice(0, -1).reduce((s, t) => s + t.length, 0);
+  const text = textOf(live[0]).replace(/<(system-reminder|system-message|recalled-context|tool-evidence|handoff)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, "").trim();
+  return { index, text };
+}
+function withRecall(messages, fingerprint, recalls) {
+  if (Object.keys(recalls).length === 0)
+    return messages;
+  return messages.map((message) => {
+    if (!isPrompt(message))
+      return message;
+    const text = recalls[fingerprint(message)];
+    return text ? { ...message, content: [...blocks(message), { type: "text", text }] } : message;
+  });
+}
+
+// src/core/estimate.ts
+var DEFAULT_RATIO = 1 / 3.6;
+var MEDIA_CHARS = 5800;
+function sizeOf(body) {
+  let media = 0;
+  const json = JSON.stringify({ system: body.system, tools: body.tools, messages: body.messages }, (key, value) => {
+    if (key !== "data" || typeof value !== "string" || value.length <= 2000)
+      return value;
+    media += 1;
+    return "";
+  });
+  return json.length + media * MEDIA_CHARS;
+}
+function estimator(body, ratio) {
+  return {
+    of: (messages) => Math.round(sizeOf({ ...body, messages }) * ratio),
+    fixed: Math.round(sizeOf({ ...body, messages: [] }) * ratio)
+  };
+}
+function targetSize(size, window) {
+  return size.fixed + 0.3 * Math.max(0, window - size.fixed);
+}
+
+// src/core/state.ts
+function memoryStore(initial = {}) {
+  const threads = new Map(Object.entries(initial).map(([key, state]) => [key, structuredClone(state)]));
+  return {
+    read: (key) => structuredClone(threads.get(key) ?? {}),
+    save: (key, state) => {
+      threads.set(key, structuredClone(state));
+    }
+  };
+}
+function resetCut(state) {
+  delete state.cut;
+  delete state.keep;
+  delete state.cleared;
+  delete state.stuck;
+  delete state.host;
+}
+
+// src/core/compaction.ts
+var FOLDED_TURNS = 4096;
+var folded = new Map;
+function reduceRemembered(turn, options) {
+  const key = `${options.evidence ? 1 : 0}:${quickHash(JSON.stringify(turn))}`;
+  const known = folded.get(key);
+  if (known) {
+    folded.delete(key);
+    folded.set(key, known);
+    return known;
+  }
+  const reduced = reduceTurn(turn, options);
+  folded.set(key, reduced);
+  if (folded.size > FOLDED_TURNS)
+    folded.delete(folded.keys().next().value);
+  return reduced;
+}
+var PROTECTED_OUTPUTS = 5;
+var STUCK_STEP = 0.1;
+function settledCut(turns, index) {
+  let cut = index;
+  while (cut > 1 && JSON.stringify(turns[cut][0].content).includes("[Request interrupted"))
+    cut -= 1;
+  return cut;
+}
+function resolveCut(turns, state, config, rollingKeep) {
+  let cutIndex = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1;
+  let stateChanged = false;
+  if (state.cut && cutIndex === -1) {
+    resetCut(state);
+    stateChanged = true;
+  }
+  if (cutIndex <= 0 && config.eval?.forceCut && turns.length >= 3) {
+    cutIndex = settledCut(turns, Math.max(1, turns.length - 1 - (rollingKeep ?? 1)));
+    state.cut = turnFingerprint(turns[cutIndex]);
+    stateChanged = true;
+  }
+  return { cutIndex, stateChanged };
+}
+function shrinkOnce(state, cutIndex, configuredKeep, liveResults) {
+  const keep = Math.min(state.keep ?? configuredKeep, cutIndex - 1);
+  if (cutIndex > 0 && keep > 0) {
+    state.keep = keep - 1;
+    return `keep=${state.keep}`;
+  }
+  const remaining = liveResults() - (state.cleared ?? 0) - PROTECTED_OUTPUTS;
+  if (remaining <= 0)
+    return "stuck";
+  state.cleared = (state.cleared ?? 0) + Math.ceil(remaining / 2);
+  return `cleared=${state.cleared}`;
+}
+function dueRoll(turns, cutIndex, rolling, size) {
+  const next = settledCut(turns, turns.length - 1 - rolling.keep);
+  const backlog = size.of(turns.slice(Math.max(cutIndex, 0), Math.max(next, 0)).flat()) - size.fixed;
+  return next >= 1 && next > cutIndex && backlog > rolling.budget ? next : null;
+}
+function shrinkToTarget(over, step, actions, rebuild) {
+  while (over()) {
+    const action = step();
+    actions.push(action);
+    if (action === "stuck")
+      return true;
+    rebuild();
+  }
+  return false;
+}
+var holdsStuck = (state, estimate, window) => window !== null && state.stuck !== undefined && estimate <= state.stuck + STUCK_STEP * window;
+var headLength = (preamble, first, state) => preamble.length + 1 + (countPinned([first], new Set(state.pins)) > 0 ? first.length : 1);
+function stuckSizes(messages, headEnd, liveFrom, size) {
+  const of = (list) => size.of(list) - size.fixed;
+  return { fixed: size.fixed, head: of(messages.slice(0, headEnd)), folded: of(messages.slice(headEnd, liveFrom)), live: of(messages.slice(liveFrom)) };
+}
+function cutNote(state, turns, cutIndex, configuredKeep, actions) {
+  const pins = new Set(state.pins);
+  const keptFrom = cutIndex > 0 ? Math.max(1, cutIndex - (state.keep ?? configuredKeep)) : 0;
+  const omitted = cutIndex > 0 ? keptFrom - 1 - countPinned(turns.slice(1, keptFrom), pins) : 0;
+  return {
+    action: cutIndex > 0 ? "compact" : "full",
+    compacted: actions.includes("cut") || actions.includes("roll"),
+    actions: actions.length > 0 ? actions : undefined,
+    cutTurn: cutIndex > 0 ? cutIndex : null,
+    omitted,
+    folded: cutIndex > 0 ? cutIndex - keptFrom - countPinned(turns.slice(keptFrom, cutIndex), pins) + (foldsOpening(turns[0], keptFrom) && countPinned([turns[0]], pins) === 0 ? 1 : 0) : 0,
+    pinned: cutIndex > 0 ? countPinned(turns.slice(0, cutIndex), pins) : 0,
+    host: state.host,
+    keep: state.keep,
+    cleared: state.cleared
+  };
+}
+function compact({ body, config, state, window, guide, transcriptDir, mayCompact, omittedBefore = 0, decorate = (m) => m, reduce }) {
+  const { preamble, turns } = splitTurns(body.messages);
+  const rolling = config.eval?.rolling ?? (config.mode === "default" ? { keep: config.keep, budget: config.budget } : undefined);
+  const resolved = resolveCut(turns, state, config, rolling?.keep);
+  let cutIndex = resolved.cutIndex;
+  let stateChanged = resolved.stateChanged;
+  const configuredKeep = config.keepTurns === "all" ? Number.MAX_SAFE_INTEGER : config.keepTurns;
+  const ratio = state.ratio ?? DEFAULT_RATIO;
+  const options = { guide, omittedBefore, evidence: config.eval?.evidence ?? true, reduce: reduce ?? reduceRemembered, capChars: config.turnCap === "off" ? undefined : config.turnCap / ratio, pinned: new Set(state.pins) };
+  const liveStart = (list) => list.length - splitTurns(list).turns.slice(-(turns.length - Math.max(cutIndex, 0))).flat().length;
+  const compacted = () => capTurns(cutIndex > 0 ? compactMessages(body.messages, cutIndex, { ...options, keepTurns: state.keep ?? configuredKeep }) : body.messages, { ...options, keepTurns: 0 });
+  const build = () => {
+    const messages = compacted();
+    return state.cleared ? clearToolResults(messages, liveStart(messages), state.cleared, clearedOutput(transcriptDir ?? null)) : messages;
+  };
+  const liveResults = () => {
+    const uncleared = compacted();
+    return countToolResults(uncleared, liveStart(uncleared));
+  };
+  const size = estimator(body, ratio);
+  const limit = window ? config.compactAt * window : Number.POSITIVE_INFINITY;
+  const target = window ? targetSize(size, window) : Number.POSITIVE_INFINITY;
+  let messages = build();
+  let estimate = size.of(decorate(messages));
+  const actions = [];
+  const rebuild = () => {
+    messages = build();
+    estimate = size.of(decorate(messages));
+  };
+  const moveCut = (index, action) => {
+    cutIndex = index;
+    resetCut(state);
+    state.cut = turnFingerprint(turns[index]);
+    actions.push(action);
+    rebuild();
+  };
+  const roll = mayCompact && rolling ? dueRoll(turns, cutIndex, rolling, size) : null;
+  if (roll !== null) {
+    moveCut(roll, "roll");
+    stateChanged = true;
+  }
+  if (mayCompact && estimate > limit) {
+    const current = turns.length - 1;
+    if (current > 0 && current > cutIndex)
+      moveCut(current, "cut");
+    if (!holdsStuck(state, estimate, window)) {
+      const stuck = shrinkToTarget(() => estimate > target, () => shrinkOnce(state, cutIndex, configuredKeep, liveResults), actions, rebuild);
+      if (stuck)
+        state.stuck = estimate;
+      else
+        delete state.stuck;
+    }
+    stateChanged = true;
+  }
+  return {
+    messages,
+    stateChanged,
+    note: {
+      ...cutNote(state, turns, cutIndex, configuredKeep, actions),
+      stuck: state.stuck === undefined ? undefined : stuckSizes(messages, headLength(preamble, turns[0], state), liveStart(messages), size),
+      turns: turns.length,
+      messagesIn: body.messages.length,
+      messagesOut: messages.length,
+      estimate,
+      window
+    }
+  };
+}
+
+// src/core/fingerprint.ts
+var isInjected = (text) => /^<(?:recalled-context|handoff)[\s>]/.test(String(text ?? ""));
+function messageFingerprint(message) {
+  const own = blocks(message).filter((b) => !(b.type === "text" && isInjected(b.text))).map(withoutCacheControl);
+  return shortHash(JSON.stringify(own), 24);
+}
+
+// src/context/fold/index.ts
+var FOLD_CAP_CHARS = 400000;
+var spoken = (message) => textOf(message).replace(/<(system-reminder|system-message|recalled-context|handoff)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, "").trim();
+var isEvidence = (text) => text.startsWith("<tool-evidence>");
+function foldedTurns(messages) {
+  return splitTurns(messages).turns.filter((turn) => isPrompt(turn[0])).map((turn) => {
+    const reduced = reduceTurn(turn, { evidence: true });
+    const users = reduced.filter((m) => m.role === "user").map(spoken);
+    return {
+      user: users.filter((t) => t && !isEvidence(t)).join(`
+
+`),
+      evidence: users.filter(isEvidence).join(`
+`),
+      reply: reduced.filter((m) => m.role === "assistant").map(spoken).join(`
+`)
+    };
+  });
+}
+function renderTurn(turn, index, full) {
+  const parts = [`### Turn ${index + 1}`, `**You:** ${turn.user}`];
+  if (full && turn.evidence)
+    parts.push(turn.evidence);
+  if (full && turn.reply)
+    parts.push(`**Agent:** ${turn.reply}`);
+  return parts.join(`
+
+`);
+}
+function foldedView(messages, cap = Number.POSITIVE_INFINITY) {
+  const turns = foldedTurns(messages);
+  const full = new Set;
+  let used = 0;
+  for (let i = turns.length - 1;i >= 0; i -= 1) {
+    const size = renderTurn(turns[i], i, true).length;
+    if (used + size > cap)
+      break;
+    full.add(i);
+    used += size;
+  }
+  return turns.map((turn, i) => renderTurn(turn, i, full.has(i))).join(`
+
+`);
+}
+function sourceChunks(messages, from, users = false) {
+  const chunks = recallChunks([...messages, { role: "user", content: "" }], new Map).map((chunk) => ({ ...chunk, from }));
+  if (!users)
+    return chunks;
+  const said = splitTurns(messages).turns.filter((turn) => isPrompt(turn[0])).map((turn, i) => ({ turn: i + 1, text: spoken(turn[0]) })).filter((t) => t.text);
+  return [...said.map((t) => ({ turn: t.turn, from, call: "you", lines: t.text.split(`
+`), terms: terms(t.text) })), ...chunks];
+}
+
+// src/core/handoff.ts
+var chunksOf2 = new WeakMap;
+var continueToken = (id) => `{ee:continue:${id}}`;
+function continueIdOf(message) {
+  if (!isPrompt(message))
+    return null;
+  const own = blocks(message).filter((b) => b.type === "text" && !isInjected(b.text)).map((b) => String(b.text ?? "")).join(`
+`);
+  return own.match(/\{ee:continue:([A-Za-z0-9-]{8,})\}/)?.[1] ?? null;
+}
+function activeHandoffs(handoffs = {}) {
+  return Object.fromEntries(Object.entries(handoffs).filter((entry) => Boolean(entry[1])));
+}
+function resolveHandoff(id, sources, state) {
+  const found = sources.findHandoff?.(id) ?? null;
+  if (!found || !sources.readHandoff)
+    return null;
+  const already = Object.values(state.handoffs ?? {}).some((h) => h?.source === found.source);
+  return already ? null : { label: found.label, source: found.source, text: foldedView(sources.readHandoff(found.source), FOLD_CAP_CHARS) };
+}
+function attachHandoffs(messages, sources, state) {
+  let changed = false;
+  for (const message of messages) {
+    const id = continueIdOf(message);
+    if (!id)
+      continue;
+    const key = messageFingerprint(message);
+    if (state.handoffs && key in state.handoffs)
+      continue;
+    const handoff = resolveHandoff(id, sources, state);
+    state.handoffs ??= {};
+    state.handoffs[key] = handoff;
+    changed = true;
+  }
+  return changed;
+}
+function withHandoffs(messages, handoffs) {
+  if (Object.keys(handoffs).length === 0)
+    return messages;
+  return messages.map((message) => {
+    if (!isPrompt(message))
+      return message;
+    const handoff = handoffs[messageFingerprint(message)];
+    return handoff ? { ...message, content: [{ type: "text", text: handoffBlock(handoff.label, handoff.text) }, ...blocks(message)] } : message;
+  });
+}
+function handoffChunks(handoffs, sources) {
+  const read = sources.readHandoff;
+  if (!read)
+    return [];
+  const labels = new Map;
+  for (const handoff of Object.values(handoffs))
+    if (!labels.has(handoff.source))
+      labels.set(handoff.source, handoff.label);
+  return [...labels].flatMap(([source, label]) => {
+    const messages = read(source);
+    const known = chunksOf2.get(messages);
+    if (known?.label === label)
+      return known.chunks;
+    const chunks = sourceChunks(messages, label, true);
+    chunksOf2.set(messages, { label, chunks });
+    return chunks;
+  });
+}
+
+// src/core/recall.ts
+var closingTurn = { role: "user", content: "" };
+var wantsRecall = (input) => (input.config.eval?.recall ?? true) && input.config.mode !== "off";
+var activeRecalls = (recalls = {}) => Object.fromEntries(Object.entries(recalls).filter(([, text]) => text));
+var touched = (input, result) => result.threadKey !== null && !(result.body === input.body && result.note.action === "pass");
+function droppedChunks(input, result, threadKey) {
+  const sources = input.sources ?? {};
+  const kept = new Map;
+  for (const message of result.body.messages)
+    for (const b of blocks(message))
+      if (b.type === "tool_result")
+        kept.set(b.tool_use_id, resultText(b));
+  const own = recallChunks(input.body.messages, kept);
+  const session = own.length > 0 || !sources.readHistory ? own : recallChunks([...sources.readHistory(), closingTurn], kept);
+  const withSubagents = sources.listSubagentChunks ? [...session, ...sources.listSubagentChunks()] : session;
+  return [...handoffChunks(activeHandoffs(input.store.read(threadKey).handoffs), sources), ...withSubagents];
+}
+function recallTarget(original) {
+  const live = livePrompt(original.messages);
+  return live ? { key: messageFingerprint(original.messages[live.index]), text: live.text } : null;
+}
+function applyRecall(input, result) {
+  if (!touched(input, result) || !result.threadKey)
+    return result;
+  const state = input.store.read(result.threadKey);
+  state.recalls ??= {};
+  const target = recallTarget(input.body);
+  let note = result.note;
+  if (target && !(target.key in state.recalls)) {
+    state.recalls[target.key] = recallFor(target.text, droppedChunks(input, result, result.threadKey), input.config.eval?.recallOptions) ?? "";
+    input.store.save(result.threadKey, state);
+    note = { ...note, recalled: state.recalls[target.key].length };
+  }
+  const messages = withRecall(result.body.messages, messageFingerprint, activeRecalls(state.recalls));
+  return messages === result.body.messages ? { ...result, note } : { ...result, body: { ...result.body, messages }, note };
+}
+async function prefetchFor(input, result, rerank) {
+  if (!touched(input, result) || !result.threadKey)
+    return null;
+  const target = recallTarget(input.body);
+  if (!target)
+    return null;
+  const state = input.store.read(result.threadKey);
+  state.recalls ??= {};
+  if (target.key in state.recalls)
+    return null;
+  const options = { candidates: input.config.eval?.rerank?.candidates, ...input.config.eval?.recallOptions };
+  state.recalls[target.key] = await recallForWith(target.text, droppedChunks(input, result, result.threadKey), rerank, options) ?? "";
+  input.store.save(result.threadKey, state);
+  return state.recalls[target.key].length;
+}
+
+// src/core/rewrite.ts
+var pass = (body) => ({ body, threadKey: null, note: { action: "pass" } });
+var isAgentThread = (body) => Array.isArray(body.tools) && body.tools.length > 0;
+var withSystemPrompt = (system, extra) => appendSystem(extra ? appendSystem(system, extra) : system, SYSTEM_PROMPT);
+var ratioOf = (input, threadKey) => input.store.read(threadKey).ratio ?? DEFAULT_RATIO;
+function threadKeyOf(threadId, messages) {
+  const first = splitTurns(messages).turns[0];
+  return first ? `${threadId}-${turnFingerprint(first)}` : null;
+}
+function evalStrategy(input, turns, threadKey, guide) {
+  const { body, config } = input;
+  const strategy = config.eval?.strategy;
+  if (strategy !== "guide" && strategy !== "trim" && strategy !== "tail")
+    return null;
+  if (!isAgentThread(body))
+    return pass(body);
+  const counts = { turns: turns.length, messagesIn: body.messages.length };
+  if (strategy === "guide") {
+    return { body: { ...body, system: withSystemPrompt(body.system, guide ? searchOnlyInstructions(guide) : null) }, threadKey, note: { action: "guide", ...counts } };
+  }
+  if (strategy === "trim") {
+    const messages = trimMessages(body.messages, { evidence: config.eval?.evidence ?? true });
+    return { body: { ...body, system: withSystemPrompt(body.system, trimInstructions(guide)), messages }, threadKey, note: { action: "trim", ...counts, messagesOut: messages.length } };
+  }
+  const based = { ...body, system: withSystemPrompt(body.system) };
+  const size = estimator(based, ratioOf(input, threadKey));
+  let from = 1;
+  if (input.window) {
+    const target = targetSize(size, input.window);
+    from = turns.length - 1;
+    while (from > 1 && size.of(tailMessages(body.messages, from - 1, guide)) <= target)
+      from -= 1;
+  }
+  const messages = tailMessages(body.messages, from, guide);
+  return { body: { ...based, messages }, threadKey, note: { action: "tail", keptTurns: turns.length - from, ...counts, messagesOut: messages.length, estimate: size.of(messages) } };
+}
+function strategize(input) {
+  const { body, threadId, config, store } = input;
+  const sources = input.sources ?? {};
+  if (!threadId || !Array.isArray(body.messages) || body.messages.length === 0)
+    return pass(body);
+  const threadKey = threadKeyOf(threadId, body.messages);
+  if (!threadKey)
+    return pass(body);
+  const off = config.mode === "off";
+  const state = store.read(threadKey);
+  if (off && !state.host)
+    return pass(body);
+  const { turns } = splitTurns(body.messages);
+  const guide = sources.guide ?? null;
+  if (!off && attachHandoffs(body.messages, sources, state))
+    store.save(threadKey, state);
+  const forced = off ? null : evalStrategy(input, turns, threadKey, guide);
+  if (forced)
+    return forced;
+  const based = isAgentThread(body) ? { ...body, system: withSystemPrompt(body.system) } : body;
+  if (body.messages.length < 2)
+    return { body: based, threadKey, note: { action: "full", turns: turns.length } };
+  const handoffs = activeHandoffs(state.handoffs);
+  const recalls = wantsRecall(input) ? activeRecalls(state.recalls) : {};
+  const result = compact({
+    body: based,
+    config,
+    state,
+    window: input.window,
+    guide,
+    transcriptDir: sources.transcriptDir ?? null,
+    mayCompact: input.mayCompact && !off,
+    omittedBefore: input.omittedBefore,
+    decorate: (messages) => withRecall(withHandoffs(messages, handoffs), messageFingerprint, recalls)
+  });
+  if (result.stateChanged)
+    store.save(threadKey, state);
+  return { body: result.messages === body.messages ? based : { ...based, messages: result.messages }, threadKey, note: result.note };
+}
+function withAttachedHandoffs(input, result) {
+  if (!result.threadKey)
+    return result;
+  const handoffs = activeHandoffs(input.store.read(result.threadKey).handoffs);
+  const messages = withHandoffs(result.body.messages, handoffs);
+  if (messages === result.body.messages)
+    return result;
+  const attached = Object.values(handoffs);
+  const note = { ...result.note, handoff: attached.reduce((sum, h) => sum + h.text.length, 0), handoffFrom: attached.map((h) => h.label).join(", ") };
+  return { ...result, body: { ...result.body, messages }, note };
+}
+function once(input) {
+  const result = withAttachedHandoffs(input, strategize(input));
+  return wantsRecall(input) ? applyRecall(input, result) : result;
+}
+function sentEstimate(input, result) {
+  return Math.round(sizeOf(result.body) * (result.threadKey ? ratioOf(input, result.threadKey) : DEFAULT_RATIO));
+}
+function overLimit(input, result) {
+  if (!input.window || !result.threadKey || input.mayCompact === false || result.note.action === "pass")
+    return false;
+  return sentEstimate(input, result) > input.config.compactAt * input.window;
+}
+function carried(from, to) {
+  const actions = [...from.note.actions ?? [], ...to.note.actions ?? []];
+  if (!from.note.compacted && actions.length === 0)
+    return to;
+  return { ...to, note: { ...to.note, compacted: Boolean(to.note.compacted || from.note.compacted), actions } };
+}
+function rewrite(input, before) {
+  const result = before ? carried(before, once(input)) : once(input);
+  if (!overLimit(input, result))
+    return result;
+  const recut = carried(result, once(input));
+  if (!overLimit(input, recut))
+    return { ...recut, note: { ...recut.note, fit: "recut" } };
+  const bare = carried(recut, once({ ...input, config: { ...input.config, eval: { ...input.config.eval, recall: false } } }));
+  return { ...bare, note: { ...bare.note, fit: overLimit(input, bare) ? "over" : "bare", fitEstimate: sentEstimate(input, bare) } };
+}
+async function rewriteAsync(input, rerank = identityReranker) {
+  if (!wantsRecall(input) || rerank === identityReranker)
+    return rewrite(input);
+  const first = strategize(input);
+  const recalled = await prefetchFor(input, first, rerank);
+  const final = rewrite(input, first);
+  return recalled === null ? final : { ...final, note: { ...final.note, recalled } };
+}
+
+// src/core/fold.ts
+function located({ store, threadId, messages }) {
+  const threadKey = threadKeyOf(threadId, messages);
+  if (!threadKey)
+    throw new RangeError("eunoe can only fold a thread that has at least one user turn");
+  return { threadKey, turns: splitTurns(messages).turns, state: store.read(threadKey) };
+}
+function checkedTurn(turn, turns, from) {
+  if (turns.length <= from)
+    throw new RangeError(`this thread has ${turns.length} turn${turns.length === 1 ? "" : "s"}, so there is no turn ${turn} to fold at`);
+  if (!Number.isInteger(turn) || turn < from || turn >= turns.length)
+    throw new RangeError(`turn ${turn} is outside turns ${from}..${turns.length - 1}`);
+  return turn;
+}
+function folded2(threadKey, turns, state) {
+  const cutTurn = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1;
+  const pins = new Set(state.pins);
+  return { threadKey, cutTurn: cutTurn > 0 ? cutTurn : null, pinned: turns.flatMap((turn, i) => pins.has(turnFingerprint(turn)) ? [i] : []) };
+}
+function withPins(state, turns, indices, pinned) {
+  const pins = new Set(state.pins);
+  for (const index of indices) {
+    const fingerprint = turnFingerprint(turns[checkedTurn(index, turns, 0)]);
+    if (pinned)
+      pins.add(fingerprint);
+    else
+      pins.delete(fingerprint);
+  }
+  if (pins.size > 0)
+    state.pins = [...pins].sort();
+  else
+    delete state.pins;
+}
+function foldThread(target, { at = "latest", pin = [] } = {}) {
+  const { threadKey, turns, state } = located(target);
+  const cut = checkedTurn(at === "latest" ? turns.length - 1 : at, turns, 1);
+  withPins(state, turns, pin, true);
+  resetCut(state);
+  state.cut = turnFingerprint(turns[cut]);
+  state.keep = cut - 1;
+  state.host = true;
+  target.store.save(threadKey, state);
+  return folded2(threadKey, turns, state);
+}
+function pinTurns(target, indices, pinned = true) {
+  const { threadKey, turns, state } = located(target);
+  withPins(state, turns, indices, pinned);
+  target.store.save(threadKey, state);
+  return folded2(threadKey, turns, state);
+}
+// src/core/usage.ts
+function usageIn(line) {
+  if (!line.startsWith("data:") || !line.includes("message_start"))
+    return null;
+  try {
+    return JSON.parse(line.slice(5)).message?.usage ?? null;
+  } catch {
+    return null;
+  }
+}
+function trailingUsage(buffer) {
+  if (!buffer.trim().startsWith("{"))
+    return null;
+  try {
+    const json = JSON.parse(buffer);
+    if (json.usage)
+      return json.usage;
+    return typeof json.input_tokens === "number" ? { input_tokens: json.input_tokens } : null;
+  } catch {
+    return null;
+  }
+}
+function scanEvents(buffer) {
+  let rest = buffer;
+  for (let newline = rest.indexOf(`
+`);newline !== -1; newline = rest.indexOf(`
+`)) {
+    const usage = usageIn(rest.slice(0, newline).trim());
+    rest = rest.slice(newline + 1);
+    if (usage)
+      return { usage, rest };
+  }
+  return { usage: null, rest };
+}
+async function readUsage(stream) {
+  const reader = stream.pipeThrough(new TextDecoderStream).getReader();
+  let buffer = "";
+  let usage = null;
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done)
+      return usage ?? trailingUsage(buffer);
+    if (usage)
+      continue;
+    const scanned = scanEvents(buffer + value);
+    usage = scanned.usage;
+    buffer = scanned.rest.length > 4000000 ? "" : scanned.rest;
+  }
+}
+function watchUsage(response, onUsage) {
+  if (!response.body)
+    return response;
+  const [toClient, toUs] = response.body.tee();
+  readUsage(toUs).then((usage) => {
+    if (usage)
+      onUsage(usage);
+  }).catch(() => {
+    return;
+  });
+  return new Response(toClient, { status: response.status, statusText: response.statusText, headers: response.headers });
+}
+function inputTokens(usage) {
+  return (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+}
+var OVERFLOW_MARGIN = 1.1;
+var charsOf = (sent) => typeof sent === "number" ? sent : sizeOf(sent);
+function overflowTokens(errorText) {
+  const tokens = Number(errorText.match(/prompt is too long[^0-9]*(\d+)\s*tokens?\s*>\s*(\d+)/i)?.[1]);
+  return Number.isFinite(tokens) && tokens > 0 ? tokens : null;
+}
+function recordUsage(store, threadKey, sent, usage) {
+  const input = inputTokens(usage);
+  const chars = charsOf(sent);
+  if (input <= 0 || chars <= 0)
+    return false;
+  const state = store.read(threadKey);
+  state.ratio = input / chars;
+  store.save(threadKey, state);
+  return true;
+}
+function recordOverflow(store, threadKey, sent, errorText) {
+  const tokens = overflowTokens(errorText);
+  const chars = charsOf(sent);
+  if (!tokens || chars <= 0)
+    return null;
+  const state = store.read(threadKey);
+  state.ratio = Math.max(state.ratio ?? 0, tokens / chars) * OVERFLOW_MARGIN;
+  store.save(threadKey, state);
+  return tokens;
+}
+
+// src/core/window.ts
+var LOOKUP_TIMEOUT_MS = 5000;
+function lookupHeaders(requestHeaders) {
+  const headers = new Headers;
+  for (const name of ["authorization", "x-api-key", "anthropic-version", "anthropic-beta"]) {
+    const value = requestHeaders.get(name);
+    if (value)
+      headers.set(name, value);
+  }
+  if (!headers.has("anthropic-version"))
+    headers.set("anthropic-version", "2023-06-01");
+  return headers;
+}
+function createWindowLookup({ known = new Map, onLearn } = {}) {
+  const lookups = new Map;
+  const lookup = async (id, requestHeaders, upstream) => {
+    const response = await fetch(`${upstream}/v1/models/${encodeURIComponent(id)}`, { headers: lookupHeaders(requestHeaders), signal: AbortSignal.timeout(LOOKUP_TIMEOUT_MS) });
+    if (!response.ok)
+      return null;
+    const info = await response.json();
+    if (typeof info.max_input_tokens !== "number" || info.max_input_tokens <= 0)
+      return null;
+    known.set(id, info.max_input_tokens);
+    onLearn?.(known);
+    return info.max_input_tokens;
+  };
+  return (model, requestHeaders, upstream = "https://api.anthropic.com") => {
+    const id = String(model ?? "").replace(/\[[^\]]*\]$/, "");
+    if (!id)
+      return Promise.resolve(null);
+    const window = known.get(id);
+    if (window)
+      return Promise.resolve(window);
+    const inFlight = lookups.get(id);
+    if (inFlight)
+      return inFlight;
+    const pending = lookup(id, requestHeaders, upstream).catch(() => null).finally(() => lookups.delete(id));
+    lookups.set(id, pending);
+    return pending;
+  };
+}
+
+// src/core/forward.ts
+var COUNT_TOKENS_ATTEMPTS = 3;
+var DROPPED_REQUEST_HEADERS = ["host", "content-length", "accept-encoding"];
+var clipped = (error) => error.slice(0, 500);
+function claudeCodeSessionId(headers, body) {
+  const header = headers.get("x-claude-code-session-id");
+  if (header)
+    return header;
+  try {
+    return JSON.parse(body.metadata?.user_id ?? "{}").session_id ?? null;
+  } catch {
+    return null;
+  }
+}
+var defaultThreadId = (request, body) => request.headers.get("x-thread-id") ?? claudeCodeSessionId(request.headers, body);
+function forwardableHeaders(headers) {
+  const out = new Headers(headers);
+  out.delete("content-encoding");
+  out.delete("content-length");
+  return out;
+}
+function defaultPrepare(options, upstream) {
+  const threadIdOf = options.threadIdOf ?? defaultThreadId;
+  const given = options.window;
+  const lookup = typeof given === "function" ? given : createWindowLookup();
+  const windowFor = typeof given === "number" || given === null ? () => Promise.resolve(given) : (model, headers) => lookup(model, headers, upstream);
+  return async (request, body, mayCompact) => {
+    const threadId = threadIdOf(request, body);
+    const window = await windowFor(body.model, request.headers);
+    const sources = threadId ? options.sources?.(threadId, request, body) : undefined;
+    return rewriteAsync({ body, threadId, config: options.config ?? CORE_DEFAULTS, store: options.store, sources, window, mayCompact }, options.reranker);
+  };
+}
+var passthrough = (bodyText) => ({ note: { action: "pass" }, threadKey: null, bodyText, sentSize: 0, givenSize: 0, fixedSize: 0 });
+async function outgoing(prepare, request, givenText, mayCompact) {
+  try {
+    const given = JSON.parse(givenText);
+    const result = await prepare(request, given, mayCompact);
+    const sentSize = sizeOf(result.body);
+    return {
+      note: result.note,
+      threadKey: result.threadKey,
+      bodyText: result.body !== given ? JSON.stringify(result.body, wellFormed) : givenText,
+      sentSize,
+      givenSize: result.body === given ? sentSize : sizeOf(given),
+      fixedSize: sizeOf({ ...result.body, messages: [] })
+    };
+  } catch (error) {
+    return { ...passthrough(givenText), note: { action: "error-passthrough", error: String(error) } };
+  }
+}
+function createSender(request, target, headers, timeout, stall) {
+  return async (body) => {
+    if (timeout === null)
+      return fetch(target, { method: request.method, headers, body });
+    for (;; ) {
+      try {
+        return await fetch(target, { method: request.method, headers, body, signal: AbortSignal.timeout(timeout) });
+      } catch (error) {
+        const timedOut = error instanceof Error && error.name === "TimeoutError";
+        if (!timedOut || stall.count + 1 >= COUNT_TOKENS_ATTEMPTS)
+          throw error;
+        stall.count += 1;
+      }
+    }
+  };
+}
+function delivered(answer, out, metered, path, log, store) {
+  const { note, threadKey, sentSize, givenSize, fixedSize } = out;
+  const response = new Response(answer.body, { status: answer.status, statusText: answer.statusText, headers: forwardableHeaders(answer.headers) });
+  if (note.action === "pass" || !metered) {
+    if (note.action !== "pass" || Object.keys(note).length > 1)
+      log({ path, status: answer.status, ...note });
+    return response;
+  }
+  return watchUsage(response, (usage) => {
+    log({
+      path,
+      status: answer.status,
+      thread: threadKey,
+      ...note,
+      input: inputTokens(usage),
+      cacheRead: usage.cache_read_input_tokens ?? 0,
+      cacheWrite: usage.cache_creation_input_tokens ?? 0,
+      uncached: usage.input_tokens ?? 0,
+      charsIn: givenSize,
+      charsOut: sentSize,
+      charsFixed: fixedSize
+    });
+    if (threadKey)
+      recordUsage(store, threadKey, sentSize, usage);
+  });
+}
+function createForwarder(options) {
+  const upstream = options.upstream ?? "https://api.anthropic.com";
+  const prepare = options.prepare ?? defaultPrepare(options, upstream);
+  const timeout = options.countTokensTimeoutMs ?? 1e4;
+  async function route(request, began) {
+    const stall = { count: 0 };
+    let prep = 0;
+    let upload = 0;
+    const log = (entry) => options.record?.({ ...entry, ms: Date.now() - began, prep, upload, ...stall.count > 0 && { stalled: stall.count } });
+    const url = new URL(request.url);
+    const headers = new Headers(request.headers);
+    for (const name of DROPPED_REQUEST_HEADERS)
+      headers.delete(name);
+    let givenText;
+    if (request.method !== "GET" && request.method !== "HEAD")
+      givenText = await request.text();
+    upload = Date.now() - began;
+    const isMessages = request.method === "POST" && url.pathname.startsWith("/v1/messages");
+    const isCountTokens = url.pathname.includes("count_tokens");
+    const build = () => givenText && isMessages ? outgoing(prepare, request, givenText, !isCountTokens) : Promise.resolve(passthrough(givenText));
+    const send = createSender(request, upstream + url.pathname + url.search, headers, isCountTokens ? timeout : null, stall);
+    let out = await build();
+    prep = Date.now() - began - upload;
+    let answer = await send(out.bodyText);
+    const errorResponse = (text) => new Response(text, { status: answer.status, statusText: answer.statusText, headers: forwardableHeaders(answer.headers) });
+    if (answer.status >= 400 && out.note.action !== "pass") {
+      const errorText = await answer.text();
+      const logged = { path: url.pathname, status: answer.status, thread: out.threadKey, ...out.note };
+      const overflow = out.threadKey && !isCountTokens ? recordOverflow(options.store, out.threadKey, out.sentSize, errorText) : null;
+      if (!overflow) {
+        log({ ...logged, error: clipped(errorText) });
+        return errorResponse(errorText);
+      }
+      log({ ...logged, overflow, error: clipped(errorText) });
+      out = await build();
+      out = { ...out, note: { ...out.note, healed: overflow } };
+      answer = await send(out.bodyText);
+      if (answer.status >= 400) {
+        const retryError = await answer.text();
+        log({ path: url.pathname, status: answer.status, thread: out.threadKey, ...out.note, error: clipped(retryError) });
+        return errorResponse(retryError);
+      }
+    }
+    return delivered(answer, out, isMessages && !isCountTokens, url.pathname, log, options.store);
+  }
+  return async (request) => {
+    const began = Date.now();
+    try {
+      return await route(request, began);
+    } catch (error) {
+      options.record?.({ path: new URL(request.url).pathname, status: 502, action: "upstream-unreachable", error: clipped(String(error)), ms: Date.now() - began });
+      return Response.json({ type: "error", error: { type: "api_error", message: `eunoe could not reach the API: ${String(error)}` } }, { status: 502 });
+    }
+  };
+}
+// src/core/subagents.ts
+var closingTurn2 = { role: "user", content: "" };
+function launchTurnOf(parentMessages, toolUseId) {
+  if (!toolUseId)
+    return 0;
+  const index = splitTurns(parentMessages).turns.findIndex((turn) => turn.some((message) => message.role === "assistant" && blocks(message).some((b) => b.type === "tool_use" && b.id === toolUseId)));
+  return index + 1;
+}
+var subagentLabel = (description) => `subagent "${description}"`;
+function subagentRecall(messages, description, parentTurn) {
+  const from = subagentLabel(description);
+  return recallChunks([...messages, closingTurn2], new Map).map((chunk) => ({ ...chunk, from, turn: parentTurn }));
+}
+function listSubagentRecall(parentMessages, subagents) {
+  return subagents.flatMap((subagent) => subagentRecall(subagent.messages, subagent.description, launchTurnOf(parentMessages, subagent.toolUseId)));
+}
+// src/transcript/format.ts
+var extension = (format) => format === "xml" ? "xml" : "md";
+var padded = (n) => String(n).padStart(4, "0");
+var calls = (count) => `${count} tool call${count === 1 ? "" : "s"}`;
+function turnFile(turn, format) {
+  return `turn-${padded(turn.number)}.${extension(format)}`;
+}
+function subagentFile(parentTurn, k, format) {
+  return `turn-${padded(parentTurn)}-subagent-${k}.${extension(format)}`;
+}
+function toolMarkdown(part, total) {
+  return [
+    `### [tool ${part.n}/${total}] ${part.name}: ${part.call}`,
+    part.record ? `Full record of this subagent run: ${part.record}` : "",
+    part.body,
+    part.output ? `[output of tool ${part.n}${part.error ? ", error" : ""}]
+\`\`\`
+${part.output}
+\`\`\`` : `[tool ${part.n}: no output]`
+  ].filter(Boolean).join(`
+
+`);
+}
+function workOf(turn) {
+  const work = turn.parts.map((part) => part.kind === "say" ? `> ${part.text.replace(/\n/g, `
+> `)}` : toolMarkdown(part, turn.calls));
+  return work.join(`
+
+`) || "_No tool calls._";
+}
+function renderMarkdown(turn) {
+  return [
+    `# Turn ${turn.number}${turn.time ? ` · ${turn.time}` : ""}`,
+    "",
+    "## User",
+    "",
+    turn.prompt,
+    "",
+    `## Work (${calls(turn.calls)})`,
+    "",
+    workOf(turn),
+    "",
+    "## Final reply",
+    "",
+    turn.final || "_No final reply: the turn was interrupted or is still running._",
+    ""
+  ].join(`
+`);
+}
+function attr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/\n/g, " ");
+}
+function toolXml(part, total) {
+  return [
+    `<tool n="${part.n}" of="${total}" name="${attr(part.name)}">`,
+    `<call>${part.call.replace(/^`|`$/g, "")}</call>`,
+    part.record ? `<record>${part.record}</record>` : "",
+    part.body ? `<input>
+${part.body}
+</input>` : "",
+    part.output ? `<output${part.error ? ' error="true"' : ""}>
+${part.output}
+</output>` : "<output/>",
+    "</tool>"
+  ].filter(Boolean).join(`
+`);
+}
+function renderXml(turn) {
+  return [
+    `<turn n="${turn.number}"${turn.time ? ` time="${turn.time}"` : ""} tool_calls="${turn.calls}">`,
+    `<user>
+${turn.prompt}
+</user>`,
+    ...turn.parts.map((part) => part.kind === "say" ? `<said>
+${part.text}
+</said>` : toolXml(part, turn.calls)),
+    turn.final ? `<final_reply>
+${turn.final}
+</final_reply>` : `<final_reply interrupted="true"/>`,
+    "</turn>",
+    ""
+  ].join(`
+`);
+}
+var finalOf = (final) => final ? clip(final, 160) : "_(no final reply)_";
+var turnLine = (turn, format) => `- **${turnFile(turn, format)}** (${turn.time}, ${turn.calls} calls): ${clip(turn.prompt, 140)} → ${finalOf(turn.final)}`;
+var recordLine = (record) => {
+  const total = record.turns.reduce((sum, turn) => sum + turn.calls, 0);
+  return `  - **${record.file}**: subagent "${clip(record.run.description, 140)}" (${total} calls) → ${finalOf(record.turns.at(-1)?.final)}`;
+};
+function renderIndex(turns, format, records = []) {
+  const ext = extension(format);
+  const subagentNote = records.length > 0 ? ` Indented lines are subagents the agent launched in that turn; turn-NNNN-subagent-K.${ext} holds the subagent's whole run, which the turn itself only has the report of.` : "";
+  return [
+    "# Session index",
+    "",
+    `One line per turn: what the user asked → how the turn ended. Open turn-NNNN.${ext} for everything that happened in it.${subagentNote}`,
+    "",
+    ...turns.flatMap((turn) => [turnLine(turn, format), ...records.filter((record) => record.parentTurn === turn.number).map(recordLine)]),
+    ...records.filter((record) => record.parentTurn === 0).map(recordLine),
+    ""
+  ].join(`
+`);
+}
+function renderSubagentMarkdown(record) {
+  const parent = record.parentTurn || "?";
+  const body = record.turns.flatMap((turn, i) => [
+    record.turns.length > 1 ? `## Message ${i + 1}` : "## Task",
+    "",
+    turn.prompt,
+    "",
+    `## Work (${calls(turn.calls)})`,
+    "",
+    workOf(turn),
+    "",
+    "## Final reply",
+    "",
+    turn.final || "_No final reply: the run was interrupted or is still going._",
+    ""
+  ]);
+  return [`# Subagent of turn ${parent} · "${record.run.description}"`, `This is the full record of a subagent launched from turn ${parent}; that turn only holds its final report.`, "", ...body].join(`
+`);
+}
+function renderSubagentXml(record) {
+  return [`<subagent parent_turn="${record.parentTurn}" description="${attr(record.run.description)}">`, ...record.turns.map(renderXml), "</subagent>", ""].join(`
+`);
+}
+
+// src/transcript/parse.ts
+var OUTPUT_CAP = 40000;
+function promptText(content) {
+  return content.filter((block) => block.type === "text").map((block) => block.text ?? "").join(`
+`).replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").replace(/<system-message>[\s\S]*?<\/system-message>/g, "").trim();
+}
+function isPrompt2(entry) {
+  if (entry.type !== "user" || entry.isMeta || entry.isCompactSummary)
+    return false;
+  const content = contentBlocks(entry.message?.content);
+  if (content.some((block) => block.type === "tool_result"))
+    return false;
+  return Boolean(promptText(content)) || content.some((block) => block.type === "image");
+}
+function describeCall(block) {
+  const input = block.input ?? {};
+  if (typeof input.command === "string")
+    return `\`${input.command.replace(/\s+/g, " ").slice(0, 300)}\``;
+  if (typeof input.file_path === "string")
+    return input.file_path;
+  if (typeof input.pattern === "string")
+    return `"${input.pattern.slice(0, 120)}"${input.path ? ` in ${input.path}` : ""}`;
+  if (typeof input.url === "string")
+    return input.url;
+  if (typeof input.description === "string")
+    return input.description.slice(0, 160);
+  return JSON.stringify(input).slice(0, 200);
+}
+function callBody(block) {
+  const input = block.input ?? {};
+  if (typeof input.new_string === "string")
+    return `Replaced:
+\`\`\`
+${input.old_string ?? ""}
+\`\`\`
+With:
+\`\`\`
+${input.new_string}
+\`\`\``;
+  if (typeof input.content === "string" && block.name === "Write")
+    return `\`\`\`
+${input.content.slice(0, OUTPUT_CAP)}
+\`\`\``;
+  return "";
+}
+function outputOf(block) {
+  const content = typeof block.content === "string" ? block.content : contentBlocks(block.content).map((part) => part.type === "text" ? part.text : `[${part.type}]`).join(`
+`);
+  return content.length > OUTPUT_CAP ? `${content.slice(0, OUTPUT_CAP)}
+… [${content.length - OUTPUT_CAP} more characters]` : content;
+}
+function promptTurn(entry, number) {
+  const text = promptText(contentBlocks(entry.message?.content));
+  const time = String(entry.timestamp ?? "").slice(0, 16).replace("T", " ");
+  return { number, time, prompt: text || "[image]", parts: [], final: "", calls: 0 };
+}
+function recordAssistant(turn, content, pending, narration) {
+  let said = narration;
+  for (const block of content) {
+    if (block.type === "text" && String(block.text).trim()) {
+      said = String(block.text).trim();
+      turn.final = said;
+    }
+    if (block.type !== "tool_use")
+      continue;
+    turn.calls += 1;
+    if (said) {
+      turn.parts.push({ kind: "say", text: said });
+      said = "";
+    }
+    turn.final = "";
+    const call = {
+      kind: "tool",
+      n: turn.calls,
+      id: String(block.id ?? ""),
+      name: block.name,
+      prompt: typeof block.input?.prompt === "string" ? block.input.prompt : undefined,
+      call: describeCall(block),
+      body: callBody(block),
+      output: "",
+      error: false
+    };
+    pending.set(block.id, call);
+    turn.parts.push(call);
+  }
+  return said;
+}
+function recordResults(content, pending) {
+  for (const block of content) {
+    if (block.type !== "tool_result")
+      continue;
+    const call = pending.get(block.tool_use_id);
+    if (!call)
+      continue;
+    pending.delete(block.tool_use_id);
+    call.output = outputOf(block).trim();
+    call.error = Boolean(block.is_error);
+  }
+}
+function parseTurns(entries, sidechain = false) {
+  const turns = [];
+  const pending = new Map;
+  let narration = "";
+  for (const entry of entries) {
+    if (sidechain !== "any" && Boolean(entry.isSidechain) !== sidechain)
+      continue;
+    if (isPrompt2(entry)) {
+      turns.push(promptTurn(entry, turns.length + 1));
+      continue;
+    }
+    const turn = turns.at(-1);
+    if (!turn)
+      continue;
+    const content = contentBlocks(entry.message?.content);
+    if (entry.type === "system" && entry.subtype === "compact_boundary")
+      turn.parts.push({ kind: "say", text: "(Claude Code compacted the context here.)" });
+    else if (entry.type === "assistant")
+      narration = recordAssistant(turn, content, pending, narration);
+    else if (entry.type === "user")
+      recordResults(content, pending);
+  }
+  return turns;
+}
+
+// src/core/transcript.ts
+var isNote = (message) => message.role === "user" && !isPrompt(message) && !blocks(message).some((b) => b.type === "tool_result");
+var turnsOf = (messages, sidechain = false) => parseTurns(messages.map((message) => ({ type: message.role, isMeta: isNote(message), message })), sidechain);
+function subagentRecords(messages, turns, subagents, format) {
+  const perTurn = new Map;
+  return subagents.map((subagent) => {
+    const parentTurn = launchTurnOf(messages, subagent.toolUseId);
+    const k = (perTurn.get(parentTurn) ?? 0) + 1;
+    perTurn.set(parentTurn, k);
+    const file = subagentFile(parentTurn, k, format);
+    const launcher = turns[parentTurn - 1]?.parts.find((part) => part.kind === "tool" && part.id === subagent.toolUseId);
+    if (launcher?.kind === "tool")
+      launcher.record = file;
+    return { run: { description: subagent.description }, turns: turnsOf(subagent.messages, "any"), parentTurn, file };
+  });
+}
+function renderTranscriptFiles(messages, { format = "markdown", subagents = [] } = {}) {
+  const turns = turnsOf(messages);
+  const records = subagentRecords(messages, turns, subagents, format);
+  const files = {};
+  for (const turn of turns)
+    files[turnFile(turn, format)] = format === "xml" ? renderXml(turn) : renderMarkdown(turn);
+  for (const record of records)
+    files[record.file] = format === "xml" ? renderSubagentXml(record) : renderSubagentMarkdown(record);
+  files["index.md"] = renderIndex(turns, format, records);
+  return files;
+}
+var transcriptGuide = (dir, format = "markdown") => searchGuide({ mode: format, dir, jsonl: "" });
+export {
+  CORE_DEFAULTS,
+  claudeCodeSessionId,
+  continueToken,
+  createForwarder,
+  createWindowLookup,
+  foldThread,
+  inputTokens,
+  jevReranker,
+  listSubagentRecall,
+  memoryStore,
+  pinTurns,
+  recordOverflow,
+  recordUsage,
+  renderTranscriptFiles,
+  rewrite,
+  rewriteAsync,
+  threadKeyOf,
+  transcriptGuide,
+  watchUsage
+};