@visual-z/xeno 0.8.4 → 0.9.1

package/src/core/session-format.ts

@@ -1,169 +0,0 @@
-/**
- * S.3: a session directory holds exactly one on-disk format, and this build
- * reads only that one. A directory written in any other format is refused
- * with its location -- never reinterpreted under today's defaults. Reading old
- * logs leniently is how a resumed session once ran without its stall watchdog:
- * new sessions wrote stallLimit 12 while the resume path restored an absent
- * field as 0.
- *
- * The format covers the metadata journal (whose first record declares it),
- * the frozen session context parsed below, events and handoffs. Changing any
- * of them incompatibly means bumping SESSION_FORMAT, not adding a fallback.
- */
-import { parseAcceptanceContract, type AcceptanceContract } from "./acceptance.ts";
-import type { BoundaryConfig } from "./boundary.ts";
-import { isContextPolicy, type ContextPolicy } from "./context-policy.ts";
-import type { FrozenPrefix } from "./project.ts";
-import { validateOutputRecoveryLimit } from "./response-recovery.ts";
-import { schedulingWindow } from "./scheduling.ts";
-import type { Skill } from "./skills.ts";
-import { isBlindChecks, type BlindChecks } from "./blind-checks.ts";
-import { emptyStallState, stallDecision } from "./stall.ts";
-
-export const SESSION_FORMAT = 1;
-
-export type FoundFormat = number | "undeclared";
-
-export function sessionFormatMessage(dir: string, found: FoundFormat): string {
-  const written = found === "undeclared" ? "a layout from before session formats were declared" : `session format ${found}`;
-  return `${dir} holds ${written}; this xeno reads session format ${SESSION_FORMAT} only. ` +
-    "The log is intact and was not modified. Start a new session with --fresh.";
-}
-
-/** Raised before any read or write of a directory in another format. */
-export class SessionFormatError extends Error {
-  readonly dir: string;
-  readonly found: FoundFormat;
-  constructor(dir: string, found: FoundFormat) {
-    super(sessionFormatMessage(dir, found));
-    this.name = "SessionFormatError";
-    this.dir = dir;
-    this.found = found;
-  }
-}
-
-/**
- * What a session freezes at start and restores on resume. Required fields
- * are written by every session of this format, so resume restores them as
- * recorded; there is no default to drift from what was written.
- */
-export interface SessionContext {
-  frozen: FrozenPrefix;
-  gates: Record<string, string>;
-  shellCheckpoints: boolean;
-  skills: readonly Skill[];
-  strictVerification: boolean;
-  workingSet: boolean;
-  workNamespace: string;
-  maxParallelTools: number;
-  contextPolicy: ContextPolicy;
-  stallLimit: number;
-  outputRecoveryLimit: number;
-  acceptanceContract?: AcceptanceContract;
-  workflowMode?: "build" | "plan";
-  agentProfile?: { name: string; workflowExplicit: boolean };
-  workflowToolProfile?: "foundation";
-  boundary?: Partial<BoundaryConfig>;
-  guidance?: boolean;
-  blindChecks?: BlindChecks;
-}
-
-const REQUIRED = ["frozen", "gates", "shellCheckpoints", "skills", "strictVerification", "workingSet",
-  "workNamespace", "maxParallelTools", "contextPolicy", "stallLimit", "outputRecoveryLimit"] as const;
-const OPTIONAL = ["acceptanceContract", "workflowMode", "agentProfile", "workflowToolProfile", "boundary", "guidance", "blindChecks"] as const;
-const BOUNDARY_KEYS = ["triggerTokens", "hardTokens", "minNodeWorkTokens"] as const;
-
-const record = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
-const strings = (value: unknown): value is string[] => Array.isArray(value) && value.every(item => typeof item === "string");
-
-function invalid(field: string, why: string): never {
-  throw new Error(`invalid session context: ${field} ${why}`);
-}
-
-function skill(value: unknown, index: number): Skill {
-  const field = `skills[${index}]`;
-  if (!record(value)) invalid(field, "must be an object");
-  const text = (key: string): string => { const v = value[key]; if (typeof v !== "string") invalid(`${field}.${key}`, "must be a string"); return v; };
-  const disable = value["disableModelInvocation"];
-  if (typeof disable !== "boolean") invalid(`${field}.disableModelInvocation`, "must be a boolean");
-  const out: { -readonly [K in keyof Skill]: Skill[K] } = { name: text("name"), description: text("description"), filePath: text("filePath"), body: text("body"), disableModelInvocation: disable };
-  const invocable = value["userInvocable"];
-  if (invocable !== undefined) { if (typeof invocable !== "boolean") invalid(`${field}.userInvocable`, "must be a boolean"); out.userInvocable = invocable; }
-  if (value["context"] !== undefined) { if (value["context"] !== "fork") invalid(`${field}.context`, "must be fork"); out.context = "fork"; }
-  for (const key of ["allowedTools", "disallowedTools"] as const) {
-    const names = value[key];
-    if (names !== undefined) { if (!strings(names)) invalid(`${field}.${key}`, "must be strings"); out[key] = [...names]; }
-  }
-  if (value["sourceText"] !== undefined) out.sourceText = text("sourceText");
-  return out;
-}
-
-/** Strict: every required field present and typed, no field this format does not define. */
-export function parseSessionContext(value: unknown): SessionContext {
-  if (!record(value)) invalid("context", "must be an object");
-  for (const key of Object.keys(value)) {
-    if (!(REQUIRED as readonly string[]).includes(key) && !(OPTIONAL as readonly string[]).includes(key)) invalid(key, "is not part of this session format");
-  }
-  for (const key of REQUIRED) if (value[key] === undefined) invalid(key, "is missing");
-
-  const frozen = value["frozen"];
-  const system = record(frozen) ? frozen["system"] : undefined, tools = record(frozen) ? frozen["tools"] : undefined;
-  if (typeof system !== "string" || !Array.isArray(tools)) invalid("frozen", "must hold a system string and a tools array");
-  const gates = value["gates"], gateMap: Record<string, string> = {};
-  if (!record(gates)) invalid("gates", "must map names to commands");
-  for (const [name, command] of Object.entries(gates)) { if (typeof command !== "string") invalid(`gates.${name}`, "must be a command string"); gateMap[name] = command; }
-  const flag = (key: "shellCheckpoints" | "strictVerification" | "workingSet"): boolean => { const v = value[key]; if (typeof v !== "boolean") invalid(key, "must be a boolean"); return v; };
-  if (!Array.isArray(value["skills"])) invalid("skills", "must be an array");
-  const skills = value["skills"].map(skill);
-  const namespace = value["workNamespace"];
-  if (typeof namespace !== "string" || namespace.length === 0) invalid("workNamespace", "must be a non-empty string");
-  const limit = (key: "maxParallelTools" | "stallLimit" | "outputRecoveryLimit", check: (n: number) => void): number => {
-    const n = value[key];
-    if (typeof n !== "number") invalid(key, "must be a number");
-    try { check(n); } catch (error) { invalid(key, error instanceof Error ? `is out of range: ${error.message}` : "is out of range"); }
-    return n;
-  };
-  const maxParallelTools = limit("maxParallelTools", n => schedulingWindow([], 0, n));
-  const stallLimit = limit("stallLimit", n => stallDecision(emptyStallState(), n));
-  const outputRecoveryLimit = limit("outputRecoveryLimit", validateOutputRecoveryLimit);
-  const policy = value["contextPolicy"];
-  if (!isContextPolicy(policy)) invalid("contextPolicy", "is not a known policy");
-
-  const context: SessionContext = {
-    frozen: { system, tools }, gates: gateMap, shellCheckpoints: flag("shellCheckpoints"),
-    skills, strictVerification: flag("strictVerification"), workingSet: flag("workingSet"),
-    workNamespace: namespace, maxParallelTools, contextPolicy: policy, stallLimit, outputRecoveryLimit,
-  };
-  if (value["acceptanceContract"] !== undefined) {
-    try { context.acceptanceContract = parseAcceptanceContract(value["acceptanceContract"]); }
-    catch (error) { invalid("acceptanceContract", error instanceof Error ? `is invalid: ${error.message}` : "is invalid"); }
-  }
-  const mode = value["workflowMode"];
-  if (mode !== undefined) { if (mode !== "build" && mode !== "plan") invalid("workflowMode", "must be build or plan"); context.workflowMode = mode; }
-  const profile = value["agentProfile"];
-  if (profile !== undefined) {
-    const name = record(profile) ? profile["name"] : undefined, explicit = record(profile) ? profile["workflowExplicit"] : undefined;
-    if (!record(profile) || Object.keys(profile).length !== 2 || typeof name !== "string" || !/^[a-z][a-z0-9_-]{0,63}$/.test(name) || typeof explicit !== "boolean")
-      invalid("agentProfile", "must name a profile and whether its workflow was explicit");
-    context.agentProfile = { name, workflowExplicit: explicit };
-  }
-  if (value["workflowToolProfile"] !== undefined) {
-    if (value["workflowToolProfile"] !== "foundation") invalid("workflowToolProfile", "must be foundation");
-    context.workflowToolProfile = "foundation";
-  }
-  const boundary = value["boundary"];
-  if (boundary !== undefined) {
-    if (!record(boundary)) invalid("boundary", "must be an object");
-    const thresholds: Partial<BoundaryConfig> = {};
-    for (const [key, n] of Object.entries(boundary)) {
-      if (!(BOUNDARY_KEYS as readonly string[]).includes(key)) invalid(`boundary.${key}`, "is not a boundary threshold");
-      if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0) invalid(`boundary.${key}`, "must be a non-negative integer");
-      thresholds[key as keyof BoundaryConfig] = n;
-    }
-    context.boundary = thresholds;
-  }
-  const guidance = value["guidance"], blind = value["blindChecks"];
-  if (guidance !== undefined) { if (typeof guidance !== "boolean") invalid("guidance", "must be a boolean"); context.guidance = guidance; }
-  if (blind !== undefined) { if (!isBlindChecks(blind)) invalid("blindChecks", "is not a frozen blind check set"); context.blindChecks = blind; }
-  return context;
-}

package/src/core/session-position.ts

@@ -1,26 +0,0 @@
-/** 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/session-tree.ts

@@ -1,147 +0,0 @@
-/**
- * The session tree as data. Pure: restore points + parent pointers in,
- * a forest out; plus a flattening that the UI and the line-mode printer
- * share. Moved from src/tui/tree.ts when the view was rewritten (D20) so the
- * shape of history does not depend on any renderer.
- */
-
-/** Same mark /back uses for a branch the session rewound away from. */
-export const LEFT_BRANCH_MARK = "↩";
-export const EMPTY_TREE_MESSAGE = "nothing to go back to -- no exchange has completed yet";
-
-export type TreeKind = "user" | "other";
-export type TreeFilter = "user" | "default" | "no-tools" | "user-only" | "labeled-only" | "all";
-
-export interface TreeNode {
-  readonly id: string;
-  readonly prompt: string;
-  readonly onPath: boolean;
-  readonly current: boolean;
-  readonly kind: TreeKind;
-  readonly children: readonly TreeNode[];
-  readonly category?: "tool" | "message" | "metadata";
-  readonly label?: string;
-  readonly labelAt?: string;
-  readonly at?: string;
-  readonly content?: string;
-  /** Exact event position; user messages navigate before themselves. */
-  readonly target?: string;
-}
-
-/**
- * A restore point as the log already knows it. parent pointers are a
- * separate map so this file never imports store.
- */
-export interface TreePoint {
-  readonly node: number;
-  readonly atEvent: string;
-  readonly prompt: string;
-  readonly onPath: boolean;
-  readonly kind?: TreeKind;
-  readonly category?: "tool" | "message" | "metadata";
-  readonly label?: string;
-  readonly labelAt?: string;
-  readonly at?: string;
-  readonly content?: string;
-  readonly target?: string;
-}
-
-export type NodeParent = { readonly node: number; readonly at_event?: string } | null;
-
-/**
- * Restore points plus parent pointers → the tree the view paints.
- *
- * Same-node exchanges stay a chain. A child node whose parent.at_event
- * matches a point hangs off that point as a sibling of the continuation,
- * which is how a rewind becomes a visible fork instead of a missing row.
- */
-export function treeFromPoints(
-  points: readonly TreePoint[],
-  parents: ReadonlyMap<number, NodeParent>,
-  currentNode: number,
-): TreeNode[] {
-  const byNode = new Map<number, TreePoint[]>();
-  for (const p of points) {
-    const list = byNode.get(p.node) ?? [];
-    list.push(p);
-    byNode.set(p.node, list);
-  }
-
-  const lastHere = [...points].reverse().find((p) => p.onPath && p.node === currentNode);
-  const lastOnPath = lastHere ?? [...points].reverse().find((p) => p.onPath);
-
-  function toNode(p: TreePoint, children: readonly TreeNode[]): TreeNode {
-    return {
-      ...p,
-      id: `${p.node}:${p.atEvent}`,
-      prompt: p.prompt,
-      onPath: p.onPath,
-      current: lastOnPath !== undefined && lastOnPath.node === p.node && lastOnPath.atEvent === p.atEvent,
-      kind: p.kind ?? "user",
-      children,
-    };
-  }
-
-  // Wire event chains and branch edges separately. Recursing once per event
-  // overflows the JS stack on otherwise valid long sessions.
-  type MutableNode = TreeNode & { children: TreeNode[] };
-  const chains = new Map<number, MutableNode[]>();
-  const events = new Map<string, MutableNode>();
-  for (const [id, pts] of byNode) {
-    const nodes = pts.map(p => toNode(p, []) as MutableNode);
-    for (let i = 0; i < nodes.length; i++) {
-      events.set(nodes[i]!.id, nodes[i]!);
-      if (nodes[i + 1]) nodes[i]!.children.push(nodes[i + 1]!);
-    }
-    chains.set(id, nodes);
-  }
-  const forest: TreeNode[] = [];
-  for (const [id, nodes] of [...chains].sort(([a], [b]) => a - b)) {
-    const first = nodes[0];
-    if (!first) continue;
-    let parent = parents.get(id);
-    const visited = new Set<number>([id]);
-    while (parent && !chains.get(parent.node)?.length && !visited.has(parent.node)) {
-      visited.add(parent.node); parent = parents.get(parent.node);
-    }
-    const anchor = parent && !visited.has(parent.node) ? events.get(`${parent.node}:${parent.at_event}`) ?? chains.get(parent.node)?.at(-1) : undefined;
-    if (anchor) anchor.children.push(first); else forest.push(first);
-  }
-  return forest;
-}
-
-
-export interface TreeRow { readonly node: TreeNode; readonly depth: number; readonly branch: string }
-
-/** Depth-first rows with connector prefixes; iterative so a 10k-event session cannot overflow the stack. */
-export function flattenTree(nodes: readonly TreeNode[], filter: TreeFilter = "all"): TreeRow[] {
-  const rows: TreeRow[] = [];
-  const stack = visibleTree(nodes, filter).map((node, i, all) => ({ node, prefix: "", root: true, last: i === all.length - 1 })).reverse();
-  while (stack.length) {
-    const { node, prefix, root, last } = stack.pop()!;
-    rows.push({ node, depth: prefix.length / 3, branch: root ? "" : prefix + (last ? "└─ " : "├─ ") });
-    const next = root ? "" : prefix + (last ? "   " : "│  ");
-    const children = node.children;
-    for (let i = children.length - 1; i >= 0; i--) stack.push({ node: children[i]!, prefix: next.length > 30 ? next.slice(-30) : next, root: false, last: i === children.length - 1 });
-  }
-  return rows;
-}
-
-/**
- * Filtering hides a node but keeps its descendants: they re-attach to the
- * nearest visible ancestor, so a "user only" view is still a tree.
- */
-export function visibleTree(nodes: readonly TreeNode[], filter: TreeFilter): TreeNode[] {
-  if (filter === "all") return [...nodes];
-  const out: TreeNode[] = [];
-  const stack = [...nodes].reverse().map(node => ({ node, into: out }));
-  while (stack.length) {
-    const { node: n, into } = stack.pop()!;
-    const include = filter === "user" || filter === "user-only" ? n.kind === "user" :
-      filter === "labeled-only" ? Boolean(n.label) : filter === "no-tools" ? n.category !== "tool" && n.category !== "metadata" : n.category !== "metadata";
-    const children: TreeNode[] = [];
-    if (include) into.push({ ...n, children });
-    for (let i = n.children.length - 1; i >= 0; i--) stack.push({ node: n.children[i]!, into: include ? children : into });
-  }
-  return out;
-}

package/src/core/settings.ts

@@ -1,192 +0,0 @@
-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;
-  /** Presentation only: no animation is allowed to advance a log or block input. */
-  readonly animations?: boolean;
-  readonly thinking?: string;
-  /** Look for a newer published xeno once a day and say so (docs/tasks/feat-update-check.md). Default on. */
-  readonly updateCheck?: boolean;
-  readonly hideThinkingBlock?: boolean;
-  readonly showCacheMissNotices?: boolean;
-  readonly defaultProvider?: string;
-  readonly defaultModel?: string;
-  readonly defaultThinking?: string;
-  readonly modelThinkingLevels?: Readonly<Record<string, ThinkingLevel>>;
-  readonly scopedModels?: readonly string[];
-  /** provider/model keys, most recent first; picker ordering and startup fallback for older settings. */
-  readonly recentModels?: readonly string[];
-  readonly steeringMode?: "all" | "one-at-a-time";
-  readonly followUpMode?: "all" | "one-at-a-time";
-  readonly tuiMode?: "auto" | "regular" | "fullscreen";
-  readonly fullscreenExitOutput?: "transcript" | "resume-hint";
-  readonly fullscreenScrollbar?: "auto" | "always" | "hidden";
-  readonly fullscreenCopyOnSelect?: 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 showImages?: boolean; readonly imageWidthCells?: number;
-    /** How pictures are drawn; `auto` names them instead when the terminal can only draw block characters. */
-    readonly imageProtocol?: "auto" | "kitty" | "sixel" | "blocks" };
-  readonly images?: { readonly autoResize?: boolean; readonly blockImages?: boolean };
-  readonly markdown?: { readonly mermaid?: "off" | "final" | "streaming" };
-}
-export const SETTINGS_KEYS = ["theme", "animations", "thinking", "updateCheck", "hideThinkingBlock", "showCacheMissNotices", "defaultProvider", "defaultModel", "defaultThinking",
-  "modelThinkingLevels", "scopedModels", "recentModels", "steeringMode", "followUpMode", "tuiMode", "fullscreenExitOutput", "fullscreenScrollbar",
-  "fullscreenCopyOnSelect", "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" }, animations: { kind: "boolean" }, thinking: levels, updateCheck: { kind: "boolean" },
-  hideThinkingBlock: { kind: "boolean" }, showCacheMissNotices: { kind: "boolean" },
-  defaultProvider: { kind: "string" }, defaultModel: { kind: "string" }, defaultThinking: levels,
-  scopedModels: { kind: "strings" }, recentModels: { kind: "strings" }, steeringMode: delivery, followUpMode: delivery,
-  tuiMode: { kind: "enum", values: ["auto", "regular", "fullscreen"] },
-  fullscreenExitOutput: { kind: "enum", values: ["transcript", "resume-hint"] },
-  fullscreenScrollbar: { kind: "enum", values: ["auto", "always", "hidden"] },
-  fullscreenCopyOnSelect: { 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.showImages": { kind: "boolean" }, "terminal.imageWidthCells": { kind: "integer", min: 1, max: 240 },
-  "terminal.imageProtocol": { kind: "enum", values: ["auto", "kitty", "sixel", "blocks"] },
-  "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: "animations", label: "Animations", fallback: "on" },
-  { 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: "updateCheck", label: "Check for updates", fallback: "on" },
-  { id: "terminal.showImages", label: "Show images", fallback: "on" },
-  { id: "terminal.imageProtocol", label: "Image protocol", fallback: "auto" },
-  { 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: "fullscreen" },
-  { id: "fullscreenExitOutput", label: "Fullscreen exit output", fallback: "resume-hint" },
-  { id: "fullscreenScrollbar", label: "Fullscreen scrollbar", fallback: "hidden" },
-  { id: "fullscreenCopyOnSelect", label: "Copy on select", fallback: "on" },
-  { id: "quietStartup", label: "Quiet startup", fallback: "off" },
-  { id: "doubleEscapeAction", label: "Double Escape", fallback: "tree" },
-  { id: "treeFilterMode", label: "Tree filter", fallback: "default" },
-] as const;
-/** Only fields with a real picker may be suggested without a value. Raw config keys remain writable explicitly. */
-export function interactiveSettingKeys(): string[] {
-  const pickers = ["theme", "thinking", "defaultModel", "modelThinkingLevels"];
-  return [...new Set([...pickers, ...SETTINGS_KEYS, ...DISPLAY_SETTINGS.map(item => item.id)])]
-    .filter(key => pickers.includes(key) || settingValues(key).length > 0);
-}
-
-export function defaultSettings(): Settings { return { theme: "dark", thinking: "high" }; }
-export function mergeSettings(layers: SettingsLayers): Settings {
-  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 ?? {})) } : {}),
-  };
-}
-export function settingsToWrite(explicit: Partial<Settings>): Record<string, unknown> {
-  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 (!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);
-  }
-  return { settings: out as Settings, diagnostics };
-}
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-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[] {
-  // `auto` is the unset default and stays valid in settings.json; cycling it in
-  // the menu would be a press that visibly does nothing on a terminal where
-  // auto already means fullscreen, so the menu toggles the two real screens.
-  if (key === "tuiMode") return ["regular", "fullscreen"];
-  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 });
-}