@vellumai/assistant 0.8.4 → 0.8.5

package/src/__tests__/conversation-skill-tools.test.ts

@@ -104,15 +104,12 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       description: entry.description,
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
+      executionTarget: "sandbox" as const,
       origin: "skill" as const,
       ownerSkillId: skillId,
       ownerSkillVersionHash: versionHash,
       ownerSkillBundled: bundled ?? undefined,
-      getDefinition: () => ({
-        name: entry.name,
-        description: entry.description,
-        input_schema: entry.input_schema as object,
-      }),
+      input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     }));
   },

package/src/__tests__/conversation-store.test.ts

@@ -334,7 +334,7 @@ describe("attachment orphan cleanup", () => {
     const stored = uploadAttachment("doc.pdf", "application/pdf", "JVBER");
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
-    clearAll();
+    await clearAll();
 
     const raw = (
       getDb() as unknown as {

package/src/__tests__/conversation-sync-tags.test.ts

@@ -73,7 +73,16 @@ describe("conversation sync tags", () => {
     resetDb();
   });
 
-  test("rename emits legacy title/list events and conversation metadata sync tags", async () => {
+  test("rename emits the typed title event and a metadata-only sync tag (no list umbrella)", async () => {
+    // Rename is a content-only change: the row stays in place, the list
+    // shape is unchanged, only the title field flips. Web patches the
+    // single cached row via the typed `conversation_title_updated` event
+    // (`patchConversation` in `metadata-handlers.ts`) and the per-
+    // conversation `sync_changed` metadata tag is included as a belt-and-
+    // suspenders signal for sibling-tab consumers that missed the typed
+    // event. The legacy `conversation_list_invalidated` broadcast is
+    // scoped to `targetInterfaceId: "macos"` and therefore not visible to
+    // this process-type subscriber.
     const conversation = createConversation("Old title");
     const route = findRoute(
       CONVERSATION_MANAGEMENT_ROUTES,
@@ -85,23 +94,39 @@ describe("conversation sync tags", () => {
         pathParams: { id: conversation.id },
         body: { name: "New title" },
       });
-    }, 3);
+    }, 2);
 
     expect(received.map((event) => event.message.type)).toEqual([
       "conversation_title_updated",
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[2]!.message).toEqual({
+    expect(received[1]!.message).toEqual({
       type: "sync_changed",
-      tags: [
-        SYNC_TAGS.conversationsList,
-        conversationMetadataSyncTag(conversation.id),
-      ],
+      tags: [conversationMetadataSyncTag(conversation.id)],
     });
+    // Defense-in-depth: the umbrella `conversationsList` tag would force
+    // web to redrain the full paginated list — we deliberately omit it
+    // for content-only reasons.
+    expect(
+      (received[1]!.message as { tags: string[] }).tags,
+    ).not.toContain(SYNC_TAGS.conversationsList);
+    // The legacy invalidation broadcast is macOS-scoped and must not
+    // reach this process-type subscriber.
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("create emits legacy list invalidation and list/metadata sync tags", async () => {
+  test("create emits a sync_changed with the conversationsList umbrella tag", async () => {
+    // Create is shape-changing — a row is added to the paginated list,
+    // so web must redrain the list (cannot patch a row it has never
+    // fetched). The umbrella `conversationsList` tag is the signal for
+    // that redrain. Per-conversation metadata is included so any future
+    // single-row consumer can patch the freshly added row in place
+    // without an extra GET. The legacy macOS-only invalidation broadcast
+    // is not visible to process subscribers.
     const route = findRoute(
       CONVERSATION_MANAGEMENT_ROUTES,
       "createConversation",
@@ -113,23 +138,33 @@ describe("conversation sync tags", () => {
         body: { conversationKey: "sync-create-test" },
       })) as { id: string };
       conversationId = result.id;
-    }, 2);
+    }, 1);
 
     expect(conversationId).toBeDefined();
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
       tags: [
         SYNC_TAGS.conversationsList,
         conversationMetadataSyncTag(conversationId!),
       ],
     });
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("reorder emits list invalidation and metadata sync tags for touched conversations", async () => {
+  test("reorder emits a sync_changed with the umbrella tag and per-conversation metadata tags", async () => {
+    // Reorder changes the row position in the paginated list — also
+    // shape-changing. The umbrella `conversationsList` tag forces a
+    // redrain so the new ordering shows. Per-conversation metadata tags
+    // are bundled in to give any single-row consumer a hint that the
+    // touched conversations' positions have moved (currently web
+    // consumes only the umbrella tag; metadata tags are forward-compat).
     const first = createConversation("First");
     const second = createConversation("Second");
     const route = findRoute(
@@ -146,13 +181,12 @@ describe("conversation sync tags", () => {
           ],
         },
       });
-    }, 2);
+    }, 1);
 
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
       tags: [
         SYNC_TAGS.conversationsList,
@@ -160,9 +194,28 @@ describe("conversation sync tags", () => {
         conversationMetadataSyncTag(second.id),
       ],
     });
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("record seen emits list invalidation and metadata sync tags for the touched conversation", async () => {
+  test("record seen emits only a per-conversation metadata sync tag (no list umbrella)", async () => {
+    // Seen state is per-conversation attention metadata, not list-
+    // shaped. The old behavior emitted `sync_changed` carrying the
+    // umbrella `conversationsList` tag, which forced every subscribed
+    // web client to redrain the full paginated sidebar on every
+    // conversation switch that landed on an unseen conversation (~14
+    // requests at ~300 conversations). The current behavior emits a
+    // single `sync_changed` with only the per-conversation
+    // `conversation:<id>:metadata` tag, which web consumes by GET-and-
+    // patching the single cached row via `refreshConversationRow`.
+    //
+    // The legacy `conversation_list_invalidated` broadcast is still
+    // emitted for macOS (which has no per-row patcher) but is scoped
+    // to `targetInterfaceId: "macos"` and therefore not visible to
+    // this process-type subscriber.
     const conversation = createConversation("Attention");
     projectAssistantMessage({
       conversationId: conversation.id,
@@ -181,22 +234,32 @@ describe("conversation sync tags", () => {
           source: "test",
         },
       });
-    }, 2);
+    }, 1);
 
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
-      tags: [
-        SYNC_TAGS.conversationsList,
-        conversationMetadataSyncTag(conversation.id),
-      ],
+      tags: [conversationMetadataSyncTag(conversation.id)],
     });
+    // Defense-in-depth: the umbrella `conversationsList` tag would
+    // force the very paginated-list drain this redesign exists to
+    // avoid. It must not appear here.
+    expect(
+      (received[0]!.message as { tags: string[] }).tags,
+    ).not.toContain(SYNC_TAGS.conversationsList);
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("mark unread emits list invalidation and metadata sync tags for the touched conversation", async () => {
+  test("mark unread emits only a per-conversation metadata sync tag (no list umbrella)", async () => {
+    // Symmetric with `record seen`: mark-unread flips the per-conversation
+    // hasUnseen flag back to true. Same per-conversation sync tag, same
+    // absence of list-level fan-out.
     const conversation = createConversation("Attention");
     projectAssistantMessage({
       conversationId: conversation.id,
@@ -218,18 +281,22 @@ describe("conversation sync tags", () => {
           conversationId: conversation.id,
         },
       });
-    }, 2);
+    }, 1);
 
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
-      tags: [
-        SYNC_TAGS.conversationsList,
-        conversationMetadataSyncTag(conversation.id),
-      ],
+      tags: [conversationMetadataSyncTag(conversation.id)],
     });
+    expect(
+      (received[0]!.message as { tags: string[] }).tags,
+    ).not.toContain(SYNC_TAGS.conversationsList);
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 });

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -87,6 +87,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -116,6 +116,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,
@@ -144,7 +145,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   setLastNotifiedInferenceProfile: () => {},
   getConversationOverrideProfileFromRow: () => undefined,
   updateMessageMetadata: () => {},
-  clearStrippedInjectionMetadataForConversation: () => {},
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -114,6 +114,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,
@@ -141,7 +142,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   setLastNotifiedInferenceProfile: () => {},
   getConversationOverrideProfileFromRow: () => undefined,
   updateMessageMetadata: () => {},
-  clearStrippedInjectionMetadataForConversation: () => {},
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/credential-execution-feature-gates.test.ts

@@ -159,7 +159,7 @@ describe("CES flags respect explicit false overrides", () => {
 // ---------------------------------------------------------------------------
 
 describe("CES flags do not affect unrelated flags", () => {
-  test("enabling all CES flags does not change browser flag (defaultEnabled: true)", () => {
+  test("enabling all CES flags does not change declared default-enabled flags", () => {
     const overrides: Record<string, boolean> = {};
     for (const key of ALL_CES_FLAG_KEYS) {
       overrides[key] = true;
@@ -167,11 +167,13 @@ describe("CES flags do not affect unrelated flags", () => {
     _setOverridesForTesting(overrides);
     const config = makeConfig();
 
-    // browser defaults to true in the registry and should stay true
-    expect(isAssistantFeatureFlagEnabled("browser", config)).toBe(true);
+    // account-deletion defaults to true in the registry and should stay true.
+    expect(isAssistantFeatureFlagEnabled("account-deletion", config)).toBe(
+      true,
+    );
   });
 
-  test("enabling all CES flags does not change unrelated default-open flags", () => {
+  test("enabling all CES flags does not change unrelated fail-closed flags", () => {
     const overrides: Record<string, boolean> = {};
     for (const key of ALL_CES_FLAG_KEYS) {
       overrides[key] = true;
@@ -179,9 +181,9 @@ describe("CES flags do not affect unrelated flags", () => {
     _setOverridesForTesting(overrides);
     const config = makeConfig();
 
-    // Unknown flags default open unless explicitly overridden.
+    // Unknown flags fail closed unless explicitly overridden.
     expect(
-      isAssistantFeatureFlagEnabled("unrelated-default-open", config),
-    ).toBe(true);
+      isAssistantFeatureFlagEnabled("unrelated-default-closed", config),
+    ).toBe(false);
   });
 });

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

@@ -13,7 +13,7 @@ import type { Tool } from "../tools/types.js";
 
 describe("CES tool schema shapes", () => {
   test("make_authenticated_request has correct name and required fields", () => {
-    const def = makeAuthenticatedRequestTool.getDefinition();
+    const def = makeAuthenticatedRequestTool;
     expect(def.name).toBe("make_authenticated_request");
     const schema = def.input_schema as {
       required: string[];
@@ -28,7 +28,7 @@ describe("CES tool schema shapes", () => {
   });
 
   test("run_authenticated_command has correct name and required fields", () => {
-    const def = runAuthenticatedCommandTool.getDefinition();
+    const def = runAuthenticatedCommandTool;
     expect(def.name).toBe("run_authenticated_command");
     const schema = def.input_schema as {
       required: string[];
@@ -43,7 +43,7 @@ describe("CES tool schema shapes", () => {
   });
 
   test("manage_secure_command_tool has correct name and required fields", () => {
-    const def = manageSecureCommandTool.getDefinition();
+    const def = manageSecureCommandTool;
     expect(def.name).toBe("manage_secure_command_tool");
     const schema = def.input_schema as {
       required: string[];
@@ -95,7 +95,7 @@ describe("CES tool manifest registration", () => {
 
   test("no CES tool exposes raw secret values in its schema", () => {
     for (const tool of cesTools) {
-      const def = tool.getDefinition();
+      const def = tool;
       const schema = def.input_schema as {
         properties: Record<string, { type?: string; description?: string }>;
       };
@@ -114,7 +114,7 @@ describe("CES tool manifest registration", () => {
 
 describe("secure tool installation is separate from credential grants", () => {
   test("manage_secure_command_tool accepts only bundle metadata, not raw bytes", () => {
-    const def = manageSecureCommandTool.getDefinition();
+    const def = manageSecureCommandTool;
     const schema = def.input_schema as {
       properties: Record<string, unknown>;
     };
@@ -144,7 +144,7 @@ describe("secure tool installation is separate from credential grants", () => {
   });
 
   test("manage_secure_command_tool action enum does not include grant actions", () => {
-    const def = manageSecureCommandTool.getDefinition();
+    const def = manageSecureCommandTool;
     const schema = def.input_schema as {
       properties: {
         action: { enum?: string[] };

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

@@ -171,6 +171,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/handlers/config-telegram.ts", // Telegram bot token management
       "daemon/handlers/config-vercel.ts", // Vercel API token management
       "runtime/routes/integrations/twilio.ts", // Twilio credential management (HTTP control-plane)
+      "acp/prepare-agent-env.ts", // shared helper injects CLAUDE_CODE_OAUTH_TOKEN into claude-agent-acp subprocess env (called by route + skill tool spawn paths)
       "security/token-manager.ts", // OAuth token refresh flow
       "tools/network/script-proxy/session-manager.ts", // proxy credential injection at runtime
       "calls/call-domain.ts", // caller identity resolution (user phone number lookup)

package/src/__tests__/credential-vault-unit.test.ts

@@ -1267,7 +1267,7 @@ describe("credential_store tool — tool definition", () => {
   });
 
   test("getDefinition returns valid schema with required action", () => {
-    const def = credentialStoreTool.getDefinition();
+    const def = credentialStoreTool;
     expect(def.name).toBe("credential_store");
     const schema = def.input_schema as Record<string, unknown>;
     expect(schema.type).toBe("object");
@@ -1277,7 +1277,7 @@ describe("credential_store tool — tool definition", () => {
   });
 
   test("getDefinition includes injection_templates schema", () => {
-    const def = credentialStoreTool.getDefinition();
+    const def = credentialStoreTool;
     const schemaProps = (def.input_schema as Record<string, unknown>)
       .properties as Record<string, Record<string, unknown>>;
     const templates = schemaProps.injection_templates as Record<

package/src/__tests__/dynamic-page-surface.test.ts

@@ -41,7 +41,7 @@ describe("DynamicPageSurfaceData shape", () => {
 
 describe("Tool definition includes dynamic_page", () => {
   test("input_schema surface_type enum includes dynamic_page", () => {
-    const definition = uiShowTool.getDefinition();
+    const definition = uiShowTool;
     const surfaceTypeEnum = (
       definition.input_schema as {
         properties: { surface_type: { enum: string[] } };
@@ -52,7 +52,7 @@ describe("Tool definition includes dynamic_page", () => {
   });
 
   test("description mentions dynamic_page", () => {
-    const definition = uiShowTool.getDefinition();
+    const definition = uiShowTool;
     expect(definition.description).toContain("dynamic_page");
   });
 });

package/src/__tests__/email-html-renderer.test.ts

@@ -49,6 +49,18 @@ describe("markdownToEmailHtml", () => {
     expect(result).toBe("");
   });
 
+  test("converts literal backslash-n after normalization", () => {
+    // LLMs often produce literal "\n" instead of real newlines.
+    // handleEmailSend normalizes them before calling markdownToEmailHtml.
+    const raw = "Hi Noa,\\n\\nTesting line breaks!\\n\\nThanks!";
+    const normalized = raw.replace(/\\n/g, "\n");
+    const result = markdownToEmailHtml(normalized);
+    expect(result).toContain("<p>Hi Noa,</p>");
+    expect(result).toContain("<p>Testing line breaks!</p>");
+    expect(result).toContain("<p>Thanks!</p>");
+    expect(result).not.toContain("\\n");
+  });
+
   test("handles multiline markdown email", () => {
     const md = `Hi there,