@chroxify/eunoe 1.0.0 → 1.2.0

package/src/cli/{help.ts → terminal/help.ts}

@@ -1,20 +1,36 @@
-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).filter(([, command]) => !command.hidden)) 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()

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/{ui.ts → terminal/ui.ts}

@@ -1,12 +1,14 @@
 import { homedir } from "node:os"
-import { TYPO_DISTANCE } from "./constants"
 
 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)
+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),
@@ -27,15 +29,15 @@ export function line(text = "") {
 }
 
 export function ok(text: string) {
-  console.log(`${c.green("✓")} ${text}`)
+  line(`${c.green("✓")} ${text}`)
 }
 
 export function note(text: string) {
-  console.log(`${c.dim("·")} ${text}`)
+  line(`${c.dim("·")} ${text}`)
 }
 
 export function warn(text: string) {
-  console.log(`${c.yellow("!")} ${text}`)
+  line(`${c.yellow("!")} ${text}`)
 }
 
 export function fail(text: string, hint?: string): never {
@@ -50,18 +52,38 @@ export function listFiles(files: string[]) {
 
 export function rows(entries: Array<[string, string]>, indent = 2) {
   const width = Math.max(...entries.map(([label]) => label.length))
-  for (const [label, value] of entries) console.log(`${" ".repeat(indent)}${c.dim(label.padEnd(width))}  ${value}`)
+  for (const [label, value] of entries) line(`${" ".repeat(indent)}${c.dim(label.padEnd(width))}  ${value}`)
 }
 
-const visible = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "")
+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)))
-    console.log(`${" ".repeat(indent)}${cells.join(" ".repeat(gap)).trimEnd()}`)
+    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) {
@@ -74,8 +96,16 @@ export function tilde(file: string) {
 }
 
 export function tokens(count: number) {
-  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(count >= 10_000_000 ? 0 : 1)}M`
-  if (count >= 1_000) return `${(count / 1_000).toFixed(count >= 10_000 ? 0 : 1)}k`
+  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)
 }
 
@@ -87,20 +117,21 @@ export function ago(iso: string) {
   return `${Math.round(seconds / 86_400)}d ago`
 }
 
-export function closest(input: string, options: string[]) {
-  const distance = (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
-      }
+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]
   }
-  const [best] = options.map((option) => [option, distance(input, option)] as const).sort((x, y) => x[1] - y[1])
-  return best && best[1] <= TYPO_DISTANCE ? best[0] : null
+  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/cli/usage/index.ts

@@ -0,0 +1,151 @@
+import { readFileSync, statSync } from "node:fs"
+import path from "node:path"
+import { listEntries, projectFolders } from "../../transcript/locate"
+import { subagentsDir } from "../../transcript/subagents"
+
+export interface UsageEntry {
+  at: number
+  model: string
+  input: number
+  output: number
+  cacheWrite5m: number
+  cacheWrite1h: number
+  cacheRead: number
+  fast: boolean
+}
+
+interface Price {
+  input: number
+  output: number
+  cacheRead: number
+}
+
+interface RawUsage {
+  input_tokens?: number
+  output_tokens?: number
+  cache_creation_input_tokens?: number
+  cache_read_input_tokens?: number
+  cache_creation?: { ephemeral_5m_input_tokens?: number; ephemeral_1h_input_tokens?: number }
+  service_tier?: string
+  speed?: string
+}
+
+interface RawLine {
+  timestamp?: string
+  requestId?: string
+  message?: { id?: string; model?: string; usage?: RawUsage }
+}
+
+const PRICES: Array<[prefix: string, price: Price]> = [
+  ["claude-fable-5-1", { input: 10, output: 50, cacheRead: 0.25 }],
+  ["claude-mythos-5-1", { input: 10, output: 50, cacheRead: 0.25 }],
+  ["claude-fable-5", { input: 10, output: 50, cacheRead: 1 }],
+  ["claude-mythos-5", { input: 10, output: 50, cacheRead: 1 }],
+  ["claude-opus-5-5", { input: 4, output: 20, cacheRead: 0.2 }],
+  ["claude-opus-5", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-opus-4-8", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-opus-4-7", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-opus-4-6", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-opus-4-5", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-sonnet-5-5", { input: 2, output: 10, cacheRead: 0.2 }],
+  ["claude-sonnet-5", { input: 2, output: 10, cacheRead: 0.2 }],
+  ["claude-sonnet-4", { input: 3, output: 15, cacheRead: 0.3 }],
+  ["claude-haiku-4-5", { input: 1, output: 5, cacheRead: 0.1 }],
+]
+
+const CACHE_WRITE_5M = 1.25
+const CACHE_WRITE_1H = 2
+const FAST_MULTIPLIER = 2
+const PLACEHOLDER_INPUT = 1000
+
+const priceFor = (model: string) => PRICES.find(([prefix]) => model === prefix || model.startsWith(`${prefix}-`))?.[1] ?? null
+
+export function ratesOf(entry: UsageEntry): { read: number; write: number } | null {
+  const price = priceFor(entry.model)
+  if (!price) return null
+  const writes = entry.cacheWrite5m + entry.cacheWrite1h
+  const writeShare = writes > 0 ? (entry.cacheWrite5m * CACHE_WRITE_5M + entry.cacheWrite1h * CACHE_WRITE_1H) / writes : CACHE_WRITE_1H
+  const scale = (entry.fast ? FAST_MULTIPLIER : 1) / 1e6
+  return { read: price.cacheRead * scale, write: price.input * writeShare * scale }
+}
+
+export function costOf(entry: UsageEntry): number | null {
+  const price = priceFor(entry.model)
+  if (!price) return null
+  const dollars = entry.input * price.input + entry.output * price.output + entry.cacheRead * price.cacheRead + entry.cacheWrite5m * price.input * CACHE_WRITE_5M + entry.cacheWrite1h * price.input * CACHE_WRITE_1H
+  return (dollars / 1e6) * (entry.fast ? FAST_MULTIPLIER : 1)
+}
+
+const fromApi = (usage: RawUsage) => usage.service_tier !== undefined
+
+const isPlaceholder = (usage: RawUsage) => !fromApi(usage) && usage.input_tokens === PLACEHOLDER_INPUT && !usage.cache_read_input_tokens && !usage.cache_creation_input_tokens
+
+const supersedes = (next: RawUsage, known: RawUsage) =>
+  fromApi(next) !== fromApi(known)
+    ? fromApi(next)
+    : (next.output_tokens ?? 0) > (known.output_tokens ?? 0) || ((next.output_tokens ?? 0) === (known.output_tokens ?? 0) && (next.cache_creation_input_tokens ?? 0) > (known.cache_creation_input_tokens ?? 0))
+
+function entryOf(line: RawLine, usage: RawUsage, at: number): UsageEntry {
+  const written = usage.cache_creation_input_tokens ?? 0
+  const hour = Math.min(written, usage.cache_creation?.ephemeral_1h_input_tokens ?? 0)
+  return {
+    at,
+    model: line.message?.model ?? "unknown",
+    input: usage.input_tokens ?? 0,
+    output: usage.output_tokens ?? 0,
+    cacheWrite5m: written - hour,
+    cacheWrite1h: hour,
+    cacheRead: usage.cache_read_input_tokens ?? 0,
+    fast: usage.speed === "fast",
+  }
+}
+
+export function usageFiles(configDirs: string[], since: number): string[] {
+  const files: string[] = []
+  const recent = (file: string) => {
+    try {
+      return statSync(file).mtimeMs >= since
+    } catch {
+      return false
+    }
+  }
+  for (const folder of projectFolders(configDirs)) {
+    for (const name of listEntries(folder)) {
+      if (!name.endsWith(".jsonl")) continue
+      const file = path.join(folder, name)
+      if (recent(file)) files.push(file)
+      const subagents = subagentsDir(file)
+      for (const agent of listEntries(subagents)) if (agent.endsWith(".jsonl") && recent(path.join(subagents, agent))) files.push(path.join(subagents, agent))
+    }
+  }
+  return files.sort()
+}
+
+export function readUsage(files: string[], since: number): UsageEntry[] {
+  const seen = new Map<string, { usage: RawUsage; entry: UsageEntry }>()
+  for (const file of files) {
+    let text: string
+    try {
+      text = readFileSync(file, "utf8")
+    } catch {
+      continue
+    }
+    for (const [index, raw] of text.split("\n").entries()) {
+      if (!raw.includes('"usage"')) continue
+      let line: RawLine
+      try {
+        line = JSON.parse(raw)
+      } catch {
+        continue
+      }
+      const usage = line.message?.usage
+      const at = Date.parse(line.timestamp ?? "")
+      if (!usage || !(at >= since) || line.message?.model === "<synthetic>") continue
+      const key = line.message?.id ? `${line.message.id}:${line.requestId ?? ""}` : `${file}:${index}`
+      const known = seen.get(key)
+      if (known && !supersedes(usage, known.usage)) continue
+      seen.set(key, { usage, entry: entryOf(line, usage, at) })
+    }
+  }
+  return [...seen.values()].filter(({ usage }) => !isPlaceholder(usage)).map(({ entry }) => entry)
+}

package/src/config/index.ts

@@ -1,47 +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, SCOPES, SEARCH_MODES, TUNABLES } from "./constants"
-import type { Config, Mode, SessionSettings, Tunable, Tunables } from "./types"
+import { EUNOE_DIR, paths } from "./paths"
 
-const VALID: { [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" || (Number.isInteger(value) && (value as number) >= 0),
-  keep: (value): value is number => Number.isInteger(value) && (value as number) >= 1,
-  budget: (value): value is number => Number.isInteger(value) && (value as number) >= 1_000,
-  search: (value): value is Tunables["search"] => SEARCH_MODES.includes(value as Tunables["search"]),
-  rerank: (value): value is string => typeof value === "string" && /^[\w.-]+$/.test(value),
+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 : Number(raw.replace(/[_,]/g, ""))
-  return VALID[key](value) ? value as 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 (!value || typeof value !== "object" || Array.isArray(value)) return null
-  const raw = value as Record<string, unknown>
-  const settings: SessionSettings = isMode(raw.mode) ? { mode: raw.mode } : {}
-  for (const key of TUNABLES) if (VALID[key](raw[key])) Object.assign(settings, { [key]: raw[key] })
+  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, any>): Config {
-  const config: Config = { ...DEFAULTS, ...raw }
+export function normalizeConfig(raw: Record<string, unknown>): Config {
+  const config = { ...DEFAULTS, ...raw } as Config
   if (!isMode(config.mode)) config.mode = DEFAULTS.mode
-  if (!SCOPES.includes(config.scope)) config.scope = DEFAULTS.scope
-  for (const key of TUNABLES) if (!VALID[key](config[key])) Object.assign(config, { [key]: DEFAULTS[key] })
-  const sessions = config.sessions && typeof config.sessions === "object" && !Array.isArray(config.sessions) ? config.sessions : {}
-  config.sessions = Object.fromEntries(Object.entries(sessions).flatMap(([id, value]) => {
-    const settings = normalizeSession(value)
-    return settings ? [[id, settings]] : []
-  }))
+  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
@@ -49,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
@@ -60,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
 }
@@ -70,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[] {
@@ -85,14 +150,14 @@ export function modeFor(config: Config, sessionId: string | null): 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]]))
+  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) }
 }
-
-export function compactionOwner(config: Config): Mode {
-  return config.scope === "all" ? config.mode : "off"
-}

package/src/config/paths.ts

@@ -0,0 +1,17 @@
+import { homedir } from "node:os"
+import path from "node:path"
+
+export const EUNOE_DIR = process.env.EUNOE_DIR ?? path.join(homedir(), ".eunoe")
+
+export const paths = {
+  config: path.join(EUNOE_DIR, "config.json"),
+  requests: path.join(EUNOE_DIR, "requests.jsonl"),
+  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"),
+}