@pi-archimedes/ui 2.9.0

package/src/migration.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+vi.mock("@pi-archimedes/core/settings-io", () => ({
+  loadConfig: vi.fn(),
+  saveConfig: vi.fn(),
+  removeConfig: vi.fn(),
+}));
+
+import { migrateCoreToUIConfig, migrateCompactThinkingToStyle, migrateRemovedToolPatch, UI_CONFIG_KEYS } from "./migration.js";
+import { loadConfig, saveConfig, removeConfig } from "@pi-archimedes/core/settings-io";
+import { ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
+
+describe("migrateCoreToUIConfig", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("is a no-op when archimedes.core has no keys", () => {
+    vi.mocked(loadConfig).mockReturnValue({});
+    migrateCoreToUIConfig();
+    expect(saveConfig).not.toHaveBeenCalled();
+    expect(removeConfig).not.toHaveBeenCalled();
+  });
+
+  it("is a no-op when archimedes.core has no UI keys", () => {
+    vi.mocked(loadConfig).mockImplementation((ns: string) => {
+      if (ns === "archimedes.core") return { nonUIKey: "value" };
+      return {};
+    });
+    migrateCoreToUIConfig();
+    expect(saveConfig).not.toHaveBeenCalled();
+    expect(removeConfig).not.toHaveBeenCalled();
+  });
+
+  it("migrates UI keys from archimedes.core to archimedes.ui and removes empty archimedes.core", () => {
+    const coreSettings: Record<string, unknown> = {
+      mutedTheme: true,
+      editorSpinSpeed: "fast",
+      animationStyle: "wave",
+    };
+    const uiSettings: Record<string, unknown> = {};
+
+    vi.mocked(loadConfig).mockImplementation((ns: string) => {
+      if (ns === "archimedes.core") return { ...coreSettings };
+      if (ns === "archimedes.ui") return { ...uiSettings };
+      return {};
+    });
+
+    migrateCoreToUIConfig();
+
+    expect(saveConfig).toHaveBeenCalledWith("archimedes.ui", {
+      mutedTheme: true,
+      editorSpinSpeed: "fast",
+      animationStyle: "wave",
+    });
+    expect(removeConfig).toHaveBeenCalledWith("archimedes.core");
+  });
+
+  it("preserves non-UI keys in archimedes.core", () => {
+    const coreSettings: Record<string, unknown> = {
+      mutedTheme: true,
+      otherPluginKey: 42,
+    };
+
+    vi.mocked(loadConfig).mockImplementation((ns: string) => {
+      if (ns === "archimedes.core") return { ...coreSettings };
+      if (ns === "archimedes.ui") return {};
+      return {};
+    });
+
+    migrateCoreToUIConfig();
+
+    expect(saveConfig).toHaveBeenCalledWith("archimedes.ui", {
+      mutedTheme: true,
+    });
+    expect(saveConfig).toHaveBeenCalledWith("archimedes.core", {
+      otherPluginKey: 42,
+    });
+    expect(removeConfig).not.toHaveBeenCalled();
+  });
+
+  it("does not overwrite already existing keys in archimedes.ui", () => {
+    const coreSettings: Record<string, unknown> = {
+      mutedTheme: true,
+      labelText: "Old label",
+    };
+    const uiSettings: Record<string, unknown> = {
+      mutedTheme: false,
+    };
+
+    vi.mocked(loadConfig).mockImplementation((ns: string) => {
+      if (ns === "archimedes.core") return { ...coreSettings };
+      if (ns === "archimedes.ui") return { ...uiSettings };
+      return {};
+    });
+
+    migrateCoreToUIConfig();
+
+    expect(saveConfig).toHaveBeenCalledWith("archimedes.ui", {
+      mutedTheme: false,
+      labelText: "Old label",
+    });
+    expect(removeConfig).toHaveBeenCalledWith("archimedes.core");
+  });
+
+  it("exports UI_CONFIG_KEYS containing all UI setting keys", () => {
+    expect(UI_CONFIG_KEYS).toContain("bashToolStyling");
+    expect(UI_CONFIG_KEYS).toContain("thinkingStyle");
+    expect(UI_CONFIG_KEYS).toContain("toolStyle");
+    expect(UI_CONFIG_KEYS).toContain("mutedTheme");
+    expect(UI_CONFIG_KEYS).toContain("autoCollapseThinking");
+    expect(UI_CONFIG_KEYS).toContain("compactThinking");
+    expect(UI_CONFIG_KEYS).toContain("codeUnindent");
+    expect(UI_CONFIG_KEYS).toContain("labelText");
+    expect(UI_CONFIG_KEYS).toContain("labelColor");
+    expect(UI_CONFIG_KEYS).toContain("animationStyle");
+    expect(UI_CONFIG_KEYS).toContain("editorSpinBorder");
+    expect(UI_CONFIG_KEYS).toContain("editorSpinSpeed");
+    expect(UI_CONFIG_KEYS).toContain("editorSpinLabel");
+    expect(UI_CONFIG_KEYS).toContain("editorSpinStyle");
+  });
+});
+
+describe("migrateCompactThinkingToStyle", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("converts legacy 'Off' to thinkingStyle 'Full' and deletes compactThinking", () => {
+    vi.mocked(loadConfig).mockImplementation((ns: string) => {
+      if (ns === "archimedes.ui") return { compactThinking: "Off", mutedTheme: true };
+      return {};
+    });
+
+    migrateCompactThinkingToStyle();
+
+    expect(saveConfig).toHaveBeenCalledWith("archimedes.ui", {
+      mutedTheme: true,
+      thinkingStyle: "Full",
+    });
+  });
+
+  it("converts legacy '1 line' / '3 lines' / '5 lines' to thinkingStyle 'Compact'", () => {
+    for (const legacy of ["1 line", "3 lines", "5 lines"] as const) {
+      vi.clearAllMocks();
+      vi.mocked(loadConfig).mockImplementation((ns: string) => {
+        if (ns === "archimedes.ui") return { compactThinking: legacy };
+        return {};
+      });
+
+      migrateCompactThinkingToStyle();
+
+      expect(saveConfig).toHaveBeenCalledWith("archimedes.ui", {
+        thinkingStyle: "Compact",
+      });
+    }
+  });
+
+  it("maps unknown legacy values to thinkingStyle 'Full'", () => {
+    vi.mocked(loadConfig).mockImplementation((ns: string) => {
+      if (ns === "archimedes.ui") return { compactThinking: "7 lines" };
+      return {};
+    });
+
+    migrateCompactThinkingToStyle();
+
+    expect(saveConfig).toHaveBeenCalledWith("archimedes.ui", {
+      thinkingStyle: "Full",
+    });
+  });
+
+  it("is a no-op (no saveConfig call) when compactThinking is absent", () => {
+    vi.mocked(loadConfig).mockImplementation((ns: string) => {
+      if (ns === "archimedes.ui") return { thinkingStyle: "Full" };
+      return {};
+    });
+
+    migrateCompactThinkingToStyle();
+
+    expect(saveConfig).not.toHaveBeenCalled();
+  });
+
+  it("preserves an existing thinkingStyle and deletes compactThinking when both are present", () => {
+    vi.mocked(loadConfig).mockImplementation((ns: string) => {
+      if (ns === "archimedes.ui")
+        return { compactThinking: "1 line", thinkingStyle: "Full", toolStyle: "Compact" };
+      return {};
+    });
+
+    migrateCompactThinkingToStyle();
+
+    expect(saveConfig).toHaveBeenCalledWith("archimedes.ui", {
+      thinkingStyle: "Full",
+      toolStyle: "Compact",
+    });
+  });
+});
+
+describe("migrateRemovedToolPatch", () => {
+  // The old patch saved the TRUE originals on the shared prototype under
+  // Symbol.for markers; the migration restores them and drops the markers.
+  // The prototype is process-global, so save/restore the real methods.
+  const proto: any = ToolExecutionComponent.prototype;
+  const ORIG_UPDATE = Symbol.for("archimedes:toolOrigUpdate");
+  const ORIG_SET_EXPANDED = Symbol.for("archimedes:toolOrigSetExpanded");
+  const realUpdateDisplay = proto.updateDisplay;
+  const realSetExpanded = proto.setExpanded;
+
+  afterEach(() => {
+    proto.updateDisplay = realUpdateDisplay;
+    proto.setExpanded = realSetExpanded;
+    delete proto[ORIG_UPDATE];
+    delete proto[ORIG_SET_EXPANDED];
+  });
+
+  it("restores the true originals and drops the markers when the old patch is present", () => {
+    const sentinelUpdate = function (this: unknown): unknown {
+      return "orig";
+    };
+    const sentinelSetExpanded = function (this: unknown): void {};
+    proto[ORIG_UPDATE] = sentinelUpdate;
+    proto[ORIG_SET_EXPANDED] = sentinelSetExpanded;
+    proto.updateDisplay = function (this: unknown): unknown {
+      return "wrapper";
+    };
+    proto.setExpanded = function (this: unknown): void {};
+
+    migrateRemovedToolPatch();
+
+    expect(proto.updateDisplay).toBe(sentinelUpdate);
+    expect(proto.setExpanded).toBe(sentinelSetExpanded);
+    expect(proto[ORIG_UPDATE]).toBeUndefined();
+    expect(proto[ORIG_SET_EXPANDED]).toBeUndefined();
+  });
+
+  it("is a no-op when the markers are absent (fresh process)", () => {
+    migrateRemovedToolPatch();
+    expect(proto.updateDisplay).toBe(realUpdateDisplay);
+    expect(proto.setExpanded).toBe(realSetExpanded);
+  });
+
+  it("is idempotent (a second run is a no-op)", () => {
+    const sentinelUpdate = function (this: unknown): unknown {
+      return "orig";
+    };
+    proto[ORIG_UPDATE] = sentinelUpdate;
+    proto.updateDisplay = function (this: unknown): unknown {
+      return "wrapper";
+    };
+
+    migrateRemovedToolPatch();
+    const restored = proto.updateDisplay;
+    migrateRemovedToolPatch();
+    expect(proto.updateDisplay).toBe(restored);
+  });
+});

package/src/migration.ts

@@ -0,0 +1,94 @@
+import { loadConfig, saveConfig, removeConfig } from "@pi-archimedes/core/settings-io";
+import { ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
+import type { UIConfig } from "./config.js";
+
+export const UI_CONFIG_KEYS: readonly (keyof UIConfig | "compactThinking")[] = [
+  "bashToolStyling",
+  "mutedTheme",
+  "autoCollapseThinking",
+  "compactThinking",
+  "thinkingStyle",
+  "toolStyle",
+  "codeUnindent",
+  "labelText",
+  "labelColor",
+  "animationStyle",
+  "editorSpinBorder",
+  "editorSpinSpeed",
+  "editorSpinLabel",
+  "editorSpinStyle",
+] as const;
+
+/**
+ * One-time migration: copies any existing UI keys from archimedes.core to archimedes.ui
+ * and removes them from archimedes.core. If archimedes.core is left empty, the namespace is removed.
+ */
+export function migrateCoreToUIConfig(): void {
+  const core = loadConfig("archimedes.core", {}) as Record<string, unknown>;
+  const keysToMigrate = UI_CONFIG_KEYS.filter((k) => k in core);
+  if (keysToMigrate.length === 0) return;
+
+  const ui = loadConfig("archimedes.ui", {}) as Record<string, unknown>;
+
+  for (const key of keysToMigrate) {
+    if (!(key in ui)) {
+      ui[key] = core[key];
+    }
+    delete core[key];
+  }
+
+  saveConfig("archimedes.ui", ui);
+
+  if (Object.keys(core).length === 0) {
+    removeConfig("archimedes.core");
+  } else {
+    saveConfig("archimedes.core", core);
+  }
+}
+
+/**
+ * One-time migration: removes the `toolStyle: "Full"` auto-expand patch from
+ * `ToolExecutionComponent`'s prototype, if an older version installed it in
+ * this process. The old patch saved the TRUE originals on the prototype under
+ * `Symbol.for` markers (which survive a jiti re-evaluation); since the patch
+ * is gone from the codebase, the wrappers would otherwise survive a `/reload`
+ * in the same process and keep auto-expanding tools even when the reloaded
+ * setting is Native/Minimal. Restoring the originals (and dropping the
+ * markers) makes the removal stick. Idempotent: a no-op when the markers are
+ * absent (fresh process, or never patched).
+ */
+export function migrateRemovedToolPatch(): void {
+  const proto: any = ToolExecutionComponent?.prototype;
+  if (!proto) return;
+  const ORIG_UPDATE = Symbol.for("archimedes:toolOrigUpdate");
+  const ORIG_SET_EXPANDED = Symbol.for("archimedes:toolOrigSetExpanded");
+  if (proto[ORIG_UPDATE]) {
+    proto.updateDisplay = proto[ORIG_UPDATE];
+    delete proto[ORIG_UPDATE];
+  }
+  if (proto[ORIG_SET_EXPANDED]) {
+    proto.setExpanded = proto[ORIG_SET_EXPANDED];
+    delete proto[ORIG_SET_EXPANDED];
+  }
+}
+
+/**
+ * One-time migration: converts the legacy `compactThinking` setting to the new
+ * `thinkingStyle` (Full/Compact) and removes `compactThinking` from archimedes.ui.
+ * Idempotent: a no-op when `compactThinking` is already gone. An existing
+ * `thinkingStyle` is preserved; `toolStyle` is never touched.
+ */
+export function migrateCompactThinkingToStyle(): void {
+  const raw = loadConfig("archimedes.ui", {});
+  if (!("compactThinking" in raw)) return; // idempotent no-op
+  const migrated: Record<string, unknown> = { ...raw };
+  delete migrated.compactThinking;
+  if (!("thinkingStyle" in migrated)) {
+    const legacy = raw.compactThinking;
+    migrated.thinkingStyle =
+      legacy === "Off" ? "Full"
+      : legacy === "1 line" || legacy === "3 lines" || legacy === "5 lines" ? "Compact"
+      : "Full";
+  }
+  saveConfig("archimedes.ui", migrated);
+}

package/src/settings.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect } from "vitest";
+import { getUISettingsItems } from "./settings.js";
+import { DEFAULT_UI_CONFIG, ANIMATION_STYLES, type UIConfig } from "./config.js";
+
+describe("getUISettingsItems", () => {
+  it("exposes all 14 UI setting items with correct defaults", () => {
+    const items = getUISettingsItems(DEFAULT_UI_CONFIG);
+    expect(items).toHaveLength(14);
+
+    const ids = items.map((i) => i.id);
+    expect(ids).toEqual([
+      "bashToolStyling",
+      "codemodeToolStyling",
+      "mutedTheme",
+      "autoCollapseThinking",
+      "thinkingStyle",
+      "toolStyle",
+      "codeUnindent",
+      "labelText",
+      "labelColor",
+      "animationStyle",
+      "editorSpinBorder",
+      "editorSpinSpeed",
+      "editorSpinStyle",
+      "editorSpinLabel",
+    ]);
+
+    expect(items.find((i) => i.id === "bashToolStyling")?.currentValue).toBe("On");
+    expect(items.find((i) => i.id === "codemodeToolStyling")?.currentValue).toBe("On");
+    expect(items.find((i) => i.id === "mutedTheme")?.currentValue).toBe("Off");
+    expect(items.find((i) => i.id === "autoCollapseThinking")?.currentValue).toBe("Off");
+    expect(items.find((i) => i.id === "thinkingStyle")?.currentValue).toBe("Full");
+    expect(items.find((i) => i.id === "toolStyle")?.currentValue).toBe("Minimal");
+    expect(items.find((i) => i.id === "codeUnindent")?.currentValue).toBe("On");
+    expect(items.find((i) => i.id === "labelText")?.currentValue).toBe("Thinking...");
+    expect(items.find((i) => i.id === "labelColor")?.currentValue).toBe("255,215,0");
+    expect(items.find((i) => i.id === "animationStyle")?.currentValue).toBe("vertical-up");
+    expect(items.find((i) => i.id === "editorSpinBorder")?.currentValue).toBe("On");
+    expect(items.find((i) => i.id === "editorSpinSpeed")?.currentValue).toBe("Normal");
+    expect(items.find((i) => i.id === "editorSpinStyle")?.currentValue).toBe("Pendulum");
+    expect(items.find((i) => i.id === "editorSpinLabel")?.currentValue).toBe("Working");
+  });
+
+  it("exposes bashToolStyling correctly when toggled off", () => {
+    const items = getUISettingsItems({ ...DEFAULT_UI_CONFIG, bashToolStyling: false });
+    const item = items.find((i) => i.id === "bashToolStyling");
+    expect(item).toBeDefined();
+    expect(item!.currentValue).toBe("Off");
+    expect(item!.values).toEqual(["On", "Off"]);
+  });
+
+  it("exposes codemodeToolStyling correctly when toggled off", () => {
+    const items = getUISettingsItems({ ...DEFAULT_UI_CONFIG, codemodeToolStyling: false });
+    const item = items.find((i) => i.id === "codemodeToolStyling");
+    expect(item).toBeDefined();
+    expect(item!.currentValue).toBe("Off");
+    expect(item!.values).toEqual(["On", "Off"]);
+  });
+
+  it("exposes thinkingStyle and toolStyle with their values and normalizes invalid values", () => {
+    const items = getUISettingsItems({ ...DEFAULT_UI_CONFIG, thinkingStyle: "invalid" as never });
+    const thinkingItem = items.find((i) => i.id === "thinkingStyle");
+    expect(thinkingItem).toBeDefined();
+    expect(thinkingItem!.currentValue).toBe("Full");
+    expect(thinkingItem!.values).toEqual(["Full", "Compact"]);
+
+    const toolItem = items.find((i) => i.id === "toolStyle");
+    expect(toolItem).toBeDefined();
+    expect(toolItem!.currentValue).toBe("Minimal");
+    expect(toolItem!.values).toEqual(["Native", "Minimal"]);
+  });
+
+  it("normalizes legacy toolStyle values (Full → Minimal, Compact → Minimal)", () => {
+    expect(
+      getUISettingsItems({ ...DEFAULT_UI_CONFIG, toolStyle: "Full" as never })
+        .find((i) => i.id === "toolStyle")?.currentValue,
+    ).toBe("Minimal");
+    expect(
+      getUISettingsItems({ ...DEFAULT_UI_CONFIG, toolStyle: "Compact" as never })
+        .find((i) => i.id === "toolStyle")?.currentValue,
+    ).toBe("Minimal");
+  });
+
+  it("exposes animationStyle with ANIMATION_STYLES values", () => {
+    const item = getUISettingsItems(DEFAULT_UI_CONFIG).find((i) => i.id === "animationStyle");
+    expect(item?.values).toEqual([...ANIMATION_STYLES]);
+  });
+
+  describe("robustness with hand-edited (corrupt) values", () => {
+    it("an empty-string editorSpinSpeed projects to 'Normal'", () => {
+      const items = getUISettingsItems({
+        ...DEFAULT_UI_CONFIG,
+        editorSpinSpeed: "" as never,
+      });
+      expect(items.find((i) => i.id === "editorSpinSpeed")?.currentValue).toBe("Normal");
+    });
+
+    it("a number editorSpinSpeed projects to 'Normal'", () => {
+      const items = getUISettingsItems({
+        ...DEFAULT_UI_CONFIG,
+        editorSpinSpeed: 42 as never,
+      });
+      expect(items.find((i) => i.id === "editorSpinSpeed")?.currentValue).toBe("Normal");
+    });
+
+    it("a trailing-dash editorSpinStyle projects without throwing", () => {
+      const items = getUISettingsItems({
+        ...DEFAULT_UI_CONFIG,
+        editorSpinStyle: "wave-" as never,
+      });
+      expect(items.find((i) => i.id === "editorSpinStyle")?.currentValue).toBe("Wave");
+    });
+
+    it("a null editorSpinStyle projects to 'Typing'", () => {
+      const items = getUISettingsItems({
+        ...DEFAULT_UI_CONFIG,
+        editorSpinStyle: null as never,
+      });
+      expect(items.find((i) => i.id === "editorSpinStyle")?.currentValue).toBe("Typing");
+    });
+  });
+});

package/src/settings.ts

@@ -0,0 +1,135 @@
+import type { SettingItem } from "@earendil-works/pi-tui";
+import {
+  ANIMATION_STYLES,
+  normalizeThinkingStyle,
+  normalizeToolStyle,
+  type UIConfig,
+} from "./config.js";
+
+export function getUISettingsItems(config: UIConfig): SettingItem[] {
+  return [
+    {
+      id: "bashToolStyling",
+      label: "Bash Tool Styling",
+      description: "Archimedes styling for bash tool execution (applies when Tool Style is Minimal)",
+      currentValue: config.bashToolStyling ? "On" : "Off",
+      values: ["On", "Off"],
+    },
+    {
+      id: "codemodeToolStyling",
+      label: "Codemode Tool Styling",
+      description: "Archimedes styling for the codemode tool (applies when Tool Style is Minimal)",
+      currentValue: config.codemodeToolStyling ? "On" : "Off",
+      values: ["On", "Off"],
+    },
+    {
+      id: "mutedTheme",
+      label: "Muted Theme",
+      description: "Use muted colors for thinking blocks",
+      currentValue: config.mutedTheme ? "On" : "Off",
+      values: ["On", "Off"],
+    },
+    {
+      id: "autoCollapseThinking",
+      label: "Auto-Collapse Thinking",
+      description: "Collapse thinking blocks after thinking completes",
+      currentValue: config.autoCollapseThinking ? "On" : "Off",
+      values: ["On", "Off"],
+    },
+    {
+      id: "thinkingStyle",
+      label: "Thinking Style",
+      description: "How thinking blocks display (Full = full text, Compact = one line, click to expand)",
+      currentValue: normalizeThinkingStyle(config.thinkingStyle),
+      values: ["Full", "Compact"],
+    },
+    {
+      id: "toolStyle",
+      label: "Tool Style",
+      description: "Tool rendering (Minimal = archimedes styled, Native = pi native, no archimedes styling)",
+      currentValue: normalizeToolStyle(config.toolStyle),
+      values: ["Native", "Minimal"],
+    },
+    {
+      id: "codeUnindent",
+      label: "Code Unindent",
+      description: "Remove 2-space indent from code blocks",
+      currentValue: config.codeUnindent ? "On" : "Off",
+      values: ["On", "Off"],
+    },
+    {
+      id: "labelText",
+      label: "Label Text",
+      description: "Text shown before thinking blocks",
+      currentValue: config.labelText,
+    },
+    {
+      id: "labelColor",
+      label: "Label Color",
+      description: "RGB color for thinking label (e.g. 255,215,0)",
+      currentValue: config.labelColor,
+    },
+    {
+      id: "animationStyle",
+      label: "Logo Animation",
+      description: "Splashscreen logo reveal style",
+      currentValue: config.animationStyle,
+      values: [...ANIMATION_STYLES],
+    },
+    {
+      id: "editorSpinBorder",
+      label: "Editor Spin Border",
+      description: "Type across the editor's top border while the agent is working (hides the “Working” line)",
+      currentValue: config.editorSpinBorder ? "On" : "Off",
+      values: ["On", "Off"],
+    },
+    {
+      id: "editorSpinSpeed",
+      label: "Spin Speed",
+      description: "Border spinner speed (slow / normal / fast — the × 1.5 / × 1 / × 0.6 of the style's native tempo)",
+      currentValue: (() => {
+        // Hand-edited (corrupt) values — non-strings (null/number/boolean) or an
+        // empty string — fall back to `normal` (the `typeof` guard keeps the
+        // settings panel from TypeError-ing on a non-string setting; the
+        // falsy check keeps an empty string from projecting as a `NaN` label).
+        const s =
+          typeof config.editorSpinSpeed === "string" && config.editorSpinSpeed
+            ? config.editorSpinSpeed
+            : "normal";
+        return s[0]!.toUpperCase() + s.slice(1);
+      })(),
+      values: ["Slow", "Normal", "Fast"],
+    },
+    {
+      id: "editorSpinStyle",
+      label: "Spin Style",
+      description: "Which animation the editor border runs while working",
+      currentValue:
+        typeof config.editorSpinStyle === "string"
+          ? config.editorSpinStyle
+              .split("-")
+              .filter(Boolean)
+              .map((w) => w[0]!.toUpperCase() + w.slice(1))
+              .join(" ")
+          : "Typing",
+      values: [
+        "Typing",
+        "Wave Rows",
+        "Columns",
+        "Pulse",
+        "Marquee",
+        "Pendulum",
+        "Rain",
+        "Cascade",
+        "Diagonal Swipe",
+        "Sparkle",
+      ],
+    },
+    {
+      id: "editorSpinLabel",
+      label: "Spinner Label",
+      description: "Label typed after the spin window (empty hides it)",
+      currentValue: config.editorSpinLabel,
+    },
+  ];
+}

package/src/startup/capture.ts

@@ -0,0 +1,47 @@
+const g: Record<string | symbol, unknown> = globalThis as unknown as typeof global & Record<string | symbol, unknown>;
+
+const MODEL_SCOPE_RE = /Model scope:\s*(.+)/;
+export const CAPTURED_MODELS = Symbol.for("splashscreen:capturedModels");
+export const PATCHED_LOG = Symbol.for("splashscreen:logPatched");
+
+// Store original console.log for restoration
+let _origLog: typeof console.log | undefined;
+
+export function patchConsoleLog(): void {
+  if (g[PATCHED_LOG]) return;
+  g[PATCHED_LOG] = true;
+  _origLog = console.log;
+
+  console.log = (...args: unknown[]) => {
+    try {
+      if (args.length === 1 && typeof args[0] === "string") {
+        const plain = (args[0] as string).replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+        const m = MODEL_SCOPE_RE.exec(plain);
+        if (m) {
+          const raw = m[1]!.replace(/\s*\(Ctrl\+\w[\w\s]*\)/gi, "");
+          g[CAPTURED_MODELS] = raw
+            .split(",")
+            .map((s: string) => s.trim())
+            .filter(Boolean);
+          // Unpatch once captured — no need to keep intercepting
+          unpatchConsoleLog();
+          return;
+        }
+      }
+    } catch (err) {
+      // Log the error but don't suppress the original call
+      console.error("[archimedes] Error in console.log patch:", err);
+    }
+    _origLog!.apply(console, args);
+  };
+}
+
+/** Restore original console.log — call on session_shutdown. */
+export function unpatchConsoleLog(): void {
+  if (!g[PATCHED_LOG]) return;
+  g[PATCHED_LOG] = false;
+  if (_origLog) {
+    console.log = _origLog;
+    _origLog = undefined;
+  }
+}