@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/registry.test.ts

@@ -9,6 +9,7 @@ import {
   getSkillRefCount,
   getSkillToolNames,
   getTool,
+  getToolOwner,
   initializeTools,
   registerSkillTools,
   registerTool,
@@ -40,12 +41,11 @@ function makeFakeTool(name: string): Tool {
   };
 }
 
-function makeSkillTool(name: string, ownerSkillId: string): Tool {
-  return {
-    ...makeFakeTool(name),
-    origin: "skill" as const,
-    ownerSkillId,
-  };
+function makeSkillTool(name: string): Tool {
+  // Ownership is recorded by the registry (via `registerSkillTools`), not by
+  // any field on the Tool itself. This helper is now a thin alias for
+  // makeFakeTool; the wrapper is kept so call sites stay readable.
+  return makeFakeTool(name);
 }
 
 describe("tool registry host tools", () => {
@@ -195,11 +195,11 @@ describe("baseline characterization: core app tool surface", () => {
 
     const tool = getTool("app_open");
     expect(tool).toBeDefined();
-    expect(tool?.executionMode).toBe("proxy");
 
-    // Proxy tools are excluded from getAllToolDefinitions() by design
+    // app_open is core-owned (no skill owner) so it flows through
+    // `getAllToolDefinitions()` like any other core tool.
     const definitionNames = getAllToolDefinitions().map((def) => def.name);
-    expect(definitionNames).not.toContain("app_open");
+    expect(definitionNames).toContain("app_open");
   });
 
   test("bundled app-builder skill has TOOLS.json manifest", async () => {
@@ -217,33 +217,27 @@ describe("baseline characterization: core app tool surface", () => {
   });
 });
 
-describe("tool origin metadata", () => {
+describe("tool ownership metadata", () => {
   beforeEach(() => {
     __resetRegistryForTesting();
   });
 
-  test("registers a skill-origin tool and preserves metadata via getTool()", () => {
-    const skillTool: Tool = {
-      ...makeFakeTool("test-skill-origin-tool"),
-      origin: "skill",
-      ownerSkillId: "test-skill",
-    };
-
-    registerTool(skillTool);
+  test("registerTool does not record ownership (bare-install path)", () => {
+    registerTool(makeFakeTool("test-bare-tool"));
 
-    const retrieved = getTool("test-skill-origin-tool");
-    expect(retrieved).toBeDefined();
-    expect(retrieved?.origin).toBe("skill");
-    expect(retrieved?.ownerSkillId).toBe("test-skill");
+    expect(getTool("test-bare-tool")).toBeDefined();
+    // `registerTool` is the bare-install path used by tests + core
+    // bootstraps; it does not record ownership. Tools that need an owner
+    // must go through `registerSkillTools(skillId, ...)` or its sibling
+    // entry points so the registry populates `ownersByName`.
+    expect(getToolOwner("test-bare-tool")).toBeUndefined();
   });
 
-  test("core tools default to no origin metadata (undefined)", async () => {
+  test("core tools have no owner", async () => {
     await initializeTools();
 
-    const coreTool = getTool("host_file_read");
-    expect(coreTool).toBeDefined();
-    expect(coreTool?.origin).toBeUndefined();
-    expect(coreTool?.ownerSkillId).toBeUndefined();
+    expect(getTool("host_file_read")).toBeDefined();
+    expect(getToolOwner("host_file_read")).toBeUndefined();
   });
 });
 
@@ -252,66 +246,67 @@ describe("dynamic skill tool registry", () => {
     __resetRegistryForTesting();
   });
 
-  test("registers skill tools and retrieves them", () => {
-    const tools = [
-      makeSkillTool("sk_tool_a", "my-skill"),
-      makeSkillTool("sk_tool_b", "my-skill"),
-    ];
-    registerSkillTools(tools);
+  test("registers skill tools and retrieves them with owner via getToolOwner", () => {
+    registerSkillTools("my-skill", [
+      makeSkillTool("sk_tool_a"),
+      makeSkillTool("sk_tool_b"),
+    ]);
 
     expect(getTool("sk_tool_a")).toBeDefined();
-    expect(getTool("sk_tool_a")?.origin).toBe("skill");
-    expect(getTool("sk_tool_a")?.ownerSkillId).toBe("my-skill");
+    expect(getToolOwner("sk_tool_a")).toEqual({
+      kind: "skill",
+      id: "my-skill",
+    });
 
     expect(getTool("sk_tool_b")).toBeDefined();
-    expect(getTool("sk_tool_b")?.origin).toBe("skill");
+    expect(getToolOwner("sk_tool_b")).toEqual({
+      kind: "skill",
+      id: "my-skill",
+    });
   });
 
   test("skips skill tool that collides with a core tool without throwing", async () => {
     await initializeTools();
 
     // host_file_read is a core tool registered during init
-    const colliding = makeSkillTool("host_file_read", "rogue-skill");
-    const accepted = registerSkillTools([colliding]);
+    const accepted = registerSkillTools("rogue-skill", [
+      makeSkillTool("host_file_read"),
+    ]);
 
     // The colliding tool should be silently skipped
     expect(accepted).toHaveLength(0);
     // The core tool should still be in place (not overwritten)
-    const retrieved = getTool("host_file_read");
-    expect(retrieved?.origin).toBeUndefined(); // core tools have no origin
+    expect(getTool("host_file_read")).toBeDefined();
+    expect(getToolOwner("host_file_read")).toBeUndefined();
   });
 
   test("allows replacement within the same owning skill", () => {
-    const original = makeSkillTool("sk_replaceable", "owner-skill");
-    registerSkillTools([original]);
+    registerSkillTools("owner-skill", [makeSkillTool("sk_replaceable")]);
 
     const replacement: Tool = {
-      ...makeSkillTool("sk_replaceable", "owner-skill"),
+      ...makeSkillTool("sk_replaceable"),
       description: "Updated description",
     };
     // Should not throw
-    registerSkillTools([replacement]);
+    registerSkillTools("owner-skill", [replacement]);
 
     const retrieved = getTool("sk_replaceable");
     expect(retrieved?.description).toBe("Updated description");
   });
 
   test("rejects replacement from a different owning skill", () => {
-    const original = makeSkillTool("sk_owned", "skill-alpha");
-    registerSkillTools([original]);
+    registerSkillTools("skill-alpha", [makeSkillTool("sk_owned")]);
 
-    const intruder = makeSkillTool("sk_owned", "skill-beta");
-    expect(() => registerSkillTools([intruder])).toThrow(
-      'already registered by skill "skill-alpha"',
-    );
+    expect(() =>
+      registerSkillTools("skill-beta", [makeSkillTool("sk_owned")]),
+    ).toThrow('already registered by skill "skill-alpha"');
   });
 
   test("unregisterSkillTools removes all tools for a skill", () => {
-    const tools = [
-      makeSkillTool("sk_rm_1", "removable-skill"),
-      makeSkillTool("sk_rm_2", "removable-skill"),
-    ];
-    registerSkillTools(tools);
+    registerSkillTools("removable-skill", [
+      makeSkillTool("sk_rm_1"),
+      makeSkillTool("sk_rm_2"),
+    ]);
     expect(getTool("sk_rm_1")).toBeDefined();
     expect(getTool("sk_rm_2")).toBeDefined();
 
@@ -319,24 +314,32 @@ describe("dynamic skill tool registry", () => {
 
     expect(getTool("sk_rm_1")).toBeUndefined();
     expect(getTool("sk_rm_2")).toBeUndefined();
+    // Ownership map is cleared in lockstep with the tools map.
+    expect(getToolOwner("sk_rm_1")).toBeUndefined();
+    expect(getToolOwner("sk_rm_2")).toBeUndefined();
   });
 
   test("unregisterSkillTools does not affect tools from other skills", () => {
-    registerSkillTools([makeSkillTool("sk_keep", "keep-skill")]);
-    registerSkillTools([makeSkillTool("sk_remove", "nuke-skill")]);
+    registerSkillTools("keep-skill", [makeSkillTool("sk_keep")]);
+    registerSkillTools("nuke-skill", [makeSkillTool("sk_remove")]);
 
     unregisterSkillTools("nuke-skill");
 
     expect(getTool("sk_keep")).toBeDefined();
     expect(getTool("sk_remove")).toBeUndefined();
+    expect(getToolOwner("sk_keep")).toEqual({
+      kind: "skill",
+      id: "keep-skill",
+    });
+    expect(getToolOwner("sk_remove")).toBeUndefined();
   });
 
   test("getSkillToolNames returns only skill tool names", async () => {
     await initializeTools();
 
-    registerSkillTools([
-      makeSkillTool("sk_names_a", "names-skill"),
-      makeSkillTool("sk_names_b", "names-skill"),
+    registerSkillTools("names-skill", [
+      makeSkillTool("sk_names_a"),
+      makeSkillTool("sk_names_b"),
     ]);
 
     const skillNames = getSkillToolNames();
@@ -350,19 +353,22 @@ describe("dynamic skill tool registry", () => {
   test("registerSkillTools skips core-colliding tools but registers the rest", async () => {
     await initializeTools();
 
-    const tools = [
-      makeSkillTool("sk_atomic_ok", "atomic-skill"),
-      makeSkillTool("host_file_read", "atomic-skill"), // collides with core
-    ];
-
-    const accepted = registerSkillTools(tools);
+    const accepted = registerSkillTools("atomic-skill", [
+      makeSkillTool("sk_atomic_ok"),
+      makeSkillTool("host_file_read"), // collides with core
+    ]);
     // Only the non-colliding tool should be accepted
     expect(accepted).toHaveLength(1);
     expect(accepted[0].name).toBe("sk_atomic_ok");
-    // The non-colliding tool should be registered
+    // The non-colliding tool should be registered with the correct owner
     expect(getTool("sk_atomic_ok")).toBeDefined();
-    // The core tool should be untouched
-    expect(getTool("host_file_read")?.origin).toBeUndefined();
+    expect(getToolOwner("sk_atomic_ok")).toEqual({
+      kind: "skill",
+      id: "atomic-skill",
+    });
+    // The core tool should be untouched (no owner recorded)
+    expect(getTool("host_file_read")).toBeDefined();
+    expect(getToolOwner("host_file_read")).toBeUndefined();
   });
 });
 
@@ -372,17 +378,17 @@ describe("skill tool reference counting", () => {
   });
 
   test("ref count increments on each registerSkillTools call", () => {
-    registerSkillTools([makeSkillTool("rc_a", "rc-skill")]);
+    registerSkillTools("rc-skill", [makeSkillTool("rc_a")]);
     expect(getSkillRefCount("rc-skill")).toBe(1);
 
-    // Second session registers the same skill (same ownerSkillId allows replacement)
-    registerSkillTools([makeSkillTool("rc_a", "rc-skill")]);
+    // Second session registers the same skill (same owner id allows replacement)
+    registerSkillTools("rc-skill", [makeSkillTool("rc_a")]);
     expect(getSkillRefCount("rc-skill")).toBe(2);
   });
 
   test("unregister decrements ref count but keeps tools when count > 0", () => {
-    registerSkillTools([makeSkillTool("rc_keep", "rc-multi")]);
-    registerSkillTools([makeSkillTool("rc_keep", "rc-multi")]);
+    registerSkillTools("rc-multi", [makeSkillTool("rc_keep")]);
+    registerSkillTools("rc-multi", [makeSkillTool("rc_keep")]);
     expect(getSkillRefCount("rc-multi")).toBe(2);
 
     unregisterSkillTools("rc-multi");
@@ -392,8 +398,8 @@ describe("skill tool reference counting", () => {
   });
 
   test("tools are removed only when last reference is unregistered", () => {
-    registerSkillTools([makeSkillTool("rc_last", "rc-final")]);
-    registerSkillTools([makeSkillTool("rc_last", "rc-final")]);
+    registerSkillTools("rc-final", [makeSkillTool("rc_last")]);
+    registerSkillTools("rc-final", [makeSkillTool("rc_last")]);
 
     unregisterSkillTools("rc-final");
     expect(getTool("rc_last")).toBeDefined();

package/src/__tests__/relay-server.test.ts

@@ -225,7 +225,7 @@ import {
   createVerificationSession,
 } from "../memory/channel-verification-sessions.js";
 import { addMessage, getMessages } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { createInvite } from "../memory/invite-store.js";
 import { resetTestTables } from "../memory/raw-query.js";
@@ -235,12 +235,13 @@ import {
   getGuardianBinding,
 } from "../runtime/channel-verification-service.js";
 import { generateVoiceCode, hashVoiceCode } from "../util/voice-code.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 initializeDb();
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 // ── Mock WebSocket factory ──────────────────────────────────────────
@@ -423,16 +424,15 @@ describe("relay-server", () => {
             includeDefaultFallback: false,
           },
           isProcessing: () => false,
-          persistUserMessage: async (
-            content: string,
-            _attachments: unknown[],
-            requestId?: string,
-          ) => {
-            session.currentRequestId = requestId;
+          persistUserMessage: async (options: {
+            content: string;
+            requestId?: string;
+          }) => {
+            session.currentRequestId = options.requestId;
             const message = await addMessage(
               conversationId,
               "user",
-              JSON.stringify([{ type: "text", text: content }]),
+              JSON.stringify([{ type: "text", text: options.content }]),
               {
                 userMessageChannel: "phone",
                 assistantMessageChannel: "phone",
@@ -440,7 +440,7 @@ describe("relay-server", () => {
                 assistantMessageInterface: "phone",
               },
             );
-            return message.id;
+            return { id: message.id, deduplicated: false };
           },
           setChannelCapabilities: () => {},
           setAssistantId: () => {},

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -51,17 +51,18 @@ import {
 } from "../memory/attachments-store.js";
 import * as conversationStore from "../memory/conversation-crud.js";
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import * as deliveryChannels from "../memory/delivery-channels.js";
 import { resetTestTables } from "../memory/raw-query.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 const TEST_TOKEN = "test-bearer-token-attach";

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

@@ -9,6 +9,17 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
+// Stub the background-wake publisher so these store-level unit tests stay
+// hermetic. `notifySchedulesChanged()` fires a debounced background-wake
+// refresh on every mutation; left real, that 250ms timer performs a
+// synchronous DB read plus a platform-client lookup which compete with the
+// serialized async event delivery and can push a `sync_changed` past the
+// wait deadline on loaded runners. Background-wake behavior is covered by the
+// background-wake tests.
+mock.module("../background-wake/publisher.js", () => ({
+  refreshBackgroundWakeIntent: () => {},
+}));
+
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
@@ -38,7 +49,11 @@ function getRawDb(): import("bun:sqlite").Database {
 }
 
 async function waitFor(predicate: () => boolean): Promise<void> {
-  const deadline = Date.now() + 500;
+  // Event delivery is async (serialized through the hub's broadcast chain),
+  // so poll until it lands. The deadline is generous to absorb scheduling
+  // jitter on loaded CI runners — the happy path returns the moment the
+  // predicate holds, so a larger budget costs nothing when events flow.
+  const deadline = Date.now() + 2000;
   while (Date.now() < deadline) {
     if (predicate()) return;
     await new Promise((resolve) => setTimeout(resolve, 5));

package/src/__tests__/scheduler-reuse-conversation.test.ts

@@ -210,12 +210,57 @@ describe("scheduler conversation reuse", () => {
     expect(runs2[0].conversationId).toBe(firstConversationId);
   });
 
+  test("recurring schedule defaults to reuseConversation=true", async () => {
+    /**
+     * When no explicit reuseConversation is provided, recurring schedules
+     * default to true — subsequent runs reuse the same conversation.
+     */
+
+    // GIVEN a recurring schedule with no explicit reuseConversation
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "Default Reuse Test",
+      cronExpression: rruleExpr,
+      message: "Default reuse message",
+      syntax: "rrule",
+      expression: rruleExpr,
+      // no explicit reuseConversation — should default to true for recurring
+    });
+
+    // WHEN the schedule fires for the first time
+    forceScheduleDue(schedule.id);
+
+    const processMessage = async (conversationId: string, message: string) => {
+      processedMessages.push({ conversationId, message });
+    };
+
+    const scheduler1 = startScheduler(processMessage, () => {});
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler1.stop();
+
+    expect(processedMessages).toHaveLength(1);
+    const firstConversationId = processedMessages[0].conversationId;
+    expect(firstConversationId).toBeTruthy();
+
+    // WHEN the schedule fires for the second time
+    forceScheduleDue(schedule.id);
+    processedMessages.length = 0;
+
+    const scheduler2 = startScheduler(processMessage, () => {});
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler2.stop();
+
+    // THEN the same conversation is reused
+    expect(processedMessages).toHaveLength(1);
+    expect(processedMessages[0].conversationId).toBe(firstConversationId);
+  });
+
   test("recurring schedule with reuseConversation=false creates new conversation each run", async () => {
     /**
-     * Default behavior: each run creates a brand-new conversation.
+     * When explicitly opted out, each run creates a brand-new conversation.
      */
 
-    // GIVEN a recurring schedule with reuseConversation disabled (default)
+    // GIVEN a recurring schedule with reuseConversation explicitly disabled
     const rruleExpr = buildEveryMinuteRrule();
     const schedule = createSchedule({
       name: "No Reuse Test",
@@ -223,7 +268,7 @@ describe("scheduler conversation reuse", () => {
       message: "New conv each run",
       syntax: "rrule",
       expression: rruleExpr,
-      // reuseConversation defaults to false
+      reuseConversation: false, // explicitly opt out of conversation reuse
     });
 
     // WHEN the schedule fires for the first time

package/src/__tests__/secret-ingress-http.test.ts

@@ -106,6 +106,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => undefined,
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({
@@ -187,7 +188,10 @@ function makeRequest(
   });
 }
 
-const persistUserMessageMock = mock(async () => "persisted-id");
+const persistUserMessageMock = mock(async () => ({
+  id: "persisted-id",
+  deduplicated: false,
+}));
 const runAgentLoopMock = mock(async () => undefined);
 
 function makeSendMessageDeps() {

package/src/__tests__/secure-keys.test.ts

@@ -25,7 +25,6 @@ mock.module("../util/logger.js", () => ({
 
 import type { CesClient } from "../credential-execution/client.js";
 import * as encryptedStore from "../security/encrypted-store.js";
-import { _setStorePath } from "../security/encrypted-store.js";
 import {
   _resetBackend,
   deleteSecureKeyAsync,
@@ -36,6 +35,7 @@ import {
   setCesReconnect,
   setSecureKeyAsync,
 } from "../security/secure-keys.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Use a temp directory for encrypted store tests
@@ -59,11 +59,11 @@ describe("secure-keys", () => {
       rmSync(TEST_DIR, { recursive: true });
     }
     mkdirSync(TEST_DIR, { recursive: true });
-    _setStorePath(STORE_PATH);
+    setStorePathForTesting(STORE_PATH);
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     _resetBackend();
     delete process.env.VELLUM_DEV;
     delete process.env.VELLUM_DESKTOP_APP;