@vellumai/assistant 0.5.10 → 0.5.12

package/src/__tests__/skill-memory.test.ts

@@ -472,8 +472,7 @@ describe("seedCatalogSkillMemories", () => {
     mockResolveCatalog = async () => skills;
 
     // Disable the feature flag for the flagged skill
-    mockIsFeatureFlagEnabled = (key: string) =>
-      key !== "feature_flags.my_gated_feature.enabled";
+    mockIsFeatureFlagEnabled = (key: string) => key !== "my_gated_feature";
 
     await seedCatalogSkillMemories();
 
@@ -519,8 +518,7 @@ describe("seedCatalogSkillMemories", () => {
     expect(beforeItems.every((i) => i.status === "active")).toBe(true);
 
     // Now disable the flag — the flagged skill should be pruned
-    mockIsFeatureFlagEnabled = (key: string) =>
-      key !== "feature_flags.my_gated_feature.enabled";
+    mockIsFeatureFlagEnabled = (key: string) => key !== "my_gated_feature";
     await seedCatalogSkillMemories();
 
     const afterItems = db

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -22,7 +22,7 @@ let mockSkillRefCount: Map<string, number> = new Map();
 
 let currentConfig: Record<string, unknown> = {};
 const DECLARED_SKILL_ID = "contacts";
-const DECLARED_FLAG_KEY = "feature_flags.contacts.enabled";
+const DECLARED_FLAG_KEY = "contacts";
 
 // ---------------------------------------------------------------------------
 // Mocks
@@ -40,9 +40,7 @@ mock.module("../config/loader.js", () => ({
 
 mock.module("../config/skill-state.js", () => ({
   skillFlagKey: (skill: { featureFlag?: string }) =>
-    skill.featureFlag
-      ? `feature_flags.${skill.featureFlag}.enabled`
-      : undefined,
+    skill.featureFlag || undefined,
 }));
 
 // Mock assistant-feature-flags to avoid loading the real module (which

package/src/__tests__/skill-projection.benchmark.test.ts

@@ -66,9 +66,7 @@ mock.module("../config/skills.js", () => ({
 // only needs skillFlagKey and doesn't exercise resolveSkillStates.
 mock.module("../config/skill-state.js", () => ({
   skillFlagKey: (skill: { featureFlag?: string }) =>
-    skill.featureFlag
-      ? `feature_flags.${skill.featureFlag}.enabled`
-      : undefined,
+    skill.featureFlag || undefined,
   resolveSkillStates: () => [],
 }));
 

package/src/__tests__/skills-uninstall.test.ts

@@ -58,7 +58,7 @@ describe("assistant skills uninstall", () => {
 
     // GIVEN a skill is installed locally
     installFakeSkill("weather");
-    writeSkillsIndex("- weather\n- google-oauth-applescript\n");
+    writeSkillsIndex("- weather\n- google-oauth-app-setup\n");
 
     // WHEN we uninstall the skill
     uninstallSkillLocally("weather");
@@ -71,7 +71,7 @@ describe("assistant skills uninstall", () => {
     expect(index).not.toContain("weather");
 
     // AND other skills should remain in the index
-    expect(index).toContain("google-oauth-applescript");
+    expect(index).toContain("google-oauth-app-setup");
   });
 
   test("errors when skill is not installed", () => {

package/src/__tests__/skills.test.ts

@@ -603,7 +603,7 @@ describe("bundled browser skill", () => {
   });
 });
 
-describe("ingress-dependent setup skills declare public-ingress", () => {
+describe("ingress-dependent setup skills declare public-ingress intentionally", () => {
   const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
   const FIRST_PARTY_SKILLS_DIR = join(
     import.meta.dir,
@@ -649,14 +649,28 @@ describe("ingress-dependent setup skills declare public-ingress", () => {
     return undefined;
   }
 
-  test("telegram-setup includes public-ingress", () => {
+  test("telegram-setup does not hard-depend on public-ingress", () => {
     const includes = readSkillIncludes(
       FIRST_PARTY_SKILLS_DIR,
       "telegram-setup",
     );
+    expect(includes ?? []).not.toContain("public-ingress");
+  });
+
+  test("twilio-setup includes public-ingress", () => {
+    const includes = readSkillIncludes(FIRST_PARTY_SKILLS_DIR, "twilio-setup");
     expect(includes).toBeDefined();
     expect(includes).toContain("public-ingress");
   });
+
+  test("public-ingress frontmatter advertises managed-mode avoidance", () => {
+    const content = readFileSync(
+      join(FIRST_PARTY_SKILLS_DIR, "public-ingress", "SKILL.md"),
+      "utf-8",
+    );
+    expect(content).toContain("avoid-when:");
+    expect(content.toLowerCase()).toContain("managed/containerized");
+  });
 });
 
 describe("bundled computer-use skill", () => {

package/src/__tests__/slack-channel-config.test.ts

@@ -252,7 +252,7 @@ describe("Slack channel config handler", () => {
   });
 
   test("GET reports per-field token presence independently of connection row", async () => {
-    // Only bot_token in keychain, no app_token, but connection row exists
+    // Only bot_token in credential store, no app_token, but connection row exists
     oauthConnectionStore["slack_channel"] = {
       id: "conn-slack",
       status: "active",

package/src/__tests__/slack-messaging-token-resolution.test.ts

@@ -117,12 +117,12 @@ describe("Slack messaging token resolution", () => {
       expect(await slackProvider.isConnected!()).toBe(true);
     });
 
-    test("returns true when only integration:slack has active OAuth connection (backwards compat)", async () => {
+    test("returns true when only slack has active OAuth connection (backwards compat)", async () => {
       // No bot token
       getSecureKeyAsyncMock.mockImplementation(async () => null);
       // But OAuth provider is connected
       isProviderConnectedMock.mockImplementation(async (service: string) =>
-        service === "integration:slack" ? true : false,
+        service === "slack" ? true : false,
       );
 
       expect(await slackProvider.isConnected!()).toBe(true);
@@ -139,7 +139,7 @@ describe("Slack messaging token resolution", () => {
   // ── slackProvider.resolveConnection() ───────────────────────────────────
 
   describe("slackProvider.resolveConnection()", () => {
-    test("returns bot token string when Socket Mode credentials exist", async () => {
+    test("returns undefined when Socket Mode credentials exist (token cached internally)", async () => {
       getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
         key === "credential/slack_channel/bot_token"
           ? "xoxb-socket-token"
@@ -147,20 +147,20 @@ describe("Slack messaging token resolution", () => {
       );
 
       const result = await slackProvider.resolveConnection!();
-      expect(result).toBe("xoxb-socket-token");
+      expect(result).toBeUndefined();
     });
 
-    test("returns bot token string even without a slack_channel connection row (token-only resilience)", async () => {
+    test("returns undefined even without a slack_channel connection row (token-only resilience)", async () => {
       getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
         key === "credential/slack_channel/bot_token" ? "xoxb-token-only" : null,
       );
-      // No connection row — resolveConnection should still return the token
+      // No connection row — resolveConnection should still return undefined (token cached internally)
 
       const result = await slackProvider.resolveConnection!();
-      expect(result).toBe("xoxb-token-only");
+      expect(result).toBeUndefined();
     });
 
-    test("returns OAuthConnection when only OAuth integration:slack credentials exist (backwards compat)", async () => {
+    test("returns OAuthConnection when only OAuth slack credentials exist (backwards compat)", async () => {
       getSecureKeyAsyncMock.mockImplementation(async () => null);
       const oauthConn = {
         accessToken: "xoxp-oauth-token",
@@ -169,16 +169,15 @@ describe("Slack messaging token resolution", () => {
 
       const result = await slackProvider.resolveConnection!();
       expect(result).toBe(oauthConn);
-      expect(resolveOAuthConnectionMock).toHaveBeenCalledWith(
-        "integration:slack",
-        { account: undefined },
-      );
+      expect(resolveOAuthConnectionMock).toHaveBeenCalledWith("slack", {
+        account: undefined,
+      });
     });
 
     test("throws when no credentials exist at all (no Socket Mode, no OAuth)", async () => {
       getSecureKeyAsyncMock.mockImplementation(async () => null);
       resolveOAuthConnectionMock.mockImplementation(async () => {
-        throw new Error("No OAuth connection found for integration:slack");
+        throw new Error("No OAuth connection found for slack");
       });
 
       await expect(slackProvider.resolveConnection!()).rejects.toThrow(
@@ -190,13 +189,13 @@ describe("Slack messaging token resolution", () => {
   // ── getProviderConnection() integration ─────────────────────────────────
 
   describe("getProviderConnection()", () => {
-    test("returns bot token string for Slack when Socket Mode credentials exist", async () => {
+    test("returns undefined for Slack when Socket Mode credentials exist (token cached internally)", async () => {
       getSecureKeyAsyncMock.mockImplementation(async (key: string) =>
         key === "credential/slack_channel/bot_token" ? "xoxb-conn-token" : null,
       );
 
       const result = await getProviderConnection(slackProvider);
-      expect(result).toBe("xoxb-conn-token");
+      expect(result).toBeUndefined();
     });
 
     test("returns OAuthConnection for Slack when only OAuth credentials exist (backwards compat)", async () => {
@@ -221,9 +220,9 @@ describe("Slack messaging token resolution", () => {
       );
     });
 
-    test('Telegram still returns "" (no resolveConnection, uses isConnected path — regression check)', async () => {
+    test("Telegram returns undefined (no resolveConnection, uses isConnected path — regression check)", async () => {
       // Telegram has isConnected but no resolveConnection.
-      // When isConnected returns true, getProviderConnection returns ""
+      // When isConnected returns true, getProviderConnection returns undefined
       getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
         if (key === "credential/telegram/bot_token") return "bot-token";
         if (key === "credential/telegram/webhook_secret") return "secret";
@@ -234,7 +233,7 @@ describe("Slack messaging token resolution", () => {
       );
 
       const result = await getProviderConnection(telegramBotMessagingProvider);
-      expect(result).toBe("");
+      expect(result).toBeUndefined();
     });
 
     test("Gmail still calls resolveOAuthConnection (no resolveConnection, no isConnected — regression check)", async () => {
@@ -247,10 +246,9 @@ describe("Slack messaging token resolution", () => {
 
       const result = await getProviderConnection(gmailMessagingProvider);
       expect(result).toBe(oauthConn);
-      expect(resolveOAuthConnectionMock).toHaveBeenCalledWith(
-        "integration:google",
-        { account: undefined },
-      );
+      expect(resolveOAuthConnectionMock).toHaveBeenCalledWith("google", {
+        account: undefined,
+      });
     });
   });
 
@@ -264,7 +262,7 @@ describe("Slack messaging token resolution", () => {
       );
       // Gmail connected via OAuth
       isProviderConnectedMock.mockImplementation(async (service: string) =>
-        service === "integration:google" ? true : false,
+        service === "google" ? true : false,
       );
 
       await expect(resolveProvider()).rejects.toThrow(
@@ -285,7 +283,7 @@ describe("Slack messaging token resolution", () => {
     test("auto-selects Gmail when it is the only connected provider (no Slack credentials)", async () => {
       getSecureKeyAsyncMock.mockImplementation(async () => null);
       isProviderConnectedMock.mockImplementation(async (service: string) =>
-        service === "integration:google" ? true : false,
+        service === "google" ? true : false,
       );
 
       const provider = await resolveProvider();

package/src/__tests__/slack-share-routes.test.ts

@@ -111,7 +111,7 @@ describe("handleListSlackChannels", () => {
   });
 
   test("returns channels sorted by type then name", async () => {
-    connectionByProvider["integration:slack"] = { id: "conn-slack-1" };
+    connectionByProvider["slack"] = { id: "conn-slack-1" };
     secureKeyValues.set(
       "oauth_connection/conn-slack-1/access_token",
       "xoxb-test",
@@ -192,7 +192,7 @@ describe("handleShareToSlackChannel", () => {
   });
 
   test("returns 400 for malformed JSON", async () => {
-    connectionByProvider["integration:slack"] = { id: "conn-slack-1" };
+    connectionByProvider["slack"] = { id: "conn-slack-1" };
     secureKeyValues.set(
       "oauth_connection/conn-slack-1/access_token",
       "xoxb-test",
@@ -207,7 +207,7 @@ describe("handleShareToSlackChannel", () => {
   });
 
   test("returns 400 when missing required fields", async () => {
-    connectionByProvider["integration:slack"] = { id: "conn-slack-1" };
+    connectionByProvider["slack"] = { id: "conn-slack-1" };
     secureKeyValues.set(
       "oauth_connection/conn-slack-1/access_token",
       "xoxb-test",
@@ -220,7 +220,7 @@ describe("handleShareToSlackChannel", () => {
   });
 
   test("returns 404 when app not found", async () => {
-    connectionByProvider["integration:slack"] = { id: "conn-slack-1" };
+    connectionByProvider["slack"] = { id: "conn-slack-1" };
     secureKeyValues.set(
       "oauth_connection/conn-slack-1/access_token",
       "xoxb-test",
@@ -232,7 +232,7 @@ describe("handleShareToSlackChannel", () => {
   });
 
   test("posts message and returns success", async () => {
-    connectionByProvider["integration:slack"] = { id: "conn-slack-1" };
+    connectionByProvider["slack"] = { id: "conn-slack-1" };
     secureKeyValues.set(
       "oauth_connection/conn-slack-1/access_token",
       "xoxb-test",

package/src/__tests__/slack-skill.test.ts

@@ -46,75 +46,11 @@ describe("slack adapter isPrivate mapping", () => {
   });
 });
 
-describe("slack skill TOOLS.json", () => {
+describe("slack skill has no TOOLS.json (uses Web API via CLI)", () => {
   const toolsPath = join(BUNDLED_SKILLS_DIR, "slack", "TOOLS.json");
-  const toolsJson = JSON.parse(readFileSync(toolsPath, "utf-8"));
 
-  test("is valid JSON with correct version", () => {
-    expect(toolsJson.version).toBe(1);
-    expect(Array.isArray(toolsJson.tools)).toBe(true);
-  });
-
-  test("has expected tools", () => {
-    const names = toolsJson.tools.map((t: { name: string }) => t.name);
-    expect(names).toContain("slack_scan_digest");
-    expect(names).toContain("slack_channel_details");
-    expect(names).toContain("slack_configure_channels");
-    expect(names).toContain("slack_add_reaction");
-    expect(names).toContain("slack_edit_message");
-    expect(names).toContain("slack_delete_message");
-    expect(names).toContain("slack_leave_channel");
-    expect(names).toContain("slack_channel_permissions");
-  });
-
-  test("has 8 tools total", () => {
-    expect(toolsJson.tools.length).toBe(8);
-  });
-
-  test("all tools have required fields", () => {
-    for (const tool of toolsJson.tools) {
-      expect(tool.name).toBeDefined();
-      expect(tool.description).toBeDefined();
-      expect(tool.category).toBeDefined();
-      expect(tool.risk).toBeDefined();
-      expect(tool.input_schema).toBeDefined();
-      expect(tool.executor).toBeDefined();
-      expect(tool.execution_target).toBeDefined();
-    }
-  });
-
-  test("all executor files exist", () => {
-    const slackSkillDir = join(BUNDLED_SKILLS_DIR, "slack");
-    for (const tool of toolsJson.tools) {
-      const executorPath = join(slackSkillDir, tool.executor);
-      expect(() => readFileSync(executorPath)).not.toThrow();
-    }
-  });
-});
-
-describe("messaging skill no longer has Slack tools", () => {
-  const messagingToolsPath = join(
-    BUNDLED_SKILLS_DIR,
-    "messaging",
-    "TOOLS.json",
-  );
-  const messagingToolsJson = JSON.parse(
-    readFileSync(messagingToolsPath, "utf-8"),
-  );
-
-  test("slack_add_reaction not in messaging TOOLS.json", () => {
-    const names = messagingToolsJson.tools.map((t: { name: string }) => t.name);
-    expect(names).not.toContain("slack_add_reaction");
-  });
-
-  test("slack_delete_message not in messaging TOOLS.json", () => {
-    const names = messagingToolsJson.tools.map((t: { name: string }) => t.name);
-    expect(names).not.toContain("slack_delete_message");
-  });
-
-  test("slack_leave_channel not in messaging TOOLS.json", () => {
-    const names = messagingToolsJson.tools.map((t: { name: string }) => t.name);
-    expect(names).not.toContain("slack_leave_channel");
+  test("TOOLS.json does not exist", () => {
+    expect(() => readFileSync(toolsPath)).toThrow();
   });
 });
 
@@ -129,7 +65,7 @@ describe("slack skill SKILL.md", () => {
   });
 
   test("mentions privacy rules", () => {
-    expect(skillMd).toContain("isPrivate");
-    expect(skillMd).toContain("MUST NEVER be shared");
+    expect(skillMd).toContain("is_private");
+    expect(skillMd).toContain("must NEVER be shared");
   });
 });

package/src/__tests__/system-prompt.test.ts

@@ -24,6 +24,7 @@ mock.module("../util/platform.js", () => ({
   getWorkspaceConfigPath: () => join(TEST_DIR, "config.json"),
   getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
   getWorkspaceHooksDir: () => join(TEST_DIR, "hooks"),
+  getConversationsDir: () => join(TEST_DIR, "conversations"),
   getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
   ensureDataDir: () => {},
   getPidPath: () => join(TEST_DIR, "vellum.pid"),
@@ -560,4 +561,42 @@ describe("ensurePromptFiles", () => {
     const bootstrapPath = join(TEST_DIR, "BOOTSTRAP.md");
     expect(existsSync(bootstrapPath)).toBe(false);
   });
+
+  test("auto-deletes stale BOOTSTRAP.md when prior conversations exist", () => {
+    // Simulate a non-first-run workspace: core files + BOOTSTRAP.md still present
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "My identity");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "My soul");
+    writeFileSync(join(TEST_DIR, "USER.md"), "My user");
+    writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "# Stale bootstrap");
+
+    // Create a conversations directory with at least one entry
+    const convDir = join(TEST_DIR, "conversations");
+    mkdirSync(convDir, { recursive: true });
+    writeFileSync(join(convDir, "conv-001.json"), "{}");
+
+    ensurePromptFiles();
+
+    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(false);
+  });
+
+  test("keeps BOOTSTRAP.md on first run even if conversations dir exists", () => {
+    // First run: no core files exist, BOOTSTRAP.md should be created and kept
+    const convDir = join(TEST_DIR, "conversations");
+    mkdirSync(convDir, { recursive: true });
+    writeFileSync(join(convDir, "conv-001.json"), "{}");
+
+    ensurePromptFiles();
+
+    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(true);
+  });
+
+  test("keeps BOOTSTRAP.md when no conversations exist yet", () => {
+    // Non-first-run but no conversations — user hasn't chatted yet
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "My identity");
+    writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "# Bootstrap");
+
+    ensurePromptFiles();
+
+    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(true);
+  });
 });

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

@@ -226,7 +226,7 @@ describe("vellum-self-knowledge inline command expansion", () => {
 
     // Enable the feature flag via protected directory override
     _setOverridesForTesting({
-      "feature_flags.inline-skill-commands.enabled": true,
+      "inline-skill-commands": true,
     });
     testConfig.skills = { load: { extraDirs: [] } };
 

package/src/__tests__/workspace-migration-018-rekey-compound-credential-keys.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must precede migration import
+// ---------------------------------------------------------------------------
+
+// In-memory credential store. Using `let` so tests can reset between runs.
+let store = new Map<string, string>();
+let storeUnreachable = false;
+
+mock.module("../security/secure-keys.js", () => ({
+  listSecureKeysAsync: async () => ({
+    accounts: [...store.keys()],
+    unreachable: storeUnreachable,
+  }),
+  getSecureKeyAsync: async (key: string) => store.get(key),
+  setSecureKeyAsync: async (key: string, value: string) => {
+    store.set(key, value);
+    return true;
+  },
+  deleteSecureKeyAsync: async (key: string) => {
+    store.delete(key);
+  },
+}));
+
+import { rekeyCompoundCredentialKeysMigration } from "../workspace/migrations/018-rekey-compound-credential-keys.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function resetStore(entries: Record<string, string> = {}): void {
+  store = new Map(Object.entries(entries));
+  storeUnreachable = false;
+}
+
+function storeEntries(): Record<string, string> {
+  return Object.fromEntries(store);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("018-rekey-compound-credential-keys migration", () => {
+  test("has correct migration id", () => {
+    expect(rekeyCompoundCredentialKeysMigration.id).toBe(
+      "018-rekey-compound-credential-keys",
+    );
+  });
+
+  test("run() re-keys compound credential from indexOf to lastIndexOf format", async () => {
+    resetStore({
+      "credential/integration/google:access_token": "my-token",
+    });
+
+    await rekeyCompoundCredentialKeysMigration.run("/fake");
+
+    expect(storeEntries()).toEqual({
+      "credential/integration:google/access_token": "my-token",
+    });
+  });
+
+  test("run() leaves simple single-colon keys unchanged", async () => {
+    resetStore({
+      "credential/github/token": "gh-token",
+    });
+
+    await rekeyCompoundCredentialKeysMigration.run("/fake");
+
+    expect(storeEntries()).toEqual({
+      "credential/github/token": "gh-token",
+    });
+  });
+
+  test("run() ignores non-credential keys", async () => {
+    resetStore({
+      "other/integration/google:access_token": "my-token",
+    });
+
+    await rekeyCompoundCredentialKeysMigration.run("/fake");
+
+    expect(storeEntries()).toEqual({
+      "other/integration/google:access_token": "my-token",
+    });
+  });
+
+  test("run() is idempotent — second run is a no-op", async () => {
+    resetStore({
+      "credential/integration/google:access_token": "my-token",
+    });
+
+    await rekeyCompoundCredentialKeysMigration.run("/fake");
+    const afterFirst = storeEntries();
+
+    await rekeyCompoundCredentialKeysMigration.run("/fake");
+
+    expect(storeEntries()).toEqual(afterFirst);
+  });
+
+  test("run() deletes orphaned old key when new key already exists", async () => {
+    resetStore({
+      "credential/integration/google:access_token": "old-token",
+      "credential/integration:google/access_token": "new-token",
+    });
+
+    await rekeyCompoundCredentialKeysMigration.run("/fake");
+
+    // Old key removed; new key (already present) wins
+    expect(storeEntries()).toEqual({
+      "credential/integration:google/access_token": "new-token",
+    });
+  });
+
+  test("run() throws when credential store is unreachable", async () => {
+    resetStore();
+    storeUnreachable = true;
+
+    await expect(
+      rekeyCompoundCredentialKeysMigration.run("/fake"),
+    ).rejects.toThrow("Credential store unreachable");
+  });
+
+  test("down() reverses run() — re-keys from lastIndexOf back to indexOf format", async () => {
+    resetStore({
+      "credential/integration:google/access_token": "my-token",
+    });
+
+    await rekeyCompoundCredentialKeysMigration.down("/fake");
+
+    expect(storeEntries()).toEqual({
+      "credential/integration/google:access_token": "my-token",
+    });
+  });
+
+  test("down() leaves simple keys unchanged", async () => {
+    resetStore({
+      "credential/github/token": "gh-token",
+    });
+
+    await rekeyCompoundCredentialKeysMigration.down("/fake");
+
+    expect(storeEntries()).toEqual({
+      "credential/github/token": "gh-token",
+    });
+  });
+
+  test("down() is idempotent — second down() is a no-op", async () => {
+    resetStore({
+      "credential/integration:google/access_token": "my-token",
+    });
+
+    await rekeyCompoundCredentialKeysMigration.down("/fake");
+    const afterFirst = storeEntries();
+
+    await rekeyCompoundCredentialKeysMigration.down("/fake");
+
+    expect(storeEntries()).toEqual(afterFirst);
+  });
+
+  test("run() then down() restores original state", async () => {
+    const original = {
+      "credential/integration/google:access_token": "my-token",
+    };
+    resetStore(original);
+
+    await rekeyCompoundCredentialKeysMigration.run("/fake");
+    await rekeyCompoundCredentialKeysMigration.down("/fake");
+
+    expect(storeEntries()).toEqual(original);
+  });
+
+  test("down() throws when credential store is unreachable", async () => {
+    resetStore();
+    storeUnreachable = true;
+
+    await expect(
+      rekeyCompoundCredentialKeysMigration.down("/fake"),
+    ).rejects.toThrow("Credential store unreachable");
+  });
+});

package/src/__tests__/workspace-migration-backfill-installation-id.test.ts

@@ -284,20 +284,21 @@ describe("011-backfill-installation-id migration", () => {
     expect(parsed.assistants[0].installationId).toBe("sqlite-id");
   });
 
-  test("respects BASE_DATA_DIR environment variable", () => {
+  test("ignores BASE_DATA_DIR and always reads lockfile from homedir", () => {
     process.env.BASE_DATA_DIR = "/custom-base";
     getMemoryCheckpointFn.mockReturnValue("sqlite-id");
 
-    const customLockPath = "/custom-base/.vellum.lock.json";
+    // Lockfile under BASE_DATA_DIR should be ignored — the migration
+    // always reads from homedir() (per-user, not per-instance).
     setupFs({
-      [customLockPath]: makeLockfile([{ assistantId: "my-assistant" }]),
+      [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
     });
 
     backfillInstallationIdMigration.run(WORKSPACE_DIR);
 
     expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
     const [path] = writeFileSyncFn.mock.calls[0] as [string, string];
-    expect(path).toBe(customLockPath);
+    expect(path).toBe(LOCK_PATH);
   });
 
   test("preserves other assistants in lockfile when writing", () => {