@chroxify/eunoe 1.0.0 → 1.1.0

package/src/cli/commands/sessions.ts

@@ -0,0 +1,70 @@
+import { readConfig } from "../../config"
+import type { Command } from "../command"
+import { routedDirs } from "../proxy/inspect"
+import { askOf, candidatesHere, continuePrompt, copy, metaOf, shortId } from "../sessions"
+import { browse, filterCandidates, UNTITLED } from "../sessions/browse"
+import type { SessionCandidate } from "../sessions/source"
+import { interactive } from "../terminal/prompt"
+import { c, fail, line, ok, warn, wrap } from "../terminal/ui"
+
+const INDENT = 6
+
+const askWidth = () => Math.max(40, Math.min(100, (process.stdout.columns ?? 100 + INDENT) - INDENT - 12))
+
+function ask(label: string, text: string | undefined) {
+  const [first = "", ...rest] = wrap(askOf(text), askWidth())
+  line(`${" ".repeat(INDENT)}${c.dim(label)}  ${first}`)
+  for (const more of rest) line(`${" ".repeat(INDENT + label.length + 2)}${more}`)
+}
+
+function show(cand: SessionCandidate) {
+  const title = cand.label ? c.bold(cand.label) : c.dim(UNTITLED)
+  line(`  ${c.cyan(shortId(cand.id))}  ${title}  ${c.dim(metaOf(cand))}`)
+  ask("first", cand.asks[0])
+  ask("last ", cand.asks.at(-1))
+  line()
+}
+
+function listSessions(words: string, candidates: SessionCandidate[]) {
+  const order = filterCandidates(words, candidates)
+  line()
+  line(`  ${c.dim(words ? `Earlier sessions here, closest to "${words}" first` : "Earlier sessions here, newest first")}`)
+  line()
+  for (const cand of order) show(cand)
+  if (order.length === 0) line(`  ${c.dim(`Nothing matches "${words}".`)}`)
+}
+
+function handOff(id: string) {
+  const prompt = continuePrompt(id)
+  line()
+  ok(`${c.bold(prompt)}  ${copy(prompt) ? c.dim("copied") : ""}`)
+  if (routedDirs(readConfig()).length === 0) warn("Claude Code isn't routed through eunoe, so the agent won't know to load it (eunoe start).")
+  line()
+}
+
+export const sessions: Command = {
+  summary: "Pick an earlier session for the agent to continue from",
+  usage: "eunoe sessions [words] [--list]",
+  details: [
+    "Browse this directory's earlier Claude Code sessions: type to filter, pick",
+    "one, and a {ee:continue:<id>} marker is copied. Paste it into any Claude Code",
+    "chat along with what you want done: eunoe attaches that whole session to the",
+    "message, and its dropped output stays searchable from then on. Words start",
+    "the filter.",
+    "",
+    "--list, or a pipe, prints the sessions newest first with each one's first",
+    "and last request. That is what the agent reads when it runs this itself.",
+  ],
+  options: [["--list", "Print the sessions instead of browsing them"]],
+  async run(args) {
+    const words = args
+      .filter((a) => !a.startsWith("-"))
+      .join(" ")
+      .trim()
+    const candidates = candidatesHere()
+    if (candidates.length === 0) fail("No earlier sessions in this directory.")
+    if (args.includes("--list") || !interactive) return listSessions(words, candidates)
+    const chosen = await browse("Earlier sessions here", candidates, words, "↑↓ move · type to filter · enter copy the marker · esc quit")
+    if (chosen) handOff(chosen.id)
+  },
+}

package/src/cli/commands/settings.ts

@@ -1,66 +1,95 @@
-import { loadConfig, overrides, parseTunable, saveConfig } from "../../config"
-import { DEFAULTS, TUNABLES } from "../../config/constants"
-import type { Tunable } from "../../config/types"
-import { TUNABLE_DESCRIPTIONS, TUNABLE_HINTS } from "../constants"
-import { input, interactive, select } from "../prompt"
+import { DEFAULTS, overrides, parseTunable, readConfig, saveConfig, TUNABLES, type Tunable } from "../../config"
+import type { Command } from "../command"
 import { sessionArgs, shortId } from "../sessions"
-import type { Command } from "../types"
-import { c, fail, line, ok, rows } from "../ui"
+import { input, interactive, select } from "../terminal/prompt"
+import { c, fail, line, ok, rows } from "../terminal/ui"
+
+const DESCRIPTIONS: Record<Tunable, string> = {
+  keep: "Turns kept whole at the end, in default mode",
+  budget: "Tokens of older detail that trigger a fold, in default mode",
+  turnCap: "A kept turn larger than this many tokens is folded at once, live turn excepted; or off",
+  compactAt: "Share of the context window that triggers the cut",
+  keepTurns: "Earlier turns kept after a cut",
+  search: "How transcripts are written for the agent to search",
+  rerank: "Typesafe model that reorders recall, or off",
+}
+
+const HINTS: Record<Tunable, string> = {
+  keep: "a whole number, 1 or more",
+  budget: "a token count, 1000 or more",
+  turnCap: "a token count, 1000 or more, or off",
+  compactAt: "a number above 0, up to 1",
+  keepTurns: "a whole number or all",
+  search: "markdown, xml, jsonl or qmd",
+  rerank: "a model name such as jev-preview, or off",
+}
 
 const RESET = "default"
 
+const forSessions = (ids: string[]) => ids.map(shortId).join(", ")
+
 function listSettings() {
-  const config = loadConfig()
+  const config = readConfig()
   line()
   const width = Math.max(...TUNABLES.map((name) => String(config[name]).length))
-  rows(TUNABLES.map((name) => {
-    const value = String(config[name])
-    const changed = config[name] !== DEFAULTS[name]
-    return [name, `${c.bold(value.padEnd(width))}  ${c.dim(TUNABLE_DESCRIPTIONS[name])}${changed ? c.dim(`  (default ${DEFAULTS[name]})`) : ""}`]
-  }))
-  const own = Object.entries(config.sessions).map(([id, settings]) => [id, overrides(settings)] as const).filter(([, values]) => Object.keys(values).length)
-  if (own.length) {
+  rows(
+    TUNABLES.map((name) => {
+      const changed = config[name] !== DEFAULTS[name]
+      return [name, `${c.bold(String(config[name]).padEnd(width))}  ${c.dim(DESCRIPTIONS[name])}${changed ? c.dim(`  (default ${DEFAULTS[name]})`) : ""}`]
+    }),
+  )
+  const own = Object.entries(config.sessions)
+    .map(([id, session]) => [id, overrides(session)] as const)
+    .filter(([, values]) => Object.keys(values).length > 0)
+  if (own.length > 0) {
     line()
-    for (const [id, values] of own) line(`  ${c.cyan(shortId(id))}  ${Object.entries(values).map(([name, value]) => `${name} ${c.bold(String(value))}`).join(c.dim("  ·  "))}`)
+    for (const [id, values] of own) {
+      const shown = Object.entries(values).map(([name, value]) => `${name} ${c.bold(String(value))}`)
+      line(`  ${c.cyan(shortId(id))}  ${shown.join(c.dim("  ·  "))}`)
+    }
   }
   line()
 }
 
-function applySetting(name: Tunable, raw: string, ids: string[]) {
-  const config = loadConfig()
-  if (raw === RESET) {
-    if (!ids.length) fail(`\`${RESET}\` only applies with --session`, `eunoe settings set ${name} ${RESET} --session <id>`)
-    const sessions = { ...config.sessions }
-    for (const id of ids) {
-      if (!sessions[id]) continue
-      const { [name]: _, ...rest } = sessions[id]
-      sessions[id] = rest
-    }
-    saveConfig({ sessions })
-    ok(`${name} back to the default (${c.bold(String(config[name]))}) for ${ids.map(shortId).join(", ")}`)
-    return
+function resetSetting(name: Tunable, ids: string[]) {
+  const config = readConfig()
+  if (ids.length === 0) fail(`\`${RESET}\` only applies with --session`, `eunoe settings set ${name} ${RESET} --session <id>`)
+  const sessions = { ...config.sessions }
+  for (const id of ids) {
+    if (!sessions[id]) continue
+    const { [name]: _, ...rest } = sessions[id]
+    sessions[id] = rest
   }
+  saveConfig({ sessions })
+  ok(`${name} back to the default (${c.bold(String(config[name]))}) for ${forSessions(ids)}`)
+}
+
+function applySetting(name: Tunable, raw: string, ids: string[]) {
+  if (raw === RESET) return resetSetting(name, ids)
+  const config = readConfig()
   const value = parseTunable(name, raw)
-  if (value === null) fail(`Not a valid ${name}: ${raw}`, `Expected ${TUNABLE_HINTS[name]}.`)
-  if (ids.length) {
-    saveConfig({ sessions: { ...config.sessions, ...Object.fromEntries(ids.map((id) => [id, { ...config.sessions[id], [name]: value }])) } })
-    ok(`${name} ${c.bold(String(value))} for ${ids.map(shortId).join(", ")}`)
-    if (config.scope === "sessions" && ids.some((id) => !config.sessions[id])) line(`  ${c.dim("eunoe only manages sessions you started it for: eunoe start --session <id>")}`)
+  if (value === null) fail(`Not a valid ${name}: ${raw}`, `Expected ${HINTS[name]}.`)
+  if (ids.length === 0) {
+    saveConfig({ [name]: value })
+    ok(`${name} ${c.bold(String(value))}`)
     return
   }
-  saveConfig({ [name]: value })
-  ok(`${name} ${c.bold(String(value))}`)
+  saveConfig({ sessions: { ...config.sessions, ...Object.fromEntries(ids.map((id) => [id, { ...config.sessions[id], [name]: value }])) } })
+  ok(`${name} ${c.bold(String(value))} for ${forSessions(ids)}`)
+  if (config.scope === "sessions" && ids.some((id) => !config.sessions[id])) line(`  ${c.dim("eunoe only manages sessions you started it for: eunoe start --session <id>")}`)
 }
 
 async function pickSetting(ids: string[]) {
-  const config = loadConfig()
+  const config = readConfig()
   line()
-  const name = await select<Tunable>(ids.length ? `Setting for ${ids.map(shortId).join(", ")}` : "Setting", TUNABLES.map((value) => ({ value, hint: `${String(config[value]).padEnd(12)} ${TUNABLE_DESCRIPTIONS[value]}` })))
+  const name = await select<Tunable>(
+    ids.length > 0 ? `Setting for ${forSessions(ids)}` : "Setting",
+    TUNABLES.map((value) => ({ value, hint: `${String(config[value]).padEnd(12)} ${DESCRIPTIONS[value]}` })),
+  )
   if (name === null) return
-  const current = ids.length === 1 ? config.sessions[ids[0]]?.[name] ?? config[name] : config[name]
-  const raw = await input(`${name}  ${c.dim(TUNABLE_HINTS[name])}`, `${current}  (current)`)
-  if (raw === null || raw === "") return
-  applySetting(name, raw, ids)
+  const current = ids.length === 1 ? (config.sessions[ids[0]]?.[name] ?? config[name]) : config[name]
+  const raw = await input(`${name}  ${c.dim(HINTS[name])}`, `${current}  (current)`)
+  if (raw) applySetting(name, raw, ids)
 }
 
 export const settings: Command = {
@@ -68,33 +97,23 @@ export const settings: Command = {
   usage: "eunoe settings [list | set <key> <value>] [--session <id>]",
   details: [
     "Without arguments it opens a picker. Keys:",
-    ...TUNABLES.map((key) => `  ${key.padEnd(10)} ${TUNABLE_DESCRIPTIONS[key]} ${c.dim(`(${TUNABLE_HINTS[key]})`)}`),
+    ...TUNABLES.map((key) => `  ${key.padEnd(10)} ${DESCRIPTIONS[key]} ${c.dim(`(${HINTS[key]})`)}`),
     "",
     `With --session, the value applies to that session only; \`${RESET}\` removes its own value.`,
     "Takes effect on the next request; no restart needed.",
   ],
   options: [["--session <id>", "Change it for just this session (repeatable; a unique prefix is enough)"]],
-  async run(args) {
-    const words = args.filter((arg, i) => !arg.startsWith("-") && args[i - 1] !== "--session")
+  run(args) {
+    const [verb, key, raw] = args.filter((arg, i) => !arg.startsWith("-") && args[i - 1] !== "--session")
     const ids = sessionArgs(args)
-    const [verb, key, raw] = words
-    if (!verb) {
-      if (interactive) await pickSetting(ids)
-      else listSettings()
-      return
-    }
-    if (verb === "list") {
-      listSettings()
-      return
-    }
-    if (verb !== "set") fail(`Unknown subcommand: ${verb}`, "Use `eunoe settings list` or `eunoe settings set <key> <value>`.")
+    if (verb === "list" || (!verb && !interactive)) return listSettings()
+    if (verb && verb !== "set") fail(`Unknown subcommand: ${verb}`, "Use `eunoe settings list` or `eunoe settings set <key> <value>`.")
     if (!key) {
-      if (interactive) await pickSetting(ids)
-      else fail("set needs a key and a value", "eunoe settings set <key> <value>")
-      return
+      if (!interactive) fail("set needs a key and a value", "eunoe settings set <key> <value>")
+      return pickSetting(ids)
     }
     if (!TUNABLES.includes(key as Tunable)) fail(`Unknown setting: ${key}`, `Choose ${TUNABLES.join(", ")}.`)
-    if (raw === undefined) fail(`${key} needs a value`, `eunoe settings set ${key} <${TUNABLE_HINTS[key as Tunable]}>`)
+    if (raw === undefined) fail(`${key} needs a value`, `eunoe settings set ${key} <${HINTS[key as Tunable]}>`)
     applySetting(key as Tunable, raw, ids)
   },
 }

package/src/cli/commands/start.ts

@@ -1,18 +1,18 @@
 import { existsSync } from "node:fs"
 import path from "node:path"
-import { claudeConfigDirs, compactionOwner, loadConfig, saveConfig } from "../../config"
-import type { Config } from "../../config/types"
-import { flagValues } from "../args"
-import { editSettings, withEunoe } from "../claude-settings"
-import { MODE_DESCRIPTIONS } from "../constants"
-import { routedDirs } from "../inspect"
-import { startService } from "../service"
+import { type Config, claudeConfigDirs, compactionOwner, readConfig, saveConfig } from "../../config"
+import type { Command } from "../command"
+import { editSettings, withEunoe } from "../proxy/claude-settings"
+import { routedDirs } from "../proxy/inspect"
+import { startService } from "../proxy/service"
+import { clearWatch } from "../proxy/watch"
 import { isKnown, sessionArgs, shortId } from "../sessions"
-import type { Command } from "../types"
-import { c, fail, line, listFiles, note, ok, rows, tilde } from "../ui"
+import { flagValues } from "../terminal/args"
+import { c, fail, line, listFiles, note, ok, rows, tilde } from "../terminal/ui"
+import { MODE_DESCRIPTIONS } from "./mode"
 
 function scoped(config: Config, ids: string[]): Partial<Config> {
-  if (!ids.length) return { scope: "all" }
+  if (ids.length === 0) return { scope: "all" }
   const managingAll = config.scope === "all" && routedDirs(config).length > 0
   const sessions = { ...config.sessions }
   for (const id of ids) {
@@ -22,6 +22,14 @@ function scoped(config: Config, ids: string[]): Partial<Config> {
   return { scope: managingAll ? "all" : "sessions", sessions }
 }
 
+function managedSessions(config: Config): string {
+  if (config.scope === "all") return "all"
+  const ids = Object.entries(config.sessions)
+    .filter(([, own]) => own.mode !== "off")
+    .map(([id]) => shortId(id))
+  return `only ${ids.join(", ")}`
+}
+
 export const start: Command = {
   summary: "Route Claude Code through eunoe",
   usage: "eunoe start [--session <id>] [--config-dir <dir>]",
@@ -40,25 +48,26 @@ export const start: Command = {
   async run(args) {
     const added = flagValues(args, "--config-dir").map((dir) => path.resolve(dir))
     for (const dir of added) if (!existsSync(dir)) fail(`No such directory: ${tilde(dir)}`)
-    if (added.length) saveConfig({ claudeConfigDirs: [...new Set([...loadConfig().claudeConfigDirs, ...added])] })
+    if (added.length > 0) saveConfig({ claudeConfigDirs: [...new Set([...readConfig().claudeConfigDirs, ...added])] })
     const ids = sessionArgs(args)
-    saveConfig(scoped(loadConfig(), ids))
-    const config = loadConfig()
+    saveConfig(scoped(readConfig(), ids))
+    const config = readConfig()
 
     line()
-    await startService(config)
+    if (!(await startService(config))) fail("Claude Code was left alone because the proxy isn't up.", "Nothing is routed through a proxy that can't answer. Fix the proxy and run `eunoe start` again.")
+    clearWatch()
     const touched = editSettings(claudeConfigDirs(config), (settings) => withEunoe(settings, config.port, compactionOwner(config)))
     ok("Claude Code routed through eunoe")
-    listFiles(touched.length ? touched : routedDirs(config).map((dir) => path.join(dir, "settings.json")))
+    listFiles(touched.length > 0 ? touched : routedDirs(config).map((dir) => path.join(dir, "settings.json")))
     line()
     rows([
       ["Mode", `${c.bold(config.mode)}  ${c.dim(MODE_DESCRIPTIONS[config.mode])}`],
-      ["Sessions", config.scope === "all" ? "all" : `only ${Object.entries(config.sessions).filter(([, own]) => own.mode !== "off").map(([id]) => shortId(id)).join(", ")}`],
+      ["Sessions", managedSessions(config)],
     ])
     line()
     const unseen = ids.filter((id) => !isKnown(id))
-    if (unseen.length) note(`Not seen through eunoe yet: ${unseen.map(shortId).join(", ")}. It applies once that session's requests come through; one started before routing needs a restart.`)
-    else note(ids.length ? "Takes effect on the session's next request." : "New sessions go through eunoe. Restart any that are already running.")
+    if (unseen.length > 0) note(`Not seen through eunoe yet: ${unseen.map(shortId).join(", ")}. It applies once that session's requests come through; one started before routing needs a restart.`)
+    else note(ids.length > 0 ? "Takes effect on the session's next request." : "New sessions go through eunoe. Restart any that are already running.")
     line()
   },
 }

package/src/cli/commands/status.ts

@@ -1,82 +1,125 @@
 import path from "node:path"
-import { loadConfig, modeFor, overrides } from "../../config"
-import { paths, RERANK_OFF } from "../../config/constants"
-import { rerankKey } from "../../context/rerank"
+import { type Config, modeFor, overrides, readConfig } from "../../config"
+import { paths } from "../../config/paths"
+import { rerankKey } from "../../context/recall/rerank"
+import type { Health } from "../../proxy/server"
 import { seenSessions } from "../../proxy/sessions"
 import { VERSION } from "../../version"
-import { proxyUrl } from "../claude-settings"
-import { MODE_DESCRIPTIONS, SESSIONS_SHOWN } from "../constants"
-import { probe, recentRequests, routedDirs } from "../inspect"
-import * as launchd from "../launchd"
+import type { Command } from "../command"
+import { BLOCKING_LIMIT_ENV, proxyUrl, readSettings } from "../proxy/claude-settings"
+import { probe, RECENT_REQUESTS, type RequestRecord, recentRequests, routedDirs, runsStaleCode } from "../proxy/inspect"
+import * as launchd from "../proxy/launchd"
+import { PROXY_AGENT } from "../proxy/service"
+import { perSession, type SessionStats, savedShare, type Totals, totals, withinWindow } from "../proxy/stats"
+import { readWatch } from "../proxy/watch"
 import { shortId } from "../sessions"
-import { perSession, savedShare, totals, withinWindow } from "../stats"
-import type { Command } from "../types"
-import { ago, c, line, percent, rows, table, tilde, tokens, warn } from "../ui"
+import { ago, c, line, percent, plural, rows, table, tilde, tokens, warn } from "../terminal/ui"
+import { MODE_DESCRIPTIONS } from "./mode"
 
 const dot = (on: boolean) => (on ? c.green("●") : c.red("○"))
 
+const settingsFiles = (dirs: string[]) => dirs.map((dir) => tilde(path.join(dir, "settings.json"))).join(", ")
+
+function summary(title: string, sum: Totals) {
+  const hit = sum.cacheRead + sum.cacheWrite + sum.uncached
+  const folds = sum.folds && sum.lastFold ? `  ${c.dim(`${plural(sum.folds, "fold")}, last ${ago(sum.lastFold)}`)}` : ""
+  const hitRate = hit ? c.dim(`  (${percent(sum.cacheRead / hit)} hit)`) : ""
+  const saved = sum.saved > 0 ? `${c.bold(c.green(tokens(sum.saved)))} input tokens not sent  ${c.dim(`(${percent(sum.saved / (sum.sent + sum.saved))} less than plain Claude Code)`)}` : c.dim("no data yet")
+  line()
+  line(`  ${title}`)
+  rows(
+    [
+      ["Requests", `${c.bold(String(sum.requests))}${folds}`],
+      ["Cache", `${c.bold(tokens(sum.cacheRead))} read  ${c.dim("·")}  ${tokens(sum.cacheWrite)} written  ${c.dim("·")}  ${tokens(sum.uncached)} uncached${hitRate}`],
+      ["Saved", saved],
+    ],
+    4,
+  )
+}
+
+function recallLine(config: Config, recent: RequestRecord[]) {
+  if (config.rerank === "off") return "bm25"
+  if (!rerankKey()) return `bm25  ${c.dim(`(${config.rerank} needs a key in ${tilde(paths.typesafeKey)} or TYPESAFE_API_KEY)`)}`
+  const last = recent.findLast((r) => r.reranked || r.rerankError)
+  if (last?.rerankError) return `bm25  ${c.yellow(`(${config.rerank} failing: ${last.rerankError.replace(/^[^:]+: /, "")}, last ${ago(last.ts)})`)}`
+  return `bm25 ${c.dim("→")} ${config.rerank}`
+}
+
+function sessionRow(config: Config, stats: Map<string, SessionStats>, [id, session]: ReturnType<typeof seenSessions>[number]) {
+  const active = modeFor(config, id)
+  const own = Object.entries(overrides(config.sessions[id]))
+    .map(([name, value]) => `${name} ${value}`)
+    .join(" · ")
+  const stat = stats.get(id)
+  const managed = active !== "off"
+  const saved = stat ? savedShare(stat.context, stat.plain) : null
+  return [
+    c.cyan(shortId(id)),
+    managed ? c.green(active) : c.dim("off"),
+    session.cwd ? tilde(session.cwd) : c.dim("–"),
+    stat?.turns ? c.dim(`${stat.turns} turns`) : "",
+    stat && managed ? `${c.bold(tokens(stat.context))} ctx${stat.fixed ? c.dim(` (${tokens(stat.fixed)} fixed)`) : ""}` : "",
+    saved !== null && managed ? (saved > 0 ? c.green(`−${percent(saved)}`) : c.dim("±0")) : "",
+    c.dim(ago(session.lastSeen)),
+    own ? c.dim(own) : "",
+  ]
+}
+
+function sessionsTable(config: Config, stats: Map<string, SessionStats>) {
+  const sessions = seenSessions().slice(0, 5)
+  if (sessions.length === 0) return
+  line()
+  line(`  ${c.dim("Sessions")}`)
+  table(sessions.map((entry) => sessionRow(config, stats, entry)))
+}
+
+function warnings(config: Config, health: Health | null, routed: string[], recent: RequestRecord[]) {
+  const notes: string[] = []
+  const watch = readWatch()
+  if (watch.paused.length > 0)
+    notes.push(`The proxy stopped answering ${watch.pausedAt ? ago(watch.pausedAt) : ""}, so Claude Code was sent straight to the API. Routing comes back by itself once the proxy does; ${c.bold("eunoe start")} forces it.`)
+  if (health && health.mode !== config.mode) notes.push(`The running proxy reports mode ${health.mode}; it switches on its next request.`)
+  if (health && runsStaleCode(health)) notes.push(`The proxy is running older code than what's installed. ${c.bold("eunoe start")} restarts it.`)
+  const unguarded = config.mode !== "off" ? routed.filter((dir) => readSettings(dir).env?.[BLOCKING_LIMIT_ENV] === undefined) : []
+  if (unguarded.length > 0) notes.push(`Claude Code can still refuse to send near a full window in ${settingsFiles(unguarded)}. ${c.bold("eunoe start")} fixes it.`)
+  const missed = recent.filter((r) => r.overflow || r.fit === "over")
+  const lastMissed = missed.at(-1)
+  if (lastMissed) notes.push(`${missed.length} request${missed.length === 1 ? "" : "s"} didn't fit the window on the first try, last ${ago(lastMissed.ts)}. Details in ${tilde(paths.requests)}.`)
+  for (const text of notes) {
+    line()
+    warn(text)
+  }
+}
+
 export const status: Command = {
   summary: "Show what eunoe is doing and saving",
   usage: "eunoe status",
   async run() {
-    const config = loadConfig()
+    const config = readConfig()
     const health = await probe(config.port)
     const routed = routedDirs(config)
-    const recent = recentRequests()
-    const today = withinWindow(recent)
-    const stats = perSession(recent)
-    const sum = totals(today)
+    const all = recentRequests(Number.POSITIVE_INFINITY)
+    const recent = all.slice(-RECENT_REQUESTS)
+    const sum = totals(withinWindow(recent))
+    const allTime = totals(all)
 
     line()
     line(`  ${c.bold("eunoe")} ${c.dim(VERSION)}`)
     line()
-
-    const recall = config.rerank === RERANK_OFF ? "bm25" : rerankKey() ? `bm25 ${c.dim("→")} ${config.rerank}` : `bm25  ${c.dim(`(${config.rerank} needs a key in ${tilde(paths.typesafeKey)} or TYPESAFE_API_KEY)`)}`
     rows([
-      ["Proxy", health ? `${dot(true)} running on ${c.cyan(proxyUrl(config.port))}${launchd.isInstalled() ? c.dim("  launchd") : ""}` : `${dot(false)} not running ${c.dim("(eunoe start)")}`],
-      ["Claude Code", routed.length ? `${dot(true)} routed ${c.dim(routed.map((dir) => tilde(path.join(dir, "settings.json"))).join(", "))}` : `${c.dim("○")} not routed ${c.dim("(eunoe start)")}`],
+      ["Proxy", health ? `${dot(true)} running on ${c.cyan(proxyUrl(config.port))}${launchd.isInstalled(PROXY_AGENT) ? c.dim("  launchd") : ""}` : `${dot(false)} not running ${c.dim("(eunoe start)")}`],
+      ["Claude Code", routed.length > 0 ? `${dot(true)} routed ${c.dim(settingsFiles(routed))}` : `${c.dim("○")} not routed ${c.dim("(eunoe start)")}`],
       ["Mode", `${c.bold(config.mode)}  ${c.dim(MODE_DESCRIPTIONS[config.mode])}`],
       ["Sessions", config.scope === "all" ? "all" : `only the ones you started it for ${c.dim("(eunoe start --session <id>)")}`],
-      ["Recall", recall],
+      ["Recall", recallLine(config, recent)],
     ])
 
-    const sessions = seenSessions().slice(0, SESSIONS_SHOWN)
-    if (sessions.length) {
-      line()
-      line(`  ${c.dim("Sessions")}`)
-      table(sessions.map(([id, session]) => {
-        const active = modeFor(config, id)
-        const own = Object.entries(overrides(config.sessions[id])).map(([name, value]) => `${name} ${value}`).join(" · ")
-        const stat = stats.get(id)
-        const saved = stat ? savedShare(stat.context, stat.plain) : null
-        return [
-          c.cyan(shortId(id)),
-          active === "off" ? c.dim("off") : c.green(active),
-          session.cwd ? tilde(session.cwd) : c.dim("–"),
-          stat?.turns ? c.dim(`${stat.turns} turns`) : "",
-          stat && active !== "off" ? `${c.bold(tokens(stat.context))} ctx` : "",
-          saved !== null && active !== "off" ? (saved > 0 ? c.green(`−${percent(saved)}`) : c.dim("±0")) : "",
-          c.dim(ago(session.lastSeen)),
-          own ? c.dim(own) : "",
-        ]
-      }))
-    }
+    sessionsTable(config, perSession(recent))
 
-    if (sum.requests) {
-      const hit = sum.cacheRead + sum.cacheWrite + sum.uncached
-      line()
-      line(`  ${c.dim("Last 24h")}`)
-      rows([
-        ["Requests", `${c.bold(String(sum.requests))}${sum.folds ? `  ${c.dim(`${sum.folds} fold${sum.folds === 1 ? "" : "s"}, last ${ago(sum.lastFold!)}`)}` : ""}`],
-        ["Cache", `${c.bold(tokens(sum.cacheRead))} read  ${c.dim("·")}  ${tokens(sum.cacheWrite)} written  ${c.dim("·")}  ${tokens(sum.uncached)} uncached${hit ? c.dim(`  (${percent(sum.cacheRead / hit)} hit)`) : ""}`],
-        ["Saved", sum.saved > 0 ? `${c.bold(c.green(tokens(sum.saved)))} input tokens not sent  ${c.dim(`(${percent(sum.saved / (sum.sent + sum.saved))} less than plain Claude Code)`)}` : c.dim("no data yet")],
-      ], 4)
-    }
+    if (sum.requests) summary(c.dim("Last 24h"), sum)
+    if (allTime.requests > sum.requests) summary(`${c.dim("All time")}  ${c.dim(`since ${new Date(all[0].ts).toLocaleDateString()}`)}`, allTime)
 
-    if (health && health.mode !== config.mode) {
-      line()
-      warn(`The running proxy reports mode ${health.mode}; it switches on its next request.`)
-    }
+    warnings(config, health, routed, recent)
     line()
   },
 }

package/src/cli/commands/stop.ts

@@ -1,8 +1,9 @@
-import { claudeConfigDirs, loadConfig, saveConfig } from "../../config"
-import { editSettings, withoutEunoe } from "../claude-settings"
+import { claudeConfigDirs, readConfig, saveConfig } from "../../config"
+import type { Command } from "../command"
+import { editSettings, withoutEunoe } from "../proxy/claude-settings"
+import { clearWatch } from "../proxy/watch"
 import { sessionArgs, shortId } from "../sessions"
-import type { Command } from "../types"
-import { line, listFiles, note, ok } from "../ui"
+import { line, listFiles, note, ok } from "../terminal/ui"
 
 export const stop: Command = {
   summary: "Send new sessions straight to the API again",
@@ -16,9 +17,9 @@ export const stop: Command = {
   ],
   options: [["--session <id>", "Stop managing just this session (repeatable; a unique prefix is enough)"]],
   run(args) {
-    const config = loadConfig()
+    const config = readConfig()
     const ids = sessionArgs(args)
-    if (ids.length) {
+    if (ids.length > 0) {
       const sessions = { ...config.sessions }
       for (const id of ids) {
         if (config.scope === "all") sessions[id] = { ...sessions[id], mode: "off" }
@@ -29,6 +30,7 @@ export const stop: Command = {
       return
     }
     const touched = editSettings(claudeConfigDirs(config), (settings) => withoutEunoe(settings, config.port))
+    clearWatch()
     line()
     ok("Claude Code no longer routed through eunoe")
     listFiles(touched)

package/src/cli/commands/uninstall.ts

@@ -1,24 +1,22 @@
-import { claudeConfigDirs, loadConfig } from "../../config"
-import { editSettings, withoutEunoe } from "../claude-settings"
-import * as launchd from "../launchd"
-import type { Command } from "../types"
-import { c, line, listFiles, note, ok, warn } from "../ui"
+import { claudeConfigDirs, readConfig } from "../../config"
+import type { Command } from "../command"
+import { editSettings, withoutEunoe } from "../proxy/claude-settings"
+import { removeService } from "../proxy/service"
+import { clearWatch } from "../proxy/watch"
+import { c, line, listFiles, note, ok, warn } from "../terminal/ui"
 
 export const uninstall: Command = {
   summary: "Stop eunoe and remove the background proxy",
   usage: "eunoe uninstall",
-  details: [
-    "Everything `stop` does, then shuts the proxy down and removes its background service.",
-    "Sessions still running through eunoe lose their connection, so restart them first.",
-    "Your config and transcripts in ~/.eunoe are kept.",
-  ],
+  details: ["Everything `stop` does, then shuts the proxy down and removes its background service.", "Sessions still running through eunoe lose their connection, so restart them first.", "Your config and transcripts in ~/.eunoe are kept."],
   run() {
-    const config = loadConfig()
+    const config = readConfig()
     const touched = editSettings(claudeConfigDirs(config), (settings) => withoutEunoe(settings, config.port))
+    clearWatch()
     line()
     ok("Claude Code no longer routed through eunoe")
     listFiles(touched)
-    if (launchd.removeAgent()) ok("Background proxy stopped and removed")
+    if (removeService()) ok("Background proxy stopped and removed")
     else note("No background proxy was installed.")
     warn(`Restart any Claude Code session that was still using eunoe.`)
     line(`  ${c.dim("Data kept in")} ~/.eunoe`)

package/src/cli/commands/watch.ts

@@ -0,0 +1,16 @@
+import { readConfig } from "../../config"
+import type { Command } from "../command"
+import { runWatch } from "../proxy/watch"
+import { line } from "../terminal/ui"
+
+export const watch: Command = {
+  summary: "Check the proxy once and unroute Claude Code while it is down",
+  usage: "eunoe watch",
+  details: ["`eunoe start` schedules this in the background. When the proxy stops answering, Claude Code goes straight to the API; when it is back, routing returns."],
+  hidden: true,
+  async run() {
+    const step = await runWatch(readConfig())
+    for (const dir of step.pause) line(`eunoe watch  proxy down, routing removed from ${dir}`)
+    for (const dir of step.resume) line(`eunoe watch  proxy back, routing restored in ${dir}`)
+  },
+}