recallnest 2.3.0 → 2.6.0

package/src/__tests__/omitted-reporting.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "bun:test";
+
+import { createRetriever, type RetrievalResultSet } from "../retriever.js";
+
+// P-omitted: 验证召回因 limit 上限截断时，对调用方暴露 omitted（提高 limit 可见）。
+// 借鉴 RepoPrompt CE「剪枝必回报」——召回从黑箱变可协商。
+
+function buildCandidate(id: string, score: number) {
+  return {
+    entry: {
+      id,
+      text: `distinct memory content number ${id}`,
+      vector: [1, 0, 0],
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.8,
+      timestamp: Date.parse("2026-03-16T00:00:00.000Z"),
+      metadata: JSON.stringify({}),
+    },
+    score,
+  };
+}
+
+// 最小过滤 config：mode=vector 跳过 BM25/rerank；minScore/hardMinScore=0 + 高分候选避免 hard-min 截断；
+// filterNoise=false；RIF/sourceDiversity 字段缺省即不启用；MMR 只重排不删。
+// 于是过滤链净效果 = sort → slice(limit)，omitted = candidates - limit 可精确断言。
+function makeRetriever(
+  candidates: ReturnType<typeof buildCandidate>[],
+  configOverride: Record<string, unknown> = {},
+) {
+  return createRetriever({
+    hasFtsSupport: false,
+    // 模拟真实 MemoryStore.vectorSearch：尊重 k 参数（按 k 截断返回）。
+    // 这样测试能真实反映 over-fetch 是否生效——若 vector-only 不 over-fetch、只取 limit 条，
+    // 候选池 ≤ limit、omitted 必为 0，下面断言会失败（Codex review 暴露的假绿点）。
+    async vectorSearch(_vec: number[], k: number) { return candidates.slice(0, k); },
+  } as any, {
+    async embedQuery() { return [1, 0, 0]; },
+    async embedPassage() { return [1, 0, 0]; },
+  } as any, {
+    mode: "vector",
+    rerank: "none",
+    filterNoise: false,
+    hardMinScore: 0,
+    minScore: 0,
+    recencyWeight: 0,
+    timeDecayHalfLifeDays: 0,
+    ...configOverride,
+  });
+}
+
+describe("retrieval omitted reporting (P-omitted)", () => {
+  it("reports omitted count + reason when candidates exceed limit", async () => {
+    const candidates = Array.from({ length: 8 }, (_, i) => buildCandidate(`m${i}`, 0.9 - i * 0.01));
+    const retriever = makeRetriever(candidates);
+
+    const results = await retriever.retrieve({ query: "user reply style preference detail", limit: 3, category: "preferences" }) as RetrievalResultSet;
+
+    expect(results).toHaveLength(3);
+    expect(results.omitted).toBeDefined();
+    expect(results.omitted?.count).toBe(5); // 8 candidates - limit 3
+    expect(results.omitted?.reason).toBe("limit");
+  });
+
+  it("leaves omitted undefined when candidates fit within limit", async () => {
+    const candidates = Array.from({ length: 2 }, (_, i) => buildCandidate(`m${i}`, 0.9 - i * 0.01));
+    const retriever = makeRetriever(candidates);
+
+    const results = await retriever.retrieve({ query: "user reply style preference detail", limit: 5, category: "preferences" }) as RetrievalResultSet;
+
+    expect(results).toHaveLength(2);
+    expect(results.omitted).toBeUndefined();
+  });
+
+  it("persists omitted through the validity filter (regression: array is rebuilt downstream)", async () => {
+    // retrieve() runs filterByValidity which returns a NEW array, dropping any
+    // property hung on the result array. omitted must survive via the resultSet snapshot.
+    const candidates = Array.from({ length: 6 }, (_, i) => buildCandidate(`m${i}`, 0.9 - i * 0.01));
+    const retriever = makeRetriever(candidates);
+
+    const results = await retriever.retrieve({ query: "user reply style preference detail", limit: 2, category: "preferences" }) as RetrievalResultSet;
+
+    expect(results).toHaveLength(2);
+    expect(results.omitted?.count).toBe(4); // 6 - 2
+  });
+
+  it("reports omitted even when sourceDiversity caps the diversified pool (P3-1)", async () => {
+    // 启用 sourceDiversity 时 applySourceDiversity 先把 diversified 压到 limit；
+    // omitted 必须从 source-diversity 之前的候选池(clusterDeduped)算，否则恒为 0（Codex 复审 P3-1）。
+    const candidates = Array.from({ length: 8 }, (_, i) => buildCandidate(`m${i}`, 0.9 - i * 0.01));
+    const retriever = makeRetriever(candidates, { sourceDiversity: 0.5 });
+
+    const results = await retriever.retrieve({ query: "user reply style preference detail", limit: 3, category: "preferences" }) as RetrievalResultSet;
+
+    expect(results).toHaveLength(3);
+    expect(results.omitted?.count).toBe(5); // 8 - 3，即使 source diversity 压缩了 diversified
+  });
+});

package/src/__tests__/pending-review.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "bun:test";
+import {
+  parseEvolution,
+  patchEvolution,
+  defaultEvolution,
+  buildPendingReviewMetadata,
+  isPendingReview,
+  resolvePendingReview,
+  isActiveMemory,
+} from "../memory-evolution.js";
+
+describe("HP-6: Pending review (delayed judgment)", () => {
+  describe("buildPendingReviewMetadata", () => {
+    it("marks entry as pending_review", () => {
+      const meta = patchEvolution("{}", defaultEvolution());
+      const result = buildPendingReviewMetadata(meta);
+      const evo = parseEvolution(result);
+      expect(evo.status).toBe("pending_review");
+    });
+
+    it("preserves other evolution fields", () => {
+      const meta = patchEvolution("{}", { ...defaultEvolution(), accessCount: 5 });
+      const result = buildPendingReviewMetadata(meta);
+      const evo = parseEvolution(result);
+      expect(evo.status).toBe("pending_review");
+      expect(evo.accessCount).toBe(5);
+    });
+  });
+
+  describe("isPendingReview", () => {
+    it("returns true for pending_review status", () => {
+      const meta = buildPendingReviewMetadata(patchEvolution("{}", defaultEvolution()));
+      expect(isPendingReview(meta)).toBe(true);
+    });
+
+    it("returns false for active status", () => {
+      const meta = patchEvolution("{}", defaultEvolution());
+      expect(isPendingReview(meta)).toBe(false);
+    });
+
+    it("returns false for undefined", () => {
+      expect(isPendingReview(undefined)).toBe(false);
+    });
+  });
+
+  describe("resolvePendingReview", () => {
+    it("transitions pending_review → active", () => {
+      const meta = buildPendingReviewMetadata(patchEvolution("{}", defaultEvolution()));
+      expect(parseEvolution(meta).status).toBe("pending_review");
+
+      const resolved = resolvePendingReview(meta);
+      expect(parseEvolution(resolved).status).toBe("active");
+    });
+  });
+
+  describe("isActiveMemory includes pending_review", () => {
+    it("active → true", () => {
+      const meta = patchEvolution("{}", defaultEvolution());
+      expect(isActiveMemory(meta)).toBe(true);
+    });
+
+    it("pending_review → true (participates in search)", () => {
+      const meta = buildPendingReviewMetadata(patchEvolution("{}", defaultEvolution()));
+      expect(isActiveMemory(meta)).toBe(true);
+    });
+
+    it("superseded → false", () => {
+      const meta = patchEvolution("{}", { ...defaultEvolution(), status: "superseded" });
+      expect(isActiveMemory(meta)).toBe(false);
+    });
+
+    it("archived → false", () => {
+      const meta = patchEvolution("{}", { ...defaultEvolution(), status: "archived" });
+      expect(isActiveMemory(meta)).toBe(false);
+    });
+  });
+});

package/src/__tests__/pii-redact.test.ts

@@ -0,0 +1,333 @@
+import { describe, expect, it } from "bun:test";
+
+import { redactSecrets, redactForLog, scanForPII } from "../pii-detector.js";
+import { persistMemory } from "../capture-engine.js";
+import type { AuditEntry } from "../audit-log.js";
+
+const TEST_SCOPE = "project:test";
+
+// ============================================================================
+// redactSecrets — rule coverage
+// ============================================================================
+
+describe("redactSecrets", () => {
+  it("scrubs Anthropic API keys with the specific type", () => {
+    const r = redactSecrets("my key is sk-ant-api03-AbCdEf12345678 ok");
+    expect(r.text).toBe("my key is [REDACTED:anthropic_key] ok");
+    expect(r.redacted).toBe(1);
+  });
+
+  it("does not scrub the sk tail of hyphenated slugs (task-, risk-)", () => {
+    for (const slug of [
+      "pivot-decision-task-assignment-worker-stability-fix",
+      "pivot-judgment-shift-risk-gated-review-decision-process",
+      "note about task-ant-colony-simulation-experiment-log",
+    ]) {
+      const r = redactSecrets(slug);
+      expect(r.redacted).toBe(0);
+      expect(r.text).toBe(slug);
+    }
+  });
+
+  it("still scrubs sk- keys that start their own token", () => {
+    const quoted = redactSecrets('key="sk-AbCdEfGhIjKlMnOpQrStUvWx1234"');
+    expect(quoted.redacted).toBe(1);
+    const lineStart = redactSecrets("sk-AbCdEfGhIjKlMnOpQrStUvWx1234 trailing");
+    expect(lineStart.redacted).toBe(1);
+  });
+
+  it("scrubs GitHub tokens", () => {
+    const r = redactSecrets("push with ghp_ABCDEFGHIJKLMNOPQRSTUV1234567890");
+    expect(r.text).toContain("[REDACTED:github_token]");
+    expect(r.text).not.toContain("ghp_");
+  });
+
+  it("scrubs Slack tokens", () => {
+    const r = redactSecrets("xoxb-123456789-abcdefghij is the bot token");
+    expect(r.text).toContain("[REDACTED:slack_token]");
+  });
+
+  it("scrubs AWS access key IDs", () => {
+    const r = redactSecrets("aws AKIAIOSFODNN7EXAMPLE used");
+    expect(r.text).toContain("[REDACTED:aws_access_key]");
+    expect(r.text).not.toContain("AKIA");
+  });
+
+  it("scrubs Google API keys", () => {
+    // Real Google API keys are exactly "AIza" + 35 chars
+    const r = redactSecrets(`key ${"AIzaSyB" + "x".repeat(32)} in config`);
+    expect(r.text).toContain("[REDACTED:google_api_key]");
+  });
+
+  it("scrubs JWTs", () => {
+    const jwt = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U";
+    const r = redactSecrets(`token: bearer-less ${jwt} end`);
+    expect(r.text).toContain("[REDACTED:jwt]");
+    expect(r.text).not.toContain("eyJhbGci");
+  });
+
+  it("scrubs Bearer headers", () => {
+    const r = redactSecrets("Authorization: Bearer abcdef1234567890XYZ_token");
+    expect(r.text).toContain("[REDACTED:bearer_token]");
+  });
+
+  it("scrubs PEM private key blocks including the body", () => {
+    const pem = "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQEA\nsecretbody\n-----END RSA PRIVATE KEY-----";
+    const r = redactSecrets(`config:\n${pem}\ndone`);
+    expect(r.text).toContain("[REDACTED:pem_private_key]");
+    expect(r.text).not.toContain("MIIEowIBAAKCAQEA");
+    expect(r.text).not.toContain("secretbody");
+  });
+
+  it("keeps the key name for password assignments, scrubs only the value", () => {
+    const r = redactSecrets("db config password=SuperSecret99 in env");
+    expect(r.text).toContain("password=[REDACTED:password]");
+    expect(r.text).not.toContain("SuperSecret99");
+  });
+
+  it("keeps the key name for api_key/token/secret assignments", () => {
+    const r = redactSecrets("set api_key=abcdefghij1234567890XYZAB then restart");
+    expect(r.text).toContain("api_key=[REDACTED:api_key]");
+    expect(r.text).not.toContain("abcdefghij1234567890XYZAB");
+  });
+
+  it("scrubs Chinese national ID numbers (checksum-valid)", () => {
+    const r = redactSecrets("身份证 11010519491231002X 登记");
+    expect(r.text).toContain("[REDACTED:id_number]");
+    expect(r.text).not.toContain("11010519491231002X");
+  });
+
+  it("scrubs credit card numbers (Luhn-valid)", () => {
+    const r = redactSecrets("card 4111 1111 1111 1111 charged");
+    expect(r.text).toContain("[REDACTED:credit_card]");
+  });
+
+  // codex review 2026-07-10: JSON/YAML/config credential forms must be caught
+  it("scrubs JSON-style quoted credential keys", () => {
+    const r = redactSecrets('config: {"password": "SuperSecret99", "region": "us"}');
+    expect(r.text).not.toContain("SuperSecret99");
+    expect(r.text).toContain("[REDACTED:password]");
+  });
+
+  it("scrubs JSON-style quoted api_key", () => {
+    const r = redactSecrets('{"api_key": "abcdefghij1234567890XYZAB"}');
+    expect(r.text).not.toContain("abcdefghij1234567890XYZAB");
+    expect(r.text).toContain("[REDACTED:api_key]");
+  });
+
+  it("scrubs YAML/config assignments with spaces around the separator", () => {
+    const r = redactSecrets("password = SuperSecret99\nsecret : abcdefghij1234567890XYZAB");
+    expect(r.text).not.toContain("SuperSecret99");
+    expect(r.text).not.toContain("abcdefghij1234567890XYZAB");
+  });
+});
+
+// ============================================================================
+// redactSecrets — false-positive guards
+// ============================================================================
+
+describe("redactSecrets false-positive guards", () => {
+  it("does NOT scrub git commit hashes (40-char hex)", () => {
+    const sha = "699bea8f3d2c1a0b9e8d7c6b5a4f3e2d1c0b9a87";
+    const r = redactSecrets(`fixed in commit ${sha} on main`);
+    expect(r.text).toContain(sha);
+    expect(r.redacted).toBe(0);
+  });
+
+  it("does NOT scrub phone numbers or emails (detection-only)", () => {
+    const r = redactSecrets("联系 13812345678 或 alice@example.com");
+    expect(r.text).toContain("13812345678");
+    expect(r.text).toContain("alice@example.com");
+    expect(r.redacted).toBe(0);
+  });
+
+  // codex review 2026-07-10: broad numeric patterns must checksum before scrub
+  it("does NOT scrub 19-digit snowflake IDs (boundary guard)", () => {
+    const id = "1891234567890123456";
+    const r = redactSecrets(`tweet id ${id} archived`);
+    expect(r.text).toContain(id);
+    expect(r.redacted).toBe(0);
+  });
+
+  it("does NOT scrub 18-digit numbers failing the ID checksum", () => {
+    const fake = "110105194912310020"; // checksum digit wrong on purpose
+    const r = redactSecrets(`订单号 ${fake} 已发货`);
+    expect(r.text).toContain(fake);
+    expect(r.redacted).toBe(0);
+  });
+
+  it("does NOT scrub 16-digit numbers failing Luhn", () => {
+    const orderNo = "1234567890123456"; // Luhn-invalid
+    const r = redactSecrets(`订单 ${orderNo} 状态正常`);
+    expect(r.text).toContain(orderNo);
+    expect(r.redacted).toBe(0);
+  });
+
+  it("leaves ordinary Chinese engineering notes untouched", () => {
+    const text = "修复 admission 门控：noise-filter 英文 greeting 加词边界 + rejection reason 透传";
+    const r = redactSecrets(text);
+    expect(r.text).toBe(text);
+    expect(r.redacted).toBe(0);
+  });
+
+  it("leaves ordinary English text untouched", () => {
+    const text = "The dream pipeline gathers active memories and consolidates clusters.";
+    const r = redactSecrets(text);
+    expect(r.text).toBe(text);
+    expect(r.redacted).toBe(0);
+  });
+});
+
+// ============================================================================
+// redactForLog — redact-then-truncate ordering
+// ============================================================================
+
+describe("redactForLog", () => {
+  it("redacts before truncating so a cut cannot leak a secret prefix", () => {
+    // Secret starts inside the 60-char window; naive slice-then-redact would leak its head
+    const text = "x".repeat(50) + " sk-ant-api03-SECRETSECRETSECRET tail";
+    const logged = redactForLog(text, 60);
+    expect(logged).not.toContain("sk-ant");
+    expect(logged.length).toBeLessThanOrEqual(60);
+  });
+
+  it("keeps clean text as-is within the limit", () => {
+    expect(redactForLog("short clean text", 60)).toBe("short clean text");
+  });
+});
+
+// ============================================================================
+// scanForPII — backward compatibility
+// ============================================================================
+
+describe("scanForPII backward compatibility", () => {
+  it("still detects and masks without altering behavior", () => {
+    const result = scanForPII("password=SuperSecret99");
+    expect(result.hasPII).toBe(true);
+    expect(result.detections[0].type).toBe("password");
+    // masked match must not contain the full secret
+    expect(result.detections[0].match).not.toBe("password=SuperSecret99");
+  });
+
+  it("reports new vendor token types", () => {
+    const result = scanForPII("sk-ant-api03-AbCdEf12345678");
+    expect(result.hasPII).toBe(true);
+    expect(result.detections.some((d) => d.type === "anthropic_key")).toBe(true);
+  });
+});
+
+// ============================================================================
+// persistMemory integration — redaction reaches every surface
+// ============================================================================
+
+function createDeps() {
+  const storedEntries: any[] = [];
+  const embeddedTexts: string[] = [];
+  const auditEntries: Array<Omit<AuditEntry, "timestamp">> = [];
+  let seq = 1;
+
+  return {
+    storedEntries,
+    embeddedTexts,
+    auditEntries,
+    deps: {
+      embedder: {
+        async embedPassage(text: string) {
+          embeddedTexts.push(text);
+          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() {
+          return [];
+        },
+        async update() {
+          return null;
+        },
+        async getById() {
+          return null;
+        },
+        async get() {
+          return null;
+        },
+      },
+      auditLogger: {
+        log(entry: Omit<AuditEntry, "timestamp">) {
+          auditEntries.push(entry);
+        },
+        getRecent: () => [],
+        exportAll: () => [],
+        count: () => 0,
+      },
+    },
+  };
+}
+
+describe("persistMemory redaction integration", () => {
+  it("embeds, stores, and audit-logs the scrubbed text, never the raw secret", async () => {
+    const h = createDeps();
+    const result = await persistMemory(h.deps as any, {
+      text: "部署踩坑：用了 password=SuperSecret99 连测试库，改环境变量后修复，教训是配置不进代码",
+      category: "cases",
+      importance: 0.9,
+      scope: TEST_SCOPE,
+      source: "manual",
+    });
+
+    expect(result.disposition).not.toBe("rejected");
+    // Embedding API never saw the secret
+    expect(h.embeddedTexts.length).toBeGreaterThan(0);
+    for (const t of h.embeddedTexts) {
+      expect(t).not.toContain("SuperSecret99");
+    }
+    // Stored text is scrubbed but keeps the key name for readability
+    expect(h.storedEntries[0].text).toContain("password=[REDACTED:password]");
+    expect(h.storedEntries[0].text).not.toContain("SuperSecret99");
+    // Audit log details are scrubbed too
+    for (const e of h.auditEntries) {
+      expect(e.details ?? "").not.toContain("SuperSecret99");
+    }
+  });
+
+  it("records piiWarning with redacted count in metadata", async () => {
+    const h = createDeps();
+    await persistMemory(h.deps as any, {
+      text: "记录一下：测试环境 token=abcdefghij1234567890XYZAB 已经轮换过了，流程要固化下来",
+      category: "cases",
+      importance: 0.9,
+      scope: TEST_SCOPE,
+      source: "manual",
+    });
+
+    const meta = JSON.parse(h.storedEntries[0].metadata ?? "{}");
+    expect(meta.piiWarning).toBeDefined();
+    expect(meta.piiWarning.redacted).toBeGreaterThan(0);
+  });
+
+  it("writes a reject entry to the audit log when admission rejects", async () => {
+    const h = createDeps();
+    const result = await persistMemory(h.deps as any, {
+      text: "ok", // below minTextLength → admission reject
+      category: "cases",
+      importance: 0.9,
+      scope: TEST_SCOPE,
+      source: "manual",
+    });
+
+    expect(result.disposition).toBe("rejected");
+    const rejects = h.auditEntries.filter((e) => e.operation === "reject");
+    expect(rejects.length).toBe(1);
+    expect(rejects[0].scope).toBe(TEST_SCOPE);
+    expect(rejects[0].details ?? "").toContain("ok");
+  });
+});