pi-openai-codex-compat 0.0.16 → 0.0.17

package/extensions/openai-codex-compat/settings-pane.ts

@@ -1,574 +1,265 @@
-import { isBoolean, isNumber } from "./value-contracts.ts";
-import {
-  getSettingsListTheme,
-  type ExtensionContext,
-  type KeybindingsManager,
-  type Theme,
-} from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  settingsMenu,
+  waitForSettingsIdle,
+  type SettingsField,
+  type SettingsMenuFactory,
+} from "../settings-menu.ts";
+import { SettingsStore } from "../settings-store.ts";
 import {
-  type Component,
-  Container,
-  decodeKittyPrintable,
-  type Focusable,
-  fuzzyFilter,
-  Input,
-  Key,
-  matchesKey,
-  type SettingItem,
-  SettingsList,
-  Text,
-  truncateToWidth,
-  type TUI,
-} from "@earendil-works/pi-tui";
-import { Value } from "typebox/value";
+  readSessionSettings,
+  sessionSettingsEntry,
+  type SettingsSessionContext,
+} from "../settings-session.ts";
 import {
+  CONFIG_ENVIRONMENT_VARIABLES,
   CODEX_TOOL_BACKGROUND_SCHEMA,
   CODEX_SHELL_TOOL_SCHEMA,
-  CONFIG_ENVIRONMENT_VARIABLES,
   IMAGE_DETAIL_SCHEMA,
   REASONING_MODE_SCHEMA,
   REASONING_SUMMARY_SCHEMA,
   TEXT_VERBOSITY_SCHEMA,
   WEB_SEARCH_MODE_SCHEMA,
-  configLayer,
   globalConfigPath,
-  loadConfig,
+  projectConfigPath,
   parseEnvironmentConfig,
-  saveConfig,
-  withoutEnvironmentOverrides,
-  writableConfigPath,
+  parseConfig,
+  resolveConfig,
+  loadConfig,
+  configLayer,
   type CodexCompatConfig,
-  type ConfigLayer,
 } from "./config.ts";
 import type { ConfigContext } from "./config-context.ts";
-import { errorFromThrown } from "./error-from-thrown.ts";
 import { selectedRegistryModel } from "./model-context.ts";
+import { isCodexModel, supportsReasoningMode } from "./request-options.ts";
+import { usesResponsesLite } from "./responses-lite.ts";
 
-const COMMAND_NAME = "codex-settings";
-
-type SettingId = keyof typeof CONFIG_ENVIRONMENT_VARIABLES;
-
-function isSettingId(value: string): value is SettingId {
-  return Object.hasOwn(CONFIG_ENVIRONMENT_VARIABLES, value);
-}
-
+export const settingFields: SettingsField[] = [
+  {
+    id: "fastMode",
+    label: "Fast mode",
+    description: "Use the priority service tier and its pricing.",
+    choices: [false, true],
+  },
+  {
+    id: "responsesLite",
+    label: "Responses Lite",
+    description: "Use Responses Lite on supported models.",
+    choices: [false, true],
+  },
+  {
+    id: "textVerbosity",
+    label: "Text verbosity",
+    description: "Set Responses API text.verbosity.",
+    choices: [...TEXT_VERBOSITY_SCHEMA.enum],
+  },
+  {
+    id: "reasoningSummary",
+    label: "Reasoning summary",
+    description: "Choose reasoning summary detail, or omit summaries.",
+    choices: [...REASONING_SUMMARY_SCHEMA.enum],
+  },
+  {
+    id: "reasoningMode",
+    label: "Reasoning mode",
+    description: "Standard or pro execution on supported models, independent of effort.",
+    choices: [...REASONING_MODE_SCHEMA.enum],
+  },
+  {
+    id: "toolBackground",
+    label: "Codex tool background",
+    description: "Choose a subtle surface, Pi status colors, or no background.",
+    choices: [...CODEX_TOOL_BACKGROUND_SCHEMA.enum],
+  },
+  {
+    id: "shellTool",
+    label: "Command tool",
+    description:
+      "Unified exec or shell_command. Collect pending output or stop sessions with /ps before switching.",
+    choices: [...CODEX_SHELL_TOOL_SCHEMA.enum],
+  },
+  {
+    id: "applyPatch",
+    label: "apply_patch tool",
+    description: "Replace Pi edit and write tools with Codex apply_patch.",
+    choices: [false, true],
+  },
+  {
+    id: "applyPatchDebug",
+    label: "apply_patch debug output",
+    description: "Show exact model feedback while patch output is collapsed.",
+    choices: [false, true],
+  },
+  {
+    id: "applyPatchDiagnostics",
+    label: "apply_patch diagnostics capture",
+    description:
+      "Retain potentially sensitive file snapshots and failed patches in Pi's agent directory.",
+    choices: [false, true],
+  },
+  {
+    id: "imageGeneration",
+    label: "image_gen.imagegen tool",
+    description: "Generate or edit images through Codex.",
+    choices: [false, true],
+  },
+  {
+    id: "imageDetail",
+    label: "Image result detail",
+    description: "Set input_image.detail for returned images.",
+    choices: [...IMAGE_DETAIL_SCHEMA.enum],
+  },
+  {
+    id: "webRun",
+    label: "web.run tool",
+    description: "Use standalone search and browsing instead of hosted web search.",
+    choices: [false, true],
+  },
+  {
+    id: "webSearch",
+    label: "Web search mode",
+    description: "Disabled removes hosted search but leaves enabled web.run cached-only.",
+    choices: [...WEB_SEARCH_MODE_SCHEMA.enum],
+  },
+  {
+    id: "autoCompactAtPercent",
+    label: "Auto-compact threshold",
+    description:
+      "An additional percentage trigger. Pi default disables the percentage override, not Pi auto-compaction.",
+    choices: [null, 75, 80, 85, 90, 95],
+    number: { min: 0, max: 100, exclusiveMin: true, unit: "%" },
+    format: (value) => (value === null ? "Pi default" : `${value}%`),
+  },
+];
+export type SettingsChangeContext = { model: Model<Api> | undefined; sessionId: string };
 export type SettingsCallbacks = {
-  getConfig?: (ctx: ConfigContext) => CodexCompatConfig;
-  onChange?: (config: CodexCompatConfig, ctx: SettingsChangeContext) => void;
+  getConfig: (ctx: ConfigContext) => CodexCompatConfig;
+  onChange: (config: CodexCompatConfig, ctx: SettingsChangeContext) => void;
+  hasPersistentSessions?: () => boolean;
 };
-
 export type CodexSettingsContext = ConfigContext &
-  Pick<ExtensionContext, "mode"> & {
-    model:
-      | {
-          id: string;
-          provider: string;
-        }
-      | undefined;
-    modelRegistry: Pick<ExtensionContext["modelRegistry"], "find">;
-    sessionManager: Pick<ExtensionContext["sessionManager"], "getSessionId">;
+  SettingsSessionContext &
+  Pick<ExtensionCommandContext, "mode" | "model" | "isIdle" | "waitForIdle"> & {
+    modelRegistry: Pick<ExtensionCommandContext["modelRegistry"], "find">;
     ui: {
-      custom: <T>(factory: SettingsComponentFactory<T>) => Promise<T>;
-      notify: (message: string, type?: "info" | "warning" | "error") => void;
+      custom: <T>(factory: SettingsMenuFactory<T>) => Promise<T>;
+      notify: ExtensionCommandContext["ui"]["notify"];
     };
   };
-
-export type SettingsComponentFactory<T> = (
-  tui: Pick<TUI, "requestRender">,
-  theme: Pick<Theme, "bold" | "fg">,
-  keybindings: Pick<KeybindingsManager, "matches">,
-  done: (result: T) => void,
-) => Component | Promise<Component>;
-
-export type SettingsChangeContext = {
-  model: Model<Api> | undefined;
-  sessionId: string;
-};
-
 export type CodexSettingsHandler = (args: string, ctx: CodexSettingsContext) => Promise<void>;
-
 export type CodexSettingsApi = {
+  appendEntry: (customType: string, data: unknown) => void;
   registerCommand: (
     name: string,
-    options: {
-      description?: string;
-      handler: CodexSettingsHandler;
-    },
+    options: { description: string; handler: CodexSettingsHandler },
   ) => void;
 };
+export const SESSION_SETTINGS_TYPE = "pi-openai-codex-compat:settings";
 
-function toggleValue(value: boolean): string {
-  return value ? "on" : "off";
-}
-
-function thresholdValue(value: number | undefined): string {
-  return value === undefined ? "Pi default" : `${value}%`;
-}
-
-function isSearchTextInput(data: string): boolean {
-  if (decodeKittyPrintable(data) !== undefined || data.includes("\u001b[200~")) return true;
-  if (data.length === 0) return false;
-  for (let index = 0; index < data.length; index++) {
-    const code = data.charCodeAt(index);
-    if (code < 32 || code === 0x7f || (code >= 0x80 && code <= 0x9f)) return false;
-  }
-  return true;
-}
-
-export function settingItems(
-  config: CodexCompatConfig,
-  environmentConfig: ConfigLayer = {},
-): SettingItem[] {
-  const items: SettingItem[] = [
-    {
-      id: "fastMode",
-      label: "Fast mode",
-      description: "Send requests through OpenAI's priority service tier.",
-      currentValue: toggleValue(config.fastMode),
-      values: ["off", "on"],
-    },
-    {
-      id: "responsesLite",
-      label: "Responses Lite",
-      description: "Use Codex's Responses Lite envelope on supported GPT-5.6 models.",
-      currentValue: toggleValue(config.responsesLite),
-      values: ["off", "on"],
-    },
-    {
-      id: "textVerbosity",
-      label: "Text verbosity",
-      description: "Set Responses API text.verbosity.",
-      currentValue: config.textVerbosity,
-      values: [...TEXT_VERBOSITY_SCHEMA.enum],
-    },
-    {
-      id: "reasoningSummary",
-      label: "Reasoning summary",
-      description: "Choose the reasoning summary detail, or omit summaries.",
-      currentValue: config.reasoningSummary,
-      values: [...REASONING_SUMMARY_SCHEMA.enum],
-    },
-    {
-      id: "reasoningMode",
-      label: "Reasoning mode",
-      description:
-        "Choose standard or pro execution independently of reasoning effort. Applied only to GPT-5.6 models.",
-      currentValue: config.reasoningMode,
-      values: [...REASONING_MODE_SCHEMA.enum],
-    },
-    {
-      id: "toolBackground",
-      label: "Codex tool background",
-      description: "Choose a distinct subtle surface, Pi's normal status colors, or no background.",
-      currentValue: config.toolBackground,
-      values: [...CODEX_TOOL_BACKGROUND_SCHEMA.enum],
-    },
-    {
-      id: "shellTool",
-      label: "Command tool",
-      description: "Choose the unified exec pair or legacy shell_command.",
-      currentValue: config.shellTool,
-      values: [...CODEX_SHELL_TOOL_SCHEMA.enum],
-    },
-    {
-      id: "applyPatch",
-      label: "apply_patch tool",
-      description: "Use Codex apply_patch instead of Pi's edit and write tools.",
-      currentValue: toggleValue(config.applyPatch),
-      values: ["off", "on"],
-    },
-    {
-      id: "applyPatchDebug",
-      label: "apply_patch debug output",
-      description: "Show exact model feedback while apply_patch output is collapsed.",
-      currentValue: toggleValue(config.applyPatchDebug),
-      values: ["off", "on"],
-    },
-    {
-      id: "applyPatchDiagnostics",
-      label: "apply_patch diagnostics capture",
-      description:
-        "Store failed patches, identifiers, and complete instruction snapshots in Pi's agent directory.",
-      currentValue: toggleValue(config.applyPatchDiagnostics),
-      values: ["off", "on"],
-    },
-    {
-      id: "imageGeneration",
-      label: "image_gen.imagegen tool",
-      description: "Generate or edit images through the standalone Codex image endpoint.",
-      currentValue: toggleValue(config.imageGeneration),
-      values: ["off", "on"],
-    },
-    {
-      id: "imageDetail",
-      label: "Image result detail",
-      description: "Set input_image.detail when image tool results are returned to the model.",
-      currentValue: config.imageDetail,
-      values: [...IMAGE_DETAIL_SCHEMA.enum],
-    },
-    {
-      id: "webRun",
-      label: "web.run tool",
-      description: "Search and browse through the standalone Codex search endpoint.",
-      currentValue: toggleValue(config.webRun),
-      values: ["off", "on"],
-    },
-    {
-      id: "webSearch",
-      label: "Web search mode",
-      description:
-        "Control hosted search and web.run access: disabled removes hosted search but keeps web.run cached-only.",
-      currentValue: config.webSearch,
-      values: [...WEB_SEARCH_MODE_SCHEMA.enum],
-    },
-    {
-      id: "autoCompactAtPercent",
-      label: "Auto-compact threshold",
-      description: "Add provider-boundary compaction or rely on Pi's normal compaction threshold.",
-      currentValue: thresholdValue(config.autoCompactAtPercent),
-      values: ["Pi default", "75%", "80%", "85%", "90%", "95%"],
-    },
-  ];
-
-  return items.map((item) => {
-    if (!isSettingId(item.id)) {
-      throw new Error(`Unknown OpenAI Codex setting: ${item.id}`);
-    }
-    const id = item.id;
-    if (!Object.hasOwn(environmentConfig, id)) return item;
-
-    const variable = CONFIG_ENVIRONMENT_VARIABLES[id];
-    const lockedItem = { ...item };
-    lockedItem.currentValue = `${item.currentValue} (env)`;
-    lockedItem.description = `${item.description} Locked by ${variable}.`;
-    delete lockedItem.values;
-    return lockedItem;
-  });
-}
-
-export function settingPatch(id: string, value: string): ConfigLayer | undefined {
-  if (!isSettingId(id)) return undefined;
-  switch (id) {
-    case "fastMode":
-      return value === "on" || value === "off" ? { fastMode: value === "on" } : undefined;
-    case "responsesLite":
-      return value === "on" || value === "off" ? { responsesLite: value === "on" } : undefined;
-    case "textVerbosity":
-      if (Value.Check(TEXT_VERBOSITY_SCHEMA, value)) {
-        return { textVerbosity: value };
-      }
-      return undefined;
-    case "reasoningSummary":
-      if (Value.Check(REASONING_SUMMARY_SCHEMA, value)) {
-        return { reasoningSummary: value };
-      }
-      return undefined;
-    case "reasoningMode":
-      if (Value.Check(REASONING_MODE_SCHEMA, value)) return { reasoningMode: value };
-      return undefined;
-    case "toolBackground":
-      if (Value.Check(CODEX_TOOL_BACKGROUND_SCHEMA, value)) {
-        return { toolBackground: value };
-      }
-      return undefined;
-    case "shellTool":
-      if (Value.Check(CODEX_SHELL_TOOL_SCHEMA, value)) {
-        return { shellTool: value };
-      }
-      return undefined;
-    case "applyPatch":
-      return value === "on" || value === "off" ? { applyPatch: value === "on" } : undefined;
-    case "applyPatchDebug":
-      return value === "on" || value === "off" ? { applyPatchDebug: value === "on" } : undefined;
-    case "applyPatchDiagnostics":
-      return value === "on" || value === "off"
-        ? { applyPatchDiagnostics: value === "on" }
-        : undefined;
-    case "imageGeneration":
-      return value === "on" || value === "off" ? { imageGeneration: value === "on" } : undefined;
-    case "imageDetail":
-      if (Value.Check(IMAGE_DETAIL_SCHEMA, value)) {
-        return { imageDetail: value };
-      }
-      return undefined;
-    case "webRun":
-      return value === "on" || value === "off" ? { webRun: value === "on" } : undefined;
-    case "webSearch":
-      if (Value.Check(WEB_SEARCH_MODE_SCHEMA, value)) {
-        return { webSearch: value };
-      }
-      return undefined;
-    case "autoCompactAtPercent": {
-      if (value === "Pi default") return { autoCompactAtPercent: null };
-      const percent = Number(value.replace(/%$/, ""));
-      return Number.isFinite(percent) && percent > 0 && percent <= 100
-        ? { autoCompactAtPercent: percent }
-        : undefined;
-    }
-  }
-}
-
-function applySettingPatch(config: CodexCompatConfig, patch: ConfigLayer): CodexCompatConfig {
-  const next: CodexCompatConfig = { ...config };
-  if (isBoolean(patch.fastMode)) next.fastMode = patch.fastMode;
-  if (isBoolean(patch.responsesLite)) next.responsesLite = patch.responsesLite;
-  if (isBoolean(patch.applyPatch)) next.applyPatch = patch.applyPatch;
-  if (isBoolean(patch.applyPatchDebug)) next.applyPatchDebug = patch.applyPatchDebug;
-  if (isBoolean(patch.applyPatchDiagnostics)) {
-    next.applyPatchDiagnostics = patch.applyPatchDiagnostics;
-  }
-  if (patch.toolBackground) next.toolBackground = patch.toolBackground;
-  if (patch.shellTool) next.shellTool = patch.shellTool;
-  if (isBoolean(patch.imageGeneration)) {
-    next.imageGeneration = patch.imageGeneration;
-  }
-  if (patch.imageDetail) next.imageDetail = patch.imageDetail;
-  if (isBoolean(patch.webRun)) next.webRun = patch.webRun;
-  if (patch.webSearch) next.webSearch = patch.webSearch;
-  if (patch.textVerbosity) next.textVerbosity = patch.textVerbosity;
-  if (patch.reasoningSummary) next.reasoningSummary = patch.reasoningSummary;
-  if (patch.reasoningMode) next.reasoningMode = patch.reasoningMode;
-  if (isNumber(patch.autoCompactAtPercent)) {
-    next.autoCompactAtPercent = patch.autoCompactAtPercent;
-  } else if (patch.autoCompactAtPercent === null) {
-    delete next.autoCompactAtPercent;
-  }
-  return next;
-}
-
-async function showSettings(
-  ctx: CodexSettingsContext,
-  callbacks: SettingsCallbacks,
-): Promise<void> {
-  if (ctx.mode !== "tui") {
-    ctx.ui.notify(`/${COMMAND_NAME} requires TUI mode`, "error");
-    return;
-  }
-
-  let config = callbacks.getConfig?.(ctx) ?? loadConfig(ctx.cwd, ctx.isProjectTrusted());
-  let persistedConfig = { ...config };
-  let revision = 0;
-  let savedRevision = 0;
-  let saveQueue = Promise.resolve();
-  const environmentConfig = parseEnvironmentConfig();
-  const settingsScope =
-    writableConfigPath(ctx.cwd, ctx.isProjectTrusted()) === globalConfigPath()
-      ? "global"
-      : "project";
-  const changeContext = (): SettingsChangeContext => {
-    return {
-      model: selectedRegistryModel(ctx),
-      sessionId: ctx.sessionManager.getSessionId(),
-    };
-  };
-
-  await ctx.ui.custom((tui, theme, keybindings, done) => {
-    let closing = false;
-    const container = new Container();
-    container.addChild(
-      new Text(theme.fg("accent", theme.bold("Codex Settings (pi-openai-codex-compat)")), 1, 1),
-    );
-    const saveStatus = new Text(
-      theme.fg(
-        "dim",
-        `Changes apply to the session immediately · Ctrl+S updates ${settingsScope} settings`,
-      ),
-      1,
-      0,
-    );
-    container.addChild(saveStatus);
-
-    const queueSave = (closeAfterSave: boolean): void => {
-      if (closing) return;
-      if (closeAfterSave) closing = true;
-
-      const snapshotConfig = { ...config };
-      const snapshot = withoutEnvironmentOverrides(configLayer(snapshotConfig), environmentConfig);
-      const snapshotRevision = revision;
-      saveStatus.setText(theme.fg("dim", closeAfterSave ? "Saving and closing…" : "Saving…"));
-      saveQueue = saveQueue.then(async () => {
-        try {
-          const savedPath = await saveConfig(ctx.cwd, ctx.isProjectTrusted(), snapshot);
-          if (snapshotRevision >= savedRevision) {
-            persistedConfig = snapshotConfig;
-            savedRevision = snapshotRevision;
-          }
-          if (closeAfterSave) {
-            done(undefined);
-            return;
-          }
-          saveStatus.setText(
-            savedRevision === revision
-              ? theme.fg("success", `Saved to ${savedPath}`)
-              : theme.fg("warning", "Unsaved session changes."),
-          );
-        } catch (cause) {
-          const error = errorFromThrown(cause, "Could not save Codex settings.");
-          if (closeAfterSave) closing = false;
-          const message = error.message;
-          saveStatus.setText(theme.fg("error", message));
-          ctx.ui.notify(message, "error");
-        }
-        tui.requestRender();
-      });
-      tui.requestRender();
-    };
-
-    const discardAndClose = (): void => {
-      if (closing) return;
-      closing = true;
-      saveStatus.setText(theme.fg("dim", "Discarding unsaved changes…"));
-      saveQueue = saveQueue.then(() => {
-        if (revision !== savedRevision) {
-          config = { ...persistedConfig };
-          revision = savedRevision;
-          callbacks.onChange?.(config, changeContext());
-        }
-        done(undefined);
-      });
-      tui.requestRender();
-    };
-
-    const listTheme = getSettingsListTheme();
-    const items = settingItems(config, environmentConfig);
-    const searchInput = new Input();
-    let rootFocused = false;
-    let searchFocused = false;
-    let filteredItems = items;
-    const resultListTheme = {
-      ...listTheme,
-      label: (text: string, selected: boolean) =>
-        searchFocused && selected ? theme.fg("text", text) : listTheme.label(text, selected),
-      value: (text: string, selected: boolean) =>
-        searchFocused && selected ? theme.fg("text", text) : listTheme.value(text, selected),
-      get cursor(): string {
-        return searchFocused ? "→ " : listTheme.cursor;
-      },
-    };
-    const changeSetting = (id: string, value: string): void => {
-      const patch = settingPatch(id, value);
-      if (!patch) return;
-
-      config = applySettingPatch(config, patch);
-      revision++;
-      callbacks.onChange?.(config, changeContext());
-      saveStatus.setText(theme.fg("warning", "Unsaved session changes."));
-      tui.requestRender();
-    };
-    const createList = (): SettingsList =>
-      new SettingsList(filteredItems, 12, resultListTheme, changeSetting, discardAndClose);
-    let list = createList();
-
-    const setSearchFocused = (focused: boolean): void => {
-      searchFocused = focused;
-      searchInput.focused = rootFocused && searchFocused;
-    };
-
-    const updateSearch = (data: string): void => {
-      const previousQuery = searchInput.getValue();
-      searchInput.handleInput(data);
-      const query = searchInput.getValue();
-      if (query === previousQuery) return;
-      filteredItems = fuzzyFilter(items, query, (item) => item.label);
-      list = createList();
-    };
-
-    const settingsSelector: Component = {
-      render: (width: number) => {
-        const query = searchInput.getValue();
-        const searchLabel = searchFocused
-          ? theme.fg("accent", theme.bold("Search"))
-          : theme.fg("dim", "Search");
-        const searchLines = searchFocused
-          ? searchInput.render(width)
-          : [truncateToWidth(listTheme.hint(query.length > 0 ? `  ${query}` : ""), width, "")];
-        const listLines =
-          filteredItems.length > 0
-            ? list.render(width)
-            : [truncateToWidth(listTheme.hint("  No matching settings"), width, ""), ""];
-        const hint = searchFocused
-          ? "  Type to filter · ↑↓ results · Tab switch · Enter save · Esc discard"
-          : "  ↑↓ navigate · Type to filter · Space change · Tab search · Enter save · Esc discard";
-        if (listLines.length > 0) {
-          listLines[listLines.length - 1] = truncateToWidth(listTheme.hint(hint), width, "");
-        }
-        return [truncateToWidth(searchLabel, width, ""), ...searchLines, "", ...listLines];
-      },
-      invalidate: () => {
-        searchInput.invalidate();
-        list.invalidate();
-      },
-      handleInput: (data: string) => {
-        if (matchesKey(data, Key.tab) || matchesKey(data, Key.shift("tab"))) {
-          setSearchFocused(!searchFocused);
-          return;
-        }
-        if (
-          searchFocused &&
-          (matchesKey(data, Key.up) ||
-            matchesKey(data, Key.down) ||
-            keybindings.matches(data, "tui.select.up") ||
-            keybindings.matches(data, "tui.select.down"))
-        ) {
-          setSearchFocused(false);
-          list.handleInput(data);
-          return;
-        }
-        if (!searchFocused) {
-          if (!matchesKey(data, Key.space) && isSearchTextInput(data)) {
-            setSearchFocused(true);
-            updateSearch(data);
-            return;
-          }
-          list.handleInput(data);
-          return;
-        }
-        updateSearch(data);
-      },
-    };
-    container.addChild(settingsSelector);
-
-    const component: Component & Focusable = {
-      get focused() {
-        return rootFocused;
-      },
-      set focused(focused: boolean) {
-        rootFocused = focused;
-        searchInput.focused = rootFocused && searchFocused;
-      },
-      render: (width: number) => container.render(width),
-      invalidate: () => container.invalidate(),
-      handleInput: (data: string) => {
-        if (closing) return;
-        if (matchesKey(data, Key.ctrl("s"))) {
-          queueSave(false);
-          return;
-        }
-        if (matchesKey(data, Key.enter)) {
-          queueSave(true);
-          return;
-        }
-        if (matchesKey(data, Key.escape) || keybindings.matches(data, "tui.select.cancel")) {
-          discardAndClose();
-          return;
-        }
-        settingsSelector.handleInput?.(data);
-        tui.requestRender();
-      },
-    };
-    return component;
-  });
-
-  await saveQueue;
+export function loadSessionConfig(ctx: ConfigContext & SettingsSessionContext): CodexCompatConfig {
+  const saved = readSessionSettings(ctx, SESSION_SETTINGS_TYPE, settingFields);
+  return resolveConfig(
+    configLayer(loadConfig(ctx.cwd, ctx.isProjectTrusted())),
+    parseConfig(saved.values),
+    parseEnvironmentConfig(),
+  );
 }
 
 export default function registerCodexSettings(
   pi: CodexSettingsApi,
-  callbacks: SettingsCallbacks = {},
+  callbacks: SettingsCallbacks,
 ): void {
-  pi.registerCommand(COMMAND_NAME, {
+  pi.registerCommand("codex-settings", {
     description: "Configure OpenAI Codex compatibility",
-    handler: async (_args, ctx) => showSettings(ctx, callbacks),
+    handler: async (_args, ctx) => {
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("/codex-settings requires TUI mode.", "error");
+        return;
+      }
+      try {
+        const environment = parseEnvironmentConfig();
+        const locked = Object.fromEntries(
+          Object.entries(CONFIG_ENVIRONMENT_VARIABLES).filter(([id]) =>
+            Object.hasOwn(environment, id),
+          ),
+        );
+        const sessionId = ctx.sessionManager.getSessionId();
+        const trusted = ctx.isProjectTrusted();
+        const store = new SettingsStore(
+          globalConfigPath(),
+          trusted ? projectConfigPath(ctx.cwd) : undefined,
+          (global, project) => {
+            const config = resolveConfig(parseConfig(global), parseConfig(project), environment);
+            return { ...config, autoCompactAtPercent: config.autoCompactAtPercent ?? null };
+          },
+          locked,
+          (data) => ({ ...parseConfig(data) }),
+        );
+        const snapshot = await store.load();
+        const selection = ctx.model;
+        const current = callbacks.getConfig(ctx);
+        const sessionState = readSessionSettings(ctx, SESSION_SETTINGS_TYPE, settingFields).session;
+        for (const id of Object.keys(locked)) delete sessionState.changes[id];
+        let appliedShell = current.shellTool;
+        const model = selectedRegistryModel(ctx);
+        const fields = settingFields.map((field) => {
+          const inactive =
+            !isCodexModel(model) ||
+            (field.id === "responsesLite" && !usesResponsesLite(model.id)) ||
+            (field.id === "reasoningMode" && !supportsReasoningMode(model.id));
+          return {
+            ...field,
+            description: `${inactive ? "Inactive on this model. " : ""}${field.description}`,
+          };
+        });
+        await ctx.ui.custom(
+          settingsMenu({
+            title: "Codex Settings",
+            store,
+            snapshot,
+            current: { ...current, autoCompactAtPercent: current.autoCompactAtPercent ?? null },
+            session: sessionState,
+            fields,
+            status: () =>
+              isCodexModel(model)
+                ? "Codex settings apply when applied to session or saved."
+                : "Configured preferences are inactive on this provider.",
+            prepare: (signal) => waitForSettingsIdle(() => ctx.waitForIdle(), signal),
+            guard: (values) => {
+              if (ctx.model?.id !== selection?.id || ctx.model?.provider !== selection?.provider) {
+                throw new Error("The selected model changed. Reopen settings.");
+              }
+              if (
+                sessionId !== ctx.sessionManager.getSessionId() ||
+                trusted !== ctx.isProjectTrusted()
+              ) {
+                throw new Error("The session or project trust changed. Reopen settings.");
+              }
+              if (!ctx.isIdle()) throw new Error("Pi is busy. Retry when idle.");
+              if (values["shellTool"] !== appliedShell && callbacks.hasPersistentSessions?.()) {
+                throw new Error(
+                  "Collect pending output with write_stdin or stop running sessions with /ps before changing Command tool.",
+                );
+              }
+            },
+            apply: (values, nextSession) => {
+              const config = resolveConfig(parseConfig(values), {}, environment);
+              pi.appendEntry(
+                SESSION_SETTINGS_TYPE,
+                sessionSettingsEntry(sessionId, values, nextSession, locked),
+              );
+              callbacks.onChange(config, { model: selectedRegistryModel(ctx), sessionId });
+              appliedShell = config.shellTool;
+            },
+          }),
+        );
+      } catch (error) {
+        ctx.ui.notify(
+          error instanceof Error ? error.message : "Could not open Codex settings.",
+          "error",
+        );
+      }
+    },
   });
 }