@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/plugin-injector-contribution.test.ts

@@ -4,7 +4,8 @@
  * A plugin may declare an `injectors` array on its {@link Plugin} shape; after
  * its model-visible surface is wired and before `init()` succeeds, bootstrap
  * registers each entry into the global injector registry via
- * {@link registerPluginInjectors}, and on shutdown calls
+ * {@link registerPluginInjectors}. A plugin rolled back after a failed bring-up
+ * (or uninstalled/disabled at runtime) is unregistered via
  * {@link unregisterPluginInjectors}. This mirrors the tools/routes contribution
  * path (see `plugin-route-contribution.test.ts`).
  *
@@ -12,8 +13,7 @@
  *
  *  1. Bootstrap → the contributed injector appears in
  *     {@link getRegisteredInjectors}, and `init()` ran.
- *  2. Shutdown → the contributed injector is unregistered.
- *  3. A plugin without `injectors` bootstraps and shuts down cleanly.
+ *  2. A plugin without `injectors` bootstraps cleanly.
  *
  * `getRegisteredInjectors()` after `bootstrapPlugins()` also contains the
  * first-party defaults (bootstrap registers `default-memory`'s injectors), so
@@ -26,7 +26,6 @@ import { join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
-import { runShutdownHooks } from "../daemon/shutdown-registry.js";
 import {
   clearInjectorRegistry,
   getRegisteredInjectors,
@@ -122,27 +121,12 @@ describe("plugin injector contributions", () => {
     expect(isTestInjectorRegistered()).toBe(true);
   });
 
-  test("shutdown unregisters the plugin's injectors", async () => {
-    registerPlugin(
-      buildPlugin("injector-plugin", { injectors: [makeTestInjector()] }),
-    );
-
-    await bootstrapPlugins();
-    expect(isTestInjectorRegistered()).toBe(true);
-
-    // Shutdown runs the reverse-order teardown hook registered by bootstrap.
-    await runShutdownHooks("test-shutdown");
-
-    expect(isTestInjectorRegistered()).toBe(false);
-  });
-
-  test("plugin with no injectors bootstraps and shuts down cleanly", async () => {
+  test("plugin with no injectors bootstraps cleanly", async () => {
     // Declaring no `injectors` field is the common case; bootstrap must skip
     // injector handling entirely (the guard is `if plugin.injectors && length`).
     registerPlugin(buildPlugin("no-injectors-plugin", { async init() {} }));
 
     await bootstrapPlugins();
-    await runShutdownHooks("test-shutdown");
 
     expect(isTestInjectorRegistered()).toBe(false);
   });

package/src/__tests__/plugin-pipeline.test.ts

@@ -1,4 +1,13 @@
-import { beforeEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Stub the conversation scope resolver so the pipeline's conversationId-based
+// scoping can be exercised without a live conversation or DB row.
+const resolveScopeMock = mock(
+  (_conversationId: string): Set<string> | null => null,
+);
+mock.module("../daemon/conversation-plugin-scope.js", () => ({
+  resolveConversationPluginScope: (id: string) => resolveScopeMock(id),
+}));
 
 import { runHook } from "../plugins/pipeline.js";
 import {
@@ -8,6 +17,8 @@ import {
 
 beforeEach(() => {
   resetPluginRegistryForTests();
+  resolveScopeMock.mockReset();
+  resolveScopeMock.mockImplementation(() => null);
 });
 
 describe("plugin pipeline", () => {
@@ -94,3 +105,54 @@ describe("plugin pipeline", () => {
     expect(result.items).toEqual(["first", "final"]);
   });
 });
+
+describe("plugin pipeline — per-conversation scope", () => {
+  function registerSeenHook(name: string) {
+    registerPlugin({
+      manifest: { name, version: "1.0.0" },
+      hooks: {
+        "user-prompt-submit": async (ctx: { seen: string[] }) => {
+          ctx.seen.push(name);
+        },
+      },
+    });
+  }
+
+  test("scopes hooks to the resolved set when the context has a conversationId", async () => {
+    registerSeenHook("in-scope");
+    registerSeenHook("out-scope");
+    resolveScopeMock.mockImplementation((conversationId: string) =>
+      conversationId === "c1" ? new Set(["in-scope"]) : null,
+    );
+
+    // A context carrying conversationId resolves the scope and skips the
+    // out-of-scope plugin's hook.
+    const scoped = await runHook<{ conversationId: string; seen: string[] }>(
+      "user-prompt-submit",
+      { conversationId: "c1", seen: [] },
+    );
+    expect(scoped.seen).toEqual(["in-scope"]);
+    expect(resolveScopeMock).toHaveBeenCalledWith("c1");
+
+    // A context without a conversationId is never resolved and imposes no
+    // restriction.
+    resolveScopeMock.mockClear();
+    const unscoped = await runHook<{ seen: string[] }>("user-prompt-submit", {
+      seen: [],
+    });
+    expect(unscoped.seen).toEqual(["in-scope", "out-scope"]);
+    expect(resolveScopeMock).not.toHaveBeenCalled();
+  });
+
+  test("imposes no restriction when the resolver returns null", async () => {
+    registerSeenHook("plugin-a");
+    registerSeenHook("plugin-b");
+    resolveScopeMock.mockImplementation(() => null);
+
+    const result = await runHook<{ conversationId: string; seen: string[] }>(
+      "user-prompt-submit",
+      { conversationId: "c1", seen: [] },
+    );
+    expect(result.seen).toEqual(["plugin-a", "plugin-b"]);
+  });
+});

package/src/__tests__/plugin-route-contribution.test.ts

@@ -3,24 +3,24 @@
  *
  * A plugin may declare a `routes` array on its {@link Plugin} shape; after
  * `init()` succeeds, bootstrap wires each entry into the skill-route registry
- * via {@link registerSkillRoute}, retains the opaque {@link SkillRouteHandle}
- * it receives back, and on shutdown calls {@link unregisterSkillRoute} with
- * that exact handle. Handle-keyed unregistration ensures that two
- * owners (e.g. a plugin and a skill) that legitimately register the same
- * regex cannot have one owner's teardown silently evict another owner's
- * route, preserving the "no traffic hits a plugin handler during
- * onShutdown" invariant.
+ * via {@link registerSkillRoute} and retains the opaque {@link SkillRouteHandle}
+ * it receives back. A plugin rolled back after a failed bring-up (or a user
+ * plugin uninstalled/disabled at runtime) is unregistered with that exact handle
+ * via {@link unregisterSkillRoute}. Handle-keyed unregistration ensures that two
+ * owners (e.g. a plugin and a skill) that legitimately register the same regex
+ * cannot have one owner's teardown silently evict another owner's route. At
+ * daemon shutdown the plugins' `shutdown` hooks fire through the unified
+ * `runHook(HOOKS.SHUTDOWN, …)` pipeline (surfaces are not unregistered — the
+ * process is exiting).
  *
  * The registry doesn't own HTTP itself — the tests here exercise:
  *
  *  1. Bootstrap → `registerSkillRoute` → `matchSkillRoute` returns the plugin's
  *     handler, and the handler responds as expected.
- *  2. Shutdown → `unregisterSkillRoute` drops the entry, and subsequent
- *     `matchSkillRoute` lookups return `null`.
- *  3. Plugins without `routes` (or with an empty array) bootstrap cleanly.
- *  4. When two plugins register regex patterns with identical `source+flags`,
- *     each plugin's shutdown only removes its own route — the other plugin's
- *     route stays live until its own teardown runs.
+ *  2. Plugins without `routes` (or with an empty array) bootstrap cleanly.
+ *  3. Handle-keyed unregistration: unregistering one route's handle leaves a
+ *     sibling's identical-pattern route live until its own handle is dropped.
+ *  4. Every contributing plugin's `shutdown` hook fires via `runHook`.
  *
  * `resetPluginRegistryForTests()` isolates plugin-registry state and
  * `resetSkillRoutesForTests()` isolates skill-route-registry state between
@@ -33,7 +33,8 @@ import { join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
-import { runShutdownHooks } from "../daemon/shutdown-registry.js";
+import { HOOKS } from "../plugin-api/constants.js";
+import { runHook } from "../plugins/pipeline.js";
 import {
   registerPlugin,
   resetPluginRegistryForTests,
@@ -41,9 +42,10 @@ import {
 import type { InitContext, Plugin } from "../plugins/types.js";
 import {
   matchSkillRoute,
+  registerSkillRoute,
   resetSkillRoutesForTests,
   type SkillRoute,
-  type SkillRouteMatch,
+  unregisterSkillRoute,
 } from "../runtime/skill-route-registry.js";
 
 // Redirect plugin storage creation into a per-process temp tree so the test
@@ -147,96 +149,59 @@ describe("plugin route contributions", () => {
     expect(await res.text()).toBe("echo");
   });
 
-  test("shutdown unregisters the plugin's routes", async () => {
-    const route: SkillRoute = {
-      pattern: echoPattern,
-      methods: ["GET"],
-      handler: async () => new Response("echo", { status: 200 }),
-    };
-
-    registerPlugin(buildPlugin("echo-plugin", { routes: [route] }));
-
-    await bootstrapPlugins();
-
-    // Sanity: route is live after bootstrap.
-    expect(matchSkillRoute("/_plugin/echo", "GET")).not.toBeNull();
-
-    // Shutdown runs the reverse-order teardown hook registered by bootstrap.
-    await runShutdownHooks("test-shutdown");
-
-    // Route is gone — matchSkillRoute returns null because no pattern
-    // matches the path at all anymore.
-    expect(matchSkillRoute("/_plugin/echo", "GET")).toBeNull();
-  });
-
-  test("plugin with no routes bootstraps and shuts down cleanly", async () => {
+  test("plugin with no routes bootstraps and tears down cleanly", async () => {
     // Declaring no `routes` field is the common case; bootstrap must skip
     // route handling entirely (the guard is `if plugin.routes && length > 0`).
     registerPlugin(buildPlugin("no-routes-plugin", { async init() {} }));
 
     await bootstrapPlugins();
-    await runShutdownHooks("test-shutdown");
+    await runHook(HOOKS.SHUTDOWN, {
+      assistantVersion: "test",
+      reason: "shutdown",
+    });
 
     // Nothing to verify beyond "neither throws" — an empty `routes` must not
     // regress existing no-op bootstrap semantics.
     expect(true).toBe(true);
   });
 
-  test("shutdown tolerates a route whose registry entry was wiped externally", async () => {
-    // Guard against the case where a stale handle no longer points at a live
-    // registry entry (e.g. the registry was cleared externally). The shutdown
-    // hook must not crash — unregisterSkillRoute returns false, and
-    // bootstrap's try/catch around the call swallows the signal. This
-    // exercises the defensive path so a partial-crash recovery still runs
-    // every plugin's onShutdown in reverse order.
-    let shutdownFired = false;
-    registerPlugin(
-      buildPlugin("echo-plugin", {
-        routes: [
-          {
-            pattern: echoPattern,
-            methods: ["GET"],
-            handler: async () => new Response("echo", { status: 200 }),
-          },
-        ],
-        async onShutdown() {
-          shutdownFired = true;
-        },
-      }),
-    );
-
-    await bootstrapPlugins();
+  test("unregistering one route handle leaves a sibling's identical-pattern route live", async () => {
+    // Regression for the reviewer-flagged invariant: keying unregistration on
+    // `pattern.source + flags` would let one owner's teardown drop another
+    // owner's route when both declared regex with identical text. The plugin
+    // surface teardown unregisters routes by the opaque handle retained at
+    // registration time (`unregisterSkillRoute(handle)`), so that is the
+    // mechanism keeping sibling routes intact. Exercise it directly: two routes
+    // with byte-identical patterns, drop one handle, and the other must still
+    // match until its own handle is dropped too.
+    const handleA = registerSkillRoute({
+      pattern: /^\/_plugin\/echo$/,
+      methods: ["GET"],
+      handler: async () => new Response("a", { status: 200 }),
+    });
+    const handleB = registerSkillRoute({
+      pattern: /^\/_plugin\/echo$/,
+      methods: ["GET"],
+      handler: async () => new Response("b", { status: 200 }),
+    });
 
-    // Simulate an external wipe before the shutdown hook runs — e.g. a
-    // different subsystem calling `resetSkillRoutesForTests` or a hot-reload
-    // flow clearing the registry. The plugin's retained handle is now stale.
-    resetSkillRoutesForTests();
+    expect(matchSkillRoute("/_plugin/echo", "GET")).not.toBeNull();
 
-    await runShutdownHooks("test-shutdown");
+    // Drop B (reverse-order teardown drops the last-registered owner first).
+    expect(unregisterSkillRoute(handleB)).toBe(true);
+    // A's identical-pattern route must still be live.
+    expect(matchSkillRoute("/_plugin/echo", "GET")).not.toBeNull();
 
-    // onShutdown still ran despite the stale handle — proving the
-    // route-unregister step does not short-circuit plugin teardown.
-    expect(shutdownFired).toBe(true);
+    // Only once A's own handle is dropped does the route disappear.
+    expect(unregisterSkillRoute(handleA)).toBe(true);
+    expect(matchSkillRoute("/_plugin/echo", "GET")).toBeNull();
   });
 
-  test("shutdown of one plugin does not evict a sibling's same-pattern route", async () => {
-    // Regression for the reviewer-flagged invariant: keying unregistration on
-    // `pattern.source + flags` would let plugin-A's teardown drop plugin-B's
-    // route when both declared regex with identical text. With handle-keyed
-    // identity, each plugin's teardown removes only its own registrations.
-    //
-    // We simulate this by wiring two plugins that both contribute a route
-    // matching `/^\/_plugin\/echo$/`. Teardown runs in reverse registration
-    // order, so plugin-B is torn down first; plugin-A's route must still
-    // match afterwards, and only disappear once plugin-A's own teardown
-    // runs.
-    let pluginAShutdown = false;
-    let pluginBShutdown = false;
-    // Capture the match result from inside plugin-B's onShutdown so assertions
-    // run after runShutdownHooks returns. teardownPlugin wraps onShutdown in a
-    // try/catch that swallows thrown assertion errors, so asserting inline
-    // would let a failing match silently pass the test.
-    let pluginBOnShutdownMatch: SkillRouteMatch | null = null;
+  test("every contributing plugin's shutdown hook fires through the runHook pipeline", async () => {
+    // At daemon shutdown the plugins' `shutdown` hooks fire through the unified
+    // `runHook` pipeline — the same dispatch path every other lifecycle hook
+    // uses. Two plugins prove each one's hook fires exactly once.
+    const pluginsThatShutDown: string[] = [];
 
     registerPlugin(
       buildPlugin("plugin-a", {
@@ -248,16 +213,10 @@ describe("plugin route contributions", () => {
           },
         ],
         async onShutdown() {
-          // When plugin-A's teardown runs, plugin-B has already been torn
-          // down — but plugin-A's route must still be live because
-          // `onShutdown` fires *after* the route-unregister step for this
-          // plugin but *before* it leaves teardownPlugin. We check liveness
-          // from plugin-B's teardown instead (see below).
-          pluginAShutdown = true;
+          pluginsThatShutDown.push("plugin-a");
         },
       }),
     );
-
     registerPlugin(
       buildPlugin("plugin-b", {
         routes: [
@@ -268,31 +227,19 @@ describe("plugin route contributions", () => {
           },
         ],
         async onShutdown() {
-          // Plugin-B's routes have already been unregistered by the time
-          // this fires, but plugin-A's route is still live — it only gets
-          // torn down after this hook returns and the loop moves on to
-          // plugin-A. Confirm the registry still has a matching route.
-          pluginBShutdown = true;
-          pluginBOnShutdownMatch = matchSkillRoute("/_plugin/echo", "GET");
+          pluginsThatShutDown.push("plugin-b");
         },
       }),
     );
 
     await bootstrapPlugins();
 
-    // Both plugins' routes landed in the registry; matching returns one of
-    // them (order defined by registration, but we only care that *some*
-    // route matches before shutdown starts).
-    expect(matchSkillRoute("/_plugin/echo", "GET")).not.toBeNull();
-
-    await runShutdownHooks("test-shutdown");
+    await runHook(HOOKS.SHUTDOWN, {
+      assistantVersion: "test",
+      reason: "shutdown",
+    });
 
-    expect(pluginBShutdown).toBe(true);
-    expect(pluginAShutdown).toBe(true);
-    expect(pluginBOnShutdownMatch).not.toBeNull();
-    expect(pluginBOnShutdownMatch!.kind).toBe("match");
-
-    // After both plugins shut down, no routes remain.
-    expect(matchSkillRoute("/_plugin/echo", "GET")).toBeNull();
+    // Both plugins' hooks fired exactly once.
+    expect(pluginsThatShutDown.sort()).toEqual(["plugin-a", "plugin-b"]);
   });
 });

package/src/__tests__/plugin-tool-contribution.test.ts

@@ -27,7 +27,6 @@ import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
-import { runShutdownHooks } from "../daemon/shutdown-registry.js";
 import { RiskLevel } from "../permissions/types.js";
 import {
   registerPlugin,
@@ -154,22 +153,6 @@ describe("plugin tool contributions", () => {
     expect(names).toContain("plugin-contrib-tool");
   });
 
-  test("plugin tools are unregistered when shutdown hooks run", async () => {
-    const plugin = buildPlugin("bravo-contributor", {
-      async init() {},
-      tools: [makeFakeTool("bravo-tool")],
-    });
-    registerPlugin(plugin);
-
-    await bootstrapPlugins();
-    expect(getTool("bravo-tool")).toBeDefined();
-
-    await runShutdownHooks("test-shutdown");
-
-    expect(getTool("bravo-tool")).toBeUndefined();
-    expect(getPluginRefCount("bravo-contributor")).toBe(0);
-  });
-
   test("bootstrap is a no-op for plugins that declare no tools", async () => {
     const plugin = buildPlugin("no-tools", { async init() {} });
     registerPlugin(plugin);
@@ -180,11 +163,6 @@ describe("plugin tool contributions", () => {
     // empty. What matters here is that the no-tools plugin contributed nothing
     // of its own — its tool refcount stays at zero.
     expect(getPluginRefCount("no-tools")).toBe(0);
-
-    // Shutdown must also be safe — `unregisterPluginTools` is idempotent for
-    // plugins that never contributed any tools.
-    await runShutdownHooks("test-shutdown");
-    expect(getPluginRefCount("no-tools")).toBe(0);
   });
 
   test("tools declared before init() runs are only visible after bootstrap", async () => {

package/src/__tests__/plugin-types.test.ts

@@ -38,7 +38,6 @@ describe("plugin core types", () => {
     const manifest: PluginManifest = {
       name: "sample-plugin",
       version: "0.1.0",
-      requiresFlag: ["sample-feature"],
       config: { parse: (input: unknown) => input },
     };
 

package/src/__tests__/pointer-conversation-trust.test.ts

@@ -55,7 +55,12 @@ class FakeConversation {
   }
 }
 
-const CONTACT_CONTEXT: TrustContext = {
+const TRUSTED_CONTACT_CONTEXT: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "trusted_contact",
+};
+
+const UNVERIFIED_CONTACT_CONTEXT: TrustContext = {
   sourceChannel: "vellum",
   trustClass: "unverified_contact",
 };
@@ -82,16 +87,43 @@ describe("elevatePointerConversationToGuardian", () => {
     expect(conv.trustContext).toBeUndefined();
   });
 
-  test("restores the prior non-memory trust context after the turn", async () => {
-    const conv = new FakeConversation({ trustContext: CONTACT_CONTEXT });
+  test("does not elevate a trusted_contact context (no guardian history leak)", async () => {
+    const conv = new FakeConversation({
+      trustContext: TRUSTED_CONTACT_CONTEXT,
+    });
+    // A contact load filters guardian history to empty; it must stay empty.
     expect(conv.visibleHistory).toEqual([]);
 
     const restore = await elevatePointerConversationToGuardian(conv);
-    expect(conv.trustContext).toBe(INTERNAL_GUARDIAN_TRUST_CONTEXT);
-    expect(conv.visibleHistory).toEqual(["m1", "m2", "m3"]);
+
+    // No elevation and no rehydration — guardian-only history is never
+    // surfaced into a contact conversation.
+    expect(conv.setTrustContextCalls).toEqual([]);
+    expect(conv.ensureCalls).toBe(0);
+    expect(conv.trustContext).toBe(TRUSTED_CONTACT_CONTEXT);
+    expect(conv.visibleHistory).toEqual([]);
+
+    restore();
+    expect(conv.setTrustContextCalls).toEqual([]);
+    expect(conv.trustContext).toBe(TRUSTED_CONTACT_CONTEXT);
+  });
+
+  test("does not elevate an unverified_contact context (no guardian history leak)", async () => {
+    const conv = new FakeConversation({
+      trustContext: UNVERIFIED_CONTACT_CONTEXT,
+    });
+    expect(conv.visibleHistory).toEqual([]);
+
+    const restore = await elevatePointerConversationToGuardian(conv);
+
+    expect(conv.setTrustContextCalls).toEqual([]);
+    expect(conv.ensureCalls).toBe(0);
+    expect(conv.trustContext).toBe(UNVERIFIED_CONTACT_CONTEXT);
+    expect(conv.visibleHistory).toEqual([]);
 
     restore();
-    expect(conv.trustContext).toBe(CONTACT_CONTEXT);
+    expect(conv.setTrustContextCalls).toEqual([]);
+    expect(conv.trustContext).toBe(UNVERIFIED_CONTACT_CONTEXT);
   });
 
   test("no-ops for a conversation that already has memory access", async () => {

package/src/__tests__/pre-model-call-sanitize.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { preModelCallSanitize } from "../agent/loop.js";
+import { preModelCallSanitize } from "../context/outbound-sanitize.js";
 import type { Message } from "../providers/types.js";
 
 /**

package/src/__tests__/prune-old-tool-invocations-job.test.ts

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Silence the logger.
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import type { AssistantConfig } from "../config/schema.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { pruneOldToolInvocationsJob } from "../persistence/job-handlers/cleanup.js";
+import type { MemoryJob } from "../persistence/jobs-store.js";
+import { conversations, toolInvocations } from "../persistence/schema/index.js";
+
+await initializeDb();
+
+const DAY_MS = 86_400_000;
+
+function seedInvocation(id: string, createdAt: number): void {
+  getDb()
+    .insert(toolInvocations)
+    .values({
+      id,
+      conversationId: "conv-1",
+      toolName: "bash",
+      input: "{}",
+      result: "{}",
+      decision: "allow",
+      riskLevel: "low",
+      durationMs: 5,
+      createdAt,
+    })
+    .run();
+}
+
+function remainingIds(): string[] {
+  return getDb()
+    .select()
+    .from(toolInvocations)
+    .all()
+    .map((r) => r.id)
+    .sort();
+}
+
+function job(payload: Record<string, unknown> = {}): MemoryJob {
+  return { payload } as unknown as MemoryJob;
+}
+
+function config(retentionDays: number): AssistantConfig {
+  return { auditLog: { retentionDays } } as unknown as AssistantConfig;
+}
+
+describe("pruneOldToolInvocationsJob", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.delete(toolInvocations).run();
+    db.delete(conversations).run();
+    // tool_invocations.conversation_id is an FK into conversations.
+    db.insert(conversations)
+      .values({
+        id: "conv-1",
+        title: "test",
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      })
+      .run();
+  });
+
+  test("deletes audit rows older than auditLog.retentionDays, keeps recent ones", async () => {
+    seedInvocation("old", Date.now() - 60 * DAY_MS);
+    seedInvocation("fresh", Date.now());
+
+    await pruneOldToolInvocationsJob(job(), config(30));
+
+    expect(remainingIds()).toEqual(["fresh"]);
+  });
+
+  test("payload retentionDays overrides the config window", async () => {
+    seedInvocation("ten-days", Date.now() - 10 * DAY_MS);
+
+    // Config would keep it (30d), but the payload tightens to 7d.
+    await pruneOldToolInvocationsJob(job({ retentionDays: 7 }), config(30));
+
+    expect(remainingIds()).toEqual([]);
+  });
+
+  test("retentionDays of 0 is a no-op (keep forever)", async () => {
+    seedInvocation("ancient", Date.now() - 999 * DAY_MS);
+
+    await pruneOldToolInvocationsJob(job(), config(0));
+
+    expect(remainingIds()).toEqual(["ancient"]);
+  });
+});