@vellumai/assistant 0.7.1 → 0.7.3

package/src/__tests__/openai-provider.test.ts

@@ -50,6 +50,10 @@ let lastCreateOptions: Record<string, unknown> | null = null;
 let lastConstructorOptions: Record<string, unknown> | null = null;
 let shouldThrow: Error | null = null;
 
+function userMsg(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
 // Simulate OpenAI.APIError
 class FakeAPIError extends Error {
   status: number;
@@ -1294,10 +1298,6 @@ describe("effort config passthrough", () => {
 // ---------------------------------------------------------------------------
 
 describe("OpenRouterProvider reasoning", () => {
-  function userMsg(text: string): Message {
-    return { role: "user", content: [{ type: "text", text }] };
-  }
-
   beforeEach(() => {
     fakeChunks = [textChunk("OK"), usageChunk(10, 2)];
     lastCreateParams = null;
@@ -1367,6 +1367,47 @@ describe("OpenRouterProvider reasoning", () => {
   });
 });
 
+describe("OpenRouterProvider Anthropic-compatible errors", () => {
+  test("retags Anthropic ProviderError instances as OpenRouter errors", async () => {
+    const provider = new OpenRouterProvider("or-key", "anthropic/claude-4.5");
+    const abortReason = createAbortReason(
+      "user_cancel",
+      "openrouter-provider-test",
+    );
+    const cause = new Error("upstream cause");
+    const innerError = new ProviderError(
+      "Anthropic API error (402): Payment Required",
+      "anthropic",
+      402,
+      { cause, retryAfterMs: 1250, abortReason },
+    );
+
+    (
+      provider as unknown as {
+        anthropicInner: {
+          sendMessage: OpenRouterProvider["sendMessage"];
+        };
+      }
+    ).anthropicInner = {
+      sendMessage: async () => {
+        throw innerError;
+      },
+    };
+
+    try {
+      await provider.sendMessage([userMsg("hi")]);
+      throw new Error("expected sendMessage to throw");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ProviderError);
+      expect((error as ProviderError).provider).toBe("openrouter");
+      expect((error as ProviderError).statusCode).toBe(402);
+      expect((error as ProviderError).retryAfterMs).toBe(1250);
+      expect((error as ProviderError).abortReason).toBe(abortReason);
+      expect((error as Error).cause).toBe(cause);
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Reasoning effort → OpenAI reasoning_effort mapping
 // ---------------------------------------------------------------------------
@@ -1374,10 +1415,6 @@ describe("OpenRouterProvider reasoning", () => {
 describe("OpenAIProvider reasoning_effort", () => {
   let provider: OpenAIProvider;
 
-  function userMsg(text: string): Message {
-    return { role: "user", content: [{ type: "text", text }] };
-  }
-
   beforeEach(() => {
     fakeChunks = [textChunk("OK"), usageChunk(10, 2)];
     lastCreateParams = null;

package/src/__tests__/persist-onboarding-artifacts.test.ts

@@ -27,6 +27,31 @@ mock.module("../util/logger.js", () => ({
 
 let writeRelationshipStateCalled = false;
 let sidecarPayload: unknown = null;
+let writeOnboardingSectionPayload: unknown = null;
+
+mock.module("../prompts/normalize-onboarding.js", () => ({
+  normalizeOnboardingContext: (ctx: unknown) => ctx,
+}));
+
+mock.module("../prompts/persona-resolver.js", () => ({
+  writeOnboardingSection: (payload: unknown) => {
+    writeOnboardingSectionPayload = payload;
+  },
+  resolveGuardianPersonaPath: () => join(TEST_DIR, "users", "guardian.md"),
+  resolveGuardianPersona: () => null,
+  resolveGuardianPersonaStrict: () => null,
+  resolveUserPersona: () => null,
+  resolveChannelPersona: () => null,
+  resolvePersonaContext: () => ({
+    userPersona: null,
+    userSlug: null,
+    channelPersona: null,
+  }),
+  resolveUserSlug: () => null,
+  ensureGuardianPersonaFile: () => {},
+  isGuardianPersonaCustomized: () => false,
+  GUARDIAN_PERSONA_TEMPLATE: "",
+}));
 
 mock.module("../home/relationship-state-writer.js", () => ({
   RELATIONSHIP_STATE_FILENAME: "relationship-state.json",
@@ -59,13 +84,12 @@ describe("persistOnboardingArtifacts", () => {
     mkdirSync(TEST_DIR, { recursive: true });
     writeRelationshipStateCalled = false;
     sidecarPayload = null;
+    writeOnboardingSectionPayload = null;
   });
 
   afterEach(() => {
-    for (const name of ["IDENTITY.md", "USER.md"]) {
-      const p = workspacePath(name);
-      if (existsSync(p)) rmSync(p, { force: true });
-    }
+    const p = workspacePath("IDENTITY.md");
+    if (existsSync(p)) rmSync(p, { force: true });
   });
 
   test("seeds IDENTITY.md with assistant name when file does not exist", () => {
@@ -80,19 +104,7 @@ describe("persistOnboardingArtifacts", () => {
     expect(content).toBe("# Identity\n\n- **Name:** Nova\n");
   });
 
-  test("seeds USER.md with user name when file does not exist", () => {
-    persistOnboardingArtifacts({
-      tools: ["slack"],
-      tasks: ["email"],
-      tone: "balanced",
-      userName: "Alex",
-    });
-
-    const content = readFileSync(workspacePath("USER.md"), "utf-8");
-    expect(content).toBe("# User\n\n- **Name:** Alex\n");
-  });
-
-  test("seeds both IDENTITY.md and USER.md when both names are provided", () => {
+  test("seeds IDENTITY.md when both names are provided", () => {
     persistOnboardingArtifacts({
       tools: [],
       tasks: [],
@@ -104,9 +116,6 @@ describe("persistOnboardingArtifacts", () => {
     expect(readFileSync(workspacePath("IDENTITY.md"), "utf-8")).toBe(
       "# Identity\n\n- **Name:** Pax\n",
     );
-    expect(readFileSync(workspacePath("USER.md"), "utf-8")).toBe(
-      "# User\n\n- **Name:** Alex\n",
-    );
   });
 
   test("updates Name field in existing IDENTITY.md template", () => {
@@ -128,23 +137,6 @@ describe("persistOnboardingArtifacts", () => {
     );
   });
 
-  test("updates Name field in existing USER.md template", () => {
-    writeFileSync(
-      workspacePath("USER.md"),
-      "# User\n\n- **Name:** _(not yet chosen)_\n",
-    );
-
-    persistOnboardingArtifacts({
-      tools: [],
-      tasks: [],
-      tone: "casual",
-      userName: "NewUser",
-    });
-
-    const content = readFileSync(workspacePath("USER.md"), "utf-8");
-    expect(content).toBe("# User\n\n- **Name:** NewUser\n");
-  });
-
   test("updates old-format Name field in existing IDENTITY.md", () => {
     writeFileSync(
       workspacePath("IDENTITY.md"),
@@ -190,17 +182,6 @@ describe("persistOnboardingArtifacts", () => {
     expect(existsSync(workspacePath("IDENTITY.md"))).toBe(false);
   });
 
-  test("skips USER.md when userName is missing", () => {
-    persistOnboardingArtifacts({
-      tools: ["notion"],
-      tasks: ["project-management"],
-      tone: "balanced",
-      assistantName: "Nova",
-    });
-
-    expect(existsSync(workspacePath("USER.md"))).toBe(false);
-  });
-
   test("skips IDENTITY.md when assistantName is whitespace-only", () => {
     persistOnboardingArtifacts({
       tools: [],
@@ -212,32 +193,17 @@ describe("persistOnboardingArtifacts", () => {
     expect(existsSync(workspacePath("IDENTITY.md"))).toBe(false);
   });
 
-  test("skips USER.md when userName is whitespace-only", () => {
-    persistOnboardingArtifacts({
-      tools: [],
-      tasks: [],
-      tone: "balanced",
-      userName: "  ",
-    });
-
-    expect(existsSync(workspacePath("USER.md"))).toBe(false);
-  });
-
-  test("trims whitespace from names before writing", () => {
+  test("trims whitespace from assistantName before writing", () => {
     persistOnboardingArtifacts({
       tools: [],
       tasks: [],
       tone: "balanced",
-      userName: "  Alex  ",
       assistantName: "  Nova  ",
     });
 
     expect(readFileSync(workspacePath("IDENTITY.md"), "utf-8")).toBe(
       "# Identity\n\n- **Name:** Nova\n",
     );
-    expect(readFileSync(workspacePath("USER.md"), "utf-8")).toBe(
-      "# User\n\n- **Name:** Alex\n",
-    );
   });
 
   test("passes onboarding payload to writeOnboardingSidecar", () => {
@@ -263,4 +229,18 @@ describe("persistOnboardingArtifacts", () => {
 
     expect(writeRelationshipStateCalled).toBe(true);
   });
+
+  test("calls writeOnboardingSection with normalized data", () => {
+    const payload = {
+      tools: ["slack", "linear"],
+      tasks: ["code-building", "writing"],
+      tone: "professional",
+      userName: "Alex",
+      assistantName: "Nova",
+    };
+
+    persistOnboardingArtifacts(payload);
+
+    expect(writeOnboardingSectionPayload).toEqual(payload);
+  });
 });

package/src/__tests__/persistence-secret-redaction.test.ts

@@ -0,0 +1,299 @@
+/**
+ * Verifies that known-pattern secrets are redacted before being written to
+ * durable conversation storage while the live model history (pendingToolResults,
+ * raw message content) is left untouched.
+ *
+ * Touch points under test:
+ *   - Tool result content blocks persisted by handleMessageComplete
+ *   - Assistant message text blocks persisted by handleMessageComplete
+ */
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Shared mock plumbing (must precede module-under-test imports) ──────────
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+interface AddMessageCall {
+  conversationId: string;
+  role: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+const addMessageCalls: AddMessageCall[] = [];
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: (
+    conversationId: string,
+    role: string,
+    content: string,
+    metadata?: Record<string, unknown>,
+  ) => {
+    addMessageCalls.push({ conversationId, role, content, metadata });
+    return { id: `mock-msg-${addMessageCalls.length}` };
+  },
+  getConversation: () => null,
+  getMessageById: () => null,
+  updateMessageContent: () => {},
+  provenanceFromTrustContext: () => ({}),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+mock.module("../memory/memory-recall-log-store.js", () => ({
+  backfillMemoryRecallLogMessageId: () => {},
+}));
+
+mock.module("../memory/conversation-disk-view.js", () => ({
+  syncMessageToDisk: () => {},
+}));
+
+// ── Imports (after mocks) ──────────────────────────────────────────────────
+
+import type { AgentEvent } from "../agent/loop.js";
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  handleMessageComplete,
+} from "../daemon/conversation-agent-loop-handlers.js";
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+const CONV = "conv-redact-test";
+
+function makeDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: CONV,
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      currentTurnSurfaces: [],
+      trustContext: {
+        sourceChannel: "vellum",
+        trustClass: "guardian",
+      },
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: () => {},
+    reqId: "test-req",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+  } as EventHandlerDeps;
+}
+
+function makeMessageCompleteEvent(
+  text: string,
+): Extract<AgentEvent, { type: "message_complete" }> {
+  return {
+    type: "message_complete",
+    message: { role: "assistant", content: [{ type: "text", text }] },
+  };
+}
+
+function lastPersisted(role: "assistant" | "user"): AddMessageCall {
+  for (let i = addMessageCalls.length - 1; i >= 0; i--) {
+    if (addMessageCalls[i].role === role) return addMessageCalls[i];
+  }
+  throw new Error(`No ${role} message was persisted`);
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+describe("persistence-layer secret redaction", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+    state = createEventHandlerState();
+    state.turnStartedAt = 1_700_000_000_000;
+  });
+
+  afterEach(() => {
+    addMessageCalls.length = 0;
+  });
+
+  // ── Tool result content ──────────────────────────────────────────────────
+
+  test("redacts Anthropic API key in tool result content before persistence", async () => {
+    // Pattern requires 80+ chars after "sk-ant-"
+    const secret =
+      "sk-ant-api03-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" +
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    state.pendingToolResults.set("tool-use-1", {
+      content: `Here is the key: ${secret}`,
+      isError: false,
+    });
+
+    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+
+    const persisted = lastPersisted("user");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      content: string;
+    }>;
+    expect(blocks[0].content).not.toContain("sk-ant-api03-");
+    expect(blocks[0].content).toContain("<redacted");
+  });
+
+  test("redacts GitHub PAT in tool result content before persistence", async () => {
+    // Pattern requires 36+ chars after "ghp_"
+    const secret = "ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
+    state.pendingToolResults.set("tool-use-2", {
+      content: `token=${secret}`,
+      isError: false,
+    });
+
+    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+
+    const persisted = lastPersisted("user");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      content: string;
+    }>;
+    expect(blocks[0].content).not.toContain("ghp_");
+    expect(blocks[0].content).toContain("<redacted");
+  });
+
+  test("does not redact non-secret content (UUID, hex hash) in tool result", async () => {
+    const safe = "id=550e8400-e29b-41d4-a716-446655440000 sha=a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2";
+    state.pendingToolResults.set("tool-use-3", {
+      content: safe,
+      isError: false,
+    });
+
+    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+
+    const persisted = lastPersisted("user");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      content: string;
+    }>;
+    expect(blocks[0].content).toBe(safe);
+  });
+
+  test("live model state (pendingToolResults) is not modified by persistence redaction", async () => {
+    const secret =
+      "sk-ant-api03-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" +
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const originalContent = `key=${secret}`;
+    state.pendingToolResults.set("tool-use-4", {
+      content: originalContent,
+      isError: false,
+    });
+
+    // Capture the content before handleMessageComplete clears pendingToolResults
+    const contentSnapshot = state.pendingToolResults.get("tool-use-4")!.content;
+
+    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+
+    // The snapshot taken from live state before the call must be unmodified
+    expect(contentSnapshot).toBe(originalContent);
+    expect(contentSnapshot).toContain("sk-ant-api03-");
+  });
+
+  // ── Assistant message text ───────────────────────────────────────────────
+
+  test("redacts known-pattern secret quoted in assistant text before persistence", async () => {
+    const secret =
+      "sk-ant-api03-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" +
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const text = `Your API key is \`${secret}\`. Keep it safe.`;
+
+    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(text));
+
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      text?: string;
+    }>;
+    const textBlock = blocks.find((b) => b.type === "text");
+    expect(textBlock?.text).not.toContain("sk-ant-api03-");
+    expect(textBlock?.text).toContain("<redacted");
+  });
+
+  test("redacts OpenAI Project Key quoted in assistant text before persistence", async () => {
+    // Pattern requires 40+ chars after "sk-proj-"
+    const secret = "sk-proj-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrst";
+    const text = `I found this key in the config: ${secret}`;
+
+    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(text));
+
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      text?: string;
+    }>;
+    const textBlock = blocks.find((b) => b.type === "text");
+    expect(textBlock?.text).not.toContain("sk-proj-");
+    expect(textBlock?.text).toContain("<redacted");
+  });
+
+  test("does not redact non-secret text in assistant message", async () => {
+    const safe = "Here is the file list: index.ts, util.ts, main.ts";
+
+    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(safe));
+
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      text?: string;
+    }>;
+    const textBlock = blocks.find((b) => b.type === "text");
+    expect(textBlock?.text).toBe(safe);
+  });
+
+  test("does not redact random-looking strings that lack known prefixes", async () => {
+    // High-entropy but no known credential prefix — should NOT be redacted
+    const text = "checksum: 8f14e45fceea167a5a36dedd4bea2543";
+
+    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(text));
+
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      text?: string;
+    }>;
+    const textBlock = blocks.find((b) => b.type === "text");
+    expect(textBlock?.text).toBe(text);
+  });
+});

package/src/__tests__/platform-bash-auto-approve.test.ts

@@ -67,7 +67,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
@@ -245,13 +244,11 @@ describe("platform-hosted bash auto-approval", () => {
     expect(promptCalled).toBe(true);
   });
 
-  test("bash NOT auto-approved for non-guardian actors via platform path (sandbox bash is allowed)", async () => {
+  test("bash NOT auto-approved for non-guardian actors via platform path (trusted_contact requires grant)", async () => {
     checkResultOverride = { decision: "prompt", reason: "Needs approval" };
 
-    const platformAutoApproveCalled = false;
     const trackingPrompter = {
       prompt: async () => {
-        // If this is called, we know the platform auto-approve did NOT fire
         return { decision: "allow" as const };
       },
       resolveConfirmation: () => {},
@@ -270,11 +267,10 @@ describe("platform-hosted bash auto-approval", () => {
       }),
     );
 
-    // With requireFreshApproval, trusted_contact+bash goes through check()
-    // which returns "prompt" and then the interactive prompter is called.
-    // The platform auto-approve path (guardian-only) is NOT taken.
-    expect(result.isError).toBe(false);
-    void platformAutoApproveCalled; // suppress unused warning
+    // trusted_contact now requires a guardian-scoped grant for side-effect
+    // tools. Without a grant, the pre-execution gate denies the invocation
+    // before the permission checker or prompter is reached.
+    expect(result.isError).toBe(true);
   });
 
   test("bash NOT auto-approved when requireFreshApproval is set", async () => {

package/src/__tests__/platform-callback-registration.test.ts

@@ -5,7 +5,6 @@ import { credentialKey } from "../security/credential-key.js";
 let mockIsPlatform = true;
 let mockPlatformBaseUrl = "";
 let mockPlatformAssistantId = "";
-let mockPlatformInternalApiKey = "";
 let mockSecureKeys: Record<string, string> = {};
 
 mock.module("../config/env-registry.js", () => ({
@@ -15,7 +14,6 @@ mock.module("../config/env-registry.js", () => ({
 mock.module("../config/env.js", () => ({
   getPlatformBaseUrl: () => mockPlatformBaseUrl,
   getPlatformAssistantId: () => mockPlatformAssistantId,
-  getPlatformInternalApiKey: () => mockPlatformInternalApiKey,
 }));
 
 mock.module("../security/secure-keys.js", () => ({
@@ -32,6 +30,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const originalFetch = globalThis.fetch;
+const originalEnvCredential = process.env.ASSISTANT_API_KEY;
 
 const { registerCallbackRoute, resolvePlatformCallbackRegistrationContext } =
   await import("../inbound/platform-callback-registration.js");
@@ -41,13 +40,18 @@ describe("platform callback registration", () => {
     mockIsPlatform = true;
     mockPlatformBaseUrl = "";
     mockPlatformAssistantId = "";
-    mockPlatformInternalApiKey = "";
     mockSecureKeys = {};
+    delete process.env.ASSISTANT_API_KEY;
     globalThis.fetch = originalFetch;
   });
 
   afterEach(() => {
     globalThis.fetch = originalFetch;
+    if (originalEnvCredential === undefined) {
+      delete process.env.ASSISTANT_API_KEY;
+    } else {
+      process.env.ASSISTANT_API_KEY = originalEnvCredential;
+    }
   });
 
   test("resolves managed callback context from stored credentials", async () => {
@@ -64,7 +68,6 @@ describe("platform callback registration", () => {
     expect(context.isPlatform).toBe(true);
     expect(context.platformBaseUrl).toBe("https://platform.example.com");
     expect(context.assistantId).toBe("11111111-2222-4333-8444-555555555555");
-    expect(context.hasInternalApiKey).toBe(false);
     expect(context.hasAssistantApiKey).toBe(true);
     expect(context.authHeader).toBe("Api-Key ast-managed-key");
   });
@@ -88,6 +91,20 @@ describe("platform callback registration", () => {
     expect(context.authHeader).toBe("Api-Key ast-self-hosted-key");
   });
 
+  test("uses ASSISTANT_API_KEY env fallback when stored credential is missing", async () => {
+    process.env.ASSISTANT_API_KEY = "env-key";
+    mockPlatformBaseUrl = "https://platform.example.com";
+    mockPlatformAssistantId = "33333333-4444-4555-8666-777777777777";
+
+    const context = await resolvePlatformCallbackRegistrationContext();
+
+    expect(context.enabled).toBe(true);
+    expect(context.platformBaseUrl).toBe("https://platform.example.com");
+    expect(context.assistantId).toBe("33333333-4444-4555-8666-777777777777");
+    expect(context.hasAssistantApiKey).toBe(true);
+    expect(context.authHeader).toBe("Api-Key env-key");
+  });
+
   test("registerCallbackRoute falls back to assistant API key auth", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";

package/src/__tests__/platform.test.ts

@@ -19,6 +19,7 @@ import {
   getWorkspacePromptPath,
   getWorkspaceSkillsDir,
   getXdgVellumConfigDirName,
+  vellumRoot,
 } from "../util/platform.js";
 
 const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
@@ -99,7 +100,7 @@ describe("path characterization", () => {
     ensureDataDir();
 
     // Root-level dirs (ensureDataDir always creates these)
-    const root = join(homedir(), ".vellum");
+    const root = vellumRoot();
     expect(existsSync(root)).toBe(true);
 
     // Workspace dirs (in our temp location)