recallnest 2.2.1 → 2.5.4

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

@@ -0,0 +1,476 @@
+/**
+ * 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

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

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