@visual-z/xeno 0.1.4 → 0.2.1

package/src/core/session-browser.ts

@@ -0,0 +1,82 @@
+/** Pi session-selector-search (MIT, 02eed88), independent of its AgentSession and clock. */
+export type SessionSort = "threaded" | "recent" | "relevance";
+export interface SessionRow {
+  path: string; id: string; name: string | null; updated_at: string | null;
+  workspace?: string; parent_session?: string; text?: string;
+}
+export interface SearchQuery {
+  tokens: { kind: "fuzzy" | "phrase"; value: string }[];
+  regex?: RegExp;
+  error?: string;
+}
+export function parseSessionQuery(query: string): SearchQuery {
+  const trimmed = query.trim();
+  if (trimmed.startsWith("re:")) {
+    if (!trimmed.slice(3).trim()) return { tokens: [], error: "Empty regex" };
+    try { return { tokens: [], regex: new RegExp(trimmed.slice(3).trim(), "i") }; }
+    catch (error) { return { tokens: [], error: String(error) }; }
+  }
+  const tokens: SearchQuery["tokens"] = [];
+  let buffer = "", quoted = false;
+  const flush = () => { if (buffer.trim()) tokens.push({ kind: quoted ? "phrase" : "fuzzy", value: buffer.trim() }); buffer = ""; };
+  for (const char of trimmed) {
+    if (char === '"') { flush(); quoted = !quoted; }
+    else if (!quoted && /\s/.test(char)) flush();
+    else buffer += char;
+  }
+  if (quoted) return { tokens: trimmed.split(/\s+/).filter(Boolean).map(value => ({ kind: "fuzzy", value })) };
+  flush(); return { tokens };
+}
+export function selectSessions<T extends SessionRow>(rows: readonly T[], query: string, sort: SessionSort, named: boolean,
+  fuzzy: (query: string, text: string) => { matches: boolean; score: number }): (T & { depth: number })[] {
+  const parsed = parseSessionQuery(query);
+  if (parsed.error) return [];
+  const scored = rows.flatMap(row => {
+    if (named && !row.name?.trim()) return [];
+    const text = `${row.id} ${row.name ?? ""} ${row.text ?? ""} ${row.workspace ?? ""}`;
+    let score = 0;
+    if (parsed.regex) { const i = text.search(parsed.regex); if (i < 0) return []; score = i * 0.1; }
+    else for (const token of parsed.tokens) {
+      if (token.kind === "phrase") {
+        const i = text.toLowerCase().replace(/\s+/g, " ").indexOf(token.value.toLowerCase().replace(/\s+/g, " "));
+        if (i < 0) return []; score += i * 0.1;
+      } else { const match = fuzzy(token.value, text); if (!match.matches) return []; score += match.score; }
+    }
+    return [{ row, score }];
+  });
+  const recent = (a: SessionRow, b: SessionRow) => (b.updated_at ?? "").localeCompare(a.updated_at ?? "") || a.path.localeCompare(b.path);
+  scored.sort((a, b) => query.trim() && sort !== "recent" ? a.score - b.score || recent(a.row, b.row) : recent(a.row, b.row));
+  if (sort !== "threaded" || query.trim()) return scored.map(({ row }) => ({ ...row, depth: 0 }));
+  const byPath = new Map(scored.map(({ row }) => [row.path, row]));
+  const children = new Map<string, T[]>();
+  const roots: T[] = [];
+  for (const { row } of scored) {
+    if (row.parent_session && row.parent_session !== row.path && byPath.has(row.parent_session)) {
+      const list = children.get(row.parent_session) ?? []; list.push(row); children.set(row.parent_session, list);
+    } else roots.push(row);
+  }
+  // Allocation can be arbitrarily deep. Iterative traversal handles cycles without hiding their rows.
+  const latest = new Map(scored.map(({ row }) => [row.path, row.updated_at ?? ""]));
+  for (const { row } of scored) {
+    const visited = new Set<string>([row.path]);
+    let parent = row.parent_session;
+    while (parent && byPath.has(parent) && !visited.has(parent)) {
+      visited.add(parent);
+      if ((row.updated_at ?? "") > (latest.get(parent) ?? "")) latest.set(parent, row.updated_at ?? "");
+      parent = byPath.get(parent)?.parent_session;
+    }
+  }
+  const byActivity = (a: T, b: T) => (latest.get(b.path) ?? "").localeCompare(latest.get(a.path) ?? "") || recent(a, b);
+  roots.sort(byActivity); for (const list of children.values()) list.sort(byActivity);
+  const out: (T & { depth: number })[] = [], visited = new Set<string>();
+  for (const root of [...roots, ...scored.map(s => s.row)]) {
+    const stack = [{ row: root, depth: 0 }];
+    while (stack.length) {
+      const next = stack.pop()!;
+      if (visited.has(next.row.path)) continue;
+      visited.add(next.row.path); out.push({ ...next.row, depth: next.depth });
+      for (const row of [...children.get(next.row.path) ?? []].reverse()) stack.push({ row, depth: next.depth + 1 });
+    }
+  }
+  return out;
+}

package/src/core/session-entry.ts

@@ -0,0 +1,56 @@
+/** Session intent is decided before any log is opened (D8, Pi entry parity). */
+export interface SessionEntryFlags {
+  explicit?: string;
+  fresh?: boolean;
+  continueLatest?: boolean;
+  noSession?: boolean;
+  session?: string;
+  sessionId?: string;
+  resume?: string | boolean;
+  forkFrom?: string;
+}
+
+export type SessionEntry =
+  | { kind: "new" }
+  | { kind: "ephemeral" }
+  | { kind: "continue" }
+  | { kind: "select" }
+  | { kind: "named"; id: string }
+  | { kind: "open"; target: string; explicit: boolean }
+  | { kind: "fork"; target: string };
+
+export function planSessionEntry(flags: SessionEntryFlags): SessionEntry {
+  const choices: { flag: string; entry: SessionEntry }[] = [];
+  if (flags.explicit) choices.push({ flag: "--log", entry: { kind: "open", target: flags.explicit, explicit: true } });
+  if (flags.session) choices.push({ flag: "--session", entry: { kind: "open", target: flags.session, explicit: false } });
+  if (flags.sessionId) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(flags.sessionId)) throw new Error("--session-id requires a plain session identifier");
+    choices.push({ flag: "--session-id", entry: { kind: "named", id: flags.sessionId } });
+  }
+  if (flags.resume) choices.push({ flag: "--resume", entry: typeof flags.resume === "string"
+    ? { kind: "open", target: flags.resume, explicit: false } : { kind: "select" } });
+  if (flags.forkFrom) choices.push({ flag: "--fork", entry: { kind: "fork", target: flags.forkFrom } });
+  if (flags.continueLatest) choices.push({ flag: "--continue", entry: { kind: "continue" } });
+  // --fresh predates --no-session; together they still mean a fresh ephemeral log.
+  if (flags.fresh || flags.noSession) choices.push({ flag: flags.noSession ? "--no-session" : "--fresh",
+    entry: { kind: flags.noSession ? "ephemeral" : "new" } });
+  if (choices.length > 1) throw new Error(`conflicting session options: ${choices.map((c) => c.flag).join(", ")}`);
+  return choices[0]?.entry ?? { kind: "new" };
+}
+
+export interface SavedModel {
+  model: string;
+  provider?: string;
+}
+
+/** Legacy logs have only an ID; accepting one requires a unique catalog match. */
+export function restoreSessionModel<T extends { id: string; provider: string }>(
+  saved: SavedModel,
+  catalog: readonly T[],
+): T {
+  const matches = catalog.filter((m) => m.id === saved.model && (saved.provider === undefined || m.provider === saved.provider));
+  const label = saved.provider === undefined ? saved.model : `${saved.provider}/${saved.model}`;
+  if (matches.length === 0) throw new Error(`saved model ${label} is unavailable. Restore its catalog entry, or start a new session`);
+  if (matches.length !== 1) throw new Error(`saved model ${label} is ambiguous across providers. Restore an unambiguous catalog before resuming`);
+  return matches[0]!;
+}

package/src/core/session-position.ts

@@ -0,0 +1,26 @@
+/** D8: session configuration is projected from the append-only metadata journal. */
+export interface PositionedState { node: number; at_event?: string }
+
+export function stateAtPosition<T extends PositionedState>(
+  states: readonly T[], node: number, eventIds: readonly string[], atEvent?: string,
+): T | null {
+  const positions = new Map(eventIds.map((id, index) => [id, index]));
+  const target = atEvent === undefined ? eventIds.length : positions.get(atEvent);
+  if (target === undefined) throw new Error(`NO_SUCH_EVENT: ${atEvent}`);
+  let result: T | null = null;
+  for (const state of states) {
+    if (state.node !== node) continue;
+    const position = state.at_event === undefined ? -1 : positions.get(state.at_event);
+    if (position !== undefined && position <= target) result = state;
+  }
+  return result;
+}
+
+export function sameModel(a: { model: string; provider?: string }, b: { model: string; provider?: string }): boolean {
+  return a.model === b.model && a.provider !== undefined && a.provider === b.provider;
+}
+
+/** Selector values must remain unambiguous when two providers serve the same ID. */
+export function modelKey(model: { provider: string; id: string }): string {
+  return `${model.provider}/${model.id}`;
+}

package/src/core/settings.ts

@@ -1,174 +1,189 @@
-/**
- * Settings schema and merge. Pure: store reads the files, this module
- * decides which keys exist and which layer wins.
- *
- * Write-back is a patch of keys the user actually changed. Dumping the
- * whole default object into ~/.xeno/settings.json freezes today's defaults
- * for that user forever (feat-theming design).
- */
-
-export const SETTINGS_KEYS = [
-  "theme",
-  "thinking",
-  "statusBar",
-  "defaultProvider",
-  "defaultModel",
-  "defaultThinking",
-  "scopedModels",
-] as const;
-
-export type SettingsKey = (typeof SETTINGS_KEYS)[number];
+import { THINKING_LEVELS, asThinkingLevel, type ThinkingLevel } from "./thinking.ts";
+import { packageDeclaration, type PackageDeclaration } from "./packages.ts";
 
+/** Validated configuration. D19: display policy never mutates the log. */
 export interface Settings {
   readonly theme?: string;
   readonly thinking?: string;
   readonly statusBar?: boolean;
+  readonly hideThinkingBlock?: boolean;
+  readonly showCacheMissNotices?: boolean;
   readonly defaultProvider?: string;
   readonly defaultModel?: string;
-  /** Ctrl+S in the thinking selector. Distinct from `thinking` so /settings does not overwrite a saved default. */
   readonly defaultThinking?: string;
-  /** `--models` / Ctrl+P set. Absent means there is nothing to cycle. */
+  readonly modelThinkingLevels?: Readonly<Record<string, ThinkingLevel>>;
   readonly scopedModels?: readonly string[];
+  readonly steeringMode?: "all" | "one-at-a-time";
+  readonly followUpMode?: "all" | "one-at-a-time";
+  readonly tuiMode?: "regular" | "fullscreen";
+  readonly fullscreenExitOutput?: "transcript" | "resume-hint";
+  readonly fullscreenScrollbar?: "auto" | "always" | "hidden";
+  readonly fullscreenCopyOnSelect?: boolean;
+  readonly fullscreenWheelScrollLines?: "auto" | number;
+  readonly editorPaddingX?: number;
+  readonly outputPad?: 0 | 1;
+  readonly autocompleteMaxVisible?: number;
+  readonly showHardwareCursor?: boolean;
+  readonly quietStartup?: boolean;
+  readonly doubleEscapeAction?: "tree" | "fork" | "none";
+  readonly treeFilterMode?: "default" | "no-tools" | "user-only" | "labeled-only" | "all";
+  readonly externalEditor?: string;
+  readonly skills?: readonly string[];
+  readonly prompts?: readonly string[];
+  readonly themes?: readonly string[];
+  readonly extensions?: readonly string[];
+  readonly packages?: readonly PackageDeclaration[];
+  readonly enableSkillCommands?: boolean;
+  readonly defaultProjectTrust?: "ask" | "always" | "never";
+  readonly terminal?: { readonly clearOnShrink?: boolean; readonly showTerminalProgress?: boolean; readonly showImages?: boolean; readonly imageWidthCells?: number };
+  readonly images?: { readonly autoResize?: boolean; readonly blockImages?: boolean };
+  readonly markdown?: { readonly mermaid?: "off" | "final" | "streaming" };
 }
-
-export interface SettingsLayers {
-  readonly builtin: Settings;
-  readonly user?: Settings;
-  readonly project?: Settings;
-  readonly cli?: Settings;
-}
-
-export interface SettingsParse {
-  readonly settings: Settings;
-  readonly diagnostics: readonly string[];
-}
-
-const THINKING_LEVELS = new Set(["low", "medium", "high", "xhigh", "max"]);
-
-export function defaultSettings(): Settings {
-  return { theme: "dark", thinking: "high", statusBar: true };
-}
-
+export const SETTINGS_KEYS = ["theme", "thinking", "statusBar", "hideThinkingBlock", "showCacheMissNotices", "defaultProvider", "defaultModel", "defaultThinking",
+  "modelThinkingLevels", "scopedModels", "steeringMode", "followUpMode", "tuiMode", "fullscreenExitOutput", "fullscreenScrollbar",
+  "fullscreenCopyOnSelect", "fullscreenWheelScrollLines", "editorPaddingX", "outputPad", "autocompleteMaxVisible",
+  "showHardwareCursor", "quietStartup", "doubleEscapeAction", "treeFilterMode", "externalEditor", "terminal", "images", "markdown",
+  "skills", "prompts", "themes", "extensions", "packages", "enableSkillCommands", "defaultProjectTrust"] as const;
+export type SettingsKey = (typeof SETTINGS_KEYS)[number];
+export interface SettingsLayers { readonly builtin: Settings; readonly user?: Settings; readonly project?: Settings; readonly cli?: Settings }
+export interface SettingsParse { readonly settings: Settings; readonly diagnostics: readonly string[] }
+type Rule = { readonly kind: "boolean" | "string" | "strings" } | { readonly kind: "enum"; readonly values: readonly string[] } |
+  { readonly kind: "integer"; readonly min: number; readonly max: number; readonly auto?: boolean };
+const levels: Rule = { kind: "enum", values: THINKING_LEVELS };
+const delivery: Rule = { kind: "enum", values: ["all", "one-at-a-time"] };
+const rules: Readonly<Record<string, Rule>> = {
+  theme: { kind: "string" }, thinking: levels, statusBar: { kind: "boolean" },
+  hideThinkingBlock: { kind: "boolean" }, showCacheMissNotices: { kind: "boolean" },
+  defaultProvider: { kind: "string" }, defaultModel: { kind: "string" }, defaultThinking: levels,
+  scopedModels: { kind: "strings" }, steeringMode: delivery, followUpMode: delivery,
+  tuiMode: { kind: "enum", values: ["regular", "fullscreen"] },
+  fullscreenExitOutput: { kind: "enum", values: ["transcript", "resume-hint"] },
+  fullscreenScrollbar: { kind: "enum", values: ["auto", "always", "hidden"] },
+  fullscreenCopyOnSelect: { kind: "boolean" },
+  // Pi's documented display bounds; these are not context/segment thresholds.
+  fullscreenWheelScrollLines: { kind: "integer", min: 1, max: 100, auto: true },
+  editorPaddingX: { kind: "integer", min: 0, max: 3 }, outputPad: { kind: "integer", min: 0, max: 1 },
+  autocompleteMaxVisible: { kind: "integer", min: 3, max: 20 },
+  showHardwareCursor: { kind: "boolean" }, quietStartup: { kind: "boolean" },
+  doubleEscapeAction: { kind: "enum", values: ["tree", "fork", "none"] },
+  treeFilterMode: { kind: "enum", values: ["default", "no-tools", "user-only", "labeled-only", "all"] },
+  externalEditor: { kind: "string" }, "terminal.clearOnShrink": { kind: "boolean" },
+  "terminal.showTerminalProgress": { kind: "boolean" },
+  "terminal.showImages": { kind: "boolean" }, "terminal.imageWidthCells": { kind: "integer", min: 1, max: 240 },
+  "images.autoResize": { kind: "boolean" }, "images.blockImages": { kind: "boolean" },
+  "markdown.mermaid": { kind: "enum", values: ["off", "final", "streaming"] },
+  skills: { kind: "strings" }, prompts: { kind: "strings" }, themes: { kind: "strings" }, extensions: { kind: "strings" },
+  enableSkillCommands: { kind: "boolean" }, defaultProjectTrust: { kind: "enum", values: ["ask", "always", "never"] },
+};
+/** One catalog supplies menu values and command validation. */
+export const DISPLAY_SETTINGS = [
+  { id: "hideThinkingBlock", label: "Hide thinking blocks", fallback: "on" },
+  { id: "showCacheMissNotices", label: "Cache miss notices", fallback: "off" },
+  { id: "enableSkillCommands", label: "Skill commands", fallback: "on" },
+  { id: "defaultProjectTrust", label: "Default project trust", fallback: "ask" },
+  { id: "terminal.showImages", label: "Show images", fallback: "on" },
+  { id: "terminal.imageWidthCells", label: "Image width", fallback: "60" },
+  { id: "images.autoResize", label: "Resize images", fallback: "on" },
+  { id: "images.blockImages", label: "Block image transmission", fallback: "off" },
+  { id: "markdown.mermaid", label: "Mermaid diagrams", fallback: "streaming" },
+  { id: "tuiMode", label: "TUI mode", fallback: "regular" },
+  { id: "fullscreenExitOutput", label: "Fullscreen exit output", fallback: "transcript" },
+  { id: "fullscreenScrollbar", label: "Fullscreen scrollbar", fallback: "auto" },
+  { id: "fullscreenCopyOnSelect", label: "Fullscreen copy on select", fallback: "on" },
+  { id: "fullscreenWheelScrollLines", label: "Fullscreen wheel scroll lines", fallback: "auto" },
+  { id: "editorPaddingX", label: "Editor padding", fallback: "0" },
+  { id: "outputPad", label: "Output padding", fallback: "1" },
+  { id: "autocompleteMaxVisible", label: "Autocomplete rows", fallback: "5" },
+  { id: "showHardwareCursor", label: "Hardware cursor", fallback: "on" },
+  { id: "quietStartup", label: "Quiet startup", fallback: "off" },
+  { id: "doubleEscapeAction", label: "Double Escape", fallback: "tree" },
+  { id: "treeFilterMode", label: "Tree filter", fallback: "default" },
+  { id: "terminal.clearOnShrink", label: "Clear on shrink", fallback: "off" },
+  { id: "terminal.showTerminalProgress", label: "Terminal progress", fallback: "on" },
+] as const;
+export function defaultSettings(): Settings { return { theme: "dark", thinking: "high", statusBar: true }; }
 export function mergeSettings(layers: SettingsLayers): Settings {
-  return {
-    ...layers.builtin,
-    ...layers.user,
-    ...layers.project,
-    ...layers.cli,
+  const { defaultProjectTrust: _projectCannotGrantTrust, ...project } = layers.project ?? {};
+  const all = [layers.builtin, layers.user ?? {}, project, layers.cli ?? {}];
+  const merged: Settings = Object.assign({}, ...all);
+  return { ...merged,
+    ...(all.some(s => s.terminal !== undefined) ? { terminal: Object.assign({}, ...all.map(s => s.terminal ?? {})) } : {}),
+    ...(all.some(s => s.images !== undefined) ? { images: Object.assign({}, ...all.map(s => s.images ?? {})) } : {}),
+    ...(all.some(s => s.markdown !== undefined) ? { markdown: Object.assign({}, ...all.map(s => s.markdown ?? {})) } : {}),
+    ...(all.some(s => s.modelThinkingLevels !== undefined) ? { modelThinkingLevels: Object.assign({}, ...all.map(s => s.modelThinkingLevels ?? {})) } : {}),
   };
 }
-
-/**
- * Only keys present on `explicit`. Passing the merged object here would
- * persist defaults and pin old users to them.
- */
 export function settingsToWrite(explicit: Partial<Settings>): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  if (explicit.theme !== undefined) out["theme"] = explicit.theme;
-  if (explicit.thinking !== undefined) out["thinking"] = explicit.thinking;
-  if (explicit.statusBar !== undefined) out["statusBar"] = explicit.statusBar;
-  if (explicit.defaultProvider !== undefined) out["defaultProvider"] = explicit.defaultProvider;
-  if (explicit.defaultModel !== undefined) out["defaultModel"] = explicit.defaultModel;
-  if (explicit.defaultThinking !== undefined) out["defaultThinking"] = explicit.defaultThinking;
-  if (explicit.scopedModels !== undefined) out["scopedModels"] = explicit.scopedModels;
-  return out;
+  return Object.fromEntries(SETTINGS_KEYS.filter(key => explicit[key] !== undefined).map(key => [key, explicit[key]]));
 }
-
+export function explicitSettings(raw: unknown, parsed: Settings): Partial<Settings> {
+  if (!isRecord(raw)) return {};
+  return Object.fromEntries(SETTINGS_KEYS.filter(key => (key in raw || Object.entries(aliases).some(([alias, canonical]) => canonical === key && alias in raw)) && parsed[key] !== undefined).map(key => [key, parsed[key]]));
+}
+const aliases: Readonly<Record<string, string>> = { defaultThinkingLevel: "defaultThinking", enabledModels: "scopedModels" };
 export function parseSettings(json: unknown): SettingsParse {
-  if (json === null || json === undefined) {
-    return { settings: {}, diagnostics: [] };
-  }
-  if (typeof json !== "object" || Array.isArray(json)) {
-    return { settings: {}, diagnostics: ["settings is not an object"] };
-  }
-  const rec = json as { readonly [k: string]: unknown };
-  const diagnostics: string[] = [];
-  const settings: { [K in SettingsKey]?: Settings[K] } = {};
-
-  for (const key of Object.keys(rec)) {
-    if (!(SETTINGS_KEYS as readonly string[]).includes(key)) {
-      diagnostics.push(`unknown setting: ${key}`);
-    }
-  }
-
-  const theme = rec["theme"];
-  if (theme !== undefined) {
-    if (typeof theme === "string" && theme.length > 0) settings.theme = theme;
-    else diagnostics.push("settings.theme must be a non-empty string");
+  if (json === null || json === undefined) return { settings: {}, diagnostics: [] };
+  if (!isRecord(json)) return { settings: {}, diagnostics: ["settings is not an object"] };
+  const out: Record<string, unknown> = {}, diagnostics: string[] = [];
+  for (const [rawKey, value] of Object.entries(json)) {
+    const key = aliases[rawKey] ?? rawKey;
+    if (rawKey !== key && key in json) continue;
+    if (value === undefined) continue;
+    if (key === "packages") {
+      if (Array.isArray(value) && value.every(packageDeclaration)) out[key] = value;
+      else diagnostics.push("settings.packages must contain source strings or package resource filters");
+    } else if (key === "modelThinkingLevels") {
+      if (!isRecord(value)) { diagnostics.push("settings.modelThinkingLevels must be an object"); continue; }
+      const mapped: Record<string, ThinkingLevel> = {};
+      for (const [id, level] of Object.entries(value)) {
+        const parsed = asThinkingLevel(level);
+        if (id.includes("/") && !id.startsWith("/") && !id.endsWith("/") && parsed) mapped[id] = parsed;
+        else diagnostics.push("settings.modelThinkingLevels requires provider/model identities and supported thinking names");
+      }
+      out[key] = mapped;
+    } else if (key === "terminal" || key === "images" || key === "markdown") {
+      if (!isRecord(value)) { diagnostics.push("settings." + key + " must be an object"); continue; }
+      const nested: Record<string, unknown> = {};
+      for (const [subkey, subvalue] of Object.entries(value)) validate(key + "." + subkey, subvalue, nested, diagnostics, subkey);
+      out[key] = nested;
+    } else validate(key, value, out, diagnostics, key);
   }
-
-  const thinking = rec["thinking"];
-  if (thinking !== undefined) {
-    if (typeof thinking === "string" && THINKING_LEVELS.has(thinking)) settings.thinking = thinking;
-    else diagnostics.push("settings.thinking must be low|medium|high|xhigh|max");
-  }
-
-  const statusBar = rec["statusBar"];
-  if (statusBar !== undefined) {
-    if (typeof statusBar === "boolean") settings.statusBar = statusBar;
-    else diagnostics.push("settings.statusBar must be a boolean");
-  }
-
-  const defaultProvider = rec["defaultProvider"];
-  if (defaultProvider !== undefined) {
-    if (typeof defaultProvider === "string") settings.defaultProvider = defaultProvider;
-    else diagnostics.push("settings.defaultProvider must be a string");
-  }
-
-  const defaultModel = rec["defaultModel"];
-  if (defaultModel !== undefined) {
-    if (typeof defaultModel === "string") settings.defaultModel = defaultModel;
-    else diagnostics.push("settings.defaultModel must be a string");
-  }
-
-  const defaultThinking = rec["defaultThinking"];
-  if (defaultThinking !== undefined) {
-    if (typeof defaultThinking === "string" && THINKING_LEVELS.has(defaultThinking)) {
-      settings.defaultThinking = defaultThinking;
-    } else diagnostics.push("settings.defaultThinking must be low|medium|high|xhigh|max");
-  }
-
-  const scopedModels = rec["scopedModels"];
-  if (scopedModels !== undefined) {
-    const parsed = parseScopedModels(scopedModels);
-    if (parsed === undefined) diagnostics.push("settings.scopedModels must be an array of strings");
-    else settings.scopedModels = parsed;
-  }
-
-  return { settings, diagnostics };
+  return { settings: out as Settings, diagnostics };
 }
-
-function parseScopedModels(raw: unknown): readonly string[] | undefined {
-  if (Array.isArray(raw) && raw.every((x) => typeof x === "string")) return raw as string[];
-  if (typeof raw === "string") {
-    return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-  }
-  return undefined;
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-
-/** Keys that were actually present on the raw object, after validation. */
-export function explicitSettings(raw: unknown, parsed: Settings): Partial<Settings> {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {};
-  const rec = raw as { readonly [k: string]: unknown };
-  const out: {
-    theme?: string;
-    thinking?: string;
-    statusBar?: boolean;
-    defaultProvider?: string;
-    defaultModel?: string;
-    defaultThinking?: string;
-    scopedModels?: readonly string[];
-  } = {};
-  if ("theme" in rec && parsed.theme !== undefined) out.theme = parsed.theme;
-  if ("thinking" in rec && parsed.thinking !== undefined) out.thinking = parsed.thinking;
-  if ("statusBar" in rec && parsed.statusBar !== undefined) out.statusBar = parsed.statusBar;
-  if ("defaultProvider" in rec && parsed.defaultProvider !== undefined) {
-    out.defaultProvider = parsed.defaultProvider;
-  }
-  if ("defaultModel" in rec && parsed.defaultModel !== undefined) out.defaultModel = parsed.defaultModel;
-  if ("defaultThinking" in rec && parsed.defaultThinking !== undefined) {
-    out.defaultThinking = parsed.defaultThinking;
-  }
-  if ("scopedModels" in rec && parsed.scopedModels !== undefined) out.scopedModels = parsed.scopedModels;
-  return out;
+function validate(key: string, raw: unknown, out: Record<string, unknown>, diagnostics: string[], field: string): void {
+  const rule = rules[key];
+  if (!rule) { diagnostics.push("unknown setting: " + key); return; }
+  const value = rule.kind === "strings" && typeof raw === "string" ? raw.split(",").map(v => v.trim()).filter(Boolean) : raw;
+  const valid = rule.kind === "string" ? typeof value === "string" && value.length > 0 :
+    rule.kind === "boolean" ? typeof value === "boolean" :
+    rule.kind === "strings" ? Array.isArray(value) && value.every(v => typeof v === "string") :
+    rule.kind === "enum" ? typeof value === "string" && rule.values.includes(value) :
+    rule.kind === "integer" && ((rule.auto && value === "auto") || (typeof value === "number" && Number.isSafeInteger(value) && value >= rule.min && value <= rule.max));
+  if (valid) out[field] = value;
+  else diagnostics.push("settings." + key + " must be " + (rule.kind === "enum" ? rule.values.join("|") : rule.kind === "integer" ? rule.min + ".." + rule.max + (rule.auto ? " or auto" : "") : rule.kind));
+}
+export function settingValues(key: string): string[] {
+  const rule = rules[key];
+  if (rule?.kind === "enum") return [...rule.values];
+  if (rule?.kind === "boolean") return ["on", "off"];
+  if (rule?.kind === "integer") return [...(rule.auto ? ["auto"] : []), ...Array.from({ length: rule.max - rule.min + 1 }, (_, i) => String(i + rule.min))];
+  return [];
+}
+export function settingValue(settings: Settings, path: string, fallback: string): string {
+  const [key, subkey] = path.split(".");
+  const object = settings[key as SettingsKey];
+  const raw = subkey && isRecord(object) ? (object as Record<string, unknown>)[subkey] : object;
+  return typeof raw === "boolean" ? raw ? "on" : "off" : raw === undefined ? fallback : String(raw);
+}
+export function settingPatch(field: string, text: string): SettingsParse {
+  const key = Object.keys(rules).find(k => k.toLowerCase() === field.toLowerCase());
+  if (!key) return { settings: {}, diagnostics: ["unknown setting: " + field] };
+  const rule = rules[key]!;
+  const value = rule.kind === "boolean" ? ["on", "true", "1"].includes(text) ? true : ["off", "false", "0"].includes(text) ? false : text :
+    rule.kind === "integer" && text !== "auto" ? Number(text) : text;
+  const [first, second] = key.split(".");
+  return parseSettings(second ? { [first!]: { [second]: value } } : { [key]: value });
 }

package/src/core/theme.ts

@@ -36,7 +36,8 @@ export const THEME_TOKENS = [
 
 export type ThemeToken = (typeof THEME_TOKENS)[number];
 
-export type ThemeColors = { readonly [K in ThemeToken]: string };
+export type ThemeColors = { readonly [K in ThemeToken]: string } & Readonly<Record<string, string>>;
+const PI_THEME_TOKENS: readonly string[] = ["accent","border","borderAccent","borderMuted","success","error","warning","muted","dim","text","thinkingText","scrollbarTrack","scrollbarThumb","searchMatchText","userMessageText","customMessageText","customMessageLabel","toolTitle","toolOutput","mdHeading","mdLink","mdLinkUrl","mdCode","mdCodeBlock","mdCodeBlockBorder","mdQuote","mdQuoteBorder","mdHr","mdListBullet","toolDiffAdded","toolDiffRemoved","toolDiffContext","syntaxComment","syntaxKeyword","syntaxFunction","syntaxVariable","syntaxString","syntaxNumber","syntaxType","syntaxOperator","syntaxPunctuation","thinkingOff","thinkingMinimal","thinkingLow","thinkingMedium","thinkingHigh","thinkingXhigh","thinkingMax","bashMode","selectedBg","searchMatchBg","userMessageBg","customMessageBg","toolPendingBg","toolSuccessBg","toolErrorBg"];
 
 export interface Theme {
   readonly name: string;
@@ -135,20 +136,28 @@ export function parseTheme(json: unknown): ThemeParse {
         })();
 
   for (const key of Object.keys(src)) {
-    if (!isThemeToken(key)) diagnostics.push(`unknown token: ${key}`);
+    if (!isThemeToken(key) && !PI_THEME_TOKENS.includes(key)) diagnostics.push(`unknown token: ${key}`);
   }
 
-  const colors: { [K in ThemeToken]: string } = { ...fallback.colors };
-  for (const token of THEME_TOKENS) {
+  const colors: { [K in ThemeToken]: string } & Record<string, string> = { ...fallback.colors };
+  const vars = typeof rec["vars"] === "object" && rec["vars"] !== null ? rec["vars"] as Record<string, unknown> : {};
+  const resolve = (value: unknown, seen = new Set<string>()): unknown => {
+    if (typeof value !== "string" || !(value in vars)) return value;
+    if (seen.has(value)) return null;
+    return resolve(vars[value], new Set([...seen, value]));
+  };
+  for (const token of new Set<string>([...THEME_TOKENS, ...PI_THEME_TOKENS])) {
     if (!(token in src)) continue;
-    const parsed = parseColor(src[token]);
+    const parsed = parseColor(resolve(src[token]));
     if (parsed === null) {
       diagnostics.push(`invalid colour for ${token}; using built-in`);
       continue;
     }
-    colors[token] = parsed;
+    colors[token] = token.endsWith("Bg") ? parsed.replace(/^38;/, "48;") : parsed;
   }
 
+  if (!("status" in src) && "dim" in colors) colors.status = colors["dim"]!;
+  if (!("prompt" in src)) colors.prompt = colors.text;
   return { theme: { name, colors }, diagnostics };
 }
 

package/src/core/thinking.ts

@@ -0,0 +1,26 @@
+/** Ported from Pi (MIT), ai/models.ts at 02eed88. Capability policy, independent of provider I/O. */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+export interface ThinkingModel {
+  readonly reasoning: boolean;
+  readonly thinkingLevelMap?: Partial<Record<ThinkingLevel, string | null>>;
+}
+export function asThinkingLevel(value: unknown): ThinkingLevel | undefined {
+  return typeof value === "string" && (THINKING_LEVELS as readonly string[]).includes(value) ? value as ThinkingLevel : undefined;
+}
+export function supportedThinkingLevels(model: ThinkingModel): ThinkingLevel[] {
+  if (!model.reasoning) return ["off"];
+  return THINKING_LEVELS.filter(level => {
+    const mapped = model.thinkingLevelMap?.[level];
+    if (mapped === null) return false;
+    return level === "xhigh" || level === "max" ? mapped !== undefined : true;
+  });
+}
+export function clampThinkingLevel(model: ThinkingModel, requested: ThinkingLevel): ThinkingLevel {
+  const available = supportedThinkingLevels(model);
+  const index = THINKING_LEVELS.indexOf(requested);
+  for (const level of [...THINKING_LEVELS.slice(index), ...THINKING_LEVELS.slice(0, index).reverse()]) {
+    if (available.includes(level)) return level;
+  }
+  return "off";
+}

package/src/core/tokens.ts

@@ -10,6 +10,7 @@
  */
 
 import type { Message } from "./project.ts";
+import { estimateImageTokens } from "./images.ts";
 
 export interface TokenCounter {
   readonly kind: "estimate" | "exact";
@@ -73,6 +74,7 @@ export const estimateTokens: TokenCounter = {
         else if (b.type === "thinking") tokens += estimateText(JSON.stringify(b.raw));
         else if (b.type === "tool_use") tokens += estimateText(b.name) + estimateText(JSON.stringify(b.input));
         else if (b.type === "tool_result") tokens += estimateText(b.content);
+        else if (b.type === "image") tokens += estimateImageTokens(b.image);
       }
       // Per-message framing overhead, roughly.
       tokens += 8 / 3.6;