@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/__tests__/telephony-tts-guard.test.ts

@@ -455,10 +455,11 @@ describe("resolveCallTtsProvider with requiresPcmAudio", () => {
     expect(result.provider?.id).toBe("elevenlabs");
   });
 
-  test("without requiresPcmAudio the configured provider is not swapped", async () => {
+  test("without requiresPcmAudio the configured provider is not swapped for playability", async () => {
     testConfig.services.tts.provider = "deepgram";
-    // No credentials at all — the CR transport path does not consult the
-    // media-stream playability capability.
+    storedKeys["deepgram"] = "dg-key";
+    // The CR transport path does not consult the media-stream playability
+    // capability.
     registerStubProvider("deepgram", async () => {
       return { audio: Buffer.from("x"), contentType: "audio/mpeg" };
     });
@@ -468,6 +469,37 @@ describe("resolveCallTtsProvider with requiresPcmAudio", () => {
     expect(result.useSynthesizedPath).toBe(true);
     expect(result.audioFormat).toBe("mp3");
   });
+
+  test("managed speech stands in for a configured provider whose credential is missing", async () => {
+    testConfig.services.tts.provider = "deepgram";
+    // No deepgram key, managed speech available: the phone speaks through
+    // managed speech, the same substitution live voice makes.
+    registerStubProvider("deepgram", async () => {
+      throw new Error("should not be used");
+    });
+    registerStubProvider("vellum", async () => {
+      return { audio: Buffer.from("x"), contentType: "audio/mpeg" };
+    });
+
+    const result = await resolveCallTtsProvider();
+    expect(result.provider?.id).toBe("vellum");
+    expect(result.useSynthesizedPath).toBe(true);
+  });
+
+  test("without managed speech a credential-less configured provider is kept", async () => {
+    mockManagedSpeechAvailable = false;
+    try {
+      testConfig.services.tts.provider = "deepgram";
+      registerStubProvider("deepgram", async () => {
+        return { audio: Buffer.from("x"), contentType: "audio/mpeg" };
+      });
+
+      const result = await resolveCallTtsProvider();
+      expect(result.provider?.id).toBe("deepgram");
+    } finally {
+      mockManagedSpeechAvailable = true;
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -584,6 +616,7 @@ describe("speakSystemPrompt mid-stream failure after audio started", () => {
   test("non-PCM transport: skips the native text fallback — no full-prompt re-speak", async () => {
     testConfig.services.tts.provider = "fish-audio";
     testConfig.services.tts.providers["fish-audio"].referenceId = "ref-123";
+    storedKeys["fish-audio"] = "fa-key";
 
     const fishStream = jest.fn(failAfterFirstChunk());
     registerStreamingStubProvider("fish-audio", fishStream);
@@ -657,6 +690,7 @@ describe("speakSystemPrompt aborted synthesis", () => {
   test("non-PCM transport with native-fallback provider: abort skips the text fallback and end-of-turn", async () => {
     testConfig.services.tts.provider = "fish-audio";
     testConfig.services.tts.providers["fish-audio"].referenceId = "ref-123";
+    storedKeys["fish-audio"] = "fa-key";
 
     const controller = new AbortController();
     controller.abort();
@@ -742,6 +776,7 @@ describe("speakSystemPrompt aborted synthesis", () => {
   test("provider AbortError without any signal is a failure — non-PCM native fallback still runs", async () => {
     testConfig.services.tts.provider = "fish-audio";
     testConfig.services.tts.providers["fish-audio"].referenceId = "ref-123";
+    storedKeys["fish-audio"] = "fa-key";
 
     const fishSynthesize = jest.fn(async () => {
       throw new DOMException("socket torn down", "AbortError");

package/src/__tests__/test-support/computer-use-skill-harness.ts

@@ -2,7 +2,7 @@
  * Reusable constants and helpers for the computer-use skill migration test suite.
  */
 
-/** The 11 computer_use_* action tool names provided by the bundled computer-use skill. */
+/** The 12 computer_use_* action tool names provided by the bundled computer-use skill. */
 export const COMPUTER_USE_TOOL_NAMES = [
   "computer_use_observe",
   "computer_use_click",
@@ -13,9 +13,10 @@ export const COMPUTER_USE_TOOL_NAMES = [
   "computer_use_wait",
   "computer_use_open_app",
   "computer_use_run_applescript",
+  "computer_use_sequence",
   "computer_use_done",
   "computer_use_respond",
 ] as const;
 
 /** Number of computer_use_* tools. */
-export const COMPUTER_USE_TOOL_COUNT = COMPUTER_USE_TOOL_NAMES.length; // 11
+export const COMPUTER_USE_TOOL_COUNT = COMPUTER_USE_TOOL_NAMES.length; // 12

package/src/__tests__/ui-channel-variants.test.ts

@@ -2,10 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import type { ToolDefinition } from "../providers/types.js";
 import { ACTIVATION_MOMENT_PARAMS } from "../telemetry/activation-funnel.js";
-import {
-  injectActivationMomentParam,
-  projectUiToolsForChannel,
-} from "../tools/ui-surface/channel-variants.js";
+import { injectActivationMomentParam } from "../tools/ui-surface/channel-variants.js";
 import {
   uiDismissTool,
   uiShowTool,
@@ -23,58 +20,6 @@ const defs: ToolDefinition[] = [
   },
 ];
 
-function surfaceTypeEnum(def: ToolDefinition): string[] {
-  return (
-    def.input_schema as { properties: { surface_type: { enum: string[] } } }
-  ).properties.surface_type.enum;
-}
-
-describe("projectUiToolsForChannel", () => {
-  test("returns the same array for channels without a variant", () => {
-    for (const channel of [undefined, "macos", "telegram", "phone"]) {
-      expect(projectUiToolsForChannel(defs, channel)).toBe(defs);
-    }
-  });
-
-  test("slack gets a task_progress-only ui_show", () => {
-    const projected = projectUiToolsForChannel(defs, "slack");
-    const uiShow = projected.find((d) => d.name === "ui_show")!;
-
-    expect(surfaceTypeEnum(uiShow)).toEqual(["card"]);
-    expect(uiShow.description).toContain("task_progress");
-    expect(uiShow.description).toContain(
-      "the only surface this channel renders",
-    );
-    expect(uiShow.description).not.toContain("oauth_connect");
-    expect(uiShow.description).not.toContain("dynamic_page");
-    expect(uiShow.description!.length).toBeLessThan(
-      uiShowTool.description.length / 2,
-    );
-  });
-
-  test("slack projection keeps execute and leaves other tools untouched", () => {
-    const projected = projectUiToolsForChannel(defs, "slack");
-    const uiShow = projected.find((d) => d.name === "ui_show") as {
-      execute?: unknown;
-    };
-
-    expect(uiShow.execute).toBe(uiShowTool.execute);
-    expect(projected.find((d) => d.name === "ui_update")).toBe(uiUpdateTool);
-    expect(projected.find((d) => d.name === "ui_dismiss")).toBe(uiDismissTool);
-    expect(projected.find((d) => d.name === "bash")).toBe(defs[3]);
-  });
-
-  test("projection never mutates the shared definitions", () => {
-    const descriptionBefore = uiShowTool.description;
-    const schemaBefore = JSON.stringify(uiShowTool.input_schema);
-
-    projectUiToolsForChannel(defs, "slack");
-
-    expect(uiShowTool.description).toBe(descriptionBefore);
-    expect(JSON.stringify(uiShowTool.input_schema)).toBe(schemaBefore);
-  });
-});
-
 describe("injectActivationMomentParam", () => {
   function properties(def: ToolDefinition): Record<string, unknown> {
     return (def.input_schema as { properties: Record<string, unknown> })

package/src/__tests__/unicode.test.ts

@@ -171,6 +171,19 @@ describe("stripOrphanedSurrogatesDeep", () => {
     expect(result.value.b[1]).toBe("also clean");
   });
 
+  test("skipKey leaves a property unscanned and uncopied", () => {
+    const payload = { type: "base64", data: `raw${HIGH}` };
+    const input = { text: `bad${HIGH}`, payload };
+    const result = stripOrphanedSurrogatesDeep(input, {
+      skipKey: (key, parent) => key === "data" && parent.type === "base64",
+    });
+    expect(result.changed).toBe(true);
+    expect(result.fixedStringCount).toBe(1);
+    expect(result.value.text).toBe(`bad${REPLACEMENT}`);
+    // The skipped subtree is carried over by reference, orphan and all.
+    expect(result.value.payload).toBe(payload);
+  });
+
   test("leaves non-plain objects untouched", () => {
     class Custom {
       value = `bad${HIGH}`;

package/src/__tests__/vellum-self-knowledge-inline-command.test.ts

@@ -136,6 +136,10 @@ describe("vellum-self-knowledge skill", () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
     expect(result.content).toContain("## Critical Rule");
     expect(result.content).toContain("Never answer from memory");
+    expect(result.content).toContain("distinct, legacy Vellum product");
+    expect(result.content).toContain(
+      "Never use it to answer questions about this Vellum",
+    );
   });
 
   // ── Resolution order ─────────────────────────────────────────────────

package/src/__tests__/watch-retro-tool-availability.test.ts

@@ -1,13 +1,10 @@
 /**
  * The gate that decides whether a watch retrospective can report at all.
  *
- * A retrospective runs as a `clientless` wake, which pins the turn
- * non-interactive. `conversation-tool-setup` gates the whole `ui_surface`
- * family on a client being present, so in that turn `ui_show` is not denied,
- * it is absent: a retrospective told to call it can only tell the user it
- * cannot. Nothing about the card's schema, its renderer, or the prompt's
- * wording reveals that, which is why it is asserted here against the real
- * registry rather than assumed anywhere else.
+ * A retrospective runs as a `clientless` wake, but its report continues to
+ * use the post-turn renderer so the report lands after its tool call has been
+ * persisted. The core UI tools remain available on that turn for other
+ * background work, so this file pins both contracts against the real registry.
  */
 
 import { afterAll, describe, expect, test } from "bun:test";
@@ -54,20 +51,14 @@ describe("watch retrospective tool availability", () => {
     ).toBe(true);
   });
 
-  test("ui_show is absent from a clientless turn", async () => {
+  test("core UI tools stay available on a clientless turn", async () => {
     await initializeTools();
     const ctx = clientlessContext();
 
-    // The reason the report does not go through `ui_show`. If this ever flips
-    // to true, the extra tool above can be reconsidered; while it is false,
-    // routing the retrospective's card through `ui_show` produces a turn that
-    // cannot report at all.
-    expect(isToolActiveForContext("ui_show", ctx)).toBe(false);
-    expect(isToolActiveForContext("ui_update", ctx)).toBe(false);
-    expect(isToolActiveForContext("ui_dismiss", ctx)).toBe(false);
+    for (const name of ["ui_show", "ui_update", "ui_dismiss"]) {
+      expect(isToolActiveForContext(name, ctx)).toBe(true);
+    }
 
-    // And the gate really is about the client, not about the tools being
-    // unregistered: with one attached, the same names are active.
     const withClient = clientfulContext();
     expect(isToolActiveForContext("ui_show", withClient)).toBe(true);
   });

package/src/__tests__/workspace-git-service.test.ts

@@ -4,6 +4,7 @@ import {
   existsSync,
   mkdirSync,
   readFileSync,
+  renameSync,
   rmSync,
   statSync,
   symlinkSync,
@@ -523,6 +524,31 @@ describe("WorkspaceGitService", () => {
       expect(trackedFiles()).not.toContain("gone-b.txt");
       expect(trackedFiles()).not.toContain("gone-c.txt");
     });
+
+    test("batched rename stages origin and destination even when they split", async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      writeFileSync(join(testDir, "old-name.txt"), "moved");
+      await service.commitChanges("Seed rename source");
+
+      renameSync(join(testDir, "old-name.txt"), join(testDir, "new-name.txt"));
+      for (const name of ["x0.txt", "x1.txt", "x2.txt", "x3.txt"]) {
+        writeFileSync(join(testDir, name), name);
+      }
+
+      await withStageBatchSize(2, async () => {
+        await service.commitChanges("Rename across batches");
+      });
+
+      expect(trackedFiles()).toContain("new-name.txt");
+      expect(trackedFiles()).not.toContain("old-name.txt");
+      const status = execFileSync("git", ["status", "--porcelain"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      }).trim();
+      expect(status).toBe("");
+    });
   });
 
   describe("getStatus", () => {

package/src/__tests__/workspace-migration-154-repair-retired-codex-gpt-5-4-model-ids.test.ts

@@ -0,0 +1,336 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairRetiredCodexGpt54ModelIdsMigration } from "../workspace/migrations/154-repair-retired-codex-gpt-5-4-model-ids.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+const STALE = "gpt-5.4";
+const STALE_MINI = "gpt-5.4-mini";
+const REPLACEMENT = "gpt-5.5";
+const REPLACEMENT_MINI = "gpt-5.6-luna";
+
+const API_KEY_AUTH = '{"type":"api_key","credential":"credential/openai"}';
+const SUBSCRIPTION_AUTH =
+  '{"type":"oauth_subscription","credential":"credential/chatgpt"}';
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-154-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function readLlm(): Record<string, any> {
+  return readConfig().llm as Record<string, any>;
+}
+
+function seedRows(
+  rows: Array<{ name: string; provider: string; auth: string }>,
+): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  db.run(`CREATE TABLE IF NOT EXISTS provider_connections (
+    name TEXT PRIMARY KEY,
+    provider TEXT NOT NULL,
+    auth TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`);
+  for (const row of rows) {
+    db.query(
+      `INSERT INTO provider_connections (name, provider, auth, created_at, updated_at) VALUES (?, ?, ?, 1, 1)`,
+    ).run(row.name, row.provider, row.auth);
+  }
+  db.close();
+}
+
+const SUBSCRIPTION_ROW = {
+  name: "chatgpt-subscription",
+  provider: "chatgpt",
+  auth: SUBSCRIPTION_AUTH,
+};
+const API_KEY_ROW = {
+  name: "openai-key",
+  provider: "openai",
+  auth: API_KEY_AUTH,
+};
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("154-repair-retired-codex-gpt-5-4-model-ids migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(repairRetiredCodexGpt54ModelIdsMigration.id).toBe(
+      "154-repair-retired-codex-gpt-5-4-model-ids",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "154-repair-retired-codex-gpt-5-4-model-ids",
+    );
+  });
+
+  test("repairs chatgpt fragments in default, call sites, and profiles", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "chatgpt", model: STALE },
+        callSites: {
+          recall: { provider: "chatgpt", model: STALE_MINI, maxTokens: 4096 },
+          heartbeat: { provider: "chatgpt", model: `${STALE}-tuned` },
+          malformed: STALE,
+        },
+        profiles: {
+          codex: { provider: "chatgpt", model: STALE, source: "user" },
+          budget: { provider: "chatgpt", model: STALE_MINI },
+          current: { provider: "chatgpt", model: "gpt-5.6-terra" },
+          // The identity fails schema validation regardless of a stray
+          // binding, so it is repaired without consulting the rows.
+          strayBinding: {
+            provider: "chatgpt",
+            provider_connection: "openai-key",
+            model: STALE,
+          },
+        },
+      },
+    });
+
+    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
+
+    const llm = readLlm();
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.model).toBe(REPLACEMENT_MINI);
+    expect(llm.callSites.recall.maxTokens).toBe(4096);
+    // Non-exact matches and malformed leaves are untouched.
+    expect(llm.callSites.heartbeat.model).toBe(`${STALE}-tuned`);
+    expect(llm.callSites.malformed).toBe(STALE);
+    expect(llm.profiles.codex.model).toBe(REPLACEMENT);
+    expect(llm.profiles.codex.source).toBe("user");
+    expect(llm.profiles.budget.model).toBe(REPLACEMENT_MINI);
+    expect(llm.profiles.current.model).toBe("gpt-5.6-terra");
+    expect(llm.profiles.strayBinding.model).toBe(REPLACEMENT);
+  });
+
+  test("repairs entry-bound fragments whose row is the subscription", () => {
+    seedRows([
+      // Post-DB-migration-366 row shape.
+      SUBSCRIPTION_ROW,
+      // Pre-366 row shape: provider still openai, auth proves the route.
+      { name: "legacy-sub", provider: "openai", auth: SUBSCRIPTION_AUTH },
+    ]);
+    writeConfig({
+      llm: {
+        default: {
+          provider: "openai",
+          provider_connection: "chatgpt-subscription",
+          model: STALE,
+        },
+        callSites: {
+          recall: { provider: "chatgpt-subscription", model: STALE_MINI },
+        },
+        profiles: {
+          bound: { provider: "chatgpt-subscription", model: STALE },
+          legacy: { provider: "legacy-sub", model: STALE_MINI },
+          // Legacy binding: dispatch honors it ahead of the declared
+          // provider and accepts the ChatGPT row for openai.
+          pinned: {
+            provider: "openai",
+            provider_connection: "chatgpt-subscription",
+            model: STALE,
+          },
+        },
+      },
+    });
+
+    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
+
+    const llm = readLlm();
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.model).toBe(REPLACEMENT_MINI);
+    expect(llm.profiles.bound.model).toBe(REPLACEMENT);
+    expect(llm.profiles.legacy.model).toBe(REPLACEMENT_MINI);
+    expect(llm.profiles.pinned.model).toBe(REPLACEMENT);
+  });
+
+  test("judges a binding as a row even when named like a vendor", () => {
+    seedRows([
+      { name: "openai", provider: "openai", auth: SUBSCRIPTION_AUTH },
+      { name: "chatgpt", provider: "openai", auth: API_KEY_AUTH },
+    ]);
+    writeConfig({
+      llm: {
+        profiles: {
+          subRow: {
+            provider: "openai",
+            provider_connection: "openai",
+            model: STALE,
+          },
+          keyRow: {
+            provider: "chatgpt-subscription",
+            provider_connection: "chatgpt",
+            model: STALE_MINI,
+          },
+        },
+      },
+    });
+
+    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
+
+    const llm = readLlm();
+    expect(llm.profiles.subRow.model).toBe(REPLACEMENT);
+    expect(llm.profiles.keyRow.model).toBe(STALE_MINI);
+  });
+
+  test("leaves API-key, other-vendor, providerless, and dangling fragments untouched", () => {
+    seedRows([API_KEY_ROW, SUBSCRIPTION_ROW]);
+    const config = {
+      llm: {
+        // Explicit vendors keep the model: API-key OpenAI still serves it
+        // and an openai-compatible endpoint may too.
+        default: { provider: "openai", model: STALE },
+        defaultProvider: { provider: "chatgpt" },
+        callSites: {
+          vision: { provider: "openai-compatible", model: STALE_MINI },
+          recall: { provider: "openai", model: STALE },
+          // A providerless pin is out of scope: it serves the model on an
+          // API-key or managed winner, and on a subscription winner the
+          // request already fails upstream with no config loss.
+          heartbeatAgent: { model: STALE },
+          // A raw call-site binding is stripped by the schema.
+          filingAgent: {
+            provider: "openai-key",
+            provider_connection: "chatgpt-subscription",
+            model: STALE,
+          },
+        },
+        profiles: {
+          byok: { provider: "openai", model: STALE_MINI },
+          keyBound: { provider: "openai-key", model: STALE },
+          // Entry name with no row: nothing proves it is the subscription.
+          dangling: { provider: "ghost", model: STALE },
+          // Dispatch honors the explicit binding ahead of the provider.
+          keyOverride: {
+            provider: "chatgpt-subscription",
+            provider_connection: "openai-key",
+            model: STALE,
+          },
+        },
+      },
+    };
+    writeConfig(config);
+    const before = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+
+    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
+
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      before,
+    );
+  });
+
+  test("needs no DB for identity or vendor fragments", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "chatgpt", model: STALE },
+        profiles: {
+          byok: { provider: "openai", model: STALE },
+          bound: { provider: "chatgpt-subscription", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
+
+    const llm = readLlm();
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.profiles.byok.model).toBe(STALE);
+    // An entry name with no DB file is dangling.
+    expect(llm.profiles.bound.model).toBe(STALE);
+  });
+
+  test("throws when an entry name needs rows and the DB is unreadable", () => {
+    // A DB file without the provider_connections table is unqueryable, so
+    // the run must fail (and retry later) instead of skipping the profile.
+    mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+    writeFileSync(join(workspaceDir, "data", "db", "assistant.db"), "");
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "chatgpt-subscription", model: STALE } },
+      },
+    });
+
+    expect(() =>
+      repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir),
+    ).toThrow();
+    expect(readLlm().profiles.bound.model).toBe(STALE);
+
+    // The identity form never needs the rows, so the same broken DB does
+    // not block its repair.
+    writeConfig({
+      llm: { default: { provider: "chatgpt", model: STALE } },
+    });
+    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
+    expect(readLlm().default.model).toBe(REPLACEMENT);
+  });
+
+  test("is idempotent and a no-op without the stale IDs", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "chatgpt", model: STALE },
+        profiles: { fine: { provider: "chatgpt", model: REPLACEMENT } },
+      },
+    });
+
+    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
+    const first = readConfig();
+    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(first);
+
+    const llm = first.llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.profiles.fine.model).toBe(REPLACEMENT);
+  });
+
+  test("handles missing config, missing llm block, and invalid JSON", () => {
+    expect(() =>
+      repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    writeConfig({ theme: "dark" });
+    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
+    expect(readConfig()).toEqual({ theme: "dark" });
+
+    writeFileSync(join(workspaceDir, "config.json"), "{not json");
+    expect(() =>
+      repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+});