@chroxify/eunoe 0.1.0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chroxify/eunoe",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Context management for Claude Code that never forgets what matters.",
   "license": "MIT",
   "repository": {
@@ -18,7 +18,8 @@
   ],
   "type": "module",
   "bin": {
-    "eunoe": "src/cli/main.ts"
+    "eunoe": "src/cli/main.ts",
+    "ee": "src/cli/main.ts"
   },
   "files": [
     "src",

package/src/cli/args.ts

@@ -5,7 +5,7 @@ export function flagValues(args: string[], flag: string): string[] {
   for (let i = 0; i < args.length; i += 1) {
     if (args[i] !== flag) continue
     const value = args[i + 1]
-    if (!value || value.startsWith("-")) fail(`${flag} needs a value`, `eunoe install ${flag} <dir>`)
+    if (!value || value.startsWith("-")) fail(`${flag} needs a value`)
     values.push(value)
     i += 1
   }

package/src/cli/commands/index.ts

@@ -1,9 +1,23 @@
 import type { Command } from "../types"
-import { install } from "./install"
 import { mode } from "./mode"
 import { serve } from "./serve"
+import { settings } from "./settings"
+import { start } from "./start"
 import { status } from "./status"
 import { stop } from "./stop"
 import { uninstall } from "./uninstall"
 
-export const commands: Record<string, Command> = { install, uninstall, stop, mode, status, serve }
+const alias = (target: Command, prefix: string[] = []): Command => ({ ...target, hidden: true, run: (args) => target.run([...prefix, ...args]) })
+
+export const commands: Record<string, Command> = {
+  start,
+  stop,
+  mode,
+  settings,
+  status,
+  uninstall,
+  serve,
+  enable: alias(start),
+  disable: alias(stop),
+  set: alias(settings, ["set"]),
+}

package/src/cli/commands/mode.ts

@@ -1,30 +1,66 @@
-import { claudeConfigDirs, loadConfig, saveConfig } from "../../config"
+import { compactionOwner, loadConfig, saveConfig } from "../../config"
+import { MODES } from "../../config/constants"
 import type { Mode } from "../../config/types"
 import { editSettings, withCompactionOwner } from "../claude-settings"
 import { MODE_DESCRIPTIONS } from "../constants"
-import * as launchd from "../launchd"
+import { routedDirs } from "../inspect"
+import { interactive, select } from "../prompt"
+import { isKnown, sessionArgs, shortId } from "../sessions"
 import type { Command } from "../types"
-import { c, fail, line, ok } from "../ui"
+import { c, fail, line, note, ok, warn } from "../ui"
+
+function listModes(current: Mode) {
+  line()
+  for (const name of MODES) {
+    const active = name === current
+    line(`  ${active ? c.green("●") : c.dim("○")} ${active ? c.bold(name.padEnd(8)) : name.padEnd(8)}  ${c.dim(MODE_DESCRIPTIONS[name])}`)
+  }
+}
+
+export function applyMode(next: Mode, ids: string[]) {
+  const config = loadConfig()
+  if (ids.length) {
+    saveConfig({ sessions: { ...config.sessions, ...Object.fromEntries(ids.map((id) => [id, { ...config.sessions[id], mode: next }])) } })
+    ok(`Mode ${c.bold(next)} for ${ids.map(shortId).join(", ")}  ${c.dim(MODE_DESCRIPTIONS[next])}`)
+    if (!routedDirs(config).length) warn("Claude Code isn't routed through eunoe. Run `eunoe start --session <id>`.")
+    const unseen = ids.filter((id) => !isKnown(id))
+    if (unseen.length) note(`Not seen through eunoe yet: ${unseen.map(shortId).join(", ")}. Check the id in Claude Code's /status.`)
+    return
+  }
+  saveConfig({ mode: next })
+  const updated = loadConfig()
+  editSettings(routedDirs(updated), (settings) => withCompactionOwner(settings, compactionOwner(updated)))
+  ok(`Mode ${c.bold(next)}  ${c.dim(MODE_DESCRIPTIONS[next])}`)
+}
 
 export const mode: Command = {
-  summary: "Show or switch how eunoe manages context",
-  usage: "eunoe mode [compact | trim | off]",
-  details: ["Takes effect on the next request; no restart needed."],
-  run(args) {
+  summary: "Pick how eunoe manages context",
+  usage: "eunoe mode [default | compact | off] [--session <id>]",
+  details: ["Without a mode it opens a picker. Takes effect on the next request; no restart needed."],
+  options: [["--session <id>", "Set the mode for just this session (repeatable; a unique prefix is enough)"]],
+  async run(args) {
     const config = loadConfig()
-    const next = args[0] as Mode | undefined
-    if (!next) {
-      line()
-      for (const [name, description] of Object.entries(MODE_DESCRIPTIONS) as Array<[Mode, string]>) {
-        const current = name === config.mode
-        line(`  ${current ? c.green("●") : c.dim("○")} ${current ? c.bold(name.padEnd(8)) : name.padEnd(8)}  ${c.dim(description)}`)
+    const given = args.find((arg, i) => !arg.startsWith("-") && args[i - 1] !== "--session") as Mode | undefined
+    const ids = sessionArgs(args)
+    if (given) {
+      if (!MODES.includes(given)) fail(`Unknown mode: ${given}`, `Choose ${MODES.join(", ")}.`)
+      applyMode(given, ids)
+      return
+    }
+    const current = ids.length === 1 ? config.sessions[ids[0]]?.mode ?? config.mode : config.mode
+    if (!interactive) {
+      listModes(current)
+      const own = Object.entries(config.sessions).filter(([, settings]) => settings.mode)
+      if (own.length) {
+        line()
+        for (const [id, settings] of own) line(`  ${c.dim(shortId(id))}  ${settings.mode}`)
       }
       line()
       return
     }
-    if (!(next in MODE_DESCRIPTIONS)) fail(`Unknown mode: ${next}`, "Choose compact, trim or off.")
-    saveConfig({ mode: next })
-    if (launchd.isInstalled()) editSettings(claudeConfigDirs(loadConfig()), (settings) => withCompactionOwner(settings, next))
-    ok(`Mode ${c.bold(next)}  ${c.dim(MODE_DESCRIPTIONS[next])}`)
+    line()
+    const chosen = await select(ids.length ? `Mode for ${ids.map(shortId).join(", ")}` : "Mode", MODES.map((value) => ({ value, hint: MODE_DESCRIPTIONS[value] })), current)
+    if (chosen === null) return
+    applyMode(chosen, ids)
   },
 }

package/src/cli/commands/serve.ts

@@ -9,7 +9,8 @@ import { c, fail, line } from "../ui"
 export const serve: Command = {
   summary: "Run the proxy in the foreground",
   usage: "eunoe serve",
-  details: ["`eunoe install` runs this for you in the background."],
+  details: ["`eunoe start` runs this for you in the background. Use it directly where there is no launchd."],
+  hidden: true,
   async run() {
     const config = loadConfig()
     if (await probe(config.port)) fail(`Something is already serving eunoe on port ${config.port}`, "Stop it first, or set another port in ~/.eunoe/config.json.")

package/src/cli/commands/settings.ts

@@ -0,0 +1,100 @@
+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 { sessionArgs, shortId } from "../sessions"
+import type { Command } from "../types"
+import { c, fail, line, ok, rows } from "../ui"
+
+const RESET = "default"
+
+function listSettings() {
+  const config = loadConfig()
+  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) {
+    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("  ·  "))}`)
+  }
+  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
+  }
+  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>")}`)
+    return
+  }
+  saveConfig({ [name]: value })
+  ok(`${name} ${c.bold(String(value))}`)
+}
+
+async function pickSetting(ids: string[]) {
+  const config = loadConfig()
+  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]}` })))
+  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)
+}
+
+export const settings: Command = {
+  summary: "List or change settings, for every session or just one",
+  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]})`)}`),
+    "",
+    `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")
+    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 (!key) {
+      if (interactive) await pickSetting(ids)
+      else fail("set needs a key and a value", "eunoe settings set <key> <value>")
+      return
+    }
+    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]}>`)
+    applySetting(key as Tunable, raw, ids)
+  },
+}

package/src/cli/commands/start.ts

@@ -0,0 +1,64 @@
+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 { isKnown, sessionArgs, shortId } from "../sessions"
+import type { Command } from "../types"
+import { c, fail, line, listFiles, note, ok, rows, tilde } from "../ui"
+
+function scoped(config: Config, ids: string[]): Partial<Config> {
+  if (!ids.length) return { scope: "all" }
+  const managingAll = config.scope === "all" && routedDirs(config).length > 0
+  const sessions = { ...config.sessions }
+  for (const id of ids) {
+    const { mode, ...rest } = sessions[id] ?? {}
+    sessions[id] = mode && mode !== "off" ? { mode, ...rest } : rest
+  }
+  return { scope: managingAll ? "all" : "sessions", sessions }
+}
+
+export const start: Command = {
+  summary: "Route Claude Code through eunoe",
+  usage: "eunoe start [--session <id>] [--config-dir <dir>]",
+  details: [
+    "Starts the background proxy if it isn't running (setting it up the first time)",
+    "and points Claude Code at it through ANTHROPIC_BASE_URL in settings.json.",
+    "New sessions pick it up; restart the ones already running.",
+    "",
+    "With --session, eunoe manages only the sessions you name and passes the rest",
+    "through untouched. Session ids are in Claude Code's /status, or `eunoe status`.",
+  ],
+  options: [
+    ["--session <id>", "Only manage this session (repeatable; a unique prefix is enough)"],
+    ["--config-dir <dir>", "Also manage this Claude config directory (repeatable, remembered)"],
+  ],
+  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])] })
+    const ids = sessionArgs(args)
+    saveConfig(scoped(loadConfig(), ids))
+    const config = loadConfig()
+
+    line()
+    await startService(config)
+    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")))
+    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(", ")}`],
+    ])
+    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.")
+    line()
+  },
+}

package/src/cli/commands/status.ts

@@ -1,44 +1,78 @@
 import path from "node:path"
-import { loadConfig } from "../../config"
+import { loadConfig, modeFor, overrides } from "../../config"
+import { paths, RERANK_OFF } from "../../config/constants"
+import { rerankKey } from "../../context/rerank"
+import { seenSessions } from "../../proxy/sessions"
 import { VERSION } from "../../version"
 import { proxyUrl } from "../claude-settings"
-import { MODE_DESCRIPTIONS } from "../constants"
+import { MODE_DESCRIPTIONS, SESSIONS_SHOWN } from "../constants"
 import { probe, recentRequests, routedDirs } from "../inspect"
 import * as launchd from "../launchd"
+import { shortId } from "../sessions"
+import { perSession, savedShare, totals, withinWindow } from "../stats"
 import type { Command } from "../types"
-import { ago, c, line, rows, tilde, tokens, warn } from "../ui"
+import { ago, c, line, percent, rows, table, tilde, tokens, warn } from "../ui"
+
+const dot = (on: boolean) => (on ? c.green("●") : c.red("○"))
 
 export const status: Command = {
-  summary: "Show what eunoe is doing",
+  summary: "Show what eunoe is doing and saving",
   usage: "eunoe status",
   async run() {
     const config = loadConfig()
     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)
 
     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 ? `${c.green("●")} running on ${c.cyan(proxyUrl(config.port))}` : `${c.red("○")} not running`],
-      ["Claude Code", routed.length ? `${c.green("●")} routed through eunoe` : `${c.dim("○")} not routed ${c.dim("(eunoe install)")}`],
+      ["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)")}`],
       ["Mode", `${c.bold(config.mode)}  ${c.dim(MODE_DESCRIPTIONS[config.mode])}`],
-      ["Search", `${config.search} transcripts`],
-      ["Background", launchd.isInstalled() ? "launchd agent" : c.dim("none")],
+      ["Sessions", config.scope === "all" ? "all" : `only the ones you started it for ${c.dim("(eunoe start --session <id>)")}`],
+      ["Recall", recall],
     ])
-    for (const dir of routed) line(`  ${" ".repeat(13)}${c.dim(tilde(path.join(dir, "settings.json")))}`)
 
-    if (recent.length) {
-      const sum = (key: string) => recent.reduce((total, entry) => total + (entry[key] ?? 0), 0)
-      const compactions = recent.filter((entry) => entry.compacted)
+    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) : "",
+        ]
+      }))
+    }
+
+    if (sum.requests) {
+      const hit = sum.cacheRead + sum.cacheWrite + sum.uncached
       line()
-      line(`  ${c.dim(`Last ${recent.length} requests`)}`)
+      line(`  ${c.dim("Last 24h")}`)
       rows([
-        ["Cache", `${c.bold(tokens(sum("cacheRead")))} read  ·  ${tokens(sum("cacheWrite"))} written  ·  ${tokens(sum("uncached"))} uncached`],
-        ["Cuts", compactions.length ? `${compactions.length}, last ${ago(compactions.at(-1)!.ts)}` : c.dim("none yet")],
-      ])
+        ["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 (health && health.mode !== config.mode) {
       line()
       warn(`The running proxy reports mode ${health.mode}; it switches on its next request.`)

package/src/cli/commands/stop.ts

@@ -1,16 +1,38 @@
-import { loadConfig } from "../../config"
-import { routedDirs } from "../inspect"
-import * as launchd from "../launchd"
+import { claudeConfigDirs, loadConfig, saveConfig } from "../../config"
+import { editSettings, withoutEunoe } from "../claude-settings"
+import { sessionArgs, shortId } from "../sessions"
 import type { Command } from "../types"
-import { fail, note, ok } from "../ui"
+import { line, listFiles, note, ok } from "../ui"
 
 export const stop: Command = {
-  summary: "Stop the background proxy",
-  usage: "eunoe stop",
-  details: ["Sessions still pointed at the proxy will fail until restarted, so run `eunoe uninstall` first."],
-  run() {
-    if (routedDirs(loadConfig()).length) fail("Claude Code is still routed through eunoe", "Run `eunoe uninstall` first, then restart your sessions.")
-    if (launchd.removeAgent()) ok("Background proxy stopped")
-    else note("The proxy isn't running as a background service.")
+  summary: "Send new sessions straight to the API again",
+  usage: "eunoe stop [--session <id>]",
+  details: [
+    "Removes eunoe from Claude Code's settings and hands compaction back to it.",
+    "The proxy stays up for sessions that are already running through it, so they",
+    "keep working until you restart them. `eunoe start` turns it back on.",
+    "",
+    "With --session, only that session is passed through untouched from its next request.",
+  ],
+  options: [["--session <id>", "Stop managing just this session (repeatable; a unique prefix is enough)"]],
+  run(args) {
+    const config = loadConfig()
+    const ids = sessionArgs(args)
+    if (ids.length) {
+      const sessions = { ...config.sessions }
+      for (const id of ids) {
+        if (config.scope === "all") sessions[id] = { ...sessions[id], mode: "off" }
+        else delete sessions[id]
+      }
+      saveConfig({ sessions })
+      ok(`eunoe off for ${ids.map(shortId).join(", ")} from the next request`)
+      return
+    }
+    const touched = editSettings(claudeConfigDirs(config), (settings) => withoutEunoe(settings, config.port))
+    line()
+    ok("Claude Code no longer routed through eunoe")
+    listFiles(touched)
+    note("Sessions already running through eunoe keep using it until restarted.")
+    line()
   },
 }

package/src/cli/commands/uninstall.ts

@@ -1,25 +1,27 @@
-import { claudeConfigDirs, loadConfig, saveConfig } from "../../config"
+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 } from "../ui"
+import { c, line, listFiles, note, ok, warn } from "../ui"
 
 export const uninstall: Command = {
-  summary: "Send new sessions straight to the API again",
+  summary: "Stop eunoe and remove the background proxy",
   usage: "eunoe uninstall",
   details: [
-    "Removes eunoe from Claude Code's settings and hands compaction back to it.",
-    "The proxy keeps running as a passthrough, so sessions already pointed at it",
-    "keep working. Run `eunoe stop` once they have been restarted.",
+    "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 touched = editSettings(claudeConfigDirs(config), (settings) => withoutEunoe(settings, config.port))
-    saveConfig({ mode: "off" })
     line()
     ok("Claude Code no longer routed through eunoe")
     listFiles(touched)
-    note("The proxy stays up as a passthrough for sessions still using it.")
-    line(`  ${c.dim("Once they're restarted:")} ${c.cyan("eunoe stop")}`)
+    if (launchd.removeAgent()) 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`)
     line()
   },
 }

package/src/cli/constants.ts

@@ -1,14 +1,32 @@
 import { homedir } from "node:os"
 import path from "node:path"
-import type { Mode } from "../config/types"
+import type { Mode, Tunable } from "../config/types"
 import type { OptionRow } from "./types"
 
 export const TAGLINE = "Context management for Claude Code that never forgets what matters."
 
 export const MODE_DESCRIPTIONS: Record<Mode, string> = {
-  compact: "Full context until the window is nearly full, then eunoe's cut",
-  trim: "Every finished turn kept as your message and the final reply",
-  off: "Passthrough. Claude Code compacts on its own",
+  default: "Recent turns whole, older turns folded; evidence and recall on",
+  compact: "Claude Code as it is, only its compaction replaced",
+  off: "Passthrough; Claude Code compacts on its own",
+}
+
+export const TUNABLE_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",
+  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",
+}
+
+export const TUNABLE_HINTS: Record<Tunable, string> = {
+  keep: "a whole number, 1 or more",
+  budget: "a token count, 1000 or more",
+  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",
 }
 
 export const GLOBAL_OPTIONS: OptionRow[] = [
@@ -20,10 +38,15 @@ export const LAUNCHD_LABEL = "com.chroxify.eunoe"
 export const LAUNCH_AGENT_PLIST = path.join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`)
 
 export const PROBE_TIMEOUT_MS = 800
-export const RECENT_REQUESTS = 200
+export const RECENT_REQUESTS = 5_000
+export const STATUS_WINDOW_MS = 24 * 3_600_000
 export const TYPO_DISTANCE = 2
+export const SHORT_ID_LENGTH = 8
+export const SESSIONS_SHOWN = 5
 
 export const TRANSPARENT_PIXEL = "."
 export const HALF_BLOCKS = " ▀▄█"
 export const OCTANTS = [..." 𜺨𜺫🮂𜴀▘𜴁𜴂𜴃𜴄▝𜴅𜴆𜴇𜴈▀𜴉𜴊𜴋𜴌🯦𜴍𜴎𜴏𜴐𜴑𜴒𜴓𜴔𜴕𜴖𜴗𜴘𜴙𜴚𜴛𜴜𜴝𜴞𜴟🯧𜴠𜴡𜴢𜴣𜴤𜴥𜴦𜴧𜴨𜴩𜴪𜴫𜴬𜴭𜴮𜴯𜴰𜴱𜴲𜴳𜴴𜴵🮅𜺣𜴶𜴷𜴸𜴹𜴺𜴻𜴼𜴽𜴾𜴿𜵀𜵁𜵂𜵃𜵄▖𜵅𜵆𜵇𜵈▌𜵉𜵊𜵋𜵌▞𜵍𜵎𜵏𜵐▛𜵑𜵒𜵓𜵔𜵕𜵖𜵗𜵘𜵙𜵚𜵛𜵜𜵝𜵞𜵟𜵠𜵡𜵢𜵣𜵤𜵥𜵦𜵧𜵨𜵩𜵪𜵫𜵬𜵭𜵮𜵯𜵰𜺠𜵱𜵲𜵳𜵴𜵵𜵶𜵷𜵸𜵹𜵺𜵻𜵼𜵽𜵾𜵿𜶀𜶁𜶂𜶃𜶄𜶅𜶆𜶇𜶈𜶉𜶊𜶋𜶌𜶍𜶎𜶏▗𜶐𜶑𜶒𜶓▚𜶔𜶕𜶖𜶗▐𜶘𜶙𜶚𜶛▜𜶜𜶝𜶞𜶟𜶠𜶡𜶢𜶣𜶤𜶥𜶦𜶧𜶨𜶩𜶪𜶫▂𜶬𜶭𜶮𜶯𜶰𜶱𜶲𜶳𜶴𜶵𜶶𜶷𜶸𜶹𜶺𜶻𜶼𜶽𜶾𜶿𜷀𜷁𜷂𜷃𜷄𜷅𜷆𜷇𜷈𜷉𜷊𜷋𜷌𜷍𜷎𜷏𜷐𜷑𜷒𜷓𜷔𜷕𜷖𜷗𜷘𜷙𜷚▄𜷛𜷜𜷝𜷞▙𜷟𜷠𜷡𜷢▟𜷣▆𜷤𜷥█"]
 export const OCTANT_TERMINALS = ["ghostty"]
+export const START_TIMEOUT_MS = 3_000
+export const START_POLL_MS = 150

package/src/cli/help.ts

@@ -13,12 +13,12 @@ export function printHelp(commands: Record<string, Command>) {
   line(`    eunoe ${c.cyan("<command>")} ${c.dim("[options]")}`)
   line()
   line(`  ${c.dim("Commands")}`)
-  for (const [name, command] of Object.entries(commands)) line(`    ${c.cyan(name.padEnd(width))}   ${command.summary}`)
+  for (const [name, command] of Object.entries(commands).filter(([, command]) => !command.hidden)) line(`    ${c.cyan(name.padEnd(width))}   ${command.summary}`)
   line()
   line(`  ${c.dim("Options")}`)
   for (const [flag, description] of GLOBAL_OPTIONS) line(`    ${flag.padEnd(width)}   ${description}`)
   line()
-  line(`  ${c.dim("Run")} eunoe ${c.cyan("<command>")} --help ${c.dim("for details.")}`)
+  line(`  ${c.dim("Run")} eunoe ${c.cyan("<command>")} --help ${c.dim("for details.")} ${c.dim("`ee` works anywhere `eunoe` does.")}`)
   line()
 }
 

package/src/cli/launchd.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs"
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"
 import path from "node:path"
 import { LAUNCH_AGENT_PLIST as PLIST, LAUNCHD_LABEL } from "./constants"
 
@@ -11,7 +11,7 @@ export function isInstalled() {
 export function installAgent(program: string[], logFile: string) {
   mkdirSync(path.dirname(PLIST), { recursive: true })
   const args = program.map((arg) => `<string>${arg}</string>`).join("")
-  writeFileSync(PLIST, `<?xml version="1.0" encoding="UTF-8"?>
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0"><dict>
   <key>Label</key><string>${LAUNCHD_LABEL}</string>
@@ -21,7 +21,12 @@ export function installAgent(program: string[], logFile: string) {
   <key>StandardOutPath</key><string>${logFile}</string>
   <key>StandardErrorPath</key><string>${logFile}</string>
 </dict></plist>
-`)
+`
+  if (existsSync(PLIST) && readFileSync(PLIST, "utf8") === plist) {
+    Bun.spawnSync(["launchctl", "load", PLIST])
+    return
+  }
+  writeFileSync(PLIST, plist)
   Bun.spawnSync(["launchctl", "unload", PLIST])
   Bun.spawnSync(["launchctl", "load", PLIST])
 }