recallnest 3.0.0 → 3.0.1

package/src/__tests__/continuity-eval.test.ts

@@ -1,275 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { buildContinuityEvalObservationInput, buildContinuityEvalRequest, createContinuityEvalCheckpointStore, runContinuityEval, runRetrievalEval, scoreContinuityCase } from "../eval.js";
-import type { ResumeContextResponse } from "../session-schema.js";
-
-describe("scoreContinuityCase", () => {
-  it("forwards profile and continuity fields into resume_context eval requests", () => {
-    expect(buildContinuityEvalRequest({
-      name: "writing_sparse",
-      task: "不要让我重复前情，接着写",
-      profile: "writing",
-      scope: "project:recallnest",
-      sessionId: "session-1",
-      limitPerSection: 4,
-      includeLatestCheckpoint: true,
-    })).toEqual({
-      task: "不要让我重复前情，接着写",
-      scope: "project:recallnest",
-      sessionId: "session-1",
-      profile: "writing",
-      limitPerSection: 4,
-      includeLatestCheckpoint: true,
-    });
-  });
-
-  it("falls back to the case checkpoint sessionId when the eval case omits top-level sessionId", () => {
-    expect(buildContinuityEvalRequest({
-      name: "project_scope_checkpoint_continuity",
-      task: "继续这个项目，不要让我重复前情",
-      profile: "default",
-      scope: "project:recallnest",
-      includeLatestCheckpoint: true,
-      checkpoint: {
-        sessionId: "eval-project-recallnest-checkpoint",
-        scope: "project:recallnest",
-        summary: "RecallNest continuity acceptance checkpoint fixture.",
-      },
-    })).toEqual({
-      task: "继续这个项目，不要让我重复前情",
-      scope: "project:recallnest",
-      sessionId: "eval-project-recallnest-checkpoint",
-      profile: "default",
-      limitPerSection: undefined,
-      includeLatestCheckpoint: true,
-    });
-  });
-
-  it("scores a continuity response using section-specific expectations", () => {
-    const response: ResumeContextResponse = {
-      summary: "Loaded stable context with a latest checkpoint for RecallNest continuity work.",
-      stableContext: [
-        "Preference: User prefers concise technical replies.",
-        "Entity: RecallNest is shared across Claude Code, Codex, and Gemini CLI.",
-      ],
-      relevantPatterns: [
-        "At task start, run search_memory before coding.",
-      ],
-      recentCases: [
-        "Keep session state in a checkpoint store instead of the durable index.",
-      ],
-      latestCheckpoint: {
-        sessionId: "session-1",
-        summary: "Continue building resume_context for fresh windows",
-        updatedAt: "2026-03-16T06:00:00.000Z",
-      },
-      generatedAt: "2026-03-16T06:05:00.000Z",
-    };
-
-    const report = scoreContinuityCase({
-      name: "continuity_case",
-      task: "continue RecallNest work",
-      expectStableAny: ["RecallNest", "Codex"],
-      expectPatternsAny: ["search_memory"],
-      expectCasesAny: ["checkpoint store"],
-      expectCheckpointAny: ["resume_context"],
-    }, response);
-
-    expect(report.passed).toBe(true);
-    expect(report.matchedStableAny).toEqual(["RecallNest", "Codex"]);
-    expect(report.matchedPatternsAny).toEqual(["search_memory"]);
-    expect(report.matchedCasesAny).toEqual(["checkpoint store"]);
-    expect(report.matchedCheckpointAny).toEqual(["resume_context"]);
-    expect(report.hasCheckpoint).toBe(true);
-    expect(report.score).toBeGreaterThan(0.9);
-  });
-
-  it("penalizes forbidden matches", () => {
-    const response: ResumeContextResponse = {
-      summary: "Loaded unrelated stable context.",
-      stableContext: ["Profile: unrelated memory"],
-      relevantPatterns: [],
-      recentCases: [],
-      generatedAt: "2026-03-16T06:10:00.000Z",
-    };
-
-    const report = scoreContinuityCase({
-      name: "continuity_forbid",
-      task: "fresh window",
-      forbid: ["unrelated"],
-    }, response);
-
-    expect(report.passed).toBe(false);
-    expect(report.forbiddenMatches).toEqual(["unrelated"]);
-    expect(report.score).toBeLessThan(0.8);
-  });
-
-  it("uses only case-defined checkpoint fixtures instead of live checkpoint state", async () => {
-    const checkpointStore = createContinuityEvalCheckpointStore([
-      {
-        name: "checkpoint_case",
-        scope: "recallnest",
-        includeLatestCheckpoint: true,
-        checkpoint: {
-          sessionId: "eval-session-1",
-          scope: "recallnest",
-          summary: "RecallNest Phase 3/4 checkpoint fixture with resume_context and store_memory.",
-          task: "Continue RecallNest continuity work",
-          decisions: ["Keep checkpoints out of the durable index"],
-          updatedAt: "2026-03-16T06:00:00.000Z",
-        },
-      },
-    ]);
-
-    const byScope = await checkpointStore.getLatest({ scope: "recallnest" });
-    const bySession = await checkpointStore.getLatest({ sessionId: "eval-session-1" });
-    const missing = await checkpointStore.getLatest({ scope: "other-project" });
-
-    expect(byScope).toMatchObject({
-      sessionId: "eval-session-1",
-      resolvedScope: "project:recallnest",
-      summary: "RecallNest Phase 3/4 checkpoint fixture with resume_context and store_memory.",
-    });
-    expect(bySession?.resolvedScope).toBe("project:recallnest");
-    expect(missing).toBeNull();
-  });
-
-  it("builds workflow observations for continuity eval results without using regular memory", () => {
-    const passed = buildContinuityEvalObservationInput({
-      name: "continuity_pass",
-      profile: "debug",
-      scope: "project:recallnest",
-    }, {
-      mode: "continuity",
-      name: "continuity_pass",
-      task: "continue RecallNest work",
-      profile: "debug",
-      score: 0.94,
-      passed: true,
-      stableCount: 2,
-      patternCount: 1,
-      caseCount: 1,
-      hasCheckpoint: true,
-      matchedStableAny: [],
-      matchedStableAll: [],
-      matchedPatternsAny: [],
-      matchedCasesAny: [],
-      matchedCheckpointAny: [],
-      forbiddenMatches: [],
-      stablePreview: [],
-      patternPreview: [],
-      casePreview: [],
-      checkpointSummary: "ok",
-    });
-
-    expect(passed).toMatchObject({
-      workflowId: "resume_context",
-      outcome: "success",
-      scope: "project:recallnest",
-      source: "eval",
-      signal: "eval-pass",
-      task: "continuity eval: continuity_pass",
-      tools: ["resume_context"],
-    });
-
-    const failed = buildContinuityEvalObservationInput({
-      name: "continuity_fail",
-      expectPatternsAny: ["search_memory"],
-      expectCheckpointAny: ["checkpoint"],
-    }, {
-      mode: "continuity",
-      name: "continuity_fail",
-      task: "continue",
-      profile: "default",
-      score: 0.42,
-      passed: false,
-      stableCount: 0,
-      patternCount: 0,
-      caseCount: 0,
-      hasCheckpoint: false,
-      matchedStableAny: [],
-      matchedStableAll: [],
-      matchedPatternsAny: [],
-      matchedCasesAny: [],
-      matchedCheckpointAny: [],
-      forbiddenMatches: [],
-      stablePreview: [],
-      patternPreview: [],
-      casePreview: [],
-      checkpointSummary: "-",
-    }, {
-      scope: "eval:continuity",
-      source: "eval",
-    });
-
-    expect(failed).toMatchObject({
-      workflowId: "resume_context",
-      outcome: "failure",
-      scope: "eval:continuity",
-      source: "eval",
-      signal: "missing-patterns",
-      task: "continuity eval: continuity_fail",
-      tools: ["resume_context"],
-    });
-    expect(failed.summary).toContain("failed");
-  });
-
-  it("creates fresh continuity eval components for each case instead of sharing one resolver", async () => {
-    let componentCreations = 0;
-
-    const reports = await runContinuityEval([
-      { name: "case-a", task: "continue A" },
-      { name: "case-b", task: "continue B" },
-    ], {}, {
-      createEvalComponents: () => {
-        componentCreations += 1;
-        const instanceId = componentCreations;
-        return {
-          retriever: {
-            instanceId,
-            async retrieve() {
-              return [];
-            },
-          } as never,
-          accessTracker: {
-            destroy() {},
-          } as never,
-        };
-      },
-      composeResumeContextFn: async (deps) => ({
-        summary: `instance:${(deps.retriever as { instanceId: number }).instanceId}`,
-        stableContext: [`instance:${(deps.retriever as { instanceId: number }).instanceId}`],
-        relevantPatterns: [],
-        recentCases: [],
-        generatedAt: "2026-03-20T00:00:00.000Z",
-      }),
-    });
-
-    expect(componentCreations).toBe(2);
-    expect(reports[0]?.stablePreview[0]).toContain("instance:1");
-    expect(reports[1]?.stablePreview[0]).toContain("instance:2");
-  });
-
-  it("runs retrieval eval in auto-recall mode so eval does not reinforce access counts", async () => {
-    const seenSources: string[] = [];
-
-    const reports = await runRetrievalEval([
-      { name: "retrieval_case", query: "RecallNest" },
-    ], {
-      createEvalComponents: () => ({
-        retriever: {
-          async retrieve(context) {
-            seenSources.push(context.source || "unset");
-            return [];
-          },
-        } as never,
-        accessTracker: {
-          destroy() {},
-        } as never,
-      }),
-    });
-
-    expect(seenSources).toEqual(["auto-recall"]);
-    expect(reports).toHaveLength(1);
-  });
-});

package/src/__tests__/continuity-schema.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { PromoteMemoryInputSchema, StoreMemoryInputSchema } from "../memory-schema.js";
-import { ResumeContextRequestSchema, ResumeContextResponseSchema, SessionCheckpointInputSchema } from "../session-schema.js";
-
-describe("StoreMemoryInputSchema", () => {
-  it("normalizes whitespace, defaults, and deduplicates tags", () => {
-    const parsed = StoreMemoryInputSchema.parse({
-      text: "  User prefers   dark mode  ",
-      category: "preferences",
-      scope: "project:test",
-      tags: [" ui ", "UI", "frontend"],
-      canonicalKey: " user.reply.style ",
-    });
-
-    expect(parsed.text).toBe("User prefers dark mode");
-    expect(parsed.importance).toBe(0.7);
-    expect(parsed.source).toBe("manual");
-    expect(parsed.tags).toEqual(["ui", "frontend"]);
-    expect(parsed.canonicalKey).toBe("user.reply.style");
-  });
-
-  it("rejects unsupported categories", () => {
-    expect(() => StoreMemoryInputSchema.parse({
-      text: "Persist this",
-      category: "decision",
-    })).toThrow();
-  });
-});
-
-describe("PromoteMemoryInputSchema", () => {
-  it("applies defaults for evidence promotion", () => {
-    const parsed = PromoteMemoryInputSchema.parse({
-      memoryId: "12345678-1234-1234-1234-123456789abc",
-      scope: "project:test",
-    });
-
-    expect(parsed.importance).toBe(0.78);
-    expect(parsed.source).toBe("agent");
-    expect(parsed.tags).toEqual([]);
-  });
-});
-
-describe("SessionCheckpointInputSchema", () => {
-  it("defaults updatedAt and deduplicates list fields", () => {
-    const parsed = SessionCheckpointInputSchema.parse({
-      sessionId: "session-123",
-      summary: "  Working on continuity layer  ",
-      decisions: ["Use session checkpoints", "use session checkpoints"],
-      nextActions: ["Add MCP store_memory", " Add MCP store_memory "],
-    });
-
-    expect(parsed.summary).toBe("Working on continuity layer");
-    expect(parsed.decisions).toEqual(["Use session checkpoints"]);
-    expect(parsed.nextActions).toEqual(["Add MCP store_memory"]);
-    expect(parsed.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-  });
-});
-
-describe("ResumeContext schemas", () => {
-  it("applies defaults for request parsing", () => {
-    const parsed = ResumeContextRequestSchema.parse({});
-
-    expect(parsed.limitPerSection).toBe(3);
-    expect(parsed.includeLatestCheckpoint).toBe(true);
-    expect(parsed.profile).toBeUndefined();
-  });
-
-  it("preserves optional retrieval profile on request parsing", () => {
-    const parsed = ResumeContextRequestSchema.parse({
-      profile: "writing",
-    });
-
-    expect(parsed.profile).toBe("writing");
-  });
-
-  it("accepts a composed response payload", () => {
-    const parsed = ResumeContextResponseSchema.parse({
-      summary: "Bring forward user identity, recent cases, and the latest checkpoint.",
-      resolvedScope: "project:recallnest",
-      stableContext: ["User works across Claude Code, Codex, and Gemini CLI"],
-      relevantPatterns: ["Always search memory at task start"],
-      recentCases: ["Fixed hybrid retrieval tuning last week"],
-      latestCheckpoint: {
-        sessionId: "session-123",
-        resolvedScope: "project:recallnest",
-        summary: "Implement schema modules first",
-        updatedAt: "2026-03-16T01:41:00.000Z",
-      },
-      generatedAt: "2026-03-16T01:42:00.000Z",
-    });
-
-    expect(parsed.latestCheckpoint?.sessionId).toBe("session-123");
-    expect(parsed.resolvedScope).toBe("project:recallnest");
-    expect(parsed.stableContext).toHaveLength(1);
-  });
-});

package/src/__tests__/contracts.test.ts

@@ -1,262 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { resetWriteCount } from "../activity-counter.js";
-import { resetGcTimestamp } from "../auto-gc.js";
-import { runDream } from "../dream-pipeline.js";
-import { MemoryStore } from "../store.js";
-import { PACKAGE_VERSION } from "../version.js";
-
-// Isolate the activity-counter default path away from the repo's data/activity-stats.json.
-let __origDataDir: string | undefined;
-beforeAll(() => {
-  __origDataDir = process.env.RECALLNEST_DATA_DIR;
-  process.env.RECALLNEST_DATA_DIR = mkdtempSync(join(tmpdir(), "rn-contracts-datadir-"));
-});
-afterAll(() => {
-  if (__origDataDir === undefined) delete process.env.RECALLNEST_DATA_DIR;
-  else process.env.RECALLNEST_DATA_DIR = __origDataDir;
-});
-
-const tmpDirs: string[] = [];
-
-function makeTmpDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), "recallnest-contract-"));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-function makeStore(): MemoryStore {
-  return new MemoryStore({ dbPath: makeTmpDir(), vectorDim: 3 });
-}
-
-function uuidFor(n: number): string {
-  return `00000000-0000-4000-8000-${n.toString(16).padStart(12, "0")}`;
-}
-
-function activeMetadata(validFrom = Date.now()): string {
-  return JSON.stringify({
-    evolution: {
-      status: "active",
-      version: 1,
-      accessCount: 0,
-      lastAccessedAt: null,
-      supersededBy: null,
-      consolidatedInto: null,
-      contributedToPattern: null,
-      sourceMemories: [],
-      validFrom,
-      validUntil: null,
-    },
-  });
-}
-
-afterEach(() => {
-  while (tmpDirs.length > 0) {
-    const dir = tmpDirs.pop();
-    if (dir) rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("MemoryStore interface contract", () => {
-  it("returns stats with totalCount and no legacy total field", async () => {
-    const store = makeStore();
-
-    await store.store({
-      id: "contract-stats-1",
-      text: "contract stats one",
-      vector: [1, 0, 0],
-      category: "events",
-      scope: "project:contracts",
-      importance: 0.4,
-      metadata: activeMetadata(),
-    });
-    await store.store({
-      id: "contract-stats-2",
-      text: "contract stats two",
-      vector: [0, 1, 0],
-      category: "preferences",
-      scope: "project:contracts",
-      importance: 0.6,
-      metadata: activeMetadata(),
-    });
-
-    const stats = await store.stats(["project:contracts"]);
-
-    expect(stats.totalCount).toBe(2);
-    expect(stats.scopeCounts["project:contracts"]).toBe(2);
-    expect(stats.categoryCounts.events).toBe(1);
-    expect(stats.categoryCounts.preferences).toBe(1);
-    expect("total" in stats).toBe(false);
-  });
-
-  it("uses positional list(scopeFilter, category, limit, offset) arguments", async () => {
-    const store = makeStore();
-
-    await store.store({
-      id: "contract-list-1",
-      text: "contract list one",
-      vector: [1, 0, 0],
-      category: "events",
-      scope: "project:contracts",
-      importance: 0.5,
-      metadata: activeMetadata(),
-    });
-    await store.store({
-      id: "contract-list-2",
-      text: "contract list two",
-      vector: [0, 1, 0],
-      category: "events",
-      scope: "project:contracts",
-      importance: 0.5,
-      metadata: activeMetadata(),
-    });
-    await store.store({
-      id: "contract-list-3",
-      text: "contract list out of scope",
-      vector: [0, 0, 1],
-      category: "events",
-      scope: "project:other",
-      importance: 0.5,
-      metadata: activeMetadata(),
-    });
-
-    const oneEvent = await store.list(["project:contracts"], "events", 1, 1);
-    const allEvents = await store.list(["project:contracts"], "events", 10, 0);
-
-    expect(oneEvent).toHaveLength(1);
-    expect(oneEvent[0].scope).toBe("project:contracts");
-    expect(oneEvent[0].category).toBe("events");
-    expect(allEvents.map(e => e.id).sort()).toEqual(["contract-list-1", "contract-list-2"]);
-  });
-});
-
-describe("Dream pipeline store contract", () => {
-  beforeEach(() => {
-    resetWriteCount("project:contracts");
-    resetGcTimestamp();
-  });
-
-  it("runs prune through auto-gc with real stats/list signatures", async () => {
-    const store = makeStore();
-    const scope = "project:contracts";
-    const oldTimestamp = Date.now() - 120 * 86_400_000;
-
-    for (let i = 0; i < 3; i++) {
-      await store.store({
-        id: uuidFor(i),
-        text: `contract dream stale memory ${i}`,
-        vector: [1, 0, 0],
-        category: "events",
-        scope,
-        importance: 0.1,
-        metadata: activeMetadata(oldTimestamp),
-      });
-    }
-
-    const result = await runDream({
-      store,
-      llm: null,
-      embedder: { async embedPassage() { return [1, 0, 0]; } },
-      scope,
-      force: true,
-      config: {
-        minClusterSize: 3,
-        maxEntriesPerRun: 10,
-        gc: {
-          minMemoryCount: 1,
-          minHoursSinceLastGc: 0,
-          decayScoreThreshold: 0.99,
-          maxArchivePerRun: 10,
-          minAgeDays: 0,
-        },
-      },
-    });
-
-    expect(result.ran).toBe(true);
-    expect(result.stats.archivedCount).toBeGreaterThan(0);
-    expect(result.phases.find(p => p.phase === "prune")?.detail).toContain("entries archived");
-  });
-});
-
-describe("MCP registry contract", () => {
-  it("keeps registered tool count and tier header in sync", () => {
-    const source = readFileSync(join(import.meta.dir, "..", "mcp-server.ts"), "utf8");
-    const header = source.slice(0, source.indexOf("const TOOL_TIERS"));
-    // P3-B: the 44 registerTool(...) calls now live in the tier modules; mcp-server.ts
-    // still owns TOOL_TIERS and the tier-count header comment above it.
-    const registeredTools = ["mcp-tools-core", "mcp-tools-advanced", "mcp-tools-governance"]
-      .flatMap((name) =>
-        [...readFileSync(join(import.meta.dir, "..", `${name}.ts`), "utf8")
-          .matchAll(/^\s*registerTool\(\s*"([^"]+)"/gm)].map((m) => m[1]),
-      );
-    const tiers = new Map(
-      [...source.matchAll(/^\s*([A-Za-z0-9_]+):\s*"(core|advanced|governance)"/gm)]
-        .map(m => [m[1], m[2]] as const),
-    );
-
-    const missingTier = registeredTools.filter(name => !tiers.has(name));
-    const coreCount = registeredTools.filter(name => tiers.get(name) === "core").length;
-    const defaultCount = registeredTools.filter(name => tiers.get(name) !== "governance").length;
-    const fullCount = registeredTools.length;
-
-    const headerCount = (tier: "core" | "advanced" | "full") => {
-      const match = header.match(new RegExp(`\\* - ${tier}:.*\\((\\d+) tools\\)`));
-      expect(match).not.toBeNull();
-      return Number(match![1]);
-    };
-
-    expect(registeredTools).toHaveLength(44);
-    expect(missingTier).toEqual([]);
-    expect(headerCount("core")).toBe(coreCount);
-    expect(headerCount("advanced")).toBe(defaultCount);
-    expect(headerCount("full")).toBe(fullCount);
-  });
-});
-
-describe("Release metadata contract", () => {
-  it("keeps every public version surface aligned with package.json", () => {
-    const root = join(import.meta.dir, "..", "..");
-    const packageMetadata = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
-    const marketplaceMetadata = JSON.parse(
-      readFileSync(join(root, ".claude-plugin", "marketplace.json"), "utf8"),
-    );
-
-    expect(marketplaceMetadata.plugins).toHaveLength(1);
-    expect(PACKAGE_VERSION).toBe(packageMetadata.version);
-    expect(marketplaceMetadata.plugins[0].version).toBe(packageMetadata.version);
-
-    for (const file of ["cli.ts", "mcp-server.ts", "api-server.ts"]) {
-      const source = readFileSync(join(root, "src", file), "utf8");
-      expect(source).toContain("PACKAGE_VERSION");
-      expect(source).not.toMatch(/version:\s*["'](?:1\.0\.0|1\.4\.0)["']/);
-    }
-  });
-
-  it("ships a self-contained Claude Code plugin without project MCP overrides", () => {
-    const root = join(import.meta.dir, "..", "..");
-    const marketplaceMetadata = JSON.parse(
-      readFileSync(join(root, ".claude-plugin", "marketplace.json"), "utf8"),
-    );
-    const plugin = marketplaceMetadata.plugins[0];
-    const projectMcp = JSON.parse(readFileSync(join(root, ".mcp.json"), "utf8"));
-
-    expect(plugin.strict).toBe(false);
-    expect(plugin.skills).toContain("./.claude-plugin/recallnest-skill");
-    expect(plugin.mcpServers.recallnest.args).toContain(
-      "${CLAUDE_PLUGIN_ROOT}/scripts/start-server.sh",
-    );
-    expect(plugin.mcpServers.recallnest.env.LOCAL_MEMORY_CONFIG).toBe(
-      "${CLAUDE_PLUGIN_DATA}/config.json",
-    );
-    expect(plugin.mcpServers.recallnest.env.RECALLNEST_MCP_TIER).toBe("full");
-    expect(plugin.userConfig.jina_api_key).toMatchObject({
-      type: "string",
-      sensitive: true,
-      required: true,
-    });
-    expect(projectMcp.mcpServers).toEqual({});
-  });
-});