@oh-my-pi/pi-coding-agent 9.3.1 → 9.6.0

package/src/modes/components/settings-defs.ts

@@ -1,961 +1,256 @@
 /**
- * Declarative settings definitions.
+ * Declarative settings definitions for the UI.
  *
- * Each setting is defined once here and the UI is generated automatically.
- * To add a new setting:
- * 1. Add it to SettingsManager (getter/setter)
- * 2. Add the definition here
- * 3. Add the handler in interactive-mode.ts settingsHandlers
+ * This file derives UI definitions from the schema - no duplicate get/set wrappers.
+ * To add a new setting to the UI:
+ * 1. Add it to settings-schema.ts with a `ui` field
+ * 2. That's it - it appears in the UI automatically
  */
-import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { TERMINAL_INFO } from "@oh-my-pi/pi-tui";
-import type {
-	ImageProviderOption,
-	KimiApiFormatOption,
-	NotificationMethod,
-	PythonKernelMode,
-	PythonToolMode,
-	SettingsManager,
-	StatusLinePreset,
-	StatusLineSeparatorStyle,
-	SymbolPreset,
-	WebSearchProviderOption,
-} from "../../config/settings-manager";
-import { getPreset } from "./status-line/presets";
+import {
+	getDefault,
+	getEnumValues,
+	getPathsForTab,
+	getType,
+	getUi,
+	type SettingPath,
+	type SettingTab,
+} from "../../config/settings-schema";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// UI Definition Types
+// ═══════════════════════════════════════════════════════════════════════════
 
-// Setting value types
 export type SettingValue = boolean | string;
 
-// Base definition for all settings
 interface BaseSettingDef {
-	id: string;
+	path: SettingPath;
 	label: string;
 	description: string;
-	tab: string;
+	tab: SettingTab;
 }
 
-// Boolean toggle setting
 export interface BooleanSettingDef extends BaseSettingDef {
 	type: "boolean";
-	get: (sm: SettingsManager) => boolean;
-	set: (sm: SettingsManager, value: boolean) => void;
-	/** If provided, setting is only shown when this returns true */
 	condition?: () => boolean;
 }
 
-// Enum setting (inline toggle between values)
 export interface EnumSettingDef extends BaseSettingDef {
 	type: "enum";
 	values: readonly string[];
-	get: (sm: SettingsManager) => string;
-	set: (sm: SettingsManager, value: string) => void;
 }
 
-// Submenu setting (opens a selection list)
 export interface SubmenuSettingDef extends BaseSettingDef {
 	type: "submenu";
-	get: (sm: SettingsManager) => string;
-	set: (sm: SettingsManager, value: string) => void;
-	/** Get available options dynamically */
-	getOptions: (sm: SettingsManager) => Array<{ value: string; label: string; description?: string }>;
-	/** Called when selection changes (for preview) */
+	getOptions: () => Array<{ value: string; label: string; description?: string }>;
 	onPreview?: (value: string) => void;
-	/** Called when submenu is cancelled (to restore preview) */
 	onPreviewCancel?: (originalValue: string) => void;
 }
 
 export type SettingDef = BooleanSettingDef | EnumSettingDef | SubmenuSettingDef;
 
-const THINKING_DESCRIPTIONS: Record<ThinkingLevel, string> = {
+// ═══════════════════════════════════════════════════════════════════════════
+// Condition Functions
+// ═══════════════════════════════════════════════════════════════════════════
+
+const CONDITIONS: Record<string, () => boolean> = {
+	hasImageProtocol: () => !!TERMINAL_INFO.imageProtocol,
+};
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Submenu Option Providers
+// ═══════════════════════════════════════════════════════════════════════════
+
+type OptionProvider = () => Array<{ value: string; label: string; description?: string }>;
+
+const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
+	// Retry max retries
+	"retry.maxRetries": () => [
+		{ value: "1", label: "1 retry" },
+		{ value: "2", label: "2 retries" },
+		{ value: "3", label: "3 retries" },
+		{ value: "5", label: "5 retries" },
+		{ value: "10", label: "10 retries" },
+	],
+	// Todo max reminders
+	"todoCompletion.maxReminders": () => [
+		{ value: "1", label: "1 reminder" },
+		{ value: "2", label: "2 reminders" },
+		{ value: "3", label: "3 reminders" },
+		{ value: "5", label: "5 reminders" },
+	],
+	// Ask timeout
+	"ask.timeout": () => [
+		{ value: "0", label: "Disabled" },
+		{ value: "15", label: "15 seconds" },
+		{ value: "30", label: "30 seconds" },
+		{ value: "60", label: "60 seconds" },
+		{ value: "120", label: "120 seconds" },
+	],
+	// Edit fuzzy threshold
+	"edit.fuzzyThreshold": () => [
+		{ value: "0.85", label: "0.85", description: "Lenient" },
+		{ value: "0.90", label: "0.90", description: "Moderate" },
+		{ value: "0.95", label: "0.95", description: "Default" },
+		{ value: "0.98", label: "0.98", description: "Strict" },
+	],
+	// TTSR repeat gap
+	"ttsr.repeatGap": () => [
+		{ value: "5", label: "5 messages" },
+		{ value: "10", label: "10 messages" },
+		{ value: "15", label: "15 messages" },
+		{ value: "20", label: "20 messages" },
+		{ value: "30", label: "30 messages" },
+	],
+	// Provider options
+	"providers.webSearch": () => [
+		{ value: "auto", label: "Auto", description: "Priority: Exa > Perplexity > Anthropic" },
+		{ value: "exa", label: "Exa", description: "Requires EXA_API_KEY" },
+		{ value: "perplexity", label: "Perplexity", description: "Requires PERPLEXITY_API_KEY" },
+		{ value: "anthropic", label: "Anthropic", description: "Uses Anthropic web search" },
+	],
+	"providers.image": () => [
+		{ value: "auto", label: "Auto", description: "Priority: OpenRouter > Gemini" },
+		{ value: "gemini", label: "Gemini", description: "Requires GEMINI_API_KEY" },
+		{ value: "openrouter", label: "OpenRouter", description: "Requires OPENROUTER_API_KEY" },
+	],
+	"providers.kimiApiFormat": () => [
+		{ value: "openai", label: "OpenAI", description: "api.kimi.com" },
+		{ value: "anthropic", label: "Anthropic", description: "api.moonshot.ai" },
+	],
+	// Symbol preset
+	symbolPreset: () => [
+		{ value: "unicode", label: "Unicode", description: "Standard symbols (default)" },
+		{ value: "nerd", label: "Nerd Font", description: "Requires Nerd Font" },
+		{ value: "ascii", label: "ASCII", description: "Maximum compatibility" },
+	],
+	// Status line preset
+	"statusLine.preset": () => [
+		{ value: "default", label: "Default", description: "Model, path, git, context, tokens, cost" },
+		{ value: "minimal", label: "Minimal", description: "Path and git only" },
+		{ value: "compact", label: "Compact", description: "Model, git, cost, context" },
+		{ value: "full", label: "Full", description: "All segments including time" },
+		{ value: "nerd", label: "Nerd", description: "Maximum info with Nerd Font icons" },
+		{ value: "ascii", label: "ASCII", description: "No special characters" },
+		{ value: "custom", label: "Custom", description: "User-defined segments" },
+	],
+	// Status line separator
+	"statusLine.separator": () => [
+		{ value: "powerline", label: "Powerline", description: "Solid arrows (Nerd Font)" },
+		{ value: "powerline-thin", label: "Thin chevron", description: "Thin arrows (Nerd Font)" },
+		{ value: "slash", label: "Slash", description: "Forward slashes" },
+		{ value: "pipe", label: "Pipe", description: "Vertical pipes" },
+		{ value: "block", label: "Block", description: "Solid blocks" },
+		{ value: "none", label: "None", description: "Space only" },
+		{ value: "ascii", label: "ASCII", description: "Greater-than signs" },
+	],
+};
+
+const THINKING_DESCRIPTIONS: Record<string, string> = {
 	off: "No reasoning",
-	minimal: "Very brief reasoning (~1k tokens)",
-	low: "Light reasoning (~2k tokens)",
-	medium: "Moderate reasoning (~8k tokens)",
-	high: "Deep reasoning (~16k tokens)",
-	xhigh: "Maximum reasoning (~32k tokens)",
+	minimal: "Very brief (~1k tokens)",
+	low: "Light (~2k tokens)",
+	medium: "Moderate (~8k tokens)",
+	high: "Deep (~16k tokens)",
+	xhigh: "Maximum (~32k tokens)",
 };
 
-/**
- * All settings definitions.
- * Order determines display order within each tab.
- *
- * Tabs:
- * - behavior: Core agent behavior (compaction, modes, retries, notifications)
- * - tools: Tool-specific settings (bash, git, python, edit, MCP, skills)
- * - display: Visual/UI settings (theme, images, thinking)
- * - ttsr: Time Traveling Stream Rules settings
- * - status: Status line configuration
- * - lsp: LSP integration settings
- * - exa: Exa search tool settings
- */
-export const SETTINGS_DEFS: SettingDef[] = [
-	// ═══════════════════════════════════════════════════════════════════════════
-	// Behavior tab - Core agent behavior
-	// ═══════════════════════════════════════════════════════════════════════════
-	{
-		id: "autoCompact",
-		tab: "behavior",
-		type: "boolean",
-		label: "Auto-compact",
-		description: "Automatically compact context when it gets too large",
-		get: sm => sm.getCompactionEnabled(),
-		set: (sm, v) => sm.setCompactionEnabled(v),
-	},
-	{
-		id: "branchSummaries",
-		tab: "behavior",
-		type: "boolean",
-		label: "Branch summaries",
-		description: "Prompt to summarize when leaving a branch",
-		get: sm => sm.getBranchSummaryEnabled(),
-		set: (sm, v) => sm.setBranchSummaryEnabled(v),
-	},
-	{
-		id: "todoCompletion",
-		tab: "behavior",
-		type: "boolean",
-		label: "Todo completion",
-		description: "Remind agent to complete todos before stopping",
-		get: sm => sm.getTodoCompletionEnabled(),
-		set: (sm, v) => sm.setTodoCompletionEnabled(v),
-	},
-	{
-		id: "todoCompletionMaxReminders",
-		tab: "behavior",
-		type: "submenu",
-		label: "Todo max reminders",
-		description: "Maximum reminders to complete todos before giving up",
-		get: sm => String(sm.getTodoCompletionMaxReminders()),
-		set: (sm, v) => sm.setTodoCompletionMaxReminders(Number.parseInt(v, 10)),
-		getOptions: () => [
-			{ value: "1", label: "1 reminder" },
-			{ value: "2", label: "2 reminders" },
-			{ value: "3", label: "3 reminders" },
-			{ value: "5", label: "5 reminders" },
-		],
-	},
-	{
-		id: "steeringMode",
-		tab: "behavior",
-		type: "enum",
-		label: "Steering mode",
-		description: "How to process queued messages while agent is working",
-		values: ["one-at-a-time", "all"],
-		get: sm => sm.getSteeringMode(),
-		set: (sm, v) => sm.setSteeringMode(v as "all" | "one-at-a-time"),
-	},
-	{
-		id: "followUpMode",
-		tab: "behavior",
-		type: "enum",
-		label: "Follow-up mode",
-		description: "How to drain follow-up messages after a turn completes",
-		values: ["one-at-a-time", "all"],
-		get: sm => sm.getFollowUpMode(),
-		set: (sm, v) => sm.setFollowUpMode(v as "one-at-a-time" | "all"),
-	},
-	{
-		id: "interruptMode",
-		tab: "behavior",
-		type: "enum",
-		label: "Interrupt mode",
-		description: "When steering messages interrupt tool execution",
-		values: ["immediate", "wait"],
-		get: sm => sm.getInterruptMode(),
-		set: (sm, v) => sm.setInterruptMode(v as "immediate" | "wait"),
-	},
-	{
-		id: "retryMaxRetries",
-		tab: "behavior",
-		type: "submenu",
-		label: "Retry max attempts",
-		description: "Maximum retry attempts on API errors",
-		get: sm => String(sm.getRetryMaxRetries()),
-		set: (sm, v) => sm.setRetryMaxRetries(Number.parseInt(v, 10)),
-		getOptions: () => [
-			{ value: "1", label: "1 retry" },
-			{ value: "2", label: "2 retries" },
-			{ value: "3", label: "3 retries" },
-			{ value: "5", label: "5 retries" },
-			{ value: "10", label: "10 retries" },
-		],
-	},
-	{
-		id: "completionNotification",
-		tab: "behavior",
-		type: "enum",
-		label: "Completion notification",
-		description: "Notify when the agent completes",
-		values: ["auto", "bell", "osc99", "osc9", "off"],
-		get: sm => sm.getNotificationOnComplete(),
-		set: (sm, v) => sm.setNotificationOnComplete(v as NotificationMethod),
-	},
-	{
-		id: "askTimeout",
-		tab: "behavior",
-		type: "enum",
-		label: "Ask tool timeout",
-		description: "Auto-select recommended option after timeout (disabled in plan mode)",
-		values: ["off", "15", "30", "60", "120"],
-		get: sm => {
-			const timeout = sm.getAskTimeout();
-			return timeout === null ? "off" : String(timeout / 1000);
-		},
-		set: (sm, v) => sm.setAskTimeout(v === "off" ? null : Number.parseInt(v, 10)),
-	},
-	{
-		id: "askNotification",
-		tab: "behavior",
-		type: "enum",
-		label: "Ask notification",
-		description: "Notify when ask tool is waiting for input",
-		values: ["auto", "bell", "osc99", "osc9", "off"],
-		get: sm => sm.getAskNotification(),
-		set: (sm, v) => sm.setAskNotification(v as NotificationMethod),
-	},
-	{
-		id: "startupQuiet",
-		tab: "behavior",
-		type: "boolean",
-		label: "Startup quiet",
-		description: "Skip welcome screen and startup status messages",
-		get: sm => sm.getStartupQuiet(),
-		set: (sm, v) => sm.setStartupQuiet(v),
-	},
-	{
-		id: "collapseChangelog",
-		tab: "behavior",
-		type: "boolean",
-		label: "Collapse changelog",
-		description: "Show condensed changelog after updates",
-		get: sm => sm.getCollapseChangelog(),
-		set: (sm, v) => sm.setCollapseChangelog(v),
-	},
-	{
-		id: "normativeRewrite",
-		tab: "behavior",
-		type: "boolean",
-		label: "Normative rewrite",
-		description: "Rewrite tool call arguments to normalized format in session history",
-		get: sm => sm.getNormativeRewrite(),
-		set: (sm, v) => sm.setNormativeRewrite(v),
-	},
-	{
-		id: "doubleEscapeAction",
-		tab: "behavior",
-		type: "enum",
-		label: "Double-escape action",
-		description: "Action when pressing Escape twice with empty editor",
-		values: ["tree", "branch"],
-		get: sm => sm.getDoubleEscapeAction(),
-		set: (sm, v) => sm.setDoubleEscapeAction(v as "branch" | "tree"),
-	},
+// ═══════════════════════════════════════════════════════════════════════════
+// Schema to UI Conversion
+// ═══════════════════════════════════════════════════════════════════════════
 
-	// ═══════════════════════════════════════════════════════════════════════════
-	// Tools tab - Tool-specific settings
-	// ═══════════════════════════════════════════════════════════════════════════
-	{
-		id: "bashInterceptor",
-		tab: "tools",
-		type: "boolean",
-		label: "Bash interceptor",
-		description: "Block shell commands that have dedicated tools (grep, cat, etc.)",
-		get: sm => sm.getBashInterceptorEnabled(),
-		set: (sm, v) => sm.setBashInterceptorEnabled(v),
-	},
-	{
-		id: "shellForceBasic",
-		tab: "tools",
-		type: "boolean",
-		label: "Force basic shell",
-		description: "Use bash/sh even if your default shell is different",
-		get: sm => sm.getShellForceBasic(),
-		set: (sm, v) => sm.setShellForceBasic(v),
-	},
-	{
-		id: "bashInterceptorSimpleLs",
-		tab: "tools",
-		type: "boolean",
-		label: "Intercept simple ls",
-		description: "Intercept bare ls commands (when bash interceptor is enabled)",
-		get: sm => sm.getBashInterceptorSimpleLsEnabled(),
-		set: (sm, v) => sm.setBashInterceptorSimpleLsEnabled(v),
-	},
-	{
-		id: "pythonToolMode",
-		tab: "tools",
-		type: "enum",
-		label: "Python tool mode",
-		description: "How Python code is executed",
-		values: ["ipy-only", "bash-only", "both"],
-		get: sm => sm.getPythonToolMode(),
-		set: (sm, v) => sm.setPythonToolMode(v as PythonToolMode),
-	},
-	{
-		id: "pythonKernelMode",
-		tab: "tools",
-		type: "enum",
-		label: "Python kernel mode",
-		description: "Whether to keep IPython kernel alive across calls",
-		values: ["session", "per-call"],
-		get: sm => sm.getPythonKernelMode(),
-		set: (sm, v) => sm.setPythonKernelMode(v as PythonKernelMode),
-	},
-	{
-		id: "pythonSharedGateway",
-		tab: "tools",
-		type: "boolean",
-		label: "Python shared gateway",
-		description: "Share IPython kernel gateway across pi instances",
-		get: sm => sm.getPythonSharedGateway(),
-		set: (sm, v) => sm.setPythonSharedGateway(v),
-	},
-	{
-		id: "editFuzzyMatch",
-		tab: "tools",
-		type: "boolean",
-		label: "Edit fuzzy match",
-		description: "Accept high-confidence fuzzy matches for whitespace/indentation differences",
-		get: sm => sm.getEditFuzzyMatch(),
-		set: (sm, v) => sm.setEditFuzzyMatch(v),
-	},
-	{
-		id: "editFuzzyThreshold",
-		tab: "tools",
-		type: "submenu",
-		label: "Edit fuzzy threshold",
-		description: "Similarity threshold for fuzzy matches (higher = stricter)",
-		get: sm => sm.getEditFuzzyThreshold().toFixed(2),
-		set: (sm, v) => sm.setEditFuzzyThreshold(Number(v)),
-		getOptions: () => [
-			{ value: "0.85", label: "0.85", description: "Lenient" },
-			{ value: "0.90", label: "0.90", description: "Moderate" },
-			{ value: "0.95", label: "0.95", description: "Default" },
-			{ value: "0.98", label: "0.98", description: "Strict" },
-		],
-	},
-	{
-		id: "editPatchMode",
-		tab: "tools",
-		type: "boolean",
-		label: "Edit patch mode",
-		description: "Use codex-style apply-patch format instead of old_text/new_text for edits",
-		get: sm => sm.getEditPatchMode(),
-		set: (sm, v) => sm.setEditPatchMode(v),
-	},
-	{
-		id: "editStreamingAbort",
-		tab: "tools",
-		type: "boolean",
-		label: "Edit streaming abort",
-		description: "Abort streaming edit tool calls when patch preview fails",
-		get: sm => sm.getEditStreamingAbort(),
-		set: (sm, v) => sm.setEditStreamingAbort(v),
-	},
-	{
-		id: "readLineNumbers",
-		tab: "tools",
-		type: "boolean",
-		label: "Read line numbers",
-		description: "Prepend line numbers to read tool output by default",
-		get: sm => sm.getReadLineNumbers(),
-		set: (sm, v) => sm.setReadLineNumbers(v),
-	},
-	{
-		id: "mcpProjectConfig",
-		tab: "tools",
-		type: "boolean",
-		label: "MCP project config",
-		description: "Load .mcp.json/mcp.json from project root",
-		get: sm => sm.getMCPProjectConfigEnabled(),
-		set: (sm, v) => sm.setMCPProjectConfigEnabled(v),
-	},
-	{
-		id: "skillCommands",
-		tab: "tools",
-		type: "boolean",
-		label: "Skill commands",
-		description: "Register skills as /skill:name commands",
-		get: sm => sm.getEnableSkillCommands(),
-		set: (sm, v) => sm.setEnableSkillCommands(v),
-	},
-	{
-		id: "claudeUserCommands",
-		tab: "tools",
-		type: "boolean",
-		label: "Claude user commands",
-		description: "Load commands from ~/.claude/commands/",
-		get: sm => sm.getCommandsEnableClaudeUser(),
-		set: (sm, v) => sm.setCommandsEnableClaudeUser(v),
-	},
-	{
-		id: "claudeProjectCommands",
-		tab: "tools",
-		type: "boolean",
-		label: "Claude project commands",
-		description: "Load commands from .claude/commands/",
-		get: sm => sm.getCommandsEnableClaudeProject(),
-		set: (sm, v) => sm.setCommandsEnableClaudeProject(v),
-	},
-	{
-		id: "webSearchProvider",
-		tab: "tools",
-		type: "submenu",
-		label: "Web search provider",
-		description: "Provider for web search tool",
-		get: sm => sm.getWebSearchProvider(),
-		set: (sm, v) => sm.setWebSearchProvider(v as WebSearchProviderOption),
-		getOptions: () => [
-			{ value: "auto", label: "Auto", description: "Priority: Exa > Perplexity > Anthropic" },
-			{ value: "exa", label: "Exa", description: "Use Exa (requires EXA_API_KEY)" },
-			{ value: "perplexity", label: "Perplexity", description: "Use Perplexity (requires PERPLEXITY_API_KEY)" },
-			{ value: "anthropic", label: "Anthropic", description: "Use Anthropic web search" },
-		],
-	},
-	{
-		id: "imageProvider",
-		tab: "tools",
-		type: "submenu",
-		label: "Image provider",
-		description: "Provider for image generation tool",
-		get: sm => sm.getImageProvider(),
-		set: (sm, v) => sm.setImageProvider(v as ImageProviderOption),
-		getOptions: () => [
-			{ value: "auto", label: "Auto", description: "Priority: OpenRouter > Gemini" },
-			{ value: "gemini", label: "Gemini", description: "Use Gemini API directly (requires GEMINI_API_KEY)" },
-			{ value: "openrouter", label: "OpenRouter", description: "Use OpenRouter (requires OPENROUTER_API_KEY)" },
-		],
-	},
-	{
-		id: "kimiApiFormat",
-		tab: "tools",
-		type: "submenu",
-		label: "Kimi API format",
-		description: "API format for Kimi Code provider",
-		get: sm => sm.getKimiApiFormat(),
-		set: (sm, v) => sm.setKimiApiFormat(v as KimiApiFormatOption),
-		getOptions: () => [
-			{ value: "openai", label: "OpenAI", description: "Use OpenAI-compatible API (api.kimi.com)" },
-			{ value: "anthropic", label: "Anthropic", description: "Use Anthropic-compatible API (api.moonshot.ai)" },
-		],
-	},
+function pathToSettingDef(path: SettingPath): SettingDef | null {
+	const ui = getUi(path);
+	if (!ui) return null;
 
-	// ═══════════════════════════════════════════════════════════════════════════
-	// Display tab - Visual/UI settings
-	// ═══════════════════════════════════════════════════════════════════════════
-	{
-		id: "theme",
-		tab: "display",
-		type: "submenu",
-		label: "Theme",
-		description: "Color theme for the interface",
-		get: sm => sm.getTheme() ?? "dark",
-		set: (sm, v) => sm.setTheme(v),
-		getOptions: () => [], // Filled dynamically from context
-	},
-	{
-		id: "symbolPreset",
-		tab: "display",
-		type: "submenu",
-		label: "Symbol preset",
-		description: "Icon/symbol style (overrides theme default)",
-		get: sm => sm.getSymbolPreset() ?? "unicode",
-		set: (sm, v) => sm.setSymbolPreset(v as SymbolPreset),
-		getOptions: () => [
-			{ value: "unicode", label: "Unicode", description: "Standard Unicode symbols (default)" },
-			{ value: "nerd", label: "Nerd Font", description: "Nerd Font icons (requires Nerd Font)" },
-			{ value: "ascii", label: "ASCII", description: "ASCII-only characters (maximum compatibility)" },
-		],
-	},
-	{
-		id: "colorBlindMode",
-		tab: "display",
-		type: "boolean",
-		label: "Color blind mode",
-		description: "Use blue instead of green for diff additions (red-green color blindness)",
-		get: sm => sm.getColorBlindMode(),
-		set: (sm, v) => sm.setColorBlindMode(v),
-	},
-	{
-		id: "thinkingLevel",
-		tab: "display",
-		type: "submenu",
-		label: "Thinking level",
-		description: "Reasoning depth for thinking-capable models",
-		get: sm => sm.getDefaultThinkingLevel() ?? "off",
-		set: (sm, v) => sm.setDefaultThinkingLevel(v as ThinkingLevel),
-		getOptions: () =>
-			(["off", "minimal", "low", "medium", "high", "xhigh"] as ThinkingLevel[]).map(level => ({
-				value: level,
-				label: level,
-				description: THINKING_DESCRIPTIONS[level],
-			})),
-	},
-	{
-		id: "hideThinking",
-		tab: "display",
-		type: "boolean",
-		label: "Hide thinking",
-		description: "Hide thinking blocks in assistant responses",
-		get: sm => sm.getHideThinkingBlock(),
-		set: (sm, v) => sm.setHideThinkingBlock(v),
-	},
-	{
-		id: "showImages",
-		tab: "display",
-		type: "boolean",
-		label: "Show images",
-		description: "Render images inline in terminal",
-		get: sm => sm.getShowImages(),
-		set: (sm, v) => sm.setShowImages(v),
-		condition: () => !!TERMINAL_INFO.imageProtocol,
-	},
-	{
-		id: "autoResizeImages",
-		tab: "display",
-		type: "boolean",
-		label: "Auto-resize images",
-		description: "Resize large images to 2000x2000 max for better model compatibility",
-		get: sm => sm.getImageAutoResize(),
-		set: (sm, v) => sm.setImageAutoResize(v),
-	},
-	{
-		id: "blockImages",
-		tab: "display",
-		type: "boolean",
-		label: "Block images",
-		description: "Prevent images from being sent to LLM providers",
-		get: sm => sm.getBlockImages(),
-		set: (sm, v) => sm.setBlockImages(v),
-	},
-	{
-		id: "showHardwareCursor",
-		tab: "display",
-		type: "boolean",
-		label: "Hardware cursor",
-		description: "Show terminal cursor for IME support (default: on for Linux/macOS)",
-		get: sm => sm.getShowHardwareCursor(),
-		set: (sm, v) => sm.setShowHardwareCursor(v),
-	},
+	const schemaType = getType(path);
+	const base = { path, label: ui.label, description: ui.description, tab: ui.tab };
 
-	// ═══════════════════════════════════════════════════════════════════════════
-	// TTSR tab - Time Traveling Stream Rules
-	// ═══════════════════════════════════════════════════════════════════════════
-	{
-		id: "ttsrEnabled",
-		tab: "ttsr",
-		type: "boolean",
-		label: "TTSR enabled",
-		description: "Time Traveling Stream Rules: interrupt agent when output matches patterns",
-		get: sm => sm.getTtsrEnabled(),
-		set: (sm, v) => sm.setTtsrEnabled(v),
-	},
-	{
-		id: "ttsrContextMode",
-		tab: "ttsr",
-		type: "enum",
-		label: "TTSR context mode",
-		description: "What to do with partial output when TTSR triggers",
-		values: ["discard", "keep"],
-		get: sm => sm.getTtsrContextMode(),
-		set: (sm, v) => sm.setTtsrContextMode(v as "keep" | "discard"),
-	},
-	{
-		id: "ttsrRepeatMode",
-		tab: "ttsr",
-		type: "enum",
-		label: "TTSR repeat mode",
-		description: "How rules can repeat: once per session or after a message gap",
-		values: ["once", "after-gap"],
-		get: sm => sm.getTtsrRepeatMode(),
-		set: (sm, v) => sm.setTtsrRepeatMode(v as "once" | "after-gap"),
-	},
-	{
-		id: "ttsrRepeatGap",
-		tab: "ttsr",
-		type: "submenu",
-		label: "TTSR repeat gap",
-		description: "Messages before a rule can trigger again (when repeat mode is after-gap)",
-		get: sm => String(sm.getTtsrRepeatGap()),
-		set: (sm, v) => sm.setTtsrRepeatGap(Number.parseInt(v, 10)),
-		getOptions: () => [
-			{ value: "5", label: "5 messages" },
-			{ value: "10", label: "10 messages" },
-			{ value: "15", label: "15 messages" },
-			{ value: "20", label: "20 messages" },
-			{ value: "30", label: "30 messages" },
-		],
-	},
+	// Check for condition
+	const condition = ui.condition ? CONDITIONS[ui.condition] : undefined;
 
-	// ═══════════════════════════════════════════════════════════════════════════
-	// Status tab - Status line configuration
-	// ═══════════════════════════════════════════════════════════════════════════
-	{
-		id: "statusLinePreset",
-		tab: "status",
-		type: "submenu",
-		label: "Preset",
-		description: "Pre-built status line configurations",
-		get: sm => sm.getStatusLinePreset(),
-		set: (sm, v) => sm.setStatusLinePreset(v as StatusLinePreset),
-		getOptions: () => [
-			{ value: "default", label: "Default", description: "Model, path, git, context, tokens, cost" },
-			{ value: "minimal", label: "Minimal", description: "Path and git only" },
-			{ value: "compact", label: "Compact", description: "Model, git, cost, context" },
-			{ value: "full", label: "Full", description: "All segments including time" },
-			{ value: "nerd", label: "Nerd", description: "Maximum info with Nerd Font icons" },
-			{ value: "ascii", label: "ASCII", description: "No special characters" },
-			{ value: "custom", label: "Custom", description: "User-defined segments" },
-		],
-	},
-	{
-		id: "statusLineSeparator",
-		tab: "status",
-		type: "submenu",
-		label: "Separator style",
-		description: "Style of separators between segments",
-		get: sm => {
-			const settings = sm.getStatusLineSettings();
-			if (settings.separator) return settings.separator;
-			return getPreset(sm.getStatusLinePreset()).separator;
-		},
-		set: (sm, v) => sm.setStatusLineSeparator(v as StatusLineSeparatorStyle),
-		getOptions: () => [
-			{ value: "powerline", label: "Powerline", description: "Solid arrows (requires Nerd Font)" },
-			{ value: "powerline-thin", label: "Thin chevron", description: "Thin arrows (requires Nerd Font)" },
-			{ value: "slash", label: "Slash", description: "Forward slashes" },
-			{ value: "pipe", label: "Pipe", description: "Vertical pipes" },
-			{ value: "block", label: "Block", description: "Solid blocks" },
-			{ value: "none", label: "None", description: "Space only" },
-			{ value: "ascii", label: "ASCII", description: "Greater-than signs" },
-		],
-	},
-	{
-		id: "statusLineShowHooks",
-		tab: "status",
-		type: "boolean",
-		label: "Show extension status",
-		description: "Display hook status messages below status line",
-		get: sm => sm.getStatusLineShowHookStatus(),
-		set: (sm, v) => sm.setStatusLineShowHookStatus(v),
-	},
-	{
-		id: "statusLineSegments",
-		tab: "status",
-		type: "submenu",
-		label: "Configure segments",
-		description: "Choose and arrange status line segments",
-		get: () => "configure...",
-		set: () => {},
-		getOptions: () => [{ value: "open", label: "Open segment editor..." }],
-	},
-	{
-		id: "statusLineModelThinking",
-		tab: "status",
-		type: "enum",
-		label: "Model thinking level",
-		description: "Show thinking level in the model segment",
-		values: ["default", "on", "off"],
-		get: sm => {
-			const value = sm.getStatusLineSegmentOptions().model?.showThinkingLevel;
-			if (value === undefined) return "default";
-			return value ? "on" : "off";
-		},
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("model", "showThinkingLevel");
-			} else {
-				sm.setStatusLineSegmentOption("model", "showThinkingLevel", v === "on");
-			}
-		},
-	},
-	{
-		id: "statusLinePathAbbreviate",
-		tab: "status",
-		type: "enum",
-		label: "Path abbreviate",
-		description: "Use ~ and strip home prefix in path segment",
-		values: ["default", "on", "off"],
-		get: sm => {
-			const value = sm.getStatusLineSegmentOptions().path?.abbreviate;
-			if (value === undefined) return "default";
-			return value ? "on" : "off";
-		},
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("path", "abbreviate");
-			} else {
-				sm.setStatusLineSegmentOption("path", "abbreviate", v === "on");
-			}
-		},
-	},
-	{
-		id: "statusLinePathMaxLength",
-		tab: "status",
-		type: "submenu",
-		label: "Path max length",
-		description: "Maximum length for displayed path",
-		get: sm => {
-			const value = sm.getStatusLineSegmentOptions().path?.maxLength;
-			return typeof value === "number" ? String(value) : "default";
-		},
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("path", "maxLength");
-			} else {
-				sm.setStatusLineSegmentOption("path", "maxLength", Number.parseInt(v, 10));
-			}
-		},
-		getOptions: () => [
-			{ value: "default", label: "Preset default" },
-			{ value: "20", label: "20" },
-			{ value: "30", label: "30" },
-			{ value: "40", label: "40" },
-			{ value: "50", label: "50" },
-			{ value: "60", label: "60" },
-			{ value: "80", label: "80" },
-		],
-	},
-	{
-		id: "statusLinePathStripWorkPrefix",
-		tab: "status",
-		type: "enum",
-		label: "Path strip /work",
-		description: "Strip /work prefix in path segment",
-		values: ["default", "on", "off"],
-		get: sm => {
-			const value = sm.getStatusLineSegmentOptions().path?.stripWorkPrefix;
-			if (value === undefined) return "default";
-			return value ? "on" : "off";
-		},
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("path", "stripWorkPrefix");
-			} else {
-				sm.setStatusLineSegmentOption("path", "stripWorkPrefix", v === "on");
-			}
-		},
-	},
-	{
-		id: "statusLineGitShowBranch",
-		tab: "status",
-		type: "enum",
-		label: "Git show branch",
-		description: "Show branch name in git segment",
-		values: ["default", "on", "off"],
-		get: sm => {
-			const value = sm.getStatusLineSegmentOptions().git?.showBranch;
-			if (value === undefined) return "default";
-			return value ? "on" : "off";
-		},
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("git", "showBranch");
-			} else {
-				sm.setStatusLineSegmentOption("git", "showBranch", v === "on");
-			}
-		},
-	},
-	{
-		id: "statusLineGitShowStaged",
-		tab: "status",
-		type: "enum",
-		label: "Git show staged",
-		description: "Show staged file count in git segment",
-		values: ["default", "on", "off"],
-		get: sm => {
-			const value = sm.getStatusLineSegmentOptions().git?.showStaged;
-			if (value === undefined) return "default";
-			return value ? "on" : "off";
-		},
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("git", "showStaged");
-			} else {
-				sm.setStatusLineSegmentOption("git", "showStaged", v === "on");
-			}
-		},
-	},
-	{
-		id: "statusLineGitShowUnstaged",
-		tab: "status",
-		type: "enum",
-		label: "Git show unstaged",
-		description: "Show unstaged file count in git segment",
-		values: ["default", "on", "off"],
-		get: sm => {
-			const value = sm.getStatusLineSegmentOptions().git?.showUnstaged;
-			if (value === undefined) return "default";
-			return value ? "on" : "off";
-		},
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("git", "showUnstaged");
-			} else {
-				sm.setStatusLineSegmentOption("git", "showUnstaged", v === "on");
-			}
-		},
-	},
-	{
-		id: "statusLineGitShowUntracked",
-		tab: "status",
-		type: "enum",
-		label: "Git show untracked",
-		description: "Show untracked file count in git segment",
-		values: ["default", "on", "off"],
-		get: sm => {
-			const value = sm.getStatusLineSegmentOptions().git?.showUntracked;
-			if (value === undefined) return "default";
-			return value ? "on" : "off";
-		},
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("git", "showUntracked");
-			} else {
-				sm.setStatusLineSegmentOption("git", "showUntracked", v === "on");
-			}
-		},
-	},
-	{
-		id: "statusLineTimeFormat",
-		tab: "status",
-		type: "enum",
-		label: "Time format",
-		description: "Clock segment time format",
-		values: ["default", "12h", "24h"],
-		get: sm => sm.getStatusLineSegmentOptions().time?.format ?? "default",
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("time", "format");
-			} else {
-				sm.setStatusLineSegmentOption("time", "format", v);
-			}
-		},
-	},
-	{
-		id: "statusLineTimeShowSeconds",
-		tab: "status",
-		type: "enum",
-		label: "Time show seconds",
-		description: "Include seconds in clock segment",
-		values: ["default", "on", "off"],
-		get: sm => {
-			const value = sm.getStatusLineSegmentOptions().time?.showSeconds;
-			if (value === undefined) return "default";
-			return value ? "on" : "off";
-		},
-		set: (sm, v) => {
-			if (v === "default") {
-				sm.clearStatusLineSegmentOption("time", "showSeconds");
-			} else {
-				sm.setStatusLineSegmentOption("time", "showSeconds", v === "on");
-			}
-		},
-	},
+	if (schemaType === "boolean") {
+		return { ...base, type: "boolean", condition };
+	}
 
-	// ═══════════════════════════════════════════════════════════════════════════
-	// LSP tab - LSP integration settings
-	// ═══════════════════════════════════════════════════════════════════════════
-	{
-		id: "lspFormatOnWrite",
-		tab: "lsp",
-		type: "boolean",
-		label: "Format on write",
-		description: "Automatically format code files using LSP after writing",
-		get: sm => sm.getLspFormatOnWrite(),
-		set: (sm, v) => sm.setLspFormatOnWrite(v),
-	},
-	{
-		id: "lspDiagnosticsOnWrite",
-		tab: "lsp",
-		type: "boolean",
-		label: "Diagnostics on write",
-		description: "Return LSP diagnostics (errors/warnings) after writing code files",
-		get: sm => sm.getLspDiagnosticsOnWrite(),
-		set: (sm, v) => sm.setLspDiagnosticsOnWrite(v),
-	},
-	{
-		id: "lspDiagnosticsOnEdit",
-		tab: "lsp",
-		type: "boolean",
-		label: "Diagnostics on edit",
-		description: "Return LSP diagnostics (errors/warnings) after editing code files",
-		get: sm => sm.getLspDiagnosticsOnEdit(),
-		set: (sm, v) => sm.setLspDiagnosticsOnEdit(v),
-	},
+	if (schemaType === "enum") {
+		const values = getEnumValues(path) ?? [];
 
-	// ═══════════════════════════════════════════════════════════════════════════
-	// Exa tab - Exa search tool settings
-	// ═══════════════════════════════════════════════════════════════════════════
-	{
-		id: "exaEnabled",
-		tab: "exa",
-		type: "boolean",
-		label: "Exa enabled",
-		description: "Master toggle for all Exa search tools",
-		get: sm => sm.getExaSettings().enabled,
-		set: (sm, v) => sm.setExaEnabled(v),
-	},
-	{
-		id: "exaSearch",
-		tab: "exa",
-		type: "boolean",
-		label: "Exa search",
-		description: "Basic search, deep search, code search, crawl",
-		get: sm => sm.getExaSettings().enableSearch,
-		set: (sm, v) => sm.setExaSearchEnabled(v),
-	},
-	{
-		id: "exaLinkedin",
-		tab: "exa",
-		type: "boolean",
-		label: "Exa LinkedIn",
-		description: "Search LinkedIn for people and companies",
-		get: sm => sm.getExaSettings().enableLinkedin,
-		set: (sm, v) => sm.setExaLinkedinEnabled(v),
-	},
-	{
-		id: "exaCompany",
-		tab: "exa",
-		type: "boolean",
-		label: "Exa company",
-		description: "Comprehensive company research tool",
-		get: sm => sm.getExaSettings().enableCompany,
-		set: (sm, v) => sm.setExaCompanyEnabled(v),
-	},
-	{
-		id: "exaResearcher",
-		tab: "exa",
-		type: "boolean",
-		label: "Exa researcher",
-		description: "AI-powered deep research tasks",
-		get: sm => sm.getExaSettings().enableResearcher,
-		set: (sm, v) => sm.setExaResearcherEnabled(v),
-	},
-	{
-		id: "exaWebsets",
-		tab: "exa",
-		type: "boolean",
-		label: "Exa websets",
-		description: "Webset management and enrichment tools",
-		get: sm => sm.getExaSettings().enableWebsets,
-		set: (sm, v) => sm.setExaWebsetsEnabled(v),
-	},
-];
+		// If marked as submenu, use submenu type
+		if (ui.submenu) {
+			const provider = OPTION_PROVIDERS[path];
+			return {
+				...base,
+				type: "submenu",
+				getOptions:
+					provider ??
+					(() =>
+						values.map(v => ({
+							value: v,
+							label: v,
+							description: path === "defaultThinkingLevel" ? THINKING_DESCRIPTIONS[v] : undefined,
+						}))),
+			};
+		}
 
-/**
- * All settings. Discovery settings have been moved to /extensions dashboard.
- */
-function getAllSettings(): SettingDef[] {
-	return SETTINGS_DEFS;
+		return { ...base, type: "enum", values };
+	}
+
+	if (schemaType === "number" && ui.submenu) {
+		const provider = OPTION_PROVIDERS[path];
+		if (provider) {
+			return { ...base, type: "submenu", getOptions: provider };
+		}
+	}
+
+	if (schemaType === "string" && ui.submenu) {
+		const provider = OPTION_PROVIDERS[path];
+		if (provider) {
+			return { ...base, type: "submenu", getOptions: provider };
+		}
+		// For theme etc, options will be injected at runtime
+		return { ...base, type: "submenu", getOptions: () => [] };
+	}
+
+	return null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Public API
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Cache of generated definitions */
+let cachedDefs: SettingDef[] | null = null;
+
+/** Get all setting definitions with UI */
+export function getAllSettingDefs(): SettingDef[] {
+	if (cachedDefs) return cachedDefs;
+
+	const defs: SettingDef[] = [];
+	for (const tab of ["behavior", "tools", "bash", "display", "ttsr", "status", "lsp", "exa"] as SettingTab[]) {
+		for (const path of getPathsForTab(tab)) {
+			const def = pathToSettingDef(path);
+			if (def) defs.push(def);
+		}
+	}
+	cachedDefs = defs;
+	return defs;
 }
 
 /** Get settings for a specific tab */
-export function getSettingsForTab(tab: string): SettingDef[] {
-	return getAllSettings().filter(def => def.tab === tab);
+export function getSettingsForTab(tab: SettingTab): SettingDef[] {
+	return getAllSettingDefs().filter(def => def.tab === tab);
+}
+
+/** Get a setting definition by path */
+export function getSettingDef(path: SettingPath): SettingDef | undefined {
+	return getAllSettingDefs().find(def => def.path === path);
 }
 
-/** Get a setting definition by id */
-export function getSettingDef(id: string): SettingDef | undefined {
-	return getAllSettings().find(def => def.id === id);
+/** Get default value for display */
+export function getDisplayDefault(path: SettingPath): string {
+	const value = getDefault(path);
+	if (value === undefined) return "";
+	if (typeof value === "boolean") return value ? "true" : "false";
+	return String(value);
 }