@cueloop/client 0.1.0-alpha.102 → 0.1.0-alpha.104

package/src/settings/config.ts

@@ -9,7 +9,13 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { OBSIDIAN_DEFAULTS, type ObsidianConfig } from "@cueloop/integration-obsidian";
-import { MESSAGE_OUTCOMES, type MessageOutcome } from "@cueloop/schema";
+import {
+  AGENT_REASONING_EFFORTS,
+  THREAD_MODEL_DEFAULTS,
+  type ThreadModelDefaults,
+  MESSAGE_OUTCOMES,
+  type MessageOutcome,
+} from "@cueloop/schema";
 import { writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import * as v from "valibot";
@@ -104,6 +110,7 @@ export function resolveQuickAction(
   const index = Number(actionRef);
 
   if (Number.isInteger(index) && index >= 1 && index <= actions.length) return actions[index - 1];
+
   const wanted = actionRef.trim().toLowerCase();
 
   return actions.find((action) => action.prompt.toLowerCase() === wanted);
@@ -127,6 +134,7 @@ export interface CueloopConfig {
   actions: QuickAction[];
   skillsPath: string;
   review: ReviewConfig;
+  thread: { harness: "pi" | "fx"; pi: ThreadModelDefaults; fx: ThreadModelDefaults };
   integrations: IntegrationsConfig;
   experimental: ExperimentalConfig;
 }
@@ -178,6 +186,11 @@ function skillsPathFrom(
   return raw?.path?.trim() ? raw.path.trim() : fallback;
 }
 
+const ThreadModelDefaultsSchema = v.object({
+  model: v.fallback(v.optional(v.pipe(v.string(), v.trim(), v.minLength(1))), undefined),
+  effort: v.fallback(v.optional(v.picklist(AGENT_REASONING_EFFORTS)), undefined),
+});
+
 const ConfigDocumentSchema = v.object({
   actions: v.optional(v.array(v.unknown())),
   authors: v.optional(v.unknown()),
@@ -189,6 +202,16 @@ const ConfigDocumentSchema = v.object({
   experimental: v.optional(v.unknown()),
   skills: v.fallback(v.optional(SkillsSectionSchema), undefined),
   review: v.optional(v.unknown()),
+  thread: v.fallback(
+    v.optional(
+      v.object({
+        harness: v.fallback(v.optional(v.picklist(["pi", "fx"])), undefined),
+        pi: v.fallback(v.optional(ThreadModelDefaultsSchema), undefined),
+        fx: v.fallback(v.optional(ThreadModelDefaultsSchema), undefined),
+      }),
+    ),
+    undefined,
+  ),
 });
 
 const IdentitySchema = v.object({
@@ -258,12 +281,14 @@ function parseToml(text: string) {
 
 function parseActions(entries: readonly unknown[] | undefined): QuickAction[] | undefined {
   if (!entries) return undefined;
+
   const actions: QuickAction[] = [];
 
   for (const entry of entries) {
     const result = v.safeParse(QuickActionSchema, entry);
 
     if (!result.success) continue;
+
     const { prompt, metadata } = result.output;
 
     actions.push(metadata?.trim() ? { prompt, metadata } : { prompt });
@@ -277,21 +302,30 @@ function mergeObsidian(
   obsidian: v.InferOutput<typeof ObsidianSchema>,
 ): void {
   if (obsidian.vault !== undefined) target.vault = obsidian.vault;
+
   if (obsidian.folder !== undefined) target.folder = obsidian.folder;
+
   if (obsidian.filenameFormat !== undefined) target.filenameFormat = obsidian.filenameFormat;
+
   if (obsidian.separator !== undefined) target.separator = obsidian.separator;
+
   if (obsidian.exportOn !== undefined) target.exportOn = obsidian.exportOn;
 }
 
 /** Fold a parsed `[ui]` table onto the accumulated ui config, field by present field. */
 function applyUi(ui: CueloopConfig["ui"], parsed: v.InferOutput<typeof UiSchema>): void {
   if (parsed.auto_close !== undefined) ui.autoClose = parsed.auto_close;
+
   if (parsed.editor?.trim()) ui.editor = parsed.editor.trim();
+
   // "unified" is the pre-rename spelling of "stacked"; keep loading it so an upgrade never flips the layout
   if (parsed.diff_view !== undefined)
     ui.diffView = parsed.diff_view === "unified" ? "stacked" : parsed.diff_view;
+
   if (parsed.default_message !== undefined) ui.defaultMessage = parsed.default_message;
+
   if (parsed.pins !== undefined) ui.pins = parsed.pins;
+
   if (parsed.layout !== undefined) {
     ui.layout = {
       threads: parsed.layout.threads ?? true,
@@ -303,9 +337,25 @@ function applyUi(ui: CueloopConfig["ui"], parsed: v.InferOutput<typeof UiSchema>
 
 function applyReview(review: ReviewConfig, parsed: v.InferOutput<typeof ReviewSchema>): void {
   if (parsed.skill?.trim()) review.skill = parsed.skill.trim();
+
   if (parsed.workspace !== undefined) review.workspace = parsed.workspace;
 }
 
+function applyThreadDefaults(
+  thread: CueloopConfig["thread"],
+  parsed: v.InferOutput<typeof ConfigDocumentSchema>["thread"],
+): void {
+  if (parsed?.harness) thread.harness = parsed.harness;
+
+  for (const harness of ["pi", "fx"] as const) {
+    const defaults = parsed?.[harness];
+
+    if (defaults?.model) thread[harness].model = defaults.model;
+
+    if (defaults?.effort) thread[harness].effort = defaults.effort;
+  }
+}
+
 function layer(
   base: CueloopConfig,
   raw: v.InferOutput<typeof ConfigDocumentSchema>,
@@ -321,6 +371,7 @@ function layer(
     actions: [...base.actions],
     skillsPath: base.skillsPath,
     review: { ...base.review },
+    thread: { ...base.thread, pi: { ...base.thread.pi }, fx: { ...base.thread.fx } },
     integrations: { obsidian: { ...base.integrations.obsidian } },
     experimental: { ...base.experimental },
   };
@@ -334,7 +385,9 @@ function layer(
   const review = v.safeParse(ReviewSchema, raw.review);
 
   if (actions) out.actions = actions;
+
   out.skillsPath = skillsPathFrom(raw.skills, base.skillsPath);
+
   if (authors.success) {
     for (const [id, value] of Object.entries(authors.output)) {
       const name = v.safeParse(v.string(), value);
@@ -342,6 +395,7 @@ function layer(
       if (name.success) out.authors[id] = name.output;
     }
   }
+
   if (keys.success) {
     for (const [action, value] of Object.entries(keys.output)) {
       const combo = v.safeParse(KeyComboSchema, value);
@@ -350,18 +404,26 @@ function layer(
         out.keys[action] = Array.isArray(combo.output) ? combo.output : [combo.output];
     }
   }
+
   // The reviewer identity is a personal credential; a repo must never forge a verified name.
   if (allowIdentity && identity.success) {
     if (identity.output.name !== undefined) out.identity.name = identity.output.name;
+
     if (identity.output.provider !== undefined) out.identity.provider = identity.output.provider;
   }
+
   if (ui.success) applyUi(out.ui, ui.output);
+
   if (integrations.success && integrations.output.obsidian) {
     mergeObsidian(out.integrations.obsidian, integrations.output.obsidian);
   }
+
   if (experimental.success) applyExperimental(out.experimental, experimental.output);
+
   if (review.success) applyReview(out.review, review.output);
 
+  applyThreadDefaults(out.thread, raw.thread);
+
   return out;
 }
 
@@ -384,6 +446,11 @@ export function loadConfig(
     actions: [...DEFAULT_QUICK_ACTIONS],
     skillsPath: join(homedir(), ".agents", "skills"),
     review: { skill: "code-review", workspace: "worktree" },
+    thread: {
+      harness: "pi",
+      pi: { ...THREAD_MODEL_DEFAULTS.pi },
+      fx: { ...THREAD_MODEL_DEFAULTS.fx },
+    },
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
     experimental: { prototypePixels: false, threadAgent: false },
   };
@@ -400,6 +467,7 @@ export function loadConfig(
     options.repoRoot ? join(options.repoRoot, ".cueloop", "config.toml") : undefined,
   ]) {
     if (!path || !existsSync(path)) continue;
+
     try {
       const raw = parseToml(readFileSync(path, "utf8"));
 
@@ -409,6 +477,7 @@ export function loadConfig(
       const parsedThemeOverrides = v.safeParse(ThemeOverridesSchema, raw.theme);
 
       if (rawTheme && isThemeName(rawTheme)) themeName = rawTheme;
+
       if (parsedThemeOverrides.success) {
         for (const [token, value] of Object.entries(parsedThemeOverrides.output)) {
           const override = v.safeParse(v.string(), value);
@@ -461,6 +530,7 @@ function persistUiSetting(key: string, rendered: string, userConfigPath?: string
   let text = "";
 
   if (existsSync(path)) text = readFileSync(path, "utf8");
+
   const assignment = new RegExp(`^(\\s*)${key}\\s*=.*$`, "m");
 
   if (assignment.test(text)) {
@@ -470,6 +540,7 @@ function persistUiSetting(key: string, rendered: string, userConfigPath?: string
   } else {
     text = text.trimEnd() + (text.trim() ? "\n\n" : "") + `[ui]\n${key} = ${rendered}\n`;
   }
+
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, text);
 }
@@ -500,6 +571,7 @@ function persistTableSetting(
   } else {
     text = `${text.trimEnd()}${text.trim() ? "\n\n" : ""}[${table}]\n${key} = ${rendered}\n`;
   }
+
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, text);
 }
@@ -548,6 +620,7 @@ export function persistIdentity(identity: IdentityConfig, userConfigPath?: strin
   } else {
     text = text.trimEnd() + (text.trim() ? "\n\n" : "") + block;
   }
+
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, text);
 }
@@ -614,6 +687,7 @@ export function persistAuthorName(id: string, name: string, userConfigPath?: str
   } else {
     text = text.trimEnd() + (text.trim() ? "\n\n" : "") + `[authors]\n${key} = ${value}\n`;
   }
+
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, text);
 }
@@ -624,5 +698,21 @@ function applyExperimental(
   raw: v.InferOutput<typeof ExperimentalSchema>,
 ): void {
   if (raw.prototype_pixels !== undefined) config.prototypePixels = raw.prototype_pixels;
+
   if (raw.thread_agent !== undefined) config.threadAgent = raw.thread_agent;
 }
+
+/** The preferred harness affects new Threads; existing Threads require a handoff. */
+export function persistThreadHarness(harness: "pi" | "fx", userConfigPath?: string): void {
+  persistTableSetting("thread", "harness", tomlString(harness), userConfigPath);
+}
+
+/** Persist one harness's new-Thread defaults without altering other TOML tables. */
+export function persistThreadModelDefault(
+  harness: "pi" | "fx",
+  key: keyof ThreadModelDefaults,
+  value: string,
+  userConfigPath?: string,
+): void {
+  persistTableSetting(`thread.${harness}`, key, tomlString(value), userConfigPath);
+}

package/src/settings/use-settings-dialog.test.tsx

@@ -0,0 +1,172 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadConfig } from "./config";
+import { expect, test } from "bun:test";
+import React, { useState } from "react";
+import { useKeyboard } from "@opentui/react";
+import { testRender } from "@opentui/react/test-utils";
+import { DARK } from "../appearance/theme";
+import { settle, locateText, typeText } from "../testing/test-support";
+import { SettingsDialog } from "./components/SettingsDialog";
+import { useSettingsDialog } from "./use-settings-dialog";
+
+function TestThreadSettings({
+  enabled,
+  onSwitch,
+}: {
+  enabled: boolean;
+  onSwitch: (harness: string) => void;
+}) {
+  const [harness, setHarness] = useState<"pi" | "fx">("pi");
+  const [threadDefaults, setThreadDefaults] = useState(() => {
+    const config = loadConfig();
+
+    return { pi: config.thread.pi, fx: config.thread.fx };
+  });
+  const model = useSettingsDialog({
+    threadDefaults,
+    setThreadDefaults,
+    theme: DARK,
+    appearance: "dark",
+    autoClose: "off",
+    setAutoClose() {},
+    diffView: "split",
+    setDiffView() {},
+    themeName: "cueloop",
+    setThemeName() {},
+    themeOverrides: {},
+    setTheme() {},
+    quickActions: [],
+    setQuickActions() {},
+    setMenuDialog() {},
+    identityProvider: "typed",
+    onSyncGithubIdentity() {},
+    onRenameDisplayName() {},
+    reviewSkill: "code-review",
+    reviewWorkspace: "worktree",
+    setReviewWorkspace() {},
+    canSwitchHarness: enabled,
+    threadHarness: harness,
+    onSwitchHarness(next) {
+      setHarness(next);
+      onSwitch(next);
+    },
+  });
+
+  useKeyboard((key) => model.handleSettingsKey(key.name));
+
+  return (
+    <SettingsDialog
+      isOpen
+      version="test"
+      categories={model.settingsCategories}
+      values={model.settingsValues}
+      keybindsSections={[]}
+      activeCategoryId={model.settingsNav.categoryId}
+      activeRowIndex={model.settingsNav.rowIndex}
+      activeZone={model.settingsNav.zone}
+      onCategorySelect={model.onCategorySelect}
+      onRowActivate={(row) => model.cycleSetting(row.key)}
+      onClose={() => {}}
+    />
+  );
+}
+
+test("Thread settings switches harness by mouse and disappears without owner capability", async () => {
+  const changes: string[] = [];
+  const setup = await testRender(
+    <TestThreadSettings enabled onSwitch={(next) => changes.push(next)} />,
+    { width: 90, height: 28 },
+  );
+
+  try {
+    await settle(setup);
+    const category = locateText(setup, "Thread");
+
+    await setup.mockMouse.click(category.column, category.row);
+    await settle(setup);
+    const row = locateText(setup, "Harness");
+
+    await setup.mockMouse.click(row.column, row.row);
+    await settle(setup);
+    expect(changes).toEqual(["fx"]);
+    expect(setup.captureCharFrame()).toContain("fx");
+    await setup.mockMouse.click(row.column, row.row);
+    await settle(setup);
+    expect(changes).toEqual(["fx", "pi"]);
+  } finally {
+    setup.renderer.destroy();
+  }
+  const disabled = await testRender(<TestThreadSettings enabled={false} onSwitch={() => {}} />, {
+    width: 90,
+    height: 28,
+  });
+
+  try {
+    await settle(disabled);
+    expect(disabled.captureCharFrame()).not.toContain("Thread");
+  } finally {
+    disabled.renderer.destroy();
+  }
+});
+
+test("Thread settings edits model defaults and effort and persists them to TOML", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "cueloop-settings-model-"));
+  const previous = process.env.CUELOOP_CONFIG;
+  const path = join(directory, "config.toml");
+
+  process.env.CUELOOP_CONFIG = path;
+  const setup = await testRender(<TestThreadSettings enabled onSwitch={() => {}} />, {
+    width: 100,
+    height: 30,
+  });
+
+  try {
+    await settle(setup);
+    const category = locateText(setup, "Thread");
+
+    await setup.mockMouse.click(category.column, category.row);
+    await settle(setup);
+    expect(setup.captureCharFrame()).toContain("gpt-6.1-sol");
+    expect(setup.captureCharFrame()).toContain("grok-4.7");
+    const effort = locateText(setup, "pi default effort");
+
+    await setup.mockMouse.click(effort.column, effort.row);
+    await settle(setup);
+    expect(loadConfig({ userConfigPath: path }).thread.pi.effort).toBe("high");
+    const model = locateText(setup, "pi default model");
+
+    await setup.mockMouse.click(model.column, model.row);
+    await settle(setup);
+    await typeText(setup, "-custom");
+    await settle(setup);
+    const save = locateText(setup, "save");
+
+    await setup.mockMouse.click(save.column, save.row);
+    await settle(setup);
+    expect(loadConfig({ userConfigPath: path }).thread.pi.model).toBe(
+      "openai-codex/gpt-6.1-sol-custom",
+    );
+    expect(setup.captureCharFrame()).toContain("gpt-6.1-sol-custom");
+    const fxModel = locateText(setup, "fx default model");
+
+    await setup.mockMouse.click(fxModel.column, fxModel.row);
+    await settle(setup);
+    await typeText(setup, "-cancelled");
+    setup.mockInput.pressKey("ESC");
+    await settle(setup);
+    expect(setup.captureCharFrame()).not.toContain("Default model for new Threads");
+    expect(loadConfig({ userConfigPath: path }).thread.fx).toEqual({
+      model: "grok/grok-4.7",
+      effort: "medium",
+    });
+  } finally {
+    setup.renderer.destroy();
+
+    if (previous === undefined) delete process.env.CUELOOP_CONFIG;
+    else process.env.CUELOOP_CONFIG = previous;
+
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

package/src/settings/use-settings-dialog.tsx

@@ -1,6 +1,7 @@
 import React, { useState, type Dispatch, type SetStateAction } from "react";
 import {
   DEFAULT_QUICK_ACTIONS,
+  persistThreadModelDefault,
   persistActions,
   persistAutoClose,
   persistDiffView,
@@ -18,6 +19,12 @@ import {
   type Appearance,
   type ThemeName,
 } from "../appearance/theme-presets";
+import {
+  AGENT_REASONING_EFFORTS,
+  type ThreadModelDefaults,
+  type AgentReasoningEffort,
+} from "@cueloop/schema";
+import { PromptDialog } from "../ui/components/PromptDialog";
 import type { Theme } from "../appearance/theme";
 import type { SettingsCategory } from "./components/SettingsDialog";
 import { QuickActionsEditor } from "./components/quick-actions-editor";
@@ -57,8 +64,10 @@ function moveNavZone(
       rowIndex: 0,
       zone: "nav",
     };
+
   if (UP_KEYS.has(name))
     return { categoryId: categories[Math.max(0, categoryIndex - 1)]!.id, rowIndex: 0, zone: "nav" };
+
   if (ENTER_BODY_KEYS.has(name))
     return { categoryId: categories[categoryIndex]!.id, rowIndex: 0, zone: "body" };
 
@@ -67,13 +76,17 @@ function moveNavZone(
 
 function moveBodyRow(name: string, nav: SettingsNav, rowCount: number): SettingsNav | null {
   if (DOWN_KEYS.has(name)) return { ...nav, rowIndex: Math.min(rowCount - 1, nav.rowIndex + 1) };
+
   if (UP_KEYS.has(name)) return { ...nav, rowIndex: Math.max(0, nav.rowIndex - 1) };
+
   if (BACK_TO_NAV_KEYS.has(name)) return { ...nav, zone: "nav" };
 
   return null;
 }
 
 export function useSettingsDialog(params: {
+  threadDefaults: Record<"pi" | "fx", ThreadModelDefaults>;
+  setThreadDefaults: Dispatch<SetStateAction<Record<"pi" | "fx", ThreadModelDefaults>>>;
   theme: Theme;
   appearance: Appearance;
   autoClose: AutoClose;
@@ -94,6 +107,9 @@ export function useSettingsDialog(params: {
   reviewSkill: string;
   reviewWorkspace: ReviewWorkspaceMode;
   setReviewWorkspace: Dispatch<SetStateAction<ReviewWorkspaceMode>>;
+  threadHarness?: "pi" | "fx";
+  canSwitchHarness?: boolean;
+  onSwitchHarness?: (harness: "pi" | "fx") => void;
 }): SettingsDialogModel {
   const {
     theme,
@@ -116,8 +132,27 @@ export function useSettingsDialog(params: {
     reviewSkill,
     reviewWorkspace,
     setReviewWorkspace,
+    threadHarness,
+    canSwitchHarness,
+    onSwitchHarness,
   } = params;
 
+  const { threadDefaults, setThreadDefaults } = params;
+  const [modelEditor, setModelEditor] = useState<{ harness: "pi" | "fx"; text: string } | null>(
+    null,
+  );
+
+  const saveModelDefault = (): void => {
+    if (!modelEditor?.text.trim()) return;
+
+    const { harness, text } = modelEditor;
+    const model = text.trim();
+
+    persistThreadModelDefault(harness, "model", model);
+    setThreadDefaults((defaults) => ({ ...defaults, [harness]: { ...defaults[harness], model } }));
+    setModelEditor(null);
+  };
+
   // open focused on the left nav, so up/down browses categories until l/tab/enter enters the body
   const [settingsNav, setSettingsNav] = useState<SettingsNav>({
     categoryId: "general",
@@ -134,6 +169,7 @@ export function useSettingsDialog(params: {
   const editActionPrompt = (index: number, prompt: string): void => {
     // a blank title fails the config schema and would vanish on reload, so never persist one
     if (prompt.trim().length === 0) return;
+
     commitActions(
       quickActions.map((action, actionIndex) =>
         actionIndex === index ? { ...action, prompt } : action,
@@ -214,6 +250,48 @@ export function useSettingsDialog(params: {
         },
       ],
     },
+    ...(canSwitchHarness
+      ? [
+          {
+            id: "thread",
+            name: "Thread",
+            rows: [
+              {
+                key: "threadHarness",
+                label: "Harness",
+                kind: "cycle" as const,
+                options: ["pi", "fx"],
+              },
+              { key: "piModel", label: "pi default model", kind: "text" as const },
+              {
+                key: "piEffort",
+                label: "pi default effort",
+                kind: "cycle" as const,
+                options: [...AGENT_REASONING_EFFORTS],
+              },
+              { key: "fxModel", label: "fx default model", kind: "text" as const },
+              {
+                key: "fxEffort",
+                label: "fx default effort",
+                kind: "cycle" as const,
+                options: [...AGENT_REASONING_EFFORTS],
+              },
+            ],
+            customBody: modelEditor ? (
+              <PromptDialog
+                isOpen
+                title=" Default model for new Threads "
+                label={`${modelEditor.harness} model (provider/model)`}
+                value={modelEditor.text}
+                onInput={(text) => setModelEditor({ ...modelEditor, text })}
+                onSave={saveModelDefault}
+                onCancel={() => setModelEditor(null)}
+                theme={theme}
+              />
+            ) : undefined,
+          },
+        ]
+      : []),
     {
       id: "actions",
       name: "Actions",
@@ -252,9 +330,31 @@ export function useSettingsDialog(params: {
     syncGithub: "enter to sync",
     reviewSkill,
     reviewWorkspace,
+    threadHarness: threadHarness ?? "pi",
+    piModel: threadDefaults.pi.model.replace(/^[^/]+\//, ""),
+    piEffort: threadDefaults.pi.effort,
+    fxModel: threadDefaults.fx.model.replace(/^[^/]+\//, ""),
+    fxEffort: threadDefaults.fx.effort,
   };
   const cycleSetting = (rowKey: string): void => {
-    if (rowKey === "autoClose") {
+    if (rowKey === "piModel" || rowKey === "fxModel") {
+      const harness = rowKey === "piModel" ? "pi" : "fx";
+
+      setModelEditor({ harness, text: threadDefaults[harness].model });
+    } else if (rowKey === "piEffort" || rowKey === "fxEffort") {
+      const harness = rowKey === "piEffort" ? "pi" : "fx";
+      const efforts = AGENT_REASONING_EFFORTS;
+      const effort: AgentReasoningEffort =
+        efforts[(efforts.indexOf(threadDefaults[harness].effort) + 1) % efforts.length]!;
+
+      persistThreadModelDefault(harness, "effort", effort);
+      setThreadDefaults((defaults) => ({
+        ...defaults,
+        [harness]: { ...defaults[harness], effort },
+      }));
+    } else if (rowKey === "threadHarness") {
+      onSwitchHarness?.(threadHarness === "fx" ? "pi" : "fx");
+    } else if (rowKey === "autoClose") {
       const next: AutoClose = autoClose === "off" ? 3 : autoClose === 3 ? 10 : "off";
 
       setAutoClose(next);
@@ -291,18 +391,28 @@ export function useSettingsDialog(params: {
   const onCategorySelect = (categoryId: string): void => {
     // ignore a select that names no real category, so the key handler never dereferences nothing
     if (!settingsCategories.some((category) => category.id === categoryId)) return;
+
     setActionsExpandedIndex(null);
     setSettingsNav({ categoryId, rowIndex: 0, zone: "body" });
   };
 
   const handleSettingsKey = (name: string): void => {
+    if (modelEditor) {
+      if (name === "escape") setModelEditor(null);
+      else if (name === "return") saveModelDefault();
+
+      return;
+    }
+
     // an open system-prompt input owns typing; only esc (close it) escapes here
     if (actionsExpandedIndex !== null) {
       if (name === "escape") setActionsExpandedIndex(null);
 
       return;
     }
+
     if (name === "escape") return void setMenuDialog(null);
+
     const categoryIndex = settingsCategories.findIndex(
       (category) => category.id === settingsNav.categoryId,
     );
@@ -315,11 +425,13 @@ export function useSettingsDialog(params: {
 
       return;
     }
+
     // the Actions category is a list of quick actions plus a trailing "add" row
     if (category.id === "actions") {
       const moved = moveBodyRow(name, settingsNav, quickActions.length + 1);
 
       if (moved) return void setSettingsNav(moved);
+
       if (ACTIVATE_KEYS.has(name)) {
         if (settingsNav.rowIndex === quickActions.length) addAction();
         else {
@@ -330,9 +442,11 @@ export function useSettingsDialog(params: {
 
       return;
     }
+
     const moved = moveBodyRow(name, settingsNav, category.rows.length);
 
     if (moved) return void setSettingsNav(moved);
+
     if (name === "return" || name === "space")
       cycleSetting(category.rows[settingsNav.rowIndex]!.key);
   };