@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/regenerate-fire-and-forget-trace.test.ts

@@ -32,6 +32,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateMessageContent: () => {},
   relinkAttachments: () => 0,
   deleteLastExchange: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/registry.test.ts

@@ -1,7 +1,6 @@
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
 import { RiskLevel } from "../permissions/types.js";
-import type { ToolDefinition } from "../providers/types.js";
 import {
   __clearRegistryForTesting,
   __resetRegistryForTesting,
@@ -10,6 +9,7 @@ import {
   getSkillRefCount,
   getSkillToolNames,
   getTool,
+  getToolOwner,
   initializeTools,
   registerSkillTools,
   registerTool,
@@ -30,13 +30,8 @@ function makeFakeTool(name: string): Tool {
     description: `Fake ${name}`,
     category: "test",
     defaultRiskLevel: RiskLevel.Low,
-    getDefinition(): ToolDefinition {
-      return {
-        name,
-        description: `Fake ${name}`,
-        input_schema: { type: "object", properties: {}, required: [] },
-      };
-    },
+    executionTarget: "sandbox",
+    input_schema: { type: "object", properties: {}, required: [] },
     async execute(
       _input: Record<string, unknown>,
       _context: ToolContext,
@@ -46,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", () => {
@@ -201,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 () => {
@@ -223,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",
-    };
+  test("registerTool does not record ownership (bare-install path)", () => {
+    registerTool(makeFakeTool("test-bare-tool"));
 
-    registerTool(skillTool);
-
-    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();
   });
 });
 
@@ -258,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();
 
@@ -325,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();
@@ -356,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();
   });
 });
 
@@ -378,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");
@@ -398,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__/require-fresh-approval.test.ts

@@ -103,7 +103,7 @@ mock.module("../permissions/checker.js", () => ({
 mock.module("../memory/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
   getRecentInvocations: () => [],
-  rotateToolInvocations: () => 0,
+  rotateToolInvocations: async () => 0,
 }));
 
 mock.module("../tools/registry.js", () => ({
@@ -116,7 +116,7 @@ mock.module("../tools/registry.js", () => ({
       category: isGmailTool ? "gmail" : "credential-execution",
       defaultRiskLevel: "high",
       executionTarget: isGmailTool ? ("host" as const) : undefined,
-      getDefinition: () => ({}),
+      input_schema: {},
       execute: async () => fakeToolResult,
     };
   },

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__/runtime-events-sse-bilingual.test.ts

@@ -0,0 +1,154 @@
+/**
+ * `GET /v1/events` (`handleSubscribeAssistantEvents`) — bilingual scope
+ * resolution. Two query params are accepted, with distinct semantics:
+ *
+ *   - `?conversationId=<internal-id>` — looks up the conversation row
+ *     directly by its assistant-minted id. 404 if not found. Does NOT
+ *     materialise a new row.
+ *   - `?conversationKey=<external-key>` — resolves via the
+ *     `conversation_keys` table; materialises on first use. Ignored when
+ *     `conversationId` is also supplied.
+ *
+ * Companion to `runtime-events-sse.test.ts`, which exercises the broader
+ * `?conversationKey=` happy/error path.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { getOrCreateConversation } from "../memory/conversation-key-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import {
+  BadRequestError,
+  NotFoundError,
+} from "../runtime/routes/errors.js";
+import { handleSubscribeAssistantEvents } from "../runtime/routes/events-routes.js";
+
+initializeDb();
+
+describe("GET /v1/events — bilingual scope query params", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM conversation_keys");
+    db.run("DELETE FROM conversations");
+  });
+
+  test("?conversationId=<existing-id> scopes the stream to that conversation", async () => {
+    // Materialise a conversation via the key path, then subscribe to it
+    // directly by its internal id.
+    const { conversationId } = getOrCreateConversation("sse-id-scope-source");
+
+    const ac = new AbortController();
+    const testHub = new AssistantEventHub();
+
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationId },
+        abortSignal: ac.signal,
+      },
+      { hub: testHub },
+    );
+
+    const reader = stream.getReader();
+    // Consume the initial heartbeat.
+    const heartbeat = await reader.read();
+    expect(new TextDecoder().decode(heartbeat.value)).toBe(": heartbeat\n\n");
+
+    // Publish an event scoped to that conversation — should be delivered.
+    await testHub.publish(buildAssistantEvent({ type: "pong" }, conversationId));
+
+    const { value, done } = await reader.read();
+    ac.abort();
+
+    expect(done).toBe(false);
+    const frame = new TextDecoder().decode(value);
+    expect(frame).toContain("event: assistant_event");
+    expect(frame).toContain(`"conversationId":"${conversationId}"`);
+  });
+
+  test("?conversationId=<non-existent-id> throws NotFoundError", () => {
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: { conversationId: "does-not-exist" },
+        abortSignal: new AbortController().signal,
+      }),
+    ).toThrow(NotFoundError);
+  });
+
+  test("?conversationId is honored and ?conversationKey is ignored when both are present", async () => {
+    // Materialise two distinct conversations: one we'll subscribe to by id,
+    // one we'll publish to via the ignored key.
+    const { conversationId: idConv } = getOrCreateConversation("sse-id-wins");
+    const { conversationId: keyConv } = getOrCreateConversation(
+      "sse-key-ignored",
+    );
+    expect(idConv).not.toBe(keyConv);
+
+    const ac = new AbortController();
+    const testHub = new AssistantEventHub();
+
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: {
+          conversationId: idConv,
+          conversationKey: "sse-key-ignored",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub: testHub },
+    );
+    const reader = stream.getReader();
+    await reader.read(); // heartbeat
+
+    // Publish on the "key" conversation — should NOT be delivered (filter
+    // is locked to idConv because conversationId wins).
+    await testHub.publish(buildAssistantEvent({ type: "pong" }, keyConv));
+    // Publish on the "id" conversation — should be delivered.
+    await testHub.publish(buildAssistantEvent({ type: "pong" }, idConv));
+
+    const { value } = await reader.read();
+    ac.abort();
+    const frame = new TextDecoder().decode(value);
+
+    expect(frame).toContain(`"conversationId":"${idConv}"`);
+    expect(frame).not.toContain(`"conversationId":"${keyConv}"`);
+  });
+
+  test("empty conversationId is rejected with BadRequestError", () => {
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: { conversationId: "" },
+        abortSignal: new AbortController().signal,
+      }),
+    ).toThrow(BadRequestError);
+  });
+
+  test("empty conversationKey is still rejected (legacy parity)", () => {
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: { conversationKey: "" },
+        abortSignal: new AbortController().signal,
+      }),
+    ).toThrow(BadRequestError);
+  });
+});

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