@vellumai/assistant 0.9.0 → 0.9.1-staging.1

package/src/__tests__/config-loader-backfill.test.ts

@@ -417,6 +417,24 @@ describe("loadConfig startup behavior", () => {
     expect(raw.memory?.jobs?.workerConcurrency).toBe(4);
   });
 
+  test("strips daemon.reapOrphanedSubprocesses from existing user configs", () => {
+    // `daemon.reapOrphanedSubprocesses` is a deprecated opt-in flag: the
+    // orphan-subprocess reaper runs by default whenever the daemon is PID 1 on
+    // Linux. Existing configs that have it written to disk should load cleanly
+    // with the field silently stripped.
+    writeConfig({
+      provider: "anthropic",
+      daemon: { reapOrphanedSubprocesses: true, standaloneRecording: false },
+    });
+
+    loadConfig();
+
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    expect(raw.daemon?.reapOrphanedSubprocesses).toBeUndefined();
+    // Sibling fields under daemon are preserved
+    expect(raw.daemon?.standaloneRecording).toBe(false);
+  });
+
   test("still writes a default config on first launch when file is absent", () => {
     // Discoverability: when no config.json exists, write one populated with
     // all schema defaults so users can see and edit available options.
@@ -674,6 +692,70 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.activeProfile).toBe("balanced");
   });
 
+  test("on-platform managed profiles reconcile to the code template on every boot", () => {
+    // Headline behavior: on-platform installs now reconcile managed profile
+    // content from the code template on every boot (same as off-platform), so
+    // model/config updates ship in a release without a workspace migration.
+    process.env.IS_PLATFORM = "true";
+
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "anthropic",
+            model: "old-model-from-previous-release",
+            maxTokens: 1,
+            provider_connection: "anthropic-managed",
+          },
+        },
+        activeProfile: "balanced",
+      },
+    });
+
+    // Non-hatch boot (no overlay). Content is refreshed from the template.
+    mergeDefaultConfigAndSeedInferenceProfiles();
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+    expect(raw.llm.profiles.balanced.model).toBe("claude-sonnet-4-6");
+    expect(raw.llm.profiles.balanced.maxTokens).toBe(16000);
+    expect(raw.llm.profiles.balanced.provider_connection).toBe(
+      "anthropic-managed",
+    );
+    expect(raw.llm.activeProfile).toBe("balanced");
+  });
+
+  test("on-platform reseed preserves user-edited label and status on managed profiles", () => {
+    // The only two fields a user may override on a managed profile — label and
+    // status — survive the on-platform reconcile, exactly as off-platform.
+    process.env.IS_PLATFORM = "true";
+
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "anthropic",
+            model: "old-model-from-previous-release",
+            provider_connection: "anthropic-managed",
+            label: "My Default",
+            status: "disabled",
+          },
+        },
+        activeProfile: "balanced",
+      },
+    });
+
+    mergeDefaultConfigAndSeedInferenceProfiles();
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+    // Content refreshes from the template...
+    expect(raw.llm.profiles.balanced.model).toBe("claude-sonnet-4-6");
+    // ...but the user's label and status overrides are preserved.
+    expect(raw.llm.profiles.balanced.label).toBe("My Default");
+    expect(raw.llm.profiles.balanced.status).toBe("disabled");
+  });
+
   test("off-platform reseed preserves user-edited label on managed profiles (Codex P1 on PR #30362)", () => {
     // Simulate a user who renamed the managed "balanced" profile via
     // PUT /v1/config/llm/profiles/balanced { label: "My Default" }.
@@ -770,7 +852,13 @@ describe("loadConfig startup behavior", () => {
     expect("status" in raw.llm.profiles.balanced).toBe(false);
   });
 
-  test("platform-provided profile fragments are not polluted by managed seeds", () => {
+  test("platform overlay fragment wins its hatch boot, then content reconciles to the code template (label preserved)", () => {
+    // The overlay is authoritative for the boot it is supplied: its `balanced`
+    // fragment lands verbatim and is never polluted by template fields it omits
+    // (no maxTokens/thinking leak in). On the next boot — overlay archived —
+    // managed profile *content* reconciles to the code template, since the
+    // templates are the single source of truth for content. Only the
+    // user/overlay-set `label` survives the reconcile.
     process.env.IS_PLATFORM = "true";
 
     writeConfig({
@@ -824,6 +912,7 @@ describe("loadConfig startup behavior", () => {
     const config = loadConfig();
     const mainAgentConfig = resolveCallSiteConfig("mainAgent", config.llm);
 
+    // Hatch boot: overlay fragment is preserved verbatim (preserveProfileNames).
     expect(config.llm.activeProfile).toBe("balanced");
     expect(config.llm.profiles.balanced).toEqual({
       source: "managed",
@@ -844,16 +933,24 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced.maxTokens).toBeUndefined();
     expect(raw.llm.profiles.balanced.thinking).toBeUndefined();
 
+    // Next boot, no overlay: content reconciles to the anthropic-managed code
+    // template; only the overlay-set label is carried across.
     mergeDefaultConfigAndSeedInferenceProfiles();
 
     const afterRestart = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
     expect(afterRestart.llm.activeProfile).toBe("balanced");
-    expect(afterRestart.llm.profiles.balanced).toEqual({
-      source: "managed",
-      provider: "openai",
-      model: "gpt-5.4",
-      label: "Platform Balanced",
+    expect(afterRestart.llm.profiles.balanced.provider).toBe("anthropic");
+    expect(afterRestart.llm.profiles.balanced.provider_connection).toBe(
+      "anthropic-managed",
+    );
+    expect(afterRestart.llm.profiles.balanced.model).toBe("claude-sonnet-4-6");
+    expect(afterRestart.llm.profiles.balanced.maxTokens).toBe(16000);
+    expect(afterRestart.llm.profiles.balanced.thinking).toEqual({
+      enabled: true,
+      streamThinking: true,
     });
+    // The user/overlay-set label is the one field that survives the reconcile.
+    expect(afterRestart.llm.profiles.balanced.label).toBe("Platform Balanced");
   });
 
   test("quarantines corrupt config before merging hatch overlay", () => {

package/src/__tests__/config-watcher.test.ts

@@ -231,24 +231,6 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(1);
   });
 
-  test("SOUL.md change triggers identity intro refetch notification", async () => {
-    let introCallCount = 0;
-    watcher.start(
-      onConversationEvict,
-      undefined,
-      undefined,
-      undefined,
-      undefined,
-      undefined,
-      () => {
-        introCallCount += 1;
-      },
-    );
-    simulateFileChange(WORKSPACE_DIR, "SOUL.md");
-    await new Promise((r) => setTimeout(r, WAIT_MS));
-    expect(introCallCount).toBe(1);
-  });
-
   test("IDENTITY.md change triggers onConversationEvict", async () => {
     watcher.start(onConversationEvict);
     simulateFileChange(WORKSPACE_DIR, "IDENTITY.md");

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -366,6 +366,7 @@ import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
 interface CapturedAgentLoopRun {
   callSite: LLMCallSite | undefined;
   overrideProfile: string | undefined;
+  forceOverrideProfile: boolean | undefined;
   resolvedOverrideProfile: string | undefined;
   resolvedMaxInputTokens: number | undefined;
 }
@@ -383,6 +384,7 @@ function makeCtx(
     captured.push({
       callSite: options.callSite,
       overrideProfile: options.overrideProfile,
+      forceOverrideProfile: options.forceOverrideProfile,
       resolvedOverrideProfile: options.resolveOverrideProfile?.(),
       resolvedMaxInputTokens: options.resolveContextWindow?.().maxInputTokens,
     });
@@ -620,6 +622,26 @@ describe("runAgentLoopImpl — per-conversation inferenceProfile", () => {
     expect(captured.length).toBeGreaterThan(0);
     for (const call of captured) {
       expect(call.overrideProfile).toBe("fast");
+      expect(call.forceOverrideProfile).toBeUndefined();
+    }
+  });
+
+  test("explicit options.forceOverrideProfile is passed to AgentLoop.run", async () => {
+    const captured: CapturedAgentLoopRun[] = [];
+    const ctx = makeCtx(captured, {
+      conversationType: "background",
+      inferenceProfile: null,
+    });
+
+    await runAgentLoopImpl(ctx, "hello", "msg-1", () => {}, {
+      overrideProfile: "fast",
+      forceOverrideProfile: true,
+    });
+
+    expect(captured.length).toBeGreaterThan(0);
+    for (const call of captured) {
+      expect(call.overrideProfile).toBe("fast");
+      expect(call.forceOverrideProfile).toBe(true);
     }
   });
 

package/src/__tests__/credential-broker.test.ts

@@ -1,14 +1,24 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { credentialKey } from "../security/credential-key.js";
+import { _resetBackend, setSecureKeyAsync } from "../security/secure-keys.js";
 import { CredentialBroker } from "../tools/credentials/broker.js";
 import {
   _setMetadataPath,
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
+import { BROWSER_FILL_CAPABILITY } from "../tools/credentials/tool-policy.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
+
+const TEST_DIR = join(
+  tmpdir(),
+  `vellum-broker-test-${randomBytes(4).toString("hex")}`,
+);
+const STORE_PATH = join(TEST_DIR, "keys.enc");
 
 describe("CredentialBroker", () => {
   let broker: CredentialBroker;
@@ -222,3 +232,441 @@ describe("CredentialBroker", () => {
     });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Behavior that reads stored secret values, exercised against the encrypted
+// store backend (transient injection, multi-template serverUseById, revokeAll,
+// and canonical/legacy capability-key resolution).
+// ---------------------------------------------------------------------------
+
+describe("CredentialBroker (encrypted store backend)", () => {
+  let broker: CredentialBroker;
+
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(TEST_DIR, { recursive: true });
+    setStorePathForTesting(STORE_PATH);
+    _resetBackend();
+    _setMetadataPath(join(TEST_DIR, "metadata.json"));
+    broker = new CredentialBroker();
+  });
+
+  afterEach(() => {
+    _setMetadataPath(null);
+    setStorePathForTesting(null);
+    _resetBackend();
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("transient credentials", () => {
+    test("consume returns transient value and deletes it", () => {
+      // GIVEN a credential with metadata and an injected one-time transient value
+      upsertCredentialMetadata("svc", "key", { allowedTools: ["tool1"] });
+      broker.injectTransient("svc", "key", "one-time-secret");
+
+      // WHEN the credential is authorized and consumed
+      const auth = broker.authorize({
+        service: "svc",
+        field: "key",
+        toolName: "tool1",
+      });
+      expect(auth.authorized).toBe(true);
+      if (!auth.authorized) return;
+      const result = broker.consume(auth.token.tokenId);
+
+      // THEN the transient value is returned alongside the storage key
+      expect(result.success).toBe(true);
+      expect(result.value).toBe("one-time-secret");
+      expect(result.storageKey).toBe(credentialKey("svc", "key"));
+
+      // AND a subsequent authorize+consume no longer has the transient value
+      const auth2 = broker.authorize({
+        service: "svc",
+        field: "key",
+        toolName: "tool1",
+      });
+      expect(auth2.authorized).toBe(true);
+      if (!auth2.authorized) return;
+      const result2 = broker.consume(auth2.token.tokenId);
+      expect(result2.success).toBe(true);
+      expect(result2.value).toBeUndefined();
+    });
+
+    test("browserFill uses transient value when available", async () => {
+      // GIVEN a credential with a transient value and no stored value
+      upsertCredentialMetadata("github", "token", {
+        allowedTools: ["browser_fill_credential"],
+      });
+      broker.injectTransient("github", "token", "transient-ghp-123");
+
+      // WHEN browserFill runs
+      let filledValue: string | undefined;
+      const result = await broker.browserFill({
+        service: "github",
+        field: "token",
+        toolName: "browser_fill_credential",
+        fill: async (v) => {
+          filledValue = v;
+        },
+      });
+
+      // THEN the transient value is filled
+      expect(result.success).toBe(true);
+      expect(filledValue).toBe("transient-ghp-123");
+    });
+
+    test("browserFill consumes transient value — second fill falls back to stored", async () => {
+      // GIVEN a credential with both a stored value and a transient value
+      upsertCredentialMetadata("github", "token", {
+        allowedTools: ["browser_fill_credential"],
+      });
+      await setSecureKeyAsync(credentialKey("github", "token"), "stored-value");
+      broker.injectTransient("github", "token", "transient-value");
+
+      // WHEN browserFill runs twice
+      let filled1: string | undefined;
+      await broker.browserFill({
+        service: "github",
+        field: "token",
+        toolName: "browser_fill_credential",
+        fill: async (v) => {
+          filled1 = v;
+        },
+      });
+      let filled2: string | undefined;
+      await broker.browserFill({
+        service: "github",
+        field: "token",
+        toolName: "browser_fill_credential",
+        fill: async (v) => {
+          filled2 = v;
+        },
+      });
+
+      // THEN the first fill uses the transient and the second falls back to stored
+      expect(filled1).toBe("transient-value");
+      expect(filled2).toBe("stored-value");
+    });
+
+    test("browserFill preserves transient value on fill failure", async () => {
+      // GIVEN a credential with a transient value
+      upsertCredentialMetadata("github", "token", {
+        allowedTools: ["browser_fill_credential"],
+      });
+      broker.injectTransient("github", "token", "transient-preserved");
+
+      // WHEN the first fill throws
+      const result1 = await broker.browserFill({
+        service: "github",
+        field: "token",
+        toolName: "browser_fill_credential",
+        fill: async () => {
+          throw new Error("Playwright timeout");
+        },
+      });
+      expect(result1.success).toBe(false);
+      let filled: string | undefined;
+      const result2 = await broker.browserFill({
+        service: "github",
+        field: "token",
+        toolName: "browser_fill_credential",
+        fill: async (v) => {
+          filled = v;
+        },
+      });
+
+      // THEN the transient value survives for the second fill
+      expect(result2.success).toBe(true);
+      expect(filled).toBe("transient-preserved");
+    });
+
+    test("serverUse uses transient value when available", async () => {
+      // GIVEN a credential with a transient value
+      upsertCredentialMetadata("vercel", "api_token", {
+        allowedTools: ["deploy"],
+      });
+      broker.injectTransient("vercel", "api_token", "transient-vercel-tok");
+
+      // WHEN serverUse runs
+      const result = await broker.serverUse({
+        service: "vercel",
+        field: "api_token",
+        toolName: "deploy",
+        execute: async (v) => {
+          expect(v).toBe("transient-vercel-tok");
+          return "deployed";
+        },
+      });
+
+      // THEN the transient value is used for execution
+      expect(result.success).toBe(true);
+      expect(result.result).toBe("deployed");
+    });
+
+    test("serverUse consumes transient — subsequent call has no value without stored key", async () => {
+      // GIVEN a credential with only a transient value (no stored value)
+      upsertCredentialMetadata("vercel", "api_token", {
+        allowedTools: ["deploy"],
+      });
+      broker.injectTransient("vercel", "api_token", "transient-only");
+
+      // WHEN serverUse runs twice
+      await broker.serverUse({
+        service: "vercel",
+        field: "api_token",
+        toolName: "deploy",
+        execute: async () => "ok",
+      });
+      const result = await broker.serverUse({
+        service: "vercel",
+        field: "api_token",
+        toolName: "deploy",
+        execute: async () => {
+          throw new Error("should not be called");
+        },
+      });
+
+      // THEN the second call fails because no stored value remains
+      expect(result.success).toBe(false);
+      expect(result.reason).toContain("no stored value");
+    });
+
+    test("injectTransient replaces previous transient for same key", () => {
+      // GIVEN two transient values injected for the same credential
+      upsertCredentialMetadata("svc", "key", { allowedTools: ["t"] });
+      broker.injectTransient("svc", "key", "first");
+      broker.injectTransient("svc", "key", "second");
+
+      // WHEN the credential is authorized and consumed
+      const auth = broker.authorize({
+        service: "svc",
+        field: "key",
+        toolName: "t",
+      });
+      if (!auth.authorized) return;
+      const result = broker.consume(auth.token.tokenId);
+
+      // THEN the most recent transient value wins
+      expect(result.value).toBe("second");
+    });
+
+    test("transient value for one credential does not affect another", () => {
+      // GIVEN a transient value injected for svcA only
+      upsertCredentialMetadata("svcA", "key", { allowedTools: ["t"] });
+      upsertCredentialMetadata("svcB", "key", { allowedTools: ["t"] });
+      broker.injectTransient("svcA", "key", "val-a");
+
+      // WHEN both credentials are authorized and consumed
+      const authB = broker.authorize({
+        service: "svcB",
+        field: "key",
+        toolName: "t",
+      });
+      if (!authB.authorized) return;
+      const resultB = broker.consume(authB.token.tokenId);
+      const authA = broker.authorize({
+        service: "svcA",
+        field: "key",
+        toolName: "t",
+      });
+      if (!authA.authorized) return;
+      const resultA = broker.consume(authA.token.tokenId);
+
+      // THEN only svcA carries the transient value
+      expect(resultB.success).toBe(true);
+      expect(resultB.value).toBeUndefined();
+      expect(resultA.value).toBe("val-a");
+    });
+  });
+
+  describe("serverUseById edge cases", () => {
+    test("serverUseById with multiple injection templates returns all", async () => {
+      // GIVEN a credential with two injection templates and a stored value
+      const meta = upsertCredentialMetadata("multi", "api_key", {
+        allowedTools: ["proxy"],
+        injectionTemplates: [
+          {
+            hostPattern: "*.fal.ai",
+            injectionType: "header",
+            headerName: "Authorization",
+            valuePrefix: "Key ",
+          },
+          {
+            hostPattern: "gateway.fal.ai",
+            injectionType: "header",
+            headerName: "X-Fal-Key",
+          },
+        ],
+      });
+      await setSecureKeyAsync(
+        credentialKey("multi", "api_key"),
+        "multi-secret",
+      );
+
+      // WHEN serverUseById resolves the credential by id
+      const result = await broker.serverUseById({
+        credentialId: meta.credentialId,
+        requestingTool: "proxy",
+      });
+
+      // THEN both injection templates are returned without leaking the secret
+      expect(result.success).toBe(true);
+      if (!result.success) return;
+      expect(result.injectionTemplates).toHaveLength(2);
+      expect(result.injectionTemplates[0].hostPattern).toBe("*.fal.ai");
+      expect(result.injectionTemplates[1].hostPattern).toBe("gateway.fal.ai");
+      expect(JSON.stringify(result)).not.toContain("multi-secret");
+    });
+  });
+
+  describe("revokeAll", () => {
+    test("revokeAll clears all tokens and subsequent consume fails", () => {
+      // GIVEN two active tokens for a credential
+      upsertCredentialMetadata("svc", "key", { allowedTools: ["t1", "t2"] });
+      const a1 = broker.authorize({
+        service: "svc",
+        field: "key",
+        toolName: "t1",
+      });
+      const a2 = broker.authorize({
+        service: "svc",
+        field: "key",
+        toolName: "t2",
+      });
+      expect(broker.activeTokenCount).toBe(2);
+
+      // WHEN revokeAll is called
+      broker.revokeAll();
+
+      // THEN the token count is zero and consuming either token fails
+      expect(broker.activeTokenCount).toBe(0);
+      if (a1.authorized) {
+        expect(broker.consume(a1.token.tokenId).success).toBe(false);
+      }
+      if (a2.authorized) {
+        expect(broker.consume(a2.token.tokenId).success).toBe(false);
+      }
+    });
+
+    test("revokeAll on empty broker is a no-op", () => {
+      // GIVEN a broker with no active tokens
+      expect(broker.activeTokenCount).toBe(0);
+
+      // WHEN revokeAll is called
+      broker.revokeAll();
+
+      // THEN the token count remains zero
+      expect(broker.activeTokenCount).toBe(0);
+    });
+  });
+
+  describe("canonical capability key", () => {
+    test("authorize succeeds with canonical key when metadata has canonical key", () => {
+      // GIVEN metadata allowing the canonical browser-fill capability key
+      upsertCredentialMetadata("github", "token", {
+        allowedTools: [BROWSER_FILL_CAPABILITY],
+      });
+
+      // WHEN authorizing with the canonical key
+      const result = broker.authorize({
+        service: "github",
+        field: "token",
+        toolName: BROWSER_FILL_CAPABILITY,
+      });
+
+      // THEN authorization succeeds
+      expect(result.authorized).toBe(true);
+    });
+
+    test("authorize succeeds with canonical key when metadata has legacy alias", () => {
+      // GIVEN metadata stored under the legacy browser_fill_credential alias
+      upsertCredentialMetadata("github", "token", {
+        allowedTools: ["browser_fill_credential"],
+      });
+
+      // WHEN authorizing with the canonical key
+      const result = broker.authorize({
+        service: "github",
+        field: "token",
+        toolName: BROWSER_FILL_CAPABILITY,
+      });
+
+      // THEN authorization succeeds
+      expect(result.authorized).toBe(true);
+    });
+
+    test("authorize succeeds with legacy alias when metadata has canonical key", () => {
+      // GIVEN metadata allowing the canonical capability key
+      upsertCredentialMetadata("github", "token", {
+        allowedTools: [BROWSER_FILL_CAPABILITY],
+      });
+
+      // WHEN authorizing with the legacy alias
+      const result = broker.authorize({
+        service: "github",
+        field: "token",
+        toolName: "browser_fill_credential",
+      });
+
+      // THEN authorization succeeds
+      expect(result.authorized).toBe(true);
+    });
+
+    test("serverUse with canonical key works when metadata has legacy alias", async () => {
+      // GIVEN metadata stored under the legacy alias with a stored value
+      upsertCredentialMetadata("vercel", "api_token", {
+        allowedTools: ["browser_fill_credential"],
+      });
+      await setSecureKeyAsync(
+        credentialKey("vercel", "api_token"),
+        "vercel-tok",
+      );
+
+      // WHEN serverUse runs with the canonical key
+      const result = await broker.serverUse({
+        service: "vercel",
+        field: "api_token",
+        toolName: BROWSER_FILL_CAPABILITY,
+        execute: async (v) => v,
+      });
+
+      // THEN execution succeeds with the stored value
+      expect(result.success).toBe(true);
+      expect(result.result).toBe("vercel-tok");
+    });
+
+    test("non-aliased tool names are unaffected by alias resolution", () => {
+      // GIVEN metadata allowing a non-aliased custom tool
+      upsertCredentialMetadata("svc", "key", {
+        allowedTools: ["custom_tool"],
+      });
+
+      // WHEN authorizing with that custom tool
+      const result = broker.authorize({
+        service: "svc",
+        field: "key",
+        toolName: "custom_tool",
+      });
+
+      // THEN authorization succeeds
+      expect(result.authorized).toBe(true);
+    });
+
+    test("non-aliased tool denied when only canonical key is allowed", () => {
+      // GIVEN metadata allowing only the canonical capability key
+      upsertCredentialMetadata("svc", "key", {
+        allowedTools: [BROWSER_FILL_CAPABILITY],
+      });
+
+      // WHEN authorizing with an unrelated tool
+      const result = broker.authorize({
+        service: "svc",
+        field: "key",
+        toolName: "unrelated_tool",
+      });
+
+      // THEN authorization is denied
+      expect(result.authorized).toBe(false);
+    });
+  });
+});

package/src/__tests__/credential-execution-tools.test.ts

@@ -136,7 +136,6 @@ describe("secure tool installation is separate from credential grants", () => {
   test("manage_secure_command_tool does not share tool name with grant tools", () => {
     // The tool name must not collide with existing credential grant tools
     const grantToolNames = [
-      "credential_store",
       "credential_grant",
       "credential_revoke",
       "credential_list",