@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/workspace-migration-087-memory-router-balanced-profile.test.ts

@@ -0,0 +1,228 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { memoryRouterBalancedProfileMigration } from "../workspace/migrations/087-memory-router-balanced-profile.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-087-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 configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("087-memory-router-balanced-profile migration", () => {
+  test("has correct migration id", () => {
+    expect(memoryRouterBalancedProfileMigration.id).toBe(
+      "087-memory-router-balanced-profile",
+    );
+  });
+
+  test("replaces seeded Sonnet 4.6 + 1M context with balanced profile", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("creates the call site when missing", () => {
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("writes a fresh starter config when config.json is absent", () => {
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("skips BYOK / non-Anthropic workspaces to avoid breaking memoryRouter", () => {
+    // `balanced` resolves to the managed Anthropic connection, which BYOK
+    // installs disable. Rewriting to `balanced` there would silently disable
+    // memory injection (getConfiguredProvider returns null). Preserve whatever
+    // memoryRouter config the workspace already has — including absence.
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+        callSites: {
+          memoryRouter: { model: "gpt-5.4" },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ model: "gpt-5.4" });
+  });
+
+  test("skips BYOK workspaces with no existing memoryRouter entry", () => {
+    writeConfig({
+      llm: { default: { provider: "gemini" } },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites?.memoryRouter).toBeUndefined();
+  });
+
+  test("preserves user customizations on memoryRouter (non-077-seeded shape)", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-haiku-4-5-20251001",
+            effort: "low",
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+    });
+  });
+
+  test("is idempotent — second run does not change the call site", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+    const afterFirst = readFileSync(configPath(), "utf-8");
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+    const afterSecond = readFileSync(configPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { model: "claude-sonnet-4-6" },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      model: "claude-sonnet-4-6",
+    });
+  });
+
+  test("preserves sibling call-site entries", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.mainAgent).toEqual({
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    });
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+});

package/src/__tests__/workspace-migration-remove-legacy-skills-index.test.ts

@@ -0,0 +1,309 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+
+import { removeLegacySkillsIndexMigration } from "../workspace/migrations/084-remove-legacy-skills-index.js";
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-084-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function writeSkill(skillId: string, body = "Body."): string {
+  const skillDir = join(workspaceDir, "skills", skillId);
+  mkdirSync(skillDir, { recursive: true });
+  const skillFilePath = join(skillDir, "SKILL.md");
+  writeFileSync(
+    skillFilePath,
+    `---\nname: "${skillId}"\ndescription: "Test skill."\n---\n\n${body}\n`,
+    "utf-8",
+  );
+  return skillFilePath;
+}
+
+function writeLegacyIndex(contents = "- alpha\n"): string {
+  const skillsDir = join(workspaceDir, "skills");
+  mkdirSync(skillsDir, { recursive: true });
+  const legacyIndexPath = join(skillsDir, "SKILLS.md");
+  writeFileSync(legacyIndexPath, contents, "utf-8");
+  return legacyIndexPath;
+}
+
+function expectNestedSkillPreserved(
+  legacyIndexPath: string,
+  nestedSkillPath: string,
+): void {
+  const topLevelSkillPath = join(
+    workspaceDir,
+    "skills",
+    "my-skill",
+    "SKILL.md",
+  );
+  expect(existsSync(legacyIndexPath)).toBe(false);
+  expect(existsSync(nestedSkillPath)).toBe(true);
+  expect(readFileSync(topLevelSkillPath, "utf-8")).toContain("org/my-skill");
+}
+
+describe("084-remove-legacy-skills-index migration", () => {
+  test("has correct id and description", () => {
+    expect(removeLegacySkillsIndexMigration.id).toBe(
+      "084-remove-legacy-skills-index",
+    );
+    expect(removeLegacySkillsIndexMigration.description).toContain("SKILLS.md");
+    expect(removeLegacySkillsIndexMigration.retryFailedCheckpoint).toBe(true);
+  });
+
+  test("removes only skills/SKILLS.md when present", () => {
+    const skillsDir = join(workspaceDir, "skills");
+    const legacyIndexPath = writeLegacyIndex();
+
+    const alphaSkillPath = writeSkill("alpha");
+    const betaSkillPath = writeSkill("beta");
+    const topLevelSkillPath = join(skillsDir, "SKILL.md");
+    writeFileSync(
+      topLevelSkillPath,
+      "---\nname: Root\ndescription: Root file.\n---\n\nRoot.\n",
+      "utf-8",
+    );
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+
+    expect(existsSync(legacyIndexPath)).toBe(false);
+    expect(readFileSync(alphaSkillPath, "utf-8")).toContain("alpha");
+    expect(readFileSync(betaSkillPath, "utf-8")).toContain("beta");
+    expect(readFileSync(topLevelSkillPath, "utf-8")).toContain("Root");
+  });
+
+  test("is a no-op when skills/SKILLS.md is absent", () => {
+    writeSkill("alpha");
+
+    expect(() =>
+      removeLegacySkillsIndexMigration.run(workspaceDir),
+    ).not.toThrow();
+    expect(existsSync(join(workspaceDir, "skills", "alpha", "SKILL.md"))).toBe(
+      true,
+    );
+  });
+
+  test("removing a stale SKILLS.md index preserves omitted valid skill directories", () => {
+    const legacyIndexPath = writeLegacyIndex("- indexed-skill\n");
+
+    writeSkill("indexed-skill");
+    writeSkill("omitted-skill");
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+
+    expect(existsSync(legacyIndexPath)).toBe(false);
+    expect(
+      readFileSync(
+        join(workspaceDir, "skills", "omitted-skill", "SKILL.md"),
+        "utf-8",
+      ),
+    ).toContain("Body.");
+  });
+
+  test("copies nested indexed skills to top-level discovery location", () => {
+    const legacyIndexPath = writeLegacyIndex("- org/my-skill\n");
+    const nestedSkillPath = writeSkill("org/my-skill");
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+
+    const topLevelSkillPath = join(
+      workspaceDir,
+      "skills",
+      "my-skill",
+      "SKILL.md",
+    );
+    expect(existsSync(legacyIndexPath)).toBe(false);
+    expect(existsSync(nestedSkillPath)).toBe(true);
+    expect(readFileSync(topLevelSkillPath, "utf-8")).toContain("org/my-skill");
+
+    expect(readFileSync(topLevelSkillPath, "utf-8")).toContain("Body.");
+  });
+
+  test("copies nested indexed skills from plain entries that point to SKILL.md", () => {
+    const legacyIndexPath = writeLegacyIndex("- org/my-skill/SKILL.md\n");
+    const nestedSkillPath = writeSkill("org/my-skill");
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+
+    expectNestedSkillPreserved(legacyIndexPath, nestedSkillPath);
+  });
+
+  test("copies nested indexed skills from markdown links that point to SKILL.md", () => {
+    const legacyIndexPath = writeLegacyIndex(
+      "- [My Skill](org/my-skill/skill.md)\n",
+    );
+    const nestedSkillPath = writeSkill("org/my-skill");
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+
+    expectNestedSkillPreserved(legacyIndexPath, nestedSkillPath);
+  });
+
+  test("preserves nested indexed skill with alternate id when top-level basename exists", () => {
+    const legacyIndexPath = writeLegacyIndex("- org/my-skill\n");
+    const nestedSkillPath = writeSkill("org/my-skill", "Nested body.");
+    const topLevelSkillPath = writeSkill("my-skill", "Top-level body.");
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+
+    const preservedSkillPath = join(
+      workspaceDir,
+      "skills",
+      "org__my-skill",
+      "SKILL.md",
+    );
+    expect(existsSync(legacyIndexPath)).toBe(false);
+    expect(readFileSync(nestedSkillPath, "utf-8")).toContain("Nested body.");
+    expect(readFileSync(topLevelSkillPath, "utf-8")).toContain(
+      "Top-level body.",
+    );
+    expect(readFileSync(preservedSkillPath, "utf-8")).toContain("Nested body.");
+
+    expect(readFileSync(topLevelSkillPath, "utf-8")).toContain(
+      "Top-level body.",
+    );
+    expect(readFileSync(preservedSkillPath, "utf-8")).toContain("Nested body.");
+  });
+
+  test("preserves same-basename nested indexed skills with unique top-level ids", () => {
+    const legacyIndexPath = writeLegacyIndex(
+      "- team-a/deploy\n- team-b/deploy\n",
+    );
+    const teamASkillPath = writeSkill("team-a/deploy", "Team A body.");
+    const teamBSkillPath = writeSkill("team-b/deploy", "Team B body.");
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+
+    const primaryPreservedSkillPath = join(
+      workspaceDir,
+      "skills",
+      "deploy",
+      "SKILL.md",
+    );
+    const alternatePreservedSkillPath = join(
+      workspaceDir,
+      "skills",
+      "team-b__deploy",
+      "SKILL.md",
+    );
+
+    expect(existsSync(legacyIndexPath)).toBe(false);
+    expect(existsSync(teamASkillPath)).toBe(true);
+    expect(existsSync(teamBSkillPath)).toBe(true);
+    expect(readFileSync(primaryPreservedSkillPath, "utf-8")).toContain(
+      "Team A body.",
+    );
+    expect(readFileSync(alternatePreservedSkillPath, "utf-8")).toContain(
+      "Team B body.",
+    );
+
+    expect(readFileSync(primaryPreservedSkillPath, "utf-8")).toContain(
+      "Team A body.",
+    );
+    expect(readFileSync(alternatePreservedSkillPath, "utf-8")).toContain(
+      "Team B body.",
+    );
+  });
+
+  test("does not follow legacy index entries outside the skills root", () => {
+    const legacyIndexPath = writeLegacyIndex("- ../outside/my-skill\n");
+    const outsideSkillDir = join(workspaceDir, "outside", "my-skill");
+    mkdirSync(outsideSkillDir, { recursive: true });
+    writeFileSync(
+      join(outsideSkillDir, "SKILL.md"),
+      "---\nname: Outside\ndescription: Outside skill.\n---\n\nOutside.\n",
+      "utf-8",
+    );
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+
+    expect(existsSync(legacyIndexPath)).toBe(false);
+    expect(existsSync(join(workspaceDir, "skills", "my-skill"))).toBe(false);
+  });
+
+  test("is safe to re-run", () => {
+    const legacyIndexPath = writeLegacyIndex();
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+    expect(() =>
+      removeLegacySkillsIndexMigration.run(workspaceDir),
+    ).not.toThrow();
+    expect(existsSync(legacyIndexPath)).toBe(false);
+  });
+
+  test("does not recursively delete a directory named SKILLS.md", () => {
+    const legacyIndexDir = join(workspaceDir, "skills", "SKILLS.md");
+    mkdirSync(legacyIndexDir, { recursive: true });
+    writeFileSync(join(legacyIndexDir, "nested.txt"), "keep\n", "utf-8");
+
+    removeLegacySkillsIndexMigration.run(workspaceDir);
+
+    expect(readFileSync(join(legacyIndexDir, "nested.txt"), "utf-8")).toBe(
+      "keep\n",
+    );
+  });
+
+  test("rethrows unexpected lstat failures", () => {
+    const legacyIndexPath = writeLegacyIndex();
+
+    const lstatError = Object.assign(new Error("simulated lstat failure"), {
+      code: "EACCES",
+    });
+    const lstatSpy = spyOn(fs, "lstatSync").mockImplementation(() => {
+      throw lstatError;
+    });
+
+    try {
+      expect(() => removeLegacySkillsIndexMigration.run(workspaceDir)).toThrow(
+        lstatError,
+      );
+      expect(existsSync(legacyIndexPath)).toBe(true);
+    } finally {
+      lstatSpy.mockRestore();
+    }
+  });
+
+  test("rethrows unexpected unlink failures and leaves SKILLS.md for retry", () => {
+    const legacyIndexPath = writeLegacyIndex();
+
+    const unlinkError = Object.assign(new Error("simulated unlink failure"), {
+      code: "EACCES",
+    });
+    const unlinkSpy = spyOn(fs, "unlinkSync").mockImplementation(() => {
+      throw unlinkError;
+    });
+
+    try {
+      expect(() => removeLegacySkillsIndexMigration.run(workspaceDir)).toThrow(
+        unlinkError,
+      );
+      expect(existsSync(legacyIndexPath)).toBe(true);
+    } finally {
+      unlinkSpy.mockRestore();
+    }
+  });
+
+  test("down() is a no-op", () => {
+    expect(() =>
+      removeLegacySkillsIndexMigration.down(workspaceDir),
+    ).not.toThrow();
+  });
+});

package/src/__tests__/workspace-migrations-runner.test.ts

@@ -137,9 +137,10 @@ describe("runWorkspaceMigrations", () => {
     expect(m1.run).toHaveBeenCalledTimes(1);
     expect(m2.run).toHaveBeenCalledTimes(1);
 
-    // Checkpoints saved: started m1, completed m1, started m2, failed m2 = 4 writes
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(4);
-    expect(renameSyncFn).toHaveBeenCalledTimes(4);
+    // Checkpoints saved: started m1, completed m1, started m2, failed m2,
+    // then the post-loop flip clearing isNewWorkspace = 5 writes.
+    expect(writeFileSyncFn).toHaveBeenCalledTimes(5);
+    expect(renameSyncFn).toHaveBeenCalledTimes(5);
 
     // Verify the completed checkpoint contains m1
     // The second write is the "completed" marker for m1
@@ -246,6 +247,33 @@ describe("runWorkspaceMigrations", () => {
     expect(m1.run).not.toHaveBeenCalled();
   });
 
+  test("skips failed migrations by default", async () => {
+    mockCheckpointContents = JSON.stringify({
+      applied: {
+        "001": { appliedAt: "2025-01-01T00:00:00.000Z", status: "failed" },
+      },
+    });
+
+    const m1 = makeMigration("001");
+    await runWorkspaceMigrations(WORKSPACE_DIR, [m1]);
+
+    expect(m1.run).not.toHaveBeenCalled();
+  });
+
+  test("retries failed migrations that opt in", async () => {
+    mockCheckpointContents = JSON.stringify({
+      applied: {
+        "001": { appliedAt: "2025-01-01T00:00:00.000Z", status: "failed" },
+      },
+    });
+
+    const m1 = makeMigration("001");
+    m1.retryFailedCheckpoint = true;
+    await runWorkspaceMigrations(WORKSPACE_DIR, [m1]);
+
+    expect(m1.run).toHaveBeenCalledTimes(1);
+  });
+
   test("supports async migrations", async () => {
     const asyncMigration: WorkspaceMigration = {
       id: "001",
@@ -278,6 +306,86 @@ describe("runWorkspaceMigrations", () => {
     expect(m1.run).not.toHaveBeenCalled();
   });
 
+  test("persists isNewWorkspace=true on first creation, then flips to false after sweep", async () => {
+    // No checkpoint file → fresh workspace.
+    const m1 = makeMigration("001");
+    let observed: boolean | undefined;
+    (m1.run as ReturnType<typeof mock>).mockImplementation(
+      (_dir: string, ctx?: { isNewWorkspace: boolean }) => {
+        observed = ctx?.isNewWorkspace;
+      },
+    );
+
+    await runWorkspaceMigrations(WORKSPACE_DIR, [m1]);
+
+    // The migration saw the new-workspace flag.
+    expect(observed).toBe(true);
+
+    // The first persisted checkpoint (m1's "started" save) carries the flag.
+    const firstSave = JSON.parse(
+      (writeFileSyncFn.mock.calls[0] as unknown[])[1] as string,
+    );
+    expect(firstSave.isNewWorkspace).toBe(true);
+
+    // The final persisted checkpoint clears the flag so subsequent boots
+    // treat this workspace as an upgrade.
+    const finalSave = JSON.parse(
+      (writeFileSyncFn.mock.calls.at(-1) as unknown[])[1] as string,
+    );
+    expect(finalSave.isNewWorkspace).toBe(false);
+  });
+
+  test("preserves isNewWorkspace=true across a crash before seeding migrations run", async () => {
+    // Simulate a crash mid-first-boot: an earlier migration recorded its
+    // "started" marker (writing the checkpoint file) and the daemon then
+    // died before reaching the seeding migration. The persisted flag must
+    // survive the reboot so the seeding migration still observes the
+    // brand-new workspace.
+    mockCheckpointContents = JSON.stringify({
+      isNewWorkspace: true,
+      applied: {
+        "001": { appliedAt: "2025-01-01T00:00:00.000Z", status: "started" },
+      },
+    });
+
+    const seedingMigration = makeMigration("seed");
+    let observed: boolean | undefined;
+    (seedingMigration.run as ReturnType<typeof mock>).mockImplementation(
+      (_dir: string, ctx?: { isNewWorkspace: boolean }) => {
+        observed = ctx?.isNewWorkspace;
+      },
+    );
+
+    const m1 = makeMigration("001");
+    await runWorkspaceMigrations(WORKSPACE_DIR, [m1, seedingMigration]);
+
+    expect(m1.run).toHaveBeenCalledTimes(1);
+    expect(seedingMigration.run).toHaveBeenCalledTimes(1);
+    expect(observed).toBe(true);
+  });
+
+  test("treats pre-existing checkpoint without isNewWorkspace field as upgrade", async () => {
+    // Workspaces created before this field was introduced have a checkpoint
+    // file with only `applied`. They must not be re-seeded.
+    mockCheckpointContents = JSON.stringify({
+      applied: {
+        "001": { appliedAt: "2025-01-01T00:00:00.000Z", status: "completed" },
+      },
+    });
+
+    const seedingMigration = makeMigration("seed");
+    let observed: boolean | undefined;
+    (seedingMigration.run as ReturnType<typeof mock>).mockImplementation(
+      (_dir: string, ctx?: { isNewWorkspace: boolean }) => {
+        observed = ctx?.isNewWorkspace;
+      },
+    );
+
+    await runWorkspaceMigrations(WORKSPACE_DIR, [seedingMigration]);
+
+    expect(observed).toBe(false);
+  });
+
   test("warns on malformed checkpoint file", async () => {
     mockCheckpointContents = "not valid json";