recallnest 2.2.0 → 2.3.0

package/src/__tests__/ethics-layer.test.ts

@@ -1,476 +0,0 @@
-/**
- * Tests for Phase 2: Memory Ethics Layer
- *
- * Covers:
- * - PrivacyTier schema + parsePrivacyTier
- * - Forget engine: single + scope-level forget
- * - Cascade-forget lifecycle unification
- * - Audit log: forget + cascade_forget operations
- * - Privacy tier gate in capture (KG extraction)
- * - StoreMemoryInput accepts privacyTier
- */
-import { describe, expect, test } from "bun:test";
-import {
-  PrivacyTierSchema,
-  parsePrivacyTier,
-  PRIVACY_TIERS,
-  StoreMemoryInputSchema,
-  type PrivacyTier,
-} from "../memory-schema.js";
-import { isActiveMemory, patchEvolution, parseEvolution } from "../memory-evolution.js";
-import { createAuditLogger, type AuditLogger } from "../audit-log.js";
-import { forgetMemory, forgetByScope, type ForgetByIdDeps } from "../forget-engine.js";
-import { cascadeForget, DEFAULT_CASCADE_FORGET_CONFIG } from "../cascade-forget.js";
-import type { MemoryEntry, MemoryStore } from "../store.js";
-import { existsSync, mkdirSync, rmSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEntry(overrides: Partial<MemoryEntry> = {}): MemoryEntry {
-  return {
-    id: overrides.id || "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
-    text: overrides.text || "test memory entry",
-    vector: overrides.vector || Array(768).fill(0.1),
-    category: overrides.category || "events",
-    scope: overrides.scope || "project:test",
-    importance: overrides.importance ?? 0.7,
-    timestamp: overrides.timestamp || Date.now(),
-    metadata: overrides.metadata || "{}",
-  };
-}
-
-function makeMockStore(entries: MemoryEntry[]): MemoryStore {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  return {
-    get: async (id: string) => data.get(id) || null,
-    delete: async (id: string) => {
-      const existed = data.has(id);
-      data.delete(id);
-      return existed;
-    },
-    update: async (id: string, updates: Partial<MemoryEntry>) => {
-      const entry = data.get(id);
-      if (!entry) return null;
-      const updated = { ...entry, ...updates };
-      data.set(id, updated);
-      return updated;
-    },
-    list: async (scopeFilter?: string[]) => {
-      const all = [...data.values()];
-      if (!scopeFilter) return all;
-      return all.filter(e => scopeFilter.includes(e.scope));
-    },
-    vectorSearch: async (vector: number[], limit: number, threshold: number, scopes?: string[]) => {
-      const all = [...data.values()];
-      const filtered = scopes
-        ? all.filter(e => scopes.includes(e.scope))
-        : all;
-      // Fake similarity: entries with same scope get high score
-      return filtered.slice(0, limit).map(e => ({
-        entry: e,
-        score: 0.85,
-      }));
-    },
-    store: async (entry: any) => {
-      data.set(entry.id, entry);
-      return entry;
-    },
-  } as any;
-}
-
-function makeMockKGStore() {
-  const deletedSources: string[] = [];
-  const deletedScopes: string[] = [];
-  return {
-    deleteBySource: async (sourceMemoryId: string) => {
-      deletedSources.push(sourceMemoryId);
-    },
-    deleteByScope: async (scope: string) => {
-      deletedScopes.push(scope);
-    },
-    _deletedSources: deletedSources,
-    _deletedScopes: deletedScopes,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// 1. PrivacyTier Schema
-// ---------------------------------------------------------------------------
-
-describe("PrivacyTier Schema", () => {
-  test("all four tiers are valid", () => {
-    for (const tier of PRIVACY_TIERS) {
-      expect(PrivacyTierSchema.parse(tier)).toBe(tier);
-    }
-  });
-
-  test("invalid tier throws", () => {
-    expect(() => PrivacyTierSchema.parse("secret")).toThrow();
-    expect(() => PrivacyTierSchema.parse("")).toThrow();
-  });
-
-  test("parsePrivacyTier returns durable for absent metadata", () => {
-    expect(parsePrivacyTier(undefined)).toBe("durable");
-    expect(parsePrivacyTier("")).toBe("durable");
-  });
-
-  test("parsePrivacyTier returns durable for metadata without privacyTier", () => {
-    expect(parsePrivacyTier(JSON.stringify({ source: "manual" }))).toBe("durable");
-  });
-
-  test("parsePrivacyTier extracts tier from metadata", () => {
-    expect(parsePrivacyTier(JSON.stringify({ privacyTier: "ephemeral" }))).toBe("ephemeral");
-    expect(parsePrivacyTier(JSON.stringify({ privacyTier: "private" }))).toBe("private");
-    expect(parsePrivacyTier(JSON.stringify({ privacyTier: "shared" }))).toBe("shared");
-  });
-
-  test("parsePrivacyTier returns durable for malformed metadata", () => {
-    expect(parsePrivacyTier("not json")).toBe("durable");
-    expect(parsePrivacyTier(JSON.stringify({ privacyTier: "invalid" }))).toBe("durable");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 2. StoreMemoryInput accepts privacyTier
-// ---------------------------------------------------------------------------
-
-describe("StoreMemoryInput with privacyTier", () => {
-  test("default privacyTier is durable", () => {
-    const input = StoreMemoryInputSchema.parse({
-      text: "test memory",
-      scope: "project:test",
-    });
-    expect(input.privacyTier).toBe("durable");
-  });
-
-  test("explicit privacyTier is preserved", () => {
-    const input = StoreMemoryInputSchema.parse({
-      text: "test memory",
-      scope: "project:test",
-      privacyTier: "ephemeral",
-    });
-    expect(input.privacyTier).toBe("ephemeral");
-  });
-
-  test("invalid privacyTier throws", () => {
-    expect(() => StoreMemoryInputSchema.parse({
-      text: "test memory",
-      scope: "project:test",
-      privacyTier: "top_secret",
-    })).toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 3. Lifecycle Unification (cascade-forget uses isActiveMemory)
-// ---------------------------------------------------------------------------
-
-describe("Lifecycle Unification", () => {
-  test("cascadeForget skips archived entries via evolution.status", async () => {
-    const archivedMeta = patchEvolution("{}", { status: "archived" });
-    const primary = makeEntry({ id: "primary-id-0000-0000-000000000001" });
-    const archivedEntry = makeEntry({
-      id: "archived-entry-0000-0000-000000000002",
-      metadata: archivedMeta,
-    });
-    const activeEntry = makeEntry({
-      id: "active-entry-0000-0000-0000000000003",
-      metadata: patchEvolution("{}", { status: "active" }),
-      importance: 0.8,
-    });
-
-    const store = makeMockStore([primary, archivedEntry, activeEntry]);
-    const result = await cascadeForget(
-      store,
-      { id: primary.id, vector: primary.vector, scope: primary.scope },
-      DEFAULT_CASCADE_FORGET_CONFIG,
-    );
-
-    // Archived entry should NOT be demoted
-    expect(result.demotedIds).not.toContain(archivedEntry.id);
-  });
-
-  test("cascadeForget skips superseded entries via evolution.status", async () => {
-    const supersededMeta = patchEvolution("{}", { status: "superseded" });
-    const primary = makeEntry({ id: "primary-id-0000-0000-000000000010" });
-    const supersededEntry = makeEntry({
-      id: "superseded-0000-0000-0000000000020",
-      metadata: supersededMeta,
-    });
-
-    const store = makeMockStore([primary, supersededEntry]);
-    const result = await cascadeForget(
-      store,
-      { id: primary.id, vector: primary.vector, scope: primary.scope },
-      DEFAULT_CASCADE_FORGET_CONFIG,
-    );
-
-    expect(result.demotedIds).not.toContain(supersededEntry.id);
-  });
-
-  test("isActiveMemory correctly identifies active vs non-active", () => {
-    expect(isActiveMemory(undefined)).toBe(true); // no metadata = active
-    expect(isActiveMemory(patchEvolution("{}", { status: "active" }))).toBe(true);
-    expect(isActiveMemory(patchEvolution("{}", { status: "pending_review" }))).toBe(true);
-    expect(isActiveMemory(patchEvolution("{}", { status: "archived" }))).toBe(false);
-    expect(isActiveMemory(patchEvolution("{}", { status: "superseded" }))).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 4. Audit Log Extensions
-// ---------------------------------------------------------------------------
-
-describe("Audit Log Extensions", () => {
-  const tmpDir = join(import.meta.dir, ".tmp-audit-test");
-
-  test("audit logger accepts forget operation", () => {
-    const logPath = join(tmpDir, "audit-forget-test.jsonl");
-    try { mkdirSync(tmpDir, { recursive: true }); } catch { /* ok */ }
-    const logger = createAuditLogger(logPath);
-
-    logger.log({
-      operation: "forget",
-      scope: "project:test",
-      memoryId: "test-id",
-      actor: "system",
-      details: "forget test",
-    });
-
-    const content = readFileSync(logPath, "utf-8");
-    const parsed = JSON.parse(content.trim());
-    expect(parsed.operation).toBe("forget");
-    expect(parsed.scope).toBe("project:test");
-
-    try { rmSync(tmpDir, { recursive: true }); } catch { /* cleanup */ }
-  });
-
-  test("audit logger accepts cascade_forget operation", () => {
-    const logPath = join(tmpDir, "audit-cascade-test.jsonl");
-    try { mkdirSync(tmpDir, { recursive: true }); } catch { /* ok */ }
-    const logger = createAuditLogger(logPath);
-
-    logger.log({
-      operation: "cascade_forget",
-      scope: "project:test",
-      memoryId: "test-id",
-      actor: "system",
-      details: "cascade forget test",
-    });
-
-    const content = readFileSync(logPath, "utf-8");
-    const parsed = JSON.parse(content.trim());
-    expect(parsed.operation).toBe("cascade_forget");
-
-    try { rmSync(tmpDir, { recursive: true }); } catch { /* cleanup */ }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 5. Forget Engine
-// ---------------------------------------------------------------------------
-
-describe("Forget Engine", () => {
-  test("forgetMemory succeeds for ephemeral memory (no confirm needed)", async () => {
-    const meta = JSON.stringify({ privacyTier: "ephemeral" });
-    const entry = makeEntry({ metadata: meta });
-    const store = makeMockStore([entry]);
-    const kgStore = makeMockKGStore();
-
-    const result = await forgetMemory(
-      { store, kgStore: kgStore as any },
-      { memoryId: entry.id, confirm: false },
-    );
-
-    expect(result.success).toBe(true);
-    expect(result.kgTriplesRemoved).toBe(true);
-    expect(kgStore._deletedSources).toContain(entry.id);
-  });
-
-  test("forgetMemory requires confirm for durable tier", async () => {
-    const entry = makeEntry(); // default = durable
-    const store = makeMockStore([entry]);
-
-    const result = await forgetMemory(
-      { store },
-      { memoryId: entry.id, confirm: false },
-    );
-
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("durable");
-    expect(result.error).toContain("confirm=true");
-  });
-
-  test("forgetMemory succeeds for durable with confirm=true", async () => {
-    const entry = makeEntry();
-    const store = makeMockStore([entry]);
-
-    const result = await forgetMemory(
-      { store },
-      { memoryId: entry.id, confirm: true, reason: "user requested" },
-    );
-
-    expect(result.success).toBe(true);
-    expect(result.evidence).toBeDefined();
-    expect(result.evidence!.reason).toBe("user requested");
-    expect(result.evidence!.privacyTier).toBe("durable");
-  });
-
-  test("forgetMemory returns error for nonexistent ID", async () => {
-    const store = makeMockStore([]);
-
-    const result = await forgetMemory(
-      { store },
-      { memoryId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", confirm: true },
-    );
-
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("not found");
-  });
-
-  test("forgetMemory preserves evidence snapshot", async () => {
-    const entry = makeEntry({
-      text: "important secret",
-      importance: 0.9,
-    });
-    const store = makeMockStore([entry]);
-
-    const result = await forgetMemory(
-      { store },
-      { memoryId: entry.id, confirm: true },
-    );
-
-    expect(result.success).toBe(true);
-    expect(result.evidence).toBeDefined();
-    expect(result.evidence!.entry.text).toBe("important secret");
-    expect(result.evidence!.entry.importance).toBe(0.9);
-    expect(result.evidence!.forgottenAt).toBeTruthy();
-  });
-
-  test("forgetMemory cascades to related memories", async () => {
-    const primary = makeEntry({ id: "primary-id-0000-0000-000000000001", importance: 0.8 });
-    const related = makeEntry({
-      id: "related-id-0000-0000-000000000002",
-      importance: 0.8,
-      metadata: patchEvolution("{}", { status: "active" }),
-    });
-
-    const store = makeMockStore([primary, related]);
-    const result = await forgetMemory(
-      { store },
-      { memoryId: primary.id, confirm: true },
-    );
-
-    expect(result.success).toBe(true);
-    // Cascade should have attempted to demote
-    // (exact count depends on mock similarity scores)
-    expect(result.cascadeResult).toBeDefined();
-  });
-
-  test("forgetMemory logs audit trail", async () => {
-    const tmpDir = join(import.meta.dir, ".tmp-forget-audit");
-    const logPath = join(tmpDir, "forget-audit.jsonl");
-    try { mkdirSync(tmpDir, { recursive: true }); } catch { /* ok */ }
-
-    const entry = makeEntry({ metadata: JSON.stringify({ privacyTier: "private" }) });
-    const store = makeMockStore([entry]);
-    const auditLogger = createAuditLogger(logPath);
-
-    const result = await forgetMemory(
-      { store, auditLogger },
-      { memoryId: entry.id, confirm: true, reason: "privacy cleanup" },
-    );
-
-    expect(result.success).toBe(true);
-
-    const content = readFileSync(logPath, "utf-8").trim();
-    const lines = content.split("\n").map(l => JSON.parse(l));
-    const forgetLog = lines.find(l => l.operation === "forget");
-    expect(forgetLog).toBeDefined();
-    expect(forgetLog.details).toContain("private");
-    expect(forgetLog.details).toContain("privacy cleanup");
-
-    try { rmSync(tmpDir, { recursive: true }); } catch { /* cleanup */ }
-  });
-
-  test("forgetMemory cleans up KG triples", async () => {
-    const entry = makeEntry();
-    const store = makeMockStore([entry]);
-    const kgStore = makeMockKGStore();
-
-    const result = await forgetMemory(
-      { store, kgStore: kgStore as any },
-      { memoryId: entry.id, confirm: true },
-    );
-
-    expect(result.success).toBe(true);
-    expect(result.kgTriplesRemoved).toBe(true);
-    expect(kgStore._deletedSources).toContain(entry.id);
-  });
-
-  test("forgetByScope deletes all entries in scope", async () => {
-    const entries = [
-      makeEntry({ id: "scope-entry-0000-0000-000000000001", scope: "project:cleanup", metadata: JSON.stringify({ privacyTier: "private" }) }),
-      makeEntry({ id: "scope-entry-0000-0000-000000000002", scope: "project:cleanup", metadata: JSON.stringify({ privacyTier: "ephemeral" }) }),
-      makeEntry({ id: "other-scope-0000-0000-000000000003", scope: "project:keep" }),
-    ];
-    const store = makeMockStore(entries);
-    const kgStore = makeMockKGStore();
-
-    const result = await forgetByScope(
-      { store, kgStore: kgStore as any },
-      "project:cleanup",
-      true,
-      "scope cleanup",
-    );
-
-    expect(result.forgottenCount).toBe(2);
-    expect(result.kgScopeCleared).toBe(true);
-    expect(kgStore._deletedScopes).toContain("project:cleanup");
-  });
-
-  test("forgetByScope requires confirm", async () => {
-    const entries = [
-      makeEntry({ id: "scope-entry-0000-0000-000000000010", scope: "project:cleanup" }),
-    ];
-    const store = makeMockStore(entries);
-
-    const result = await forgetByScope(
-      { store },
-      "project:cleanup",
-      false,
-    );
-
-    expect(result.forgottenCount).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 6. Privacy Tier values
-// ---------------------------------------------------------------------------
-
-describe("Privacy Tier Semantics", () => {
-  test("PRIVACY_TIERS has exactly 4 tiers", () => {
-    expect(PRIVACY_TIERS).toHaveLength(4);
-    expect(PRIVACY_TIERS).toContain("ephemeral");
-    expect(PRIVACY_TIERS).toContain("private");
-    expect(PRIVACY_TIERS).toContain("durable");
-    expect(PRIVACY_TIERS).toContain("shared");
-  });
-
-  test("ephemeral and private should block KG (semantics check)", () => {
-    // This tests the logic that would be used in capture-engine
-    const kgBlockedTiers: PrivacyTier[] = ["ephemeral", "private"];
-    const kgAllowedTiers: PrivacyTier[] = ["durable", "shared"];
-
-    for (const tier of kgBlockedTiers) {
-      expect(tier === "ephemeral" || tier === "private").toBe(true);
-    }
-    for (const tier of kgAllowedTiers) {
-      expect(tier !== "ephemeral" && tier !== "private").toBe(true);
-    }
-  });
-});

package/src/__tests__/event-segmenter.test.ts

@@ -1,153 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { segmentEvents, type EventSegmenterConfig } from "../event-segmenter.js";
-
-const cfg: EventSegmenterConfig = { maxSegmentSize: 500, minSegmentSize: 50 };
-
-describe("segmentEvents", () => {
-  it("returns single segment for short text", () => {
-    const result = segmentEvents("Hello world", cfg);
-    expect(result).toHaveLength(1);
-    expect(result[0].boundaryType).toBe("initial");
-  });
-
-  it("returns empty for empty input", () => {
-    expect(segmentEvents("", cfg)).toHaveLength(0);
-    expect(segmentEvents("   ", cfg)).toHaveLength(0);
-  });
-
-  it("splits on topic shift markers (Chinese)", () => {
-    const text = [
-      "[用户] 帮我查一下 TypeScript 的配置方法",
-      "[助手] TypeScript 需要 tsconfig.json 文件来配置编译选项...",
-      "这里有一些常见的配置项：strictNullChecks, target, module 等等。你可以根据项目需要来选择。",
-      "[用户] 另外，帮我看看 Docker 的问题",
-      "[助手] Docker 的问题是什么呢？请描述一下具体的错误信息。",
-    ].join("\n");
-
-    const result = segmentEvents(text, cfg);
-    expect(result.length).toBeGreaterThanOrEqual(2);
-    // First segment should contain TypeScript content
-    expect(result[0].text).toContain("TypeScript");
-    // Second segment should start with the Docker topic
-    expect(result[result.length - 1].text).toContain("Docker");
-  });
-
-  it("splits on topic shift markers (English)", () => {
-    const text = [
-      "[用户] How do I configure TypeScript?",
-      "[助手] You need a tsconfig.json file with compiler options like strictNullChecks and target settings for your project.",
-      "[用户] By the way, what about Docker setup?",
-      "[助手] For Docker, you'll need a Dockerfile and optionally a docker-compose.yml for multi-service setups.",
-    ].join("\n");
-
-    const result = segmentEvents(text, cfg);
-    expect(result.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it("splits on Q&A boundaries (user after assistant)", () => {
-    const longAssistant = "A".repeat(200);
-    const text = [
-      `[用户] First question about performance`,
-      `[助手] ${longAssistant}`,
-      `[用户] Second question about security`,
-      `[助手] Security requires authentication and authorization checks.`,
-    ].join("\n");
-
-    const result = segmentEvents(text, { maxSegmentSize: 500, minSegmentSize: 50 });
-    expect(result.length).toBeGreaterThanOrEqual(2);
-    expect(result[0].text).toContain("performance");
-  });
-
-  it("does not split inside code blocks", () => {
-    const text = [
-      "[用户] Show me the code",
-      "[助手] Here's the implementation:",
-      "```typescript",
-      "function hello() {",
-      "  // 另外 this is NOT a topic shift inside code",
-      '  console.log("hello");',
-      "}",
-      "```",
-      "That's the basic structure you need. Let me explain more about the details and configuration options.",
-    ].join("\n");
-
-    const result = segmentEvents(text, cfg);
-    // Should keep code block intact — "另外" inside ``` should not trigger split
-    const codeSegment = result.find(s => s.text.includes("```typescript"));
-    expect(codeSegment).toBeDefined();
-    expect(codeSegment!.text).toContain('console.log("hello")');
-  });
-
-  it("keeps numbered lists intact", () => {
-    const text = [
-      "[助手] Here are the steps to follow for this configuration:",
-      "1. Install the package using npm install",
-      "2. Create config file in your project root",
-      "3. Run the build command to verify",
-      "4. Deploy to staging environment first",
-      "5. Monitor logs for errors before production",
-      "",
-      "[用户] 另外，帮我看看另一个问题",
-    ].join("\n");
-
-    const result = segmentEvents(text, cfg);
-    // The list should be in one segment
-    const listSegment = result.find(s => s.text.includes("1. Install"));
-    expect(listSegment).toBeDefined();
-    expect(listSegment!.text).toContain("5. Monitor");
-  });
-
-  it("detects time jumps", () => {
-    const text = [
-      "[用户] 帮我看看这个 bug，已经排查了很久了。",
-      "[助手] 好的，让我看看错误日志。根据分析，这个问题是由于内存泄漏导致的。",
-      "[用户] 2024-03-15 下午我又遇到了另一个问题",
-      "[助手] 请描述一下新的问题现象。",
-    ].join("\n");
-
-    const result = segmentEvents(text, cfg);
-    // Should split at the date marker
-    const timeSegment = result.find(s => s.text.includes("2024-03-15"));
-    expect(timeSegment).toBeDefined();
-  });
-
-  it("respects max segment size", () => {
-    const longLine = "A".repeat(300);
-    const text = Array.from({ length: 10 }, (_, i) => `Line ${i}: ${longLine}`).join("\n");
-
-    const result = segmentEvents(text, { maxSegmentSize: 800, minSegmentSize: 100 });
-    // All segments should respect max size (with some tolerance for boundary alignment)
-    for (const seg of result) {
-      expect(seg.text.length).toBeLessThanOrEqual(800 * 1.5); // Allow some overshoot for boundary alignment
-    }
-  });
-
-  it("merges tiny trailing segments", () => {
-    const text = [
-      "[用户] " + "A".repeat(400),
-      "[助手] 好的",  // This tiny trailing bit should merge with previous
-    ].join("\n");
-
-    const result = segmentEvents(text, { maxSegmentSize: 500, minSegmentSize: 50 });
-    // Should not produce a segment with just "好的"
-    const tinySegments = result.filter(s => s.text.length < 50);
-    expect(tinySegments).toHaveLength(0);
-  });
-
-  it("handles bullet lists with - markers", () => {
-    const text = [
-      "[助手] Key considerations when designing this system:",
-      "- Performance: optimize hot paths and cache results",
-      "- Security: validate all inputs at system boundaries",
-      "- Reliability: add retry logic with exponential backoff",
-      "- Observability: structured logging with trace IDs",
-      "",
-      "[用户] 另外还有什么需要注意的吗？",
-    ].join("\n");
-
-    const result = segmentEvents(text, cfg);
-    const listSeg = result.find(s => s.text.includes("- Performance"));
-    expect(listSeg).toBeDefined();
-    expect(listSeg!.text).toContain("- Observability");
-  });
-});

package/src/__tests__/feature-flags-integration.test.ts

@@ -1,54 +0,0 @@
-import { describe, test, expect, afterAll } from "bun:test";
-import { detectEmotionIfEnabled } from "../emotion-detector.js";
-import { shouldReconstruct, extractCitedIds, removeSentencesWithId } from "../context-reconstructor.js";
-import { adjustHalfLifeForEmotion, weibullDecay } from "../decay-engine.js";
-
-describe("feature flag isolation", () => {
-  const saved = {
-    emo: process.env.RECALLNEST_EMOTION_SCORING,
-    con: process.env.RECALLNEST_CONSTRUCTIVE_RETRIEVAL,
-  };
-
-  afterAll(() => {
-    if (saved.emo !== undefined) process.env.RECALLNEST_EMOTION_SCORING = saved.emo;
-    else delete process.env.RECALLNEST_EMOTION_SCORING;
-    if (saved.con !== undefined) process.env.RECALLNEST_CONSTRUCTIVE_RETRIEVAL = saved.con;
-    else delete process.env.RECALLNEST_CONSTRUCTIVE_RETRIEVAL;
-  });
-
-  test("emotion off -> detectEmotionIfEnabled returns null", () => {
-    delete process.env.RECALLNEST_EMOTION_SCORING;
-    expect(detectEmotionIfEnabled("terrible bug")).toBeNull();
-  });
-
-  test("constructive off -> shouldReconstruct false", () => {
-    expect(shouldReconstruct({
-      flagEnabled: false, callerOptIn: true, resultCount: 10, llmAvailable: true,
-    })).toBe(false);
-  });
-});
-
-describe("emotion + decay end-to-end", () => {
-  test("emotional memory retains more score at 30 days", () => {
-    const baseHL = 60;
-    const emoHL = adjustHalfLifeForEmotion(baseHL, { valence: -0.8, arousal: 0.7, label: "frustration" });
-    expect(weibullDecay(30, emoHL, "working")).toBeGreaterThan(weibullDecay(30, baseHL, "working"));
-  });
-});
-
-describe("grounding end-to-end", () => {
-  test("removes phantom citations and lowers confidence", () => {
-    const text = "Valid [src:r1]. Fake [src:phantom]. Also valid [src:r2].";
-    const validIds = new Set(["r1", "r2"]);
-    let result = text;
-    let confidence = 1.0;
-    for (const id of extractCitedIds(result)) {
-      if (!validIds.has(id)) {
-        result = removeSentencesWithId(result, id);
-        confidence -= 0.2;
-      }
-    }
-    expect(result).not.toContain("phantom");
-    expect(confidence).toBe(0.8);
-  });
-});