@prometheus-ai/agent 0.5.0

package/dist/types/config/settings-schema.d.ts

@@ -0,0 +1,4352 @@
+/** Unified settings schema - single source of truth for all settings.
+ * Unified settings schema - single source of truth for all settings.
+ *
+ * Each setting is defined once here with:
+ * - Type and default value
+ * - Optional UI metadata (label, description, tab)
+ *
+ * The Settings singleton provides type-safe path-based access:
+ *   settings.get("compaction.enabled")  // => boolean
+ *   settings.set("theme.dark", "titanium")  // sync, saves in background
+ */
+export type SettingTab = "appearance" | "model" | "interaction" | "context" | "memory" | "editing" | "tools" | "tasks" | "providers" | "channels";
+/** Tab display metadata - icon is resolved via theme.symbol() */
+export type TabMetadata = {
+    label: string;
+    icon: `tab.${string}`;
+};
+/** Ordered list of tabs for UI rendering */
+export declare const SETTING_TABS: SettingTab[];
+/** Tab display metadata - icon is a symbol key from theme.ts (tab.*) */
+export declare const TAB_METADATA: Record<SettingTab, {
+    label: string;
+    icon: `tab.${string}`;
+}>;
+/** Status line segment identifiers */
+export type StatusLineSegmentId = "prometheus" | "model" | "mode" | "path" | "git" | "pr" | "subagents" | "token_in" | "token_out" | "token_total" | "token_rate" | "cost" | "context_pct" | "context_total" | "time_spent" | "time" | "session" | "hostname" | "cache_read" | "cache_write" | "cache_hit" | "session_name" | "usage";
+/** Submenu choice metadata. */
+export type SubmenuOption<V extends string = string> = {
+    value: V;
+    label: string;
+    description?: string;
+};
+interface UiBase {
+    tab: SettingTab;
+    label: string;
+    description: string;
+    /** Condition function name - setting only shown when true */
+    condition?: string;
+}
+interface UiBoolean extends UiBase {
+}
+interface UiEnum<T extends readonly string[]> extends UiBase {
+    /** Submenu options. When omitted, the enum renders as an inline toggle derived from `values`. */
+    options?: ReadonlyArray<SubmenuOption<T[number]>>;
+}
+interface UiNumber extends UiBase {
+    /** Submenu options. Without options, a numeric setting has no UI representation (intentional hide). */
+    options?: ReadonlyArray<SubmenuOption>;
+}
+interface UiString extends UiBase {
+    /**
+     * Submenu options.
+     *  - Array  → submenu with these choices.
+     *  - "runtime" → submenu populated by the runtime layer (theme registry, etc.).
+     *  - Omitted → renders as a free text input.
+     */
+    options?: ReadonlyArray<SubmenuOption> | "runtime";
+}
+/** Wide ui shape exposed to consumers that walk the schema generically. */
+export type AnyUiMetadata = UiBase & {
+    options?: ReadonlyArray<SubmenuOption> | "runtime";
+};
+interface BooleanDef {
+    type: "boolean";
+    default: boolean;
+    ui?: UiBoolean;
+}
+interface StringDef {
+    type: "string";
+    default: string | undefined;
+    ui?: UiString;
+}
+interface NumberDef {
+    type: "number";
+    default: number;
+    ui?: UiNumber;
+}
+interface EnumDef<T extends readonly string[]> {
+    type: "enum";
+    values: T;
+    default: T[number];
+    ui?: UiEnum<T>;
+}
+interface ArrayDef<T> {
+    type: "array";
+    default: T[];
+    ui?: UiBase;
+}
+interface RecordDef<T> {
+    type: "record";
+    default: Record<string, T>;
+    ui?: UiBase;
+}
+type SettingDef = BooleanDef | StringDef | NumberDef | EnumDef<readonly string[]> | ArrayDef<unknown> | RecordDef<unknown>;
+export interface ModelTagDef {
+    name: string;
+    color?: string;
+}
+export interface ModelTagsSettings {
+    [key: string]: ModelTagDef;
+}
+export declare const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[];
+export declare const SETTINGS_SCHEMA: {
+    readonly lastChangelogVersion: {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly setupVersion: {
+        readonly type: "number";
+        readonly default: 0;
+    };
+    readonly "auth.broker.url": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "auth.broker.token": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "gateway.telegram.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Gateway";
+            readonly description: "Use the configured Telegram Bot API gateway when serving Prometheus externally";
+        };
+    };
+    readonly "gateway.telegram.mode": {
+        readonly type: "enum";
+        readonly values: readonly ["webhook", "polling"];
+        readonly default: "webhook";
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Connection Mode";
+            readonly description: "Use webhook ingress or Bot API long polling for Telegram updates";
+            readonly options: readonly [{
+                readonly value: "webhook";
+                readonly label: "Webhook";
+                readonly description: "Public HTTPS ingress for production/tunnels";
+            }, {
+                readonly value: "polling";
+                readonly label: "Polling";
+                readonly description: "Outbound getUpdates loop for local or always-on hosts";
+            }];
+        };
+    };
+    readonly "gateway.telegram.botUsername": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Bot Username";
+            readonly description: "Telegram bot username without @; setup can fill this from getMe";
+        };
+    };
+    readonly "gateway.telegram.publicBaseUrl": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Public URL";
+            readonly description: "HTTPS public base URL that Telegram should call through the tunnel";
+        };
+    };
+    readonly "gateway.telegram.webhookPath": {
+        readonly type: "string";
+        readonly default: "/telegram/webhook";
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Webhook Path";
+            readonly description: "HTTP path that receives Telegram webhook updates";
+        };
+    };
+    readonly "gateway.telegram.allowedUsers": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Allowed Users";
+            readonly description: "Comma-separated Telegram user IDs allowed to use the gateway";
+        };
+    };
+    readonly "gateway.telegram.groupScope": {
+        readonly type: "enum";
+        readonly values: readonly ["shared", "per-user"];
+        readonly default: "shared";
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Group Scope";
+            readonly description: "Session sharing for non-threaded group chats";
+            readonly options: readonly [{
+                readonly value: "shared";
+                readonly label: "Shared";
+                readonly description: "One session per group chat";
+            }, {
+                readonly value: "per-user";
+                readonly label: "Per User";
+                readonly description: "Separate group sessions by Telegram user";
+            }];
+        };
+    };
+    readonly "gateway.telegram.threadScope": {
+        readonly type: "enum";
+        readonly values: readonly ["shared", "per-user"];
+        readonly default: "shared";
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Thread Scope";
+            readonly description: "Session sharing for Telegram topics and direct-message topics";
+            readonly options: readonly [{
+                readonly value: "shared";
+                readonly label: "Shared";
+                readonly description: "One session per thread/topic";
+            }, {
+                readonly value: "per-user";
+                readonly label: "Per User";
+                readonly description: "Separate topic sessions by Telegram user";
+            }];
+        };
+    };
+    readonly "gateway.telegram.parseMode": {
+        readonly type: "enum";
+        readonly values: readonly ["none", "HTML", "Markdown", "MarkdownV2"];
+        readonly default: "none";
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Parse Mode";
+            readonly description: "Telegram parse_mode for bot replies";
+            readonly options: readonly [{
+                readonly value: "none";
+                readonly label: "None";
+                readonly description: "Send plain text";
+            }, {
+                readonly value: "HTML";
+                readonly label: "HTML";
+                readonly description: "Use Telegram HTML parsing";
+            }, {
+                readonly value: "Markdown";
+                readonly label: "Markdown";
+                readonly description: "Use Telegram Markdown parsing";
+            }, {
+                readonly value: "MarkdownV2";
+                readonly label: "MarkdownV2";
+                readonly description: "Use Telegram MarkdownV2 parsing";
+            }];
+        };
+    };
+    readonly "gateway.telegram.disableNotification": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Silent Replies";
+            readonly description: "Send Telegram replies without notification sound";
+        };
+    };
+    readonly "gateway.telegram.preferLargeMedia": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram HD Previews";
+            readonly description: "Ask Telegram to use larger media previews where the Bot API supports it";
+        };
+    };
+    readonly "gateway.telegram.allowBotMessages": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Bot Messages";
+            readonly description: "Allow Telegram messages sent by bot accounts";
+        };
+    };
+    readonly "gateway.telegram.includeRaw": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Raw Payloads";
+            readonly description: "Attach raw Telegram update payloads to gateway events for debugging";
+        };
+    };
+    readonly "gateway.telegram.expressions.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Expressions";
+            readonly description: "Allow Prometheus to attach matching Telegram expression intents to replies";
+        };
+    };
+    readonly "gateway.telegram.expressions.minScore": {
+        readonly type: "number";
+        readonly default: 2;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Expression Match";
+            readonly description: "Minimum local catalog match score before attaching a Telegram expression";
+            readonly options: readonly [{
+                readonly value: "1";
+                readonly label: "Loose";
+                readonly description: "Send expressions for broad matches";
+            }, {
+                readonly value: "2";
+                readonly label: "Balanced";
+                readonly description: "Send expressions for clear matches";
+            }, {
+                readonly value: "4";
+                readonly label: "Strict";
+                readonly description: "Send expressions only for strong matches";
+            }];
+        };
+    };
+    readonly "gateway.telegram.expressions.catalog": {
+        readonly type: "record";
+        readonly default: Record<string, unknown>;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Expression Catalog";
+            readonly description: "Searchable Telegram expression intents with sticker/GIF variants";
+        };
+    };
+    readonly "gateway.telegram.expressionCatalogPath": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "channels";
+            readonly label: "Telegram Expression File";
+            readonly description: "Optional JSON catalog path for Telegram expression intents";
+        };
+    };
+    readonly autoResume: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Auto Resume";
+            readonly description: "Automatically resume the most recent session in the current directory";
+        };
+    };
+    readonly "power.preventIdleSleep": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Prevent Idle Sleep (macOS)";
+            readonly description: "caffeinate -i: keep the system awake while a session is open";
+        };
+    };
+    readonly "power.preventSystemSleep": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Prevent System Sleep on AC (macOS)";
+            readonly description: "caffeinate -s: block all system sleep while on AC power";
+        };
+    };
+    readonly "power.declareUserActive": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Declare User Active (macOS)";
+            readonly description: "caffeinate -u: keep the display lit and treat the user as active";
+        };
+    };
+    readonly "power.preventDisplaySleep": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Prevent Display Sleep (macOS)";
+            readonly description: "caffeinate -d: keep the display from idle-sleeping while a session is open";
+        };
+    };
+    readonly shellPath: {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly extensions: {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly "marketplace.autoUpdate": {
+        readonly type: "enum";
+        readonly values: readonly ["off", "notify", "auto"];
+        readonly default: "notify";
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Marketplace Auto-Update";
+            readonly description: "Check for plugin updates on startup (off/notify/auto)";
+            readonly options: readonly [{
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Don't check for plugin updates";
+            }, {
+                readonly value: "notify";
+                readonly label: "Notify";
+                readonly description: "Check on startup and notify when updates are available";
+            }, {
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Check on startup and auto-install updates";
+            }];
+        };
+    };
+    readonly enabledModels: {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly disabledProviders: {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly disabledExtensions: {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly modelRoles: {
+        readonly type: "record";
+        readonly default: Record<string, string>;
+    };
+    readonly modelTags: {
+        readonly type: "record";
+        readonly default: ModelTagsSettings;
+    };
+    readonly modelProviderOrder: {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly cycleOrder: {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly "theme.dark": {
+        readonly type: "string";
+        readonly default: "titanium";
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Dark Theme";
+            readonly description: "Theme used when terminal has dark background";
+            readonly options: "runtime";
+        };
+    };
+    readonly "theme.light": {
+        readonly type: "string";
+        readonly default: "light";
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Light Theme";
+            readonly description: "Theme used when terminal has light background";
+            readonly options: "runtime";
+        };
+    };
+    readonly symbolPreset: {
+        readonly type: "enum";
+        readonly values: readonly ["unicode", "nerd", "ascii"];
+        readonly default: "unicode";
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Symbol Preset";
+            readonly description: "Icon/symbol style";
+            readonly options: readonly [{
+                readonly value: "unicode";
+                readonly label: "Unicode";
+                readonly description: "Standard symbols (default)";
+            }, {
+                readonly value: "nerd";
+                readonly label: "Nerd Font";
+                readonly description: "Requires Nerd Font";
+            }, {
+                readonly value: "ascii";
+                readonly label: "ASCII";
+                readonly description: "Maximum compatibility";
+            }];
+        };
+    };
+    readonly colorBlindMode: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Color-Blind Mode";
+            readonly description: "Use blue instead of green for diff additions";
+        };
+    };
+    readonly "statusLine.preset": {
+        readonly type: "enum";
+        readonly values: readonly ["default", "minimal", "compact", "full", "nerd", "ascii", "custom"];
+        readonly default: "default";
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Status Line Preset";
+            readonly description: "Pre-built status line configurations";
+            readonly options: readonly [{
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "Model, path, git, context, tokens, cost";
+            }, {
+                readonly value: "minimal";
+                readonly label: "Minimal";
+                readonly description: "Path and git only";
+            }, {
+                readonly value: "compact";
+                readonly label: "Compact";
+                readonly description: "Model, git, cost, context";
+            }, {
+                readonly value: "full";
+                readonly label: "Full";
+                readonly description: "All segments including time";
+            }, {
+                readonly value: "nerd";
+                readonly label: "Nerd";
+                readonly description: "Maximum info with Nerd Font icons";
+            }, {
+                readonly value: "ascii";
+                readonly label: "ASCII";
+                readonly description: "No special characters";
+            }, {
+                readonly value: "custom";
+                readonly label: "Custom";
+                readonly description: "User-defined segments";
+            }];
+        };
+    };
+    readonly "statusLine.separator": {
+        readonly type: "enum";
+        readonly values: readonly ["powerline", "powerline-thin", "slash", "pipe", "block", "none", "ascii"];
+        readonly default: "powerline-thin";
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Status Line Separator";
+            readonly description: "Style of separators between segments";
+            readonly options: readonly [{
+                readonly value: "powerline";
+                readonly label: "Powerline";
+                readonly description: "Solid arrows (Nerd Font)";
+            }, {
+                readonly value: "powerline-thin";
+                readonly label: "Thin chevron";
+                readonly description: "Thin arrows (Nerd Font)";
+            }, {
+                readonly value: "slash";
+                readonly label: "Slash";
+                readonly description: "Forward slashes";
+            }, {
+                readonly value: "pipe";
+                readonly label: "Pipe";
+                readonly description: "Vertical pipes";
+            }, {
+                readonly value: "block";
+                readonly label: "Block";
+                readonly description: "Solid blocks";
+            }, {
+                readonly value: "none";
+                readonly label: "None";
+                readonly description: "Space only";
+            }, {
+                readonly value: "ascii";
+                readonly label: "ASCII";
+                readonly description: "Greater-than signs";
+            }];
+        };
+    };
+    readonly "statusLine.sessionAccent": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Session Accent";
+            readonly description: "Use the session name color for the editor border and status line gap";
+        };
+    };
+    readonly "tools.artifactSpillThreshold": {
+        readonly type: "number";
+        readonly default: 50;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Artifact spill threshold (KB)";
+            readonly description: "Tool output above this size is saved as an artifact; tail is kept inline";
+            readonly options: readonly [{
+                readonly value: "1";
+                readonly label: "1 KB";
+                readonly description: "~250 tokens";
+            }, {
+                readonly value: "2.5";
+                readonly label: "2.5 KB";
+                readonly description: "~625 tokens";
+            }, {
+                readonly value: "5";
+                readonly label: "5 KB";
+                readonly description: "~1.25K tokens";
+            }, {
+                readonly value: "10";
+                readonly label: "10 KB";
+                readonly description: "~2.5K tokens";
+            }, {
+                readonly value: "20";
+                readonly label: "20 KB";
+                readonly description: "~5K tokens";
+            }, {
+                readonly value: "30";
+                readonly label: "30 KB";
+                readonly description: "~7.5K tokens";
+            }, {
+                readonly value: "50";
+                readonly label: "50 KB";
+                readonly description: "Default; ~12.5K tokens";
+            }, {
+                readonly value: "75";
+                readonly label: "75 KB";
+                readonly description: "~19K tokens";
+            }, {
+                readonly value: "100";
+                readonly label: "100 KB";
+                readonly description: "~25K tokens";
+            }, {
+                readonly value: "200";
+                readonly label: "200 KB";
+                readonly description: "~50K tokens";
+            }, {
+                readonly value: "500";
+                readonly label: "500 KB";
+                readonly description: "~125K tokens";
+            }, {
+                readonly value: "1000";
+                readonly label: "1 MB";
+                readonly description: "~250K tokens";
+            }];
+        };
+    };
+    readonly "tools.artifactTailBytes": {
+        readonly type: "number";
+        readonly default: 20;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Artifact tail size (KB)";
+            readonly description: "Amount of tail content kept inline when output spills to artifact";
+            readonly options: readonly [{
+                readonly value: "1";
+                readonly label: "1 KB";
+                readonly description: "~250 tokens";
+            }, {
+                readonly value: "2.5";
+                readonly label: "2.5 KB";
+                readonly description: "~625 tokens";
+            }, {
+                readonly value: "5";
+                readonly label: "5 KB";
+                readonly description: "~1.25K tokens";
+            }, {
+                readonly value: "10";
+                readonly label: "10 KB";
+                readonly description: "~2.5K tokens";
+            }, {
+                readonly value: "20";
+                readonly label: "20 KB";
+                readonly description: "Default; ~5K tokens";
+            }, {
+                readonly value: "50";
+                readonly label: "50 KB";
+                readonly description: "~12.5K tokens";
+            }, {
+                readonly value: "100";
+                readonly label: "100 KB";
+                readonly description: "~25K tokens";
+            }, {
+                readonly value: "200";
+                readonly label: "200 KB";
+                readonly description: "~50K tokens";
+            }];
+        };
+    };
+    readonly "tools.artifactHeadBytes": {
+        readonly type: "number";
+        readonly default: 20;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Artifact head size (KB)";
+            readonly description: "Amount of head content kept inline alongside the tail when output spills to artifact (middle elision). 0 disables — keep tail only.";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "0 KB";
+                readonly description: "Disabled; tail-only truncation";
+            }, {
+                readonly value: "1";
+                readonly label: "1 KB";
+                readonly description: "~250 tokens";
+            }, {
+                readonly value: "2.5";
+                readonly label: "2.5 KB";
+                readonly description: "~625 tokens";
+            }, {
+                readonly value: "5";
+                readonly label: "5 KB";
+                readonly description: "~1.25K tokens";
+            }, {
+                readonly value: "10";
+                readonly label: "10 KB";
+                readonly description: "~2.5K tokens";
+            }, {
+                readonly value: "20";
+                readonly label: "20 KB";
+                readonly description: "Default; ~5K tokens";
+            }, {
+                readonly value: "50";
+                readonly label: "50 KB";
+                readonly description: "~12.5K tokens";
+            }, {
+                readonly value: "100";
+                readonly label: "100 KB";
+                readonly description: "~25K tokens";
+            }, {
+                readonly value: "200";
+                readonly label: "200 KB";
+                readonly description: "~50K tokens";
+            }];
+        };
+    };
+    readonly "tools.outputMaxColumns": {
+        readonly type: "number";
+        readonly default: 768;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Output column cap";
+            readonly description: "Per-line byte cap for streaming tool outputs (bash, ssh, python, js eval) and `read`. Lines wider than this are ellipsis-truncated; remaining bytes up to the next newline are dropped. 0 disables.";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "Off";
+                readonly description: "No per-line cap";
+            }, {
+                readonly value: "256";
+                readonly label: "256";
+                readonly description: "Tight";
+            }, {
+                readonly value: "512";
+                readonly label: "512";
+            }, {
+                readonly value: "768";
+                readonly label: "768";
+                readonly description: "Default";
+            }, {
+                readonly value: "1024";
+                readonly label: "1024";
+            }, {
+                readonly value: "2048";
+                readonly label: "2048";
+            }, {
+                readonly value: "4096";
+                readonly label: "4096";
+                readonly description: "Loose";
+            }];
+        };
+    };
+    readonly "tools.artifactTailLines": {
+        readonly type: "number";
+        readonly default: 500;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Artifact tail lines";
+            readonly description: "Maximum lines of tail content kept inline when output spills to artifact";
+            readonly options: readonly [{
+                readonly value: "50";
+                readonly label: "50 lines";
+                readonly description: "~250 tokens";
+            }, {
+                readonly value: "100";
+                readonly label: "100 lines";
+                readonly description: "~500 tokens";
+            }, {
+                readonly value: "250";
+                readonly label: "250 lines";
+                readonly description: "~1.25K tokens";
+            }, {
+                readonly value: "500";
+                readonly label: "500 lines";
+                readonly description: "Default; ~2.5K tokens";
+            }, {
+                readonly value: "1000";
+                readonly label: "1000 lines";
+                readonly description: "~5K tokens";
+            }, {
+                readonly value: "2000";
+                readonly label: "2000 lines";
+                readonly description: "~10K tokens";
+            }, {
+                readonly value: "5000";
+                readonly label: "5000 lines";
+                readonly description: "~25K tokens";
+            }];
+        };
+    };
+    readonly "statusLine.showHookStatus": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Show Hook Status";
+            readonly description: "Display hook status messages below status line";
+        };
+    };
+    readonly "statusLine.leftSegments": {
+        readonly type: "array";
+        readonly default: StatusLineSegmentId[];
+    };
+    readonly "statusLine.rightSegments": {
+        readonly type: "array";
+        readonly default: StatusLineSegmentId[];
+    };
+    readonly "statusLine.segmentOptions": {
+        readonly type: "record";
+        readonly default: Record<string, unknown>;
+    };
+    readonly "terminal.showImages": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Show Inline Images";
+            readonly description: "Render images inline in terminal";
+            readonly condition: "hasImageProtocol";
+        };
+    };
+    readonly "images.autoResize": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Auto-Resize Images";
+            readonly description: "Resize large images to 2000x2000 max for better model compatibility";
+        };
+    };
+    readonly "images.blockImages": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Block Images";
+            readonly description: "Prevent images from being sent to LLM providers";
+        };
+    };
+    readonly "tui.maxInlineImageColumns": {
+        readonly type: "number";
+        readonly default: 100;
+        readonly description: "Maximum width in terminal columns for inline images (default 100). Set to 0 for unlimited (bounded only by terminal width).";
+    };
+    readonly "tui.maxInlineImageRows": {
+        readonly type: "number";
+        readonly default: 20;
+        readonly description: "Maximum height in terminal rows for inline images (default 20). Set to 0 to use only the viewport-based limit (60% of terminal height).";
+    };
+    readonly "tui.maxInlineImages": {
+        readonly type: "number";
+        readonly default: 8;
+        readonly description: "Maximum number of inline images kept as live terminal graphics (default 8). Older images fall back to a text placeholder via a full redraw once the limit is exceeded. Set to 0 to keep every image (no limit).";
+    };
+    readonly "tui.textSizing": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Large Headings (Kitty)";
+            readonly description: "Render Markdown H1 headings at 2x scale using Kitty's OSC 66 text-sizing protocol. Only takes effect on Kitty terminals; ignored everywhere else. Off by default.";
+        };
+    };
+    readonly "tui.hyperlinks": {
+        readonly type: "enum";
+        readonly values: readonly ["off", "auto", "always"];
+        readonly default: "auto";
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Terminal Hyperlinks";
+            readonly description: "Wrap paths and URLs in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)";
+        };
+    };
+    readonly "display.tabWidth": {
+        readonly type: "number";
+        readonly default: 3;
+    };
+    readonly "display.shimmer": {
+        readonly type: "enum";
+        readonly values: readonly ["classic", "kitt", "disabled"];
+        readonly default: "classic";
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Shimmer";
+            readonly description: "Animation style for working/loading messages";
+            readonly options: readonly [{
+                readonly value: "classic";
+                readonly label: "Classic";
+                readonly description: "Soft cosine wave sweeping across the text";
+            }, {
+                readonly value: "kitt";
+                readonly label: "KITT Scanner";
+                readonly description: "Knight Rider 1982 red light bouncing left-right";
+            }, {
+                readonly value: "disabled";
+                readonly label: "Disabled";
+                readonly description: "No animation; static muted text";
+            }];
+        };
+    };
+    readonly "display.showTokenUsage": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Show Token Usage";
+            readonly description: "Show per-turn token usage on assistant messages";
+        };
+    };
+    readonly showHardwareCursor: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Show Hardware Cursor";
+            readonly description: "Show terminal cursor for IME support";
+        };
+    };
+    readonly clearOnShrink: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Clear on Shrink";
+            readonly description: "Clear empty rows when content shrinks (may cause flicker)";
+        };
+    };
+    readonly defaultThinkingLevel: {
+        readonly type: "enum";
+        readonly values: readonly [...import("@prometheus-ai/ai").Effort[], "auto"];
+        readonly default: "high";
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Thinking Level";
+            readonly description: "Reasoning depth for thinking-capable models";
+            readonly options: readonly [import("../thinking").ConfiguredThinkingLevelMetadata, ...import("../thinking").ThinkingLevelMetadata[]];
+        };
+    };
+    readonly hideThinkingBlock: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Hide Thinking Blocks";
+            readonly description: "Hide thinking blocks in assistant responses";
+        };
+    };
+    readonly repeatToolDescriptions: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Repeat Tool Descriptions";
+            readonly description: "Render full tool descriptions in the system prompt instead of a tool name list";
+        };
+    };
+    readonly includeModelInPrompt: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Include Model In Prompt";
+            readonly description: "Surface the active model identifier in the system prompt so the agent knows which model it is";
+        };
+    };
+    readonly temperature: {
+        readonly type: "number";
+        readonly default: -1;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Temperature";
+            readonly description: "Sampling temperature (0 = deterministic, 1 = creative, -1 = provider default)";
+            readonly options: readonly [{
+                readonly value: "-1";
+                readonly label: "Default";
+                readonly description: "Use provider default";
+            }, {
+                readonly value: "0";
+                readonly label: "0";
+                readonly description: "Deterministic";
+            }, {
+                readonly value: "0.2";
+                readonly label: "0.2";
+                readonly description: "Focused";
+            }, {
+                readonly value: "0.5";
+                readonly label: "0.5";
+                readonly description: "Balanced";
+            }, {
+                readonly value: "0.7";
+                readonly label: "0.7";
+                readonly description: "Creative";
+            }, {
+                readonly value: "1";
+                readonly label: "1";
+                readonly description: "Maximum variety";
+            }];
+        };
+    };
+    readonly topP: {
+        readonly type: "number";
+        readonly default: -1;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Top P";
+            readonly description: "Nucleus sampling cutoff (0-1, -1 = provider default)";
+            readonly options: readonly [{
+                readonly value: "-1";
+                readonly label: "Default";
+                readonly description: "Use provider default";
+            }, {
+                readonly value: "0.1";
+                readonly label: "0.1";
+                readonly description: "Very focused";
+            }, {
+                readonly value: "0.3";
+                readonly label: "0.3";
+                readonly description: "Focused";
+            }, {
+                readonly value: "0.5";
+                readonly label: "0.5";
+                readonly description: "Balanced";
+            }, {
+                readonly value: "0.9";
+                readonly label: "0.9";
+                readonly description: "Broad";
+            }, {
+                readonly value: "1";
+                readonly label: "1";
+                readonly description: "No nucleus filtering";
+            }];
+        };
+    };
+    readonly topK: {
+        readonly type: "number";
+        readonly default: -1;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Top K";
+            readonly description: "Sample from top-K tokens (-1 = provider default)";
+            readonly options: readonly [{
+                readonly value: "-1";
+                readonly label: "Default";
+                readonly description: "Use provider default";
+            }, {
+                readonly value: "1";
+                readonly label: "1";
+                readonly description: "Greedy top token";
+            }, {
+                readonly value: "20";
+                readonly label: "20";
+                readonly description: "Focused";
+            }, {
+                readonly value: "40";
+                readonly label: "40";
+                readonly description: "Balanced";
+            }, {
+                readonly value: "100";
+                readonly label: "100";
+                readonly description: "Broad";
+            }];
+        };
+    };
+    readonly minP: {
+        readonly type: "number";
+        readonly default: -1;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Min P";
+            readonly description: "Minimum probability threshold (0-1, -1 = provider default)";
+            readonly options: readonly [{
+                readonly value: "-1";
+                readonly label: "Default";
+                readonly description: "Use provider default";
+            }, {
+                readonly value: "0.01";
+                readonly label: "0.01";
+                readonly description: "Very permissive";
+            }, {
+                readonly value: "0.05";
+                readonly label: "0.05";
+                readonly description: "Balanced";
+            }, {
+                readonly value: "0.1";
+                readonly label: "0.1";
+                readonly description: "Strict";
+            }];
+        };
+    };
+    readonly presencePenalty: {
+        readonly type: "number";
+        readonly default: -1;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Presence Penalty";
+            readonly description: "Penalty for introducing already-present tokens (-1 = provider default)";
+            readonly options: readonly [{
+                readonly value: "-1";
+                readonly label: "Default";
+                readonly description: "Use provider default";
+            }, {
+                readonly value: "0";
+                readonly label: "0";
+                readonly description: "No penalty";
+            }, {
+                readonly value: "0.5";
+                readonly label: "0.5";
+                readonly description: "Mild novelty";
+            }, {
+                readonly value: "1";
+                readonly label: "1";
+                readonly description: "Encourage novelty";
+            }, {
+                readonly value: "2";
+                readonly label: "2";
+                readonly description: "Strong novelty";
+            }];
+        };
+    };
+    readonly repetitionPenalty: {
+        readonly type: "number";
+        readonly default: -1;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Repetition Penalty";
+            readonly description: "Penalty for repeated tokens (-1 = provider default)";
+            readonly options: readonly [{
+                readonly value: "-1";
+                readonly label: "Default";
+                readonly description: "Use provider default";
+            }, {
+                readonly value: "0.8";
+                readonly label: "0.8";
+                readonly description: "Allow repetition";
+            }, {
+                readonly value: "1";
+                readonly label: "1";
+                readonly description: "No penalty";
+            }, {
+                readonly value: "1.1";
+                readonly label: "1.1";
+                readonly description: "Mild penalty";
+            }, {
+                readonly value: "1.2";
+                readonly label: "1.2";
+                readonly description: "Balanced";
+            }, {
+                readonly value: "1.5";
+                readonly label: "1.5";
+                readonly description: "Strong penalty";
+            }];
+        };
+    };
+    readonly serviceTier: {
+        readonly type: "enum";
+        readonly values: readonly ["none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
+        readonly default: "none";
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Service Tier";
+            readonly description: 'Processing priority hint (none = omit). OpenAI accepts the tier values directly; Anthropic realizes `priority` as `speed: "fast"` on supported Opus models. Scoped values target one family.';
+            readonly options: readonly [{
+                readonly value: "none";
+                readonly label: "None";
+                readonly description: "Omit service_tier parameter";
+            }, {
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Use provider default tier selection (OpenAI)";
+            }, {
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "Standard priority processing (OpenAI)";
+            }, {
+                readonly value: "flex";
+                readonly label: "Flex";
+                readonly description: "Flexible capacity tier when available (OpenAI)";
+            }, {
+                readonly value: "scale";
+                readonly label: "Scale";
+                readonly description: "Scale Tier credits when available (OpenAI)";
+            }, {
+                readonly value: "priority";
+                readonly label: "Priority";
+                readonly description: "Priority on every supported provider (OpenAI `service_tier`, Anthropic fast mode)";
+            }, {
+                readonly value: "openai-only";
+                readonly label: "Priority (OpenAI only)";
+                readonly description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere";
+            }, {
+                readonly value: "claude-only";
+                readonly label: "Priority (Claude only)";
+                readonly description: "Anthropic fast mode on direct Claude requests; ignored elsewhere (incl. Bedrock/Vertex)";
+            }];
+        };
+    };
+    readonly "retry.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "retry.maxRetries": {
+        readonly type: "number";
+        readonly default: 3;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Retry Attempts";
+            readonly description: "Maximum retry attempts on API errors";
+            readonly options: readonly [{
+                readonly value: "1";
+                readonly label: "1 retry";
+            }, {
+                readonly value: "2";
+                readonly label: "2 retries";
+            }, {
+                readonly value: "3";
+                readonly label: "3 retries";
+            }, {
+                readonly value: "5";
+                readonly label: "5 retries";
+            }, {
+                readonly value: "10";
+                readonly label: "10 retries";
+            }];
+        };
+    };
+    readonly "retry.baseDelayMs": {
+        readonly type: "number";
+        readonly default: 2000;
+    };
+    readonly "retry.maxDelayMs": {
+        readonly type: "number";
+        readonly default: number;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Max Retry Delay";
+            readonly description: "Maximum wait between retries, in ms. When the provider asks us to wait longer than this and no credential or model fallback succeeds, the request fails fast instead of sleeping (e.g. 3-hour Anthropic rate-limit windows).";
+        };
+    };
+    readonly "retry.modelFallback": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Retry Model Fallback";
+            readonly description: "Allow retry recovery to switch to configured fallback models";
+        };
+    };
+    readonly "retry.fallbackChains": {
+        readonly type: "record";
+        readonly default: Record<string, string[]>;
+    };
+    readonly "retry.fallbackRevertPolicy": {
+        readonly type: "enum";
+        readonly values: readonly ["cooldown-expiry", "never"];
+        readonly default: "cooldown-expiry";
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Fallback Revert Policy";
+            readonly description: "When to return to the primary model after a fallback";
+            readonly options: readonly [{
+                readonly value: "cooldown-expiry";
+                readonly label: "Cooldown expiry";
+                readonly description: "Return to the primary model after its suppression window ends";
+            }, {
+                readonly value: "never";
+                readonly label: "Never";
+                readonly description: "Stay on the fallback model until manually changed";
+            }];
+        };
+    };
+    readonly steeringMode: {
+        readonly type: "enum";
+        readonly values: readonly ["all", "one-at-a-time"];
+        readonly default: "one-at-a-time";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Steering Mode";
+            readonly description: "How to process queued messages while agent is working";
+        };
+    };
+    readonly followUpMode: {
+        readonly type: "enum";
+        readonly values: readonly ["all", "one-at-a-time"];
+        readonly default: "one-at-a-time";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Follow-Up Mode";
+            readonly description: "How to drain follow-up messages after a turn completes";
+        };
+    };
+    readonly interruptMode: {
+        readonly type: "enum";
+        readonly values: readonly ["immediate", "wait"];
+        readonly default: "immediate";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Interrupt Mode";
+            readonly description: "When steering messages interrupt tool execution";
+        };
+    };
+    readonly "loop.mode": {
+        readonly type: "enum";
+        readonly values: readonly ["prompt", "compact", "reset"];
+        readonly default: "prompt";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Loop Mode";
+            readonly description: "What happens between /loop iterations before re-submitting the prompt";
+            readonly options: readonly [{
+                readonly value: "prompt";
+                readonly label: "Prompt";
+                readonly description: "Re-submit the prompt as a follow-up message (current behavior)";
+            }, {
+                readonly value: "compact";
+                readonly label: "Compact";
+                readonly description: "Compact the session context, then re-submit the prompt";
+            }, {
+                readonly value: "reset";
+                readonly label: "Reset";
+                readonly description: "Start a new session, then re-submit the prompt";
+            }];
+        };
+    };
+    readonly doubleEscapeAction: {
+        readonly type: "enum";
+        readonly values: readonly ["branch", "tree", "none"];
+        readonly default: "tree";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Double-Escape Action";
+            readonly description: "Action when pressing Escape twice with empty editor";
+        };
+    };
+    readonly treeFilterMode: {
+        readonly type: "enum";
+        readonly values: readonly ["default", "no-tools", "user-only", "labeled-only", "all"];
+        readonly default: "default";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Session Tree Filter";
+            readonly description: "Default filter mode when opening the session tree";
+        };
+    };
+    readonly autocompleteMaxVisible: {
+        readonly type: "number";
+        readonly default: 5;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Autocomplete Items";
+            readonly description: "Max visible items in autocomplete dropdown (3-20)";
+            readonly options: readonly [{
+                readonly value: "3";
+                readonly label: "3 items";
+            }, {
+                readonly value: "5";
+                readonly label: "5 items";
+            }, {
+                readonly value: "7";
+                readonly label: "7 items";
+            }, {
+                readonly value: "10";
+                readonly label: "10 items";
+            }, {
+                readonly value: "15";
+                readonly label: "15 items";
+            }, {
+                readonly value: "20";
+                readonly label: "20 items";
+            }];
+        };
+    };
+    readonly emojiAutocomplete: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Emoji Autocomplete";
+            readonly description: "Suggest emojis from `:name:` shortcodes and expand text emoticons like `:D` or `:-)`";
+        };
+    };
+    readonly "startup.quiet": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Quiet Startup";
+            readonly description: "Skip welcome screen and startup status messages";
+        };
+    };
+    readonly "startup.setupWizard": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Setup Wizard";
+            readonly description: "Show newly added onboarding steps once per setup version";
+        };
+    };
+    readonly "startup.checkUpdate": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Check for Updates";
+            readonly description: "If false, skip update check";
+        };
+    };
+    readonly collapseChangelog: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Collapse Changelog";
+            readonly description: "Show condensed changelog after updates";
+        };
+    };
+    readonly "completion.notify": {
+        readonly type: "enum";
+        readonly values: readonly ["on", "off"];
+        readonly default: "on";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Completion Notification";
+            readonly description: "Notify when the agent completes";
+        };
+    };
+    readonly "ask.timeout": {
+        readonly type: "number";
+        readonly default: 0;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Ask Timeout";
+            readonly description: "Auto-select recommended option after timeout (0 to disable)";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "Disabled";
+            }, {
+                readonly value: "15";
+                readonly label: "15 seconds";
+            }, {
+                readonly value: "30";
+                readonly label: "30 seconds";
+            }, {
+                readonly value: "60";
+                readonly label: "60 seconds";
+            }, {
+                readonly value: "120";
+                readonly label: "120 seconds";
+            }];
+        };
+    };
+    readonly "ask.notify": {
+        readonly type: "enum";
+        readonly values: readonly ["on", "off"];
+        readonly default: "on";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Ask Notification";
+            readonly description: "Notify when ask tool is waiting for input";
+        };
+    };
+    readonly "stt.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Speech-to-Text";
+            readonly description: "Enable speech-to-text input via microphone";
+        };
+    };
+    readonly "stt.language": {
+        readonly type: "string";
+        readonly default: "en";
+    };
+    readonly "stt.modelName": {
+        readonly type: "enum";
+        readonly values: readonly ["tiny", "tiny.en", "base", "base.en", "small", "small.en", "medium", "medium.en", "large"];
+        readonly default: "base.en";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Speech Model";
+            readonly description: "Whisper model size (larger = more accurate but slower)";
+            readonly options: readonly [{
+                readonly value: "tiny";
+                readonly label: "tiny";
+                readonly description: "Multilingual; fastest, lowest accuracy";
+            }, {
+                readonly value: "tiny.en";
+                readonly label: "tiny.en";
+                readonly description: "English-only; fastest";
+            }, {
+                readonly value: "base";
+                readonly label: "base";
+                readonly description: "Multilingual; small and fast";
+            }, {
+                readonly value: "base.en";
+                readonly label: "base.en";
+                readonly description: "English-only; default";
+            }, {
+                readonly value: "small";
+                readonly label: "small";
+                readonly description: "Multilingual; balanced";
+            }, {
+                readonly value: "small.en";
+                readonly label: "small.en";
+                readonly description: "English-only; balanced";
+            }, {
+                readonly value: "medium";
+                readonly label: "medium";
+                readonly description: "Multilingual; accurate but slower";
+            }, {
+                readonly value: "medium.en";
+                readonly label: "medium.en";
+                readonly description: "English-only; accurate but slower";
+            }, {
+                readonly value: "large";
+                readonly label: "large";
+                readonly description: "Multilingual; most accurate";
+            }];
+        };
+    };
+    readonly "contextPromotion.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Auto-Promote Context";
+            readonly description: "Promote to a larger-context model on context overflow instead of compacting";
+        };
+    };
+    readonly "compaction.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Auto-Compact";
+            readonly description: "Automatically compact context when it gets too large";
+        };
+    };
+    readonly "compaction.strategy": {
+        readonly type: "enum";
+        readonly values: readonly ["context-full", "handoff", "shake", "off"];
+        readonly default: "context-full";
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Compaction Strategy";
+            readonly description: "Choose in-place context-full maintenance, auto-handoff, surgical shake (drop heavy content), or disable auto maintenance (off)";
+            readonly options: readonly [{
+                readonly value: "context-full";
+                readonly label: "Context-full";
+                readonly description: "Summarize in-place and keep the current session";
+            }, {
+                readonly value: "handoff";
+                readonly label: "Handoff";
+                readonly description: "Generate handoff and continue in a new session";
+            }, {
+                readonly value: "shake";
+                readonly label: "Shake";
+                readonly description: "Drop heavy content (tool results + large blocks) in place; recover via artifact";
+            }, {
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Disable automatic context maintenance (same behavior as Auto-compact off)";
+            }];
+        };
+    };
+    readonly "compaction.thresholdPercent": {
+        readonly type: "number";
+        readonly default: -1;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Compaction Threshold";
+            readonly description: "Percent threshold for context maintenance; set to Default to use legacy reserve-based behavior";
+            readonly options: readonly [{
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "Legacy reserve-based threshold";
+            }, {
+                readonly value: "10";
+                readonly label: "10%";
+                readonly description: "Extremely early maintenance";
+            }, {
+                readonly value: "20";
+                readonly label: "20%";
+                readonly description: "Very early maintenance";
+            }, {
+                readonly value: "30";
+                readonly label: "30%";
+                readonly description: "Early maintenance";
+            }, {
+                readonly value: "40";
+                readonly label: "40%";
+                readonly description: "Moderately early maintenance";
+            }, {
+                readonly value: "50";
+                readonly label: "50%";
+                readonly description: "Halfway point";
+            }, {
+                readonly value: "60";
+                readonly label: "60%";
+                readonly description: "Moderate context usage";
+            }, {
+                readonly value: "70";
+                readonly label: "70%";
+                readonly description: "Balanced";
+            }, {
+                readonly value: "75";
+                readonly label: "75%";
+                readonly description: "Slightly aggressive";
+            }, {
+                readonly value: "80";
+                readonly label: "80%";
+                readonly description: "Typical threshold";
+            }, {
+                readonly value: "85";
+                readonly label: "85%";
+                readonly description: "Aggressive context usage";
+            }, {
+                readonly value: "90";
+                readonly label: "90%";
+                readonly description: "Very aggressive";
+            }, {
+                readonly value: "95";
+                readonly label: "95%";
+                readonly description: "Near context limit";
+            }];
+        };
+    };
+    readonly "compaction.thresholdTokens": {
+        readonly type: "number";
+        readonly default: -1;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Compaction Token Limit";
+            readonly description: "Fixed token limit for context maintenance; overrides percentage if set";
+            readonly options: readonly [{
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "Use percentage-based threshold";
+            }, {
+                readonly value: "25000";
+                readonly label: "25K tokens";
+                readonly description: "Quarter of a 200K window";
+            }, {
+                readonly value: "50000";
+                readonly label: "50K tokens";
+                readonly description: "Half of a 200K window";
+            }, {
+                readonly value: "100000";
+                readonly label: "100K tokens";
+                readonly description: "Half of a 200K window";
+            }, {
+                readonly value: "150000";
+                readonly label: "150K tokens";
+                readonly description: "Three-quarters of a 200K window";
+            }, {
+                readonly value: "200000";
+                readonly label: "200K tokens";
+                readonly description: "Full standard context window";
+            }, {
+                readonly value: "300000";
+                readonly label: "300K tokens";
+                readonly description: "Large context window";
+            }, {
+                readonly value: "500000";
+                readonly label: "500K tokens";
+                readonly description: "Very large context window";
+            }];
+        };
+    };
+    readonly "compaction.handoffSaveToDisk": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Save Handoff Docs";
+            readonly description: "Save generated handoff documents to markdown files for the auto-handoff flow";
+        };
+    };
+    readonly "compaction.remoteEnabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Remote Compaction";
+            readonly description: "Use remote compaction endpoints when available instead of local summarization";
+        };
+    };
+    readonly "compaction.reserveTokens": {
+        readonly type: "number";
+        readonly default: 16384;
+    };
+    readonly "compaction.keepRecentTokens": {
+        readonly type: "number";
+        readonly default: 20000;
+    };
+    readonly "compaction.autoContinue": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "compaction.remoteEndpoint": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "compaction.idleEnabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Idle Compaction";
+            readonly description: "Compact context while idle when token count exceeds threshold";
+        };
+    };
+    readonly "compaction.idleThresholdTokens": {
+        readonly type: "number";
+        readonly default: 200000;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Idle Compaction Threshold";
+            readonly description: "Token count above which idle compaction triggers";
+            readonly options: readonly [{
+                readonly value: "100000";
+                readonly label: "100K tokens";
+            }, {
+                readonly value: "200000";
+                readonly label: "200K tokens";
+            }, {
+                readonly value: "300000";
+                readonly label: "300K tokens";
+            }, {
+                readonly value: "400000";
+                readonly label: "400K tokens";
+            }, {
+                readonly value: "500000";
+                readonly label: "500K tokens";
+            }, {
+                readonly value: "600000";
+                readonly label: "600K tokens";
+            }, {
+                readonly value: "700000";
+                readonly label: "700K tokens";
+            }, {
+                readonly value: "800000";
+                readonly label: "800K tokens";
+            }, {
+                readonly value: "900000";
+                readonly label: "900K tokens";
+            }];
+        };
+    };
+    readonly "compaction.idleTimeoutSeconds": {
+        readonly type: "number";
+        readonly default: 300;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Idle Compaction Delay";
+            readonly description: "Seconds to wait while idle before compacting";
+            readonly options: readonly [{
+                readonly value: "60";
+                readonly label: "1 minute";
+            }, {
+                readonly value: "120";
+                readonly label: "2 minutes";
+            }, {
+                readonly value: "300";
+                readonly label: "5 minutes";
+            }, {
+                readonly value: "600";
+                readonly label: "10 minutes";
+            }, {
+                readonly value: "1800";
+                readonly label: "30 minutes";
+            }, {
+                readonly value: "3600";
+                readonly label: "1 hour";
+            }];
+        };
+    };
+    readonly "branchSummary.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Branch Summaries";
+            readonly description: "Prompt to summarize when leaving a branch";
+        };
+    };
+    readonly "branchSummary.reserveTokens": {
+        readonly type: "number";
+        readonly default: 16384;
+    };
+    readonly "memories.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly "memories.maxRolloutsPerStartup": {
+        readonly type: "number";
+        readonly default: 64;
+    };
+    readonly "memories.maxRolloutAgeDays": {
+        readonly type: "number";
+        readonly default: 30;
+    };
+    readonly "memories.minRolloutIdleHours": {
+        readonly type: "number";
+        readonly default: 12;
+    };
+    readonly "memories.threadScanLimit": {
+        readonly type: "number";
+        readonly default: 300;
+    };
+    readonly "memories.maxRawMemoriesForGlobal": {
+        readonly type: "number";
+        readonly default: 200;
+    };
+    readonly "memories.stage1Concurrency": {
+        readonly type: "number";
+        readonly default: 8;
+    };
+    readonly "memories.stage1LeaseSeconds": {
+        readonly type: "number";
+        readonly default: 120;
+    };
+    readonly "memories.stage1RetryDelaySeconds": {
+        readonly type: "number";
+        readonly default: 120;
+    };
+    readonly "memories.phase2LeaseSeconds": {
+        readonly type: "number";
+        readonly default: 180;
+    };
+    readonly "memories.phase2RetryDelaySeconds": {
+        readonly type: "number";
+        readonly default: 180;
+    };
+    readonly "memories.phase2HeartbeatSeconds": {
+        readonly type: "number";
+        readonly default: 30;
+    };
+    readonly "memories.rolloutPayloadPercent": {
+        readonly type: "number";
+        readonly default: 0.7;
+    };
+    readonly "memories.phase1InputTokenLimit": {
+        readonly type: "number";
+        readonly default: 4000;
+    };
+    readonly "memories.fallbackTokenLimit": {
+        readonly type: "number";
+        readonly default: 16000;
+    };
+    readonly "memories.summaryInjectionTokenLimit": {
+        readonly type: "number";
+        readonly default: 5000;
+    };
+    readonly "memory.backend": {
+        readonly type: "enum";
+        readonly values: readonly ["off", "local", "hindsight", "prometheus-memory"];
+        readonly default: "off";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Memory Backend";
+            readonly description: "Off, local summary pipeline, Prometheus Memory SQLite, or Hindsight remote memory";
+            readonly options: readonly [{
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "No memory subsystem runs";
+            }, {
+                readonly value: "local";
+                readonly label: "Local";
+                readonly description: "Local rollout summarisation pipeline (memory_summary.md)";
+            }, {
+                readonly value: "hindsight";
+                readonly label: "Hindsight";
+                readonly description: "Vectorize Hindsight remote memory service";
+            }, {
+                readonly value: "prometheus-memory";
+                readonly label: "Prometheus Memory";
+                readonly description: "Local SQLite recall/retain backend with optional embeddings";
+            }];
+        };
+    };
+    readonly "selfImprovement.mode": {
+        readonly type: "enum";
+        readonly values: readonly ["memory-and-skills", "off"];
+        readonly default: "memory-and-skills";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Self Improvement";
+            readonly description: "Hermes-style native learning: memory, user profile, and skills update automatically; SOUL stays stable";
+            readonly options: readonly [{
+                readonly value: "memory-and-skills";
+                readonly label: "Memory and Skills";
+                readonly description: "Allow the local memory backend to maintain MEMORY.md, USER.md, and generated skills";
+            }, {
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Do not run local self-improvement maintenance";
+            }];
+        };
+    };
+    readonly "selfImprovement.backgroundReviewMode": {
+        readonly type: "enum";
+        readonly values: readonly ["memory-and-skills", "off"];
+        readonly default: "memory-and-skills";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Post-Turn Review";
+            readonly description: "Hermes-style background review after settled turns, routed through the native Prometheus memory pipeline";
+            readonly options: readonly [{
+                readonly value: "memory-and-skills";
+                readonly label: "Memory and Skills";
+                readonly description: "Review completed turns and feed durable signal into MEMORY.md, USER.md, and generated skills";
+            }, {
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Do not run post-turn self-improvement review";
+            }];
+        };
+    };
+    readonly "selfImprovement.backgroundReviewEveryNTurns": {
+        readonly type: "number";
+        readonly default: 10;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Review Turn Interval";
+            readonly description: "User turns between post-turn self-improvement reviews; 10 mirrors Hermes";
+        };
+    };
+    readonly "selfImprovement.identityReviewMode": {
+        readonly type: "enum";
+        readonly values: readonly ["propose", "off"];
+        readonly default: "propose";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Identity Review";
+            readonly description: "Proposal-only SOUL review; never rewrites SOUL.md automatically";
+            readonly options: readonly [{
+                readonly value: "propose";
+                readonly label: "Propose";
+                readonly description: "Write approval-gated SOUL.proposed.md suggestions when identity changes are warranted";
+            }, {
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Do not run identity proposal review";
+            }];
+        };
+    };
+    readonly "selfImprovement.curatorMode": {
+        readonly type: "enum";
+        readonly values: readonly ["dry-run", "off"];
+        readonly default: "dry-run";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Skill Curator";
+            readonly description: "Report-only generated-skill curation with recoverable archive lifecycle";
+            readonly options: readonly [{
+                readonly value: "dry-run";
+                readonly label: "Dry Run";
+                readonly description: "Track provenance, usage, stale/archive candidates, and lifecycle reports";
+            }, {
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Do not write generated-skill curator reports";
+            }];
+        };
+    };
+    readonly "selfImprovement.generatedSkillStaleAfterDays": {
+        readonly type: "number";
+        readonly default: 30;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Skill Stale Days";
+            readonly description: "Days of no generated-skill activity before the dry-run curator marks it stale";
+        };
+    };
+    readonly "selfImprovement.generatedSkillArchiveAfterDays": {
+        readonly type: "number";
+        readonly default: 90;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Skill Archive Days";
+            readonly description: "Days of no generated-skill activity before the dry-run curator suggests archive";
+        };
+    };
+    readonly "prometheusMemory.dbPath": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory DB Path";
+            readonly description: "Optional SQLite DB path. Defaults to the agent memories directory.";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.bank": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory Bank";
+            readonly description: "Optional shared bank base name. Per-project modes derive project-local banks from it.";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.scoping": {
+        readonly type: "enum";
+        readonly values: readonly ["global", "per-project", "per-project-tagged"];
+        readonly default: "per-project";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory Scoping";
+            readonly description: "global = one shared bank; per-project = isolated bank per cwd; per-project-tagged = project-local writes plus global recall visibility";
+            readonly options: readonly [{
+                readonly value: "global";
+                readonly label: "Global";
+                readonly description: "One shared Prometheus Memory bank for every project";
+            }, {
+                readonly value: "per-project";
+                readonly label: "Per project";
+                readonly description: "Project-local Prometheus Memory bank per cwd basename";
+            }, {
+                readonly value: "per-project-tagged";
+                readonly label: "Per project (tagged)";
+                readonly description: "Write to a project-local bank but merge project + shared recall results";
+            }];
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.autoRecall": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory Auto Recall";
+            readonly description: "Recall local memories into the first turn of each session";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.autoRetain": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory Auto Retain";
+            readonly description: "Retain completed conversation turns into local Prometheus Memory";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.noEmbeddings": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory Disable Embeddings";
+            readonly description: "Force deterministic FTS-only recall instead of vector embeddings";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.embeddingModel": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory Embedding Model";
+            readonly description: "Optional embedding model override passed to Prometheus Memory";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.embeddingApiUrl": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory Embedding API URL";
+            readonly description: "Optional OpenAI-compatible embedding endpoint passed to Prometheus Memory";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.embeddingApiKey": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory Embedding API Key";
+            readonly description: "Optional embedding API key passed to Prometheus Memory";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.llmMode": {
+        readonly type: "enum";
+        readonly values: readonly ["none", "smol", "remote"];
+        readonly default: "smol";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory LLM Mode";
+            readonly description: "Use no LLM, the configured smol model, or a remote OpenAI-compatible endpoint";
+            readonly condition: "prometheusMemoryActive";
+            readonly options: readonly [{
+                readonly value: "none";
+                readonly label: "None";
+                readonly description: "Disable Prometheus Memory LLM-backed extraction";
+            }, {
+                readonly value: "smol";
+                readonly label: "Smol";
+                readonly description: "Use the configured Prometheus smol model";
+            }, {
+                readonly value: "remote";
+                readonly label: "Remote";
+                readonly description: "Use the Prometheus Memory remote LLM settings below";
+            }];
+        };
+    };
+    readonly "prometheusMemory.llmBaseUrl": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory LLM Base URL";
+            readonly description: "Optional OpenAI-compatible LLM endpoint for Prometheus Memory remote mode";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.llmApiKey": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory LLM API Key";
+            readonly description: "Optional LLM API key for Prometheus Memory remote mode";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.llmModel": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Prometheus Memory LLM Model";
+            readonly description: "Optional LLM model name for Prometheus Memory remote mode";
+            readonly condition: "prometheusMemoryActive";
+        };
+    };
+    readonly "prometheusMemory.retainEveryNTurns": {
+        readonly type: "number";
+        readonly default: 4;
+    };
+    readonly "prometheusMemory.recallLimit": {
+        readonly type: "number";
+        readonly default: 8;
+    };
+    readonly "prometheusMemory.recallContextTurns": {
+        readonly type: "number";
+        readonly default: 3;
+    };
+    readonly "prometheusMemory.recallMaxQueryChars": {
+        readonly type: "number";
+        readonly default: 4000;
+    };
+    readonly "prometheusMemory.injectionTokenLimit": {
+        readonly type: "number";
+        readonly default: 5000;
+    };
+    readonly "prometheusMemory.debug": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly "hindsight.apiUrl": {
+        readonly type: "string";
+        readonly default: "http://localhost:8888";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Hindsight API URL";
+            readonly description: "Hindsight server URL (Cloud or self-hosted)";
+            readonly condition: "hindsightActive";
+        };
+    };
+    readonly "hindsight.apiToken": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "hindsight.bankId": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Hindsight Bank ID";
+            readonly description: "Memory bank identifier (default: project name)";
+            readonly condition: "hindsightActive";
+        };
+    };
+    readonly "hindsight.bankIdPrefix": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "hindsight.scoping": {
+        readonly type: "enum";
+        readonly values: readonly ["global", "per-project", "per-project-tagged"];
+        readonly default: "per-project-tagged";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Hindsight Scoping";
+            readonly description: "global = one shared bank; per-project = isolated bank per cwd; per-project-tagged = shared bank with project tags so global + project memories merge on recall";
+            readonly options: readonly [{
+                readonly value: "global";
+                readonly label: "Global";
+                readonly description: "One shared bank — every project sees the same memories";
+            }, {
+                readonly value: "per-project";
+                readonly label: "Per project";
+                readonly description: "Isolated bank per cwd basename — projects cannot see each other's memories";
+            }, {
+                readonly value: "per-project-tagged";
+                readonly label: "Per project (tagged)";
+                readonly description: "Shared bank, retains tagged with project:<cwd>. Recall surfaces project + untagged global memories together";
+            }];
+            readonly condition: "hindsightActive";
+        };
+    };
+    readonly "hindsight.bankMission": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "hindsight.retainMission": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "hindsight.autoRecall": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Hindsight Auto Recall";
+            readonly description: "Recall memories on the first turn of each session";
+            readonly condition: "hindsightActive";
+        };
+    };
+    readonly "hindsight.autoRetain": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Hindsight Auto Retain";
+            readonly description: "Retain transcript every N turns and at session boundaries";
+            readonly condition: "hindsightActive";
+        };
+    };
+    readonly "hindsight.retainMode": {
+        readonly type: "enum";
+        readonly values: readonly ["full-session", "last-turn"];
+        readonly default: "full-session";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Hindsight Retain Mode";
+            readonly description: "full-session = upsert one document per session, last-turn = chunked";
+            readonly options: readonly [{
+                readonly value: "full-session";
+                readonly label: "Full session";
+                readonly description: "Upsert one document per session (recommended)";
+            }, {
+                readonly value: "last-turn";
+                readonly label: "Last turn";
+                readonly description: "Chunked retention sliced by turn boundaries";
+            }];
+            readonly condition: "hindsightActive";
+        };
+    };
+    readonly "hindsight.retainEveryNTurns": {
+        readonly type: "number";
+        readonly default: 3;
+    };
+    readonly "hindsight.retainOverlapTurns": {
+        readonly type: "number";
+        readonly default: 2;
+    };
+    readonly "hindsight.retainContext": {
+        readonly type: "string";
+        readonly default: "prometheus";
+    };
+    readonly "hindsight.recallBudget": {
+        readonly type: "enum";
+        readonly values: readonly ["low", "mid", "high"];
+        readonly default: "mid";
+    };
+    readonly "hindsight.recallMaxTokens": {
+        readonly type: "number";
+        readonly default: 1024;
+    };
+    readonly "hindsight.recallContextTurns": {
+        readonly type: "number";
+        readonly default: 1;
+    };
+    readonly "hindsight.recallMaxQueryChars": {
+        readonly type: "number";
+        readonly default: 800;
+    };
+    readonly "hindsight.recallTypes": {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly "hindsight.debug": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly "hindsight.mentalModelsEnabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Hindsight Mental Models";
+            readonly description: "Read curated reflect summaries (mental models) into developer instructions at boot. Loads existing models on the bank — does not write. Pair with hindsight.mentalModelAutoSeed to also auto-create the built-in seed set.";
+            readonly condition: "hindsightActive";
+        };
+    };
+    readonly "hindsight.mentalModelAutoSeed": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Hindsight Mental Model Auto-Seed";
+            readonly description: "At session start, create any built-in mental models (project-conventions, project-decisions, user-preferences) that do not yet exist on the bank.";
+            readonly condition: "hindsightActive";
+        };
+    };
+    readonly "hindsight.mentalModelRefreshIntervalMs": {
+        readonly type: "number";
+        readonly default: number;
+    };
+    readonly "hindsight.mentalModelMaxRenderChars": {
+        readonly type: "number";
+        readonly default: 16000;
+    };
+    readonly "ttsr.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "TTSR";
+            readonly description: "Time Traveling Stream Rules: interrupt agent when output matches patterns";
+        };
+    };
+    readonly "ttsr.contextMode": {
+        readonly type: "enum";
+        readonly values: readonly ["discard", "keep"];
+        readonly default: "discard";
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "TTSR Context Mode";
+            readonly description: "What to do with partial output when TTSR triggers";
+        };
+    };
+    readonly "ttsr.interruptMode": {
+        readonly type: "enum";
+        readonly values: readonly ["never", "prose-only", "tool-only", "always"];
+        readonly default: "always";
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "TTSR Interrupt Mode";
+            readonly description: "When to interrupt mid-stream vs inject warning after completion";
+            readonly options: readonly [{
+                readonly value: "always";
+                readonly label: "always";
+                readonly description: "Interrupt on prose and tool streams";
+            }, {
+                readonly value: "prose-only";
+                readonly label: "prose-only";
+                readonly description: "Interrupt only on reply/thinking matches";
+            }, {
+                readonly value: "tool-only";
+                readonly label: "tool-only";
+                readonly description: "Interrupt only on tool-call argument matches";
+            }, {
+                readonly value: "never";
+                readonly label: "never";
+                readonly description: "Never interrupt; inject warning after completion";
+            }];
+        };
+    };
+    readonly "ttsr.repeatMode": {
+        readonly type: "enum";
+        readonly values: readonly ["once", "after-gap"];
+        readonly default: "once";
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "TTSR Repeat Mode";
+            readonly description: "How rules can repeat: once per session or after a message gap";
+        };
+    };
+    readonly "ttsr.repeatGap": {
+        readonly type: "number";
+        readonly default: 10;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "TTSR Repeat Gap";
+            readonly description: "Messages before a rule can trigger again";
+            readonly options: readonly [{
+                readonly value: "5";
+                readonly label: "5 messages";
+            }, {
+                readonly value: "10";
+                readonly label: "10 messages";
+            }, {
+                readonly value: "15";
+                readonly label: "15 messages";
+            }, {
+                readonly value: "20";
+                readonly label: "20 messages";
+            }, {
+                readonly value: "30";
+                readonly label: "30 messages";
+            }];
+        };
+    };
+    readonly "ttsr.builtinRules": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Builtin Rules";
+            readonly description: "Load the default rules shipped with the agent (override individually with ttsr.disabledRules)";
+        };
+    };
+    readonly "ttsr.disabledRules": {
+        readonly type: "array";
+        readonly default: string[];
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Disabled Rules";
+            readonly description: "Rule names to ignore entirely (applies to bundled defaults and your own rules)";
+        };
+    };
+    readonly "edit.mode": {
+        readonly type: "enum";
+        readonly values: import("..").EditMode[];
+        readonly default: "hashline";
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Edit Mode";
+            readonly description: "Select the edit tool variant (replace, patch, hashline, or apply_patch)";
+        };
+    };
+    readonly "edit.fuzzyMatch": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Fuzzy Match";
+            readonly description: "Accept high-confidence fuzzy matches for whitespace differences";
+        };
+    };
+    readonly "edit.fuzzyThreshold": {
+        readonly type: "number";
+        readonly default: 0.95;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Fuzzy Match Threshold";
+            readonly description: "Similarity threshold for fuzzy matches";
+            readonly options: readonly [{
+                readonly value: "0.85";
+                readonly label: "0.85";
+                readonly description: "Lenient";
+            }, {
+                readonly value: "0.90";
+                readonly label: "0.90";
+                readonly description: "Moderate";
+            }, {
+                readonly value: "0.95";
+                readonly label: "0.95";
+                readonly description: "Default";
+            }, {
+                readonly value: "0.98";
+                readonly label: "0.98";
+                readonly description: "Strict";
+            }];
+        };
+    };
+    readonly "edit.streamingAbort": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Abort on Failed Preview";
+            readonly description: "Abort streaming edit tool calls when patch preview fails";
+        };
+    };
+    readonly "edit.blockAutoGenerated": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Block Auto-Generated Files";
+            readonly description: "Prevent editing of files that appear to be auto-generated (protoc, sqlc, swagger, etc.)";
+        };
+    };
+    readonly readLineNumbers: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Line Numbers";
+            readonly description: "Prepend line numbers to read tool output by default";
+        };
+    };
+    readonly readHashLines: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Hash Lines";
+            readonly description: "Include snapshot-tag headers and line numbers in read output for hashline edit mode ([PATH#TAG] plus LINE:content)";
+        };
+    };
+    readonly "read.defaultLimit": {
+        readonly type: "number";
+        readonly default: 300;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Default Read Limit";
+            readonly description: "Default number of lines returned when agent calls read without a limit";
+            readonly options: readonly [{
+                readonly value: "200";
+                readonly label: "200 lines";
+            }, {
+                readonly value: "300";
+                readonly label: "300 lines";
+            }, {
+                readonly value: "500";
+                readonly label: "500 lines";
+            }, {
+                readonly value: "1000";
+                readonly label: "1000 lines";
+            }, {
+                readonly value: "5000";
+                readonly label: "5000 lines";
+            }];
+        };
+    };
+    readonly "read.summarize.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Read Summaries";
+            readonly description: "Return structural code summaries when read is called without an explicit selector";
+        };
+    };
+    readonly "read.summarize.prose": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Prose Summaries";
+            readonly description: "Return structural summaries for Markdown and plain text reads";
+        };
+    };
+    readonly "read.summarize.minBodyLines": {
+        readonly type: "number";
+        readonly default: 4;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Read Summary Body Lines";
+            readonly description: "Minimum multiline body or literal length before read summaries collapse it";
+        };
+    };
+    readonly "read.summarize.minCommentLines": {
+        readonly type: "number";
+        readonly default: 6;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Read Summary Comment Lines";
+            readonly description: "Minimum multiline block comment length before read summaries collapse it";
+        };
+    };
+    readonly "read.summarize.minTotalLines": {
+        readonly type: "number";
+        readonly default: 100;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Read Summary Minimum File Length";
+            readonly description: "Files with fewer total lines are read verbatim instead of structurally summarized";
+        };
+    };
+    readonly "read.summarize.unfoldUntil": {
+        readonly type: "number";
+        readonly default: 50;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Read Summary Unfold Target";
+            readonly description: "BFS-unfold elidable spans until the summary is at least this many visible lines. 0 keeps only the outermost elisions.";
+        };
+    };
+    readonly "read.summarize.unfoldLimit": {
+        readonly type: "number";
+        readonly default: 100;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Read Summary Unfold Ceiling";
+            readonly description: "Hard ceiling on summary size while BFS-unfolding. An unfold that would exceed this is reverted and unfolding stops.";
+        };
+    };
+    readonly "read.toolResultPreview": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Inline Read Previews";
+            readonly description: "Render read tool results inline in the transcript instead of summary rows";
+        };
+    };
+    readonly "lsp.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "LSP";
+            readonly description: "Enable the lsp tool for language server protocol";
+        };
+    };
+    readonly "lsp.formatOnWrite": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Format on Write";
+            readonly description: "Automatically format code files using LSP after writing";
+        };
+    };
+    readonly "lsp.diagnosticsOnWrite": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Diagnostics on Write";
+            readonly description: "Return LSP diagnostics after writing code files";
+        };
+    };
+    readonly "lsp.diagnosticsOnEdit": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Diagnostics on Edit";
+            readonly description: "Return LSP diagnostics after editing code files";
+        };
+    };
+    readonly "lsp.diagnosticsDeduplicate": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Deduplicate Diagnostics";
+            readonly description: "Suppress post-edit LSP diagnostics already shown for a file; only surface new or changed ones";
+        };
+    };
+    readonly "bashInterceptor.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Bash Interceptor";
+            readonly description: "Block shell commands that have dedicated tools";
+        };
+    };
+    readonly "bashInterceptor.patterns": {
+        readonly type: "array";
+        readonly default: BashInterceptorRule[];
+    };
+    readonly "bash.stripTrailingHeadTail": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Strip Trailing head/tail";
+            readonly description: "Silently drop trailing `| head`/`| tail` pipes from single-line bash commands. Output is already truncated automatically.";
+        };
+    };
+    readonly "shellMinimizer.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Shell Minimizer";
+            readonly description: "Compress verbose shell output (git, npm, cargo, etc.) before returning it to the agent";
+        };
+    };
+    readonly "shellMinimizer.settingsPath": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "shellMinimizer.only": {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly "shellMinimizer.except": {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly "shellMinimizer.maxCaptureBytes": {
+        readonly type: "number";
+        readonly default: number;
+    };
+    readonly "eval.py": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Eval: Python backend";
+            readonly description: "Allow the eval tool to dispatch to the IPython kernel";
+        };
+    };
+    readonly "eval.js": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Eval: JavaScript backend";
+            readonly description: "Allow the eval tool to dispatch to the in-process JavaScript runtime";
+        };
+    };
+    readonly "python.kernelMode": {
+        readonly type: "enum";
+        readonly values: readonly ["session", "per-call"];
+        readonly default: "session";
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Python Kernel Mode";
+            readonly description: "Whether to keep IPython kernel alive across calls";
+        };
+    };
+    readonly "tools.approval": {
+        readonly type: "record";
+        readonly default: {};
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Tool Approval Policies";
+            readonly description: "Per-tool approval policies. Set to 'allow' to auto-approve, 'prompt' to require confirmation, or 'deny' to block. Overrides are honored in every approval mode.";
+        };
+    };
+    readonly "tools.approvalMode": {
+        readonly type: "enum";
+        readonly values: readonly ["always-ask", "write", "yolo"];
+        readonly default: "yolo";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Tool Approval";
+            readonly description: "Default approval behaviour for tool calls. 'Always ask' auto-approves read-only tools only. 'Write' auto-approves read and workspace-write tools. 'Yolo' auto-approves all tiers; user policy may still prompt or block.";
+            readonly options: readonly [{
+                readonly value: "always-ask";
+                readonly label: "Always ask";
+                readonly description: "Auto-approve read-only tools; require confirmation for write and exec tools.";
+            }, {
+                readonly value: "write";
+                readonly label: "Write";
+                readonly description: "Auto-approve read-only and write tools; require confirmation for exec tools such as bash, eval, browser, task, and ssh.";
+            }, {
+                readonly value: "yolo";
+                readonly label: "Yolo";
+                readonly description: "Auto-approve read, write, and exec tools. User policy can still require confirmation or block calls.";
+            }];
+        };
+    };
+    readonly "todo.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Todos";
+            readonly description: "Enable the todo tool for task tracking";
+        };
+    };
+    readonly "todo.reminders": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Todo Reminders";
+            readonly description: "Remind agent to complete todos before stopping";
+        };
+    };
+    readonly "todo.reminders.max": {
+        readonly type: "number";
+        readonly default: 3;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Todo Reminder Limit";
+            readonly description: "Maximum reminders to complete todos before giving up";
+            readonly options: readonly [{
+                readonly value: "1";
+                readonly label: "1 reminder";
+            }, {
+                readonly value: "2";
+                readonly label: "2 reminders";
+            }, {
+                readonly value: "3";
+                readonly label: "3 reminders";
+            }, {
+                readonly value: "5";
+                readonly label: "5 reminders";
+            }];
+        };
+    };
+    readonly "todo.eager": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Create Todos Automatically";
+            readonly description: "Automatically create a comprehensive todo list after the first message";
+        };
+    };
+    readonly "find.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Find";
+            readonly description: "Enable the find tool for file searching";
+        };
+    };
+    readonly "search.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Search";
+            readonly description: "Enable the search tool for content searching";
+        };
+    };
+    readonly "search.contextBefore": {
+        readonly type: "number";
+        readonly default: 1;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Search Context Before";
+            readonly description: "Lines of context before each search match";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "0 lines";
+            }, {
+                readonly value: "1";
+                readonly label: "1 line";
+            }, {
+                readonly value: "2";
+                readonly label: "2 lines";
+            }, {
+                readonly value: "3";
+                readonly label: "3 lines";
+            }, {
+                readonly value: "5";
+                readonly label: "5 lines";
+            }];
+        };
+    };
+    readonly "search.contextAfter": {
+        readonly type: "number";
+        readonly default: 3;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Search Context After";
+            readonly description: "Lines of context after each search match";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "0 lines";
+            }, {
+                readonly value: "1";
+                readonly label: "1 line";
+            }, {
+                readonly value: "2";
+                readonly label: "2 lines";
+            }, {
+                readonly value: "3";
+                readonly label: "3 lines";
+            }, {
+                readonly value: "5";
+                readonly label: "5 lines";
+            }, {
+                readonly value: "10";
+                readonly label: "10 lines";
+            }];
+        };
+    };
+    readonly "astGrep.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "AST Grep";
+            readonly description: "Enable the ast_grep tool for structural AST search";
+        };
+    };
+    readonly "astEdit.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "AST Edit";
+            readonly description: "Enable the ast_edit tool for structural AST rewrites";
+        };
+    };
+    readonly "irc.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "IRC";
+            readonly description: "Enable agent-to-agent IRC messaging via the irc tool";
+        };
+    };
+    readonly "irc.timeoutMs": {
+        readonly type: "number";
+        readonly default: 120000;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "IRC Timeout";
+            readonly description: "Drop IRC messages whose recipient does not respond within this many milliseconds (0 disables the timeout)";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "Disabled";
+            }, {
+                readonly value: "30000";
+                readonly label: "30 seconds";
+            }, {
+                readonly value: "60000";
+                readonly label: "1 minute";
+            }, {
+                readonly value: "120000";
+                readonly label: "2 minutes";
+            }, {
+                readonly value: "300000";
+                readonly label: "5 minutes";
+            }];
+        };
+    };
+    readonly "renderMermaid.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Render Mermaid";
+            readonly description: "Enable the render_mermaid tool for Mermaid-to-ASCII rendering";
+        };
+    };
+    readonly "debug.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Debug";
+            readonly description: "Enable the debug tool for DAP-based debugging";
+        };
+    };
+    readonly "tts.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Text-to-Speech";
+            readonly description: "Enable the tts tool for xAI Grok Voice speech synthesis";
+        };
+    };
+    readonly "inspect_image.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Inspect Image";
+            readonly description: "Enable the inspect_image tool, delegating image understanding to a vision-capable model";
+        };
+    };
+    readonly "checkpoint.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Checkpoint/Rewind";
+            readonly description: "Enable the checkpoint and rewind tools for context checkpointing";
+        };
+    };
+    readonly "fetch.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Read URLs";
+            readonly description: "Allow the read tool to fetch and process URLs";
+        };
+    };
+    readonly "vault.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Obsidian Vault";
+            readonly description: "Enable the vault:// internal URL for reading and editing Obsidian vault content via the Obsidian CLI. When disabled, vault:// resolution is refused and the vault:// entry is omitted from the system prompt.";
+        };
+    };
+    readonly "github.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "GitHub CLI";
+            readonly description: "Enable the github tool (op-based dispatch for repository, issue, pull request, diff, search, checkout, push, and Actions watch workflows)";
+        };
+    };
+    readonly "github.cache.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "GitHub view cache";
+            readonly description: "Cache rendered issue/PR view output in ~/.prometheus/cache/github-cache.db so repeated reads are free";
+        };
+    };
+    readonly "github.cache.softTtlSec": {
+        readonly type: "number";
+        readonly default: 300;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "GitHub cache soft TTL (seconds)";
+            readonly description: "Within this window, cached issue/PR view rows are returned directly. Default 5 minutes.";
+        };
+    };
+    readonly "github.cache.hardTtlSec": {
+        readonly type: "number";
+        readonly default: 604800;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "GitHub cache hard TTL (seconds)";
+            readonly description: "Past soft TTL but within hard TTL, the tool returns the cached row and refreshes it in the background. Past hard TTL, the row is dropped. Default 7 days.";
+        };
+    };
+    readonly "web_search.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Web Search";
+            readonly description: "Enable the web_search tool for web searching";
+        };
+    };
+    readonly "browser.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Browser";
+            readonly description: "Enable the browser tool (Ulixee Hero)";
+        };
+    };
+    readonly "browser.headless": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Headless Browser";
+            readonly description: "Launch browser in headless mode (disable to show browser UI)";
+        };
+    };
+    readonly "browser.screenshotDir": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Screenshot directory";
+            readonly description: "Directory to save screenshots. If unset, screenshots go to a temp file. Supports ~. Examples: ~/Downloads, ~/Desktop, /sdcard/Download (Android)";
+        };
+    };
+    readonly "tools.intentTracing": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Intent Tracing";
+            readonly description: "Ask the agent to describe the intent of each tool call before executing it";
+        };
+    };
+    readonly "tools.maxTimeout": {
+        readonly type: "number";
+        readonly default: 0;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Max Tool Timeout";
+            readonly description: "Maximum timeout in seconds the agent can set for any tool (0 = no limit)";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "No limit";
+            }, {
+                readonly value: "30";
+                readonly label: "30 seconds";
+            }, {
+                readonly value: "60";
+                readonly label: "60 seconds";
+            }, {
+                readonly value: "120";
+                readonly label: "120 seconds";
+            }, {
+                readonly value: "300";
+                readonly label: "5 minutes";
+            }, {
+                readonly value: "600";
+                readonly label: "10 minutes";
+            }];
+        };
+    };
+    readonly "async.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Async Execution";
+            readonly description: "Enable async bash commands and background task execution";
+        };
+    };
+    readonly "async.maxJobs": {
+        readonly type: "number";
+        readonly default: 100;
+    };
+    readonly "async.pollWaitDuration": {
+        readonly type: "enum";
+        readonly values: readonly ["5s", "10s", "30s", "1m", "5m"];
+        readonly default: "30s";
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Poll Wait Duration";
+            readonly description: "How long the poll tool waits for background job updates before returning the current state";
+            readonly options: readonly [{
+                readonly value: "5s";
+                readonly label: "5 seconds";
+            }, {
+                readonly value: "10s";
+                readonly label: "10 seconds";
+            }, {
+                readonly value: "30s";
+                readonly label: "30 seconds";
+                readonly description: "Default";
+            }, {
+                readonly value: "1m";
+                readonly label: "1 minute";
+            }, {
+                readonly value: "5m";
+                readonly label: "5 minutes";
+            }];
+        };
+    };
+    readonly "bash.autoBackground.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Bash Auto-Background";
+            readonly description: "Automatically background long-running bash commands and deliver the result later";
+        };
+    };
+    readonly "bash.autoBackground.thresholdMs": {
+        readonly type: "number";
+        readonly default: 60000;
+    };
+    readonly "tools.discoveryMode": {
+        readonly type: "enum";
+        readonly values: readonly ["auto", "off", "mcp-only", "all"];
+        readonly default: "auto";
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Tool Discovery";
+            readonly description: "Hide tools behind a search tool to save tokens. 'auto' hides MCP tools once the tool set has more than 40 tools; 'mcp-only' always hides MCP tools; 'all' hides all non-essential built-ins too.";
+        };
+    };
+    readonly "tools.essentialOverride": {
+        readonly type: "array";
+        readonly default: string[];
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Essential Tools Override";
+            readonly description: "Override the always-loaded built-in tools (default: read, bash, edit). Leave empty to use defaults.";
+        };
+    };
+    readonly "mcp.enableProjectConfig": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "MCP Project Config";
+            readonly description: "Load .mcp.json/mcp.json from project root";
+        };
+    };
+    readonly "mcp.discoveryMode": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "MCP Tool Discovery";
+            readonly description: "Hide MCP tools by default and expose them through a tool discovery tool";
+        };
+    };
+    readonly "mcp.discoveryDefaultServers": {
+        readonly type: "array";
+        readonly default: string[];
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "MCP Discovery Default Servers";
+            readonly description: "Keep MCP tools from these servers visible while discovery mode hides other MCP tools";
+        };
+    };
+    readonly "mcp.notifications": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "MCP Update Injection";
+            readonly description: "Inject MCP resource updates into the agent conversation";
+        };
+    };
+    readonly "mcp.notificationDebounceMs": {
+        readonly type: "number";
+        readonly default: 500;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "MCP Notification Debounce";
+            readonly description: "Debounce window for MCP resource update notifications before injecting into conversation";
+        };
+    };
+    readonly "plan.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Plan Mode";
+            readonly description: "Enable plan mode for read-only exploration and planning before execution";
+        };
+    };
+    readonly "goal.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Goal Mode";
+            readonly description: "Enable per-session goal mode and the hidden goal tool";
+        };
+    };
+    readonly "goal.statusInFooter": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Goal Status In Footer";
+            readonly description: "Show token budget alongside the goal indicator in the status line";
+        };
+    };
+    readonly "goal.continuationModes": {
+        readonly type: "array";
+        readonly default: readonly ["interactive"];
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Goal Continuation Modes";
+            readonly description: "Run modes where active goals may auto-continue between turns";
+        };
+    };
+    readonly "task.isolation.mode": {
+        readonly type: "enum";
+        readonly values: readonly ["none", "auto", "apfs", "btrfs", "zfs", "reflink", "overlayfs", "projfs", "block-clone", "rcopy"];
+        readonly default: "none";
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Isolation Mode";
+            readonly description: 'Isolation backend for subagents. "auto" lets the native PAL pick the best available backend (CoW-aware filesystems, then overlayfs/ProjFS, then a git worktree / recursive-copy fallback).';
+            readonly options: readonly [{
+                readonly value: "none";
+                readonly label: "None";
+                readonly description: "No isolation";
+            }, {
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Let the PAL pick the best available backend";
+            }, {
+                readonly value: "apfs";
+                readonly label: "APFS";
+                readonly description: "macOS clonefile reflink (APFS)";
+            }, {
+                readonly value: "btrfs";
+                readonly label: "btrfs";
+                readonly description: "btrfs subvolume snapshot";
+            }, {
+                readonly value: "zfs";
+                readonly label: "ZFS";
+                readonly description: "ZFS snapshot + clone";
+            }, {
+                readonly value: "reflink";
+                readonly label: "Reflink";
+                readonly description: "Linux FICLONE per-file reflink";
+            }, {
+                readonly value: "overlayfs";
+                readonly label: "Overlayfs";
+                readonly description: "Linux kernel overlay (or fuse-overlayfs fallback)";
+            }, {
+                readonly value: "projfs";
+                readonly label: "ProjFS";
+                readonly description: "Windows Projected File System";
+            }, {
+                readonly value: "block-clone";
+                readonly label: "Block clone";
+                readonly description: "Windows FSCTL_DUPLICATE_EXTENTS_TO_FILE (NTFS/ReFS)";
+            }, {
+                readonly value: "rcopy";
+                readonly label: "Recursive copy";
+                readonly description: "git worktree if available, otherwise recursive copy";
+            }];
+        };
+    };
+    readonly "task.isolation.merge": {
+        readonly type: "enum";
+        readonly values: readonly ["patch", "branch"];
+        readonly default: "patch";
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Isolation Merge Strategy";
+            readonly description: "How isolated task changes are integrated (patch apply or branch merge)";
+            readonly options: readonly [{
+                readonly value: "patch";
+                readonly label: "Patch";
+                readonly description: "Combine diffs and git apply";
+            }, {
+                readonly value: "branch";
+                readonly label: "Branch";
+                readonly description: "Commit per task, merge with --no-ff";
+            }];
+        };
+    };
+    readonly "task.isolation.commits": {
+        readonly type: "enum";
+        readonly values: readonly ["generic", "ai"];
+        readonly default: "generic";
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Isolation Commit Style";
+            readonly description: "Commit message style for nested repo changes (generic or AI-generated)";
+            readonly options: readonly [{
+                readonly value: "generic";
+                readonly label: "Generic";
+                readonly description: "Static commit message";
+            }, {
+                readonly value: "ai";
+                readonly label: "AI";
+                readonly description: "AI-generated commit message from diff";
+            }];
+        };
+    };
+    readonly "task.eager": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Prefer Task Delegation";
+            readonly description: "Encourage the agent to delegate work to subagents unless changes are trivial";
+        };
+    };
+    readonly "task.simple": {
+        readonly type: "enum";
+        readonly values: readonly ["default", "schema-free", "independent"];
+        readonly default: "schema-free";
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Task Input Mode";
+            readonly description: "How much shared structure the task tool accepts (default, schema-free, or independent)";
+            readonly options: readonly [{
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "Shared context and custom task schema are available";
+            }, {
+                readonly value: "schema-free";
+                readonly label: "Schema-free";
+                readonly description: "Shared context stays available, but custom task schema is disabled";
+            }, {
+                readonly value: "independent";
+                readonly label: "Independent";
+                readonly description: "No shared context or custom task schema; each task must stand alone";
+            }];
+        };
+    };
+    readonly "task.maxConcurrency": {
+        readonly type: "number";
+        readonly default: 32;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Max Concurrent Tasks";
+            readonly description: "Concurrent limit for subagents";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "Unlimited";
+            }, {
+                readonly value: "1";
+                readonly label: "1 task";
+            }, {
+                readonly value: "2";
+                readonly label: "2 tasks";
+            }, {
+                readonly value: "4";
+                readonly label: "4 tasks";
+            }, {
+                readonly value: "8";
+                readonly label: "8 tasks";
+            }, {
+                readonly value: "16";
+                readonly label: "16 tasks";
+            }, {
+                readonly value: "32";
+                readonly label: "32 tasks";
+            }, {
+                readonly value: "64";
+                readonly label: "64 tasks";
+            }];
+        };
+    };
+    readonly "task.enableLsp": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "LSP in Subagents";
+            readonly description: "Allow subagents spawned via the task tool to use the lsp tool. Off by default to keep subagents cheap; enable when LSP-aware delegation is worth the extra tokens.";
+        };
+    };
+    readonly "task.maxRecursionDepth": {
+        readonly type: "number";
+        readonly default: 2;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Max Task Recursion";
+            readonly description: "How many levels deep subagents can spawn their own subagents";
+            readonly options: readonly [{
+                readonly value: "-1";
+                readonly label: "Unlimited";
+            }, {
+                readonly value: "0";
+                readonly label: "None";
+            }, {
+                readonly value: "1";
+                readonly label: "Single";
+            }, {
+                readonly value: "2";
+                readonly label: "Double";
+            }, {
+                readonly value: "3";
+                readonly label: "Triple";
+            }];
+        };
+    };
+    readonly "task.maxRuntimeMs": {
+        readonly type: "number";
+        readonly default: 0;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Max Subagent Runtime";
+            readonly description: "Hard wall-clock limit per subagent (ms). 0 disables it. Defense-in-depth against provider-side stream hangs that escape the inference-layer watchdog; triggers a normal subagent abort with a 'timed out' reason.";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "Unlimited";
+                readonly description: "Default";
+            }, {
+                readonly value: "300000";
+                readonly label: "5 minutes";
+            }, {
+                readonly value: "900000";
+                readonly label: "15 minutes";
+            }, {
+                readonly value: "1800000";
+                readonly label: "30 minutes";
+            }, {
+                readonly value: "3600000";
+                readonly label: "1 hour";
+            }];
+        };
+    };
+    readonly "task.disabledAgents": {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly "task.agentModelOverrides": {
+        readonly type: "record";
+        readonly default: Record<string, string>;
+    };
+    readonly "tasks.todoClearDelay": {
+        readonly type: "number";
+        readonly default: 60;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Todo auto-clear delay";
+            readonly description: "How long to wait before removing completed/abandoned tasks from the list";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "Instant";
+            }, {
+                readonly value: "60";
+                readonly label: "1 minute";
+                readonly description: "Default";
+            }, {
+                readonly value: "300";
+                readonly label: "5 minutes";
+            }, {
+                readonly value: "900";
+                readonly label: "15 minutes";
+            }, {
+                readonly value: "1800";
+                readonly label: "30 minutes";
+            }, {
+                readonly value: "3600";
+                readonly label: "1 hour";
+            }, {
+                readonly value: "-1";
+                readonly label: "Never";
+            }];
+        };
+    };
+    readonly "task.showResolvedModelBadge": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly label: "Show Resolved Model Badge";
+            readonly description: "Display the actual model ID used by each subagent in the task widget status line";
+        };
+    };
+    readonly "skills.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "skills.enableSkillCommands": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Skill Commands";
+            readonly description: "Register skills as /skill:name commands";
+        };
+    };
+    readonly "skills.enableCodexUser": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "skills.enableClaudeUser": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "skills.enableClaudeProject": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "skills.enablePrometheusUser": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "skills.enablePrometheusProject": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "skills.customDirectories": {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly "skills.ignoredSkills": {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly "skills.includeSkills": {
+        readonly type: "array";
+        readonly default: string[];
+    };
+    readonly "commands.enableClaudeUser": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Claude User Commands";
+            readonly description: "Load commands from ~/.claude/commands/";
+        };
+    };
+    readonly "commands.enableClaudeProject": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Claude Project Commands";
+            readonly description: "Load commands from .claude/commands/";
+        };
+    };
+    readonly "commands.enableOpencodeUser": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "OpenCode User Commands";
+            readonly description: "Load commands from ~/.config/opencode/commands/";
+        };
+    };
+    readonly "commands.enableOpencodeProject": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "OpenCode Project Commands";
+            readonly description: "Load commands from .opencode/commands/";
+        };
+    };
+    readonly "secrets.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Hide Secrets";
+            readonly description: "Obfuscate secrets before sending to AI providers";
+        };
+    };
+    readonly "providers.webSearch": {
+        readonly type: "enum";
+        readonly values: readonly ["auto", "tavily", "perplexity", "brave", "jina", "kimi", "anthropic", "gemini", "codex", "zai", "exa", "parallel", "kagi", "synthetic", "searxng"];
+        readonly default: "auto";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Web Search Provider";
+            readonly description: "Provider for web search tool";
+            readonly options: readonly [{
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Automatically uses the first configured web-search provider";
+            }, {
+                readonly value: "tavily";
+                readonly label: "Tavily";
+                readonly description: "Requires TAVILY_API_KEY";
+            }, {
+                readonly value: "perplexity";
+                readonly label: "Perplexity";
+                readonly description: "Requires PERPLEXITY_COOKIES or PERPLEXITY_API_KEY";
+            }, {
+                readonly value: "brave";
+                readonly label: "Brave";
+                readonly description: "Requires BRAVE_API_KEY";
+            }, {
+                readonly value: "jina";
+                readonly label: "Jina";
+                readonly description: "Requires JINA_API_KEY";
+            }, {
+                readonly value: "kimi";
+                readonly label: "Kimi";
+                readonly description: "Requires MOONSHOT_SEARCH_API_KEY or MOONSHOT_API_KEY";
+            }, {
+                readonly value: "anthropic";
+                readonly label: "Anthropic";
+                readonly description: "Claude's native web_search tool (uses Anthropic OAuth or ANTHROPIC_API_KEY)";
+            }, {
+                readonly value: "gemini";
+                readonly label: "Gemini";
+                readonly description: "Google Search grounding via Gemini (uses google-gemini-cli or google-antigravity OAuth)";
+            }, {
+                readonly value: "codex";
+                readonly label: "OpenAI";
+                readonly description: "OpenAI's native web_search (uses ChatGPT OAuth via /login openai-codex)";
+            }, {
+                readonly value: "zai";
+                readonly label: "Z.AI";
+                readonly description: "Calls Z.AI webSearchPrime MCP";
+            }, {
+                readonly value: "exa";
+                readonly label: "Exa";
+                readonly description: "Uses Exa API when EXA_API_KEY is set; falls back to Exa MCP";
+            }, {
+                readonly value: "parallel";
+                readonly label: "Parallel";
+                readonly description: "Requires PARALLEL_API_KEY";
+            }, {
+                readonly value: "kagi";
+                readonly label: "Kagi";
+                readonly description: "Requires KAGI_API_KEY and Kagi Search API beta access";
+            }, {
+                readonly value: "synthetic";
+                readonly label: "Synthetic";
+                readonly description: "Requires SYNTHETIC_API_KEY";
+            }, {
+                readonly value: "searxng";
+                readonly label: "SearXNG";
+                readonly description: "Requires SEARXNG_ENDPOINT or searxng.endpoint";
+            }];
+        };
+    };
+    readonly "providers.image": {
+        readonly type: "enum";
+        readonly values: readonly ["auto", "openai", "antigravity", "xai", "gemini", "openrouter"];
+        readonly default: "auto";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Image Provider";
+            readonly description: "Provider for image generation tool";
+            readonly options: readonly [{
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Priority: GPT model image tool > Antigravity > xAI > OpenRouter > Gemini";
+            }, {
+                readonly value: "openai";
+                readonly label: "OpenAI";
+                readonly description: "Uses the active GPT Responses/Codex model";
+            }, {
+                readonly value: "antigravity";
+                readonly label: "Antigravity";
+                readonly description: "Requires google-antigravity OAuth";
+            }, {
+                readonly value: "xai";
+                readonly label: "xAI Grok Imagine";
+                readonly description: "Requires xAI Grok OAuth or XAI_API_KEY";
+            }, {
+                readonly value: "gemini";
+                readonly label: "Gemini";
+                readonly description: "Requires GEMINI_API_KEY";
+            }, {
+                readonly value: "openrouter";
+                readonly label: "OpenRouter";
+                readonly description: "Requires OPENROUTER_API_KEY";
+            }];
+        };
+    };
+    readonly "providers.tinyModel": {
+        readonly type: "enum";
+        readonly values: readonly ["online", "lfm2-350m", "qwen3-0.6b", "gemma-270m", "qwen2.5-0.5b", "lfm2-700m"];
+        readonly default: "online";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Tiny Model";
+            readonly description: "Session-title model: online prometheus/smol by default, or a local on-device model";
+            readonly options: ({
+                value: "online";
+                label: string;
+                description: string;
+            } | {
+                value: "gemma-270m" | "lfm2-350m" | "lfm2-700m" | "qwen2.5-0.5b" | "qwen3-0.6b";
+                label: "Gemma 270M" | "LFM2 350M" | "LFM2 700M" | "Qwen2.5 0.5B" | "Qwen3 0.6B";
+                description: "Balanced local fallback; moderate quality and cache footprint." | "Highest-quality local option; larger and slower than LFM2 350M." | "Most robust local option; slower first load, about 500 MB cached." | "Recommended local model; best speed/quality balance, about 212 MB cached." | "Smallest viable local option; lower quality, lowest cache footprint.";
+            })[];
+        };
+    };
+    readonly "providers.tinyModelDevice": {
+        readonly type: "enum";
+        readonly values: readonly ["default", "gpu", "cpu", "metal", "webgpu", "cuda", "dml", "coreml", "auto", "wasm", "webnn", "webnn-gpu", "webnn-cpu", "webnn-npu"];
+        readonly default: "default";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Tiny Model Device";
+            readonly description: "ONNX execution provider for local tiny models (titles + memory). Default uses CPU-only inference. The PROMETHEUS_TINY_DEVICE env var overrides this.";
+            readonly options: readonly [{
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "CPU-only inference";
+            }, {
+                readonly value: "gpu";
+                readonly label: "GPU";
+                readonly description: "Accelerated provider (WebGPU/Metal, CUDA, or DirectML)";
+            }, {
+                readonly value: "cpu";
+                readonly label: "CPU";
+                readonly description: "CPU-only inference";
+            }, {
+                readonly value: "metal";
+                readonly label: "Metal";
+                readonly description: "WebGPU alias for Apple GPUs";
+            }, {
+                readonly value: "webgpu";
+                readonly label: "WebGPU";
+                readonly description: "WebGPU/Metal backend";
+            }, {
+                readonly value: "cuda";
+                readonly label: "CUDA";
+                readonly description: "NVIDIA CUDA (Linux x64)";
+            }, {
+                readonly value: "dml";
+                readonly label: "DirectML";
+                readonly description: "DirectML backend (Windows)";
+            }, {
+                readonly value: "coreml";
+                readonly label: "CoreML";
+                readonly description: "Apple CoreML (opt-in; can fail to load)";
+            }, {
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Let ONNX Runtime choose a provider";
+            }, {
+                readonly value: "wasm";
+                readonly label: "WASM";
+                readonly description: "WebAssembly backend";
+            }, {
+                readonly value: "webnn";
+                readonly label: "WebNN";
+                readonly description: "WebNN backend";
+            }, {
+                readonly value: "webnn-gpu";
+                readonly label: "WebNN GPU";
+                readonly description: "WebNN GPU device";
+            }, {
+                readonly value: "webnn-cpu";
+                readonly label: "WebNN CPU";
+                readonly description: "WebNN CPU device";
+            }, {
+                readonly value: "webnn-npu";
+                readonly label: "WebNN NPU";
+                readonly description: "WebNN NPU device";
+            }];
+        };
+    };
+    readonly "providers.tinyModelDtype": {
+        readonly type: "enum";
+        readonly values: readonly ["default", "q4", "q4f16", "q8", "fp16", "fp32", "int8", "uint8", "bnb4", "q2", "q2f16", "q1", "q1f16", "auto"];
+        readonly default: "default";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Tiny Model Precision";
+            readonly description: "ONNX quantization/precision for local tiny models. Default uses each model's shipped dtype (q4); lower precision is faster, higher is more faithful. The PROMETHEUS_TINY_DTYPE env var overrides this.";
+            readonly options: readonly [{
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "Each model's shipped dtype (currently q4)";
+            }, {
+                readonly value: "q4";
+                readonly label: "q4";
+                readonly description: "4-bit weights; smallest and fastest";
+            }, {
+                readonly value: "q4f16";
+                readonly label: "q4f16";
+                readonly description: "4-bit weights with fp16 activations";
+            }, {
+                readonly value: "q8";
+                readonly label: "q8";
+                readonly description: "8-bit quantization";
+            }, {
+                readonly value: "fp16";
+                readonly label: "fp16";
+                readonly description: "16-bit float; higher fidelity, larger";
+            }, {
+                readonly value: "fp32";
+                readonly label: "fp32";
+                readonly description: "Full precision; largest and slowest";
+            }, {
+                readonly value: "int8";
+                readonly label: "int8";
+                readonly description: "Signed 8-bit integer";
+            }, {
+                readonly value: "uint8";
+                readonly label: "uint8";
+                readonly description: "Unsigned 8-bit integer";
+            }, {
+                readonly value: "bnb4";
+                readonly label: "bnb4";
+                readonly description: "bitsandbytes 4-bit";
+            }, {
+                readonly value: "q2";
+                readonly label: "q2";
+                readonly description: "2-bit weights";
+            }, {
+                readonly value: "q2f16";
+                readonly label: "q2f16";
+                readonly description: "2-bit weights with fp16 activations";
+            }, {
+                readonly value: "q1";
+                readonly label: "q1";
+                readonly description: "1-bit weights";
+            }, {
+                readonly value: "q1f16";
+                readonly label: "q1f16";
+                readonly description: "1-bit weights with fp16 activations";
+            }, {
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Let transformers.js choose per device";
+            }];
+        };
+    };
+    readonly "providers.memoryModel": {
+        readonly type: "enum";
+        readonly values: readonly ["online", "qwen3-1.7b", "gemma-3-1b", "qwen2.5-1.5b", "lfm2-1.2b"];
+        readonly default: "online";
+        readonly ui: {
+            readonly tab: "memory";
+            readonly label: "Memory Model";
+            readonly description: "Prometheus Memory LLM for fact extraction + consolidation: online (smol/remote) by default, or a local on-device model";
+            readonly condition: "prometheusMemoryActive";
+            readonly options: ({
+                value: "online";
+                label: string;
+                description: string;
+            } | {
+                value: "gemma-3-1b" | "lfm2-1.2b" | "qwen2.5-1.5b" | "qwen3-1.7b";
+                label: "Gemma 3 1B" | "LFM2 1.2B" | "Qwen2.5 1.5B" | "Qwen3 1.7B";
+                description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction." | "Best extraction granularity (atomic facts); weaker consolidation." | "Fastest load; solid all-rounder, slightly noisier extraction labels." | "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
+            })[];
+        };
+    };
+    readonly "providers.autoThinkingModel": {
+        readonly type: "enum";
+        readonly values: readonly ["online", "qwen3-1.7b", "gemma-3-1b", "qwen2.5-1.5b", "lfm2-1.2b"];
+        readonly default: "online";
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Auto Thinking Model";
+            readonly description: "Difficulty classifier for the `auto` thinking level: online smol by default, or a local on-device model";
+            readonly condition: "autoThinkingActive";
+            readonly options: ({
+                value: "online";
+                label: string;
+                description: string;
+            } | {
+                value: "gemma-3-1b" | "lfm2-1.2b" | "qwen2.5-1.5b" | "qwen3-1.7b";
+                label: "Gemma 3 1B" | "LFM2 1.2B" | "Qwen2.5 1.5B" | "Qwen3 1.7B";
+                description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction." | "Best extraction granularity (atomic facts); weaker consolidation." | "Fastest load; solid all-rounder, slightly noisier extraction labels." | "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
+            })[];
+        };
+    };
+    readonly "providers.kimiApiFormat": {
+        readonly type: "enum";
+        readonly values: readonly ["openai", "anthropic"];
+        readonly default: "anthropic";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Kimi API Format";
+            readonly description: "API format for Kimi Code provider";
+            readonly options: readonly [{
+                readonly value: "openai";
+                readonly label: "OpenAI";
+                readonly description: "api.kimi.com";
+            }, {
+                readonly value: "anthropic";
+                readonly label: "Anthropic";
+                readonly description: "api.moonshot.ai";
+            }];
+        };
+    };
+    readonly "providers.openaiWebsockets": {
+        readonly type: "enum";
+        readonly values: readonly ["auto", "off", "on"];
+        readonly default: "auto";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "OpenAI WebSockets";
+            readonly description: "Websocket policy for OpenAI Codex models (auto uses model defaults, on forces, off disables)";
+            readonly options: readonly [{
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Use model/provider default websocket behavior";
+            }, {
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Disable websockets for OpenAI Codex models";
+            }, {
+                readonly value: "on";
+                readonly label: "On";
+                readonly description: "Force websockets for OpenAI Codex models";
+            }];
+        };
+    };
+    readonly "providers.openrouterVariant": {
+        readonly type: "enum";
+        readonly values: readonly ["default", "nitro", "floor", "online", "exacto"];
+        readonly default: "default";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "OpenRouter Routing";
+            readonly description: "Default routing-variant suffix appended to OpenRouter model IDs (overridden when the selector already names a variant)";
+            readonly options: readonly [{
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "No suffix; use OpenRouter's default routing";
+            }, {
+                readonly value: "nitro";
+                readonly label: ":nitro";
+                readonly description: "Prioritize throughput / lowest latency";
+            }, {
+                readonly value: "floor";
+                readonly label: ":floor";
+                readonly description: "Prioritize cheapest available provider";
+            }, {
+                readonly value: "online";
+                readonly label: ":online";
+                readonly description: "Enable OpenRouter's web-search plugin";
+            }, {
+                readonly value: "exacto";
+                readonly label: ":exacto";
+                readonly description: "Cherry-picked high-quality providers (only defined for select models)";
+            }];
+        };
+    };
+    readonly "providers.parallelFetch": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Parallel Fetch";
+            readonly description: "Use Parallel extract API for URL fetching when credentials are available";
+        };
+    };
+    readonly "provider.appendOnlyContext": {
+        readonly type: "enum";
+        readonly values: readonly ["auto", "on", "off"];
+        readonly default: "auto";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Append-Only Context";
+            readonly description: "Cache system prompt + tool specs and keep an append-only message log so provider prefix caches (DeepSeek, Xiaomi/SGLang, Anthropic) hit at maximum rate. Auto enables for known prefix-cache providers.";
+            readonly options: readonly [{
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Enable for known prefix-cache providers (recommended)";
+            }, {
+                readonly value: "on";
+                readonly label: "On";
+                readonly description: "Always enable append-only context";
+            }, {
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Disable append-only context";
+            }];
+        };
+    };
+    readonly "exa.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Exa";
+            readonly description: "Master toggle for all Exa search tools";
+        };
+    };
+    readonly "exa.enableSearch": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Exa Search";
+            readonly description: "Basic search, deep search, code search, crawl";
+        };
+    };
+    readonly "exa.enableResearcher": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Exa Researcher";
+            readonly description: "AI-powered deep research tasks";
+        };
+    };
+    readonly "exa.enableWebsets": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "Exa Websets";
+            readonly description: "Webset management and enrichment tools";
+        };
+    };
+    readonly "searxng.endpoint": {
+        readonly type: "string";
+        readonly default: undefined;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly label: "SearXNG Endpoint";
+            readonly description: "Self-hosted search base URL";
+        };
+    };
+    readonly "searxng.token": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "searxng.basicUsername": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "searxng.basicPassword": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "searxng.categories": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "searxng.language": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "commit.mapReduceEnabled": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "commit.mapReduceMinFiles": {
+        readonly type: "number";
+        readonly default: 4;
+    };
+    readonly "commit.mapReduceMaxFileTokens": {
+        readonly type: "number";
+        readonly default: 50000;
+    };
+    readonly "commit.mapReduceTimeoutMs": {
+        readonly type: "number";
+        readonly default: 120000;
+    };
+    readonly "commit.mapReduceMaxConcurrency": {
+        readonly type: "number";
+        readonly default: 5;
+    };
+    readonly "commit.changelogMaxDiffChars": {
+        readonly type: "number";
+        readonly default: 120000;
+    };
+    readonly "dev.autoqa": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Auto QA";
+            readonly description: "Enable automated tool issue reporting (report_tool_issue) for all agents";
+        };
+    };
+    readonly "dev.autoqaPush.endpoint": {
+        readonly type: "string";
+        readonly default: "https://qa.prometheus.trivlab.com/v1/grievances";
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Auto QA Push Endpoint";
+            readonly description: "Full URL that receives the JSON payload (default ships to https://qa.prometheus.trivlab.com/v1/grievances)";
+        };
+    };
+    readonly "dev.autoqaPush.token": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    /**
+     * User decision on sharing automatic `report_tool_issue` grievances.
+     *
+     *   - `"unset"`  — never asked; the first `report_tool_issue` invocation
+     *                  pops a consent dialog and persists the answer here.
+     *   - `"granted"` — record and (when push is configured) ship grievances.
+     *   - `"denied"`  — silently no-op every `report_tool_issue` call.
+     *
+     * Owned by `packages/coding-agent/src/tools/report-tool-issue.ts` via the
+     * process-global consent handler registered by `InteractiveMode`.
+     */
+    readonly "dev.autoqa.consent": {
+        readonly type: "enum";
+        readonly values: readonly ["unset", "granted", "denied"];
+        readonly default: "unset";
+    };
+    readonly "thinkingBudgets.minimal": {
+        readonly type: "number";
+        readonly default: 1024;
+    };
+    readonly "thinkingBudgets.low": {
+        readonly type: "number";
+        readonly default: 2048;
+    };
+    readonly "thinkingBudgets.medium": {
+        readonly type: "number";
+        readonly default: 8192;
+    };
+    readonly "thinkingBudgets.high": {
+        readonly type: "number";
+        readonly default: 16384;
+    };
+    readonly "thinkingBudgets.xhigh": {
+        readonly type: "number";
+        readonly default: 32768;
+    };
+};
+type Schema = typeof SETTINGS_SCHEMA;
+/** All valid setting paths */
+export type SettingPath = keyof Schema;
+/** Infer the value type for a setting path */
+export type SettingValue<P extends SettingPath> = Schema[P] extends {
+    type: "boolean";
+} ? boolean : Schema[P] extends {
+    type: "string";
+} ? string | undefined : Schema[P] extends {
+    type: "number";
+} ? number : Schema[P] extends {
+    type: "enum";
+    values: infer V;
+} ? V extends readonly string[] ? V[number] : never : Schema[P] extends {
+    type: "array";
+    default: infer D;
+} ? D : Schema[P] extends {
+    type: "record";
+    default: infer D;
+} ? D : never;
+/** Get the default value for a setting path */
+export declare function getDefault<P extends SettingPath>(path: P): SettingValue<P>;
+/** Check if a path has UI metadata (should appear in settings panel) */
+export declare function hasUi(path: SettingPath): boolean;
+/** Get UI metadata for a path (undefined if no UI) */
+export declare function getUi(path: SettingPath): AnyUiMetadata | undefined;
+/** Get all paths for a specific tab */
+export declare function getPathsForTab(tab: SettingTab): SettingPath[];
+/** Get the type of a setting */
+export declare function getType(path: SettingPath): SettingDef["type"];
+/** Get enum values for an enum setting */
+export declare function getEnumValues(path: SettingPath): readonly string[] | undefined;
+/** Status line preset - derived from schema */
+export type StatusLinePreset = SettingValue<"statusLine.preset">;
+/** Status line separator style - derived from schema */
+export type StatusLineSeparatorStyle = SettingValue<"statusLine.separator">;
+/** Tree selector filter mode - derived from schema */
+export type TreeFilterMode = SettingValue<"treeFilterMode">;
+export interface CompactionSettings {
+    enabled: boolean;
+    strategy: "context-full" | "handoff" | "shake" | "off";
+    thresholdPercent: number;
+    thresholdTokens: number;
+    reserveTokens: number;
+    keepRecentTokens: number;
+    handoffSaveToDisk: boolean;
+    autoContinue: boolean;
+    remoteEnabled: boolean;
+    remoteEndpoint: string | undefined;
+    idleEnabled: boolean;
+    idleThresholdTokens: number;
+    idleTimeoutSeconds: number;
+}
+export interface ContextPromotionSettings {
+    enabled: boolean;
+}
+export interface RetrySettings {
+    enabled: boolean;
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    modelFallback: boolean;
+}
+export interface MemoriesSettings {
+    enabled: boolean;
+    maxRolloutsPerStartup: number;
+    maxRolloutAgeDays: number;
+    minRolloutIdleHours: number;
+    threadScanLimit: number;
+    maxRawMemoriesForGlobal: number;
+    stage1Concurrency: number;
+    stage1LeaseSeconds: number;
+    stage1RetryDelaySeconds: number;
+    phase2LeaseSeconds: number;
+    phase2RetryDelaySeconds: number;
+    phase2HeartbeatSeconds: number;
+    rolloutPayloadPercent: number;
+    fallbackTokenLimit: number;
+    summaryInjectionTokenLimit: number;
+}
+export interface TodoCompletionSettings {
+    enabled: boolean;
+    maxReminders: number;
+}
+export interface BranchSummarySettings {
+    enabled: boolean;
+    reserveTokens: number;
+}
+export interface SkillsSettings {
+    enabled?: boolean;
+    enableSkillCommands?: boolean;
+    enableCodexUser?: boolean;
+    enableClaudeUser?: boolean;
+    enableClaudeProject?: boolean;
+    enablePrometheusUser?: boolean;
+    enablePrometheusProject?: boolean;
+    customDirectories?: string[];
+    ignoredSkills?: string[];
+    includeSkills?: string[];
+    disabledExtensions?: string[];
+}
+export interface CommitSettings {
+    mapReduceEnabled: boolean;
+    mapReduceMinFiles: number;
+    mapReduceMaxFileTokens: number;
+    mapReduceTimeoutMs: number;
+    mapReduceMaxConcurrency: number;
+    changelogMaxDiffChars: number;
+}
+export interface TtsrSettings {
+    enabled: boolean;
+    contextMode: "discard" | "keep";
+    interruptMode: "never" | "prose-only" | "tool-only" | "always";
+    repeatMode: "once" | "after-gap";
+    repeatGap: number;
+    /** Bucketing-only (read by bucketRules, not the TtsrManager). */
+    builtinRules?: boolean;
+    /** Bucketing-only (read by bucketRules, not the TtsrManager). */
+    disabledRules?: string[];
+}
+export interface ExaSettings {
+    enabled: boolean;
+    enableSearch: boolean;
+    enableResearcher: boolean;
+    enableWebsets: boolean;
+}
+export interface StatusLineSettings {
+    preset: StatusLinePreset;
+    separator: StatusLineSeparatorStyle;
+    showHookStatus: boolean;
+    leftSegments: StatusLineSegmentId[];
+    rightSegments: StatusLineSegmentId[];
+    segmentOptions: Record<string, unknown>;
+}
+export interface ThinkingBudgetsSettings {
+    minimal: number;
+    low: number;
+    medium: number;
+    high: number;
+    xhigh: number;
+}
+export interface SttSettings {
+    enabled: boolean;
+    language: string | undefined;
+    modelName: string;
+    whisperPath: string | undefined;
+    modelPath: string | undefined;
+}
+export interface BashInterceptorRule {
+    pattern: string;
+    flags?: string;
+    tool: string;
+    message: string;
+    allowSubcommands?: string[];
+}
+export interface ShellMinimizerSettings {
+    enabled: boolean;
+    settingsPath: string | undefined;
+    only: string[];
+    except: string[];
+    maxCaptureBytes: number;
+}
+/** Map group prefix -> typed settings interface */
+export interface GroupTypeMap {
+    compaction: CompactionSettings;
+    contextPromotion: ContextPromotionSettings;
+    retry: RetrySettings;
+    memories: MemoriesSettings;
+    branchSummary: BranchSummarySettings;
+    skills: SkillsSettings;
+    commit: CommitSettings;
+    ttsr: TtsrSettings;
+    exa: ExaSettings;
+    statusLine: StatusLineSettings;
+    thinkingBudgets: ThinkingBudgetsSettings;
+    stt: SttSettings;
+    modelRoles: Record<string, string>;
+    modelTags: ModelTagsSettings;
+    cycleOrder: string[];
+    shellMinimizer: ShellMinimizerSettings;
+}
+export type GroupPrefix = keyof GroupTypeMap;
+export {};