@chroxify/eunoe 1.0.0 → 1.2.0

package/src/proxy/compaction.ts

@@ -1,11 +1,36 @@
-import { CLEARED_OUTPUT } from "../context/prompts"
-import { clearToolResults, compactMessages, countToolResults } from "../context/strategies"
-import { splitTurns, turnFingerprint } from "../context/turns"
-import { DEFAULT_RATIO, PROTECTED_OUTPUTS } from "./constants"
-import { estimator, targetSize } from "./estimate"
-import { resetCut } from "./state"
-import type { Message } from "../context/types"
-import type { CompactInput, CompactResult } from "./types"
+import type { Config } from "../config"
+import type { Body, Message } from "../context/content"
+import { type CompactOptions, capTurns, clearToolResults, compactMessages, countToolResults } from "../context/fold/strategies"
+import { splitTurns, turnFingerprint } from "../context/fold/turns"
+import { clearedOutput } from "../context/prompts"
+import { DEFAULT_RATIO, type Estimator, estimator, targetSize } from "./estimate"
+import { resetCut, type ThreadState } from "./state"
+
+export interface CompactInput {
+  body: Body
+  config: Config
+  state: ThreadState
+  window: number | null
+  guide: string | null
+  transcriptDir?: string | null
+  mayCompact: boolean
+  omittedBefore?: number
+  decorate?: (messages: Message[]) => Message[]
+  reduce?: CompactOptions["reduce"]
+}
+
+export interface CompactResult {
+  messages: Message[]
+  stateChanged: boolean
+  note: Record<string, unknown>
+}
+
+interface Rolling {
+  keep: number
+  budget: number
+}
+
+const PROTECTED_OUTPUTS = 5
 
 function settledCut(turns: Message[][], index: number) {
   let cut = index
@@ -13,80 +38,107 @@ function settledCut(turns: Message[][], index: number) {
   return cut
 }
 
-export function compact({ body, config, state, window, guide, mayCompact, omittedBefore = 0 }: CompactInput): CompactResult {
-  const { turns } = splitTurns(body.messages)
-  let stateChanged = false
-
+function resolveCut(turns: Message[][], state: ThreadState, config: Config, rollingKeep: number | undefined) {
   let cutIndex = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1
+  let stateChanged = false
   if (state.cut && cutIndex === -1) {
     resetCut(state)
     stateChanged = true
   }
-  const rolling = config.eval?.rolling ?? (config.mode === "default" ? { keep: config.keep, budget: config.budget } : undefined)
   if (cutIndex <= 0 && config.eval?.forceCut && turns.length >= 3) {
-    const forced = settledCut(turns, Math.max(1, turns.length - 1 - (rolling?.keep ?? 1)))
-    cutIndex = forced
-    state.cut = turnFingerprint(turns[forced])
+    cutIndex = settledCut(turns, Math.max(1, turns.length - 1 - (rollingKeep ?? 1)))
+    state.cut = turnFingerprint(turns[cutIndex])
     stateChanged = true
   }
+  return { cutIndex, stateChanged }
+}
+
+function shrinkOnce(state: ThreadState, cutIndex: number, configuredKeep: number, liveResults: () => number): string {
+  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: Message[][], cutIndex: number, rolling: Rolling, size: Estimator): number | null {
+  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: () => boolean, step: () => string, actions: string[], rebuild: () => void) {
+  while (over()) {
+    const action = step()
+    actions.push(action)
+    if (action === "stuck") return
+    rebuild()
+  }
+}
+
+export function compact({ body, config, state, window, guide, transcriptDir, mayCompact, omittedBefore = 0, decorate = (m) => m, reduce }: CompactInput): CompactResult {
+  const { 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 liveLength = () => turns.slice(Math.max(cutIndex, 0)).flat().length
-  const compacted = () => cutIndex > 0
-    ? compactMessages(body.messages, cutIndex, { keepTurns: state.keep ?? configuredKeep, guide, omittedBefore, evidence: config.eval?.evidence ?? true })
-    : body.messages
+  const ratio = state.ratio ?? DEFAULT_RATIO
+  const options = { guide, omittedBefore, evidence: config.eval?.evidence ?? true, reduce, capChars: config.turnCap === "off" ? undefined : config.turnCap / ratio }
+  const liveStart = (list: Message[]) =>
+    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, messages.length - liveLength(), state.cleared, CLEARED_OUTPUT) : messages
+    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, state.ratio ?? DEFAULT_RATIO)
+  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(messages)
+  let estimate = size.of(decorate(messages))
   const actions: string[] = []
-  const current = turns.length - 1
+  const rebuild = () => {
+    messages = build()
+    estimate = size.of(decorate(messages))
+  }
   const moveCut = (index: number, action: string) => {
     cutIndex = index
     resetCut(state)
     state.cut = turnFingerprint(turns[index])
     actions.push(action)
-    messages = build()
-    estimate = size.of(messages)
+    rebuild()
   }
 
-  if (mayCompact && rolling) {
-    const next = settledCut(turns, current - rolling.keep)
-    const backlog = size.of(turns.slice(Math.max(cutIndex, 0), Math.max(next, 0)).flat()) - size.fixed
-    if (next >= 1 && next > cutIndex && backlog > rolling.budget) {
-      moveCut(next, "roll")
-      stateChanged = true
-    }
+  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")
-    while (estimate > target) {
-      const keep = Math.min(state.keep ?? configuredKeep, cutIndex - 1)
-      if (cutIndex > 0 && keep > 0) {
-        state.keep = keep - 1
-        actions.push(`keep=${state.keep}`)
-      } else {
-        const unclearedLive = compacted()
-        const total = countToolResults(unclearedLive, unclearedLive.length - liveLength())
-        const remaining = total - (state.cleared ?? 0) - PROTECTED_OUTPUTS
-        if (remaining <= 0) {
-          actions.push("stuck")
-          break
-        }
-        state.cleared = (state.cleared ?? 0) + Math.ceil(remaining / 2)
-        actions.push(`cleared=${state.cleared}`)
-      }
-      messages = build()
-      estimate = size.of(messages)
-    }
+    shrinkToTarget(
+      () => estimate > target,
+      () => shrinkOnce(state, cutIndex, configuredKeep, liveResults),
+      actions,
+      rebuild,
+    )
     stateChanged = true
   }
 
@@ -96,8 +148,9 @@ export function compact({ body, config, state, window, guide, mayCompact, omitte
     note: {
       action: cutIndex > 0 ? "compact" : "full",
       compacted: actions.includes("cut") || actions.includes("roll"),
-      actions: actions.length ? actions : undefined,
+      actions: actions.length > 0 ? actions : undefined,
       cutTurn: cutIndex > 0 ? cutIndex : null,
+      omitted: cutIndex > 0 ? Math.max(1, cutIndex - (state.keep ?? configuredKeep)) - 1 : 0,
       keep: state.keep,
       cleared: state.cleared,
       turns: turns.length,

package/src/proxy/estimate.ts

@@ -1,15 +1,20 @@
-import type { Body, Message } from "../context/types"
-import { MEDIA_CHARS, MEDIA_MIN_LENGTH, TARGET_SHARE } from "./constants"
-import type { Estimator } from "./types"
+import type { Body, Message } from "../context/content"
+
+export interface Estimator {
+  of: (messages: Message[]) => number
+  fixed: number
+}
+
+export const DEFAULT_RATIO = 1 / 3.6
+
+const MEDIA_CHARS = 5_800
 
 export function sizeOf(body: Pick<Body, "system" | "tools" | "messages">): number {
   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 > MEDIA_MIN_LENGTH) {
-      media += 1
-      return ""
-    }
-    return value
+    if (key !== "data" || typeof value !== "string" || value.length <= 2_000) return value
+    media += 1
+    return ""
   })
   return json.length + media * MEDIA_CHARS
 }
@@ -22,5 +27,5 @@ export function estimator(body: Body, ratio: number): Estimator {
 }
 
 export function targetSize(size: Estimator, window: number): number {
-  return size.fixed + TARGET_SHARE * Math.max(0, window - size.fixed)
+  return size.fixed + 0.3 * Math.max(0, window - size.fixed)
 }

package/src/proxy/fingerprint.ts

@@ -1,15 +1,29 @@
-import type { Body } from "../context/types"
-import { FINGERPRINT_LENGTH, SKILL_MARKER } from "./constants"
-import type { ContextFingerprint } from "./types"
-
-const hash = (value: unknown) => {
-  const hasher = new Bun.CryptoHasher("sha256")
-  hasher.update(JSON.stringify(value ?? null, (key, inner) => (key === "cache_control" ? undefined : inner)))
-  return hasher.digest("hex").slice(0, FINGERPRINT_LENGTH)
+import { type Body, blocks, type Message, shortHash, withoutCacheControl } from "../context/content"
+
+export interface ContextFingerprint {
+  system: string
+  tools: string
+  skills: string[]
+  given?: ContextFingerprint
 }
 
+export const isInjected = (text: unknown) => /^<(?:recalled-context|handoff)[\s>]/.test(String(text ?? ""))
+
+export function messageFingerprint(message: Message) {
+  const own = blocks(message)
+    .filter((b) => !(b.type === "text" && isInjected(b.text)))
+    .map(withoutCacheControl)
+  return shortHash(JSON.stringify(own), 24)
+}
+
+const hash = (value: unknown) =>
+  shortHash(
+    JSON.stringify(value ?? null, (key, inner) => (key === "cache_control" ? undefined : inner)),
+    12,
+  )
+
 export function contextFingerprint(body: Body): ContextFingerprint {
   const skills = new Set<string>()
-  for (const match of JSON.stringify(body.messages ?? []).matchAll(SKILL_MARKER)) skills.add(match[1].split("/").at(-1)!)
+  for (const match of JSON.stringify(body.messages ?? []).matchAll(/Base directory for this skill: ([^\s"\\]+)/g)) skills.add(match[1].split("/").at(-1) ?? match[1])
   return { system: hash(body.system), tools: hash(body.tools), skills: [...skills].sort() }
 }

package/src/proxy/handoff.ts

@@ -0,0 +1,71 @@
+import { statSync } from "node:fs"
+import { type Config, claudeConfigDirs } from "../config"
+import { blocks, type Message } from "../context/content"
+import { FOLD_CAP_CHARS, foldedView, sourceChunks } from "../context/fold"
+import { isPrompt } from "../context/fold/turns"
+import { handoffBlock } from "../context/prompts"
+import type { RecallChunk } from "../context/recall"
+import { findSessionByPrefix } from "../transcript/locate"
+import { sessionMessages } from "../transcript/messages"
+import { isInjected, messageFingerprint } from "./fingerprint"
+import { titleOf } from "./sessions"
+import type { Handoff, ThreadState } from "./state"
+
+const sourceCache = new Map<string, { mtime: number; chunks: RecallChunk[] }>()
+
+export const continueToken = (id: string) => `{ee:continue:${id}}`
+
+export function continueIdOf(message: Message): string | null {
+  if (!isPrompt(message)) return null
+  const own = blocks(message)
+    .filter((b) => b.type === "text" && !isInjected(b.text))
+    .map((b) => String(b.text ?? ""))
+    .join("\n")
+  return own.match(/\{ee:continue:([A-Za-z0-9-]{8,})\}/)?.[1] ?? null
+}
+
+export function activeHandoffs(handoffs: Record<string, Handoff | null> = {}): Record<string, Handoff> {
+  return Object.fromEntries(Object.entries(handoffs).filter((entry): entry is [string, Handoff] => Boolean(entry[1])))
+}
+
+export function attachHandoffs(messages: Message[], config: Config, sessionId: string | null, state: ThreadState): boolean {
+  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
+    state.handoffs ??= {}
+    const file = findSessionByPrefix(id, claudeConfigDirs(config), sessionId ?? undefined)
+    const already = Object.values(state.handoffs).some((h) => h?.source === file)
+    state.handoffs[key] = file && !already ? { label: titleOf(file) ?? id, source: file, text: foldedView(sessionMessages(file), FOLD_CAP_CHARS) } : null
+    changed = true
+  }
+  return changed
+}
+
+export function withHandoffs(messages: Message[], handoffs: Record<string, Handoff>): Message[] {
+  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
+  })
+}
+
+export function handoffChunks(handoffs: Record<string, Handoff>): RecallChunk[] {
+  const sources = new Map<string, string>()
+  for (const handoff of Object.values(handoffs)) if (!sources.has(handoff.source)) sources.set(handoff.source, handoff.label)
+  return [...sources].flatMap(([source, label]) => {
+    let mtime: number
+    try {
+      mtime = statSync(source).mtimeMs
+    } catch {
+      return []
+    }
+    const cached = sourceCache.get(source)
+    const chunks = cached?.mtime === mtime ? cached.chunks : sourceChunks(sessionMessages(source), label, true)
+    sourceCache.set(source, { mtime, chunks })
+    return chunks
+  })
+}

package/src/proxy/log.ts

@@ -1,9 +1,9 @@
 import { appendFileSync, mkdirSync } from "node:fs"
-import { EUNOE_DIR, paths } from "../config/constants"
+import { EUNOE_DIR, paths } from "../config/paths"
 
 export function logRequest(record: Record<string, unknown>) {
   try {
     mkdirSync(EUNOE_DIR, { recursive: true })
-    appendFileSync(paths.requests, JSON.stringify({ ts: new Date().toISOString(), ...record }) + "\n")
+    appendFileSync(paths.requests, `${JSON.stringify({ ts: new Date().toISOString(), ...record })}\n`)
   } catch {}
 }

package/src/proxy/recall.ts

@@ -0,0 +1,58 @@
+import { type Body, blocks, resultText } from "../context/content"
+import { livePrompt, type RecallChunk, type Reranker, recallChunks, recallFor, recallForWith, withRecall } from "../context/recall"
+import { sessionMessages } from "../transcript/messages"
+import { subagentChunks } from "../transcript/subagents"
+import { messageFingerprint } from "./fingerprint"
+import { activeHandoffs, handoffChunks } from "./handoff"
+import type { Rewrite, RewriteInput } from "./rewrite"
+import { readState, saveState } from "./state"
+
+export const wantsRecall = (input: RewriteInput) => (input.config.eval?.recall ?? true) && input.config.mode !== "off"
+
+export const activeRecalls = (recalls: Record<string, string> = {}) => Object.fromEntries(Object.entries(recalls).filter(([, text]) => text))
+
+const touched = (input: RewriteInput, result: Rewrite) => result.threadKey !== null && !(result.body === input.body && result.note.action === "pass")
+
+function droppedChunks(input: RewriteInput, result: Rewrite): RecallChunk[] {
+  const transcript = input.transcript?.jsonl ?? null
+  const kept = new Map<string, string>()
+  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 || !transcript ? own : recallChunks([...sessionMessages(transcript), { role: "user", content: "" }], kept)
+  const withSubagents = transcript ? [...session, ...subagentChunks(transcript)] : session
+  const handoffs = result.threadKey ? activeHandoffs(readState(result.threadKey).handoffs) : {}
+  return [...handoffChunks(handoffs), ...withSubagents]
+}
+
+function recallTarget(original: Body, result: Rewrite): { key: string; text: string } | null {
+  const live = livePrompt(original.messages)
+  return live && result.threadKey ? { key: messageFingerprint(original.messages[live.index]), text: live.text } : null
+}
+
+export function applyRecall(input: RewriteInput, result: Rewrite): Rewrite {
+  if (!touched(input, result) || !result.threadKey) return result
+  const state = readState(result.threadKey)
+  state.recalls ??= {}
+  const target = recallTarget(input.body, result)
+  let note = result.note
+  if (target && !(target.key in state.recalls)) {
+    state.recalls[target.key] = recallFor(target.text, droppedChunks(input, result), input.config.eval?.recallOptions) ?? ""
+    saveState(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 }
+}
+
+export async function prefetchFor(input: RewriteInput, result: Rewrite, rerank: Reranker): Promise<number | null> {
+  if (!touched(input, result) || !result.threadKey) return null
+  const target = recallTarget(input.body, result)
+  if (!target) return null
+  const state = readState(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), rerank, options)) ?? ""
+  saveState(result.threadKey, state)
+  return state.recalls[target.key].length
+}