recallnest 1.4.1 → 2.2.1

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

@@ -1,91 +0,0 @@
-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

@@ -1,275 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,235 +0,0 @@
-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",
-      },
-    });
-  });
-});