recallnest 2.2.0 → 2.2.1

package/src/__tests__/multi-vector.test.ts

@@ -1,242 +0,0 @@
-import { describe, expect, it, beforeEach, afterEach } from "bun:test";
-
-import {
-  blendMultiVectorScores,
-  cosineSimilarity,
-  DEFAULT_BLEND_CONFIG,
-  embedMultiVector,
-  extractMultiVectorText,
-  isMultiVectorEnabled,
-  tokenize,
-  textOverlapScore,
-  adaptiveBlendConfig,
-} from "../multi-vector.js";
-
-describe("isMultiVectorEnabled", () => {
-  const original = process.env.RECALLNEST_MULTI_VECTOR;
-
-  afterEach(() => {
-    if (original === undefined) {
-      delete process.env.RECALLNEST_MULTI_VECTOR;
-    } else {
-      process.env.RECALLNEST_MULTI_VECTOR = original;
-    }
-  });
-
-  it("returns false by default", () => {
-    delete process.env.RECALLNEST_MULTI_VECTOR;
-    expect(isMultiVectorEnabled()).toBe(false);
-  });
-
-  it("returns true when set to 'true'", () => {
-    process.env.RECALLNEST_MULTI_VECTOR = "true";
-    expect(isMultiVectorEnabled()).toBe(true);
-  });
-});
-
-describe("extractMultiVectorText", () => {
-  it("extracts L0 and L1 from valid metadata", () => {
-    const meta = JSON.stringify({
-      l0_abstract: "User prefers TypeScript",
-      l1_overview: "User consistently chooses TypeScript over JavaScript for type safety",
-    });
-    const result = extractMultiVectorText(meta);
-    expect(result.l0).toBe("User prefers TypeScript");
-    expect(result.l1).toContain("TypeScript");
-  });
-
-  it("returns empty for missing fields", () => {
-    const meta = JSON.stringify({ source: "manual" });
-    const result = extractMultiVectorText(meta);
-    expect(result.l0).toBeUndefined();
-    expect(result.l1).toBeUndefined();
-  });
-
-  it("returns empty for undefined metadata", () => {
-    const result = extractMultiVectorText(undefined);
-    expect(result.l0).toBeUndefined();
-  });
-
-  it("skips very short L0/L1 text (<=5 chars)", () => {
-    const meta = JSON.stringify({ l0_abstract: "abc", l1_overview: "short" });
-    const result = extractMultiVectorText(meta);
-    expect(result.l0).toBeUndefined();
-    expect(result.l1).toBeUndefined();
-  });
-});
-
-describe("embedMultiVector", () => {
-  const mockEmbedder = {
-    async embedPassage(text: string) {
-      return [text.length, 0.5, 0.1];
-    },
-  };
-
-  it("returns null vectors when disabled", async () => {
-    delete process.env.RECALLNEST_MULTI_VECTOR;
-    const result = await embedMultiVector(mockEmbedder, JSON.stringify({
-      l0_abstract: "Some abstract text here",
-    }));
-    expect(result.vector_l0).toBeNull();
-    expect(result.vector_l1).toBeNull();
-  });
-
-  it("generates vectors when enabled and text available", async () => {
-    process.env.RECALLNEST_MULTI_VECTOR = "true";
-    const result = await embedMultiVector(mockEmbedder, JSON.stringify({
-      l0_abstract: "User prefers TypeScript",
-      l1_overview: "Detailed overview of TypeScript preference with reasoning",
-    }));
-    expect(result.vector_l0).not.toBeNull();
-    expect(result.vector_l1).not.toBeNull();
-    expect(result.vector_l0![0]).toBe("User prefers TypeScript".length);
-    // Cleanup
-    delete process.env.RECALLNEST_MULTI_VECTOR;
-  });
-
-  it("returns null for missing L0/L1 text even when enabled", async () => {
-    process.env.RECALLNEST_MULTI_VECTOR = "true";
-    const result = await embedMultiVector(mockEmbedder, JSON.stringify({ source: "manual" }));
-    expect(result.vector_l0).toBeNull();
-    expect(result.vector_l1).toBeNull();
-    delete process.env.RECALLNEST_MULTI_VECTOR;
-  });
-});
-
-describe("blendMultiVectorScores", () => {
-  it("returns main score when no L0/L1 available", () => {
-    expect(blendMultiVectorScores(0.8, null, null)).toBe(0.8);
-  });
-
-  it("blends with L0 only", () => {
-    const blended = blendMultiVectorScores(0.8, 0.9, null);
-    // (0.8 * 0.65 + 0.9 * 0.20) / (0.65 + 0.20) = (0.52 + 0.18) / 0.85
-    expect(blended).toBeCloseTo(0.824, 2);
-  });
-
-  it("blends with both L0 and L1", () => {
-    const blended = blendMultiVectorScores(0.8, 0.9, 0.7);
-    // (0.8*0.65 + 0.9*0.20 + 0.7*0.15) / (0.65+0.20+0.15) = (0.52+0.18+0.105)/1.0
-    expect(blended).toBeCloseTo(0.805, 2);
-  });
-
-  it("supports custom weights", () => {
-    const config = { vectorWeight: 0.5, l0Weight: 0.3, l1Weight: 0.2 };
-    const blended = blendMultiVectorScores(0.8, 0.9, 0.7, config);
-    expect(blended).toBeCloseTo(0.81, 2);
-  });
-});
-
-describe("cosineSimilarity", () => {
-  it("returns 1 for identical vectors", () => {
-    expect(cosineSimilarity([1, 0, 0], [1, 0, 0])).toBeCloseTo(1.0, 5);
-  });
-
-  it("returns 0 for orthogonal vectors", () => {
-    expect(cosineSimilarity([1, 0, 0], [0, 1, 0])).toBeCloseTo(0.0, 5);
-  });
-
-  it("returns -1 for opposite vectors", () => {
-    expect(cosineSimilarity([1, 0, 0], [-1, 0, 0])).toBeCloseTo(-1.0, 5);
-  });
-
-  it("returns 0 for empty vectors", () => {
-    expect(cosineSimilarity([], [])).toBe(0);
-  });
-
-  it("returns 0 for mismatched dimensions", () => {
-    expect(cosineSimilarity([1, 0], [1, 0, 0])).toBe(0);
-  });
-});
-
-// ===========================================================================
-// Tier 4.3: Text-overlap multi-vector scoring
-// ===========================================================================
-
-describe("tokenize", () => {
-  it("tokenizes English text, removes stop words", () => {
-    const tokens = tokenize("The user prefers TypeScript for projects");
-    expect(tokens).toContain("user");
-    expect(tokens).toContain("prefers");
-    expect(tokens).toContain("typescript");
-    expect(tokens).toContain("projects");
-    expect(tokens).not.toContain("the");
-    expect(tokens).not.toContain("for");
-  });
-
-  it("tokenizes Chinese text into unigrams, removes stop words", () => {
-    const tokens = tokenize("用户喜欢使用TypeScript编程");
-    expect(tokens).toContain("用");
-    expect(tokens).toContain("户");
-    expect(tokens).toContain("喜");
-    expect(tokens).toContain("欢");
-    expect(tokens).toContain("typescript");
-    expect(tokens).not.toContain("的");
-  });
-
-  it("handles mixed CJK and English", () => {
-    const tokens = tokenize("RecallNest 记忆服务 is great");
-    expect(tokens).toContain("recallnest");
-    expect(tokens).toContain("记");
-    expect(tokens).toContain("忆");
-    expect(tokens).toContain("服");
-    expect(tokens).toContain("务");
-    expect(tokens).toContain("great");
-  });
-
-  it("returns empty for empty/whitespace input", () => {
-    expect(tokenize("")).toEqual([]);
-    expect(tokenize("   ")).toEqual([]);
-  });
-});
-
-describe("textOverlapScore", () => {
-  it("returns 1.0 when query fully matches a concise abstract", () => {
-    const score = textOverlapScore("TypeScript preference", "TypeScript preference");
-    expect(score).toBeGreaterThan(0.8);
-  });
-
-  it("returns higher score for L0 abstract than L2 full text on topic query", () => {
-    const query = "TypeScript projects";
-    const l0 = "User prefers TypeScript for all projects";
-    const l2 = "The user mentioned that they have been working with React and JavaScript for three years. They recently started using TypeScript for their projects because of type safety. They also mentioned Python for data science work.";
-
-    const l0Score = textOverlapScore(query, l0);
-    const l2Score = textOverlapScore(query, l2);
-    expect(l0Score).toBeGreaterThan(l2Score);
-  });
-
-  it("returns 0 for completely unrelated texts", () => {
-    const score = textOverlapScore("TypeScript projects", "天气很好适合出去玩");
-    expect(score).toBe(0);
-  });
-
-  it("returns 0 for empty query", () => {
-    expect(textOverlapScore("", "some text")).toBe(0);
-  });
-
-  it("returns 0 for empty candidate", () => {
-    expect(textOverlapScore("some query", "")).toBe(0);
-  });
-});
-
-describe("adaptiveBlendConfig", () => {
-  it("boosts L0/L1 for short queries (≤3 tokens)", () => {
-    const config = adaptiveBlendConfig(2);
-    expect(config.l0Weight).toBe(0.25);
-    expect(config.l1Weight).toBe(0.25);
-    expect(config.vectorWeight).toBe(0.50);
-  });
-
-  it("uses default for medium queries (4-10 tokens)", () => {
-    const config = adaptiveBlendConfig(7);
-    expect(config).toEqual(DEFAULT_BLEND_CONFIG);
-  });
-
-  it("favors L2 for long queries (>10 tokens)", () => {
-    const config = adaptiveBlendConfig(15);
-    expect(config.vectorWeight).toBe(0.80);
-    expect(config.l0Weight).toBe(0.10);
-    expect(config.l1Weight).toBe(0.10);
-  });
-});

package/src/__tests__/narrative-architecture.test.ts

@@ -1,456 +0,0 @@
-/**
- * Phase 3: Autobiographical Narrative Architecture tests.
- *
- * Validates:
- * 1. NarrativeMetadata schema — Zod parsing + backward compat
- * 2. narrative-tagger — rule-based tagging with keyword detection
- * 3. parseNarrative — safe extraction from metadata JSON
- * 4. Feature flag gating — all features no-op when flag is off
- * 5. Graph export — narrative edges between siblings
- */
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { tagNarrative, tagNarrativeIfEnabled } from "../narrative-tagger.js";
-import {
-  parseNarrative,
-  isNarrativeModeEnabled,
-  NarrativeMetadataSchema,
-  type NarrativeMetadata,
-} from "../narrative-schema.js";
-
-// ---------------------------------------------------------------------------
-// 1. NarrativeMetadata Schema
-// ---------------------------------------------------------------------------
-
-describe("NarrativeMetadataSchema", () => {
-  test("accepts valid narrative metadata", () => {
-    const valid: NarrativeMetadata = {
-      lifePeriodId: "lp:project:2026-Q2",
-      lifePeriodLabel: "project (2026-Q2)",
-      generalEventId: "ge:session-abc",
-      generalEventLabel: "debugging @ project (2026-04-11)",
-      specificEventId: "se:project:1712835600000:abc123",
-      specificEventLabel: "Fixed the auth bug after 3 hours",
-      startAt: 1712835600000,
-      endAt: null,
-      sequence: 0,
-    };
-    const parsed = NarrativeMetadataSchema.parse(valid);
-    expect(parsed.lifePeriodId).toBe("lp:project:2026-Q2");
-    expect(parsed.endAt).toBeNull();
-    expect(parsed.sequence).toBe(0);
-  });
-
-  test("rejects empty lifePeriodId", () => {
-    expect(() =>
-      NarrativeMetadataSchema.parse({
-        lifePeriodId: "",
-        lifePeriodLabel: "x",
-        generalEventId: "ge:x",
-        generalEventLabel: "x",
-        specificEventId: "se:x",
-        specificEventLabel: "x",
-        startAt: 0,
-        endAt: null,
-        sequence: 0,
-      }),
-    ).toThrow();
-  });
-
-  test("rejects negative sequence", () => {
-    expect(() =>
-      NarrativeMetadataSchema.parse({
-        lifePeriodId: "lp:x:2026-Q1",
-        lifePeriodLabel: "x",
-        generalEventId: "ge:x",
-        generalEventLabel: "x",
-        specificEventId: "se:x",
-        specificEventLabel: "x",
-        startAt: 0,
-        endAt: null,
-        sequence: -1,
-      }),
-    ).toThrow();
-  });
-
-  test("accepts endAt as a number", () => {
-    const parsed = NarrativeMetadataSchema.parse({
-      lifePeriodId: "lp:x:2026-Q1",
-      lifePeriodLabel: "x",
-      generalEventId: "ge:x",
-      generalEventLabel: "x",
-      specificEventId: "se:x",
-      specificEventLabel: "x",
-      startAt: 1000,
-      endAt: 2000,
-      sequence: 1,
-    });
-    expect(parsed.endAt).toBe(2000);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 2. parseNarrative — safe extraction
-// ---------------------------------------------------------------------------
-
-describe("parseNarrative", () => {
-  test("returns null for undefined metadata", () => {
-    expect(parseNarrative(undefined)).toBeNull();
-  });
-
-  test("returns null for empty string", () => {
-    expect(parseNarrative("")).toBeNull();
-  });
-
-  test("returns null for metadata without narrative key", () => {
-    expect(parseNarrative(JSON.stringify({ source: "agent" }))).toBeNull();
-  });
-
-  test("returns null for malformed JSON", () => {
-    expect(parseNarrative("{broken json")).toBeNull();
-  });
-
-  test("extracts valid narrative from metadata", () => {
-    const metadata = JSON.stringify({
-      source: "agent",
-      narrative: {
-        lifePeriodId: "lp:memory:2026-Q2",
-        lifePeriodLabel: "memory (2026-Q2)",
-        generalEventId: "ge:session-123",
-        generalEventLabel: "development @ memory (2026-04-11)",
-        specificEventId: "se:memory:1712835600000:xyz",
-        specificEventLabel: "Implemented narrative tagger",
-        startAt: 1712835600000,
-        endAt: null,
-        sequence: 0,
-      },
-    });
-    const result = parseNarrative(metadata);
-    expect(result).not.toBeNull();
-    expect(result!.lifePeriodId).toBe("lp:memory:2026-Q2");
-    expect(result!.generalEventId).toBe("ge:session-123");
-    expect(result!.sequence).toBe(0);
-  });
-
-  test("returns null for narrative with missing lifePeriodId", () => {
-    const metadata = JSON.stringify({
-      narrative: { generalEventId: "ge:x" },
-    });
-    expect(parseNarrative(metadata)).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 3. tagNarrative — rule-based tagger
-// ---------------------------------------------------------------------------
-
-describe("tagNarrative", () => {
-  const origFlag = process.env.RECALLNEST_NARRATIVE_MODE;
-
-  afterAll(() => {
-    if (origFlag !== undefined) {
-      process.env.RECALLNEST_NARRATIVE_MODE = origFlag;
-    } else {
-      delete process.env.RECALLNEST_NARRATIVE_MODE;
-    }
-  });
-
-  test("returns null when feature flag is off", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "false";
-    const result = tagNarrative({
-      scope: "project:test",
-      text: "some memory",
-      timestamp: Date.now(),
-    });
-    expect(result).toBeNull();
-  });
-
-  test("returns narrative metadata when flag is on", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const ts = new Date("2026-04-11T10:00:00Z").getTime();
-    const result = tagNarrative({
-      scope: "project:recallnest",
-      text: "Implemented the narrative tagger feature",
-      timestamp: ts,
-    });
-
-    expect(result).not.toBeNull();
-    expect(result!.lifePeriodId).toBe("lp:project:2026-Q2");
-    expect(result!.lifePeriodLabel).toBe("project (2026-Q2)");
-    expect(result!.startAt).toBe(ts);
-    expect(result!.endAt).toBeNull();
-    expect(result!.sequence).toBe(0);
-  });
-
-  test("uses sessionId for generalEventId when provided", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const result = tagNarrative({
-      scope: "project:test",
-      text: "test memory",
-      timestamp: Date.now(),
-      sessionId: "sess-abc-123",
-    });
-    expect(result!.generalEventId).toBe("ge:sess-abc-123");
-  });
-
-  test("uses date-based generalEventId when no sessionId", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const ts = new Date("2026-04-11T10:00:00Z").getTime();
-    const result = tagNarrative({
-      scope: "project:test",
-      text: "test memory",
-      timestamp: ts,
-    });
-    expect(result!.generalEventId).toContain("2026-04-11");
-    expect(result!.generalEventId).toContain("ge:");
-  });
-
-  test("respects sequence parameter", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const result = tagNarrative({
-      scope: "project:test",
-      text: "third event",
-      timestamp: Date.now(),
-      sequence: 3,
-    });
-    expect(result!.sequence).toBe(3);
-  });
-
-  test("detects debugging event type from keywords", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const result = tagNarrative({
-      scope: "project:app",
-      text: "Debug the authentication crash in production",
-      timestamp: new Date("2026-04-11T10:00:00Z").getTime(),
-    });
-    expect(result!.generalEventLabel).toContain("debugging");
-  });
-
-  test("detects deployment event type from keywords", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const result = tagNarrative({
-      scope: "project:app",
-      text: "Deploy the new release to production",
-      timestamp: new Date("2026-04-11T10:00:00Z").getTime(),
-    });
-    expect(result!.generalEventLabel).toContain("deployment");
-  });
-
-  test("detects learning event type from keywords", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const result = tagNarrative({
-      scope: "project:app",
-      text: "Research new approaches for memory systems",
-      timestamp: new Date("2026-04-11T10:00:00Z").getTime(),
-    });
-    expect(result!.generalEventLabel).toContain("learning");
-  });
-
-  test("detects Chinese keywords", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const result = tagNarrative({
-      scope: "project:app",
-      text: "调试认证模块的崩溃问题",
-      timestamp: new Date("2026-04-11T10:00:00Z").getTime(),
-    });
-    expect(result!.generalEventLabel).toContain("debugging");
-  });
-
-  test("falls back to 'activity' when no keywords match", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const result = tagNarrative({
-      scope: "project:app",
-      text: "Meeting about quarterly goals",
-      timestamp: new Date("2026-04-11T10:00:00Z").getTime(),
-    });
-    expect(result!.generalEventLabel).toContain("activity");
-  });
-
-  test("truncates long text in specificEventLabel", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const longText = "A".repeat(100);
-    const result = tagNarrative({
-      scope: "project:app",
-      text: longText,
-      timestamp: Date.now(),
-    });
-    expect(result!.specificEventLabel.length).toBeLessThanOrEqual(60);
-    expect(result!.specificEventLabel).toContain("\u2026"); // ellipsis
-  });
-
-  test("quarterly boundary — Q1 vs Q2", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const q1 = tagNarrative({
-      scope: "project:app",
-      text: "Q1 work",
-      timestamp: new Date("2026-03-15T10:00:00Z").getTime(),
-    });
-    const q2 = tagNarrative({
-      scope: "project:app",
-      text: "Q2 work",
-      timestamp: new Date("2026-04-15T10:00:00Z").getTime(),
-    });
-    expect(q1!.lifePeriodId).toContain("2026-Q1");
-    expect(q2!.lifePeriodId).toContain("2026-Q2");
-    expect(q1!.lifePeriodId).not.toBe(q2!.lifePeriodId);
-  });
-
-  test("same scope+day → same generalEventId (without sessionId)", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const ts1 = new Date("2026-04-11T08:00:00Z").getTime();
-    const ts2 = new Date("2026-04-11T16:00:00Z").getTime();
-    const r1 = tagNarrative({ scope: "project:app", text: "morning work", timestamp: ts1 });
-    const r2 = tagNarrative({ scope: "project:app", text: "evening work", timestamp: ts2 });
-    expect(r1!.generalEventId).toBe(r2!.generalEventId);
-  });
-
-  test("different days → different generalEventId", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const day1 = new Date("2026-04-11T10:00:00Z").getTime();
-    const day2 = new Date("2026-04-12T10:00:00Z").getTime();
-    const r1 = tagNarrative({ scope: "project:app", text: "day1", timestamp: day1 });
-    const r2 = tagNarrative({ scope: "project:app", text: "day2", timestamp: day2 });
-    expect(r1!.generalEventId).not.toBe(r2!.generalEventId);
-  });
-
-  test("different text → different specificEventId", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const ts = Date.now();
-    const r1 = tagNarrative({ scope: "project:app", text: "event A happened", timestamp: ts });
-    const r2 = tagNarrative({ scope: "project:app", text: "event B happened", timestamp: ts });
-    expect(r1!.specificEventId).not.toBe(r2!.specificEventId);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 4. tagNarrativeIfEnabled — convenience wrapper
-// ---------------------------------------------------------------------------
-
-describe("tagNarrativeIfEnabled", () => {
-  const origFlag = process.env.RECALLNEST_NARRATIVE_MODE;
-
-  afterAll(() => {
-    if (origFlag !== undefined) {
-      process.env.RECALLNEST_NARRATIVE_MODE = origFlag;
-    } else {
-      delete process.env.RECALLNEST_NARRATIVE_MODE;
-    }
-  });
-
-  test("returns null when flag is off", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "false";
-    expect(tagNarrativeIfEnabled({ scope: "x", text: "y", timestamp: 0 })).toBeNull();
-  });
-
-  test("returns metadata when flag is on", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const result = tagNarrativeIfEnabled({
-      scope: "project:test",
-      text: "test",
-      timestamp: Date.now(),
-    });
-    expect(result).not.toBeNull();
-    expect(result!.lifePeriodId).toBeDefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 5. isNarrativeModeEnabled
-// ---------------------------------------------------------------------------
-
-describe("isNarrativeModeEnabled", () => {
-  const origFlag = process.env.RECALLNEST_NARRATIVE_MODE;
-
-  afterAll(() => {
-    if (origFlag !== undefined) {
-      process.env.RECALLNEST_NARRATIVE_MODE = origFlag;
-    } else {
-      delete process.env.RECALLNEST_NARRATIVE_MODE;
-    }
-  });
-
-  test("returns false when env is not set", () => {
-    delete process.env.RECALLNEST_NARRATIVE_MODE;
-    expect(isNarrativeModeEnabled()).toBe(false);
-  });
-
-  test("returns false when env is 'false'", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "false";
-    expect(isNarrativeModeEnabled()).toBe(false);
-  });
-
-  test("returns true when env is 'true'", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    expect(isNarrativeModeEnabled()).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 6. Narrative metadata round-trip (tag → JSON → parse)
-// ---------------------------------------------------------------------------
-
-describe("narrative round-trip", () => {
-  const origFlag = process.env.RECALLNEST_NARRATIVE_MODE;
-
-  afterAll(() => {
-    if (origFlag !== undefined) {
-      process.env.RECALLNEST_NARRATIVE_MODE = origFlag;
-    } else {
-      delete process.env.RECALLNEST_NARRATIVE_MODE;
-    }
-  });
-
-  test("tag → embed in metadata JSON → parseNarrative → same values", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "true";
-    const tagged = tagNarrative({
-      scope: "project:recallnest",
-      text: "Fixed the scoring bug in retriever",
-      timestamp: new Date("2026-04-11T10:00:00Z").getTime(),
-      sessionId: "sess-xyz",
-      sequence: 2,
-    });
-
-    expect(tagged).not.toBeNull();
-
-    // Simulate embedding in metadata JSON (as done in capture-engine/ingest)
-    const metadata = JSON.stringify({
-      source: "agent",
-      tags: ["fix"],
-      narrative: tagged,
-    });
-
-    // Parse back out
-    const parsed = parseNarrative(metadata);
-    expect(parsed).not.toBeNull();
-    expect(parsed!.lifePeriodId).toBe(tagged!.lifePeriodId);
-    expect(parsed!.generalEventId).toBe(tagged!.generalEventId);
-    expect(parsed!.specificEventId).toBe(tagged!.specificEventId);
-    expect(parsed!.sequence).toBe(2);
-    expect(parsed!.startAt).toBe(tagged!.startAt);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 7. Backward compatibility — existing metadata without narrative
-// ---------------------------------------------------------------------------
-
-describe("backward compatibility", () => {
-  test("parseNarrative on pre-narrative metadata returns null", () => {
-    const oldMeta = JSON.stringify({
-      source: "agent",
-      tags: ["test"],
-      emotion: { valence: 0.5, arousal: 0.3, label: "positive" },
-      evolution: { status: "active", version: 1 },
-    });
-    expect(parseNarrative(oldMeta)).toBeNull();
-  });
-
-  test("feature flag off means zero narrative overhead", () => {
-    process.env.RECALLNEST_NARRATIVE_MODE = "false";
-    const result = tagNarrative({
-      scope: "project:test",
-      text: "this should produce nothing",
-      timestamp: Date.now(),
-    });
-    expect(result).toBeNull();
-  });
-});