@vellumai/assistant 0.7.3 → 0.8.1

package/src/memory/v2/__tests__/sim.test.ts

@@ -136,7 +136,11 @@ class MockQdrantClient {
       limit: params.limit,
       filter: params.filter,
     });
-    const channel = params.using as "dense" | "sparse";
+    // Both `dense` and `summary_dense` consume from the dense queue (and
+    // similarly for sparse). The four-channel hybrid query fires them in
+    // order: body-dense, body-sparse, summary-dense, summary-sparse — so
+    // the queue order matches the call order.
+    const channel = params.using.endsWith("sparse") ? "sparse" : "dense";
     return state.queryResponses[channel].shift() ?? { points: [] };
   }
 }
@@ -185,10 +189,18 @@ function configWithWeights(
 /**
  * Stage a single Qdrant response that maps each (slug, denseScore?, sparseScore?)
  * tuple onto the dense or sparse channel, mirroring how `hybridQueryConceptPages`
- * merges per-channel hits.
+ * merges per-channel hits. Optional `summaryDenseScore` / `summarySparseScore`
+ * stage the summary-side channels — pages without those entries fall through
+ * to body-only scoring at fusion time.
  */
 function stageHybridResponse(
-  hits: Array<{ slug: string; denseScore?: number; sparseScore?: number }>,
+  hits: Array<{
+    slug: string;
+    denseScore?: number;
+    sparseScore?: number;
+    summaryDenseScore?: number;
+    summarySparseScore?: number;
+  }>,
 ): void {
   state.queryResponses.dense.push({
     points: hits
@@ -200,6 +212,20 @@ function stageHybridResponse(
       .filter((h) => h.sparseScore !== undefined)
       .map((h) => ({ score: h.sparseScore, payload: { slug: h.slug } })),
   });
+  // The four-channel hybrid query also fires `summary_dense` and
+  // `summary_sparse` queries against the same collection. Tests that don't
+  // care about summary scores leave those channels empty so the fallback
+  // (body-only) path runs.
+  state.queryResponses.dense.push({
+    points: hits
+      .filter((h) => h.summaryDenseScore !== undefined)
+      .map((h) => ({ score: h.summaryDenseScore, payload: { slug: h.slug } })),
+  });
+  state.queryResponses.sparse.push({
+    points: hits
+      .filter((h) => h.summarySparseScore !== undefined)
+      .map((h) => ({ score: h.summarySparseScore, payload: { slug: h.slug } })),
+  });
 }
 
 beforeEach(resetState);
@@ -407,7 +433,7 @@ describe("simBatch", () => {
 
     const out = await simBatch("query", ["dense-only-page"], config);
 
-    // 0.7 * 0.5 + 0.3 * 0 = 0.35
+    // cosine 0.5 (positive, passes through); 0.7 * 0.5 + 0.3 * 0 = 0.35
     expect(out.get("dense-only-page")).toBeCloseTo(0.35, 6);
   });
 
@@ -449,6 +475,7 @@ describe("simBatch", () => {
 
     const out = await simBatch("query", ["alice", "bob"], config);
 
+    // Positive cosines pass through unchanged.
     // alice: 0.4 * 0.5 + 0.6 * 1.0 = 0.8
     // bob:   0.4 * 0.25 + 0.6 * 0.5 = 0.4
     expect(out.get("alice")).toBeCloseTo(0.8, 6);
@@ -468,15 +495,16 @@ describe("simBatch", () => {
     expect(out.get("loud-page")).toBe(1);
   });
 
-  test("forwards the candidate slugs as a Qdrant slug-IN filter", async () => {
+  test("forwards the candidate slugs as a Qdrant slug-IN filter on every channel", async () => {
     const config = configWithWeights(0.7, 0.3);
     stageHybridResponse([]);
 
     await simBatch("query", ["alice", "bob", "carol"], config);
 
-    // Both channels (dense + sparse) ran with the same slug-restriction
-    // filter and the same per-channel limit equal to the candidate count.
-    expect(state.queryCalls).toHaveLength(2);
+    // All four channels (body dense + sparse, summary dense + sparse) ran
+    // with the same slug-restriction filter and the same per-channel limit
+    // equal to the candidate count.
+    expect(state.queryCalls).toHaveLength(4);
     for (const call of state.queryCalls) {
       expect(call.limit).toBe(3);
       expect(call.filter).toEqual({
@@ -496,6 +524,133 @@ describe("simBatch", () => {
     expect(state.sparseCalls).toEqual(["hello world"]);
   });
 
+  test("takes max(body, summary) per slug — summary higher than body wins", async () => {
+    // Body channels return a modest score; summary channels return a much
+    // higher score. The max collapses to the summary score.
+    const config = configWithWeights(1.0, 0.0);
+    stageHybridResponse([
+      {
+        slug: "alice",
+        denseScore: 0.3,
+        summaryDenseScore: 0.7,
+      },
+    ]);
+
+    const out = await simBatch("query", ["alice"], config);
+
+    // Positive cosines pass through unchanged: max(0.3, 0.7) = 0.7.
+    expect(out.get("alice")).toBeCloseTo(0.7, 6);
+  });
+
+  test("takes max(body, summary) per slug — body higher than summary wins", async () => {
+    // Inverse case: body dominates, max stays at body.
+    const config = configWithWeights(1.0, 0.0);
+    stageHybridResponse([
+      {
+        slug: "alice",
+        denseScore: 0.9,
+        summaryDenseScore: 0.4,
+      },
+    ]);
+
+    const out = await simBatch("query", ["alice"], config);
+
+    // Positive cosines pass through unchanged: max(0.9, 0.4) = 0.9.
+    expect(out.get("alice")).toBeCloseTo(0.9, 6);
+  });
+
+  test("falls back to body-only when the page has no summary embedding", async () => {
+    // Pages predating the summary field have no summary_dense/sparse vectors.
+    // Their summary channels return no hits — the max collapses to body.
+    const config = configWithWeights(1.0, 0.0);
+    stageHybridResponse([
+      {
+        slug: "legacy-page",
+        denseScore: 0.6,
+        // summaryDenseScore / summarySparseScore omitted
+      },
+    ]);
+
+    const out = await simBatch("query", ["legacy-page"], config);
+
+    // Positive cosine 0.6 passes through unchanged.
+    expect(out.get("legacy-page")).toBeCloseTo(0.6, 6);
+  });
+
+  test("normalizes body and summary sparse channels independently", async () => {
+    // Summary sparse scores live on a different scale than body sparse —
+    // a small absolute summary-sparse value (1.5) on the only page that
+    // has summary signal still normalizes to 1.0 within the summary
+    // channel, so the summary-only fused score should win out.
+    const config = configWithWeights(0.0, 1.0);
+    stageHybridResponse([
+      {
+        slug: "alice",
+        denseScore: 0.0,
+        sparseScore: 100, // body sparse max in this batch
+      },
+      {
+        slug: "bob",
+        denseScore: 0.0,
+        sparseScore: 0.5, // body sparse normalized = 0.005
+        summaryDenseScore: 0.0,
+        summarySparseScore: 1.5, // summary sparse max in this batch
+      },
+    ]);
+
+    const out = await simBatch("query", ["alice", "bob"], config);
+
+    // Alice has only body. Body sparse normalized to 1.0; sparse_weight=1.0 → 1.0.
+    expect(out.get("alice")).toBeCloseTo(1.0, 6);
+    // Bob's summary side normalizes its 1.5 (only sparse-bearing summary
+    // hit) — a single sparse-bearing hit is below the adaptive-spread
+    // floor, so the channel collapses to base weights and the lone
+    // sparseNormalized=1.0 hit yields a fused summary score of 1.0.
+    // Body side has only bob's tiny sparse=0.5 against the body batch max
+    // of 100 → ~0.005. The max picks the summary side.
+    expect(out.get("bob")).toBeCloseTo(1.0, 6);
+  });
+
+  test("dense-favored config keeps the dense-strong candidate above the sparse-strong one", async () => {
+    // Regression guard: an earlier fix mapped cosines into [0, 1] via
+    // `(cos + 1) / 2` before fusion, which halved every pairwise dense
+    // difference and silently shifted ranking toward sparse. With dense
+    // weighted higher than sparse, the dense-only hit must outrank the
+    // sparse-only hit even though sparse normalizes to 1.0.
+    const config = configWithWeights(0.7, 0.3);
+    stageHybridResponse([
+      { slug: "dense-strong", denseScore: 0.5 /* sparseScore omitted */ },
+      { slug: "sparse-strong", denseScore: 0.0, sparseScore: 1 },
+    ]);
+
+    const out = await simBatch(
+      "query",
+      ["dense-strong", "sparse-strong"],
+      config,
+    );
+
+    // dense-strong: 0.7 * max(0, 0.5) + 0.3 * 0 = 0.35
+    // sparse-strong: 0.7 * max(0, 0.0) + 0.3 * 1.0 = 0.30
+    expect(out.get("dense-strong")).toBeCloseTo(0.35, 6);
+    expect(out.get("sparse-strong")).toBeCloseTo(0.3, 6);
+    expect(out.get("dense-strong")!).toBeGreaterThan(out.get("sparse-strong")!);
+  });
+
+  test("negative cosine maps to a non-negative dense contribution", async () => {
+    // Qdrant cosine search returns scores in [-1, 1]. A near-zero or
+    // negative cosine must not yield a negative dense contribution that
+    // depresses the fused score below the sparse-only floor.
+    const config = configWithWeights(0.7, 0.3);
+    stageHybridResponse([
+      { slug: "anti-match", denseScore: -1.0, sparseScore: 1 },
+    ]);
+
+    const out = await simBatch("query", ["anti-match"], config);
+
+    // cosine -1 → clamped to 0; sparse-norm = 1.0; fused = 0.7*0 + 0.3*1 = 0.3.
+    expect(out.get("anti-match")).toBeCloseTo(0.3, 6);
+  });
+
   test("returned scores are always in [0, 1] for arbitrary inputs", async () => {
     const config = configWithWeights(0.7, 0.3);
     stageHybridResponse([

package/src/memory/v2/__tests__/skill-store.test.ts

@@ -39,11 +39,13 @@ interface UpsertCall {
   dense: number[];
   sparse: { indices: number[]; values: number[] };
   updatedAt: number;
+  kind?: string;
 }
 
 interface PruneCall {
   prefix: string;
   activeSuffixes: readonly string[];
+  options?: { kind?: string };
 }
 
 interface TestState {
@@ -118,8 +120,9 @@ mock.module("../qdrant.js", () => ({
   pruneSlugsWithPrefixExcept: async (
     prefix: string,
     activeSuffixes: readonly string[],
+    options?: { kind?: string },
   ) => {
-    state.pruneCalls.push({ prefix, activeSuffixes });
+    state.pruneCalls.push({ prefix, activeSuffixes, options });
   },
 }));
 
@@ -131,8 +134,12 @@ mock.module("../../../skills/catalog-cache.js", () => ({
 }));
 
 // Imported AFTER all mocks are wired so the module under test sees the stubs.
-const { seedV2SkillEntries, getSkillCapability, _resetSkillStoreForTests } =
-  await import("../skill-store.js");
+const {
+  seedV2SkillEntries,
+  getSkillCapability,
+  listSkillEntries,
+  _resetSkillStoreForTests,
+} = await import("../skill-store.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -467,3 +474,51 @@ describe("getSkillCapability", () => {
     expect(getSkillCapability("does-not-exist")).toBeNull();
   });
 });
+
+describe("listSkillEntries", () => {
+  test("returns [] when the cache is empty (pre-seed)", () => {
+    expect(listSkillEntries()).toEqual([]);
+  });
+
+  test("returns entries sorted by id after seeding", async () => {
+    // Insert in non-sorted order to prove the sort happens on read.
+    const skillB = makeSummary({ id: "example-skill-b" });
+    const skillA = makeSummary({ id: "example-skill-a" });
+    state.catalog = [skillB, skillA];
+    state.resolved = [
+      { summary: skillB, state: "enabled" },
+      { summary: skillA, state: "enabled" },
+    ];
+    state.embedReturn = [
+      [0.1, 0.2, 0.3],
+      [0.4, 0.5, 0.6],
+    ];
+
+    await seedV2SkillEntries();
+
+    const list = listSkillEntries();
+    expect(list).toHaveLength(2);
+    expect(list.map((e) => e.id)).toEqual([
+      "example-skill-a",
+      "example-skill-b",
+    ]);
+  });
+
+  test("mutating the returned array does not affect subsequent calls", async () => {
+    const skillA = makeSummary({ id: "example-skill-a" });
+    state.catalog = [skillA];
+    state.resolved = [{ summary: skillA, state: "enabled" }];
+    state.embedReturn = [[0.1, 0.2, 0.3]];
+
+    await seedV2SkillEntries();
+
+    const first = listSkillEntries();
+    expect(first).toHaveLength(1);
+    first.length = 0;
+    first.push({ id: "injected", content: "junk" });
+
+    const second = listSkillEntries();
+    expect(second).toHaveLength(1);
+    expect(second[0].id).toBe("example-skill-a");
+  });
+});

package/src/memory/v2/__tests__/static-context.test.ts

@@ -1,8 +1,6 @@
 /**
  * Tests for `readMemoryV2StaticContent` — the loader that powers the
- * `memory-v2-static` user-message auto-injection. Mirrors the coverage that
- * lived in the deprecated `system-prompt-memory-v2.test.ts`:
- *   - Returns null when the v2 flag is off.
+ * `memory-v2-static` user-message auto-injection.
  *   - Returns null when `config.memory.v2.enabled` is off.
  *   - Reads the four files in canonical order and joins them under headings.
  *   - Skips empty / missing files.
@@ -47,9 +45,7 @@ mock.module("../../../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
-const { _setOverridesForTesting } =
-  await import("../../../config/assistant-feature-flags.js");
-const { readMemoryV2StaticContent, shouldLoadMemoryV2Static } =
+const { readMemoryV2StaticContent, shouldExposePersonalMemory } =
   await import("../static-context.js");
 
 const MEMORY_FILES = [
@@ -75,18 +71,10 @@ describe("readMemoryV2StaticContent", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
     configMemoryV2Enabled = true;
-    _setOverridesForTesting({ "memory-v2-enabled": true });
   });
 
   afterEach(() => {
     cleanupMemoryDir();
-    _setOverridesForTesting({});
-  });
-
-  test("returns null when the feature flag is off", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    for (const file of MEMORY_FILES) writeMemoryFile(file, `Content ${file}`);
-    expect(readMemoryV2StaticContent()).toBeNull();
   });
 
   test("returns null when config.memory.v2.enabled is off", () => {
@@ -152,21 +140,10 @@ describe("readMemoryV2StaticContent", () => {
   });
 });
 
-describe("shouldLoadMemoryV2Static", () => {
-  test("blocks all turns until the cadence gate fires", () => {
-    expect(
-      shouldLoadMemoryV2Static({
-        shouldInjectNowAndPkb: false,
-        sourceChannel: "vellum",
-        isTrustedActor: true,
-      }),
-    ).toBe(false);
-  });
-
+describe("shouldExposePersonalMemory", () => {
   test("allows guardian-trusted local conversations", () => {
     expect(
-      shouldLoadMemoryV2Static({
-        shouldInjectNowAndPkb: true,
+      shouldExposePersonalMemory({
         sourceChannel: "vellum",
         isTrustedActor: true,
       }),
@@ -175,8 +152,7 @@ describe("shouldLoadMemoryV2Static", () => {
 
   test("allows local-channel conversations even when trust class is unknown (analyze runs, dev)", () => {
     expect(
-      shouldLoadMemoryV2Static({
-        shouldInjectNowAndPkb: true,
+      shouldExposePersonalMemory({
         sourceChannel: "vellum",
         isTrustedActor: false,
       }),
@@ -185,8 +161,7 @@ describe("shouldLoadMemoryV2Static", () => {
 
   test("allows turns with no trust context (work-item task runs, internal background)", () => {
     expect(
-      shouldLoadMemoryV2Static({
-        shouldInjectNowAndPkb: true,
+      shouldExposePersonalMemory({
         sourceChannel: undefined,
         isTrustedActor: false,
       }),
@@ -204,8 +179,7 @@ describe("shouldLoadMemoryV2Static", () => {
   test("allows guardian-trusted remote channels (user's own phone/Slack)", () => {
     for (const channel of REMOTE_CHANNELS) {
       expect(
-        shouldLoadMemoryV2Static({
-          shouldInjectNowAndPkb: true,
+        shouldExposePersonalMemory({
           sourceChannel: channel,
           isTrustedActor: true,
         }),
@@ -216,8 +190,7 @@ describe("shouldLoadMemoryV2Static", () => {
   test("blocks non-guardian remote-channel actors (the leak this gate exists to prevent)", () => {
     for (const channel of REMOTE_CHANNELS) {
       expect(
-        shouldLoadMemoryV2Static({
-          shouldInjectNowAndPkb: true,
+        shouldExposePersonalMemory({
           sourceChannel: channel,
           isTrustedActor: false,
         }),

package/src/memory/v2/__tests__/sweep-job.test.ts

@@ -1,10 +1,11 @@
 /**
  * Tests for `assistant/src/memory/v2/sweep-job.ts`.
  *
- * Coverage matrix (from PR 18 acceptance criteria):
- *   - Flag off → no provider/DB calls, returns 0 (early bail).
- *   - Flag on + no recent messages → no provider call, returns 0.
- *   - Flag on + recent messages → provider invoked with rendered prompt;
+ * Coverage matrix:
+ *   - v2 disabled in config → no provider/DB calls, returns 0 (early bail).
+ *   - sweep_enabled off → no provider call, returns 0.
+ *   - v2 on + no recent messages → no provider call, returns 0.
+ *   - v2 on + recent messages → provider invoked with rendered prompt;
  *     each entry is appended to `memory/buffer.md` AND today's archive.
  *   - Tool-call response shape mismatch → returns 0 without writes.
  *   - Empty entries are skipped (the model can't pad the buffer).
@@ -24,7 +25,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -62,6 +62,23 @@ mock.module("../../../providers/provider-send-message.js", () => ({
     response.content.find((b): b is ToolUseContent => b.type === "tool_use"),
 }));
 
+// emitNotificationSignal spy — captures every notification the sweep emits
+// so the failure-path test can assert on `activity.failed` shape and dedupe.
+const emitCalls: Array<Record<string, unknown>> = [];
+
+mock.module("../../../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async (params: Record<string, unknown>) => {
+    emitCalls.push(params);
+    return {
+      signalId: "sig-1",
+      deduplicated: false,
+      dispatched: true,
+      reason: "ok",
+      deliveryResults: [],
+    };
+  },
+}));
+
 // Workspace setup — temp dir per test run, pinned via VELLUM_WORKSPACE_DIR
 // so `getWorkspaceDir()` resolves to the tmpdir.
 let tmpWorkspace: string;
@@ -85,23 +102,20 @@ afterAll(() => {
 const { resetDb, getDb } = await import("../../db-connection.js");
 const { initializeDb } = await import("../../db-init.js");
 const { messages, conversations } = await import("../../schema.js");
-const { _setOverridesForTesting } =
-  await import("../../../config/assistant-feature-flags.js");
 const { memoryV2SweepJob } = await import("../sweep-job.js");
 
-// `isAssistantFeatureFlagEnabled` ignores the `config` argument it receives
-// (resolution is purely from the overrides + registry caches), so we hand
-// the handler a minimal stand-in instead of materializing the full default
+// The handler reads `config.memory.v2.enabled` and `sweep_enabled`, so we
+// hand it a minimal stand-in instead of materializing the full default
 // config — which would otherwise pull in heavy schemas this test doesn't
-// exercise. The handler reads `config.memory.v2.sweep_enabled`, so the
-// `flag on` cases need the field set; the `flag off` case bails before
-// the check and uses the bare empty stand-in.
+// exercise.
 const CONFIG = {
-  memory: { v2: { sweep_enabled: true } },
+  memory: { v2: { enabled: true, sweep_enabled: true } },
+} as Parameters<typeof memoryV2SweepJob>[1];
+const CONFIG_V2_OFF = {
+  memory: { v2: { enabled: false, sweep_enabled: true } },
 } as Parameters<typeof memoryV2SweepJob>[1];
-const CONFIG_FLAG_OFF = {} as Parameters<typeof memoryV2SweepJob>[1];
 const CONFIG_SWEEP_OFF = {
-  memory: { v2: { sweep_enabled: false } },
+  memory: { v2: { enabled: true, sweep_enabled: false } },
 } as Parameters<typeof memoryV2SweepJob>[1];
 
 function makeJob(): Parameters<typeof memoryV2SweepJob>[0] {
@@ -169,6 +183,7 @@ function extractFirstUserText(msgs: { content: unknown }[]): string {
 function seedMessages(
   conversationId: string,
   rows: Array<{ role: string; content: string; offsetMs: number }>,
+  conversationType: "standard" | "background" | "scheduled" = "standard",
 ): void {
   const db = getDb();
   const now = Date.now();
@@ -178,6 +193,7 @@ function seedMessages(
       title: null,
       createdAt: now - 60_000,
       updatedAt: now,
+      conversationType,
     })
     .run();
   for (let i = 0; i < rows.length; i++) {
@@ -203,20 +219,16 @@ beforeEach(() => {
   mkdirSync(join(tmpWorkspace, "memory"), { recursive: true });
   providerCalls.length = 0;
   providerStub = null;
-});
-
-afterEach(() => {
-  _setOverridesForTesting({});
+  emitCalls.length = 0;
 });
 
 // ---------------------------------------------------------------------------
 
-describe("memoryV2SweepJob — flag off", () => {
-  test("returns 0 without invoking the provider when flag is off", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
+describe("memoryV2SweepJob — v2 disabled", () => {
+  test("returns 0 without invoking the provider when memory.v2.enabled is false", async () => {
     providerStub = makeEntriesProvider(["should-not-be-written"]);
 
-    const written = await memoryV2SweepJob(makeJob(), CONFIG_FLAG_OFF);
+    const written = await memoryV2SweepJob(makeJob(), CONFIG_V2_OFF);
 
     expect(written).toBe(0);
     expect(providerCalls).toHaveLength(0);
@@ -224,9 +236,8 @@ describe("memoryV2SweepJob — flag off", () => {
   });
 });
 
-describe("memoryV2SweepJob — flag on, sweep_enabled off", () => {
+describe("memoryV2SweepJob — sweep_enabled off", () => {
   test("returns 0 without invoking the provider when sweep_enabled is false", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     // No message seeding required — the sweep_enabled bail short-circuits
     // before any DB or workspace reads.
     providerStub = makeEntriesProvider(["should-not-be-written"]);
@@ -239,11 +250,7 @@ describe("memoryV2SweepJob — flag on, sweep_enabled off", () => {
   });
 });
 
-describe("memoryV2SweepJob — flag on, no recent messages", () => {
-  beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-  });
-
+describe("memoryV2SweepJob — no recent messages", () => {
   test("returns 0 when no messages exist in the recent window", async () => {
     providerStub = makeEntriesProvider(["should-not-be-written"]);
 
@@ -273,9 +280,8 @@ describe("memoryV2SweepJob — flag on, no recent messages", () => {
 // DB intact long enough for the SQL inserts here to clash.
 let convCounter = 0;
 
-describe("memoryV2SweepJob — flag on, recent messages", () => {
+describe("memoryV2SweepJob — recent messages", () => {
   beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     seedMessages(`conv-${++convCounter}`, [
       {
         role: "user",
@@ -431,6 +437,81 @@ describe("memoryV2SweepJob — flag on, recent messages", () => {
 
     expect(written).toBe(0);
   });
+
+  test("emits an activity.failed notification when provider.sendMessage throws", async () => {
+    // Simulate a transient provider failure once we're past the early
+    // bail checks. The sweep must (a) preserve the existing silent-failure
+    // contract by returning 0, and (b) surface the failure via the
+    // centralized notifications pipeline so the user sees it instead of
+    // the failure being silently swallowed.
+    providerStub = {
+      name: "stub",
+      sendMessage: async () => {
+        throw new Error("simulated provider failure");
+      },
+    };
+
+    const written = await memoryV2SweepJob(makeJob(), CONFIG);
+
+    expect(written).toBe(0);
+    expect(emitCalls).toHaveLength(1);
+    const emitted = emitCalls[0]!;
+    expect(emitted.sourceEventName).toBe("activity.failed");
+    expect(emitted.sourceChannel).toBe("scheduler");
+    const day = new Date().toISOString().slice(0, 10);
+    expect(emitted.dedupeKey).toBe(`activity-failed:memory.v2.sweep:${day}`);
+    const contextPayload = emitted.contextPayload as Record<string, unknown>;
+    expect(contextPayload.jobName).toBe("memory.v2.sweep");
+    expect(contextPayload.errorKind).toBe("exception");
+    expect(contextPayload.errorMessage).toContain("simulated provider failure");
+  });
+});
+
+describe("memoryV2SweepJob — background/scheduled conversation filter", () => {
+  test("excludes background/scheduled conversation content from sweep input", async () => {
+    seedMessages(
+      `conv-bg-${++convCounter}`,
+      [
+        {
+          role: "assistant",
+          content:
+            "[heartbeat] internal automation chatter that should not leak",
+          offsetMs: -60_000,
+        },
+      ],
+      "background",
+    );
+    seedMessages(
+      `conv-sched-${++convCounter}`,
+      [
+        {
+          role: "assistant",
+          content:
+            "[scheduled] scheduled-job chatter that should not leak either",
+          offsetMs: -45_000,
+        },
+      ],
+      "scheduled",
+    );
+    seedMessages(`conv-user-${++convCounter}`, [
+      {
+        role: "user",
+        content: "Bob mentioned he prefers dark mode.",
+        offsetMs: -30_000,
+      },
+    ]);
+
+    providerStub = makeEntriesProvider(["Bob prefers dark mode."]);
+
+    const written = await memoryV2SweepJob(makeJob(), CONFIG);
+
+    expect(written).toBe(1);
+    expect(providerCalls).toHaveLength(1);
+    const [{ userText }] = providerCalls;
+    expect(userText).toContain("Bob mentioned he prefers dark mode.");
+    expect(userText).not.toContain("internal automation chatter");
+    expect(userText).not.toContain("scheduled-job chatter");
+  });
 });
 
 function todaysArchiveBasename(now: Date = new Date()): string {