recallnest 1.4.1

package/src/__tests__/context-renderer.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "bun:test";
+
+import { computeTermOverlap, extractTerms, renderMemories, type RenderableMemory } from "../context-renderer.js";
+
+const MEMORIES: RenderableMemory[] = [
+  { id: "a", text: "I prefer TypeScript for all projects", score: 0.8, category: "preferences" },
+  { id: "b", text: "Docker deployment pipeline for RecallNest", score: 0.75, category: "patterns" },
+  { id: "c", text: "Fixed a LanceDB indexing bug yesterday", score: 0.9, category: "cases" },
+];
+
+describe("extractTerms", () => {
+  it("removes stop words and short words", () => {
+    const terms = extractTerms("The quick brown fox is a great animal");
+    expect(terms.has("the")).toBe(false);
+    expect(terms.has("is")).toBe(false);
+    expect(terms.has("a")).toBe(false);
+    expect(terms.has("quick")).toBe(true);
+    expect(terms.has("brown")).toBe(true);
+  });
+
+  it("handles CJK text", () => {
+    const terms = extractTerms("我喜欢用 TypeScript 写代码");
+    expect(terms.has("typescript")).toBe(true);
+  });
+
+  it("lowercases all terms", () => {
+    const terms = extractTerms("TypeScript Docker LanceDB");
+    expect(terms.has("typescript")).toBe(true);
+    expect(terms.has("docker")).toBe(true);
+  });
+});
+
+describe("computeTermOverlap", () => {
+  it("returns 0 for empty sets", () => {
+    expect(computeTermOverlap(new Set(), new Set(["a"]))).toBe(0);
+    expect(computeTermOverlap(new Set(["a"]), new Set())).toBe(0);
+  });
+
+  it("returns 1 for identical sets", () => {
+    const s = new Set(["typescript", "docker"]);
+    expect(computeTermOverlap(s, s)).toBe(1);
+  });
+
+  it("returns partial overlap correctly", () => {
+    const a = new Set(["typescript", "docker", "lancedb"]);
+    const b = new Set(["typescript", "lancedb", "react"]);
+    // overlap=2, max(3,3)=3 → 2/3 ≈ 0.667
+    expect(computeTermOverlap(a, b)).toBeCloseTo(0.667, 2);
+  });
+});
+
+describe("renderMemories", () => {
+  it("verbatim mode preserves original order", () => {
+    const result = renderMemories(MEMORIES, "anything");
+    expect(result.mode).toBe("verbatim");
+    expect(result.memories.map(m => m.id)).toEqual(["a", "b", "c"]);
+    expect(result.memories[0].relevance).toBe(0.8);
+  });
+
+  it("highlight mode reorders by contextual relevance", () => {
+    const result = renderMemories(MEMORIES, "LanceDB indexing bug fix", "highlight");
+    expect(result.mode).toBe("highlight");
+    // Memory "c" should rank highest because it has strong term overlap with query
+    expect(result.memories[0].id).toBe("c");
+  });
+
+  it("highlight mode uses taskContext for scoring", () => {
+    const result = renderMemories(MEMORIES, "deployment", "highlight", "Docker pipeline");
+    // Memory "b" should rank high due to Docker + deployment + pipeline overlap
+    expect(result.memories[0].id).toBe("b");
+  });
+
+  it("synthesize mode processes memories", () => {
+    const result = renderMemories(MEMORIES, "TypeScript preferences", "synthesize");
+    expect(result.mode).toBe("synthesize");
+    expect(result.memories.length).toBe(3);
+  });
+
+  it("returns empty for empty input", () => {
+    const result = renderMemories([], "query", "highlight");
+    expect(result.memories.length).toBe(0);
+  });
+
+  it("relevance scores are rounded to 3 decimals in highlight mode", () => {
+    const result = renderMemories(MEMORIES, "test query", "highlight");
+    for (const m of result.memories) {
+      const decimals = String(m.relevance).split(".")[1]?.length ?? 0;
+      expect(decimals).toBeLessThanOrEqual(3);
+    }
+  });
+});

package/src/__tests__/continuity-eval.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, it } from "bun:test";
+
+import { buildContinuityEvalObservationInput, buildContinuityEvalRequest, createContinuityEvalCheckpointStore, runContinuityEval, runRetrievalEval, scoreContinuityCase } from "../eval.js";
+import type { ResumeContextResponse } from "../session-schema.js";
+
+describe("scoreContinuityCase", () => {
+  it("forwards profile and continuity fields into resume_context eval requests", () => {
+    expect(buildContinuityEvalRequest({
+      name: "writing_sparse",
+      task: "不要让我重复前情，接着写",
+      profile: "writing",
+      scope: "project:recallnest",
+      sessionId: "session-1",
+      limitPerSection: 4,
+      includeLatestCheckpoint: true,
+    })).toEqual({
+      task: "不要让我重复前情，接着写",
+      scope: "project:recallnest",
+      sessionId: "session-1",
+      profile: "writing",
+      limitPerSection: 4,
+      includeLatestCheckpoint: true,
+    });
+  });
+
+  it("falls back to the case checkpoint sessionId when the eval case omits top-level sessionId", () => {
+    expect(buildContinuityEvalRequest({
+      name: "project_scope_checkpoint_continuity",
+      task: "继续这个项目，不要让我重复前情",
+      profile: "default",
+      scope: "project:recallnest",
+      includeLatestCheckpoint: true,
+      checkpoint: {
+        sessionId: "eval-project-recallnest-checkpoint",
+        scope: "project:recallnest",
+        summary: "RecallNest continuity acceptance checkpoint fixture.",
+      },
+    })).toEqual({
+      task: "继续这个项目，不要让我重复前情",
+      scope: "project:recallnest",
+      sessionId: "eval-project-recallnest-checkpoint",
+      profile: "default",
+      limitPerSection: undefined,
+      includeLatestCheckpoint: true,
+    });
+  });
+
+  it("scores a continuity response using section-specific expectations", () => {
+    const response: ResumeContextResponse = {
+      summary: "Loaded stable context with a latest checkpoint for RecallNest continuity work.",
+      stableContext: [
+        "Preference: User prefers concise technical replies.",
+        "Entity: RecallNest is shared across Claude Code, Codex, and Gemini CLI.",
+      ],
+      relevantPatterns: [
+        "At task start, run search_memory before coding.",
+      ],
+      recentCases: [
+        "Keep session state in a checkpoint store instead of the durable index.",
+      ],
+      latestCheckpoint: {
+        sessionId: "session-1",
+        summary: "Continue building resume_context for fresh windows",
+        updatedAt: "2026-03-16T06:00:00.000Z",
+      },
+      generatedAt: "2026-03-16T06:05:00.000Z",
+    };
+
+    const report = scoreContinuityCase({
+      name: "continuity_case",
+      task: "continue RecallNest work",
+      expectStableAny: ["RecallNest", "Codex"],
+      expectPatternsAny: ["search_memory"],
+      expectCasesAny: ["checkpoint store"],
+      expectCheckpointAny: ["resume_context"],
+    }, response);
+
+    expect(report.passed).toBe(true);
+    expect(report.matchedStableAny).toEqual(["RecallNest", "Codex"]);
+    expect(report.matchedPatternsAny).toEqual(["search_memory"]);
+    expect(report.matchedCasesAny).toEqual(["checkpoint store"]);
+    expect(report.matchedCheckpointAny).toEqual(["resume_context"]);
+    expect(report.hasCheckpoint).toBe(true);
+    expect(report.score).toBeGreaterThan(0.9);
+  });
+
+  it("penalizes forbidden matches", () => {
+    const response: ResumeContextResponse = {
+      summary: "Loaded unrelated stable context.",
+      stableContext: ["Profile: unrelated memory"],
+      relevantPatterns: [],
+      recentCases: [],
+      generatedAt: "2026-03-16T06:10:00.000Z",
+    };
+
+    const report = scoreContinuityCase({
+      name: "continuity_forbid",
+      task: "fresh window",
+      forbid: ["unrelated"],
+    }, response);
+
+    expect(report.passed).toBe(false);
+    expect(report.forbiddenMatches).toEqual(["unrelated"]);
+    expect(report.score).toBeLessThan(0.8);
+  });
+
+  it("uses only case-defined checkpoint fixtures instead of live checkpoint state", async () => {
+    const checkpointStore = createContinuityEvalCheckpointStore([
+      {
+        name: "checkpoint_case",
+        scope: "recallnest",
+        includeLatestCheckpoint: true,
+        checkpoint: {
+          sessionId: "eval-session-1",
+          scope: "recallnest",
+          summary: "RecallNest Phase 3/4 checkpoint fixture with resume_context and store_memory.",
+          task: "Continue RecallNest continuity work",
+          decisions: ["Keep checkpoints out of the durable index"],
+          updatedAt: "2026-03-16T06:00:00.000Z",
+        },
+      },
+    ]);
+
+    const byScope = await checkpointStore.getLatest({ scope: "recallnest" });
+    const bySession = await checkpointStore.getLatest({ sessionId: "eval-session-1" });
+    const missing = await checkpointStore.getLatest({ scope: "other-project" });
+
+    expect(byScope).toMatchObject({
+      sessionId: "eval-session-1",
+      resolvedScope: "project:recallnest",
+      summary: "RecallNest Phase 3/4 checkpoint fixture with resume_context and store_memory.",
+    });
+    expect(bySession?.resolvedScope).toBe("project:recallnest");
+    expect(missing).toBeNull();
+  });
+
+  it("builds workflow observations for continuity eval results without using regular memory", () => {
+    const passed = buildContinuityEvalObservationInput({
+      name: "continuity_pass",
+      profile: "debug",
+      scope: "project:recallnest",
+    }, {
+      mode: "continuity",
+      name: "continuity_pass",
+      task: "continue RecallNest work",
+      profile: "debug",
+      score: 0.94,
+      passed: true,
+      stableCount: 2,
+      patternCount: 1,
+      caseCount: 1,
+      hasCheckpoint: true,
+      matchedStableAny: [],
+      matchedStableAll: [],
+      matchedPatternsAny: [],
+      matchedCasesAny: [],
+      matchedCheckpointAny: [],
+      forbiddenMatches: [],
+      stablePreview: [],
+      patternPreview: [],
+      casePreview: [],
+      checkpointSummary: "ok",
+    });
+
+    expect(passed).toMatchObject({
+      workflowId: "resume_context",
+      outcome: "success",
+      scope: "project:recallnest",
+      source: "eval",
+      signal: "eval-pass",
+      task: "continuity eval: continuity_pass",
+      tools: ["resume_context"],
+    });
+
+    const failed = buildContinuityEvalObservationInput({
+      name: "continuity_fail",
+      expectPatternsAny: ["search_memory"],
+      expectCheckpointAny: ["checkpoint"],
+    }, {
+      mode: "continuity",
+      name: "continuity_fail",
+      task: "continue",
+      profile: "default",
+      score: 0.42,
+      passed: false,
+      stableCount: 0,
+      patternCount: 0,
+      caseCount: 0,
+      hasCheckpoint: false,
+      matchedStableAny: [],
+      matchedStableAll: [],
+      matchedPatternsAny: [],
+      matchedCasesAny: [],
+      matchedCheckpointAny: [],
+      forbiddenMatches: [],
+      stablePreview: [],
+      patternPreview: [],
+      casePreview: [],
+      checkpointSummary: "-",
+    }, {
+      scope: "eval:continuity",
+      source: "eval",
+    });
+
+    expect(failed).toMatchObject({
+      workflowId: "resume_context",
+      outcome: "failure",
+      scope: "eval:continuity",
+      source: "eval",
+      signal: "missing-patterns",
+      task: "continuity eval: continuity_fail",
+      tools: ["resume_context"],
+    });
+    expect(failed.summary).toContain("failed");
+  });
+
+  it("creates fresh continuity eval components for each case instead of sharing one resolver", async () => {
+    let componentCreations = 0;
+
+    const reports = await runContinuityEval([
+      { name: "case-a", task: "continue A" },
+      { name: "case-b", task: "continue B" },
+    ], {}, {
+      createEvalComponents: () => {
+        componentCreations += 1;
+        const instanceId = componentCreations;
+        return {
+          retriever: {
+            instanceId,
+            async retrieve() {
+              return [];
+            },
+          } as never,
+          accessTracker: {
+            destroy() {},
+          } as never,
+        };
+      },
+      composeResumeContextFn: async (deps) => ({
+        summary: `instance:${(deps.retriever as { instanceId: number }).instanceId}`,
+        stableContext: [`instance:${(deps.retriever as { instanceId: number }).instanceId}`],
+        relevantPatterns: [],
+        recentCases: [],
+        generatedAt: "2026-03-20T00:00:00.000Z",
+      }),
+    });
+
+    expect(componentCreations).toBe(2);
+    expect(reports[0]?.stablePreview[0]).toContain("instance:1");
+    expect(reports[1]?.stablePreview[0]).toContain("instance:2");
+  });
+
+  it("runs retrieval eval in auto-recall mode so eval does not reinforce access counts", async () => {
+    const seenSources: string[] = [];
+
+    const reports = await runRetrievalEval([
+      { name: "retrieval_case", query: "RecallNest" },
+    ], {
+      createEvalComponents: () => ({
+        retriever: {
+          async retrieve(context) {
+            seenSources.push(context.source || "unset");
+            return [];
+          },
+        } as never,
+        accessTracker: {
+          destroy() {},
+        } as never,
+      }),
+    });
+
+    expect(seenSources).toEqual(["auto-recall"]);
+    expect(reports).toHaveLength(1);
+  });
+});

package/src/__tests__/continuity-schema.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "bun:test";
+
+import { PromoteMemoryInputSchema, StoreMemoryInputSchema } from "../memory-schema.js";
+import { ResumeContextRequestSchema, ResumeContextResponseSchema, SessionCheckpointInputSchema } from "../session-schema.js";
+
+describe("StoreMemoryInputSchema", () => {
+  it("normalizes whitespace, defaults, and deduplicates tags", () => {
+    const parsed = StoreMemoryInputSchema.parse({
+      text: "  User prefers   dark mode  ",
+      category: "preferences",
+      scope: "project:test",
+      tags: [" ui ", "UI", "frontend"],
+      canonicalKey: " user.reply.style ",
+    });
+
+    expect(parsed.text).toBe("User prefers dark mode");
+    expect(parsed.importance).toBe(0.7);
+    expect(parsed.source).toBe("manual");
+    expect(parsed.tags).toEqual(["ui", "frontend"]);
+    expect(parsed.canonicalKey).toBe("user.reply.style");
+  });
+
+  it("rejects unsupported categories", () => {
+    expect(() => StoreMemoryInputSchema.parse({
+      text: "Persist this",
+      category: "decision",
+    })).toThrow();
+  });
+});
+
+describe("PromoteMemoryInputSchema", () => {
+  it("applies defaults for evidence promotion", () => {
+    const parsed = PromoteMemoryInputSchema.parse({
+      memoryId: "12345678-1234-1234-1234-123456789abc",
+      scope: "project:test",
+    });
+
+    expect(parsed.importance).toBe(0.78);
+    expect(parsed.source).toBe("agent");
+    expect(parsed.tags).toEqual([]);
+  });
+});
+
+describe("SessionCheckpointInputSchema", () => {
+  it("defaults updatedAt and deduplicates list fields", () => {
+    const parsed = SessionCheckpointInputSchema.parse({
+      sessionId: "session-123",
+      summary: "  Working on continuity layer  ",
+      decisions: ["Use session checkpoints", "use session checkpoints"],
+      nextActions: ["Add MCP store_memory", " Add MCP store_memory "],
+    });
+
+    expect(parsed.summary).toBe("Working on continuity layer");
+    expect(parsed.decisions).toEqual(["Use session checkpoints"]);
+    expect(parsed.nextActions).toEqual(["Add MCP store_memory"]);
+    expect(parsed.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+});
+
+describe("ResumeContext schemas", () => {
+  it("applies defaults for request parsing", () => {
+    const parsed = ResumeContextRequestSchema.parse({});
+
+    expect(parsed.limitPerSection).toBe(3);
+    expect(parsed.includeLatestCheckpoint).toBe(true);
+    expect(parsed.profile).toBeUndefined();
+  });
+
+  it("preserves optional retrieval profile on request parsing", () => {
+    const parsed = ResumeContextRequestSchema.parse({
+      profile: "writing",
+    });
+
+    expect(parsed.profile).toBe("writing");
+  });
+
+  it("accepts a composed response payload", () => {
+    const parsed = ResumeContextResponseSchema.parse({
+      summary: "Bring forward user identity, recent cases, and the latest checkpoint.",
+      resolvedScope: "project:recallnest",
+      stableContext: ["User works across Claude Code, Codex, and Gemini CLI"],
+      relevantPatterns: ["Always search memory at task start"],
+      recentCases: ["Fixed hybrid retrieval tuning last week"],
+      latestCheckpoint: {
+        sessionId: "session-123",
+        resolvedScope: "project:recallnest",
+        summary: "Implement schema modules first",
+        updatedAt: "2026-03-16T01:41:00.000Z",
+      },
+      generatedAt: "2026-03-16T01:42:00.000Z",
+    });
+
+    expect(parsed.latestCheckpoint?.sessionId).toBe("session-123");
+    expect(parsed.resolvedScope).toBe("project:recallnest");
+    expect(parsed.stableContext).toHaveLength(1);
+  });
+});

package/src/__tests__/core-recall-eval.test.ts

@@ -0,0 +1,235 @@
+import { describe, expect, it } from "bun:test";
+
+import { promoteMemory } from "../capture-engine.js";
+import { createRetriever } from "../retriever.js";
+import { buildRetrievalContext, matchesScopeFilter } from "../scope-policy.js";
+
+function cosineSimilarity(a: number[], b: number[]): number {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+function createCoreRetriever(entries: Array<{
+  id: string;
+  text: string;
+  scope: string;
+  category?: "entities" | "events";
+  vector: number[];
+}>) {
+  return createRetriever({
+    hasFtsSupport: false,
+    async vectorSearch(queryVector: number[], limit = 5, minScore = 0, scopeFilter?: string[]) {
+      return entries
+        .filter((entry) => matchesScopeFilter(entry.scope, scopeFilter))
+        .map((entry) => ({
+          entry: {
+            id: entry.id,
+            text: entry.text,
+            vector: entry.vector,
+            category: entry.category || "entities",
+            scope: entry.scope,
+            importance: 0.8,
+            timestamp: Date.parse("2026-03-17T00:00:00.000Z"),
+            metadata: "{}",
+          },
+          score: cosineSimilarity(queryVector, entry.vector),
+        }))
+        .filter((result) => result.score >= minScore)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    },
+  } as any, {
+    async embedQuery(query: string) {
+      if (/衰减|公式|曲线|weibull/i.test(query)) return [1, 0, 0];
+      if (/部署|deploy|region|在哪/i.test(query)) return [0, 1, 0];
+      return [0, 0, 1];
+    },
+    async embedPassage() {
+      return [0, 0, 1];
+    },
+  } as any, {
+    mode: "vector",
+    rerank: "none",
+    filterNoise: false,
+    hardMinScore: 0,
+    minScore: 0,
+    recencyWeight: 0,
+    timeDecayHalfLifeDays: 0,
+  });
+}
+
+function createCaptureDeps() {
+  const storedEntries: any[] = [];
+  let seq = 1;
+
+  return {
+    storedEntries,
+    deps: {
+      embedder: {
+        async embedPassage(text: string) {
+          return [text.length, 1, 0];
+        },
+      },
+      store: {
+        async store(entry: any) {
+          const stored = {
+            ...entry,
+            id: `00000000-0000-0000-0000-${String(seq).padStart(12, "0")}`,
+            timestamp: 1_700_000_000_000 + seq,
+          };
+          seq += 1;
+          storedEntries.push(stored);
+          return stored;
+        },
+        async list(_scopeFilter?: string[], category?: string, limit = 20, offset = 0) {
+          return storedEntries
+            .filter((entry) => !category || entry.category === category)
+            .slice(offset, offset + limit);
+        },
+        async update(id: string, updates: any) {
+          const index = storedEntries.findIndex((entry) => entry.id === id);
+          if (index < 0) return null;
+          storedEntries[index] = {
+            ...storedEntries[index],
+            ...updates,
+            timestamp: updates.timestamp ?? storedEntries[index].timestamp,
+          };
+          return storedEntries[index];
+        },
+        async get(id: string) {
+          return storedEntries.find((entry) => entry.id === id) || null;
+        },
+        async getById(id: string) {
+          return storedEntries.find((entry) => entry.id === id) || null;
+        },
+      },
+      conflictStore: {
+        async save(record: any) {
+          return record;
+        },
+        async replace(record: any) {
+          return record;
+        },
+        async getOpenByFingerprint() {
+          return null;
+        },
+        async getLatestByFingerprint() {
+          return null;
+        },
+      },
+    },
+  };
+}
+
+describe("core recall eval", () => {
+  it("hits the right memory for a vague associative query within the target scope", async () => {
+    const retriever = createCoreRetriever([
+      {
+        id: "alpha-weibull",
+        text: "RecallNest uses Weibull decay with beta=0.8 for the core tier.",
+        scope: "project:alpha",
+        vector: [1, 0, 0],
+      },
+      {
+        id: "alpha-entity",
+        text: "RecallNest exposes checkpoint_session and resume_context.",
+        scope: "project:alpha",
+        vector: [0, 0, 1],
+      },
+      {
+        id: "beta-deploy",
+        text: "Project beta deploys in us-east-1.",
+        scope: "project:beta",
+        vector: [0, 1, 0],
+      },
+    ]);
+
+    const results = await retriever.retrieve(buildRetrievalContext({
+      query: "那个衰减曲线用的什么公式来着",
+      limit: 5,
+      scope: "project:alpha",
+    }, {
+      operation: "test:associative-recall",
+    }));
+
+    expect(results[0]?.entry.id).toBe("alpha-weibull");
+    expect(results.every((result) => result.entry.scope === "project:alpha")).toBe(true);
+  });
+
+  it("does not leak results from another scope when default scope is inferred", async () => {
+    const retriever = createCoreRetriever([
+      {
+        id: "alpha-note",
+        text: "Project alpha stores its API key outside the memory index.",
+        scope: "project:alpha",
+        vector: [0, 0, 1],
+      },
+      {
+        id: "beta-deploy",
+        text: "Project beta deploys in us-east-1.",
+        scope: "project:beta",
+        vector: [0, 1, 0],
+      },
+    ]);
+
+    const results = await retriever.retrieve(buildRetrievalContext({
+      query: "部署在哪",
+      limit: 5,
+    }, {
+      operation: "test:scope-isolation",
+      env: {
+        RECALLNEST_DEFAULT_SCOPE: "project:alpha",
+      } as NodeJS.ProcessEnv,
+    }));
+
+    expect(results.some((result) => result.entry.id === "beta-deploy")).toBe(false);
+    expect(results.every((result) => result.entry.scope === "project:alpha")).toBe(true);
+  });
+
+  it("preserves text and provenance when promoting evidence into durable memory", async () => {
+    const { deps, storedEntries } = createCaptureDeps();
+    const source = await deps.store.store({
+      text: "RecallNest uses Weibull decay with beta=0.8 for the core tier.",
+      vector: [1, 0, 0],
+      category: "events",
+      scope: "cc:session-alpha",
+      importance: 0.5,
+      metadata: JSON.stringify({
+        source: "cc",
+        boundary: {
+          layer: "evidence",
+          authority: "transcript-ingest",
+          conflictPolicy: "append-only",
+          originalCategory: "entities",
+        },
+      }),
+    });
+
+    const promoted = await promoteMemory(deps as any, {
+      memoryId: source.id,
+      category: "entities",
+      scope: "project:alpha",
+      source: "agent",
+      tags: ["core-eval"],
+    });
+
+    expect(promoted.text).toBe("RecallNest uses Weibull decay with beta=0.8 for the core tier.");
+    expect(promoted.resolvedScope).toBe("project:alpha");
+    expect(storedEntries[1]?.text).toBe("RecallNest uses Weibull decay with beta=0.8 for the core tier.");
+    expect(JSON.parse(storedEntries[1]?.metadata || "{}")).toMatchObject({
+      promotedFrom: {
+        memoryId: source.id,
+        scope: "cc:session-alpha",
+        category: "events",
+      },
+    });
+  });
+});