@vellumai/assistant 0.12.1-staging.1 → 0.12.1

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

@@ -104,7 +104,6 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   publishConversationTitleChanged: mockPublishConversationTitleChanged,
 }));
 
-import { MESSAGE_KEYS } from "../i18n/index.js";
 import {
   AUTO_TITLE_DETERMINISTIC,
   AUTO_TITLE_LLM,
@@ -310,10 +309,10 @@ describe("conversation-title-service", () => {
       userMessage: "so about that t-shirt...",
     });
 
-    expect(result.title).toBe(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED);
+    expect(result.title).toBe("Untitled Conversation");
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
       "conv-1",
-      MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
+      "Untitled Conversation",
       AUTO_TITLE_DETERMINISTIC,
     );
   });
@@ -334,7 +333,7 @@ describe("conversation-title-service", () => {
       userMessage: "something",
     });
 
-    expect(result.title).toBe(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED);
+    expect(result.title).toBe("Untitled Conversation");
   });
 
   // The core bug this PR fixes: weak title models emit their reasoning or
@@ -362,10 +361,10 @@ describe("conversation-title-service", () => {
       userMessage: "hey baby",
     });
 
-    expect(result.title).toBe(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED);
+    expect(result.title).toBe("Untitled Conversation");
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
       "conv-1",
-      MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
+      "Untitled Conversation",
       AUTO_TITLE_DETERMINISTIC,
     );
   });
@@ -424,7 +423,7 @@ describe("conversation-title-service", () => {
       userMessage: "x",
     });
 
-    expect(result.title).toBe(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED);
+    expect(result.title).toBe("Untitled Conversation");
   });
 
   test("regeneration skips LLM call when recent messages have no extractable text", async () => {
@@ -516,17 +515,17 @@ describe("conversation-title-service", () => {
     });
 
     expect(provider.sendMessage).not.toHaveBeenCalled();
-    expect(result).toEqual({ title: MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED, updated: true });
+    expect(result).toEqual({ title: "Untitled Conversation", updated: true });
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
       "conv-1",
-      MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
+      "Untitled Conversation",
       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 the untitled fallback would name the
+    // generated title. Settling for "Untitled Conversation" would name the
     // job's work less well than the bootstrap title already does.
     mockGetConversation.mockImplementation(() => ({
       title: "Memory consolidation",
@@ -585,9 +584,6 @@ 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 () => {
@@ -665,7 +661,7 @@ describe("conversation-title-service", () => {
     ).find((c) => c[0] === "conv-1");
     expect(firstUpdate).toEqual([
       "conv-1",
-      MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
+      "Untitled Conversation",
       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 not hooked: compile with
- * `app_refresh` or `assistant apps refresh` after a batch of edits.
+ * File-change detection for file_write/file_edit is handled by
+ * AppSourceWatcher (see app-source-watcher.test.ts).
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -50,7 +50,9 @@ mock.module("../tools/browser/browser-screencast.js", () => ({
   registerConversationSender: mock(() => {}),
 }));
 
-// Stub app-store functions used by other modules (e.g. conversation-surfaces)
+// 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.
 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,57 +354,6 @@ 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,10 +8,8 @@ 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";
@@ -37,9 +35,7 @@ function leftoverContents(): string {
   return readFileSync(leftoverPath(), "utf-8");
 }
 
-function makeBackend(
-  name?: string,
-): CredentialRecordBackend & {
+function makeBackend(): CredentialRecordBackend & {
   store: Map<string, CredentialRecord>;
   bulkSetCalls: number;
   listCalls: number;
@@ -50,7 +46,6 @@ function makeBackend(
     bulkSetCalls: number;
     listCalls: number;
   } = {
-    name,
     store,
     bulkSetCalls: 0,
     listCalls: 0,
@@ -88,7 +83,6 @@ function makeBackend(
 describe("CES credential record cache", () => {
   beforeEach(() => {
     setCredentialRecordBackend(undefined);
-    _setHttpRecordBackendForTests(null);
     _setMetadataPath(null);
     const leftover = leftoverPath();
     if (existsSync(leftover)) {
@@ -98,7 +92,6 @@ describe("CES credential record cache", () => {
 
   afterEach(() => {
     setCredentialRecordBackend(undefined);
-    _setHttpRecordBackendForTests(null);
     _setMetadataPath(null);
     const leftover = leftoverPath();
     if (existsSync(leftover)) {
@@ -225,169 +218,6 @@ 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,10 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-} from "../runtime/routes/errors.js";
+import { BadRequestError, ForbiddenError } from "../runtime/routes/errors.js";
 import type { CredentialMetadata } from "../tools/credentials/metadata-store.js";
 
 // ---------------------------------------------------------------------------
@@ -19,8 +15,6 @@ 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}`;
@@ -55,7 +49,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: secretGetUnreachable,
+    unreachable: false,
   })),
   deleteSecureKeyAsync: mock(async (key: string) =>
     secureStore.delete(key) ? "deleted" : "not-found",
@@ -66,10 +60,7 @@ mock.module("../security/secure-keys.js", () => ({
 
 mock.module("../tools/credentials/metadata-store.js", () => ({
   assertMetadataWritable: () => {},
-  listCredentialRecordsLive: mock(async () => ({
-    records: Array.from(metadataStore.values()),
-    unreachable: liveRecordsUnreachable,
-  })),
+  listCredentialMetadata: mock(() => Array.from(metadataStore.values())),
   getCredentialMetadata: mock((service: string, field: string) =>
     metadataStore.get(metaKey(service, field)),
   ),
@@ -210,8 +201,6 @@ describe("credentials routes", () => {
     credentialIdCounter = 0;
     scrubbedValues = [];
     scrubRejects = false;
-    liveRecordsUnreachable = false;
-    secretGetUnreachable = false;
     _resetRevealSuccessRegistryForTest();
     resetForChatMintRegistryForTest();
     chatCredentialRevealFlag = false;
@@ -810,204 +799,6 @@ 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,8 +211,7 @@ 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-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
+      "config/platform-rehydration.ts", // startup rehydration of platform base URL + IDs from credential store (daemon and schedule worker)
       "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,10 +224,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       );
 
       expect(result.isError).toBe(true);
-      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");
+      expect(result.content).toContain("no desktop client connected");
     });
 
     test("returns error when proxy exists but client not connected", async () => {
@@ -240,10 +237,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      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");
+      expect(result.content).toContain("no desktop client connected");
       proxyObj.dispose();
     });
 

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

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