0sec-cli 0.15.0 → 0.18.0

package/chunks/chunk-GMT2AZKM.js

@@ -0,0 +1,2439 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+import {
+  ANALYTICS_LEVEL_ENV,
+  analyticsPipeline,
+  levelAtLeast,
+  resolveAnalyticsLevel
+} from "./chunk-BZNEY2ZS.js";
+import {
+  DEFAULT_ALLOW_MODEL_SELF_EXTENSION,
+  createPresentationEvent,
+  homeStateDir
+} from "./chunk-6L26OBWI.js";
+
+// packages/cli/src/tui/settings-store.ts
+import { useSyncExternalStore } from "react";
+
+// packages/cli/src/tui/settings.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+
+// packages/cli/src/tui/keybindings.ts
+var KEYBINDINGS = [
+  // ── Composer ──────────────────────────────────────────────────────────────
+  {
+    id: "composer.send",
+    keys: "Enter",
+    defaultChords: ["return"],
+    rebindable: false,
+    description: "Send the message or run the highlighted slash command; queues the line when a turn is already in flight.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.name === "return") { \u2026 send / queue / dequeue }'
+  },
+  {
+    id: "composer.newline",
+    keys: "Shift+Enter",
+    defaultChords: ["shift+return"],
+    rebindable: false,
+    description: "Insert a newline instead of sending (terminals without the kitty protocol fall through to send).",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.name === "return" && key.shift) setComposerText(`${\u2026}\\n`)'
+  },
+  {
+    id: "composer.complete-command",
+    keys: "Tab",
+    defaultChords: ["tab"],
+    rebindable: false,
+    description: "Complete the highlighted slash command in the command menu.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.name === "tab") setComposerText(completionFor(selectedSlashCommand, \u2026))'
+  },
+  {
+    id: "composer.edit-queued",
+    keys: "Ctrl+Y",
+    defaultChords: ["ctrl+y"],
+    rebindable: true,
+    description: "Pull the most recently queued message back into the composer to edit, re-send, or drop.",
+    category: "Composer",
+    handler: 'if (matchesBinding(key, "composer.edit-queued", \u2026) && queuedRef.current.length > 0) \u2026'
+  },
+  {
+    id: "composer.delete-word",
+    keys: "Ctrl+W / Alt+Backspace",
+    defaultChords: ["ctrl+w", "option+backspace"],
+    rebindable: false,
+    description: "Delete the word before the cursor.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.ctrl && key.name === "w") / if (key.name === "backspace" && (key.meta || key.option || key.ctrl)) \u2192 deletePreviousWord'
+  },
+  {
+    id: "composer.delete-to-start",
+    keys: "Ctrl+U",
+    defaultChords: ["ctrl+u"],
+    rebindable: false,
+    description: "Delete from the cursor to the start of the line.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.ctrl && key.name === "u") \u2192 deleteToLineStart'
+  },
+  {
+    id: "composer.accept-suggestion",
+    keys: "Right",
+    defaultChords: ["right"],
+    rebindable: false,
+    description: "Accept the inline autosuggestion, filling the ghost suffix into the draft without sending.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.name === "right") { const suffix = suggestCompletion(...); if (suffix) setComposerText(`${\u2026}${suffix}`) }'
+  },
+  // ── Navigation ──────────────────────────────────────────────────────────────
+  {
+    id: "nav.palette",
+    keys: "Ctrl+P / Ctrl+K",
+    defaultChords: ["ctrl+p", "ctrl+k"],
+    rebindable: true,
+    description: "Open the slash-command palette.",
+    category: "Navigation",
+    handler: 'if (matchesBinding(key, "nav.palette", \u2026)) setComposerText("/")'
+  },
+  {
+    id: "nav.history-prev",
+    keys: "Up",
+    defaultChords: ["up"],
+    rebindable: false,
+    description: "Recall the previous submitted message into the composer (also moves the selection in menus and overlays).",
+    category: "Navigation",
+    lockReason: "modal",
+    handler: 'if (key.name === "up") recallComposerHistory("up")'
+  },
+  {
+    id: "nav.history-next",
+    keys: "Down",
+    defaultChords: ["down"],
+    rebindable: false,
+    description: "Recall the next message, or \u2014 on an empty composer with workers running \u2014 drop into the active-subagents list.",
+    category: "Navigation",
+    lockReason: "modal",
+    handler: 'if (key.name === "down") { setAgentNavIndex(0) | recallComposerHistory("down") }'
+  },
+  {
+    id: "nav.jump-agents",
+    keys: "Ctrl+G",
+    defaultChords: ["ctrl+g"],
+    rebindable: true,
+    description: "Drop straight into the active-subagents list from the composer (a direct chord complementing Down).",
+    category: "Navigation",
+    handler: 'if (matchesBinding(key, "nav.jump-agents", \u2026) && workerRoster.length) setAgentNavIndex(0)'
+  },
+  {
+    id: "nav.open-comms",
+    keys: "Ctrl+T",
+    defaultChords: ["ctrl+t"],
+    rebindable: true,
+    description: "Open the agent comms view (the live sub-agent fleet) from chat.",
+    category: "Navigation",
+    handler: 'if (matchesBinding(key, "nav.open-comms", \u2026)) onNavigate("comms")'
+  },
+  {
+    id: "nav.escape",
+    keys: "Esc",
+    defaultChords: ["escape"],
+    rebindable: false,
+    description: "Step back one level: close the command menu, then clear the draft, then interrupt a running turn, then leave the screen.",
+    category: "Navigation",
+    lockReason: "modal",
+    handler: 'if (key.name === "escape") { \u2026 interruptTurn() \u2026 onGoBack() }'
+  },
+  {
+    id: "nav.scroll-up",
+    keys: "PageUp / Ctrl+Up",
+    defaultChords: ["pageup", "ctrl+up"],
+    rebindable: true,
+    description: "Scroll the transcript up by half a viewport.",
+    category: "Navigation",
+    handler: 'if (matchesBinding(key, "nav.scroll-up", \u2026)) transcriptRef.current?.scrollBy(-0.5, "viewport")'
+  },
+  {
+    id: "nav.scroll-down",
+    keys: "PageDown / Ctrl+Down",
+    defaultChords: ["pagedown", "ctrl+down"],
+    rebindable: true,
+    description: "Scroll the transcript down by half a viewport.",
+    category: "Navigation",
+    handler: 'if (matchesBinding(key, "nav.scroll-down", \u2026)) transcriptRef.current?.scrollBy(0.5, "viewport")'
+  },
+  {
+    id: "nav.focus-subagent",
+    keys: "Enter",
+    defaultChords: ["return"],
+    rebindable: false,
+    description: "In the active-subagents list, drill into the highlighted subagent's live focus view.",
+    category: "Navigation",
+    lockReason: "modal",
+    handler: 'if (agentNavIndex >= 0) { if (key.name === "return") setFocusAgentId(agent.agent_id) }'
+  },
+  {
+    id: "nav.leave-subagent",
+    keys: "Left / Esc",
+    defaultChords: ["left", "escape"],
+    rebindable: false,
+    description: "Return from the active-subagents list or a subagent focus view back to the composer.",
+    category: "Navigation",
+    lockReason: "modal",
+    handler: 'if (focusAgentId) / if (agentNavIndex >= 0) { if (key.name === "escape" || key.name === "left") \u2026 }'
+  },
+  // ── Session ─────────────────────────────────────────────────────────────────
+  {
+    id: "session.quit",
+    keys: "Ctrl+C",
+    defaultChords: ["ctrl+c"],
+    rebindable: false,
+    description: "Press twice within 3 seconds to quit; the first press arms and warns.",
+    category: "Session",
+    lockReason: "quit",
+    handler: 'if (key.ctrl && key.name === "c") requestExitRef.current()'
+  },
+  // ── View ────────────────────────────────────────────────────────────────────
+  // The only rebindable set: self-contained, stateless toggles that call
+  // `updateSetting(...)` and take no part in text entry or modal cycles.
+  {
+    id: "view.left-sidebar",
+    keys: "Ctrl+B",
+    defaultChords: ["ctrl+b"],
+    rebindable: true,
+    description: "Toggle the left sidebar (persists across the session).",
+    category: "View",
+    handler: 'if (matchesBinding(key, "view.left-sidebar", \u2026)) updateSetting("showLeftSidebar", \u2026)'
+  },
+  {
+    id: "view.right-sidebar",
+    keys: "Ctrl+L",
+    defaultChords: ["ctrl+l"],
+    rebindable: true,
+    description: "Toggle the right sidebar (persists across the session).",
+    category: "View",
+    handler: 'if (matchesBinding(key, "view.right-sidebar", \u2026)) updateSetting("showRightSidebar", \u2026)'
+  },
+  {
+    id: "view.transcript-detail",
+    keys: "Ctrl+R",
+    defaultChords: ["ctrl+r"],
+    rebindable: true,
+    description: "Toggle the whole transcript between collapsed and expanded tool/reasoning detail (persists across the session).",
+    category: "View",
+    handler: 'if (matchesBinding(key, "view.transcript-detail", \u2026)) updateSetting("transcriptDetail", \u2026)'
+  },
+  {
+    id: "overlay.review-toggle",
+    keys: "Ctrl+O",
+    defaultChords: ["ctrl+o"],
+    rebindable: true,
+    description: "Open (and close) the full-screen transcript-review overlay.",
+    category: "View",
+    handler: 'if (matchesBinding(key, "overlay.review-toggle", \u2026)) setReviewOpen(true) / (reviewOpen) close'
+  },
+  {
+    id: "overlay.review-top",
+    keys: "Ctrl+Home",
+    defaultChords: ["ctrl+home"],
+    rebindable: false,
+    description: "Jump to the top of the transcript-review overlay.",
+    category: "View",
+    lockReason: "modal",
+    handler: 'if (reviewOpen && key.ctrl && key.name === "home") review.scrollY = 0'
+  },
+  {
+    id: "overlay.review-bottom",
+    keys: "Ctrl+End",
+    defaultChords: ["ctrl+end"],
+    rebindable: false,
+    description: "Jump to the bottom of the transcript-review overlay.",
+    category: "View",
+    lockReason: "modal",
+    handler: 'if (reviewOpen && key.ctrl && key.name === "end") review.scrollY = review.maxScrollY'
+  },
+  // ── Autonomy ─────────────────────────────────────────────────────────────────
+  {
+    id: "autonomy.cycle-mode",
+    keys: "Shift+Tab",
+    defaultChords: ["shift+tab"],
+    rebindable: false,
+    description: "Cycle the autonomy mode: Standard \u2192 Co-pilot \u2192 YOLO \u2192 Recon; no preconfigured scope is required.",
+    category: "Autonomy",
+    lockReason: "mode-cycle",
+    handler: "if (isAutonomyCycleKey(key)) routeSlashCommand(`/mode ${next}`)"
+  }
+];
+var KEYBINDING_CATEGORIES = [
+  "Composer",
+  "Navigation",
+  "Session",
+  "View",
+  "Autonomy"
+];
+function keybindingsByCategory(bindings = KEYBINDINGS) {
+  const grouped = /* @__PURE__ */ new Map();
+  const push = (binding) => {
+    const existing = grouped.get(binding.category);
+    if (existing) existing.push(binding);
+    else grouped.set(binding.category, [binding]);
+  };
+  for (const category of KEYBINDING_CATEGORIES) {
+    for (const binding of bindings) {
+      if (binding.category === category) push(binding);
+    }
+  }
+  for (const binding of bindings) {
+    if (!KEYBINDING_CATEGORIES.includes(binding.category)) push(binding);
+  }
+  return grouped;
+}
+var MODIFIER_ALIASES = {
+  ctrl: "ctrl",
+  control: "ctrl",
+  ctl: "ctrl",
+  shift: "shift",
+  meta: "meta",
+  cmd: "meta",
+  command: "meta",
+  super: "meta",
+  win: "meta",
+  option: "option",
+  opt: "option",
+  alt: "option"
+};
+var NAME_ALIASES = {
+  esc: "escape",
+  escape: "escape",
+  enter: "return",
+  return: "return",
+  ret: "return",
+  pgup: "pageup",
+  pageup: "pageup",
+  pgdn: "pagedown",
+  pgdown: "pagedown",
+  pagedown: "pagedown",
+  del: "delete",
+  ins: "insert",
+  space: "space",
+  spacebar: "space"
+};
+function formatChord(chord) {
+  const parts = [];
+  if (chord.ctrl) parts.push("ctrl");
+  if (chord.shift) parts.push("shift");
+  if (chord.meta) parts.push("meta");
+  if (chord.option) parts.push("option");
+  parts.push(chord.name);
+  return parts.join("+");
+}
+function parseChord(input) {
+  if (typeof input !== "string") return null;
+  const tokens = input.split("+").map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0);
+  if (tokens.length === 0) return null;
+  let ctrl = false;
+  let shift = false;
+  let meta = false;
+  let option = false;
+  let name;
+  for (const token of tokens) {
+    const modifier = MODIFIER_ALIASES[token];
+    if (modifier) {
+      if (modifier === "ctrl") ctrl = true;
+      else if (modifier === "shift") shift = true;
+      else if (modifier === "meta") meta = true;
+      else option = true;
+      continue;
+    }
+    if (name !== void 0) return null;
+    if (/\s/.test(token)) return null;
+    name = NAME_ALIASES[token] ?? token;
+  }
+  if (name === void 0 || name.length === 0) return null;
+  return { ctrl, shift, meta, option, name };
+}
+function chordFromKey(key) {
+  const name = typeof key.name === "string" ? key.name.toLowerCase() : "";
+  if (name.length === 0) return null;
+  return {
+    ctrl: Boolean(key.ctrl),
+    shift: Boolean(key.shift),
+    meta: Boolean(key.meta),
+    option: Boolean(key.option),
+    name
+  };
+}
+function keyMatchesChord(key, chord) {
+  if (typeof chord !== "string" || chord.length === 0) return false;
+  const parsed = parseChord(chord);
+  if (!parsed) return false;
+  const pressed = chordFromKey(key);
+  if (!pressed) return false;
+  return formatChord(pressed) === formatChord(parsed);
+}
+function isAssignableChord(chord) {
+  if (!chord || chord.name.length === 0) return false;
+  return chord.ctrl || chord.meta || chord.option;
+}
+var REBINDABLE_IDS = new Set(
+  KEYBINDINGS.filter((binding) => binding.rebindable).map((binding) => binding.id)
+);
+function effectiveChords(binding, overrides) {
+  if (binding.rebindable && overrides) {
+    const raw = overrides[binding.id];
+    const parsed = parseChord(raw);
+    if (parsed && isAssignableChord(parsed)) return [formatChord(parsed)];
+  }
+  return [...binding.defaultChords];
+}
+function reservedChords(bindings = KEYBINDINGS) {
+  const reserved = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    if (binding.rebindable) continue;
+    for (const chord of binding.defaultChords) reserved.add(chord);
+  }
+  return reserved;
+}
+function matchesBinding(key, id, overrides, bindings = KEYBINDINGS) {
+  const binding = bindings.find((entry) => entry.id === id);
+  if (!binding) return false;
+  const chord = chordFromKey(key);
+  if (!chord) return false;
+  return effectiveChords(binding, overrides).includes(formatChord(chord));
+}
+function reservedOwner(bindings, chord) {
+  return bindings.find((binding) => !binding.rebindable && binding.defaultChords.includes(chord));
+}
+function assessChordAssignment(id, key, overrides, bindings = KEYBINDINGS) {
+  const target = bindings.find((entry) => entry.id === id);
+  if (!target || !target.rebindable) return null;
+  const chord = chordFromKey(key);
+  if (!chord) return null;
+  const canonical = formatChord(chord);
+  if (!isAssignableChord(chord)) return { kind: "unassignable", chord: canonical };
+  const owner = reservedOwner(bindings, canonical);
+  if (owner) {
+    return { kind: "conflict", chord: canonical, conflictId: owner.id, conflictLabel: owner.description };
+  }
+  for (const binding of bindings) {
+    if (binding.id === id || !binding.rebindable) continue;
+    if (effectiveChords(binding, overrides).includes(canonical)) {
+      return { kind: "conflict", chord: canonical, conflictId: binding.id, conflictLabel: binding.description };
+    }
+  }
+  return { kind: "ok", chord: canonical };
+}
+function sanitizeKeybindingOverrides(raw, bindings = KEYBINDINGS) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {};
+  const reserved = reservedChords(bindings);
+  const candidates = {};
+  for (const [id, value] of Object.entries(raw)) {
+    if (!REBINDABLE_IDS.has(id)) continue;
+    const parsed = parseChord(value);
+    if (!parsed || !isAssignableChord(parsed)) continue;
+    const canonical = formatChord(parsed);
+    if (reserved.has(canonical)) continue;
+    candidates[id] = canonical;
+  }
+  const occupied = /* @__PURE__ */ new Map();
+  for (const binding of bindings) {
+    if (!binding.rebindable) continue;
+    for (const chord of effectiveChords(binding, candidates)) {
+      if (!chord) continue;
+      const existing = occupied.get(chord);
+      if (existing) {
+        if (!existing.includes(binding.id)) existing.push(binding.id);
+      } else occupied.set(chord, [binding.id]);
+    }
+  }
+  for (const [, ids] of occupied) {
+    if (ids.length <= 1) continue;
+    for (const id of ids) delete candidates[id];
+  }
+  return candidates;
+}
+
+// packages/cli/src/tui/themes.ts
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+
+// packages/cli/src/tui/user-themes.ts
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function coerceUserTheme(id, raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { ok: false, reason: "file is not a JSON object" };
+  }
+  const record = raw;
+  const issues = validateTheme(record.palette);
+  if (issues.length > 0) {
+    return { ok: false, reason: issues.map((i) => i.message).join("; ") };
+  }
+  const label = typeof record.label === "string" && record.label.length > 0 ? record.label : id;
+  const description = typeof record.description === "string" ? record.description : "User theme.";
+  const mode = record.mode === "light" ? "light" : "dark";
+  return {
+    ok: true,
+    entry: { name: id, label, description, mode, palette: record.palette }
+  };
+}
+function loadUserThemes(dir) {
+  const valid = [];
+  const rejected = [];
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return { valid, rejected };
+  }
+  for (const file of [...files].sort()) {
+    if (!file.endsWith(".json")) continue;
+    const id = file.slice(0, -".json".length);
+    if (!isSafeThemeId(id)) {
+      rejected.push({
+        name: id,
+        file,
+        reason: "invalid theme name \u2014 must be a lowercase dotted/hyphenated identifier of at most 64 characters, with no path separators"
+      });
+      continue;
+    }
+    if (isThemeName(id)) {
+      rejected.push({
+        name: id,
+        file,
+        reason: `"${id}" is a built-in theme name and cannot be overridden \u2014 rename the file`
+      });
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync(join(dir, file), "utf8"));
+    } catch (err) {
+      rejected.push({
+        name: id,
+        file,
+        reason: `could not read or parse: ${err instanceof Error ? err.message : String(err)}`
+      });
+      continue;
+    }
+    const result = coerceUserTheme(id, parsed);
+    if (result.ok) valid.push(result.entry);
+    else rejected.push({ name: id, file, reason: result.reason });
+  }
+  valid.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  return { valid, rejected };
+}
+
+// packages/cli/src/tui/themes.ts
+var BACKGROUND_TOKENS = ["CANVAS", "PANEL", "PANEL_ALT"];
+var TEXT_TOKENS = [
+  "TEXT",
+  "MUTED",
+  "PRIMARY",
+  "ACCENT",
+  "BRAND",
+  "SUCCESS",
+  "WARNING",
+  "ERROR",
+  "INFO"
+];
+var CHROME_TOKENS = ["BORDER"];
+var LAYER_TOKENS = ["background", "surface", "surfaceAlt", "overlay"];
+var SYNTAX_TOKENS = [
+  "syntaxKeyword",
+  "syntaxString",
+  "syntaxNumber",
+  "syntaxComment",
+  "syntaxFunction",
+  "syntaxType",
+  "syntaxVariable",
+  "syntaxOperator",
+  "syntaxPunctuation",
+  "DIFF_ADD",
+  "DIFF_DEL",
+  "LINK"
+];
+var THEME_TOKENS = [
+  ...BACKGROUND_TOKENS,
+  ...TEXT_TOKENS,
+  ...CHROME_TOKENS,
+  ...LAYER_TOKENS
+];
+function resolveSyntaxColors(theme) {
+  const t = theme;
+  return {
+    keyword: t.syntaxKeyword ?? theme.PRIMARY,
+    string: t.syntaxString ?? theme.SUCCESS,
+    number: t.syntaxNumber ?? theme.WARNING,
+    comment: t.syntaxComment ?? theme.MUTED,
+    function: t.syntaxFunction ?? theme.INFO,
+    type: t.syntaxType ?? theme.BRAND,
+    variable: t.syntaxVariable ?? theme.TEXT,
+    operator: t.syntaxOperator ?? theme.MUTED,
+    punctuation: t.syntaxPunctuation ?? theme.MUTED,
+    diffAdd: t.DIFF_ADD ?? theme.SUCCESS,
+    diffDel: t.DIFF_DEL ?? theme.ERROR,
+    link: t.LINK ?? theme.INFO
+  };
+}
+var HEX_RE = /^#[0-9a-fA-F]{6}$/;
+function parseHex(hex) {
+  if (typeof hex !== "string" || !HEX_RE.test(hex)) return null;
+  return {
+    r: Number.parseInt(hex.slice(1, 3), 16),
+    g: Number.parseInt(hex.slice(3, 5), 16),
+    b: Number.parseInt(hex.slice(5, 7), 16)
+  };
+}
+function isHexColor(value) {
+  return typeof value === "string" && HEX_RE.test(value);
+}
+function linearize(channel) {
+  const c = channel / 255;
+  return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function relativeLuminance(hex) {
+  const rgb = parseHex(hex);
+  if (!rgb) throw new TypeError(`relativeLuminance: not a #RRGGBB colour: ${String(hex)}`);
+  return 0.2126 * linearize(rgb.r) + 0.7152 * linearize(rgb.g) + 0.0722 * linearize(rgb.b);
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  const hi = Math.max(la, lb);
+  const lo = Math.min(la, lb);
+  return (hi + 0.05) / (lo + 0.05);
+}
+function readableOnPrimary(theme) {
+  return contrastRatio(theme.CANVAS, theme.PRIMARY) >= contrastRatio(theme.TEXT, theme.PRIMARY) ? theme.CANVAS : theme.TEXT;
+}
+var MIN_TEXT_CONTRAST = 4.5;
+var MIN_CHROME_CONTRAST = 3;
+var MIN_SEMANTIC_CONTRAST = 1.15;
+var DARK = {
+  CANVAS: "#080808",
+  PANEL: "#2B2825",
+  PANEL_ALT: "#363129",
+  BORDER: "#302E2C",
+  TEXT: "#F3EEE9",
+  MUTED: "#B8AC9E",
+  PRIMARY: "#FFFFFF",
+  ACCENT: "#F3EEE9",
+  BRAND: "#A78BFA",
+  SUCCESS: "#22C55E",
+  WARNING: "#EAB308",
+  ERROR: "#F4695E",
+  INFO: "#B8AFA6",
+  background: "#080808",
+  surface: "#111111",
+  surfaceAlt: "#171515",
+  overlay: "#1C1A18"
+};
+var LIGHT = {
+  CANVAS: "#FCFCFD",
+  PANEL: "#EFF1F4",
+  PANEL_ALT: "#E2E5EA",
+  BORDER: "#7A828F",
+  TEXT: "#191C22",
+  MUTED: "#565D68",
+  PRIMARY: "#111318",
+  ACCENT: "#2E333B",
+  BRAND: "#6D28D9",
+  SUCCESS: "#136B31",
+  WARNING: "#654A00",
+  ERROR: "#74130B",
+  INFO: "#1F4E7A",
+  background: "#FCFCFD",
+  surface: "#EFF1F4",
+  surfaceAlt: "#E2E5EA",
+  overlay: "#D7DBE1"
+};
+var HIGH_CONTRAST = {
+  CANVAS: "#000000",
+  PANEL: "#0B0B0B",
+  PANEL_ALT: "#161616",
+  BORDER: "#B3B3B3",
+  TEXT: "#FFFFFF",
+  MUTED: "#BCBCBC",
+  PRIMARY: "#FFFFFF",
+  ACCENT: "#E6E6E6",
+  BRAND: "#C4B5FD",
+  SUCCESS: "#3AE483",
+  WARNING: "#FFE635",
+  ERROR: "#FC8979",
+  INFO: "#82DAFF",
+  background: "#000000",
+  surface: "#0B0B0B",
+  surfaceAlt: "#161616",
+  overlay: "#1E1E1E"
+};
+var ANSI = {
+  CANVAS: "#000000",
+  PANEL: "#000000",
+  PANEL_ALT: "#000000",
+  BORDER: "#808080",
+  TEXT: "#FFFFFF",
+  MUTED: "#808080",
+  PRIMARY: "#FFFFFF",
+  ACCENT: "#C0C0C0",
+  BRAND: "#FF00FF",
+  SUCCESS: "#00FF00",
+  WARNING: "#FFFF00",
+  ERROR: "#FF0000",
+  INFO: "#C0C0C0",
+  background: "#000000",
+  surface: "#000000",
+  surfaceAlt: "#000000",
+  overlay: "#000000"
+};
+var MIDNIGHT = {
+  CANVAS: "#0A0E14",
+  PANEL: "#121824",
+  PANEL_ALT: "#1B2333",
+  BORDER: "#6B7688",
+  TEXT: "#E8ECF2",
+  MUTED: "#93A0B5",
+  PRIMARY: "#FFFFFF",
+  ACCENT: "#DDE3EC",
+  BRAND: "#A78BFA",
+  SUCCESS: "#57BE86",
+  WARNING: "#E2C14E",
+  ERROR: "#F0686C",
+  INFO: "#8FB4E0",
+  background: "#0A0E14",
+  surface: "#121824",
+  surfaceAlt: "#1B2333",
+  overlay: "#232D40"
+};
+var SLATE = {
+  CANVAS: "#141516",
+  PANEL: "#1D1F21",
+  PANEL_ALT: "#26292C",
+  BORDER: "#6E7379",
+  TEXT: "#E9EAEC",
+  MUTED: "#9A9EA4",
+  PRIMARY: "#FFFFFF",
+  ACCENT: "#D8DADD",
+  BRAND: "#A78BFA",
+  SUCCESS: "#5BC088",
+  WARNING: "#DEBB4E",
+  ERROR: "#EB767A",
+  INFO: "#9FB3C8",
+  background: "#141516",
+  surface: "#1D1F21",
+  surfaceAlt: "#26292C",
+  overlay: "#303438",
+  // Bespoke syntax palette — a real 9-hue code palette so highlighted code and
+  // diffs are polychrome even though the chrome stays a restrained grey. Every
+  // value is a light-band hue that reads clearly on the grey surfaces; none is
+  // the ERROR red (reserved for failures). DIFF_ADD/DIFF_DEL mirror
+  // SUCCESS/ERROR so diff semantics stay consistent with the rest of the TUI.
+  syntaxKeyword: "#7AA2F7",
+  syntaxString: "#9ECE6A",
+  syntaxNumber: "#E0AF68",
+  syntaxComment: "#7C828C",
+  syntaxFunction: "#E5C07B",
+  syntaxType: "#4EC9B0",
+  syntaxVariable: "#D4D8DE",
+  syntaxOperator: "#ABB2BF",
+  syntaxPunctuation: "#ABB2BF",
+  DIFF_ADD: "#5BC088",
+  DIFF_DEL: "#EB767A",
+  LINK: "#7AA2F7"
+};
+var PAPER = {
+  CANVAS: "#FBF7EF",
+  PANEL: "#F1EADC",
+  PANEL_ALT: "#EAE1CF",
+  BORDER: "#7C7158",
+  TEXT: "#201C15",
+  MUTED: "#5A5140",
+  PRIMARY: "#1A1712",
+  ACCENT: "#3A342A",
+  BRAND: "#5B2A86",
+  SUCCESS: "#155E2C",
+  WARNING: "#78560E",
+  ERROR: "#8A2015",
+  INFO: "#2A5578",
+  background: "#FBF7EF",
+  surface: "#F1EADC",
+  surfaceAlt: "#EAE1CF",
+  overlay: "#DACFB8"
+};
+var MONO_DIM = {
+  CANVAS: "#161616",
+  PANEL: "#1E1E1E",
+  PANEL_ALT: "#262626",
+  BORDER: "#787878",
+  TEXT: "#C9C9C9",
+  MUTED: "#8C8C8C",
+  PRIMARY: "#E4E4E4",
+  ACCENT: "#B8B8B8",
+  BRAND: "#A99BC9",
+  SUCCESS: "#63AE7B",
+  WARNING: "#C9B25E",
+  ERROR: "#D47878",
+  INFO: "#93A7BC",
+  background: "#161616",
+  surface: "#1E1E1E",
+  surfaceAlt: "#262626",
+  overlay: "#2E2E2E"
+};
+var SWISS = {
+  CANVAS: "#120809",
+  PANEL: "#1C0C0E",
+  PANEL_ALT: "#260F12",
+  BORDER: "#D9534C",
+  TEXT: "#FBF3F3",
+  MUTED: "#D69B9E",
+  PRIMARY: "#F26257",
+  ACCENT: "#F58379",
+  BRAND: "#F26257",
+  SUCCESS: "#4FB477",
+  WARNING: "#E0A83C",
+  ERROR: "#F26257",
+  INFO: "#8FB4E0",
+  background: "#120809",
+  surface: "#1C0C0E",
+  surfaceAlt: "#260F12",
+  overlay: "#301418"
+};
+var GOLDEN = {
+  CANVAS: "#0A0A0A",
+  PANEL: "#141414",
+  PANEL_ALT: "#1E1E1E",
+  BORDER: "#6E6E6E",
+  TEXT: "#EEEEEE",
+  MUTED: "#9A9A9A",
+  PRIMARY: "#FAB283",
+  ACCENT: "#B48EE8",
+  BRAND: "#9D7CD8",
+  SUCCESS: "#7FD88F",
+  WARNING: "#F5A742",
+  ERROR: "#EB7A82",
+  INFO: "#56B6C2",
+  background: "#0A0A0A",
+  surface: "#141414",
+  surfaceAlt: "#1E1E1E",
+  overlay: "#282828",
+  // Polychrome syntax mirroring OpenCode's code hues (keyword=purple,
+  // function=tan, string=green, number=orange, type=gold, variable=red).
+  syntaxKeyword: "#B48EE8",
+  syntaxString: "#7FD88F",
+  syntaxNumber: "#F5A742",
+  syntaxComment: "#9A9A9A",
+  syntaxFunction: "#FAB283",
+  syntaxType: "#E5C07B",
+  syntaxVariable: "#EB7A82",
+  syntaxOperator: "#56B6C2",
+  syntaxPunctuation: "#9A9A9A",
+  DIFF_ADD: "#7FD88F",
+  DIFF_DEL: "#EB7A82",
+  LINK: "#7AA2F7"
+};
+var OH_MY_PI = {
+  CANVAS: "#151820",
+  PANEL: "#0F1216",
+  PANEL_ALT: "#1F252D",
+  BORDER: "#6B7280",
+  TEXT: "#E8ECF4",
+  MUTED: "#9CA3B0",
+  PRIMARY: "#00B4FF",
+  ACCENT: "#D4C090",
+  BRAND: "#00B4FF",
+  SUCCESS: "#00FF88",
+  WARNING: "#FFB347",
+  ERROR: "#FF6B78",
+  // OMP alertRed #FF4757 nudged up for AA on the lightest surface
+  INFO: "#00B4FF",
+  background: "#151820",
+  surface: "#0F1216",
+  surfaceAlt: "#1F252D",
+  overlay: "#2A3038",
+  // OMP titanium's syntax hues, verbatim.
+  syntaxKeyword: "#00B4FF",
+  syntaxString: "#D4C090",
+  syntaxNumber: "#FFB347",
+  syntaxComment: "#6B7280",
+  syntaxFunction: "#00FF88",
+  syntaxType: "#00B4FF",
+  syntaxVariable: "#E8ECF4",
+  syntaxOperator: "#00B4FF",
+  syntaxPunctuation: "#9CA3B0",
+  DIFF_ADD: "#00FF88",
+  DIFF_DEL: "#FF6B78",
+  LINK: "#00B4FF"
+};
+var OSEC_THEME = {
+  CANVAS: "#1A1613",
+  PANEL: "#26221D",
+  PANEL_ALT: "#35302A",
+  BORDER: "#8A7D6B",
+  TEXT: "#F5EEE4",
+  MUTED: "#B0A493",
+  PRIMARY: "#FD802E",
+  ACCENT: "#F2A24C",
+  BRAND: "#FD802E",
+  SUCCESS: "#69C489",
+  WARNING: "#E4BC46",
+  ERROR: "#F47B72",
+  // signature-adjacent coral; lifted from a deeper red so it clears AA on PANEL_ALT
+  INFO: "#4FBAC6",
+  background: "#1A1613",
+  surface: "#26221D",
+  surfaceAlt: "#35302A",
+  overlay: "#403D39",
+  // the #403D39 graphite anchor itself, as the topmost raised surface tier
+  // Code palette HARMONIZED to the 0sec warm palette (oh-my-pi dark-volcanic
+  // philosophy: draw the syntax hues from the theme's OWN colours rather than a
+  // foreign rainbow, so code reads as part of the brand, not confetti). A warm
+  // family carries the meaningful tokens — keyword=amber (ACCENT), function=soft
+  // gold, string=yellow (WARNING hue), number=green (SUCCESS) — with ONE cool
+  // teal (INFO) for types as the single contrast note; everything structural
+  // (variable/operator/punctuation/comment) recedes into warm greys so the eye
+  // lands on the meaning, not the punctuation. Every token clears AA on PANEL.
+  syntaxKeyword: "#F2A24C",
+  // amber (ACCENT) — warm, in-brand
+  syntaxFunction: "#F7C97D",
+  // soft gold, a step lighter than keyword
+  syntaxString: "#E4BC46",
+  // saturated yellow (WARNING hue)
+  syntaxNumber: "#69C489",
+  // green (SUCCESS) — the warm-family break
+  syntaxType: "#4FBAC6",
+  // teal (INFO) — the single cool accent
+  syntaxVariable: "#D8CBBA",
+  // warm cream — plain identifiers stay calm
+  syntaxComment: "#9E927F",
+  // dim warm grey — dimmer than MUTED
+  syntaxOperator: "#B0A493",
+  // MUTED — structure recedes
+  syntaxPunctuation: "#9E9384",
+  // a touch dimmer than operators
+  DIFF_ADD: "#69C489",
+  // number/string green
+  DIFF_DEL: "#F47B72",
+  // ERROR coral
+  LINK: "#4FBAC6"
+  // teal (INFO)
+};
+var THEME_NAMES = [
+  "0sec",
+  "midnight",
+  "dark",
+  "light",
+  "high-contrast",
+  "ansi",
+  "slate",
+  "paper",
+  "mono-dim",
+  "swiss",
+  "golden-gate",
+  "blue-team"
+];
+var THEME_ALIASES = {
+  opencode: "golden-gate",
+  golden: "golden-gate",
+  "oh-my-pi": "blue-team",
+  ember: "0sec"
+};
+var DEFAULT_THEME_NAME = "0sec";
+var THEMES = {
+  "0sec": {
+    name: "0sec",
+    label: "0sec",
+    description: "The flagship 0sec look: signature orange on warm graphite, with an amber accent.",
+    mode: "dark",
+    palette: OSEC_THEME
+  },
+  dark: {
+    name: "dark",
+    label: "Carbon",
+    description: "Warm dark surfaces, neutral white highlight. The original shipped palette.",
+    mode: "dark",
+    palette: DARK
+  },
+  light: {
+    name: "light",
+    label: "Standard",
+    description: "Light theme with clearly stepped section surfaces. Neutral highlight.",
+    mode: "light",
+    palette: LIGHT
+  },
+  "high-contrast": {
+    name: "high-contrast",
+    label: "Contrast",
+    description: "Pure black canvas, every text colour at WCAG AAA (7:1) or better.",
+    mode: "dark",
+    palette: HIGH_CONTRAST
+  },
+  ansi: {
+    name: "ansi",
+    label: "ANSI 16",
+    description: "Only the 16 standard terminal colours. For terminals without truecolor.",
+    mode: "dark",
+    palette: ANSI
+  },
+  midnight: {
+    name: "midnight",
+    label: "Midnight",
+    description: "Deep blue-black dark. Cool stepped surfaces, white highlight.",
+    mode: "dark",
+    palette: MIDNIGHT
+  },
+  slate: {
+    name: "slate",
+    label: "Slate",
+    description: "Neutral grey dark. No hue in the chrome, white highlight.",
+    mode: "dark",
+    palette: SLATE
+  },
+  paper: {
+    name: "paper",
+    label: "Paper",
+    description: "Warm off-white light. Stepped paper surfaces, warm near-black highlight.",
+    mode: "light",
+    palette: PAPER
+  },
+  "mono-dim": {
+    name: "mono-dim",
+    label: "Mono Dim",
+    description: "Very low-contrast dark, minimalist. Muted but still AA-legible.",
+    mode: "dark",
+    palette: MONO_DIM
+  },
+  swiss: {
+    name: "swiss",
+    label: "Swiss",
+    description: "Swiss-flag red on near-black, crisp white text. For the Swiss Applied AI & Cybersecurity Research Lab.",
+    mode: "dark",
+    palette: SWISS
+  },
+  "golden-gate": {
+    name: "golden-gate",
+    label: "Golden Gate",
+    description: "Warm tan-and-gold highlights on near-black surfaces, with a purple accent.",
+    mode: "dark",
+    palette: GOLDEN
+  },
+  "blue-team": {
+    name: "blue-team",
+    label: "Blue Team",
+    description: "Electric-blue on brushed-titanium near-black, gold accent. A port of oh-my-pi's titanium theme.",
+    mode: "dark",
+    palette: OH_MY_PI
+  }
+};
+function isThemeName(value) {
+  return typeof value === "string" && THEME_NAMES.includes(value);
+}
+function getTheme(name) {
+  return getThemeEntry(name).palette;
+}
+function getThemeEntry(name) {
+  if (isThemeName(name)) return THEMES[name];
+  if (typeof name === "string" && name in THEME_ALIASES) return THEMES[THEME_ALIASES[name]];
+  if (typeof name === "string" && installedThemes !== null) {
+    const installed = installedThemes.get(name);
+    if (installed) return installed;
+  }
+  return THEMES[DEFAULT_THEME_NAME];
+}
+function severityToneFor(palette, severity) {
+  switch (String(severity).toLowerCase()) {
+    case "critical":
+    case "high":
+      return palette.ERROR;
+    case "medium":
+      return palette.WARNING;
+    case "low":
+      return palette.INFO;
+    default:
+      return palette.MUTED;
+  }
+}
+var CONTRAST_WAIVERS = [
+  {
+    theme: "dark",
+    token: "BORDER",
+    against: "CANVAS",
+    ratio: 1.48,
+    reason: "Preserved default: #302E2C is an intentional hairline, well below even the 3:1 non-text bar. #9C948C reaches 3:1 on all three surfaces if visible panel edges are wanted."
+  },
+  {
+    theme: "dark",
+    token: "BORDER",
+    against: "PANEL",
+    ratio: 1.08,
+    reason: "Preserved default: see the CANVAS waiver for BORDER."
+  },
+  {
+    theme: "dark",
+    token: "BORDER",
+    against: "PANEL_ALT",
+    ratio: 1.05,
+    reason: "Preserved default: see the CANVAS waiver for BORDER."
+  },
+  {
+    theme: "dark",
+    token: "ERROR",
+    against: "PANEL_ALT",
+    ratio: 4.32,
+    reason: "Preserved default: the coral #F4695E clears AA on CANVAS/PANEL but lands at 3.96:1 on the lightest surface. #FF9B93 clears 4.5:1 there if a visible change is acceptable."
+  }
+];
+function isWaived(theme, token, against) {
+  return CONTRAST_WAIVERS.some(
+    (w) => w.theme === theme && w.token === token && w.against === against
+  );
+}
+var SEMANTIC_PAIRS = [
+  ["SUCCESS", "WARNING"],
+  ["SUCCESS", "ERROR"],
+  ["WARNING", "ERROR"]
+];
+function validateTheme(palette, options = {}) {
+  const issues = [];
+  if (typeof palette !== "object" || palette === null || Array.isArray(palette)) {
+    return [{ kind: "missing", token: "*", message: "palette is not an object" }];
+  }
+  const record = palette;
+  for (const token of THEME_TOKENS) {
+    if (!(token in record)) {
+      issues.push({ kind: "missing", token, message: `missing token ${token}` });
+    } else if (!isHexColor(record[token])) {
+      issues.push({
+        kind: "malformed",
+        token,
+        message: `token ${token} is not a #RRGGBB colour: ${JSON.stringify(record[token])}`
+      });
+    }
+  }
+  for (const token of SYNTAX_TOKENS) {
+    if (token in record && !isHexColor(record[token])) {
+      issues.push({
+        kind: "malformed",
+        token,
+        message: `token ${token} is not a #RRGGBB colour: ${JSON.stringify(record[token])}`
+      });
+    }
+  }
+  for (const key of Object.keys(record)) {
+    if (!THEME_TOKENS.includes(key) && !SYNTAX_TOKENS.includes(key)) {
+      issues.push({ kind: "extra", token: key, message: `unknown token ${key}` });
+    }
+  }
+  if (issues.some((i) => i.kind === "missing" || i.kind === "malformed")) return issues;
+  const theme = record;
+  const minText = options.minTextContrast ?? MIN_TEXT_CONTRAST;
+  const minChrome = options.minChromeContrast ?? MIN_CHROME_CONTRAST;
+  const minSemantic = options.minSemanticContrast ?? MIN_SEMANTIC_CONTRAST;
+  const checkAgainstBackgrounds = (token, required) => {
+    for (const bg of BACKGROUND_TOKENS) {
+      if (options.name && isWaived(options.name, token, bg)) continue;
+      const ratio = contrastRatio(theme[token], theme[bg]);
+      if (ratio < required) {
+        issues.push({
+          kind: "contrast",
+          token,
+          against: bg,
+          ratio,
+          required,
+          message: `${token} on ${bg} is ${ratio.toFixed(2)}:1, below ${required}:1`
+        });
+      }
+    }
+  };
+  for (const token of TEXT_TOKENS) checkAgainstBackgrounds(token, minText);
+  for (const token of CHROME_TOKENS) checkAgainstBackgrounds(token, minChrome);
+  for (const [a, b] of SEMANTIC_PAIRS) {
+    const ratio = contrastRatio(theme[a], theme[b]);
+    if (ratio < minSemantic) {
+      issues.push({
+        kind: "semantic",
+        token: `${a}/${b}`,
+        ratio,
+        required: minSemantic,
+        message: `${a} and ${b} differ by only ${ratio.toFixed(3)}:1 in luminance (need ${minSemantic}:1) \u2014 indistinguishable without colour vision`
+      });
+    }
+  }
+  return issues;
+}
+var ANSI_16 = [
+  { index: 0, name: "black", hex: "#000000" },
+  { index: 1, name: "red", hex: "#800000" },
+  { index: 2, name: "green", hex: "#008000" },
+  { index: 3, name: "yellow", hex: "#808000" },
+  { index: 4, name: "blue", hex: "#000080" },
+  { index: 5, name: "magenta", hex: "#800080" },
+  { index: 6, name: "cyan", hex: "#008080" },
+  { index: 7, name: "white", hex: "#C0C0C0" },
+  { index: 8, name: "bright black", hex: "#808080" },
+  { index: 9, name: "bright red", hex: "#FF0000" },
+  { index: 10, name: "bright green", hex: "#00FF00" },
+  { index: 11, name: "bright yellow", hex: "#FFFF00" },
+  { index: 12, name: "bright blue", hex: "#0000FF" },
+  { index: 13, name: "bright magenta", hex: "#FF00FF" },
+  { index: 14, name: "bright cyan", hex: "#00FFFF" },
+  { index: 15, name: "bright white", hex: "#FFFFFF" }
+];
+function redmeanDistance(a, b) {
+  const rmean = (a.r + b.r) / 2;
+  const dr = a.r - b.r;
+  const dg = a.g - b.g;
+  const db = a.b - b.b;
+  return (2 + rmean / 256) * dr * dr + 4 * dg * dg + (2 + (255 - rmean) / 256) * db * db;
+}
+function nearestAnsi16(hex) {
+  const rgb = parseHex(hex);
+  if (!rgb) throw new TypeError(`nearestAnsi16: not a #RRGGBB colour: ${String(hex)}`);
+  let best = 0;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const entry of ANSI_16) {
+    const d = redmeanDistance(rgb, parseHex(entry.hex));
+    if (d < bestDistance) {
+      bestDistance = d;
+      best = entry.index;
+    }
+  }
+  return best;
+}
+var CUBE_LEVELS = [0, 95, 135, 175, 215, 255];
+function ansi256Hex(index) {
+  if (index < 16) return ANSI_16[index].hex;
+  const toHex = (n) => n.toString(16).padStart(2, "0").toUpperCase();
+  if (index < 232) {
+    const n = index - 16;
+    const r = CUBE_LEVELS[Math.floor(n / 36) % 6];
+    const g = CUBE_LEVELS[Math.floor(n / 6) % 6];
+    const b = CUBE_LEVELS[n % 6];
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+  }
+  const level = 8 + (index - 232) * 10;
+  return `#${toHex(level)}${toHex(level)}${toHex(level)}`;
+}
+function nearestAnsi256(hex) {
+  const rgb = parseHex(hex);
+  if (!rgb) throw new TypeError(`nearestAnsi256: not a #RRGGBB colour: ${String(hex)}`);
+  let best = 0;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < 256; i += 1) {
+    const d = redmeanDistance(rgb, parseHex(ansi256Hex(i)));
+    if (d < bestDistance) {
+      bestDistance = d;
+      best = i;
+    }
+  }
+  return best;
+}
+function detectColorDepth(env = {}) {
+  const term = (env.TERM ?? "").toLowerCase();
+  if (typeof env.NO_COLOR === "string") return "none";
+  if (term === "dumb") return "none";
+  const force = env.FORCE_COLOR;
+  if (typeof force === "string") {
+    if (force === "0" || force === "false") return "none";
+    if (force === "1") return "ansi16";
+    if (force === "2") return "ansi256";
+    if (force === "3" || force === "true" || force === "") return "truecolor";
+  }
+  const colorterm = (env.COLORTERM ?? "").toLowerCase();
+  if (colorterm.includes("truecolor") || colorterm.includes("24bit")) return "truecolor";
+  if (term.includes("truecolor") || term.includes("direct")) return "truecolor";
+  if (term.includes("256")) return "ansi256";
+  return "ansi16";
+}
+function degradePalette(palette, depth) {
+  if (depth === "truecolor" || depth === "none") return palette;
+  const map = depth === "ansi16" ? nearestAnsi16 : nearestAnsi256;
+  const snap = (hex) => depth === "ansi16" ? ANSI_16[map(hex)].hex : ansi256Hex(map(hex));
+  const out = {};
+  for (const token of THEME_TOKENS) {
+    out[token] = snap(palette[token]);
+  }
+  const source = palette;
+  for (const token of SYNTAX_TOKENS) {
+    const value = source[token];
+    if (typeof value === "string") out[token] = snap(value);
+  }
+  return out;
+}
+var INSTALLED_THEMES_DIRNAME = "themes";
+function installedThemesDir(homeDir2) {
+  return join2(homeStateDir(homeDir2), INSTALLED_THEMES_DIRNAME);
+}
+function installedThemeFilePath(id, homeDir2) {
+  return join2(installedThemesDir(homeDir2), `${id}.json`);
+}
+var THEME_ID_RE = /^[a-z][a-z0-9]*([._-][a-z0-9]+)*$/;
+var THEME_ID_MAX = 64;
+function isSafeThemeId(id) {
+  return typeof id === "string" && id.length > 0 && id.length <= THEME_ID_MAX && THEME_ID_RE.test(id) && !id.includes("/") && !id.includes("\\") && id !== "." && id !== "..";
+}
+var installedThemes = null;
+var installedFromHome;
+function readInstalledThemes(homeDir2) {
+  const out = /* @__PURE__ */ new Map();
+  for (const entry of loadUserThemes(installedThemesDir(homeDir2)).valid) {
+    out.set(entry.name, entry);
+  }
+  return out;
+}
+function ensureInstalledThemesLoaded(homeDir2) {
+  if (installedThemes === null || installedFromHome !== homeDir2) {
+    installedThemes = readInstalledThemes(homeDir2);
+    installedFromHome = homeDir2;
+  }
+  return installedThemes;
+}
+function reloadInstalledThemes(homeDir2) {
+  installedThemes = readInstalledThemes(homeDir2);
+  installedFromHome = homeDir2;
+  return installedThemes;
+}
+function installedThemeEntries(homeDir2) {
+  return [...ensureInstalledThemesLoaded(homeDir2).values()];
+}
+function allThemeNames(homeDir2) {
+  return [...THEME_NAMES, ...ensureInstalledThemesLoaded(homeDir2).keys()];
+}
+function isKnownTheme(value) {
+  if (isThemeName(value)) return true;
+  return typeof value === "string" && installedThemes !== null && installedThemes.has(value);
+}
+function writeInstalledTheme(file, homeDir2) {
+  if (!isSafeThemeId(file.id)) return { ok: false, error: `unsafe theme id ${JSON.stringify(file.id)}` };
+  if (isThemeName(file.id)) return { ok: false, error: `"${file.id}" is a built-in theme name and cannot be overridden` };
+  const issues = validateTheme(file.palette);
+  if (issues.length > 0) {
+    return { ok: false, error: `invalid palette: ${issues.map((i) => i.message).join("; ")}` };
+  }
+  try {
+    const path = installedThemeFilePath(file.id, homeDir2);
+    mkdirSync(dirname(path), { recursive: true });
+    const body = {
+      id: file.id,
+      ...file.label !== void 0 ? { label: file.label } : {},
+      ...file.description !== void 0 ? { description: file.description } : {},
+      ...file.mode !== void 0 ? { mode: file.mode } : {},
+      palette: file.palette
+    };
+    writeFileSync(path, `${JSON.stringify(body, null, 2)}
+`, "utf8");
+    return { ok: true, path };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function removeInstalledTheme(id, homeDir2) {
+  if (!isSafeThemeId(id)) return { ok: false, error: `unsafe theme id ${JSON.stringify(id)}` };
+  if (isThemeName(id)) return { ok: false, error: `"${id}" is a built-in theme and cannot be removed` };
+  const cache = ensureInstalledThemesLoaded(homeDir2);
+  if (!cache.has(id)) return { ok: false, error: `theme "${id}" is not installed` };
+  try {
+    rmSync(installedThemeFilePath(id, homeDir2), { force: true });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// packages/cli/src/tui/settings.ts
+var THEME_CHOICES = [...THEME_NAMES];
+function syncThemeChoices(homeDir2) {
+  ensureInstalledThemesLoaded(homeDir2);
+  THEME_CHOICES.splice(0, THEME_CHOICES.length, ...allThemeNames(homeDir2));
+}
+var DEFS = [
+  {
+    key: "showStatusBar",
+    label: "Status bar",
+    description: "Optional bottom-bar telemetry: model, working directory, git state and token counters. Permission mode and the turn timer share that row and stay visible with this off.",
+    kind: "boolean",
+    default: true,
+    group: "Display"
+  },
+  {
+    key: "showComposerHints",
+    label: "Composer hints",
+    description: "Keyboard-hint line under the input box.",
+    kind: "boolean",
+    default: true,
+    group: "Display"
+  },
+  {
+    key: "composerSuggestions",
+    label: "Composer autosuggestions",
+    description: "Inline ghost-text continuation from your submitted-message history, accepted with the Right arrow at end-of-input.",
+    kind: "boolean",
+    default: true,
+    group: "Display"
+  },
+  {
+    key: "mouseSupport",
+    label: "Mouse support",
+    description: "Scroll-wheel scrolling, click-to-select on list rows, and clickable hints. Turn off for a keyboard-only console where the terminal's own text selection works.",
+    kind: "boolean",
+    default: true,
+    group: "Display"
+  },
+  {
+    key: "showLogo",
+    label: "Logo",
+    description: 'Block "0SEC" mark shown on an empty transcript.',
+    kind: "boolean",
+    default: true,
+    group: "Display"
+  },
+  {
+    key: "showRuntimeNotices",
+    label: "Runtime notices",
+    description: "Surface runtime stdout/stderr as transcript notices.",
+    kind: "boolean",
+    default: true,
+    group: "Transcript"
+  },
+  {
+    key: "showTurnSummary",
+    label: "Turn summary",
+    description: 'Per-turn "N tool calls - in->out tok" line after each answer.',
+    kind: "boolean",
+    default: false,
+    group: "Transcript"
+  },
+  {
+    key: "showSubagents",
+    label: "Subagent list",
+    description: "List the active subagents while workers are running.",
+    kind: "boolean",
+    default: true,
+    group: "Transcript"
+  },
+  {
+    key: "showLeftSidebar",
+    label: "Left sidebar",
+    description: "Left sidebar in the chat view: recent sessions to resume, plus this run's findings. Hidden on narrow terminals.",
+    kind: "boolean",
+    default: false,
+    group: "Display"
+  },
+  {
+    key: "showRightSidebar",
+    label: "Right sidebar",
+    description: "Right sidebar: live agents, their activity, the current plan and findings. Hidden on narrow terminals.",
+    kind: "boolean",
+    default: false,
+    group: "Display"
+  },
+  {
+    key: "showTimestamps",
+    label: "Timestamps",
+    description: "Relative timestamps on transcript entries.",
+    kind: "boolean",
+    default: false,
+    group: "Transcript"
+  },
+  {
+    key: "showObjective",
+    label: "Objective",
+    description: `Bottom-bar "objective" pill: a short "what am I working on" title derived from the session's first message.`,
+    kind: "boolean",
+    default: true,
+    group: "Display"
+  },
+  {
+    key: "showScope",
+    label: "Scope",
+    description: "Show the configured multi-host scope and exclusions. An absent scope is distinct from an explicit empty scope.",
+    kind: "boolean",
+    default: true,
+    group: "Display"
+  },
+  {
+    key: "density",
+    label: "Density",
+    description: 'Transcript spacing: "comfortable" adds blank lines between entries.',
+    kind: "enum",
+    default: "comfortable",
+    choices: ["comfortable", "compact"],
+    group: "Display"
+  },
+  {
+    key: "composerStyle",
+    label: "Composer style",
+    description: "How the composer frame is drawn around the input.",
+    kind: "enum",
+    default: "border",
+    choices: ["border", "rail", "plain"],
+    group: "Display"
+  },
+  {
+    key: "busyInputMode",
+    label: "Busy input",
+    description: "Steer interrupts the main turn before sending the follow-up. Queue waits for it to finish. Background workers keep running.",
+    kind: "enum",
+    default: "steer",
+    choices: ["steer", "queue"],
+    group: "Display"
+  },
+  {
+    key: "allowSubagentPeerMessaging",
+    label: "Subagent peer messaging",
+    description: "A subagent runs attacker-influenced code, so a direct sibling channel is how one compromised subagent reaches another's context.",
+    kind: "boolean",
+    default: true,
+    group: "Security"
+  },
+  {
+    key: "allowSubagentOperatorMessaging",
+    label: "Subagent messages to you",
+    description: "Messages arrive in your transcript sanitized and attributed, but a compromised subagent can use this channel to say things to you.",
+    kind: "boolean",
+    default: true,
+    group: "Security"
+  },
+  {
+    key: "transcriptStyle",
+    label: "Transcript style",
+    description: "Minimal (the default) drops every bubble and box: your turns carry a thin coloured accent rail and the answer flows as plain body text, the OpenCode / oh-my-pi flat look. Bubble right-aligns your messages against left-aligned answers and titles each card on its border. Balanced: only your own messages are bubbled; everything else is flat. Rail, plain, compact and document offer alternative transcript layouts.",
+    kind: "enum",
+    default: "minimal",
+    choices: ["minimal", "rail", "bubble", "balanced", "plain", "compact", "document"],
+    group: "Display"
+  },
+  {
+    key: "roleLabelStyle",
+    label: "Role label",
+    description: 'Speaker name on each message: "You" for your turns, "0sec" for answers. Full and short add the elapsed age when one is known; glyph shows the name alone; off omits the label entirely. Bubble cards carry it top-left on the card border, with your messages right-aligned and answers left.',
+    kind: "enum",
+    default: "full",
+    choices: ["full", "short", "glyph", "off"],
+    group: "Display"
+  },
+  {
+    key: "toolCardStyle",
+    label: "Tool card",
+    description: "How a tool or subagent call is drawn: compact, rail, inline or hidden (failures always show).",
+    kind: "enum",
+    default: "compact",
+    choices: ["compact", "rail", "inline", "hidden"],
+    group: "Display"
+  },
+  {
+    key: "richToolCards",
+    label: "Rich tool cards",
+    description: "Draw bash/run_command output and apply_patch edits as bordered cards (command + output + wall/exit footer, or an edit header + diff) instead of a plain line.",
+    kind: "boolean",
+    default: true,
+    group: "Transcript"
+  },
+  {
+    key: "transcriptDetail",
+    label: "Transcript detail",
+    description: "Expanded shows every step (thinking, tool calls + their output) inline \u2014 the default; collapsed folds each turn's successful steps into one-line summaries (failures always show). Ctrl+R toggles it live.",
+    kind: "enum",
+    default: "expanded",
+    choices: ["expanded", "collapsed"],
+    group: "Transcript"
+  },
+  {
+    key: "autoCompaction",
+    label: "Auto-compaction",
+    description: "Automatically summarise older turns when the conversation nears the model's context window (the recap stays viewable with Ctrl+O).",
+    kind: "boolean",
+    default: true,
+    group: "Context"
+  },
+  {
+    key: "compactionThreshold",
+    label: "Compaction threshold",
+    description: "How full the context window gets before auto-compaction runs.",
+    kind: "enum",
+    default: "80%",
+    choices: ["70%", "75%", "80%", "85%"],
+    group: "Context"
+  },
+  {
+    key: "theme",
+    label: "Theme",
+    description: "Colour palette. Slate (neutral grey, default) and Midnight (deep blue-black) and Carbon (warm dark), Standard/Paper (light), plus Contrast, Mono Dim and ANSI 16 for 16-colour terminals. Drop validated palettes in ~/.0sec/themes to add your own.",
+    kind: "enum",
+    default: DEFAULT_THEME_NAME,
+    choices: THEME_CHOICES,
+    group: "Display"
+  },
+  {
+    key: "allowModelSelfExtension",
+    label: "Model self-extension",
+    description: "Allow new sessions to add sandboxed tools and live harness generations. Existing disabled sessions stay disabled. Trusted harness code requires separate workspace trust; development engine updates are controlled independently.",
+    kind: "boolean",
+    default: DEFAULT_ALLOW_MODEL_SELF_EXTENSION,
+    group: "Security"
+  },
+  {
+    key: "allowDevSourceUpdates",
+    label: "Development engine updates",
+    description: "0dev only. Reload changed core engine code between turns without losing the session. Runs with host privileges, including credential access; independent of sandboxed tool extension.",
+    kind: "boolean",
+    default: false,
+    group: "Security"
+  },
+  {
+    key: "autoEvolveFinderLenses",
+    label: "Auto-evolve finder lenses",
+    description: "Start the TUI watcher for ~/.0sec/lens-synthesis/miss-input.json (or OSEC_TUI_LENS_SYNTH_INPUT) so each new curated revision can invoke the configured model.",
+    kind: "boolean",
+    default: false,
+    group: "Security"
+  },
+  {
+    key: "autoPromoteFinderLenses",
+    label: "Auto-promote validated lenses",
+    description: "Permit the TUI watcher to persist a candidate only after its positive and negative-control corpus gate passes, otherwise automatic evaluation stays dry-run.",
+    kind: "boolean",
+    default: false,
+    group: "Security"
+  },
+  {
+    key: "showTokenUsage",
+    label: "Token usage",
+    description: 'Per-turn "in\u2192out tok" line under each answer.',
+    kind: "boolean",
+    default: true,
+    group: "Telemetry"
+  },
+  {
+    key: "showCost",
+    label: "Cost",
+    description: "Estimated dollar cost, per turn and in the status bar.",
+    kind: "boolean",
+    default: true,
+    group: "Telemetry"
+  },
+  {
+    key: "showContextMeter",
+    label: "Context meter",
+    description: "Visual context-usage bar in the status bar.",
+    kind: "boolean",
+    default: true,
+    group: "Telemetry"
+  },
+  {
+    key: "modelDisplay",
+    label: "Model display",
+    description: "Where the model name appears: status bar, per message, or hidden.",
+    kind: "enum",
+    default: "statusbar",
+    choices: ["statusbar", "message", "off"],
+    group: "Telemetry"
+  },
+  {
+    key: "elapsedTimer",
+    label: "Elapsed timer",
+    description: "Show the running-turn elapsed time as a compact clock-glyphed pill next to the left status icon, or hide it.",
+    kind: "enum",
+    default: "left",
+    choices: ["left", "off"],
+    group: "Telemetry"
+  },
+  {
+    key: "logoAnimation",
+    label: "Logo animation",
+    description: 'Intro animation for the "0SEC" logo: glitch (a neon-flecked scramble that resolves \u2014 the default), rainbow (a looping hue sweep), matrix (a green matrix-rain cascade), wave (a rippling cyan wavefront), neon (a neon-sign warm-up flicker), shimmer (a bright comet with a gradient tail), pulse (the slash breathes), strike (an orange slash strikes through the 0), draw (letters draw in behind a pen tip), fade (a centre-out bloom), typein (per-cell reveal), sweep (a bright bar wipes across) or off (static).',
+    kind: "enum",
+    default: "glitch",
+    choices: [
+      "glitch",
+      "rainbow",
+      "matrix",
+      "wave",
+      "neon",
+      "shimmer",
+      "pulse",
+      "strike",
+      "draw",
+      "fade",
+      "typein",
+      "sweep",
+      "swiss",
+      "off"
+    ],
+    group: "Motion"
+  },
+  {
+    key: "reduceMotion",
+    label: "Reduce motion",
+    description: "Master reduce-motion: the console keeps essential feedback but disables decorative animations like the logo intro, shimmers and sweeps.",
+    kind: "boolean",
+    default: false,
+    group: "Motion"
+  },
+  {
+    key: "analyticsLevel",
+    label: "Analytics and training data",
+    description: "Full is the new-install default. Usage shares feature counters and error categories, not tool content. Commands adds tool arguments/results and submitted code for model training and security research; Full also adds scope and findings. Recognized credentials are scrubbed; emails, URLs, identifiers and other content are retained. Sending uses authenticated Cloud storage and is not anonymous. Each tool/code content field is limited to 256 KiB after credential scrubbing; oversized records are reported locally, not silently truncated. Explicit 0SEC_ANALYTICS_LEVEL and offline/no-telemetry/DO_NOT_TRACK restrictions win over broader settings. Problem reports are separate. Applies to this computer, not this project.",
+    kind: "enum",
+    default: "full",
+    choices: ["off", "usage", "commands", "full"],
+    group: "Privacy"
+  },
+  {
+    key: "diagnosticReporting",
+    label: "Problem reports",
+    description: "Send limited diagnostics automatically by default, ask first, or turn reporting off. Uses Cloud sign-in or a configured HTTPS feedback endpoint. Never includes prompts, tool arguments or output. Applies to this computer, not this project.",
+    kind: "enum",
+    default: "automatic",
+    choices: ["off", "ask", "automatic"],
+    group: "Privacy"
+  },
+  {
+    key: "updatePolicy",
+    label: "Updates",
+    description: "Off, notify about releases, or install updates before the console starts. Applies to this computer; project settings cannot enable installation.",
+    kind: "enum",
+    default: "automatic",
+    choices: ["off", "notify", "automatic"],
+    group: "Updates"
+  },
+  {
+    key: "symbolPreset",
+    label: "Symbols",
+    description: "Glyph set for icons, status marks and checkboxes: Unicode (default, works everywhere), Nerd Font (crisp patched-font icons \u2014 requires a Nerd Font terminal) or ASCII (plain, single-cell).",
+    kind: "enum",
+    default: "unicode",
+    choices: ["unicode", "nerd", "ascii"],
+    group: "Display"
+  },
+  {
+    key: "rosterSort",
+    label: "Roster order",
+    description: "Order the agent herd and comms fleet by attention (blocked and working agents float to the top \u2014 the default) or by fixed lifecycle status.",
+    kind: "enum",
+    default: "attention",
+    choices: ["attention", "status"],
+    group: "Display"
+  },
+  {
+    key: "leaderKey",
+    label: "Leader key",
+    description: "Optional tmux-style prefix chord for the roster views: press it, then a number to focus that agent, or n/p to step. Off disables it (the direct number keys work regardless).",
+    kind: "enum",
+    default: "off",
+    choices: ["off", "ctrl+a", "ctrl+b", "ctrl+space"],
+    group: "Display"
+  }
+];
+var SETTING_DEFS = DEFS;
+var DEF_BY_KEY = new Map(DEFS.map((def) => [def.key, def]));
+var DEFAULT_SETTINGS = {
+  showStatusBar: true,
+  showComposerHints: true,
+  composerSuggestions: true,
+  mouseSupport: true,
+  showLogo: true,
+  showRuntimeNotices: true,
+  showTurnSummary: false,
+  showSubagents: true,
+  showLeftSidebar: false,
+  showRightSidebar: false,
+  showTimestamps: false,
+  showObjective: true,
+  showScope: true,
+  density: "comfortable",
+  composerStyle: "border",
+  busyInputMode: "steer",
+  onboardingCompleted: false,
+  allowSubagentPeerMessaging: true,
+  allowSubagentOperatorMessaging: true,
+  transcriptStyle: "minimal",
+  roleLabelStyle: "full",
+  toolCardStyle: "compact",
+  richToolCards: true,
+  transcriptDetail: "expanded",
+  autoCompaction: true,
+  compactionThreshold: "80%",
+  theme: DEFAULT_THEME_NAME,
+  allowModelSelfExtension: DEFAULT_ALLOW_MODEL_SELF_EXTENSION,
+  allowDevSourceUpdates: false,
+  autoEvolveFinderLenses: false,
+  autoPromoteFinderLenses: false,
+  showTokenUsage: true,
+  showCost: true,
+  showContextMeter: true,
+  modelDisplay: "statusbar",
+  elapsedTimer: "left",
+  logoAnimation: "glitch",
+  reduceMotion: false,
+  analyticsLevel: "full",
+  diagnosticReporting: "automatic",
+  diagnosticReportingPrompted: false,
+  updatePolicy: "automatic",
+  symbolPreset: "unicode",
+  rosterSort: "attention",
+  leaderKey: "off",
+  keybindings: {}
+};
+var SETTINGS_FILENAME = "tui-settings.json";
+function settingsFilePath(homeDir2) {
+  return join3(homeStateDir(homeDir2), SETTINGS_FILENAME);
+}
+function projectStateDir(projectDir2 = process.cwd()) {
+  return join3(projectDir2, ".0sec");
+}
+function projectSettingsFilePath(projectDir2 = process.cwd()) {
+  return join3(projectStateDir(projectDir2), SETTINGS_FILENAME);
+}
+function readRawSettingsFile(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function projectSettingsExist(projectDir2 = process.cwd()) {
+  const raw = readRawSettingsFile(projectSettingsFilePath(projectDir2));
+  return typeof raw === "object" && raw !== null && !Array.isArray(raw);
+}
+function strictValueAt(raw, key) {
+  const value = rawValue(raw, key);
+  if (value === void 0) return void 0;
+  if (key === "onboardingCompleted" || key === "diagnosticReportingPrompted") {
+    return typeof value === "boolean" ? value : void 0;
+  }
+  if (value === false && (key === "diagnosticReporting" || key === "updatePolicy")) {
+    return "off";
+  }
+  if (key === "theme") {
+    return typeof value === "string" && isKnownTheme(value) ? value : void 0;
+  }
+  if (key === "keybindings") {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? sanitizeKeybindingOverrides(value) : void 0;
+  }
+  const def = DEF_BY_KEY.get(key);
+  if (def?.kind === "boolean") {
+    return typeof value === "boolean" ? value : void 0;
+  }
+  const choices = def?.choices ?? [];
+  return typeof value === "string" && choices.includes(value) ? value : void 0;
+}
+function isOperatorSetting(key) {
+  return key === "onboardingCompleted" || key === "analyticsLevel" || key === "diagnosticReporting" || key === "diagnosticReportingPrompted" || key === "updatePolicy" || key === "allowDevSourceUpdates";
+}
+function resolveLayeredSettings(globalRaw, projectRaw) {
+  const settings = {};
+  const sources = {};
+  for (const key of Object.keys(DEFAULT_SETTINGS)) {
+    const projectValue = isOperatorSetting(key) ? void 0 : strictValueAt(projectRaw, key);
+    if (projectValue !== void 0) {
+      settings[key] = projectValue;
+      sources[key] = "project";
+      continue;
+    }
+    const globalValue = strictValueAt(globalRaw, key);
+    if (globalValue !== void 0) {
+      settings[key] = globalValue;
+      sources[key] = "global";
+      continue;
+    }
+    settings[key] = DEFAULT_SETTINGS[key];
+    sources[key] = "default";
+  }
+  return { settings, sources };
+}
+function loadLayeredSettings(opts = {}) {
+  syncThemeChoices(opts.homeDir);
+  const globalRaw = readRawSettingsFile(settingsFilePath(opts.homeDir));
+  const projectRaw = readRawSettingsFile(projectSettingsFilePath(opts.projectDir));
+  return resolveLayeredSettings(globalRaw, projectRaw);
+}
+function rawValue(raw, key) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+  const value = raw[key];
+  return key === "transcriptStyle" && value === "messenger" ? "bubble" : value;
+}
+function booleanAt(raw, key) {
+  const value = rawValue(raw, key);
+  return typeof value === "boolean" ? value : DEFAULT_SETTINGS[key];
+}
+function booleanWithLegacy(raw, key, legacyKey) {
+  const value = rawValue(raw, key);
+  if (typeof value === "boolean") return value;
+  const legacy = rawValue(raw, legacyKey);
+  if (typeof legacy === "boolean") return legacy;
+  return DEFAULT_SETTINGS[key];
+}
+function enumAt(raw, key) {
+  const def = DEF_BY_KEY.get(key);
+  const value = rawValue(raw, key);
+  const choices = def?.choices ?? [];
+  return typeof value === "string" && choices.includes(value) ? value : DEFAULT_SETTINGS[key];
+}
+function themeAt(raw) {
+  const value = rawValue(raw, "theme");
+  return typeof value === "string" && isKnownTheme(value) ? value : DEFAULT_SETTINGS.theme;
+}
+function keybindingsAt(raw) {
+  return sanitizeKeybindingOverrides(rawValue(raw, "keybindings"));
+}
+function normalizeSettings(raw) {
+  return {
+    showStatusBar: booleanAt(raw, "showStatusBar"),
+    showComposerHints: booleanAt(raw, "showComposerHints"),
+    composerSuggestions: booleanAt(raw, "composerSuggestions"),
+    mouseSupport: booleanAt(raw, "mouseSupport"),
+    showLogo: booleanAt(raw, "showLogo"),
+    showRuntimeNotices: booleanAt(raw, "showRuntimeNotices"),
+    showTurnSummary: booleanAt(raw, "showTurnSummary"),
+    showSubagents: booleanAt(raw, "showSubagents"),
+    showLeftSidebar: booleanAt(raw, "showLeftSidebar"),
+    // Back-compat: the right sidebar was `showAgentRail` before it grew a
+    // context strip and a left twin. A pre-rename file keeps its choice.
+    showRightSidebar: booleanWithLegacy(raw, "showRightSidebar", "showAgentRail"),
+    showTimestamps: booleanAt(raw, "showTimestamps"),
+    showObjective: booleanAt(raw, "showObjective"),
+    showScope: booleanAt(raw, "showScope"),
+    density: enumAt(raw, "density"),
+    composerStyle: enumAt(raw, "composerStyle"),
+    busyInputMode: enumAt(raw, "busyInputMode"),
+    onboardingCompleted: booleanAt(raw, "onboardingCompleted"),
+    allowSubagentPeerMessaging: booleanAt(raw, "allowSubagentPeerMessaging"),
+    allowSubagentOperatorMessaging: booleanAt(raw, "allowSubagentOperatorMessaging"),
+    transcriptStyle: enumAt(raw, "transcriptStyle"),
+    roleLabelStyle: enumAt(raw, "roleLabelStyle"),
+    toolCardStyle: enumAt(raw, "toolCardStyle"),
+    richToolCards: booleanAt(raw, "richToolCards"),
+    transcriptDetail: enumAt(raw, "transcriptDetail"),
+    autoCompaction: booleanAt(raw, "autoCompaction"),
+    compactionThreshold: enumAt(raw, "compactionThreshold"),
+    theme: themeAt(raw),
+    allowModelSelfExtension: booleanAt(raw, "allowModelSelfExtension"),
+    allowDevSourceUpdates: booleanAt(raw, "allowDevSourceUpdates"),
+    autoEvolveFinderLenses: booleanAt(raw, "autoEvolveFinderLenses"),
+    autoPromoteFinderLenses: booleanAt(raw, "autoPromoteFinderLenses"),
+    showTokenUsage: booleanAt(raw, "showTokenUsage"),
+    showCost: booleanAt(raw, "showCost"),
+    showContextMeter: booleanAt(raw, "showContextMeter"),
+    modelDisplay: enumAt(raw, "modelDisplay"),
+    elapsedTimer: enumAt(raw, "elapsedTimer"),
+    logoAnimation: enumAt(raw, "logoAnimation"),
+    reduceMotion: booleanAt(raw, "reduceMotion"),
+    analyticsLevel: enumAt(raw, "analyticsLevel"),
+    diagnosticReporting: strictValueAt(raw, "diagnosticReporting") ?? DEFAULT_SETTINGS.diagnosticReporting,
+    diagnosticReportingPrompted: booleanAt(raw, "diagnosticReportingPrompted"),
+    updatePolicy: strictValueAt(raw, "updatePolicy") ?? DEFAULT_SETTINGS.updatePolicy,
+    symbolPreset: enumAt(raw, "symbolPreset"),
+    rosterSort: enumAt(raw, "rosterSort"),
+    leaderKey: enumAt(raw, "leaderKey"),
+    keybindings: keybindingsAt(raw)
+  };
+}
+function loadSettings(homeDir2, projectDir2) {
+  return loadLayeredSettings({ homeDir: homeDir2, projectDir: projectDir2 }).settings;
+}
+function loadGlobalSettings(homeDir2) {
+  syncThemeChoices(homeDir2);
+  return normalizeSettings(readRawSettingsFile(settingsFilePath(homeDir2)));
+}
+function saveSettings(settings, homeDir2) {
+  try {
+    const path = settingsFilePath(homeDir2);
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync2(path, `${JSON.stringify(normalizeSettings(settings), null, 2)}
+`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sanitizeOverrides(raw) {
+  const out = {};
+  for (const key of Object.keys(DEFAULT_SETTINGS)) {
+    if (isOperatorSetting(key)) continue;
+    const value = strictValueAt(raw, key);
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function readProjectOverrides(projectDir2) {
+  return sanitizeOverrides(readRawSettingsFile(projectSettingsFilePath(projectDir2)));
+}
+function saveProjectOverrides(patch, projectDir2) {
+  try {
+    const path = projectSettingsFilePath(projectDir2);
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync2(path, `${JSON.stringify(sanitizeOverrides(patch), null, 2)}
+`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// packages/cli/src/tui/settings-store.ts
+var cached = null;
+var globalDraft = null;
+var projectDraft = null;
+var homeDir;
+var projectDir;
+var subscribers = /* @__PURE__ */ new Set();
+function notify(settings) {
+  bridgeAnalyticsLevel(settings);
+  for (const fn of [...subscribers]) {
+    try {
+      fn(settings);
+    } catch {
+    }
+  }
+}
+function loadLayered() {
+  return globalDraft === null && projectDraft === null ? loadLayeredSettings({ homeDir, projectDir }) : resolveLayeredSettings(globalDraft ?? loadGlobalSettings(homeDir), projectDraft ?? readProjectOverrides(projectDir));
+}
+function getSettings() {
+  if (cached === null) {
+    cached = loadLayered();
+    bridgeAnalyticsLevel(cached.settings);
+  }
+  return cached.settings;
+}
+function setSettings(next) {
+  const value = normalizeSettings(next);
+  const saved = saveSettings(value, homeDir);
+  globalDraft = saved ? null : value;
+  cached = loadLayered();
+  notify(cached.settings);
+  return saved;
+}
+function defaultWriteLayer() {
+  return projectSettingsExist(projectDir) ? "project" : "global";
+}
+function updateSetting(key, value, opts = {}) {
+  const operatorOnly = isOperatorSetting(key);
+  if (operatorOnly && opts.scope === "project") return false;
+  const layer = operatorOnly ? "global" : opts.scope ?? defaultWriteLayer();
+  if (layer === "global") {
+    return setSettings({ ...globalDraft ?? loadGlobalSettings(homeDir), [key]: value });
+  }
+  const patch = { ...projectDraft ?? readProjectOverrides(projectDir), [key]: value };
+  const saved = saveProjectOverrides(patch, projectDir);
+  projectDraft = saved ? null : patch;
+  cached = loadLayered();
+  notify(cached.settings);
+  return saved;
+}
+function resetSettings(next, keys) {
+  const selected = keys.filter((key) => SETTING_DEFS.some((def) => def.key === key));
+  if (selected.length === 0) return true;
+  const global = { ...globalDraft ?? loadGlobalSettings(homeDir) };
+  const project = { ...projectDraft ?? readProjectOverrides(projectDir) };
+  let projectChanged = false;
+  for (const key of selected) {
+    global[key] = next[key];
+    if (Object.hasOwn(project, key)) {
+      delete project[key];
+      projectChanged = true;
+    }
+  }
+  const value = normalizeSettings(global);
+  const globalSaved = saveSettings(value, homeDir);
+  globalDraft = globalSaved ? null : value;
+  const projectSaved = !projectChanged || saveProjectOverrides(project, projectDir);
+  if (projectChanged) projectDraft = projectSaved ? null : project;
+  cached = loadLayered();
+  notify(cached.settings);
+  return globalSaved && projectSaved;
+}
+function previewSetting(key, value) {
+  if (cached === null) cached = loadLayered();
+  cached = { settings: { ...cached.settings, [key]: value }, sources: cached.sources };
+  notify(cached.settings);
+}
+function subscribeSettings(fn) {
+  subscribers.add(fn);
+  return () => {
+    subscribers.delete(fn);
+  };
+}
+var bridgedAnalyticsEnv;
+function bridgeAnalyticsLevel(settings) {
+  try {
+    const current = process.env[ANALYTICS_LEVEL_ENV];
+    if (current === void 0 || current === bridgedAnalyticsEnv) {
+      process.env[ANALYTICS_LEVEL_ENV] = settings.analyticsLevel;
+      bridgedAnalyticsEnv = settings.analyticsLevel;
+    } else {
+      bridgedAnalyticsEnv = void 0;
+    }
+    const environmentLevel = resolveAnalyticsLevel();
+    analyticsPipeline.setLevel(levelAtLeast(environmentLevel, settings.analyticsLevel) ? settings.analyticsLevel : environmentLevel);
+  } catch {
+  }
+}
+function reloadSettings() {
+  globalDraft = null;
+  projectDraft = null;
+  cached = loadLayered();
+  notify(cached.settings);
+  return cached.settings;
+}
+function configureSettingsStore(options) {
+  homeDir = options.homeDir;
+  projectDir = options.projectDir;
+  reloadSettings();
+}
+function useSettings() {
+  return useSyncExternalStore(subscribeSettings, getSettings, getSettings);
+}
+
+// packages/cli/src/codex-auth.ts
+import { readFileSync as readFileSync3, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join as join4 } from "node:path";
+var AUTH_FILE_ENV = "0SEC_CHATGPT_AUTH_FILE";
+var LEGACY_AUTH_FILE_ENV = "0SEC_CODEX_AUTH_JSON_PATH";
+function maybeLoadCodexAuth(options = {}) {
+  const env = options.env ?? process.env;
+  if (!options.force && (env["0SEC_CHATGPT_ACCESS_TOKEN"] || env["0SEC_CHATGPT_OAUTH_REFRESH_TOKEN"])) {
+    return;
+  }
+  const home = options.home ?? homedir();
+  const override = nonEmpty(env[AUTH_FILE_ENV]) ?? nonEmpty(env[LEGACY_AUTH_FILE_ENV]);
+  const path = override ?? join4(home, ".codex", "auth.json");
+  if (!existsSync(path)) return;
+  try {
+    const raw = JSON.parse(readFileSync3(path, "utf8"));
+    const accessToken = nonEmpty(asString(raw.tokens?.access_token));
+    const refreshToken = nonEmpty(asString(raw.tokens?.refresh_token));
+    if (!accessToken && !refreshToken) return;
+    if (options.force) {
+      delete env["0SEC_CHATGPT_ACCESS_TOKEN"];
+      delete env["0SEC_CHATGPT_OAUTH_REFRESH_TOKEN"];
+    }
+    if (accessToken) {
+      env["0SEC_CHATGPT_ACCESS_TOKEN"] = accessToken;
+    }
+    if (refreshToken) {
+      env["0SEC_CHATGPT_OAUTH_REFRESH_TOKEN"] = refreshToken;
+    }
+  } catch {
+  }
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
+// packages/cli/src/presentation/event-bus.ts
+var PresentationEventBus = class {
+  listeners = [];
+  subscribe(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index >= 0) this.listeners.splice(index, 1);
+    };
+  }
+  emit(event) {
+    for (const listener of [...this.listeners]) {
+      try {
+        listener.emit(event);
+      } catch {
+      }
+    }
+  }
+  get size() {
+    return this.listeners.length;
+  }
+};
+var presentationEventBus = new PresentationEventBus();
+function createPresentationEmitter(options = {}) {
+  const source = options.source ?? "cli";
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const bus = options.bus ?? presentationEventBus;
+  let sequence = 0;
+  return {
+    emit(eventType, payload, correlation = {}) {
+      const event = createPresentationEvent({
+        source,
+        sequence: ++sequence,
+        at: now(),
+        eventType,
+        payload,
+        ...correlation.scanId ? { scanId: correlation.scanId } : {},
+        ...correlation.sessionId ? { sessionId: correlation.sessionId } : {}
+      });
+      bus.emit(event);
+      return event;
+    }
+  };
+}
+
+// packages/cli/src/presentation/process-output.ts
+import { format } from "node:util";
+var streamBridgeSuppressionDepth = 0;
+var activeStreamBridge = null;
+function currentPresentationTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createProcessPresentationOutput(options = {}) {
+  const stdout = options.stdout ?? { write: process.stdout.write.bind(process.stdout) };
+  const stderr = options.stderr ?? { write: process.stderr.write.bind(process.stderr) };
+  const source = options.source ?? "cli";
+  const now = options.now ?? currentPresentationTimestamp;
+  let sequence = 0;
+  const write = (channel, target, text, eventType) => {
+    const event = createPresentationEvent({
+      source,
+      sequence: ++sequence,
+      at: now(),
+      eventType,
+      payload: { channel, text }
+    });
+    streamBridgeSuppressionDepth += 1;
+    try {
+      target.write(text);
+    } finally {
+      streamBridgeSuppressionDepth -= 1;
+    }
+    options.onEvent?.(event);
+    return event;
+  };
+  return {
+    stdout(text, eventType = "output.stdout") {
+      return write("stdout", stdout, text, eventType);
+    },
+    stderr(text, eventType = "output.stderr") {
+      return write("stderr", stderr, text, eventType);
+    }
+  };
+}
+function createConsolePresentationOutput(options = {}) {
+  const source = options.source ?? "cli";
+  const now = options.now ?? currentPresentationTimestamp;
+  let sequence = 0;
+  const emit = (channel, text, eventType) => {
+    const event = createPresentationEvent({
+      source,
+      sequence: ++sequence,
+      at: now(),
+      eventType,
+      payload: { channel, text }
+    });
+    streamBridgeSuppressionDepth += 1;
+    try {
+      if (channel === "stdout") {
+        (options.log ?? console.log)(text);
+      } else {
+        (options.error ?? console.error)(text);
+      }
+    } finally {
+      streamBridgeSuppressionDepth -= 1;
+    }
+    options.onEvent?.(event);
+    return event;
+  };
+  return {
+    stdout(text, eventType = "output.stdout") {
+      return emit("stdout", text, eventType);
+    },
+    stderr(text, eventType = "output.stderr") {
+      return emit("stderr", text, eventType);
+    }
+  };
+}
+var consolePresentationOutput = createConsolePresentationOutput({
+  onEvent(event) {
+    presentationEventBus.emit(event);
+  }
+});
+function installConsolePresentationBridge(options = {}) {
+  const target = options.target ?? console;
+  const originals = {
+    log: target.log,
+    info: target.info,
+    warn: target.warn,
+    error: target.error
+  };
+  const source = options.source ?? "cli";
+  const now = options.now ?? currentPresentationTimestamp;
+  let sequence = 0;
+  const emit = (method, channel, args, eventType) => {
+    const text = format(...args);
+    if (streamBridgeSuppressionDepth > 0) {
+      originals[method].call(target, text);
+      return;
+    }
+    const event = createPresentationEvent({
+      source,
+      sequence: ++sequence,
+      at: now(),
+      eventType,
+      payload: { channel, text }
+    });
+    streamBridgeSuppressionDepth += 1;
+    try {
+      originals[method].call(target, text);
+    } finally {
+      streamBridgeSuppressionDepth -= 1;
+    }
+    presentationEventBus.emit(event);
+    options.onEvent?.(event);
+  };
+  const bridgedLog = (...args) => emit("log", "stdout", args, "output.console.log");
+  const bridgedInfo = (...args) => emit("info", "stdout", args, "output.console.info");
+  const bridgedWarn = (...args) => emit("warn", "stderr", args, "output.console.warn");
+  const bridgedError = (...args) => emit("error", "stderr", args, "output.console.error");
+  target.log = bridgedLog;
+  target.info = bridgedInfo;
+  target.warn = bridgedWarn;
+  target.error = bridgedError;
+  return {
+    restore() {
+      if (target.log === bridgedLog) target.log = originals.log;
+      if (target.info === bridgedInfo) target.info = originals.info;
+      if (target.warn === bridgedWarn) target.warn = originals.warn;
+      if (target.error === bridgedError) target.error = originals.error;
+    }
+  };
+}
+function installProcessPresentationStreamBridge(options = {}) {
+  if (activeStreamBridge) return activeStreamBridge;
+  const source = options.source ?? "cli";
+  const now = options.now ?? currentPresentationTimestamp;
+  let sequence = 0;
+  let suspended = false;
+  const streams = [];
+  const emit = (channel, chunk, encoding) => {
+    const text = typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk).toString(typeof encoding === "string" ? encoding : "utf8") : String(chunk ?? "");
+    if (channel === "stdout" && text.startsWith("0SEC_EVENT_")) return;
+    const event = createPresentationEvent({
+      source,
+      sequence: ++sequence,
+      at: now(),
+      eventType: channel === "stdout" ? "output.stream.stdout" : "output.stream.stderr",
+      payload: { channel, text }
+    });
+    presentationEventBus.emit(event);
+    options.onEvent?.(event);
+  };
+  for (const [channel, stream] of [
+    ["stdout", options.stdout ?? process.stdout],
+    ["stderr", options.stderr ?? process.stderr]
+  ]) {
+    const original = stream.write;
+    const patched = ((chunk, encoding, callback) => {
+      const result = original.call(stream, chunk, encoding, callback);
+      if (!suspended && streamBridgeSuppressionDepth === 0) emit(channel, chunk, encoding);
+      return result;
+    });
+    streams.push({ channel, stream, original, patched });
+  }
+  const bridge = {
+    suspend() {
+      if (suspended) return;
+      suspended = true;
+      for (const item of streams) {
+        if (item.stream.write === item.patched) item.stream.write = item.original;
+      }
+    },
+    resume() {
+      if (!suspended) return;
+      suspended = false;
+      for (const item of streams) {
+        if (item.stream.write === item.original) item.stream.write = item.patched;
+      }
+    },
+    restore() {
+      for (const item of streams) {
+        if (item.stream.write === item.patched) item.stream.write = item.original;
+      }
+      if (activeStreamBridge === bridge) activeStreamBridge = null;
+    }
+  };
+  for (const item of streams) item.stream.write = item.patched;
+  activeStreamBridge = bridge;
+  return bridge;
+}
+function suspendProcessPresentationStreamBridge() {
+  activeStreamBridge?.suspend();
+}
+function resumeProcessPresentationStreamBridge() {
+  activeStreamBridge?.resume();
+}
+var processPresentationOutput = createProcessPresentationOutput({
+  onEvent(event) {
+    presentationEventBus.emit(event);
+  }
+});
+function writePresentationLine(text, eventType = "output.stdout") {
+  return processPresentationOutput.stdout(`${text}
+`, eventType);
+}
+
+export {
+  KEYBINDINGS,
+  keybindingsByCategory,
+  parseChord,
+  keyMatchesChord,
+  effectiveChords,
+  matchesBinding,
+  assessChordAssignment,
+  resolveSyntaxColors,
+  parseHex,
+  readableOnPrimary,
+  THEME_NAMES,
+  DEFAULT_THEME_NAME,
+  THEMES,
+  isThemeName,
+  getTheme,
+  getThemeEntry,
+  severityToneFor,
+  validateTheme,
+  detectColorDepth,
+  degradePalette,
+  installedThemesDir,
+  isSafeThemeId,
+  reloadInstalledThemes,
+  installedThemeEntries,
+  isKnownTheme,
+  writeInstalledTheme,
+  removeInstalledTheme,
+  SETTING_DEFS,
+  DEFAULT_SETTINGS,
+  settingsFilePath,
+  projectSettingsFilePath,
+  loadLayeredSettings,
+  normalizeSettings,
+  loadSettings,
+  loadGlobalSettings,
+  saveSettings,
+  sanitizeOverrides,
+  readProjectOverrides,
+  saveProjectOverrides,
+  getSettings,
+  updateSetting,
+  resetSettings,
+  previewSetting,
+  subscribeSettings,
+  reloadSettings,
+  configureSettingsStore,
+  useSettings,
+  maybeLoadCodexAuth,
+  presentationEventBus,
+  createPresentationEmitter,
+  consolePresentationOutput,
+  installConsolePresentationBridge,
+  installProcessPresentationStreamBridge,
+  suspendProcessPresentationStreamBridge,
+  resumeProcessPresentationStreamBridge,
+  processPresentationOutput,
+  writePresentationLine
+};