@chroxify/eunoe 0.1.0 → 1.1.0

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

package/src/cli/{args.ts → terminal/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/{help.ts → terminal/help.ts}

@@ -1,24 +1,40 @@
-import { VERSION } from "../version"
-import { GLOBAL_OPTIONS, TAGLINE } from "./constants"
-import { withLogo } from "./logo"
-import type { Command } from "./types"
+import { VERSION } from "../../version"
+import type { Command, OptionRow } from "../command"
+import { withLogo } from "../logo"
 import { c, line } from "./ui"
 
+const GROUPS: Array<[title: string, names: string[]]> = [
+  ["Proxy", ["start", "stop", "status", "replay", "uninstall"]],
+  ["Context", ["mode", "settings"]],
+  ["Sessions", ["sessions"]],
+]
+
+const GLOBAL_OPTIONS: OptionRow[] = [
+  ["-h, --help", "Show help for a command"],
+  ["-v, --version", "Show the version"],
+]
+
 export function printHelp(commands: Record<string, Command>) {
   const width = Math.max(...Object.keys(commands).map((name) => name.length), ...GLOBAL_OPTIONS.map(([flag]) => flag.length))
   line()
-  for (const row of withLogo([`${c.bold("eunoe")} ${c.dim(VERSION)}`, c.italic(TAGLINE)])) line(row)
+  for (const row of withLogo([`${c.bold("eunoe")} ${c.dim(VERSION)}`, c.italic("Context management for Claude Code that never forgets what matters.")])) line(row)
   line()
   line(`  ${c.dim("Usage")}`)
   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}`)
-  line()
+  const visible = Object.keys(commands).filter((name) => !commands[name].hidden)
+  const grouped = new Set(GROUPS.flatMap(([, names]) => names))
+  for (const [title, names] of [...GROUPS, ["Other", visible.filter((name) => !grouped.has(name))] as const]) {
+    const shown = names.filter((name) => visible.includes(name))
+    if (shown.length === 0) continue
+    line(`  ${c.dim(title)}`)
+    for (const name of shown) line(`    ${c.cyan(name.padEnd(width))}   ${commands[name].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/terminal/prompt.ts

@@ -0,0 +1,114 @@
+import { c, useColor } from "./ui"
+
+const ESC = "\x1b"
+const KEY_SEQUENCE = new RegExp(`${ESC}\\[[0-9;]*[A-Za-z~]|${ESC}.|[\\s\\S]`, "g")
+
+interface Choice<T extends string = string> {
+  value: T
+  label?: string
+  hint?: string
+}
+
+export const keys = {
+  up: "\x1b[A",
+  down: "\x1b[B",
+  enter: ["\r", "\n"],
+  escape: ["\x1b", "\x03"],
+  backspace: ["\x7f", "\b"],
+  clear: "\x15",
+}
+
+export const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY)
+
+export const printable = (key: string) => key >= " " && !key.startsWith("\x1b")
+
+function readKeys(onKey: (key: string) => boolean | undefined): Promise<void> {
+  return new Promise((resolve) => {
+    const stdin = process.stdin
+    stdin.setRawMode(true)
+    stdin.resume()
+    stdin.setEncoding("utf8")
+    const handler = (chunk: string) => {
+      for (const key of chunk.match(KEY_SEQUENCE) ?? []) {
+        if (onKey(key) !== true) continue
+        stdin.off("data", handler)
+        stdin.setRawMode(false)
+        stdin.pause()
+        resolve()
+        return
+      }
+    }
+    stdin.on("data", handler)
+  })
+}
+
+export async function interact(render: () => string[], onKey: (key: string) => boolean | undefined, hideCursor = true): Promise<void> {
+  let drawn = 0
+  const draw = () => {
+    const lines = render()
+    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+    process.stdout.write(`${lines.join("\n")}\n`)
+    drawn = lines.length
+  }
+  const toggleCursor = hideCursor && useColor
+  if (toggleCursor) process.stdout.write("\x1b[?25l")
+  draw()
+  await readKeys((key) => {
+    if (onKey(key) === true) return true
+    draw()
+  })
+  process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+  if (toggleCursor) process.stdout.write("\x1b[?25h")
+}
+
+function renderChoices(title: string, choices: Choice[], index: number, width: number) {
+  const lines = [`  ${c.bold(title)}`, ""]
+  for (const [i, choice] of choices.entries()) {
+    const label = (choice.label ?? choice.value).padEnd(width)
+    const marker = i === index ? c.green("●") : c.dim("○")
+    lines.push(`  ${marker} ${i === index ? c.bold(label) : label}${choice.hint ? `  ${c.dim(choice.hint)}` : ""}`)
+  }
+  lines.push("", `  ${c.dim("↑↓ move · enter choose · esc cancel")}`)
+  return lines
+}
+
+export async function select<T extends string>(title: string, choices: Choice<T>[], current?: T): Promise<T | null> {
+  let index = Math.max(
+    0,
+    choices.findIndex((choice) => choice.value === current),
+  )
+  const width = Math.max(...choices.map((choice) => (choice.label ?? choice.value).length))
+  let chosen: T | null = null
+  await interact(
+    () => renderChoices(title, choices, index, width),
+    (key) => {
+      if (key === keys.up || key === "k") index = (index + choices.length - 1) % choices.length
+      else if (key === keys.down || key === "j") index = (index + 1) % choices.length
+      else if (keys.enter.includes(key)) {
+        chosen = choices[index].value
+        return true
+      } else if (keys.escape.includes(key) || key === "q") return true
+    },
+  )
+  return chosen
+}
+
+export async function input(title: string, placeholder: string, initial = ""): Promise<string | null> {
+  let value = initial
+  let result: string | null = null
+  const render = () => [`  ${c.bold(title)}`, `  ${c.cyan("›")} ${value || c.dim(placeholder)}`, "", `  ${c.dim("enter save · esc cancel")}`]
+  await interact(
+    render,
+    (key) => {
+      if (keys.enter.includes(key)) {
+        result = value
+        return true
+      }
+      if (keys.escape.includes(key)) return true
+      if (keys.backspace.includes(key)) value = value.slice(0, -1)
+      else if (printable(key)) value += key
+    },
+    false,
+  )
+  return result
+}

package/src/cli/terminal/ui.ts

@@ -0,0 +1,137 @@
+import { homedir } from "node:os"
+
+const colorFor = (stream: NodeJS.WriteStream) => Boolean(stream.isTTY) && !process.env.NO_COLOR && process.env.TERM !== "dumb"
+export const useColor = colorFor(process.stdout)
+export const trueColor = /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? "")
+const useColorErr = colorFor(process.stderr)
+
+const paint =
+  (open: number, close: number, enabled = useColor) =>
+  (text: string) =>
+    enabled ? `\x1b[${open}m${text}\x1b[${close}m` : text
+
+export const c = {
+  bold: paint(1, 22),
+  dim: paint(2, 22),
+  italic: paint(3, 23),
+  cyan: paint(36, 39),
+  green: paint(32, 39),
+  yellow: paint(33, 39),
+  red: paint(31, 39),
+  magenta: paint(35, 39),
+}
+
+const errRed = paint(31, 39, useColorErr)
+const errDim = paint(2, 22, useColorErr)
+
+export function line(text = "") {
+  console.log(text)
+}
+
+export function ok(text: string) {
+  line(`${c.green("✓")} ${text}`)
+}
+
+export function note(text: string) {
+  line(`${c.dim("·")} ${text}`)
+}
+
+export function warn(text: string) {
+  line(`${c.yellow("!")} ${text}`)
+}
+
+export function fail(text: string, hint?: string): never {
+  console.error(`${errRed("✗")} ${text}`)
+  if (hint) console.error(`  ${errDim(hint)}`)
+  process.exit(1)
+}
+
+export function listFiles(files: string[]) {
+  for (const file of files) line(`    ${c.dim(tilde(file))}`)
+}
+
+export function rows(entries: Array<[string, string]>, indent = 2) {
+  const width = Math.max(...entries.map(([label]) => label.length))
+  for (const [label, value] of entries) line(`${" ".repeat(indent)}${c.dim(label.padEnd(width))}  ${value}`)
+}
+
+const ESC = "\x1b"
+const ANSI_STYLE = new RegExp(`${ESC}\\[[0-9;]*m`, "g")
+
+const visible = (text: string) => text.replace(ANSI_STYLE, "")
+
+export function table(entries: string[][], indent = 4, gap = 2) {
+  const columns = Math.max(...entries.map((row) => row.length))
+  const widths = Array.from({ length: columns }, (_, column) => Math.max(...entries.map((row) => visible(row[column] ?? "").length)))
+  for (const row of entries) {
+    const cells = widths.map((width, column) => (row[column] ?? "") + " ".repeat(Math.max(0, width - visible(row[column] ?? "").length)))
+    line(`${" ".repeat(indent)}${cells.join(" ".repeat(gap)).trimEnd()}`)
+  }
+}
+
+export function wrap(text: string, width: number): string[] {
+  const out: string[] = []
+  let current = ""
+  for (const word of text.split(" ")) {
+    if (current && current.length + 1 + word.length > width) {
+      out.push(current)
+      current = word
+    } else current = current ? `${current} ${word}` : word
+  }
+  if (current) out.push(current)
+  return out
+}
+
+export function plural(count: number, word: string) {
+  return `${count} ${word}${count === 1 ? "" : "s"}`
+}
+
+export function percent(share: number) {
+  return `${Math.round(share * 100)}%`
+}
+
+export function tilde(file: string) {
+  const home = homedir()
+  return file.startsWith(home) ? `~${file.slice(home.length)}` : file
+}
+
+export function tokens(count: number) {
+  for (const [scale, suffix] of [
+    [1e12, "T"],
+    [1e9, "B"],
+    [1e6, "M"],
+    [1e3, "k"],
+  ] as const) {
+    const scaled = count / scale
+    const shown = scaled.toFixed(scaled >= 10 ? 0 : 1)
+    if (Number(shown) >= 1) return `${shown}${suffix}`
+  }
+  return String(count)
+}
+
+export function ago(iso: string) {
+  const seconds = Math.max(0, Math.round((Date.now() - Date.parse(iso)) / 1000))
+  if (seconds < 60) return "just now"
+  if (seconds < 3_600) return `${Math.round(seconds / 60)}m ago`
+  if (seconds < 86_400) return `${Math.round(seconds / 3_600)}h ago`
+  return `${Math.round(seconds / 86_400)}d ago`
+}
+
+function editDistance(a: string, b: string) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i)
+  for (let i = 1; i <= a.length; i += 1) {
+    let previous = row[0]
+    row[0] = i
+    for (let j = 1; j <= b.length; j += 1) {
+      const current = row[j]
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1))
+      previous = current
+    }
+  }
+  return row[b.length]
+}
+
+export function closest(input: string, options: string[]) {
+  const [best] = options.map((option) => [option, editDistance(input, option)] as const).sort((x, y) => x[1] - y[1])
+  return best && best[1] <= 2 ? best[0] : null
+}

package/src/config/index.ts

@@ -1,15 +1,114 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
 import path from "node:path"
-import { DEFAULTS, EUNOE_DIR, MODES, paths, SEARCH_MODES } from "./constants"
-import type { Config } from "./types"
-
-export function normalizeConfig(raw: Record<string, any>): Config {
-  const config: Config = { ...DEFAULTS, ...raw }
-  if (!MODES.includes(config.mode)) config.mode = DEFAULTS.mode
-  if (!SEARCH_MODES.includes(config.search)) config.search = DEFAULTS.search
-  if (typeof config.compactAt !== "number" || config.compactAt <= 0 || config.compactAt > 1) config.compactAt = DEFAULTS.compactAt
-  if (config.keepTurns !== "all" && (typeof config.keepTurns !== "number" || config.keepTurns < 0)) config.keepTurns = DEFAULTS.keepTurns
+import { EUNOE_DIR, paths } from "./paths"
+
+export type Mode = "off" | "compact" | "default"
+export type SearchMode = "jsonl" | "markdown" | "xml" | "qmd"
+type Scope = "all" | "sessions"
+
+interface EvalConfig {
+  recallOptions?: { maxChars?: number; maxCharsMulti?: number; perQuery?: number }
+  strategy?: "tail" | "guide" | "trim"
+  rolling?: { keep: number; budget: number }
+  forceCut?: boolean
+  trustHeaders?: boolean
+  evidence?: boolean
+  recall?: boolean
+  rerank?: { model: string; candidates?: number; endpoint?: string }
+}
+
+export interface Tunables {
+  compactAt: number
+  keepTurns: number | "all"
+  keep: number
+  budget: number
+  turnCap: number | "off"
+  search: SearchMode
+  rerank: string
+}
+
+export type Tunable = keyof Tunables
+
+interface SessionSettings extends Partial<Tunables> {
+  mode?: Mode
+}
+
+export interface Config extends Tunables {
+  mode: Mode
+  scope: Scope
+  sessions: Record<string, SessionSettings>
+  port: number
+  upstream: string
+  claudeConfigDirs: string[]
+  window?: number
+  eval?: EvalConfig
+}
+
+export const DEFAULTS: Config = {
+  mode: "default",
+  scope: "all",
+  sessions: {},
+  port: 38663,
+  compactAt: 0.9,
+  keepTurns: "all",
+  keep: 3,
+  budget: 100_000,
+  turnCap: 100_000,
+  search: "markdown",
+  rerank: "jev-preview",
+  upstream: "https://api.anthropic.com",
+  claudeConfigDirs: [],
+}
+
+export const MODES: Mode[] = ["default", "compact", "off"]
+export const TUNABLES: Tunable[] = ["keep", "budget", "turnCap", "compactAt", "keepTurns", "search", "rerank"]
+
+const SEARCH_MODES: SearchMode[] = ["jsonl", "markdown", "xml", "qmd"]
+const TEXT_TUNABLES: Tunable[] = ["search", "rerank"]
+
+const isWhole = (value: unknown, min: number): value is number => Number.isInteger(value) && (value as number) >= min
+
+const validators: { [K in Tunable]: (value: unknown) => value is Tunables[K] } = {
+  compactAt: (value): value is number => typeof value === "number" && value > 0 && value <= 1,
+  keepTurns: (value): value is number | "all" => value === "all" || isWhole(value, 0),
+  keep: (value): value is number => isWhole(value, 1),
+  budget: (value): value is number => isWhole(value, 1_000),
+  turnCap: (value): value is number | "off" => value === "off" || isWhole(value, 1_000),
+  search: (value): value is SearchMode => SEARCH_MODES.includes(value as SearchMode),
+  rerank: (value): value is string => typeof value === "string" && /^[\w.-]+$/.test(value),
+}
+
+const isMode = (value: unknown): value is Mode => MODES.includes(value as Mode)
+
+const isRecord = (value: unknown): value is Record<string, unknown> => Boolean(value) && typeof value === "object" && !Array.isArray(value)
+
+export function parseTunable<K extends Tunable>(key: K, raw: string): Tunables[K] | null {
+  const value = TEXT_TUNABLES.includes(key) || raw === "all" || raw === "off" ? raw : Number(raw.replace(/[_,]/g, ""))
+  return validators[key](value) ? (value as Tunables[K]) : null
+}
+
+function normalizeSession(value: unknown): SessionSettings | null {
+  if (value === null) return {}
+  if (isMode(value)) return { mode: value }
+  if (!isRecord(value)) return null
+  const settings: SessionSettings = isMode(value.mode) ? { mode: value.mode } : {}
+  for (const key of TUNABLES) if (validators[key](value[key])) Object.assign(settings, { [key]: value[key] })
+  return settings
+}
+
+export function normalizeConfig(raw: Record<string, unknown>): Config {
+  const config = { ...DEFAULTS, ...raw } as Config
+  if (!isMode(config.mode)) config.mode = DEFAULTS.mode
+  if (config.scope !== "all" && config.scope !== "sessions") config.scope = DEFAULTS.scope
+  for (const key of TUNABLES) if (!validators[key](config[key])) Object.assign(config, { [key]: DEFAULTS[key] })
+  const sessions = isRecord(config.sessions) ? config.sessions : {}
+  config.sessions = Object.fromEntries(
+    Object.entries(sessions).flatMap(([id, value]) => {
+      const settings = normalizeSession(value)
+      return settings ? [[id, settings]] : []
+    }),
+  )
   if (!Number.isInteger(config.port)) config.port = DEFAULTS.port
   if (!Array.isArray(config.claudeConfigDirs)) config.claudeConfigDirs = []
   return config
@@ -17,7 +116,7 @@ export function normalizeConfig(raw: Record<string, any>): Config {
 
 let cached: { mtimeMs: number; config: Config } | null = null
 
-export function loadConfig(): Config {
+export function readConfig(): Config {
   let mtimeMs: number
   try {
     mtimeMs = statSync(paths.config).mtimeMs
@@ -28,9 +127,7 @@ export function loadConfig(): Config {
   let config = DEFAULTS
   try {
     config = normalizeConfig(JSON.parse(readFileSync(paths.config, "utf8")))
-  } catch (error) {
-    console.error(`[eunoe] ${paths.config} is not valid JSON; using defaults`, error)
-  }
+  } catch {}
   cached = { mtimeMs, config }
   return config
 }
@@ -38,7 +135,7 @@ export function loadConfig(): Config {
 export function saveConfig(patch: Partial<Config>) {
   mkdirSync(EUNOE_DIR, { recursive: true })
   const current = existsSync(paths.config) ? JSON.parse(readFileSync(paths.config, "utf8")) : {}
-  writeFileSync(paths.config, JSON.stringify({ ...current, ...patch }, null, 2) + "\n")
+  writeFileSync(paths.config, `${JSON.stringify({ ...current, ...patch }, null, 2)}\n`)
 }
 
 export function claudeConfigDirs(config: Config): string[] {
@@ -47,3 +144,20 @@ export function claudeConfigDirs(config: Config): string[] {
   for (const dir of config.claudeConfigDirs) dirs.add(dir.replace(/^~(?=$|\/)/, homedir()))
   return [...dirs]
 }
+
+export function modeFor(config: Config, sessionId: string | null): Mode {
+  if (sessionId && sessionId in config.sessions) return config.sessions[sessionId].mode ?? config.mode
+  return config.scope === "all" ? config.mode : "off"
+}
+
+export function compactionOwner(config: Config): Mode {
+  return modeFor(config, null)
+}
+
+export function overrides(settings: SessionSettings | undefined): Partial<Tunables> {
+  return Object.fromEntries(TUNABLES.filter((key) => settings?.[key] !== undefined).map((key) => [key, settings?.[key]]))
+}
+
+export function settingsFor(config: Config, sessionId: string | null): Config {
+  return { ...config, ...overrides(sessionId ? config.sessions[sessionId] : undefined), mode: modeFor(config, sessionId) }
+}

package/src/config/{constants.ts → paths.ts}

@@ -1,6 +1,5 @@
 import { homedir } from "node:os"
 import path from "node:path"
-import type { Config, Mode, SearchMode } from "./types"
 
 export const EUNOE_DIR = process.env.EUNOE_DIR ?? path.join(homedir(), ".eunoe")
 
@@ -10,18 +9,9 @@ export const paths = {
   threads: path.join(EUNOE_DIR, "threads"),
   transcripts: path.join(EUNOE_DIR, "transcripts"),
   models: path.join(EUNOE_DIR, "models.json"),
+  sessions: path.join(EUNOE_DIR, "sessions.json"),
   proxyLog: path.join(EUNOE_DIR, "proxy.log"),
+  typesafeKey: path.join(EUNOE_DIR, "typesafe-key"),
+  loaded: path.join(EUNOE_DIR, "loaded"),
+  watch: path.join(EUNOE_DIR, "watch.json"),
 }
-
-export const DEFAULTS: Config = {
-  mode: "compact",
-  port: 8788,
-  compactAt: 0.9,
-  keepTurns: "all",
-  search: "markdown",
-  upstream: "https://api.anthropic.com",
-  claudeConfigDirs: [],
-}
-
-export const MODES: Mode[] = ["off", "trim", "compact"]
-export const SEARCH_MODES: SearchMode[] = ["jsonl", "markdown", "xml", "qmd"]