pi-archimedes 2.7.3 → 2.9.0

package/src/onboarding/overlay.ts

@@ -0,0 +1,255 @@
+import { Key, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import {
+  padEnd,
+  renderFooter,
+  renderHeader,
+  wrapWithBorder,
+  type OverlayTheme,
+} from "@pi-archimedes/core/overlay";
+import type { ThinkingStyle, ToolStyle } from "@pi-archimedes/ui/config";
+import { spinFrame } from "@pi-archimedes/ui/editor";
+
+/**
+ * The onboarding modal's result. Each `*Answered` flag tells the orchestrator
+ * (Task 4) whether the user actually committed that step — an unanswered step
+ * is left untouched on the write side. `thinkingValue`/`toolValue` are only
+ * meaningful when their step was answered; `pluginSelections` maps every plugin
+ * id to its final on/off state (present regardless, so the orchestrator can
+ * diff against the current flags).
+ */
+export interface OnboardingResult {
+  thinkingAnswered: boolean;
+  thinkingValue: ThinkingStyle;
+  toolAnswered: boolean;
+  toolValue: ToolStyle;
+  pluginsAnswered: boolean;
+  pluginSelections: Record<string, boolean>;
+  spinnerAnswered: boolean;
+  spinnerValue: string;
+}
+
+export interface OnboardingOverlayOptions {
+  theme: OverlayTheme;
+  thinkingDefault: ThinkingStyle;
+  toolDefault: ToolStyle;
+  plugins: { id: string; label: string; description: string; selected: boolean }[];
+  spinners: readonly string[];
+  spinnerDefault: string;
+  /** The TUI repaint hook (the `ui.custom` factory's `tui.requestRender`) — when provided, the spinner step's live 4-cell previews animate on a 40 ms tick; without it the previews are static (tick 0) and no timer runs. */
+  requestRender?: () => void;
+  onDone: (result: OnboardingResult) => void;
+}
+
+// The single "style" question was split into two INDEPENDENT ones (thinking +
+// tool) so the user can mix, e.g. "Full thinking" + "Minimal tools". The tool
+// question is the styling master switch: Minimal = archimedes-styled tools,
+// Native = no archimedes tool styling at all. Both steps list the standard
+// option first and the compact option second (matching the /archimedes
+// panel's value order: thinkingStyle [Full, Compact], toolStyle
+// [Native, Minimal]).
+const THINKING_OPTIONS: { label: ThinkingStyle; description: string }[] = [
+  { label: "Full", description: "Show all of the model's reasoning" },
+  { label: "Compact", description: "One line of reasoning (click to expand)" },
+];
+const TOOL_OPTIONS: { label: ToolStyle; description: string }[] = [
+  { label: "Native", description: "Pi's native tool rendering (no styling)" },
+  { label: "Minimal", description: "Archimedes-styled tools (minimal view)" },
+];
+
+/**
+ * Build the onboarding wizard as a single pure TUI component: one `ui.custom`
+ * overlay with an internal `step` state (0 → 1 → 2 → 3) and no open/close
+ * flicker between steps. It is deliberately NOT a reuse of the `ask`
+ * package's `askQuestionsWithTabs` (whose "Other" option,
+ * cancel-discards-everything semantics, and blocked empty-multi-select don't
+ * fit a setup wizard).
+ *
+ * It is a pure function: it takes the pre-selected values + an `onDone`
+ * callback and returns a TUI component; it knows nothing about settings or
+ * plugins, so it is testable in isolation. The `theme` is typed as the
+ * structural `OverlayTheme` (not the `Theme` class, which has private members
+ * and can't be satisfied by a plain object mock).
+ */
+export function createOnboardingOverlay(opts: OnboardingOverlayOptions) {
+  const theme = opts.theme;
+  let activeStep = 0;
+  // Clamp the pre-selected indices (a corrupt/unknown value → index 0, never -1).
+  const cursorByStep: number[] = [
+    Math.max(0, THINKING_OPTIONS.findIndex((o) => o.label === opts.thinkingDefault)),
+    Math.max(0, TOOL_OPTIONS.findIndex((o) => o.label === opts.toolDefault)),
+    0,
+    Math.max(0, opts.spinners.indexOf(opts.spinnerDefault)),
+  ];
+  const pluginToggles: boolean[] = opts.plugins.map((p) => p.selected);
+  const confirmed: boolean[] = [false, false, false, false];
+  let finalized = false;
+  // The live spinner-preview tick (the spinner step renders `spinFrame(name, tick)` next to each name); only advances when a repaint hook is provided.
+  let tick = 0;
+  const onTick = opts.requestRender;
+  // Only the spinner step (3) renders a live frame — don't advance the tick or
+  // request a repaint while the user is on the thinking/tool/plugin steps.
+  const timer = onTick
+    ? setInterval(() => {
+        if (activeStep === 3) {
+          tick += 1;
+          onTick();
+        }
+      }, 40)
+    : undefined;
+
+  function optionsCountForStep(step: number): number {
+    if (step === 0) return THINKING_OPTIONS.length;
+    if (step === 1) return TOOL_OPTIONS.length;
+    if (step === 2) return opts.plugins.length;
+    return opts.spinners.length;
+  }
+
+  function finalize(): void {
+    if (finalized) return;
+    finalized = true;
+    // Belt-and-braces: stop the interval the moment the wizard is done (in case
+    // the TUI tears down without calling dispose()).
+    if (timer) clearInterval(timer);
+    const thinkingIdx = cursorByStep[0] ?? 0;
+    const toolIdx = cursorByStep[1] ?? 0;
+    const spinnerIdx = cursorByStep[3] ?? 0;
+    const pluginSelections: Record<string, boolean> = {};
+    for (let i = 0; i < opts.plugins.length; i++) {
+      const p = opts.plugins[i];
+      if (!p) continue;
+      pluginSelections[p.id] = pluginToggles[i] ?? false;
+    }
+    opts.onDone({
+      thinkingAnswered: confirmed[0] ?? false,
+      thinkingValue: THINKING_OPTIONS[thinkingIdx]?.label ?? "Full",
+      toolAnswered: confirmed[1] ?? false,
+      toolValue: TOOL_OPTIONS[toolIdx]?.label ?? "Minimal",
+      pluginsAnswered: confirmed[2] ?? false,
+      pluginSelections,
+      spinnerAnswered: confirmed[3] ?? false,
+      spinnerValue: opts.spinners[spinnerIdx] ?? "",
+    });
+  }
+
+  function handleInput(data: string): void {
+    if (matchesKey(data, Key.up)) {
+      cursorByStep[activeStep] = Math.max(0, (cursorByStep[activeStep] ?? 0) - 1);
+      return;
+    }
+    if (matchesKey(data, Key.down)) {
+      // Math.max(0, …): with an empty options list the min() bound alone is -1,
+      // which would drive the cursor negative (same discipline as the up clamp).
+      cursorByStep[activeStep] = Math.max(
+        0,
+        Math.min(
+          optionsCountForStep(activeStep) - 1,
+          (cursorByStep[activeStep] ?? 0) + 1,
+        ),
+      );
+      return;
+    }
+    if (matchesKey(data, Key.space) && activeStep === 2) {
+      const cur = cursorByStep[2] ?? 0;
+      pluginToggles[cur] = !(pluginToggles[cur] ?? false);
+      return;
+    }
+    if (matchesKey(data, Key.enter)) {
+      confirmed[activeStep] = true;
+      if (activeStep === 3) finalize();
+      else activeStep += 1;
+      return;
+    }
+    if (matchesKey(data, Key.escape)) {
+      finalize();
+      return;
+    }
+  }
+
+  function render(width: number): string[] {
+    const lines: string[] = [];
+    lines.push(renderHeader(" Welcome to pi-archimedes ", width - 2, theme));
+    lines.push(padEnd(`Set up your preferences · ${activeStep + 1}/4`, width - 2));
+    lines.push(padEnd("Choices apply from your next session.", width - 2));
+
+    if (activeStep === 0) {
+      lines.push(padEnd("Thinking style", width - 2));
+      lines.push("");
+      for (let i = 0; i < THINKING_OPTIONS.length; i++) {
+        const opt = THINKING_OPTIONS[i];
+        if (!opt) continue;
+        const marker = i === (cursorByStep[0] ?? 0) ? "> " : "  ";
+        lines.push(
+          padEnd(
+            `${marker}${opt.label.padEnd(9)}${truncateToWidth(opt.description, width - 14, "")}`,
+            width - 2,
+          ),
+        );
+      }
+      lines.push("");
+      lines.push(renderFooter(" [↑↓] move  [enter] next  [esc] finish ", width - 2, theme));
+    } else if (activeStep === 1) {
+      lines.push(padEnd("Tool output style", width - 2));
+      lines.push("");
+      for (let i = 0; i < TOOL_OPTIONS.length; i++) {
+        const opt = TOOL_OPTIONS[i];
+        if (!opt) continue;
+        const marker = i === (cursorByStep[1] ?? 0) ? "> " : "  ";
+        lines.push(
+          padEnd(
+            `${marker}${opt.label.padEnd(9)}${truncateToWidth(opt.description, width - 14, "")}`,
+            width - 2,
+          ),
+        );
+      }
+      lines.push("");
+      lines.push(renderFooter(" [↑↓] move  [enter] next  [esc] finish ", width - 2, theme));
+    } else if (activeStep === 2) {
+      lines.push(padEnd("Which plugins do you want?", width - 2));
+      lines.push("");
+      for (let i = 0; i < opts.plugins.length; i++) {
+        const p = opts.plugins[i];
+        if (!p) continue;
+        // The cursor (>) marks the row Space will toggle; the ✓/· marker shows
+        // the row's enabled state — both, so the user sees what they're about
+        // to change and what it currently is.
+        const cursor = i === (cursorByStep[2] ?? 0) ? "> " : "  ";
+        const marker = (pluginToggles[i] ?? false) ? "✓" : "·";
+        const label = truncateToWidth(p.label, 15, "");
+        lines.push(
+          padEnd(
+            `${cursor} ${marker} ${label.padEnd(16)}${truncateToWidth(p.description, width - 26, "")}`,
+            width - 2,
+          ),
+        );
+      }
+      lines.push("");
+      lines.push(renderFooter(" [↑↓] move  [space] toggle  [enter] next  [esc] finish ", width - 2, theme));
+    } else {
+      lines.push(padEnd("Which spinner for the editor border?", width - 2));
+      lines.push("");
+      for (let i = 0; i < opts.spinners.length; i++) {
+        const name = opts.spinners[i] ?? "";
+        const marker = i === (cursorByStep[3] ?? 0) ? "> " : "  ";
+        const preview = spinFrame(name, tick);
+        // Options render consecutively (no blank line between them): the 10
+        // options must fit the overlay's 80% max height on a small terminal
+        // (24 rows → ~19), so the per-option vertical spacing was dropped.
+        lines.push(padEnd(`${marker}${name.padEnd(15)}${preview}`, width - 2));
+      }
+      lines.push("");
+      lines.push(renderFooter(" [↑↓] move  [enter] done  [esc] finish (skip rest) ", width - 2, theme));
+    }
+
+    return wrapWithBorder(lines, width, theme);
+  }
+
+  return {
+    focused: true,
+    render,
+    handleInput,
+    invalidate(): void {},
+    dispose(): void {
+      if (timer) clearInterval(timer);
+    },
+  };
+}

package/src/plugins.test.ts

@@ -51,6 +51,16 @@ vi.mock("@pi-archimedes/core", () => ({
   ]),
 }));
 
+vi.mock("@pi-archimedes/ui", () => ({
+  getUISettingsItems: vi.fn(() => [
+    { id: "mutedTheme", label: "Muted theme", currentValue: "Off", values: ["On", "Off"] },
+  ]),
+  loadUIConfig: vi.fn(() => ({})),
+  saveUIConfig: vi.fn(),
+  registerUI: vi.fn(),
+  unpatchConsoleLog: vi.fn(),
+}));
+
 vi.mock("@pi-archimedes/footer/config", () => ({
   getFooterSettingsItems: vi.fn(() => [
     { id: "splitThreshold", label: "Footer split threshold", currentValue: "120" },
@@ -76,6 +86,7 @@ vi.mock("@pi-archimedes/diff", () => ({
     { id: "diffTheme", label: "Diff theme", currentValue: "github-dark" },
   ]),
 }));
+const { getUISettingsItems } = await import("@pi-archimedes/ui");
 const {
   PLUGINS,
   isPluginEnabled,
@@ -89,14 +100,14 @@ describe("isPluginEnabled (per-namespace gate)", () => {
   });
 
   it("defaults to enabled when config is empty", () => {
-    expect(isPluginEnabled("mcp")).toBe(true);
+    expect(isPluginEnabled("web")).toBe(true);
     expect(isPluginEnabled("footer")).toBe(true);
     expect(isPluginEnabled("diff")).toBe(true);
   });
 
   it("returns false only for the plugin disabled in its own namespace", () => {
-    mockStore["archimedes.mcp"] = { enabled: false };
-    expect(isPluginEnabled("mcp")).toBe(false);
+    mockStore["archimedes.web"] = { enabled: false };
+    expect(isPluginEnabled("web")).toBe(false);
     expect(isPluginEnabled("footer")).toBe(true);
     expect(isPluginEnabled("todo")).toBe(true);
   });
@@ -186,6 +197,7 @@ describe("setPluginEnabled (save path)", () => {
 
 describe("PLUGINS manifest integrity", () => {
   const EXPECTED_IDS = [
+    "ui",
     "footer",
     "todo",
     "ask",
@@ -194,11 +206,11 @@ describe("PLUGINS manifest integrity", () => {
     "diff",
     "image-paste",
     "subagent",
-    "mcp",
+    "web",
     "sudo",
   ];
 
-  it("lists exactly the 10 non-core packages (no drift)", () => {
+  it("lists exactly the 11 non-core packages (no drift)", () => {
     expect([...PLUGINS.map((p) => p.id)].sort()).toEqual([...EXPECTED_IDS].sort());
   });
 
@@ -243,12 +255,12 @@ const ARROW_RIGHT = "\x1b[C";
 
 /** All enabled — no `enabled` keys persisted anywhere. */
 function fakeAllConfig(): Parameters<typeof buildSettingsItems>[0] {
-  // Minimal shape — buildSettingsItems only reads core/notify/sessionName
+  // Minimal shape — buildSettingsItems only reads ui/notify/sessionName
   // through the (mocked) item builders, so missing fields never surface.
   return {
-    core: { mutedTheme: false },
+    ui: {},
     footer: { splitThreshold: 120 },
-    diff: { diffTheme: "github-dark", diffSplitMinWidth: 150, diffSplitMinCodeWidth: 60 },
+    diff: { diffTheme: "github-dark", diffSplitMinWidth: 150, diffSplitMinCodeWidth: 60, diffSplitWrapCheck: true },
     notify: { delayMs: 30000, notifyOnAgentEnd: true, notifyOnQuestion: true },
     sessionName: {},
   } as unknown as Parameters<typeof buildSettingsItems>[0];
@@ -258,6 +270,7 @@ describe("buildSettingsItems (settings gate)", () => {
   beforeEach(() => {
     for (const key of Object.keys(mockStore)) delete mockStore[key];
     vi.mocked(getDiffSettingsItems).mockClear();
+    vi.mocked(getUISettingsItems).mockClear();
   });
 
   it("includes all packages' items when everything is enabled, and lazy-imports diff", async () => {
@@ -272,9 +285,10 @@ describe("buildSettingsItems (settings gate)", () => {
     mockStore["archimedes.diff"] = { enabled: false };
     mockStore["archimedes.sessionName"] = { enabled: false };
     mockStore["archimedes.notify"] = { enabled: false };
+    mockStore["archimedes.ui"] = { enabled: false };
     const items = await buildSettingsItems(fakeAllConfig());
-    // Core items are always present
-    expect(items.map((i) => i.id)).toContain("mutedTheme");
+    // Core (UI) items are no longer automatically present
+    expect(items.map((i) => i.id)).not.toContain("mutedTheme");
     // No item from a disabled package
     for (const id of ["splitThreshold", "diffTheme", "delayMs", "sessionNameModel"]) {
       expect(items.map((i) => i.id)).not.toContain(id);

package/src/plugins.ts

@@ -10,15 +10,16 @@
 import { isConfigEnabled, setConfigEnabled, loadConfig, removeConfig } from "@pi-archimedes/core/settings-io";
 
 export interface PluginDef {
-  id: string;              // matches package npm name suffix, e.g. "mcp"
-  label: string;           // human label, e.g. "MCP"
+  id: string;              // matches package npm name suffix, e.g. "web"
+  label: string;           // human label, e.g. "Web"
   description: string;     // one-liner shown in the menu
-  namespace: string;       // "archimedes.mcp" — the settings.json key holding this plugin's { enabled, ...settings }
+  namespace: string;       // "archimedes.web" — the settings.json key holding this plugin's { enabled, ...settings }
   load: () => Promise<unknown>; // lazy import for instance probing + future lazy mount
 }
 
 // Array order = menu display order. There is no separate order constant.
 export const PLUGINS: PluginDef[] = [
+  { id: "ui",           label: "UI Enhancements",    description: "Bash styling, editor spinner, thinking collapse, splash animation", namespace: "archimedes.ui",           load: () => import("@pi-archimedes/ui") },
   { id: "footer",       label: "Footer status bar",  description: "Status bar with cost/timer",                      namespace: "archimedes.footer",      load: () => import("@pi-archimedes/footer") },
   { id: "todo",         label: "Todo list",          description: "manage_todo_list tool + widget",                  namespace: "archimedes.todo",        load: () => import("@pi-archimedes/todo") },
   { id: "ask",          label: "Ask tool",           description: "Structured in-conversation questions",            namespace: "archimedes.ask",         load: () => import("@pi-archimedes/ask") },
@@ -27,7 +28,7 @@ export const PLUGINS: PluginDef[] = [
   { id: "diff",         label: "Diff rendering",     description: "Shiki-powered diff display",                      namespace: "archimedes.diff",        load: () => import("@pi-archimedes/diff") },
   { id: "image-paste",  label: "Image paste",        description: "Clipboard image paste",                           namespace: "archimedes.imagePaste",  load: () => import("@pi-archimedes/image-paste") },
   { id: "subagent",     label: "Subagents",          description: "Live subagent dispatch (general, reviewer, …)",  namespace: "archimedes.subagent",    load: () => import("@pi-archimedes/subagent") },
-  { id: "mcp",          label: "MCP",                description: "MCP client adapter + /mcp commands",             namespace: "archimedes.mcp",         load: () => import("@pi-archimedes/mcp") },
+  { id: "web",          label: "Web",                description: "Web search and content fetching with multi-provider routing", namespace: "archimedes.web",         load: () => import("@pi-archimedes/web") },
   { id: "sudo",         label: "Sudo",                 description: "Safe privileged execution",                      namespace: "archimedes.sudo",      load: () => import("@pi-archimedes/sudo") },
 ];
 

package/src/settings.ts

@@ -1,25 +1,20 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { SettingItem } from "@earendil-works/pi-tui";
 
-import { getCoreSettingsItems } from "@pi-archimedes/core";
-import { OVERLAY_CHROME } from "@pi-archimedes/core/overlay";
+import { getUISettingsItems, saveUIConfig, normalizeThinkingStyle, normalizeToolStyle, type UIConfig } from "@pi-archimedes/ui";
 import { getFooterSettingsItems } from "@pi-archimedes/footer/config";
-// diff (shiki) is lazy-loaded inside buildSettingsItems AND gated by the
-// per-namespace plugin gate (archimedes.diff.enabled — see ADR 0012) —
-// disabled means shiki is never imported
 import { getNotifySettingsItems } from "@pi-archimedes/notify";
 import { getSessionNameSettingsItems } from "@pi-archimedes/session-name";
 import {
   loadAllConfig,
-  saveCoreConfig,
   saveFooterConfig,
   saveDiffConfig,
   saveNotifyConfig,
   saveSessionNameConfig,
-  type CoreConfig,
   type NotifyConfig,
 } from "./config.js";
 import { isPluginEnabled } from "./plugins.js";
+import { OVERLAY_CHROME } from "@pi-archimedes/core/overlay";
 import { createSettingsManager, type PromptDescriptor } from "./settings-manager.js";
 
 // ── Free-input prompt descriptors (keyed by item.id) ───────────────────────
@@ -43,7 +38,11 @@ const PROMPTS: Record<string, PromptDescriptor> = {
 // not leak back in through the settings overlay. The diff import (heavy —
 // pulls in shiki) is lazy AND inside the gate: disabled diff is never loaded.
 export async function buildSettingsItems(allConfig: ReturnType<typeof loadAllConfig>): Promise<SettingItem[]> {
-  const items: SettingItem[] = [...getCoreSettingsItems({ ...allConfig.core })];
+  const items: SettingItem[] = [];
+
+  if (isPluginEnabled("ui")) {
+    items.push(...getUISettingsItems({ ...allConfig.ui }));
+  }
 
   if (isPluginEnabled("footer")) {
     items.push(...getFooterSettingsItems());
@@ -51,7 +50,7 @@ export async function buildSettingsItems(allConfig: ReturnType<typeof loadAllCon
 
   if (isPluginEnabled("diff")) {
     const { getDiffSettingsItems } = await import("@pi-archimedes/diff");
-    items.push(...getDiffSettingsItems());
+    items.push(...getDiffSettingsItems(allConfig.diff));
   }
 
   if (isPluginEnabled("notify")) {
@@ -76,7 +75,7 @@ export async function buildSettingsItems(allConfig: ReturnType<typeof loadAllCon
 export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
   const allConfig = loadAllConfig();
 
-  const coreConfig: CoreConfig = { ...allConfig.core };
+  const uiConfig: UIConfig = { ...allConfig.ui };
   const notifyConfig: NotifyConfig = { ...allConfig.notify };
   const footerConfig = { ...allConfig.footer };
   const diffConfig = { ...allConfig.diff };
@@ -91,16 +90,20 @@ export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Pro
       theme,
       onChange: (id: string, newValue: string) => {
         switch (id) {
-          // ── Core settings ──
-          case "mutedTheme": coreConfig.mutedTheme = newValue === "On"; break;
-          case "codeUnindent": coreConfig.codeUnindent = newValue === "On"; break;
-          case "editorSpinBorder": coreConfig.editorSpinBorder = newValue === "On"; break;
-          case "editorSpinSpeed": coreConfig.editorSpinSpeed = newValue.toLowerCase() as CoreConfig["editorSpinSpeed"]; break;
-          case "editorSpinStyle": coreConfig.editorSpinStyle = newValue.toLowerCase().replace(/ /g, "-") as CoreConfig["editorSpinStyle"]; break;
-          case "editorSpinLabel": coreConfig.editorSpinLabel = newValue; break;
-          case "labelText": coreConfig.labelText = newValue; break;
-          case "labelColor": coreConfig.labelColor = newValue; break;
-          case "animationStyle": coreConfig.animationStyle = newValue as CoreConfig["animationStyle"]; break;
+          // ── UI settings ──
+          case "bashToolStyling": uiConfig.bashToolStyling = newValue === "On"; break;
+          case "mutedTheme": uiConfig.mutedTheme = newValue === "On"; break;
+          case "autoCollapseThinking": uiConfig.autoCollapseThinking = newValue === "On"; break;
+          case "thinkingStyle": uiConfig.thinkingStyle = normalizeThinkingStyle(newValue); break;
+          case "toolStyle": uiConfig.toolStyle = normalizeToolStyle(newValue); break;
+          case "codeUnindent": uiConfig.codeUnindent = newValue === "On"; break;
+          case "editorSpinBorder": uiConfig.editorSpinBorder = newValue === "On"; break;
+          case "editorSpinSpeed": uiConfig.editorSpinSpeed = newValue.toLowerCase() as UIConfig["editorSpinSpeed"]; break;
+          case "editorSpinStyle": uiConfig.editorSpinStyle = newValue.toLowerCase().replace(/ /g, "-") as UIConfig["editorSpinStyle"]; break;
+          case "editorSpinLabel": uiConfig.editorSpinLabel = newValue; break;
+          case "labelText": uiConfig.labelText = newValue; break;
+          case "labelColor": uiConfig.labelColor = newValue; break;
+          case "animationStyle": uiConfig.animationStyle = newValue as UIConfig["animationStyle"]; break;
 
           // ── Footer settings ──
           case "splitThreshold": {
@@ -121,6 +124,7 @@ export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Pro
             if (Number.isFinite(v)) diffConfig.diffSplitMinCodeWidth = v;
             break;
           }
+          case "diffSplitWrapCheck": diffConfig.diffSplitWrapCheck = newValue === "On"; break;
 
           // ── Notify settings ──
           case "notifyOnAgentEnd": notifyConfig.notifyOnAgentEnd = newValue === "On"; break;
@@ -136,7 +140,7 @@ export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Pro
         }
       },
       onSave: () => {
-        saveCoreConfig(coreConfig);
+        saveUIConfig(uiConfig);
         saveFooterConfig(footerConfig);
         saveDiffConfig(diffConfig);
         saveNotifyConfig(notifyConfig);