@chroxify/eunoe 0.1.0 → 1.1.0

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
+}

package/src/proxy/rewrite.ts

@@ -1,72 +1,168 @@
-import { searchOnlyInstructions, trimInstructions, TRANSCRIPT_FALLBACK } from "../context/prompts"
-import { appendSystem, tailMessages, trimMessages } from "../context/strategies"
-import { splitTurns, turnFingerprint } from "../context/turns"
-import type { Body } from "../context/types"
-import { searchGuide } from "../transcript/search"
+import type { Config } from "../config"
+import type { Body, Message } from "../context/content"
+import { appendSystem, tailMessages, trimMessages } from "../context/fold/strategies"
+import { splitTurns, turnFingerprint } from "../context/fold/turns"
+import { SYSTEM_PROMPT, searchGuide, searchOnlyInstructions, trimInstructions } from "../context/prompts"
+import { identityReranker, type Reranker, withRecall } from "../context/recall"
+import { jevReranker, rerankKey } from "../context/recall/rerank"
+import type { TranscriptRef } from "../transcript/search"
 import { compact } from "./compaction"
-import { DEFAULT_RATIO } from "./constants"
-import { estimator, targetSize } from "./estimate"
-import { loadState, saveState } from "./state"
-import type { Rewrite, RewriteInput } from "./types"
+import { DEFAULT_RATIO, estimator, sizeOf, targetSize } from "./estimate"
+import { messageFingerprint } from "./fingerprint"
+import { activeHandoffs, attachHandoffs, withHandoffs } from "./handoff"
+import { activeRecalls, applyRecall, prefetchFor, wantsRecall } from "./recall"
+import { readState, saveState } from "./state"
+
+export interface RewriteInput {
+  body: Body
+  sessionId: string | null
+  config: Config
+  transcript: TranscriptRef | null
+  window: number | null
+  mayCompact: boolean
+  omittedBefore?: number
+}
+
+export interface Rewrite {
+  body: Body
+  threadKey: string | null
+  note: Record<string, unknown>
+}
+
+interface Prefetched {
+  reranked: boolean
+  rerankError: string | null
+  recalled: number
+}
 
 const pass = (body: Body): Rewrite => ({ body, threadKey: null, note: { action: "pass" } })
 
 const isAgentThread = (body: Body) => Array.isArray(body.tools) && body.tools.length > 0
 
-export function rewrite(input: RewriteInput): Rewrite {
+const withSystemPrompt = (system: Body["system"], extra?: string | null) => appendSystem(extra ? appendSystem(system, extra) : system, SYSTEM_PROMPT)
+
+const ratioOf = (threadKey: string) => readState(threadKey).ratio ?? DEFAULT_RATIO
+
+function rerankModel(config: Config): string | null {
+  const model = config.eval?.rerank?.model ?? config.rerank
+  return model && model !== "off" ? model : null
+}
+
+function evalStrategy(input: RewriteInput, turns: Message[][], threadKey: string, guide: string | null): Rewrite | null {
+  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(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: RewriteInput): Rewrite {
   const { body, sessionId, config, transcript } = input
   if (config.mode === "off" || !sessionId || !Array.isArray(body.messages) || body.messages.length === 0) return pass(body)
   const { turns } = splitTurns(body.messages)
   if (turns.length === 0) return pass(body)
   const threadKey = `${sessionId}-${turnFingerprint(turns[0])}`
   const guide = transcript ? searchGuide(transcript) : null
+  const state = readState(threadKey)
+  if (attachHandoffs(body.messages, config, sessionId, state)) saveState(threadKey, state)
 
-  switch (config.eval?.strategy) {
-    case "guide": {
-      if (!isAgentThread(body)) return pass(body)
-      return {
-        body: guide ? { ...body, system: appendSystem(body.system, searchOnlyInstructions(guide)) } : body,
-        threadKey,
-        note: { action: "guide", turns: turns.length, messagesIn: body.messages.length },
-      }
-    }
-    case "tail": {
-      if (!isAgentThread(body)) return pass(body)
-      const size = estimator(body, loadState(threadKey).ratio ?? DEFAULT_RATIO)
-      let from = 1
-      if (config.eval.tailTurns) {
-        from = Math.max(1, turns.length - config.eval.tailTurns)
-      } else 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: { ...body, messages },
-        threadKey,
-        note: { action: "tail", keptTurns: turns.length - from, turns: turns.length, messagesIn: body.messages.length, messagesOut: messages.length, estimate: size.of(messages) },
-      }
-    }
-  }
-
-  if (config.mode === "trim") {
-    if (!isAgentThread(body)) return pass(body)
-    const messages = trimMessages(body.messages)
-    return {
-      body: { ...body, system: appendSystem(body.system, trimInstructions(guide ?? TRANSCRIPT_FALLBACK)), messages },
-      threadKey,
-      note: { action: "trim", turns: turns.length, messagesIn: body.messages.length, messagesOut: messages.length },
-    }
-  }
+  const forced = evalStrategy(input, turns, threadKey, guide)
+  if (forced) return forced
 
-  if (body.messages.length < 2) return { body, threadKey, note: { action: "full", turns: turns.length } }
-  const state = loadState(threadKey)
-  const result = compact({ body, config, state, window: input.window, guide, mayCompact: input.mayCompact, omittedBefore: input.omittedBefore })
+  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: transcript && transcript.mode !== "jsonl" ? transcript.dir : null,
+    mayCompact: input.mayCompact,
+    omittedBefore: input.omittedBefore,
+    decorate: (messages) => withRecall(withHandoffs(messages, handoffs), messageFingerprint, recalls),
+  })
   if (result.stateChanged) saveState(threadKey, state)
-  return {
-    body: result.messages === body.messages ? body : { ...body, messages: result.messages },
-    threadKey,
-    note: result.note,
-  }
+  return { body: result.messages === body.messages ? based : { ...based, messages: result.messages }, threadKey, note: result.note }
+}
+
+function withAttachedHandoffs(result: Rewrite): Rewrite {
+  if (!result.threadKey) return result
+  const handoffs = activeHandoffs(readState(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: RewriteInput): Rewrite {
+  const result = withAttachedHandoffs(strategize(input))
+  return wantsRecall(input) ? applyRecall(input, result) : result
+}
+
+function sentEstimate(result: Rewrite): number {
+  return Math.round(sizeOf(result.body) * (result.threadKey ? ratioOf(result.threadKey) : DEFAULT_RATIO))
+}
+
+function overLimit(input: RewriteInput, result: Rewrite): boolean {
+  if (!input.window || !result.threadKey || input.mayCompact === false || result.note.action === "pass") return false
+  return sentEstimate(result) > input.config.compactAt * input.window
+}
+
+function carried(from: Rewrite, to: Rewrite): Rewrite {
+  const actionsOf = ({ note }: Rewrite) => (note.actions as string[] | undefined) ?? []
+  const actions = [...actionsOf(from), ...actionsOf(to)]
+  if (!from.note.compacted && actions.length === 0) return to
+  return { ...to, note: { ...to.note, compacted: Boolean(to.note.compacted || from.note.compacted), actions } }
+}
+
+export function rewrite(input: RewriteInput, before?: Rewrite): Rewrite {
+  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(bare) } }
+}
+
+export async function prefetchRecall(input: RewriteInput, rerank: Reranker): Promise<Prefetched | null> {
+  if (!wantsRecall(input)) return null
+  const recalled = await prefetchFor(input, strategize(input), rerank)
+  return recalled === null ? null : { reranked: rerank !== identityReranker, rerankError: null, recalled }
+}
+
+export async function rewriteAsync(input: RewriteInput): Promise<Rewrite> {
+  const model = wantsRecall(input) ? rerankModel(input.config) : null
+  const key = model ? rerankKey() : null
+  if (!model || !key) return rewrite(input)
+  const failure = { reason: null as string | null }
+  const reranker = jevReranker(model, key, input.config.eval?.rerank?.endpoint, (reason) => {
+    failure.reason = reason
+  })
+  const first = strategize(input)
+  const recalled = await prefetchFor(input, first, reranker)
+  const final = rewrite(input, first)
+  if (recalled === null) return final
+  const outcome = failure.reason ? { rerankError: `${model}: ${failure.reason}` } : { reranked: model }
+  return { ...final, note: { ...final.note, recalled, ...outcome } }
 }

package/src/proxy/server.ts

@@ -1,21 +1,47 @@
 import path from "node:path"
-import { claudeConfigDirs, loadConfig } from "../config"
-import type { Config } from "../config/types"
-import type { Body } from "../context/types"
+import { type Config, claudeConfigDirs, readConfig, settingsFor } from "../config"
+import { type Body, wellFormed } from "../context/content"
 import { findSessionFile } from "../transcript/locate"
 import { prepareTranscript } from "../transcript/search"
 import { VERSION } from "../version"
-import { HEALTH_PATH, IDLE_TIMEOUT_SECONDS, LOGGED_ERROR_CHARS, OMITTED_BEFORE_HEADER, SESSION_HEADER, TRANSCRIPT_HEADER } from "./constants"
+import { applyCanonical } from "./canonical"
 import { sizeOf } from "./estimate"
+import { type ContextFingerprint, contextFingerprint } from "./fingerprint"
 import { logRequest } from "./log"
-import { rewrite } from "./rewrite"
-import { loadState, saveState } from "./state"
-import type { Health, Note } from "./types"
+import { rewriteAsync } from "./rewrite"
+import { recordSession } from "./sessions"
+import { readState, saveState } from "./state"
 import { inputTokens, watchUsage } from "./usage"
 import { resolveWindow } from "./window"
 
-export function sessionIdOf(headers: Headers, body: Body): string | null {
-  const header = headers.get(SESSION_HEADER)
+export interface Health {
+  ok: boolean
+  version: string
+  mode: Config["mode"]
+  pid: number
+  startedAt?: number
+}
+
+interface Outgoing {
+  note: Record<string, unknown>
+  threadKey: string | null
+  bodyText: string | undefined
+  sentSize: number
+  givenSize: number
+  fixedSize: number
+  sent: (ContextFingerprint & { session: string | null }) | null
+}
+
+export const HEALTH_PATH = "/_eunoe/health"
+
+const startedAt = Date.now()
+
+const trustedHeader = (request: Request, config: Config, name: string) => (config.eval?.trustHeaders === true ? request.headers.get(`x-eunoe-${name}`) : null)
+
+const clipped = (error: string) => error.slice(0, 500)
+
+function sessionIdOf(headers: Headers, body: Body): string | null {
+  const header = headers.get("x-claude-code-session-id")
   if (header) return header
   try {
     return JSON.parse(body.metadata?.user_id ?? "{}").session_id ?? null
@@ -31,67 +57,116 @@ function forwardableHeaders(headers: Headers) {
   return out
 }
 
-async function prepare(request: Request, body: Body, config: Config, isCountTokens: boolean) {
+function overflowTokens(errorText: string): number | null {
+  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
+}
+
+async function prepare(request: Request, body: Body, base: Config, isCountTokens: boolean) {
   const sessionId = sessionIdOf(request.headers, body)
+  const config = settingsFor(base, sessionId)
   const trusted = config.eval?.trustHeaders === true
-  const transcriptOverride = trusted ? request.headers.get(TRANSCRIPT_HEADER) : null
+  const transcriptOverride = trustedHeader(request, config, "transcript")
   const sessionFile = transcriptOverride ?? (sessionId ? findSessionFile(sessionId, claudeConfigDirs(config)) : null)
-  const transcript = sessionFile && sessionId
-    ? prepareTranscript(config.search, sessionFile, transcriptOverride ? path.basename(transcriptOverride, ".jsonl") : sessionId)
-    : null
-  const needsWindow = config.mode === "compact" || config.eval?.strategy === "tail"
-  const window = config.window ?? (needsWindow ? await resolveWindow(body.model, request.headers, config.upstream) : null)
-  return rewrite({
+  if (sessionId && !trusted) recordSession(sessionId, config.mode, sessionFile)
+  if (config.mode === "off") return rewriteAsync({ body, sessionId, config, transcript: null, window: null, mayCompact: false })
+  const transcriptKey = transcriptOverride ? path.basename(transcriptOverride, ".jsonl") : sessionId
+  const transcript = sessionFile && sessionId && transcriptKey ? prepareTranscript(config.search, sessionFile, transcriptKey) : null
+  const needsWindow = !config.eval?.strategy || config.eval.strategy === "tail"
+  const windowOverride = Number(trustedHeader(request, config, "window")) || null
+  let resolved: number | null = null
+  if (needsWindow) resolved = await resolveWindow(body.model, request.headers, config.upstream)
+  return rewriteAsync({
     body,
     sessionId,
     config,
     transcript,
-    window,
+    window: windowOverride ?? config.window ?? resolved,
     mayCompact: !isCountTokens,
-    omittedBefore: trusted ? Number(request.headers.get(OMITTED_BEFORE_HEADER) ?? 0) : 0,
+    omittedBefore: Number(trustedHeader(request, config, "omitted-before") ?? 0),
   })
 }
 
+function saveRatio(threadKey: string, ratio: (previous: number | undefined) => number) {
+  const state = readState(threadKey)
+  state.ratio = ratio(state.ratio)
+  saveState(threadKey, state)
+}
+
 export async function handle(request: Request): Promise<Response> {
-  const config = loadConfig()
+  try {
+    return await route(request)
+  } catch (error) {
+    logRequest({ path: new URL(request.url).pathname, status: 502, action: "upstream-unreachable", error: clipped(String(error)) })
+    return Response.json({ type: "error", error: { type: "api_error", message: `eunoe could not reach the API: ${String(error)}` } }, { status: 502 })
+  }
+}
+
+async function route(request: Request): Promise<Response> {
+  const config = readConfig()
   const url = new URL(request.url)
-  if (url.pathname === HEALTH_PATH) return Response.json({ ok: true, version: VERSION, mode: config.mode, pid: process.pid } satisfies Health)
+  if (url.pathname === HEALTH_PATH) return Response.json({ ok: true, version: VERSION, mode: config.mode, pid: process.pid, startedAt } satisfies Health)
   const headers = new Headers(request.headers)
-  headers.delete("host")
-  headers.delete("content-length")
-  headers.delete("accept-encoding")
+  for (const name of ["host", "content-length", "accept-encoding"]) headers.delete(name)
 
-  let bodyText = request.method === "GET" || request.method === "HEAD" ? undefined : await request.text()
+  let givenText: string | undefined
+  if (request.method !== "GET" && request.method !== "HEAD") givenText = await request.text()
   const isMessages = request.method === "POST" && url.pathname.startsWith("/v1/messages")
   const isCountTokens = url.pathname.includes("count_tokens")
-  let note: Note = { action: "pass" }
-  let threadKey: string | null = null
-  let sentSize = 0
 
-  if (bodyText && isMessages) {
+  const build = async (): Promise<Outgoing> => {
+    const passthrough: Outgoing = { note: { action: "pass" }, threadKey: null, bodyText: givenText, sentSize: 0, givenSize: 0, fixedSize: 0, sent: null }
+    if (!givenText || !isMessages) return passthrough
     try {
-      const body = JSON.parse(bodyText) as Body
-      const result = await prepare(request, body, config, isCountTokens)
-      note = result.note
-      threadKey = result.threadKey
-      if (result.body !== body) bodyText = JSON.stringify(result.body)
-      sentSize = sizeOf(result.body)
+      const given = JSON.parse(givenText) as Body
+      const canonicalFile = trustedHeader(request, config, "canonical")
+      const canonical = canonicalFile ? applyCanonical(given, canonicalFile) : null
+      const result = await prepare(request, canonical?.body ?? given, config, isCountTokens)
+      const sentSize = sizeOf(result.body)
+      return {
+        note: canonical ? { ...result.note, canonical: canonical.status } : 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: [] }),
+        sent: config.eval ? { session: sessionIdOf(request.headers, given), ...contextFingerprint(result.body), given: contextFingerprint(given) } : null,
+      }
     } catch (error) {
-      note = { action: "error-passthrough", error: String(error) }
+      return { ...passthrough, note: { action: "error-passthrough", error: String(error) } }
     }
   }
+  const send = (body: string | undefined) => fetch(config.upstream + url.pathname + url.search, { method: request.method, headers, body })
 
-  const upstream = await fetch(config.upstream + url.pathname + url.search, { method: request.method, headers, body: bodyText })
+  let out = await build()
+  let upstream = await send(out.bodyText)
+  const errorResponse = (text: string) => new Response(text, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
 
-  if (upstream.status >= 400 && note.action !== "pass") {
+  if (upstream.status >= 400 && out.note.action !== "pass") {
     const errorText = await upstream.text()
-    logRequest({ path: url.pathname, status: upstream.status, thread: threadKey, ...note, error: errorText.slice(0, LOGGED_ERROR_CHARS) })
-    return new Response(errorText, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
+    const overflow = overflowTokens(errorText)
+    const logged = { path: url.pathname, status: upstream.status, thread: out.threadKey, ...out.note }
+    if (!overflow || !out.threadKey || out.sentSize === 0 || isCountTokens) {
+      logRequest({ ...logged, error: clipped(errorText) })
+      return errorResponse(errorText)
+    }
+    const sentSize = out.sentSize
+    saveRatio(out.threadKey, (previous) => Math.max(previous ?? 0, overflow / sentSize) * 1.1)
+    logRequest({ ...logged, overflow, error: clipped(errorText) })
+    out = await build()
+    out = { ...out, note: { ...out.note, healed: overflow } }
+    upstream = await send(out.bodyText)
+    if (upstream.status >= 400) {
+      const retryError = await upstream.text()
+      logRequest({ path: url.pathname, status: upstream.status, thread: out.threadKey, ...out.note, error: clipped(retryError) })
+      return errorResponse(retryError)
+    }
   }
 
+  const { note, threadKey, sentSize, givenSize, fixedSize, sent } = out
   const response = new Response(upstream.body, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
   if (note.action === "pass" || !isMessages || isCountTokens) {
-    if (note.action !== "pass") logRequest({ path: url.pathname, status: upstream.status, ...note })
+    if (note.action !== "pass" || sent) logRequest({ path: url.pathname, status: upstream.status, ...note, ...(sent && { context: sent }) })
     return response
   }
 
@@ -106,15 +181,15 @@ export async function handle(request: Request): Promise<Response> {
       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,
+      ...(sent && { context: sent }),
     })
-    if (threadKey && input > 0 && sentSize > 0) {
-      const state = loadState(threadKey)
-      state.ratio = input / sentSize
-      saveState(threadKey, state)
-    }
+    if (threadKey && input > 0 && sentSize > 0) saveRatio(threadKey, () => input / sentSize)
   })
 }
 
 export function serve(port: number) {
-  return Bun.serve({ port, hostname: "127.0.0.1", idleTimeout: IDLE_TIMEOUT_SECONDS, fetch: handle })
+  return Bun.serve({ port, hostname: "127.0.0.1", idleTimeout: 255, fetch: handle })
 }

package/src/proxy/sessions.ts

@@ -0,0 +1,64 @@
+import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from "node:fs"
+import type { Mode } from "../config"
+import { EUNOE_DIR, paths } from "../config/paths"
+
+interface SeenSession {
+  lastSeen: string
+  mode: Mode
+  cwd?: string
+}
+
+const HEAD_BYTES = 65_536
+
+let seen: Record<string, SeenSession> | null = null
+
+function readSeen(): Record<string, SeenSession> {
+  try {
+    return JSON.parse(readFileSync(paths.sessions, "utf8"))
+  } catch {
+    return {}
+  }
+}
+
+const newestFirst = (entries: Array<[string, SeenSession]>) => entries.sort(([, a], [, b]) => b.lastSeen.localeCompare(a.lastSeen))
+
+export function cwdOf(sessionFile: string): string | undefined {
+  try {
+    const fd = openSync(sessionFile, "r")
+    const buffer = Buffer.alloc(HEAD_BYTES)
+    const read = readSync(fd, buffer, 0, HEAD_BYTES, 0)
+    closeSync(fd)
+    return buffer
+      .subarray(0, read)
+      .toString("utf8")
+      .match(/"cwd":"((?:[^"\\]|\\.)*)"/)?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+export function titleOf(sessionFile: string): string | undefined {
+  try {
+    return readFileSync(sessionFile, "utf8").match(/"aiTitle":"((?:[^"\\]|\\.)*)"/)?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+export function recordSession(sessionId: string, mode: Mode, sessionFile: string | null) {
+  seen ??= readSeen()
+  const previous = seen[sessionId]
+  const now = Date.now()
+  const needsCwd = !previous?.cwd && sessionFile !== null
+  if (previous && previous.mode === mode && !needsCwd && now - Date.parse(previous.lastSeen) < 30_000) return
+  seen[sessionId] = { lastSeen: new Date(now).toISOString(), mode, cwd: previous?.cwd ?? (sessionFile ? cwdOf(sessionFile) : undefined) }
+  seen = Object.fromEntries(newestFirst(Object.entries(seen)).slice(0, 200))
+  try {
+    mkdirSync(EUNOE_DIR, { recursive: true })
+    writeFileSync(paths.sessions, JSON.stringify(seen, null, 2))
+  } catch {}
+}
+
+export function seenSessions(): Array<[string, SeenSession]> {
+  return newestFirst(Object.entries(readSeen()))
+}

package/src/proxy/state.ts

@@ -1,13 +1,27 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import path from "node:path"
-import { paths } from "../config/constants"
-import type { ThreadState } from "./types"
+import { paths } from "../config/paths"
+
+export interface Handoff {
+  label: string
+  source: string
+  text: string
+}
+
+export interface ThreadState {
+  handoffs?: Record<string, Handoff | null>
+  cut?: string
+  keep?: number
+  cleared?: number
+  ratio?: number
+  recalls?: Record<string, string>
+}
 
 function stateFile(key: string) {
   return path.join(paths.threads, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`)
 }
 
-export function loadState(key: string): ThreadState {
+export function readState(key: string): ThreadState {
   try {
     return JSON.parse(readFileSync(stateFile(key), "utf8"))
   } catch {