@vellumai/assistant 0.6.5 → 0.6.6

package/src/__tests__/memory-retrieval-pipeline.test.ts

@@ -0,0 +1,401 @@
+/**
+ * Tests for the `memoryRetrieval` plugin pipeline (PR 20).
+ *
+ * Covers the default terminal behavior, timeout handling, and custom-plugin
+ * substitution. Uses `mock.module` to stub the workspace PKB/NOW readers
+ * so the test doesn't touch the developer's real `~/.vellum`. The memory
+ * graph handle is a hand-rolled fake passed as a dependency — the default
+ * retriever only needs `prepareMemory`.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Stub PKB/NOW readers BEFORE importing the module under test so the
+// bindings resolve through the mock.
+const readPkbContextMock = mock((): string | null => "pkb-default");
+const readNowContextMock = mock((): string | null => "now-default");
+mock.module("../daemon/conversation-runtime-assembly.js", () => ({
+  readPkbContext: readPkbContextMock,
+  readNowScratchpad: readNowContextMock,
+}));
+
+import type { AssistantConfig } from "../config/schema.js";
+import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
+import {
+  asDefaultGraphPayload,
+  DEFAULT_MEMORY_GRAPH_KIND,
+  type DefaultMemoryRetrievalDeps,
+  defaultMemoryRetrievalPlugin,
+  runDefaultMemoryRetrieval,
+} from "../plugins/defaults/memory-retrieval.js";
+import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
+import {
+  getMiddlewaresFor,
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import {
+  type MemoryArgs,
+  type MemoryResult,
+  type Middleware,
+  type Plugin,
+  PluginTimeoutError,
+  type TurnContext,
+} from "../plugins/types.js";
+import type { Message } from "../providers/types.js";
+
+const trust: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+};
+
+function makeTurnCtx(overrides: Partial<TurnContext> = {}): TurnContext {
+  return {
+    requestId: "req-test",
+    conversationId: "conv-test",
+    turnIndex: 0,
+    trust,
+    ...overrides,
+  };
+}
+
+function makeMemoryArgs(overrides: Partial<MemoryArgs> = {}): MemoryArgs {
+  return {
+    conversationId: "conv-test",
+    trustContext: trust,
+    turnIndex: 0,
+    ...overrides,
+  };
+}
+
+/**
+ * Fake graph-memory whose `prepareMemory` returns a canonical result. The
+ * default retriever threads this return value through
+ * `MemoryResult.memoryGraphBlocks[0].result`, so tests can assert the block
+ * shape by comparing the embedded object identity.
+ */
+function makeFakeGraphMemory(overrides?: {
+  messages?: Message[];
+  injectedTokens?: number;
+  injectedBlockText?: string | null;
+}): {
+  memory: ConversationGraphMemory;
+  prepareMemoryMock: ReturnType<typeof mock>;
+} {
+  const returnValue = {
+    runMessages: overrides?.messages ?? [],
+    injectedTokens: overrides?.injectedTokens ?? 0,
+    latencyMs: 0,
+    mode: "none" as const,
+    injectedBlockText:
+      overrides?.injectedBlockText === undefined
+        ? null
+        : overrides.injectedBlockText,
+    metrics: null,
+  };
+  const prepareMemoryMock = mock(async () => returnValue);
+  const memory = {
+    prepareMemory: prepareMemoryMock,
+  } as unknown as ConversationGraphMemory;
+  return { memory, prepareMemoryMock };
+}
+
+function makeDeps(
+  overrides: Partial<DefaultMemoryRetrievalDeps> = {},
+): DefaultMemoryRetrievalDeps {
+  const { memory } = makeFakeGraphMemory();
+  return {
+    messages: [],
+    graphMemory: memory,
+    config: {} as AssistantConfig,
+    onEvent: () => {},
+    isTrustedActor: true,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  resetPluginRegistryForTests();
+  readPkbContextMock.mockReset();
+  readNowContextMock.mockReset();
+  readPkbContextMock.mockImplementation(() => "pkb-default");
+  readNowContextMock.mockImplementation(() => "now-default");
+});
+
+describe("runDefaultMemoryRetrieval", () => {
+  test("returns PKB, NOW, and a single graph block when the actor is trusted", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    const deps = makeDeps({ graphMemory: memory, isTrustedActor: true });
+
+    const result = await runDefaultMemoryRetrieval(makeMemoryArgs(), deps);
+
+    expect(result.pkbContent).toBe("pkb-default");
+    expect(result.nowContent).toBe("now-default");
+    expect(result.memoryGraphBlocks).toHaveLength(1);
+    expect(prepareMemoryMock).toHaveBeenCalledTimes(1);
+
+    const payload = asDefaultGraphPayload(result.memoryGraphBlocks);
+    expect(payload).not.toBeNull();
+    expect(payload?.kind).toBe(DEFAULT_MEMORY_GRAPH_KIND);
+    // The default retriever forwards the graph-memory return value
+    // verbatim under `payload.result` — consumers in the agent loop
+    // rely on that identity.
+    expect(payload?.result.mode).toBe("none");
+  });
+
+  test("skips graph retrieval for untrusted actors", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    const deps = makeDeps({ graphMemory: memory, isTrustedActor: false });
+
+    const result = await runDefaultMemoryRetrieval(makeMemoryArgs(), deps);
+
+    expect(prepareMemoryMock).not.toHaveBeenCalled();
+    expect(result.memoryGraphBlocks).toEqual([]);
+    expect(result.pkbContent).toBe("pkb-default");
+    expect(result.nowContent).toBe("now-default");
+  });
+
+  test("passes through null PKB and NOW when the files are absent", async () => {
+    readPkbContextMock.mockImplementation(() => null);
+    readNowContextMock.mockImplementation(() => null);
+    const deps = makeDeps();
+
+    const result = await runDefaultMemoryRetrieval(makeMemoryArgs(), deps);
+
+    expect(result.pkbContent).toBeNull();
+    expect(result.nowContent).toBeNull();
+  });
+});
+
+describe("asDefaultGraphPayload", () => {
+  test("returns null when the blocks array is empty", () => {
+    expect(asDefaultGraphPayload([])).toBeNull();
+  });
+
+  test("returns null when the first block lacks the default discriminator", () => {
+    expect(asDefaultGraphPayload([{ kind: "custom" }])).toBeNull();
+    expect(asDefaultGraphPayload([{}])).toBeNull();
+    expect(asDefaultGraphPayload([null])).toBeNull();
+  });
+
+  test("narrows blocks whose first entry carries the default discriminator", () => {
+    const payload = {
+      kind: DEFAULT_MEMORY_GRAPH_KIND,
+      result: { mode: "per-turn" } as never,
+    };
+    expect(asDefaultGraphPayload([payload])).toBe(payload);
+  });
+});
+
+describe("memoryRetrieval pipeline — default vs custom plugin", () => {
+  test("default (no plugins registered) matches current retrieval exactly", async () => {
+    const deps = makeDeps();
+    const args = makeMemoryArgs();
+    const terminalDirect = await runDefaultMemoryRetrieval(args, deps);
+
+    // With an empty registry the pipeline runs the terminal directly. Use a
+    // fresh graph handle so `prepareMemory` call counts don't leak across
+    // the two invocations.
+    const deps2 = makeDeps();
+    const terminalViaPipeline = await runPipeline(
+      "memoryRetrieval",
+      getMiddlewaresFor("memoryRetrieval"),
+      (innerArgs: MemoryArgs) => runDefaultMemoryRetrieval(innerArgs, deps2),
+      args,
+      makeTurnCtx(),
+      DEFAULT_TIMEOUTS.memoryRetrieval,
+    );
+
+    expect(terminalViaPipeline.pkbContent).toBe(terminalDirect.pkbContent);
+    expect(terminalViaPipeline.nowContent).toBe(terminalDirect.nowContent);
+    expect(terminalViaPipeline.memoryGraphBlocks).toHaveLength(
+      terminalDirect.memoryGraphBlocks.length,
+    );
+  });
+
+  test("with the default plugin registered, pipeline still produces default output", async () => {
+    registerPlugin(defaultMemoryRetrievalPlugin);
+    const deps = makeDeps();
+    const args = makeMemoryArgs();
+
+    const result = await runPipeline(
+      "memoryRetrieval",
+      getMiddlewaresFor("memoryRetrieval"),
+      (innerArgs: MemoryArgs) => runDefaultMemoryRetrieval(innerArgs, deps),
+      args,
+      makeTurnCtx(),
+      DEFAULT_TIMEOUTS.memoryRetrieval,
+    );
+
+    expect(result.pkbContent).toBe("pkb-default");
+    expect(result.nowContent).toBe("now-default");
+    expect(result.memoryGraphBlocks).toHaveLength(1);
+    expect(asDefaultGraphPayload(result.memoryGraphBlocks)).not.toBeNull();
+  });
+
+  test("custom plugin can replace all three sources via short-circuit", async () => {
+    const customBlock = { kind: "custom.source", text: "replacement" };
+    const customMiddleware: Middleware<MemoryArgs, MemoryResult> =
+      async function customRetriever() {
+        // Skip `next` entirely — the terminal never runs.
+        return {
+          pkbContent: "pkb-custom",
+          nowContent: "now-custom",
+          memoryGraphBlocks: [customBlock],
+        };
+      };
+
+    const customPlugin: Plugin = {
+      manifest: {
+        name: "custom-memory-retrieval",
+        version: "0.0.1",
+        requires: { pluginRuntime: "v1", memoryApi: "v1" },
+      },
+      middleware: { memoryRetrieval: customMiddleware },
+    };
+    registerPlugin(customPlugin);
+
+    const deps = makeDeps();
+    const args = makeMemoryArgs();
+
+    const result = await runPipeline(
+      "memoryRetrieval",
+      getMiddlewaresFor("memoryRetrieval"),
+      (innerArgs: MemoryArgs) => runDefaultMemoryRetrieval(innerArgs, deps),
+      args,
+      makeTurnCtx(),
+      DEFAULT_TIMEOUTS.memoryRetrieval,
+    );
+
+    expect(result.pkbContent).toBe("pkb-custom");
+    expect(result.nowContent).toBe("now-custom");
+    expect(result.memoryGraphBlocks).toEqual([customBlock]);
+    // The terminal never ran, so the stubbed readers were NOT invoked.
+    expect(readPkbContextMock).not.toHaveBeenCalled();
+    expect(readNowContextMock).not.toHaveBeenCalled();
+    // And `asDefaultGraphPayload` must return null because the custom
+    // plugin supplied a block without the default discriminator — this is
+    // what drives the agent-loop escape hatch.
+    expect(asDefaultGraphPayload(result.memoryGraphBlocks)).toBeNull();
+  });
+
+  test("timeout: terminal that hangs past the budget fails with PluginTimeoutError", async () => {
+    // Hang-prone middleware that never resolves; the runner arms a 5s timer
+    // by default, but the test overrides to a much smaller budget to keep
+    // the suite fast.
+    const hanging: Middleware<MemoryArgs, MemoryResult> =
+      async function hangingRetriever(_args, _next) {
+        return new Promise<MemoryResult>(() => {
+          // Never resolves — simulates a retriever that blocks on I/O.
+        });
+      };
+
+    const plugin: Plugin = {
+      manifest: {
+        name: "hanging-memory-plugin",
+        version: "0.0.1",
+        requires: { pluginRuntime: "v1", memoryApi: "v1" },
+      },
+      middleware: { memoryRetrieval: hanging },
+    };
+    registerPlugin(plugin);
+
+    const deps = makeDeps();
+    const args = makeMemoryArgs();
+
+    let caught: unknown;
+    try {
+      await runPipeline(
+        "memoryRetrieval",
+        getMiddlewaresFor("memoryRetrieval"),
+        (innerArgs: MemoryArgs) => runDefaultMemoryRetrieval(innerArgs, deps),
+        args,
+        makeTurnCtx(),
+        30, // tiny budget — real production path uses 5_000ms
+      );
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(PluginTimeoutError);
+    const timeoutErr = caught as PluginTimeoutError;
+    expect(timeoutErr.pipeline).toBe("memoryRetrieval");
+    // The runner records whatever `ctx.pluginName` is set to when the
+    // timer fires. The default pipeline doesn't bind a plugin name, so
+    // the attribution is undefined — still fail the turn cleanly.
+    expect(timeoutErr.message).toContain("memoryRetrieval");
+  });
+
+  test("pipeline timeout aborts the signal threaded into prepareMemory", async () => {
+    // Regression for the cancellation gap: before `MemoryArgs.signal` was
+    // swapped by the pipeline's abort-linker, a pipeline timeout rejected
+    // the race but left `prepareMemory` running — mutating graph state
+    // after the turn had already errored. This test wires a long-running
+    // `prepareMemory` fake, arms a tight budget, and asserts the signal
+    // the terminal actually received reports `aborted === true` once the
+    // timer fires.
+    let capturedSignal: AbortSignal | undefined;
+    const hangingPrepare = mock(
+      (
+        _msgs: Message[],
+        _cfg: AssistantConfig,
+        signal: AbortSignal,
+        _onEvent: (msg: ServerMessage) => void,
+      ) => {
+        capturedSignal = signal;
+        return new Promise((_resolve, reject) => {
+          signal.addEventListener("abort", () => reject(new Error("aborted")));
+        });
+      },
+    );
+    const graphMemory = {
+      prepareMemory: hangingPrepare,
+    } as unknown as ConversationGraphMemory;
+    const deps = makeDeps({ graphMemory });
+    const outerController = new AbortController();
+    const args = makeMemoryArgs({ signal: outerController.signal });
+
+    let caught: unknown;
+    try {
+      await runPipeline(
+        "memoryRetrieval",
+        getMiddlewaresFor("memoryRetrieval"),
+        (innerArgs: MemoryArgs) => runDefaultMemoryRetrieval(innerArgs, deps),
+        args,
+        makeTurnCtx(),
+        30,
+      );
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(PluginTimeoutError);
+    expect(capturedSignal).toBeDefined();
+    // The signal the terminal observed must be the pipeline's linked
+    // signal (not the caller's bare signal), and it must be aborted so
+    // `prepareMemory` stops work instead of running to completion after
+    // the race has already rejected.
+    expect(capturedSignal).not.toBe(outerController.signal);
+    expect(capturedSignal!.aborted).toBe(true);
+  });
+
+  test("onEvent is invoked by the default retriever's terminal path", async () => {
+    const received: ServerMessage[] = [];
+    const { memory } = makeFakeGraphMemory();
+    const deps = makeDeps({
+      graphMemory: memory,
+      onEvent: (msg) => received.push(msg),
+      isTrustedActor: true,
+    });
+
+    await runDefaultMemoryRetrieval(makeMemoryArgs(), deps);
+
+    // The fake graph doesn't emit events, but the event sink must be
+    // forwarded intact so the real retriever can use it. Verify by
+    // reaching into the mock assertion above (prepareMemoryMock called
+    // with `onEvent`).
+    expect(received).toEqual([]);
+  });
+});

package/src/__tests__/memory-upsert-concurrency.test.ts

@@ -35,6 +35,7 @@ mock.module("../memory/qdrant-client.js", () => ({
     deletePoints: async () => {},
   }),
   initQdrantClient: () => {},
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
 }));
 
 import { DEFAULT_CONFIG } from "../config/defaults.js";

package/src/__tests__/migration-import-from-url.test.ts

@@ -11,11 +11,11 @@
  * - Invalid GCS URL: a real https://evil.com URL is rejected with the
  *   redacted `Invalid URL: host` message; the raw URL is not echoed back
  *   in the response body.
- * - Memory ceiling: a 100 MB fixture streams through with peak RSS delta
- *   bounded at ~128 MB. The ceiling is wider than the direct
- *   `streamCommitImport` ceiling because the URL handler stacks a Node
- *   HTTP response body + gunzip state + tar-stream state on top of the
- *   importer's per-entry working set.
+ *
+ * Memory-ceiling coverage lives at the streaming-importer layer — see
+ * `vbundle-streaming-importer.test.ts` ("streamCommitImport — memory
+ * ceiling"). The URL handler adds only fixed HTTP/framing overhead on top
+ * of that pipeline, not bundle-size-proportional allocation.
  *
  * The raw-bytes ingress path is exercised by a separate test file,
  * `migration-import-commit-http.test.ts`.
@@ -414,69 +414,6 @@ describe("handleMigrationImport — JSON {url} body", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Memory ceiling — streams a 100 MB fixture through and caps RSS.
-// ---------------------------------------------------------------------------
-
-function writeLargeFixtureToDisk(archivePath: string): void {
-  const CHUNK = 25 * 1024 * 1024;
-  const files = [0, 1, 2, 3].map((i) => ({
-    path: `workspace/big-${i}.bin`,
-    data: new Uint8Array(CHUNK).fill(0x41 + i),
-  }));
-  const { archive } = buildVBundle({ files });
-  writeFileSync(archivePath, archive);
-}
-
-describe("handleMigrationImport — URL body memory ceiling", () => {
-  test("100 MB fixture streams in without pushing RSS past ~128 MB over baseline", async () => {
-    const archivePath = join(testParent, "fixture-large.vbundle");
-    writeLargeFixtureToDisk(archivePath);
-
-    const fixture = await startFixtureServer((_req, res) => {
-      res.writeHead(200, { "Content-Type": "application/octet-stream" });
-      createReadStream(archivePath).pipe(res);
-    });
-
-    try {
-      // Force a GC opportunity before measuring baseline so stale fixture
-      // buffers don't count against the importer's budget. Bun exposes
-      // `Bun.gc` but not process.gc; gate on whether it exists.
-      const maybeBunGc = (
-        globalThis as { Bun?: { gc?: (sync?: boolean) => void } }
-      ).Bun?.gc;
-      if (typeof maybeBunGc === "function") maybeBunGc(true);
-
-      const baselineRss = process.memoryUsage().rss;
-
-      const req = new Request("http://localhost/v1/migrations/import", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ url: makeFakeSignedUrl(fixture.port) }),
-      });
-
-      const res = await handleMigrationImport(req);
-      const body = (await res.json()) as ImportCommitResponse;
-
-      const peakRss = process.memoryUsage().rss;
-
-      expect(res.status).toBe(200);
-      expect(body.success).toBe(true);
-
-      // 128 MB ceiling: the URL handler pipes the HTTP response body
-      // through gunzip + tar-stream on top of the streaming importer's
-      // per-entry working set. The extra framing state is bigger than
-      // raw-stream importing (which fits in ~64 MB), so 128 MB keeps
-      // enough headroom to detect full-bundle buffering without
-      // flapping on normal streaming-mode overhead.
-      const delta = peakRss - baselineRss;
-      expect(delta).toBeLessThan(128 * 1024 * 1024);
-    } finally {
-      await fixture.close();
-    }
-  }, 90_000);
-});
-
 // ---------------------------------------------------------------------------
 // Gap A regression: no-swap success path must not append a stale
 // "newer migration" warning sourced from the live DB. The warning would

package/src/__tests__/model-intents.test.ts

@@ -31,9 +31,11 @@ describe("model intents", () => {
   });
 
   test("falls back to provider default for unknown providers", () => {
-    expect(getProviderDefaultModel("unknown-provider")).toBe("claude-opus-4-7");
+    expect(getProviderDefaultModel("unknown-provider")).toBe(
+      "claude-sonnet-4-6",
+    );
     expect(resolveModelIntent("unknown-provider", "quality-optimized")).toBe(
-      "claude-opus-4-7",
+      "claude-sonnet-4-6",
     );
   });
 });

package/src/__tests__/notification-broadcaster.test.ts

@@ -593,7 +593,7 @@ describe("notification broadcaster", () => {
     broadcaster.setOnConversationCreated((info) => createdCalls.push(info));
 
     const signal = makeSignal({
-      sourceEventName: "schedule.complete",
+      sourceEventName: "schedule.notify",
       conversationMetadata: {
         groupId: "system:scheduled",
         source: "schedule",
@@ -607,7 +607,7 @@ describe("notification broadcaster", () => {
     expect(createdCalls).toHaveLength(1);
     expect(createdCalls[0].groupId).toBe("system:scheduled");
     expect(createdCalls[0].source).toBe("schedule");
-    expect(createdCalls[0].sourceEventName).toBe("schedule.complete");
+    expect(createdCalls[0].sourceEventName).toBe("schedule.notify");
   });
 
   test("onConversationCreated omits groupId and source when conversationMetadata is absent", async () => {
@@ -632,7 +632,7 @@ describe("notification broadcaster", () => {
     const dispatchCalls: ConversationCreatedInfo[] = [];
 
     const signal = makeSignal({
-      sourceEventName: "schedule.complete",
+      sourceEventName: "schedule.notify",
       conversationMetadata: {
         groupId: "system:scheduled",
         source: "schedule",

package/src/__tests__/notification-decision-strategy.test.ts

@@ -147,17 +147,6 @@ describe("notification decision strategy", () => {
       expect(copy.telegram!.deliveryText).toBe("Take out the trash");
     });
 
-    test("schedule.complete template uses name from payload", () => {
-      const signal = makeSignal({
-        sourceEventName: "schedule.complete",
-        contextPayload: { name: "Daily backup" },
-      });
-
-      const copy = composeFallbackCopy(signal, channels);
-      expect(copy.vellum).toBeDefined();
-      expect(copy.vellum!.body).toContain("Daily backup");
-    });
-
     test("unknown event name produces generic copy with urgency prefix", () => {
       const signal = makeSignal({
         sourceEventName: "some_novel.event",

package/src/__tests__/notification-schedule-notify-dedup.test.ts

@@ -0,0 +1,108 @@
+/**
+ * Regression test: recurring `schedule.notify` firings must not be
+ * deduplicated against prior firings of the same schedule.
+ *
+ * The scheduler supplies a unique per-firing dedupeKey
+ * (`schedule:notify:<id>:<timestamp>`) so `updateEventDedupeKey` is never
+ * called for schedule signals and `checkDedupe` never finds a matching
+ * row when the LLM decision engine generates a stable key like
+ * `schedule:notify:<id>`.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (value: string) => value,
+}));
+
+import { getDb, initializeDb } from "../memory/db.js";
+import { notificationEvents } from "../memory/schema.js";
+import { runDeterministicChecks } from "../notifications/deterministic-checks.js";
+import { createEvent } from "../notifications/events-store.js";
+import type { NotificationSignal } from "../notifications/signal.js";
+import type { NotificationDecision } from "../notifications/types.js";
+
+initializeDb();
+
+beforeEach(() => {
+  getDb().delete(notificationEvents).run();
+});
+
+function makeSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: `sig-${crypto.randomUUID()}`,
+    createdAt: Date.now(),
+    sourceChannel: "scheduler",
+    sourceContextId: "schedule-123",
+    sourceEventName: "schedule.notify",
+    contextPayload: { scheduleId: "schedule-123", label: "Drink water" },
+    attentionHints: {
+      requiresAction: true,
+      urgency: "high",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+function makeDecision(
+  overrides?: Partial<NotificationDecision>,
+): NotificationDecision {
+  return {
+    shouldNotify: true,
+    selectedChannels: ["vellum"],
+    reasoningSummary: "Schedule reminder",
+    renderedCopy: {
+      vellum: { title: "Reminder", body: "Time to drink water" },
+    },
+    dedupeKey: "schedule:notify:schedule-123",
+    confidence: 0.9,
+    fallbackUsed: false,
+    ...overrides,
+  };
+}
+
+describe("recurring schedule.notify dedup", () => {
+  test("notify mode with timestamped producer keys is not blocked", async () => {
+    const stableKey = "schedule:notify:schedule-123";
+    const firstId = crypto.randomUUID();
+    const secondId = crypto.randomUUID();
+
+    const firstSignal = makeSignal({ signalId: firstId });
+    createEvent({
+      id: firstSignal.signalId,
+      sourceEventName: "schedule.notify",
+      sourceChannel: "scheduler",
+      sourceContextId: "schedule-123",
+      attentionHints: firstSignal.attentionHints,
+      payload: firstSignal.contextPayload,
+      dedupeKey: `schedule:notify:schedule-123:${Date.now() - 60_000}`,
+    });
+
+    const secondSignal = makeSignal({ signalId: secondId });
+    createEvent({
+      id: secondSignal.signalId,
+      sourceEventName: "schedule.notify",
+      sourceChannel: "scheduler",
+      sourceContextId: "schedule-123",
+      attentionHints: secondSignal.attentionHints,
+      payload: secondSignal.contextPayload,
+      dedupeKey: `schedule:notify:schedule-123:${Date.now()}`,
+    });
+
+    const decision = makeDecision({ dedupeKey: stableKey });
+
+    const result = await runDeterministicChecks(secondSignal, decision, {
+      connectedChannels: ["vellum"],
+    });
+
+    expect(result.passed).toBe(true);
+  });
+});

package/src/__tests__/oauth-apps-routes.test.ts

@@ -56,7 +56,7 @@ mock.module("../oauth/oauth-store.js", () => ({
           userinfoUrl: null,
           baseUrl: null,
           defaultScopes: "[]",
-          scopePolicy: "[]",
+          availableScopes: null,
           scopeSeparator: null,
           authorizeParams: null,
           pingUrl: null,