@vellumai/assistant 0.12.0 → 0.12.1-staging.1

package/src/__tests__/conversation-title-service.test.ts

@@ -104,6 +104,7 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   publishConversationTitleChanged: mockPublishConversationTitleChanged,
 }));
 
+import { MESSAGE_KEYS } from "../i18n/index.js";
 import {
   AUTO_TITLE_DETERMINISTIC,
   AUTO_TITLE_LLM,
@@ -309,10 +310,10 @@ describe("conversation-title-service", () => {
       userMessage: "so about that t-shirt...",
     });
 
-    expect(result.title).toBe("Untitled Conversation");
+    expect(result.title).toBe(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED);
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
       "conv-1",
-      "Untitled Conversation",
+      MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
       AUTO_TITLE_DETERMINISTIC,
     );
   });
@@ -333,7 +334,7 @@ describe("conversation-title-service", () => {
       userMessage: "something",
     });
 
-    expect(result.title).toBe("Untitled Conversation");
+    expect(result.title).toBe(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED);
   });
 
   // The core bug this PR fixes: weak title models emit their reasoning or
@@ -361,10 +362,10 @@ describe("conversation-title-service", () => {
       userMessage: "hey baby",
     });
 
-    expect(result.title).toBe("Untitled Conversation");
+    expect(result.title).toBe(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED);
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
       "conv-1",
-      "Untitled Conversation",
+      MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
       AUTO_TITLE_DETERMINISTIC,
     );
   });
@@ -423,7 +424,7 @@ describe("conversation-title-service", () => {
       userMessage: "x",
     });
 
-    expect(result.title).toBe("Untitled Conversation");
+    expect(result.title).toBe(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED);
   });
 
   test("regeneration skips LLM call when recent messages have no extractable text", async () => {
@@ -515,17 +516,17 @@ describe("conversation-title-service", () => {
     });
 
     expect(provider.sendMessage).not.toHaveBeenCalled();
-    expect(result).toEqual({ title: "Untitled Conversation", updated: true });
+    expect(result).toEqual({ title: MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED, updated: true });
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
       "conv-1",
-      "Untitled Conversation",
+      MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
       AUTO_TITLE_DETERMINISTIC,
     );
   });
 
   test("keeps a background job's deterministic title when the model declines", async () => {
     // The model answered with prose the normalizer rejects, so there is no
-    // generated title. Settling for "Untitled Conversation" would name the
+    // generated title. Settling for the untitled fallback would name the
     // job's work less well than the bootstrap title already does.
     mockGetConversation.mockImplementation(() => ({
       title: "Memory consolidation",
@@ -584,6 +585,9 @@ describe("conversation-title-service", () => {
     expect(content).not.toContain("Generate a very short title");
     expect(content).not.toContain("do NOT respond");
     expect(options.systemPrompt).toContain("Do NOT respond");
+    expect(options.systemPrompt).toContain(
+      "same language as the conversation content",
+    );
   });
 
   test("queueGenerateConversationTitle serializes concurrent calls", async () => {
@@ -661,7 +665,7 @@ describe("conversation-title-service", () => {
     ).find((c) => c[0] === "conv-1");
     expect(firstUpdate).toEqual([
       "conv-1",
-      "Untitled Conversation",
+      MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
       AUTO_TITLE_DETERMINISTIC,
     ]);
     const secondUpdate = (

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -7,8 +7,8 @@
  * app_id from the executor's typed `resolvedAppId` side channel — and that
  * non-hooked tools (app_file_edit, app_file_write) do not trigger side effects.
  *
- * File-change detection for file_write/file_edit is handled by
- * AppSourceWatcher (see app-source-watcher.test.ts).
+ * File-change detection for file_write/file_edit is not hooked: compile with
+ * `app_refresh` or `assistant apps refresh` after a batch of edits.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -50,9 +50,7 @@ mock.module("../tools/browser/browser-screencast.js", () => ({
   registerConversationSender: mock(() => {}),
 }));
 
-// Stub app-store functions used by other modules (e.g. app-source-watcher,
-// conversation-surfaces) so tool-side-effects' hooks can run without touching
-// the real app store during tests.
+// Stub app-store functions used by other modules (e.g. conversation-surfaces)
 mock.module("../apps/app-store.js", () => ({
   getApp: mock(() => null),
   getAppDirPath: mock(() => "/tmp/test-apps/dummy"),

package/src/__tests__/conversation-tool-setup-attribution.test.ts

@@ -354,6 +354,57 @@ describe("createToolExecutor isInteractive threading", () => {
   });
 });
 
+describe("createToolExecutor unattended host-tool gate", () => {
+  test("rejects a direct host tool in a background turn before dispatch", async () => {
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(
+      executor,
+      makeCtx({ currentTurnIsNonInteractive: true, transportInterface: "web" }),
+    );
+
+    const result = await toolFn("host_bash", { command: "pwd" });
+
+    expect(result).toMatchObject({ isError: true });
+    expect(result.content).toContain("requires an interactive user turn");
+    expect(calls).toHaveLength(0);
+  });
+
+  test("rejects a skill-dispatched host tool in a background turn before dispatch", async () => {
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(
+      executor,
+      makeCtx({ currentTurnIsNonInteractive: true, transportInterface: "web" }),
+    );
+
+    const result = await toolFn("skill_execute", {
+      tool: "host_file_read",
+      input: { path: "/tmp/a" },
+      activity: "testing",
+    });
+
+    expect(result).toMatchObject({ isError: true });
+    expect(result.content).toContain("requires an interactive user turn");
+    expect(calls).toHaveLength(0);
+  });
+
+  test("dispatches a host tool during an interactive turn", async () => {
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(
+      executor,
+      makeCtx({
+        currentTurnIsNonInteractive: false,
+        transportInterface: "web",
+      }),
+    );
+
+    const result = await toolFn("host_bash", { command: "pwd" });
+
+    expect(result).toMatchObject({ content: "ok", isError: false });
+    expect(calls).toHaveLength(1);
+    expect(calls[0].name).toBe("host_bash");
+  });
+});
+
 describe("createToolExecutor channel-permission coordinate threading", () => {
   beforeEach(() => {
     mockBindingExternalChatId = null;

package/src/__tests__/credential-record-retire.test.ts

@@ -8,8 +8,10 @@ import type { CredentialRecord } from "@vellumai/service-contracts/credential-rp
 import type { CredentialRecordBackend } from "../security/ces-rpc-record-backend.js";
 import {
   _ensureCesRecordsLoaded,
+  _setHttpRecordBackendForTests,
   _setMetadataPath,
   getCredentialMetadata,
+  listCredentialRecordsLive,
   setCredentialRecordBackend,
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
@@ -35,7 +37,9 @@ function leftoverContents(): string {
   return readFileSync(leftoverPath(), "utf-8");
 }
 
-function makeBackend(): CredentialRecordBackend & {
+function makeBackend(
+  name?: string,
+): CredentialRecordBackend & {
   store: Map<string, CredentialRecord>;
   bulkSetCalls: number;
   listCalls: number;
@@ -46,6 +50,7 @@ function makeBackend(): CredentialRecordBackend & {
     bulkSetCalls: number;
     listCalls: number;
   } = {
+    name,
     store,
     bulkSetCalls: 0,
     listCalls: 0,
@@ -83,6 +88,7 @@ function makeBackend(): CredentialRecordBackend & {
 describe("CES credential record cache", () => {
   beforeEach(() => {
     setCredentialRecordBackend(undefined);
+    _setHttpRecordBackendForTests(null);
     _setMetadataPath(null);
     const leftover = leftoverPath();
     if (existsSync(leftover)) {
@@ -92,6 +98,7 @@ describe("CES credential record cache", () => {
 
   afterEach(() => {
     setCredentialRecordBackend(undefined);
+    _setHttpRecordBackendForTests(null);
     _setMetadataPath(null);
     const leftover = leftoverPath();
     if (existsSync(leftover)) {
@@ -218,6 +225,169 @@ describe("CES credential record cache", () => {
     await _ensureCesRecordsLoaded();
   });
 
+  test("live catalog list returns CES records without the in-process cache", async () => {
+    const backend = makeBackend();
+    const record: CredentialRecord = {
+      credentialId: "cred-live",
+      service: "github",
+      field: "token",
+      allowedTools: ["bash"],
+      allowedDomains: [],
+      createdAt: 1,
+      updatedAt: 2,
+    };
+    backend.store.set(credentialKey("github", "token"), record);
+    setCredentialRecordBackend(backend);
+
+    const live = await listCredentialRecordsLive();
+    expect(live.unreachable).toBe(false);
+    expect(live.records).toHaveLength(1);
+    expect(live.records[0]?.credentialId).toBe("cred-live");
+    expect(getCredentialMetadata("github", "token")).toBeUndefined();
+  });
+
+  test("live catalog list reports unreachable when CES list fails", async () => {
+    const backend = makeBackend();
+    backend.list = async () => null;
+    setCredentialRecordBackend(backend);
+
+    const live = await listCredentialRecordsLive();
+    expect(live.unreachable).toBe(true);
+    expect(live.records).toEqual([]);
+  });
+
+  test("live catalog list reports unreachable when no record backend is attached", async () => {
+    const live = await listCredentialRecordsLive();
+    expect(live.unreachable).toBe(true);
+    expect(live.records).toEqual([]);
+  });
+
+  test("live catalog list fails over to CES HTTP when CES RPC list fails", async () => {
+    const rpc = makeBackend("ces-rpc");
+    rpc.list = async () => null;
+    setCredentialRecordBackend(rpc);
+
+    const http = makeBackend("ces-http");
+    const record: CredentialRecord = {
+      credentialId: "cred-http",
+      service: "github",
+      field: "token",
+      allowedTools: ["bash"],
+      allowedDomains: [],
+      createdAt: 1,
+      updatedAt: 2,
+    };
+    http.store.set(credentialKey("github", "token"), record);
+    _setHttpRecordBackendForTests(http);
+
+    const live = await listCredentialRecordsLive();
+    expect(live.unreachable).toBe(false);
+    expect(live.records).toHaveLength(1);
+    expect(live.records[0]?.credentialId).toBe("cred-http");
+    expect(http.listCalls).toBe(1);
+  });
+
+  test("live catalog list fails over to CES HTTP when CES RPC is unavailable", async () => {
+    const rpc = makeBackend("ces-rpc");
+    rpc.isAvailable = () => false;
+    setCredentialRecordBackend(rpc);
+
+    const http = makeBackend("ces-http");
+    const record: CredentialRecord = {
+      credentialId: "cred-http-down-rpc",
+      service: "github",
+      field: "token",
+      allowedTools: ["bash"],
+      allowedDomains: [],
+      createdAt: 1,
+      updatedAt: 2,
+    };
+    http.store.set(credentialKey("github", "token"), record);
+    _setHttpRecordBackendForTests(http);
+
+    const live = await listCredentialRecordsLive();
+    expect(live.unreachable).toBe(false);
+    expect(live.records[0]?.credentialId).toBe("cred-http-down-rpc");
+  });
+
+  test("live catalog list uses CES HTTP when no record backend is attached", async () => {
+    const http = makeBackend("ces-http");
+    const record: CredentialRecord = {
+      credentialId: "cred-http-only",
+      service: "github",
+      field: "token",
+      allowedTools: ["bash"],
+      allowedDomains: [],
+      createdAt: 1,
+      updatedAt: 2,
+    };
+    http.store.set(credentialKey("github", "token"), record);
+    _setHttpRecordBackendForTests(http);
+
+    const live = await listCredentialRecordsLive();
+    expect(live.unreachable).toBe(false);
+    expect(live.records[0]?.credentialId).toBe("cred-http-only");
+  });
+
+  test("live catalog list does not fail over when CES RPC returns an empty catalog", async () => {
+    const rpc = makeBackend("ces-rpc");
+    setCredentialRecordBackend(rpc);
+
+    const http = makeBackend("ces-http");
+    http.store.set(credentialKey("github", "token"), {
+      credentialId: "cred-http-ignored",
+      service: "github",
+      field: "token",
+      allowedTools: ["bash"],
+      allowedDomains: [],
+      createdAt: 1,
+      updatedAt: 2,
+    });
+    _setHttpRecordBackendForTests(http);
+
+    const live = await listCredentialRecordsLive();
+    expect(live.unreachable).toBe(false);
+    expect(live.records).toEqual([]);
+    expect(http.listCalls).toBe(0);
+  });
+
+  test("live catalog list does not fail over for a non-RPC record backend", async () => {
+    const backend = makeBackend();
+    backend.list = async () => null;
+    setCredentialRecordBackend(backend);
+
+    const http = makeBackend("ces-http");
+    http.store.set(credentialKey("github", "token"), {
+      credentialId: "cred-http-ignored",
+      service: "github",
+      field: "token",
+      allowedTools: ["bash"],
+      allowedDomains: [],
+      createdAt: 1,
+      updatedAt: 2,
+    });
+    _setHttpRecordBackendForTests(http);
+
+    const live = await listCredentialRecordsLive();
+    expect(live.unreachable).toBe(true);
+    expect(live.records).toEqual([]);
+    expect(http.listCalls).toBe(0);
+  });
+
+  test("live catalog list reports unreachable when CES RPC and HTTP both fail", async () => {
+    const rpc = makeBackend("ces-rpc");
+    rpc.list = async () => null;
+    setCredentialRecordBackend(rpc);
+
+    const http = makeBackend("ces-http");
+    http.list = async () => null;
+    _setHttpRecordBackendForTests(http);
+
+    const live = await listCredentialRecordsLive();
+    expect(live.unreachable).toBe(true);
+    expect(live.records).toEqual([]);
+  });
+
   test("upsert write-throughs to CES without updating leftover metadata.json", async () => {
     const leftoverRecord: CredentialRecord = {
       credentialId: "cred-leftover",

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

@@ -1,6 +1,10 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { BadRequestError, ForbiddenError } from "../runtime/routes/errors.js";
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+} from "../runtime/routes/errors.js";
 import type { CredentialMetadata } from "../tools/credentials/metadata-store.js";
 
 // ---------------------------------------------------------------------------
@@ -15,6 +19,8 @@ let disconnectedProviders: string[];
 let credentialIdCounter: number;
 let scrubbedValues: string[];
 let scrubRejects: boolean;
+let liveRecordsUnreachable: boolean;
+let secretGetUnreachable: boolean;
 
 function metaKey(service: string, field: string): string {
   return `${service}:${field}`;
@@ -49,7 +55,7 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: mock(async (key: string) => secureStore.get(key)),
   getSecureKeyResultAsync: mock(async (key: string) => ({
     value: secureStore.get(key),
-    unreachable: false,
+    unreachable: secretGetUnreachable,
   })),
   deleteSecureKeyAsync: mock(async (key: string) =>
     secureStore.delete(key) ? "deleted" : "not-found",
@@ -60,7 +66,10 @@ mock.module("../security/secure-keys.js", () => ({
 
 mock.module("../tools/credentials/metadata-store.js", () => ({
   assertMetadataWritable: () => {},
-  listCredentialMetadata: mock(() => Array.from(metadataStore.values())),
+  listCredentialRecordsLive: mock(async () => ({
+    records: Array.from(metadataStore.values()),
+    unreachable: liveRecordsUnreachable,
+  })),
   getCredentialMetadata: mock((service: string, field: string) =>
     metadataStore.get(metaKey(service, field)),
   ),
@@ -201,6 +210,8 @@ describe("credentials routes", () => {
     credentialIdCounter = 0;
     scrubbedValues = [];
     scrubRejects = false;
+    liveRecordsUnreachable = false;
+    secretGetUnreachable = false;
     _resetRevealSuccessRegistryForTest();
     resetForChatMintRegistryForTest();
     chatCredentialRevealFlag = false;
@@ -799,6 +810,204 @@ describe("credentials routes", () => {
       expect(result.credentials).toHaveLength(1);
       expect(result.credentials[0].service).toBe("github");
     });
+
+    test("fails immediately when the credential vault is unreachable", async () => {
+      liveRecordsUnreachable = true;
+      await setRoute!.handler({
+        body: { service: "vercel", field: "api_token", value: SECRET_VALUE },
+      });
+
+      await expect(listRoute!.handler({ body: {} })).rejects.toThrow(
+        InternalError,
+      );
+      await expect(listRoute!.handler({ body: {} })).rejects.toThrow(
+        /Credential store is unreachable/,
+      );
+    });
+
+    test("fails immediately when a secret fetch reports the vault unreachable", async () => {
+      await setRoute!.handler({
+        body: { service: "vercel", field: "api_token", value: SECRET_VALUE },
+      });
+      secretGetUnreachable = true;
+
+      await expect(listRoute!.handler({ body: {} })).rejects.toThrow(
+        InternalError,
+      );
+    });
+  });
+
+  describe("platform-managed credentials", () => {
+    const PLATFORM_KEY = "vk-platform-provisioned-key";
+    const PLATFORM_BASE_URL = "https://platform.example";
+
+    /**
+     * The platform provisions the pod's own credentials by POSTing them to
+     * `/v1/secrets` as `credential` entries, which land in the same secure
+     * store and metadata table as a user's own credentials.
+     */
+    function seedPlatformCredential(field: string, value: string): string {
+      const key = `vellum:${field}`;
+      secureStore.set(key, value);
+      const now = Date.now();
+      metadataStore.set(key, {
+        credentialId: `cred-${++credentialIdCounter}`,
+        service: "vellum",
+        field,
+        allowedTools: [],
+        allowedDomains: [],
+        createdAt: now,
+        updatedAt: now,
+      });
+      return metadataStore.get(key)!.credentialId;
+    }
+
+    test("the listing omits platform credentials and keeps the user's own", async () => {
+      // GIVEN the platform's provisioned credentials alongside a user's
+      seedPlatformCredential("assistant_api_key", PLATFORM_KEY);
+      seedPlatformCredential("platform_base_url", PLATFORM_BASE_URL);
+      await setRoute!.handler({
+        body: { service: "vercel", field: "api_token", value: SECRET_VALUE },
+      });
+
+      // WHEN the credentials are listed
+      const result = (await listRoute!.handler({ body: {} })) as ListResponse;
+
+      // THEN only the user's credential is a row, and no platform value leaks
+      expect(result.credentials.map((c) => `${c.service}:${c.field}`)).toEqual([
+        "vercel:api_token",
+      ]);
+      expect(JSON.stringify(result)).not.toContain(PLATFORM_KEY);
+    });
+
+    test("reveal refuses the platform API key for every principal", async () => {
+      /**
+       * Both farming paths land on this handler: the assistant's own tool
+       * shell arrives as `local`, a Settings click as `user`.
+       */
+      seedPlatformCredential("assistant_api_key", PLATFORM_KEY);
+
+      for (const principal of ["local", "user", "svc_gateway"]) {
+        await expect(
+          revealRoute!.handler({
+            body: { service: "vellum", field: "assistant_api_key" },
+            headers: { "x-vellum-principal-type": principal },
+          }),
+        ).rejects.toThrow(ForbiddenError);
+      }
+    });
+
+    test("reveal refuses a platform credential looked up by UUID", async () => {
+      const credentialId = seedPlatformCredential(
+        "assistant_api_key",
+        PLATFORM_KEY,
+      );
+
+      await expect(
+        revealRoute!.handler({
+          body: { id: credentialId },
+          headers: { "x-vellum-principal-type": "local" },
+        }),
+      ).rejects.toThrow(/owned by the Vellum platform/);
+    });
+
+    test("inspect refuses platform credentials", async () => {
+      seedPlatformCredential("assistant_api_key", PLATFORM_KEY);
+      seedPlatformCredential("platform_base_url", PLATFORM_BASE_URL);
+
+      for (const field of ["assistant_api_key", "platform_base_url"]) {
+        await expect(
+          inspectRoute!.handler({
+            body: { service: "vellum", field },
+          }),
+        ).rejects.toThrow(ForbiddenError);
+      }
+    });
+
+    test("set refuses platform credentials", async () => {
+      /**
+       * A write is a read by another name: repointing `platform_base_url`
+       * sends the next platform call, bearing the API key, to a host the
+       * writer chose. The platform's own provisioning does not come through
+       * this route; it writes over `POST /v1/secrets`.
+       */
+      for (const field of ["assistant_api_key", "platform_base_url"]) {
+        await expect(
+          setRoute!.handler({
+            body: { service: "vellum", field, value: "https://attacker.test" },
+          }),
+        ).rejects.toThrow(ForbiddenError);
+      }
+
+      expect(secureStore.has("vellum:assistant_api_key")).toBe(false);
+      expect(secureStore.has("vellum:platform_base_url")).toBe(false);
+    });
+
+    test("set does not overwrite an already-provisioned platform credential", async () => {
+      seedPlatformCredential("platform_base_url", PLATFORM_BASE_URL);
+
+      await expect(
+        setRoute!.handler({
+          body: {
+            service: "vellum",
+            field: "platform_base_url",
+            value: "https://attacker.test",
+          },
+        }),
+      ).rejects.toThrow(/owned by the Vellum platform/);
+
+      expect(secureStore.get("vellum:platform_base_url")).toBe(
+        PLATFORM_BASE_URL,
+      );
+    });
+
+    test("delete refuses platform credentials", async () => {
+      seedPlatformCredential("assistant_api_key", PLATFORM_KEY);
+      seedPlatformCredential("platform_base_url", PLATFORM_BASE_URL);
+
+      for (const field of ["assistant_api_key", "platform_base_url"]) {
+        await expect(
+          deleteRoute!.handler({ body: { service: "vellum", field } }),
+        ).rejects.toThrow(ForbiddenError);
+      }
+
+      expect(secureStore.get("vellum:assistant_api_key")).toBe(PLATFORM_KEY);
+      expect(secureStore.get("vellum:platform_base_url")).toBe(
+        PLATFORM_BASE_URL,
+      );
+    });
+
+    test("a user credential is still writable and deletable", async () => {
+      const stored = (await setRoute!.handler({
+        body: { service: "vercel", field: "api_token", value: SECRET_VALUE },
+      })) as SetResponse;
+      expect(stored.service).toBe("vercel");
+      expect(secureStore.get("vercel:api_token")).toBe(SECRET_VALUE);
+
+      const deleted = (await deleteRoute!.handler({
+        body: { service: "vercel", field: "api_token" },
+      })) as DeleteResponse;
+      expect(deleted.field).toBe("api_token");
+      expect(secureStore.has("vercel:api_token")).toBe(false);
+    });
+
+    test("a user credential still inspects and reveals", async () => {
+      seedPlatformCredential("assistant_api_key", PLATFORM_KEY);
+      await setRoute!.handler({
+        body: { service: "vercel", field: "api_token", value: SECRET_VALUE },
+      });
+
+      const inspected = (await inspectRoute!.handler({
+        body: { service: "vercel", field: "api_token" },
+      })) as { scrubbedValue: string };
+      expect(inspected.scrubbedValue).toBe("supe****");
+
+      const revealed = (await revealRoute!.handler({
+        body: { service: "vercel", field: "api_token" },
+        headers: { "x-vellum-principal-type": "user" },
+      })) as { value: string };
+      expect(revealed.value).toBe(SECRET_VALUE);
+    });
   });
 
   describe("platform-managed credentials", () => {

package/src/__tests__/credential-security-invariants.test.ts

@@ -211,7 +211,8 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "persistence/llm-request-log-source-clickhouse.ts", // ClickHouse read source — lazy lookup of clickhouse:url + clickhouse:password + vellum:platform_assistant_id for self-scoped mirror reads
       "persistence/llm-request-log-sink-clickhouse.ts", // ClickHouse write sink — lazy lookup of clickhouse:url + clickhouse:password + vellum:platform_assistant_id for self-scoped log writes
       "persistence/compaction-log-store-clickhouse.ts", // ClickHouse compaction log writer — lazy lookup of clickhouse:url + clickhouse:password + vellum:platform_assistant_id for self-scoped event writes
-      "config/platform-rehydration.ts", // startup rehydration of platform base URL + IDs from credential store (daemon and schedule worker)
+      "config/platform-identity.ts", // in-memory platform ids, then vault copies of vellum:platform_*
+      "config/platform-rehydration.ts", // startup rehydration of platform base URL from the credential store and ids from platform validate
       "workspace/migrations/006-services-config.ts", // services config migration reads provider API keys
       "workspace/migrations/018-rekey-compound-credential-keys.ts", // re-key compound credential storage keys
       "daemon/conversation-process.ts", // masked provider key display

package/src/__tests__/cu-unified-flow.test.ts

@@ -224,7 +224,10 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("no desktop client connected");
+      expect(result.content).toContain(
+        "The Vellum desktop app is needed to view or control your screen",
+      );
+      expect(result.content).toContain("https://www.vellum.ai/downloads");
     });
 
     test("returns error when proxy exists but client not connected", async () => {
@@ -237,7 +240,10 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("no desktop client connected");
+      expect(result.content).toContain(
+        "The Vellum desktop app is needed to view or control your screen",
+      );
+      expect(result.content).toContain("https://www.vellum.ai/downloads");
       proxyObj.dispose();
     });
 

package/src/__tests__/drain-kick-guard.test.ts

@@ -79,8 +79,6 @@ function makeFakeConversation(
     getTurnInterfaceContext: () => null,
     setTurnInterfaceContext: () => {},
     setTransportHints: () => {},
-    setTrustContext: () => {},
-    ensureActorScopedHistory: async () => {},
     emitActivityState: () => {
       if (activityFailures > 0) {
         activityFailures -= 1;