@chroxify/eunoe 1.0.0 → 1.2.0

package/src/cli/proxy/live.ts

@@ -0,0 +1,57 @@
+import { spawnSync } from "node:child_process"
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+import path from "node:path"
+
+export interface LiveSession {
+  pid: number
+  sessionId: string
+  cwd: string
+  startedAt: number
+  status: string
+  entrypoint: string
+}
+
+const isLiveSession = (value: Partial<LiveSession>): value is LiveSession => typeof value.pid === "number" && typeof value.sessionId === "string" && typeof value.startedAt === "number" && typeof value.status === "string"
+
+function runsClaude(pid: number) {
+  const result = spawnSync("ps", ["-o", "command=", "-p", String(pid)], { encoding: "utf8" })
+  return result.status === 0 && /claude/i.test(result.stdout)
+}
+
+export function listLiveSessions(configDirs: string[]): LiveSession[] {
+  const live: LiveSession[] = []
+  for (const dir of configDirs) {
+    const sessionsDir = path.join(dir, "sessions")
+    if (!existsSync(sessionsDir)) continue
+    for (const file of readdirSync(sessionsDir).filter((name) => /^\d+\.json$/.test(name))) {
+      try {
+        const session = JSON.parse(readFileSync(path.join(sessionsDir, file), "utf8"))
+        if (isLiveSession(session) && runsClaude(session.pid)) live.push(session)
+      } catch {}
+    }
+  }
+  return live
+}
+
+export function unroutedSessions(live: LiveSession[], lastSeen: Map<string, string>, managed: (sessionId: string) => boolean, self: string | undefined): LiveSession[] {
+  return live.filter((session) => {
+    if (session.sessionId === self || !managed(session.sessionId)) return false
+    const seen = lastSeen.get(session.sessionId)
+    return !seen || Date.parse(seen) < session.startedAt
+  })
+}
+
+export const isIdle = (session: LiveSession) => session.status === "idle"
+
+export const isTerminal = (session: LiveSession) => session.entrypoint === "cli"
+
+export function restartSessions(sessions: LiveSession[]): LiveSession[] {
+  return sessions.filter((session) => {
+    try {
+      process.kill(session.pid, "SIGTERM")
+      return true
+    } catch {
+      return false
+    }
+  })
+}

package/src/cli/proxy/service.ts

@@ -0,0 +1,53 @@
+import { homedir } from "node:os"
+import path from "node:path"
+import type { Config } from "../../config"
+import { paths } from "../../config/paths"
+import type { Health } from "../../proxy/server"
+import { c, line, ok, warn } from "../terminal/ui"
+import { proxyUrl } from "./claude-settings"
+import { probe, runsStaleCode } from "./inspect"
+import * as launchd from "./launchd"
+
+const agentFor = (label: string, interval?: number): launchd.Agent => ({ label, plist: path.join(homedir(), "Library", "LaunchAgents", `${label}.plist`), interval })
+
+export const PROXY_AGENT = agentFor("com.chroxify.eunoe")
+const WATCH_AGENT = agentFor("com.chroxify.eunoe.watch", 10)
+
+const cli = () => path.resolve(process.argv[1] ?? "")
+
+async function waitFor(port: number, ready: (health: Health | null) => boolean) {
+  const deadline = Date.now() + 3_000
+  while (Date.now() < deadline) {
+    if (ready(await probe(port))) return true
+    await Bun.sleep(150)
+  }
+  return false
+}
+
+export async function startService(config: Config) {
+  if (!launchd.supported) {
+    if (await probe(config.port)) return true
+    warn("No launchd here, so keep the proxy running yourself:")
+    line(`    ${c.cyan("eunoe serve")}`)
+    return false
+  }
+  launchd.installAgent(PROXY_AGENT, [process.execPath, cli(), "serve"], paths.proxyLog)
+  launchd.installAgent(WATCH_AGENT, [process.execPath, cli(), "watch"], paths.proxyLog)
+  const running = await probe(config.port)
+  if (running && runsStaleCode(running)) {
+    launchd.restartAgent(PROXY_AGENT)
+    await waitFor(config.port, (health) => health !== null && health.pid !== running.pid)
+  }
+  if (await waitFor(config.port, (health) => health !== null)) {
+    ok(`Proxy running in the background on ${c.cyan(proxyUrl(config.port))}`)
+    return true
+  }
+  warn(`The proxy didn't answer on ${proxyUrl(config.port)}. Check ${paths.proxyLog}.`)
+  return false
+}
+
+export function removeService() {
+  const removed = launchd.removeAgent(PROXY_AGENT)
+  launchd.removeAgent(WATCH_AGENT)
+  return removed
+}

package/src/cli/{stats.ts → proxy/stats.ts}

@@ -1,8 +1,8 @@
-import { STATUS_WINDOW_MS } from "./constants"
-import type { RequestRecord } from "./types"
+import type { RequestRecord } from "./inspect"
 
 export interface SessionStats {
   context: number
+  fixed: number | null
   plain: number | null
   turns: number | null
   requests: number
@@ -21,13 +21,22 @@ export interface Totals {
   saved: number
 }
 
-const THREAD_SUFFIX = /-[0-9a-f]{24}$/
+const sessionOf = (record: RequestRecord): string | null => (typeof record.thread === "string" ? record.thread.replace(/-[0-9a-f]{24}$/, "") : null)
 
-export const sessionOf = (record: RequestRecord): string | null => (typeof record.thread === "string" ? record.thread.replace(THREAD_SUFFIX, "") : null)
+const inputOf = (record: RequestRecord) => record.input ?? 0
 
-const plainTokens = (record: RequestRecord): number | null => (record.charsIn > 0 && record.charsOut > 0 && record.input > 0 ? Math.round(record.input * record.charsIn / record.charsOut) : null)
+function scaled(record: RequestRecord, chars: number | undefined): number | null {
+  const input = inputOf(record)
+  const charsOut = record.charsOut ?? 0
+  return input > 0 && charsOut > 0 && chars && chars > 0 ? Math.round((input * chars) / charsOut) : null
+}
+
+export function savedTokens(record: RequestRecord): number | null {
+  const plain = scaled(record, record.charsIn)
+  return plain === null ? null : plain - inputOf(record)
+}
 
-export function withinWindow(records: RequestRecord[], now = Date.now(), window = STATUS_WINDOW_MS): RequestRecord[] {
+export function withinWindow(records: RequestRecord[], now = Date.now(), window = 24 * 3_600_000): RequestRecord[] {
   return records.filter((record) => now - Date.parse(record.ts) <= window)
 }
 
@@ -35,12 +44,13 @@ export function perSession(records: RequestRecord[]): Map<string, SessionStats>
   const stats = new Map<string, SessionStats>()
   for (const record of records) {
     const id = sessionOf(record)
-    if (!id || !(record.input > 0)) continue
+    if (!id || inputOf(record) <= 0) continue
     const previous = stats.get(id)
     stats.set(id, {
-      context: record.input,
-      plain: plainTokens(record),
-      turns: typeof record.turns === "number" ? record.turns : previous?.turns ?? null,
+      context: inputOf(record),
+      fixed: scaled(record, record.charsFixed),
+      plain: scaled(record, record.charsIn),
+      turns: record.turns ?? previous?.turns ?? null,
       requests: (previous?.requests ?? 0) + 1,
       folds: (previous?.folds ?? 0) + (record.compacted ? 1 : 0),
       lastSeen: record.ts,
@@ -52,7 +62,7 @@ export function perSession(records: RequestRecord[]): Map<string, SessionStats>
 export function totals(records: RequestRecord[]): Totals {
   const out: Totals = { requests: 0, cacheRead: 0, cacheWrite: 0, uncached: 0, folds: 0, lastFold: null, sent: 0, saved: 0 }
   for (const record of records) {
-    if (!(record.input > 0)) continue
+    if (inputOf(record) <= 0) continue
     out.requests += 1
     out.cacheRead += record.cacheRead ?? 0
     out.cacheWrite += record.cacheWrite ?? 0
@@ -61,13 +71,16 @@ export function totals(records: RequestRecord[]): Totals {
       out.folds += 1
       out.lastFold = record.ts
     }
-    const plain = plainTokens(record)
-    if (plain !== null) {
-      out.sent += record.input
-      out.saved += plain - record.input
+    const saved = savedTokens(record)
+    if (saved !== null) {
+      out.sent += inputOf(record)
+      out.saved += saved
     }
   }
   return out
 }
 
-export const savedShare = (context: number, plain: number | null): number | null => (plain && plain > context ? 1 - context / plain : plain ? 0 : null)
+export function savedShare(context: number, plain: number | null): number | null {
+  if (!plain) return null
+  return plain > context ? 1 - context / plain : 0
+}

package/src/cli/proxy/watch.ts

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"
+import { type Config, claudeConfigDirs, compactionOwner } from "../../config"
+import { paths } from "../../config/paths"
+import { editSettings, withEunoe, withoutEunoe } from "./claude-settings"
+import { probe, routedDirs } from "./inspect"
+
+interface Watch {
+  misses: number
+  paused: string[]
+  pausedAt?: string
+}
+
+interface WatchStep {
+  watch: Watch
+  pause: string[]
+  resume: string[]
+}
+
+export const WATCH_MISSES = 2
+
+const idle = (): Watch => ({ misses: 0, paused: [] })
+
+export function readWatch(): Watch {
+  try {
+    return { ...idle(), ...JSON.parse(readFileSync(paths.watch, "utf8")) }
+  } catch {
+    return idle()
+  }
+}
+
+function saveWatch(watch: Watch) {
+  if (watch.misses === 0 && watch.paused.length === 0) {
+    if (existsSync(paths.watch)) unlinkSync(paths.watch)
+    return
+  }
+  writeFileSync(paths.watch, `${JSON.stringify(watch, null, 2)}\n`)
+}
+
+export function clearWatch() {
+  saveWatch(idle())
+}
+
+export function nextWatch(watch: Watch, alive: boolean, routed: string[], now: string): WatchStep {
+  if (alive) return { watch: idle(), pause: [], resume: watch.paused }
+  if (routed.length === 0) return { watch: { ...watch, misses: 0 }, pause: [], resume: [] }
+  const misses = watch.misses + 1
+  if (misses < WATCH_MISSES) return { watch: { ...watch, misses }, pause: [], resume: [] }
+  return { watch: { misses: 0, paused: [...new Set([...watch.paused, ...routed])], pausedAt: now }, pause: routed, resume: [] }
+}
+
+export async function runWatch(config: Config): Promise<WatchStep> {
+  const alive = (await probe(config.port)) !== null
+  const step = nextWatch(readWatch(), alive, routedDirs(config), new Date().toISOString())
+  if (step.pause.length > 0) editSettings(step.pause, (settings) => withoutEunoe(settings, config.port))
+  const managed = claudeConfigDirs(config)
+  const resumed = step.resume.filter((dir) => managed.includes(dir))
+  if (resumed.length > 0) editSettings(resumed, (settings) => withEunoe(settings, config.port, compactionOwner(config)))
+  saveWatch(step.watch)
+  return step
+}

package/src/cli/replay/index.ts

@@ -0,0 +1,146 @@
+import type { Config } from "../../config"
+import type { Body, Message } from "../../context/content"
+import { isPrompt, type ReduceOptions, reduceTurn, splitTurns, turnFingerprint } from "../../context/fold/turns"
+import { compact } from "../../proxy/compaction"
+import { DEFAULT_RATIO, sizeOf } from "../../proxy/estimate"
+import type { ThreadState } from "../../proxy/state"
+
+export interface ReplayOptions {
+  config: Config
+  window: number
+  fixedTokens: number
+  recallChars?: number
+}
+
+export interface Replay {
+  requests: number
+  turns: number
+  folds: number
+  dropped: number
+  nativeCompactions: number
+  discarded: number
+  plainTokens: number
+  eunoeTokens: number
+  plainCost: number
+  eunoeCost: number
+  peakPlain: number
+  peakEunoe: number
+}
+
+export interface ReplayedSession extends Replay {
+  id: string
+  file: string
+  bytes: number
+  cwd: string | null
+  title: string | null
+  ms: number
+}
+
+export interface ReplayFailure {
+  file: string
+  error: string
+}
+
+export const REPLAY_NATIVE_COMPACT_AT = 0.92
+
+const NATIVE_SUMMARY_CHARS = 30_000
+const CACHE_READ_WEIGHT = 0.1
+const CACHE_WRITE_WEIGHT = 1.25
+
+const emptyChars = sizeOf({ system: "", tools: [], messages: [] })
+const charsOf = (message: Message) => sizeOf({ system: "", tools: [], messages: [message] }) - emptyChars
+const listChars = (sum: number, count: number) => sum + Math.max(0, count - 1)
+const tokens = (chars: number) => Math.round(chars * DEFAULT_RATIO)
+
+function commonPrefix(a: Message[], b: Message[]): number {
+  let chars = 0
+  for (let i = 0; i < Math.min(a.length, b.length); i += 1) {
+    if (a[i] !== b[i] && JSON.stringify(a[i]) !== JSON.stringify(b[i])) break
+    chars += charsOf(a[i]) + 1
+  }
+  return chars
+}
+
+export function replaySession(messages: Message[], { config, window, fixedTokens, recallChars: recallPerPrompt = 3_500 }: ReplayOptions): Replay {
+  const out: Replay = { requests: 0, turns: 0, folds: 0, dropped: 0, nativeCompactions: 0, discarded: 0, plainTokens: 0, eunoeTokens: 0, plainCost: 0, eunoeCost: 0, peakPlain: 0, peakEunoe: 0 }
+  const fixedChars = Math.round(fixedTokens / DEFAULT_RATIO)
+  const system = "x".repeat(fixedChars)
+  const sizes = messages.map(charsOf)
+  const { preamble, turns } = splitTurns(messages)
+  const turnAt = [...preamble.map(() => -1), ...turns.flatMap((turn, k) => turn.map(() => k))]
+  const limit = (config.compactAt * window) / DEFAULT_RATIO
+  const cost = (chars: number, cacheable: number) => {
+    const cached = Math.max(0, cacheable - fixedChars)
+    return CACHE_READ_WEIGHT * tokens(cached) + CACHE_WRITE_WEIGHT * tokens(chars - fixedChars - cached)
+  }
+  out.turns = turns.length
+
+  const reduced = new Map<string, Message[]>()
+  const reduce = (turn: Message[], options: ReduceOptions) => {
+    const key = `${turnFingerprint(turn)}:${turn.length}`
+    const hit = reduced.get(key) ?? reduceTurn(turn, options)
+    reduced.set(key, hit)
+    return hit
+  }
+
+  const state: ThreadState = {}
+  const eunoe = { sent: [] as Message[], sum: 0, count: 0, upTo: 0, recall: 0, compactedTurn: -2, previous: 0 }
+  const plain = { sum: 0, count: 0, since: 0, previous: 0 }
+
+  const sendEunoe = (i: number) => {
+    const turn = turnAt[i - 1]
+    const newTurn = turn !== eunoe.compactedTurn
+    if (newTurn && state.cut && isPrompt(messages[i - 1])) eunoe.recall += recallPerPrompt
+    for (; eunoe.upTo < i; eunoe.upTo += 1) {
+      eunoe.sum += sizes[eunoe.upTo]
+      eunoe.count += 1
+    }
+    let cacheable = eunoe.previous
+    if (newTurn || fixedChars + listChars(eunoe.sum, eunoe.count) + eunoe.recall > limit) {
+      const recall = eunoe.recall
+      const decorate = (ms: Message[]) => (recall ? [...ms, { role: "user", content: "r".repeat(recall) }] : ms)
+      const result = compact({ body: { system, tools: [], messages: messages.slice(0, i) } as Body, config, state, window, guide: null, mayCompact: true, reduce, decorate })
+      if (result.note.compacted) out.folds += 1
+      out.dropped = Math.max(out.dropped, Number(result.note.omitted ?? 0))
+      if (result.note.compacted || result.note.actions) cacheable = Math.min(eunoe.previous, fixedChars + commonPrefix(eunoe.sent, result.messages))
+      eunoe.sent = result.messages
+      eunoe.sum = eunoe.sent.reduce((sum, m) => sum + charsOf(m), 0)
+      eunoe.count = eunoe.sent.length
+      eunoe.compactedTurn = turn
+    }
+    const chars = fixedChars + listChars(eunoe.sum, eunoe.count) + eunoe.recall
+    out.eunoeTokens += tokens(chars - fixedChars)
+    out.peakEunoe = Math.max(out.peakEunoe, tokens(chars))
+    out.eunoeCost += cost(chars, cacheable)
+    eunoe.previous = chars
+  }
+
+  const sendPlain = (i: number) => {
+    for (; plain.since < i; plain.since += 1) {
+      plain.sum += sizes[plain.since]
+      plain.count += 1
+    }
+    let chars = fixedChars + listChars(plain.sum, plain.count)
+    let cacheable = plain.previous
+    out.peakPlain = Math.max(out.peakPlain, tokens(chars))
+    if (tokens(chars) > REPLAY_NATIVE_COMPACT_AT * window) {
+      out.nativeCompactions += 1
+      out.discarded += tokens(chars - fixedChars)
+      plain.sum = NATIVE_SUMMARY_CHARS
+      plain.count = 1
+      chars = fixedChars + listChars(plain.sum, plain.count)
+      cacheable = fixedChars
+    }
+    out.plainTokens += tokens(chars - fixedChars)
+    out.plainCost += cost(chars, cacheable)
+    plain.previous = chars
+  }
+
+  for (let i = 1; i < messages.length; i += 1) {
+    if (messages[i].role !== "assistant") continue
+    out.requests += 1
+    sendEunoe(i)
+    sendPlain(i)
+  }
+  return out
+}

package/src/cli/replay/worker.ts

@@ -0,0 +1,20 @@
+import { statSync } from "node:fs"
+import { basename } from "node:path"
+import { cwdOf, titleOf } from "../../proxy/sessions"
+import { sessionMessages } from "../../transcript/messages"
+import { type ReplayedSession, type ReplayFailure, type ReplayOptions, replaySession } from "."
+
+declare var self: Worker
+
+self.onmessage = (event: MessageEvent<{ file: string; options: ReplayOptions }>) => {
+  const { file, options } = event.data
+  const started = performance.now()
+  try {
+    const replay = replaySession(sessionMessages(file), options)
+    const done: ReplayedSession = { ...replay, id: basename(file, ".jsonl"), file, bytes: statSync(file).size, cwd: cwdOf(file) ?? null, title: titleOf(file) ?? null, ms: Math.round(performance.now() - started) }
+    postMessage(done)
+  } catch (error) {
+    const failed: ReplayFailure = { file, error: String(error) }
+    postMessage(failed)
+  }
+}

package/src/cli/sessions/browse.ts

@@ -0,0 +1,88 @@
+import { clip } from "../../context/content"
+import { interact, keys, printable } from "../terminal/prompt"
+import { c, wrap } from "../terminal/ui"
+import { askOf, metaOf, shortId } from "."
+import { rankCandidates, type SessionCandidate } from "./source"
+
+export const UNTITLED = "untitled"
+
+const ROWS = 7
+
+const metas = new Map<string, string>()
+
+const columns = () => Math.max(60, process.stdout.columns ?? 100)
+
+function cachedMeta(cand: SessionCandidate) {
+  const meta = metas.get(cand.id) ?? metaOf(cand)
+  metas.set(cand.id, meta)
+  return meta
+}
+
+export function filterCandidates(query: string, candidates: SessionCandidate[]): SessionCandidate[] {
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean)
+  if (words.length === 0) return candidates
+  const ranked = rankCandidates(query, candidates)
+  const haystack = (cand: SessionCandidate) => `${cand.label} ${cand.asks.join(" ")} ${cand.id}`.toLowerCase()
+  const loose = candidates.filter((cand) => !ranked.includes(cand) && words.every((word) => haystack(cand).includes(word)))
+  return [...ranked, ...loose]
+}
+
+function row(cand: SessionCandidate, chosen: boolean, width: number): string[] {
+  const marker = chosen ? c.green("●") : c.dim("○")
+  const info = cachedMeta(cand)
+  const title = cand.label ? clip(cand.label, width - info.length - 16) : UNTITLED
+  const head = `  ${marker} ${c.cyan(shortId(cand.id))}  ${chosen ? c.bold(title) : cand.label ? title : c.dim(title)}  ${c.dim(info)}`
+  if (!chosen) return [head]
+  const lines = [head]
+  for (const [label, text] of [
+    ["first", cand.asks[0]],
+    ["last ", cand.asks.at(-1)],
+  ] as const) {
+    const [first = "", ...rest] = wrap(askOf(text), width - 14)
+    lines.push(`      ${c.dim(label)}  ${first}`, ...rest.map((more) => `             ${more}`))
+  }
+  return lines
+}
+
+function render(title: string, query: string, shown: SessionCandidate[], total: number, index: number, help: string): string[] {
+  const width = columns()
+  const lines = [`  ${c.bold(title)}  ${c.dim(`${shown.length} of ${total}`)}`, `  ${c.cyan("›")} ${query || c.dim("type to filter")}`, ""]
+  if (shown.length === 0) lines.push(`  ${c.dim("nothing matches")}`)
+  const start = Math.max(0, Math.min(index - Math.floor(ROWS / 2), shown.length - ROWS))
+  if (start > 0) lines.push(`  ${c.dim(`↑ ${start} more`)}`)
+  for (const [i, cand] of shown.slice(start, start + ROWS).entries()) lines.push(...row(cand, start + i === index, width))
+  if (start + ROWS < shown.length) lines.push(`  ${c.dim(`↓ ${shown.length - start - ROWS} more`)}`)
+  lines.push("", `  ${c.dim(help)}`)
+  return lines
+}
+
+export async function browse(title: string, candidates: SessionCandidate[], initial = "", help = "↑↓ move · type to filter · enter choose · esc quit"): Promise<SessionCandidate | null> {
+  let query = initial
+  let shown = filterCandidates(query, candidates)
+  let index = 0
+  let chosen: SessionCandidate | null = null
+  const step = (by: number) => {
+    index = shown.length > 0 ? (index + shown.length + by) % shown.length : 0
+  }
+  await interact(
+    () => render(title, query, shown, candidates.length, index, help),
+    (key) => {
+      if (key === keys.up || key === keys.down) {
+        step(key === keys.up ? -1 : 1)
+        return
+      }
+      if (keys.enter.includes(key)) {
+        chosen = shown[index] ?? null
+        return true
+      }
+      if (keys.escape.includes(key)) return true
+      if (keys.backspace.includes(key)) query = query.slice(0, -1)
+      else if (key === keys.clear) query = ""
+      else if (printable(key)) query += key
+      else return
+      shown = filterCandidates(query, candidates)
+      index = 0
+    },
+  )
+  return chosen
+}

package/src/cli/sessions/index.ts

@@ -0,0 +1,76 @@
+import { spawnSync } from "node:child_process"
+import { claudeConfigDirs, readConfig } from "../../config"
+import { FOLD_CAP_CHARS, foldedView, sourceChunks } from "../../context/fold"
+import { recallFor } from "../../context/recall"
+import { DEFAULT_RATIO } from "../../proxy/estimate"
+import { continueToken } from "../../proxy/handoff"
+import { seenSessions } from "../../proxy/sessions"
+import { isSessionId } from "../../transcript/locate"
+import { subagentChunks } from "../../transcript/subagents"
+import { flagValues } from "../terminal/args"
+import { ago, fail, tokens } from "../terminal/ui"
+import { type SessionCandidate, sessionCandidates } from "./source"
+
+const ASK_CHARS = 160
+
+export const shortId = (sessionId: string) => sessionId.slice(0, 8)
+
+function byPrefix<T>(input: string, items: T[], idOf: (item: T) => string): T | null {
+  if (!isSessionId(input)) fail(`Not a session id: ${input}`)
+  const exact = items.find((item) => idOf(item) === input)
+  if (exact) return exact
+  const matches = items.filter((item) => idOf(item).startsWith(input))
+  if (matches.length > 1) fail(`${input} matches ${matches.length} sessions`, "Use more of the id.")
+  return matches[0] ?? null
+}
+
+export function sessionArgs(args: string[]): string[] {
+  const seen = seenSessions().map(([id]) => id)
+  return [...new Set(flagValues(args, "--session").map((input) => byPrefix(input, seen, (id) => id) ?? input))]
+}
+
+export function isKnown(sessionId: string) {
+  return seenSessions().some(([id]) => id === sessionId)
+}
+
+export const candidatesHere = () => sessionCandidates(process.env.CLAUDE_CODE_SESSION_ID ?? "", process.cwd(), claudeConfigDirs(readConfig()))
+
+export function candidateOf(input: string | undefined, candidates: SessionCandidate[]): SessionCandidate {
+  if (!input) fail("Say which session: eunoe sessions lists them.")
+  return byPrefix(input, candidates, (cand) => cand.id) ?? fail(`No earlier session ${input} in this directory.`, "eunoe sessions lists them.")
+}
+
+const tokensOf = (cand: SessionCandidate) => tokens(Math.round(foldedView(cand.messages, FOLD_CAP_CHARS).length * DEFAULT_RATIO))
+
+export const titleOf = (cand: SessionCandidate) => cand.label || shortId(cand.id)
+
+export const metaOf = (cand: SessionCandidate) => `${cand.asks.length} turns · ~${tokensOf(cand)} tokens · ${ago(new Date(cand.mtime).toISOString())}`
+
+export function askOf(text: string | undefined): string {
+  const flat = (text ?? "").replace(/\s+/g, " ").trim()
+  if (flat.length <= ASK_CHARS) return flat
+  const cut = flat.slice(0, ASK_CHARS)
+  return `${cut.slice(0, Math.max(cut.lastIndexOf(" "), ASK_CHARS / 2))}…`
+}
+
+export const continuePrompt = (id: string) => continueToken(shortId(id))
+
+export function copy(text: string): boolean {
+  const clipboards: Array<[string, string[]]> = [
+    ["pbcopy", []],
+    ["wl-copy", []],
+    ["xclip", ["-selection", "clipboard"]],
+  ]
+  return clipboards.some(([cmd, args]) => {
+    const result = spawnSync(cmd, args, { input: text })
+    return !result.error && result.status === 0
+  })
+}
+
+export function peekText(cand: SessionCandidate, words: string): string | null {
+  const chunks = [...sourceChunks(cand.messages, titleOf(cand), true), ...subagentChunks(cand.file)]
+  const found = recallFor(words, chunks, { maxChars: 12_000, maxCharsMulti: 12_000, perQuery: 6, minTerms: 1 })
+  if (!found) return null
+  const excerpts = found.replace(/^<recalled-context>\n[^\n]*\n\n|\n<\/recalled-context>$/g, "")
+  return `Excerpts of session ${shortId(cand.id)} "${titleOf(cand)}" that match "${words}", quoted exactly, oldest first:\n\n${excerpts}`
+}

package/src/cli/sessions/source.ts

@@ -0,0 +1,74 @@
+import { statSync } from "node:fs"
+import path from "node:path"
+import { type Message, textOf } from "../../context/content"
+import { isPrompt, splitTurns } from "../../context/fold/turns"
+import { type RecallChunk, rank, terms } from "../../context/recall"
+import { cwdOf, seenSessions, titleOf } from "../../proxy/sessions"
+import { findSessionFile, listEntries, projectFolderName } from "../../transcript/locate"
+import { sessionMessages } from "../../transcript/messages"
+
+export interface SessionCandidate {
+  id: string
+  file: string
+  label: string
+  mtime: number
+  asks: string[]
+  outline: string
+  messages: Message[]
+}
+
+export const SESSION_SOURCE_MIN_TURNS = 2
+export const SESSION_SOURCE_CANDIDATES = 12
+export const SESSION_MIN_TERMS = 2
+
+const promptText = (message: Message) =>
+  textOf(message)
+    .replace(/<[a-z-]+(?:\s[^>]*)?>[\s\S]*?<\/[a-z-]+>/g, "")
+    .trim()
+
+export function outlineOf(messages: Message[]): string[] {
+  return splitTurns(messages)
+    .turns.filter((turn) => isPrompt(turn[0]))
+    .map((turn) => promptText(turn[0]))
+    .filter(Boolean)
+    .map((text) => text.slice(0, 240))
+}
+
+function sessionFiles(sessionId: string, cwd: string, configDirs: string[]): Array<{ id: string; file: string; mtime: number }> {
+  const files = new Map<string, { file: string; mtime: number }>()
+  const add = (id: string, file: string) => {
+    if (id === sessionId || files.has(id)) return
+    try {
+      files.set(id, { file, mtime: statSync(file).mtimeMs })
+    } catch {}
+  }
+  for (const [id, seen] of seenSessions()) {
+    if (seen.cwd !== cwd) continue
+    const file = findSessionFile(id, configDirs)
+    if (file) add(id, file)
+  }
+  for (const dir of configDirs) {
+    const folder = path.join(dir, "projects", projectFolderName(cwd))
+    for (const name of listEntries(folder)) if (name.endsWith(".jsonl")) add(name.slice(0, -".jsonl".length), path.join(folder, name))
+  }
+  return [...files].map(([id, entry]) => ({ id, ...entry })).sort((a, b) => b.mtime - a.mtime)
+}
+
+export function sessionCandidates(sessionId: string, cwd: string, configDirs: string[]): SessionCandidate[] {
+  const out: SessionCandidate[] = []
+  for (const { id, file, mtime } of sessionFiles(sessionId, cwd, configDirs)) {
+    const recorded = cwdOf(file)
+    if (recorded && recorded !== cwd) continue
+    const messages = sessionMessages(file)
+    const asks = outlineOf(messages)
+    if (asks.length < SESSION_SOURCE_MIN_TURNS) continue
+    out.push({ id, file, label: titleOf(file) ?? "", mtime, asks, outline: asks.map((ask, i) => `${i + 1}. ${ask}`).join("\n"), messages })
+    if (out.length >= SESSION_SOURCE_CANDIDATES) break
+  }
+  return out
+}
+
+export function rankCandidates(prompt: string, candidates: SessionCandidate[]): SessionCandidate[] {
+  const chunks: RecallChunk[] = candidates.map((cand, i) => ({ turn: i, call: cand.id, lines: [cand.outline], terms: terms(cand.outline) }))
+  return rank(terms(prompt), chunks, SESSION_MIN_TERMS).map((r) => candidates[r.index])
+}