@chroxify/eunoe 0.1.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chroxify/eunoe",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "Context management for Claude Code that never forgets what matters.",
   "license": "MIT",
   "repository": {
@@ -8,6 +8,7 @@
     "url": "git+https://github.com/chroxify/eunoe.git"
   },
   "homepage": "https://github.com/chroxify/eunoe#readme",
+  "bugs": "https://github.com/chroxify/eunoe/issues",
   "keywords": [
     "claude-code",
     "claude",
@@ -18,7 +19,8 @@
   ],
   "type": "module",
   "bin": {
-    "eunoe": "src/cli/main.ts"
+    "eunoe": "src/cli/main.ts",
+    "ee": "src/cli/main.ts"
   },
   "files": [
     "src",
@@ -31,13 +33,28 @@
   "scripts": {
     "start": "bun src/cli/main.ts serve",
     "test": "bun test",
-    "typecheck": "tsc --noEmit -p ."
+    "check-types": "tsc --noEmit -p .",
+    "lint": "biome check . && bun lint:conventions",
+    "lint:conventions": "bun scripts/lint-conventions.ts",
+    "format": "biome check .",
+    "format:fix": "biome check . --write",
+    "prepare": "husky"
   },
   "devDependencies": {
+    "@babel/parser": "7.27.0",
+    "@biomejs/biome": "2.5.9",
     "@types/bun": "^1.4.2",
+    "husky": "9.1.7",
+    "knip": "6.41.0",
+    "lint-staged": "16.4.0",
     "typescript": "^7.0.2"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "lint-staged": {
+    "*.{js,ts,json,jsonc,md,yml}": [
+      "biome check --write --files-ignore-unknown=true --no-errors-on-unmatched"
+    ]
   }
 }

package/src/cli/{types.ts → command.ts}

@@ -1,5 +1,3 @@
-export type Settings = Record<string, any>
-
 export type OptionRow = [flag: string, description: string]
 
 export interface Command {
@@ -7,7 +5,6 @@ export interface Command {
   usage: string
   details?: string[]
   options?: OptionRow[]
+  hidden?: boolean
   run: (args: string[]) => void | Promise<void>
 }
-
-export type RequestRecord = Record<string, any>

package/src/cli/commands/index.ts

@@ -1,9 +1,33 @@
-import type { Command } from "../types"
-import { install } from "./install"
+import type { Command } from "../command"
+import { load } from "./load"
 import { mode } from "./mode"
+import { peek } from "./peek"
+import { replay } from "./replay"
 import { serve } from "./serve"
+import { sessions } from "./sessions"
+import { settings } from "./settings"
+import { start } from "./start"
 import { status } from "./status"
 import { stop } from "./stop"
 import { uninstall } from "./uninstall"
+import { watch } from "./watch"
 
-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,
+  replay,
+  sessions,
+  peek,
+  load,
+  uninstall,
+  serve,
+  watch,
+  enable: alias(start),
+  disable: alias(stop),
+  set: alias(settings, ["set"]),
+}

package/src/cli/commands/load.ts

@@ -0,0 +1,44 @@
+import { mkdirSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import { paths } from "../../config/paths"
+import { FOLD_CAP_CHARS, foldedView } from "../../context/fold"
+import type { Command } from "../command"
+import { candidateOf, candidatesHere, shortId, titleOf } from "../sessions"
+import type { SessionCandidate } from "../sessions/source"
+import { line } from "../terminal/ui"
+
+interface Loaded {
+  file: string
+  lines: number
+  chars: number
+}
+
+export function writeLoaded(cand: SessionCandidate): Loaded {
+  const text = foldedView(cand.messages, FOLD_CAP_CHARS)
+  mkdirSync(paths.loaded, { recursive: true })
+  const file = path.join(paths.loaded, `${cand.id}.md`)
+  writeFileSync(file, text)
+  return { file, lines: text.split("\n").length, chars: text.length }
+}
+
+export const loadedLine = (cand: SessionCandidate, written: Loaded) =>
+  `Session ${shortId(cand.id)} "${titleOf(cand)}" written to ${written.file} (${written.lines} lines, ${Math.round(written.chars / 1000)}k characters). Read the whole file with the Read tool, from line 1 to line ${written.lines}, before acting.`
+
+export const load: Command = {
+  summary: "Write an earlier session to a file for the agent to read",
+  usage: "eunoe load <id>",
+  hidden: true,
+  details: [
+    "Writes the whole record of an earlier session in this directory to a file:",
+    "your messages, the key output lines and the agent's replies. The agent runs",
+    "this when a message continues that session, then reads the file start to",
+    "end. Ids come from eunoe sessions; a unique prefix is enough.",
+  ],
+  run(args) {
+    const cand = candidateOf(
+      args.find((a) => !a.startsWith("-")),
+      candidatesHere(),
+    )
+    line(loadedLine(cand, writeLoaded(cand)))
+  },
+}

package/src/cli/commands/mode.ts

@@ -1,30 +1,74 @@
-import { claudeConfigDirs, loadConfig, saveConfig } from "../../config"
-import type { Mode } from "../../config/types"
-import { editSettings, withCompactionOwner } from "../claude-settings"
-import { MODE_DESCRIPTIONS } from "../constants"
-import * as launchd from "../launchd"
-import type { Command } from "../types"
-import { c, fail, line, ok } from "../ui"
+import { compactionOwner, MODES, type Mode, readConfig, saveConfig } from "../../config"
+import type { Command } from "../command"
+import { editSettings, withCompactionOwner } from "../proxy/claude-settings"
+import { routedDirs } from "../proxy/inspect"
+import { isKnown, sessionArgs, shortId } from "../sessions"
+import { interactive, select } from "../terminal/prompt"
+import { c, fail, line, note, ok, warn } from "../terminal/ui"
+
+export const MODE_DESCRIPTIONS: Record<Mode, string> = {
+  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",
+}
+
+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])}`)
+  }
+}
+
+function applyMode(next: Mode, ids: string[]) {
+  const config = readConfig()
+  if (ids.length > 0) {
+    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 === 0) warn("Claude Code isn't routed through eunoe. Run `eunoe start --session <id>`.")
+    const unseen = ids.filter((id) => !isKnown(id))
+    if (unseen.length > 0) note(`Not seen through eunoe yet: ${unseen.map(shortId).join(", ")}. Check the id in Claude Code's /status.`)
+    return
+  }
+  saveConfig({ mode: next })
+  const updated = readConfig()
+  editSettings(routedDirs(updated), (settings) => withCompactionOwner(settings, compactionOwner(updated)))
+  ok(`Mode ${c.bold(next)}  ${c.dim(MODE_DESCRIPTIONS[next])}`)
+}
+
+function printModes(current: Mode) {
+  const config = readConfig()
+  listModes(current)
+  const own = Object.entries(config.sessions).filter(([, settings]) => settings.mode)
+  if (own.length > 0) {
+    line()
+    for (const [id, settings] of own) line(`  ${c.dim(shortId(id))}  ${settings.mode}`)
+  }
+  line()
+}
 
 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) {
-    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)}`)
-      }
-      line()
+  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 = readConfig()
+    const given = args.find((arg, i) => !arg.startsWith("-") && args[i - 1] !== "--session")
+    const ids = sessionArgs(args)
+    if (given) {
+      if (!MODES.includes(given as Mode)) fail(`Unknown mode: ${given}`, `Choose ${MODES.join(", ")}.`)
+      applyMode(given as Mode, ids)
       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])}`)
+    const current = ids.length === 1 ? (config.sessions[ids[0]]?.mode ?? config.mode) : config.mode
+    if (!interactive) return printModes(current)
+    line()
+    const chosen = await select(
+      ids.length > 0 ? `Mode for ${ids.map(shortId).join(", ")}` : "Mode",
+      MODES.map((value) => ({ value, hint: MODE_DESCRIPTIONS[value] })),
+      current,
+    )
+    if (chosen !== null) applyMode(chosen, ids)
   },
 }

package/src/cli/commands/peek.ts

@@ -0,0 +1,22 @@
+import type { Command } from "../command"
+import { candidateOf, candidatesHere, peekText, shortId } from "../sessions"
+import { fail, line } from "../terminal/ui"
+
+export const peek: Command = {
+  summary: "Show the excerpts of an earlier session that match some words",
+  usage: "eunoe peek <id> <words>",
+  hidden: true,
+  details: [
+    "Searches one earlier session in this directory for the words and prints the",
+    "excerpts that match: tool output and your messages, quoted exactly. For a",
+    "single fact such as an error message or a value. To continue the session's",
+    "work the agent should eunoe load it instead. Ids come from eunoe sessions.",
+  ],
+  run(args) {
+    const [id, ...rest] = args.filter((a) => !a.startsWith("-"))
+    const cand = candidateOf(id, candidatesHere())
+    const words = rest.join(" ").trim()
+    if (!words) fail("Say what to look for: eunoe peek <id> <words>")
+    line(peekText(cand, words) ?? fail(`Nothing in ${shortId(cand.id)} matches "${words}".`))
+  },
+}

package/src/cli/commands/replay.ts

@@ -0,0 +1,194 @@
+import { statSync } from "node:fs"
+import { cpus } from "node:os"
+import path from "node:path"
+import { claudeConfigDirs, DEFAULTS, parseTunable, readConfig } from "../../config"
+import { listEntries, projectFolderName, projectFolders } from "../../transcript/locate"
+import type { Command } from "../command"
+import { recentRequests } from "../proxy/inspect"
+import type { ReplayedSession, ReplayOptions } from "../replay"
+import { shortId } from "../sessions"
+import { c, fail, line, percent, plural, rows, table, tilde, tokens, useColor } from "../terminal/ui"
+
+interface Target {
+  file: string
+  bytes: number
+}
+
+const WINDOW = 1_000_000
+const TOP_SESSIONS = 10
+
+function targets(configDirs: string[], ids: string[], here: string | null): Target[] {
+  const seen = new Map<string, Target>()
+  const wanted = (id: string) => ids.length === 0 || ids.some((prefix) => id.startsWith(prefix))
+  const onlyFolder = here ? projectFolderName(here) : null
+  for (const folder of projectFolders(configDirs)) {
+    if (onlyFolder && path.basename(folder) !== onlyFolder) continue
+    for (const name of listEntries(folder)) {
+      if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/.test(name)) continue
+      const id = name.slice(0, -".jsonl".length)
+      if (!wanted(id) || seen.has(id)) continue
+      const file = path.join(folder, name)
+      seen.set(id, { file, bytes: statSync(file).size })
+    }
+  }
+  return [...seen.values()].sort((a, b) => b.bytes - a.bytes)
+}
+
+function fixedTokens(): { value: number; measured: boolean } {
+  const sizes = recentRequests()
+    .flatMap((r) => (r.charsFixed && r.charsOut && r.input ? [Math.round((r.input * r.charsFixed) / r.charsOut)] : []))
+    .sort((a, b) => a - b)
+  if (sizes.length === 0) return { value: 30_000, measured: false }
+  return { value: sizes[Math.floor(sizes.length / 2)], measured: true }
+}
+
+const duration = (ms: number) => (ms < 60_000 ? `${Math.max(1, Math.round(ms / 1000))}s` : `${Math.floor(ms / 60_000)}m ${Math.round((ms % 60_000) / 1000)}s`)
+const size = (bytes: number) => (bytes >= 1e9 ? `${(bytes / 1e9).toFixed(1)} GB` : `${Math.round(bytes / 1e6)} MB`)
+const fewer = (plain: number, eunoe: number) => (plain > 0 ? percent(1 - eunoe / plain) : "–")
+
+async function replayAll(list: Target[], options: ReplayOptions, onDone: (done: number, bytes: number) => void): Promise<ReplayedSession[]> {
+  const results: ReplayedSession[] = []
+  const queue = [...list]
+  let bytesDone = 0
+  const workers = Math.max(1, Math.min(8, cpus().length - 1, list.length))
+  await Promise.all(
+    Array.from(
+      { length: workers },
+      () =>
+        new Promise<void>((resolve) => {
+          const worker = new Worker(new URL("../replay/worker.ts", import.meta.url).href)
+          const next = () => {
+            const target = queue.shift()
+            if (!target) {
+              worker.terminate()
+              resolve()
+              return
+            }
+            worker.postMessage({ file: target.file, options })
+          }
+          worker.onmessage = (event: MessageEvent<ReplayedSession>) => {
+            results.push(event.data)
+            bytesDone += event.data.bytes
+            onDone(results.length, bytesDone)
+            next()
+          }
+          worker.onerror = () => next()
+          next()
+        }),
+    ),
+  )
+  return results
+}
+
+export const replay: Command = {
+  summary: "Replay your Claude Code history through eunoe and show what it saves",
+  usage: "eunoe replay [session…] [--here] [--window <tokens>]",
+  details: [
+    "Reads every Claude Code session on this machine and replays each request",
+    "through eunoe's folding, without calling Claude. Shows the input tokens",
+    "and the cache-weighted cost plain Claude Code would have paid against what",
+    "eunoe would have sent, the folds it would have made, and the compactions",
+    "Claude Code would have needed. Deterministic and offline.",
+  ],
+  options: [
+    ["--here", "Only sessions from the current directory"],
+    ["--window <tokens>", `Context window to assume (default ${tokens(WINDOW)})`],
+    ["--turn-cap <tokens|off>", "Override the turnCap setting for this replay"],
+  ],
+  async run(args) {
+    const windowAt = args.indexOf("--window")
+    const capAt = args.indexOf("--turn-cap")
+    const optionValues = [windowAt, capAt].filter((at) => at !== -1).map((at) => args[at + 1])
+    const ids = args.filter((a) => !a.startsWith("-") && !optionValues.includes(a))
+    const window = windowAt === -1 ? WINDOW : Number(args[windowAt + 1])
+    if (!(window > 0)) fail("--window needs a token count", "eunoe replay --window 200000")
+    const config = readConfig()
+    const turnCap = capAt === -1 ? config.turnCap : parseTunable("turnCap", args[capAt + 1] ?? "")
+    if (turnCap === null) fail("--turn-cap needs a token count or off", "eunoe replay --turn-cap off")
+    const list = targets(claudeConfigDirs(config), ids, args.includes("--here") ? process.cwd() : null)
+    if (list.length === 0) fail("No Claude Code sessions found.")
+    const totalBytes = list.reduce((total, entry) => total + entry.bytes, 0)
+    const fixed = fixedTokens()
+    line()
+    const options: ReplayOptions = { config: { ...config, turnCap, mode: config.mode === "off" ? DEFAULTS.mode : config.mode }, window, fixedTokens: fixed.value }
+    const started = Date.now()
+    const progress = useColor && process.stdout.isTTY
+    const results = await replayAll(list, options, (done, doneBytes) => {
+      if (!progress) return
+      const left = doneBytes > 0 ? ` · ~${duration(((Date.now() - started) / doneBytes) * (totalBytes - doneBytes))} left` : ""
+      process.stdout.write(`\r\x1b[K  ${c.dim(`Replaying ${done} / ${list.length} sessions · ${size(doneBytes)} of ${size(totalBytes)}${left}`)}`)
+    })
+    if (progress) process.stdout.write("\r\x1b[K")
+    const sum = results.reduce(
+      (acc, r) => {
+        for (const key of ["requests", "folds", "dropped", "nativeCompactions", "discarded", "plainTokens", "eunoeTokens", "plainCost", "eunoeCost"] as const) acc[key] += r[key]
+        acc.peakPlain = Math.max(acc.peakPlain, r.peakPlain)
+        acc.peakEunoe = Math.max(acc.peakEunoe, r.peakEunoe)
+        return acc
+      },
+      { requests: 0, folds: 0, dropped: 0, nativeCompactions: 0, discarded: 0, plainTokens: 0, eunoeTokens: 0, plainCost: 0, eunoeCost: 0, peakPlain: 0, peakEunoe: 0 },
+    )
+    const compared = results.filter((r) => r.requests > 0)
+    line(`  ${c.bold("eunoe replay")}  ${c.dim("your Claude Code history, as eunoe would have sent it")}`)
+    line()
+    rows(
+      [
+        ["Sessions", `${c.bold(String(compared.length))} replayed  ${c.dim("·")}  ${size(totalBytes)}  ${c.dim("·")}  ${duration(Date.now() - started)}`],
+        ["Requests", c.bold(sum.requests.toLocaleString())],
+        ["Window", `${tokens(window)}  ${c.dim(`· ${tokens(fixed.value)} of it system prompt and tools, ${fixed.measured ? "from your logged requests" : "assumed"}`)}`],
+      ],
+      4,
+    )
+    line()
+    rows(
+      [
+        [
+          "History kept",
+          `eunoe ${c.bold(c.green("every turn"))}, folded or whole  ${c.dim("·")}  Claude Code compacted ${c.bold(String(sum.nativeCompactions))} time${sum.nativeCompactions === 1 ? "" : "s"}, ${c.bold(tokens(sum.discarded))} tokens of conversation replaced by summaries`,
+        ],
+        [
+          "Input tokens",
+          `plain ${tokens(sum.plainTokens)}  ${c.dim("→")}  eunoe ${c.bold(tokens(sum.eunoeTokens))} tokens   ${c.green(c.bold(`${fewer(sum.plainTokens, sum.eunoeTokens)} fewer`))}  ${c.dim("the conversation; system prompt and tools are the same on both sides")}`,
+        ],
+        ["Cost", `${c.green(c.bold(`${fewer(sum.plainCost, sum.eunoeCost)} cheaper`))}  ${c.dim("cache reads at 0.1×, writes at 1.25×")}`],
+        ["Folds", c.bold(String(sum.folds))],
+        ["Folds dropped", `${c.bold(String(sum.dropped))} ${c.dim("folded turns removed entirely to fit the window")}`],
+        ["Peak context", `plain ${tokens(sum.peakPlain)}  ${c.dim("→")}  eunoe ${c.bold(tokens(sum.peakEunoe))}`],
+      ],
+      4,
+    )
+    const saved = [...compared]
+      .filter((r) => r.nativeCompactions > 0)
+      .sort((a, b) => b.discarded - a.discarded)
+      .slice(0, TOP_SESSIONS)
+    if (saved.length > 0) {
+      line()
+      line(`  ${c.dim("Sessions Claude Code would have compacted, by history it would have lost")}`)
+      table(
+        saved.map((r) => [
+          c.cyan(shortId(r.id)),
+          (r.title ?? (r.cwd ? tilde(r.cwd) : "")).slice(0, 40),
+          c.bold(c.green(`${plural(r.nativeCompactions, "compaction")} avoided`)),
+          `${tokens(r.discarded)} tokens kept`,
+          c.dim(`${plural(r.folds, "fold")} · ${tokens(r.plainTokens)} → ${tokens(r.eunoeTokens)} tokens`),
+        ]),
+      )
+    }
+    const top = [...compared].sort((a, b) => b.plainTokens - b.eunoeTokens - (a.plainTokens - a.eunoeTokens)).slice(0, TOP_SESSIONS)
+    if (top.length > 1) {
+      line()
+      line(`  ${c.dim("Biggest token savings")}`)
+      table(
+        top.map((r) => [
+          c.cyan(shortId(r.id)),
+          (r.title ?? (r.cwd ? tilde(r.cwd) : "")).slice(0, 40),
+          `${tokens(r.plainTokens)} ${c.dim("→")} ${tokens(r.eunoeTokens)} tokens`,
+          c.green(c.bold(`${tokens(r.plainTokens - r.eunoeTokens)} tokens saved`)),
+          c.dim(`${fewer(r.plainTokens, r.eunoeTokens)} fewer`),
+          c.dim(plural(r.folds, "fold")),
+        ]),
+      )
+    }
+    line()
+  },
+}

package/src/cli/commands/serve.ts

@@ -1,19 +1,35 @@
-import { loadConfig } from "../../config"
+import { readConfig } from "../../config"
 import { serve as startProxy } from "../../proxy/server"
 import { VERSION } from "../../version"
-import { proxyUrl } from "../claude-settings"
-import { probe } from "../inspect"
-import type { Command } from "../types"
-import { c, fail, line } from "../ui"
+import type { Command } from "../command"
+import { proxyUrl } from "../proxy/claude-settings"
+import { probe } from "../proxy/inspect"
+import { c, fail, line, warn } from "../terminal/ui"
+
+async function bind(port: number) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return startProxy(port)
+    } catch (error) {
+      if (attempt >= 30) throw error
+      warn(`Port ${port} is busy (${String(error)}), trying again in 1000ms`)
+      await Bun.sleep(1_000)
+    }
+  }
+}
 
 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()
+    const config = readConfig()
     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.")
-    startProxy(config.port)
+    const keepGoing = (error: unknown) => warn(`eunoe kept going after an error: ${String(error)}`)
+    process.on("uncaughtException", keepGoing)
+    process.on("unhandledRejection", keepGoing)
+    await bind(config.port)
     line(`${c.bold("eunoe")} ${c.dim(VERSION)}  listening on ${c.cyan(proxyUrl(config.port))}  ${c.dim(`mode ${config.mode} · Ctrl-C to stop`)}`)
   },
 }

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