@vellumai/assistant 0.7.1 → 0.7.3

package/src/memory/__tests__/memory-v2-concept-frequency.test.ts

@@ -0,0 +1,272 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+let listPagesImpl: (workspaceDir: string) => Promise<string[]> = async () => [];
+
+mock.module("../v2/page-store.js", () => ({
+  listPages: (workspaceDir: string) => listPagesImpl(workspaceDir),
+}));
+
+import { getDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import {
+  type MemoryV2ConceptRowRecord,
+  recordMemoryV2ActivationLog,
+} from "../memory-v2-activation-log-store.js";
+import { getConceptFrequencySummary } from "../memory-v2-concept-frequency.js";
+import { memoryV2ActivationLogs } from "../schema.js";
+import { sampleConfig } from "./fixtures/memory-v2-activation-fixtures.js";
+
+initializeDb();
+
+const WORKSPACE = "/tmp/memory-v2-concept-frequency-test";
+
+function makeConcept(
+  slug: string,
+  status: MemoryV2ConceptRowRecord["status"],
+): MemoryV2ConceptRowRecord {
+  return {
+    slug,
+    finalActivation: 0.5,
+    ownActivation: 0.4,
+    priorActivation: 0.1,
+    simUser: 0.3,
+    simAssistant: 0.2,
+    simNow: 0.1,
+    simUserRerankBoost: 0,
+    simAssistantRerankBoost: 0,
+    inRerankPool: false,
+    spreadContribution: 0.1,
+    source: "ann_top50",
+    status,
+  };
+}
+
+function resetTables(): void {
+  getDb().delete(memoryV2ActivationLogs).run();
+}
+
+describe("memory-v2-concept-frequency", () => {
+  beforeEach(() => {
+    resetTables();
+    listPagesImpl = async () => [];
+  });
+
+  test("aggregates per-status counts across multiple turns", async () => {
+    const conv = "conv-1";
+    recordMemoryV2ActivationLog({
+      conversationId: conv,
+      turn: 1,
+      mode: "context-load",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("bob", "not_injected"),
+      ],
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId: conv,
+      turn: 2,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "in_context"),
+        makeConcept("bob", "injected"),
+      ],
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId: conv,
+      turn: 3,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("charlie", "page_missing"),
+      ],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice", "bob", "delta"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+
+    expect(result.totals.logCount).toBe(3);
+    expect(result.totals.conceptOccurrences).toBe(6);
+    expect(result.filters).toEqual({ conversationId: null, sinceMs: null });
+
+    const bySlug = new Map(result.concepts.map((c) => [c.slug, c]));
+
+    expect(bySlug.get("alice")!.counts).toEqual({
+      injected: 2,
+      in_context: 1,
+      not_injected: 0,
+      page_missing: 0,
+    });
+    expect(bySlug.get("alice")!.totalEvaluations).toBe(3);
+    expect(bySlug.get("alice")!.onDisk).toBe(true);
+    expect(bySlug.get("alice")!.lastInjectedAt).not.toBeNull();
+
+    expect(bySlug.get("bob")!.counts).toEqual({
+      injected: 1,
+      in_context: 0,
+      not_injected: 1,
+      page_missing: 0,
+    });
+    expect(bySlug.get("bob")!.totalEvaluations).toBe(2);
+    expect(bySlug.get("bob")!.onDisk).toBe(true);
+
+    expect(bySlug.get("charlie")!.counts).toEqual({
+      injected: 0,
+      in_context: 0,
+      not_injected: 0,
+      page_missing: 1,
+    });
+    expect(bySlug.get("charlie")!.onDisk).toBe(false);
+    expect(bySlug.get("charlie")!.lastInjectedAt).toBeNull();
+
+    // Sorted by totalEvaluations desc — alice (3) before bob (2) before charlie (1).
+    expect(result.concepts.map((c) => c.slug)).toEqual([
+      "alice",
+      "bob",
+      "charlie",
+    ]);
+
+    // delta is on disk but never appeared in any log row.
+    expect(result.neverEvaluatedSlugs).toEqual(["delta"]);
+  });
+
+  test("conversationId filter narrows aggregation", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-a",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [makeConcept("alice", "injected")],
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-b",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("alice", "injected"),
+      ],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice"];
+
+    const all = await getConceptFrequencySummary(WORKSPACE, {});
+    expect(all.totals.logCount).toBe(2);
+    expect(all.concepts[0]!.counts.injected).toBe(3);
+    expect(all.filters.conversationId).toBeNull();
+
+    const onlyA = await getConceptFrequencySummary(WORKSPACE, {
+      conversationId: "conv-a",
+    });
+    expect(onlyA.totals.logCount).toBe(1);
+    expect(onlyA.concepts[0]!.counts.injected).toBe(1);
+    expect(onlyA.filters.conversationId).toBe("conv-a");
+
+    const onlyB = await getConceptFrequencySummary(WORKSPACE, {
+      conversationId: "conv-b",
+    });
+    expect(onlyB.totals.logCount).toBe(1);
+    expect(onlyB.concepts[0]!.counts.injected).toBe(2);
+  });
+
+  test("sinceMs filter excludes older log rows", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [makeConcept("alice", "injected")],
+      config: sampleConfig,
+    });
+    // Backdate the just-written row — recordMemoryV2ActivationLog uses Date.now().
+    getDb().update(memoryV2ActivationLogs).set({ createdAt: 1_000 }).run();
+
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 2,
+      mode: "per-turn",
+      concepts: [makeConcept("alice", "injected")],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice"];
+
+    const all = await getConceptFrequencySummary(WORKSPACE, {});
+    expect(all.totals.logCount).toBe(2);
+    expect(all.concepts[0]!.counts.injected).toBe(2);
+
+    const recent = await getConceptFrequencySummary(WORKSPACE, {
+      sinceMs: 10_000,
+    });
+    expect(recent.totals.logCount).toBe(1);
+    expect(recent.concepts[0]!.counts.injected).toBe(1);
+    expect(recent.filters.sinceMs).toBe(10_000);
+  });
+
+  test("never-evaluated list excludes slugs that appeared in any status", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("bob", "not_injected"),
+        makeConcept("charlie", "page_missing"),
+      ],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice", "bob", "delta", "echo"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+    // bob was scored but rejected — still excluded from neverEvaluated.
+    expect(result.neverEvaluatedSlugs).toEqual(["delta", "echo"]);
+  });
+
+  test("returns empty result when no logs exist", async () => {
+    listPagesImpl = async () => ["alice", "bob"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+    expect(result.totals).toEqual({ logCount: 0, conceptOccurrences: 0 });
+    expect(result.concepts).toEqual([]);
+    expect(result.neverEvaluatedSlugs).toEqual(["alice", "bob"]);
+  });
+
+  test("flags slugs that appear in logs but no longer have a page on disk", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [makeConcept("ghost", "injected")],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+    const ghost = result.concepts.find((c) => c.slug === "ghost")!;
+    expect(ghost.onDisk).toBe(false);
+    expect(ghost.counts.injected).toBe(1);
+  });
+});

package/src/memory/__tests__/qdrant-client-sentinel.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+
+import { stripLegacySparseSuffix } from "../qdrant-client.js";
+
+describe("stripLegacySparseSuffix", () => {
+  test("strips a trailing :sparse-v<digit> suffix", () => {
+    expect(
+      stripLegacySparseSuffix("gemini:gemini-embedding-2-preview:sparse-v3"),
+    ).toBe("gemini:gemini-embedding-2-preview");
+  });
+
+  test("strips multi-digit version suffixes", () => {
+    expect(stripLegacySparseSuffix("openai:text-embed-3:sparse-v42")).toBe(
+      "openai:text-embed-3",
+    );
+  });
+
+  test("returns the input unchanged when no suffix is present", () => {
+    expect(stripLegacySparseSuffix("gemini:gemini-embedding-2-preview")).toBe(
+      "gemini:gemini-embedding-2-preview",
+    );
+  });
+
+  test("does not strip a non-trailing :sparse-v segment", () => {
+    expect(stripLegacySparseSuffix("foo:sparse-v3:bar")).toBe(
+      "foo:sparse-v3:bar",
+    );
+  });
+
+  test("does not strip when the version part is missing", () => {
+    expect(stripLegacySparseSuffix("provider:model:sparse-v")).toBe(
+      "provider:model:sparse-v",
+    );
+  });
+
+  test("normalizes legacy and current sentinels to the same value", () => {
+    const legacy = "gemini:gemini-embedding-2-preview:sparse-v2";
+    const current = "gemini:gemini-embedding-2-preview";
+    expect(stripLegacySparseSuffix(legacy)).toBe(
+      stripLegacySparseSuffix(current),
+    );
+  });
+
+  test("differentiates sentinels that diverge on the dense identity", () => {
+    const a = "gemini:gemini-embedding-2-preview:sparse-v2";
+    const b = "openai:text-embedding-3-small:sparse-v2";
+    expect(stripLegacySparseSuffix(a)).not.toBe(stripLegacySparseSuffix(b));
+  });
+});

package/src/memory/__tests__/sparse-tokenize.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from "bun:test";
+
+import { tokenize, tokenizeStemmed } from "../sparse-tokenize.js";
+
+describe("tokenize", () => {
+  test("lowercases and splits on non-alphanumeric runs", () => {
+    expect(tokenize("Hello, World!")).toEqual(["hello", "world"]);
+  });
+
+  test("preserves alphanumeric runs as-is (no stemming)", () => {
+    expect(tokenize("running supplements taking")).toEqual([
+      "running",
+      "supplements",
+      "taking",
+    ]);
+  });
+
+  test("handles Unicode letters and digits", () => {
+    expect(tokenize("café-99 naïve")).toEqual(["café", "99", "naïve"]);
+  });
+
+  test("returns empty array for empty / whitespace input", () => {
+    expect(tokenize("")).toEqual([]);
+    expect(tokenize("   \n\t  ")).toEqual([]);
+  });
+});
+
+describe("tokenizeStemmed", () => {
+  test("collapses plurals to their singular stem", () => {
+    expect(tokenizeStemmed("supplements")).toEqual(["supplement"]);
+    expect(tokenizeStemmed("tests")).toEqual(["test"]);
+  });
+
+  test("collapses verb tenses and gerunds to a shared stem", () => {
+    expect(tokenizeStemmed("taking")).toEqual(["take"]);
+    expect(tokenizeStemmed("running")).toEqual(["run"]);
+    expect(tokenizeStemmed("testing")).toEqual(["test"]);
+  });
+
+  test("singular forms map to themselves (idempotent on stems)", () => {
+    expect(tokenizeStemmed("supplement")).toEqual(["supplement"]);
+    expect(tokenizeStemmed("run")).toEqual(["run"]);
+  });
+
+  test("query and document forms collapse to identical buckets", () => {
+    // Plural query terms must land on the same stem as singular doc terms
+    // (and vice versa). This is the property the BM25 sparse channel
+    // relies on so doc-side weights and query-side occurrences match.
+    const queryTokens = tokenizeStemmed("filing reports");
+    const docTokens = tokenizeStemmed("filed a report");
+    expect(queryTokens).toContain("file");
+    expect(queryTokens).toContain("report");
+    expect(docTokens).toContain("file");
+    expect(docTokens).toContain("report");
+  });
+
+  test("returns empty array for empty input", () => {
+    expect(tokenizeStemmed("")).toEqual([]);
+  });
+
+  test("preserves token order and length (one stem per token)", () => {
+    const original = tokenize("the quick brown foxes were jumping");
+    const stemmed = tokenizeStemmed("the quick brown foxes were jumping");
+    expect(stemmed.length).toBe(original.length);
+  });
+});

package/src/memory/admin.ts

@@ -6,7 +6,6 @@ import { getWorkspaceDir } from "../util/platform.js";
 import { deleteMemoryCheckpoint } from "./checkpoints.js";
 import { runDeterministicRecallSearch } from "./context-search/search.js";
 import type { RecallEvidence } from "./context-search/types.js";
-import { getConversationMemoryScopeId } from "./conversation-crud.js";
 import { getDb } from "./db-connection.js";
 import { getMemoryBackendStatus } from "./embedding-backend.js";
 import {
@@ -32,7 +31,7 @@ import {
 
 const log = getLogger("memory-admin");
 
-export interface MemorySystemStatus {
+interface MemorySystemStatus {
   enabled: boolean;
   degraded: boolean;
   reason: string | null;
@@ -47,7 +46,7 @@ export interface MemorySystemStatus {
   jobs: Record<string, number>;
 }
 
-export interface AdminMemoryQueryResult {
+interface AdminMemoryQueryResult {
   results: Array<{
     id: string;
     content: string;
@@ -106,7 +105,6 @@ export async function queryMemory(
     { query, sources: ["memory", "conversations", "pkb"] },
     {
       workingDir: getWorkspaceDir(),
-      memoryScopeId: getConversationMemoryScopeId(conversationId) ?? "default",
       conversationId,
       config,
     },
@@ -148,7 +146,7 @@ function readNumericMetadata(
 
 // ── Short segment cleanup ─────────────────────────────────────────────
 
-export interface CleanupShortSegmentsResult {
+interface CleanupShortSegmentsResult {
   removed: number;
   failed: number;
   dryRunCount?: number;
@@ -216,7 +214,7 @@ export async function compactLongMemoryNodes(
 
 // ── Re-extraction ──────────────────────────────────────────────────────
 
-export interface ReextractTarget {
+interface ReextractTarget {
   conversationId: string;
   title: string | null;
   messageCount: number;
@@ -312,11 +310,9 @@ export function requestReextract(targets: ReextractTarget[]): {
       )
       .run();
 
-    // Resolve scope and enqueue re-extraction
-    const scopeId = getConversationMemoryScopeId(conversationId);
     const jobId = enqueueMemoryJob("graph_extract", {
       conversationId,
-      scopeId,
+      scopeId: "default",
     });
     jobIds.push(jobId);
 

package/src/memory/anisotropy.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  type AnisotropyCalibration,
+  applyAnisotropyCorrection,
+  explainedVarianceRatio,
+  fitAnisotropyCalibration,
+} from "./anisotropy.js";
+
+const META = { provider: "gemini" as const, model: "test-model" };
+
+function dot(a: readonly number[], b: readonly number[]): number {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+
+function l2Norm(v: readonly number[]): number {
+  return Math.sqrt(dot(v, v));
+}
+
+function l2Normalize(v: readonly number[]): number[] {
+  const n = l2Norm(v);
+  if (n === 0) return [...v];
+  return v.map((x) => x / n);
+}
+
+/**
+ * Build a synthetic anisotropic corpus: every sample lives close to a fixed
+ * direction `axis`, with small Gaussian-ish noise injected in the orthogonal
+ * subspace. This gives us a known top-1 PC the fit must recover.
+ */
+function buildAnisotropicCorpus(
+  n: number,
+  dim: number,
+  axis: readonly number[],
+  noiseScale: number,
+): number[][] {
+  const ax = l2Normalize(axis);
+  const out: number[][] = [];
+  let seed = 42;
+  const rand = () => {
+    // Tiny deterministic LCG so tests don't depend on Math.random.
+    seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+    return seed / 0x7fffffff;
+  };
+  for (let i = 0; i < n; i++) {
+    const v = new Array<number>(dim);
+    // Strong common direction component, slightly varied per sample.
+    const along = 1 + (rand() - 0.5) * 0.1;
+    for (let j = 0; j < dim; j++) v[j] = along * ax[j];
+    // Orthogonal noise.
+    for (let j = 0; j < dim; j++) v[j] += (rand() - 0.5) * noiseScale;
+    out.push(v);
+  }
+  return out;
+}
+
+describe("fitAnisotropyCalibration", () => {
+  test("recovers the dominant direction of an anisotropic corpus", () => {
+    const dim = 16;
+    const axis = new Array<number>(dim)
+      .fill(0)
+      .map((_, i) => (i === 0 ? 1 : 0));
+    const corpus = buildAnisotropicCorpus(200, dim, axis, 0.05);
+
+    const calib = fitAnisotropyCalibration(corpus, 1, META);
+
+    expect(calib.components.length).toBe(1);
+    expect(calib.components[0].length).toBe(dim);
+    // PC1 should align with the planted axis (sign-agnostic).
+    const alignment = Math.abs(dot(calib.components[0], axis));
+    expect(alignment).toBeGreaterThan(0.95);
+  });
+
+  test("captures most variance in PC1 for a strongly anisotropic corpus", () => {
+    const dim = 16;
+    const axis = new Array<number>(dim)
+      .fill(0)
+      .map((_, i) => (i === 0 ? 1 : 0));
+    const corpus = buildAnisotropicCorpus(200, dim, axis, 0.02);
+
+    const calib = fitAnisotropyCalibration(corpus, 3, META);
+    const ratios = explainedVarianceRatio(calib);
+
+    // Spectrum is monotonically non-increasing.
+    expect(ratios[0]).toBeGreaterThanOrEqual(ratios[1]);
+    expect(ratios[1]).toBeGreaterThanOrEqual(ratios[2]);
+    // PC1 should dwarf PC2 by an order of magnitude when noise is small.
+    expect(ratios[0]).toBeGreaterThan(ratios[1] * 10);
+  });
+
+  test("returns mean and dim metadata", () => {
+    const dim = 8;
+    const corpus = [
+      [1, 1, 0, 0, 0, 0, 0, 0],
+      [3, 3, 0, 0, 0, 0, 0, 0],
+    ];
+    const calib = fitAnisotropyCalibration(corpus, 1, META);
+    expect(calib.dim).toBe(dim);
+    expect(calib.mean[0]).toBeCloseTo(2);
+    expect(calib.mean[1]).toBeCloseTo(2);
+    expect(calib.mean[2]).toBeCloseTo(0);
+    expect(calib.sampleCount).toBe(2);
+    expect(calib.provider).toBe("gemini");
+    expect(calib.model).toBe("test-model");
+  });
+
+  test("rejects empty input, bad k, and ragged rows", () => {
+    expect(() => fitAnisotropyCalibration([], 1, META)).toThrow(/no vectors/);
+    expect(() => fitAnisotropyCalibration([[1, 2, 3]], 0, META)).toThrow(
+      /positive integer/,
+    );
+    expect(() =>
+      fitAnisotropyCalibration(
+        [
+          [1, 2],
+          [3, 4, 5],
+        ],
+        1,
+        META,
+      ),
+    ).toThrow(/dim/);
+    expect(() => fitAnisotropyCalibration([[1, 2]], 5, META)).toThrow(
+      /exceeds/,
+    );
+  });
+});
+
+describe("applyAnisotropyCorrection", () => {
+  test("output has unit L2 norm", () => {
+    const corpus = buildAnisotropicCorpus(
+      100,
+      8,
+      [1, 0, 0, 0, 0, 0, 0, 0],
+      0.05,
+    );
+    const calib = fitAnisotropyCalibration(corpus, 1, META);
+
+    const corrected = applyAnisotropyCorrection(corpus[0], calib);
+    expect(l2Norm(corrected)).toBeCloseTo(1, 6);
+  });
+
+  test("removes projection onto the dominant direction", () => {
+    const dim = 8;
+    const axis = [1, 0, 0, 0, 0, 0, 0, 0];
+    const corpus = buildAnisotropicCorpus(200, dim, axis, 0.02);
+    const calib = fitAnisotropyCalibration(corpus, 1, META);
+
+    // Pick a vector that points strongly along the planted axis.
+    const sample = [...axis];
+    const corrected = applyAnisotropyCorrection(sample, calib);
+
+    // After removing PC1 (which is ~axis), the projection back onto axis
+    // should be nearly zero — the sample is in the deflated subspace.
+    expect(Math.abs(dot(corrected, axis))).toBeLessThan(0.05);
+  });
+
+  test("spreads cosine similarities for vectors in the cone", () => {
+    const dim = 16;
+    const axis = new Array<number>(dim)
+      .fill(0)
+      .map((_, i) => (i === 0 ? 1 : 0));
+    const corpus = buildAnisotropicCorpus(300, dim, axis, 0.1);
+    const calib = fitAnisotropyCalibration(corpus, 1, META);
+
+    // Compute pairwise cosines on raw vs corrected vectors. The corrected
+    // distribution should have noticeably larger spread (max - min) — the
+    // whole point of the correction.
+    function spread(vectors: number[][]): number {
+      const sims: number[] = [];
+      for (let i = 0; i < vectors.length; i++) {
+        const a = l2Normalize(vectors[i]);
+        for (let j = i + 1; j < vectors.length; j++) {
+          const b = l2Normalize(vectors[j]);
+          sims.push(dot(a, b));
+        }
+      }
+      let min = Infinity;
+      let max = -Infinity;
+      for (const s of sims) {
+        if (s < min) min = s;
+        if (s > max) max = s;
+      }
+      return max - min;
+    }
+
+    const rawSpread = spread(corpus.slice(0, 30));
+    const correctedSpread = spread(
+      corpus.slice(0, 30).map((v) => applyAnisotropyCorrection(v, calib)),
+    );
+
+    expect(correctedSpread).toBeGreaterThan(rawSpread * 2);
+  });
+
+  test("rejects mismatched dim", () => {
+    const calib: AnisotropyCalibration = {
+      provider: "gemini",
+      model: "x",
+      dim: 4,
+      mean: [0, 0, 0, 0],
+      components: [[1, 0, 0, 0]],
+      componentVariance: [1],
+      totalVariance: 1,
+      sampleCount: 1,
+      fitAt: 0,
+    };
+    expect(() => applyAnisotropyCorrection([1, 2, 3], calib)).toThrow(/dim/);
+  });
+});
+
+describe("explainedVarianceRatio", () => {
+  test("returns zeros when totalVariance is zero", () => {
+    const calib: AnisotropyCalibration = {
+      provider: "gemini",
+      model: "x",
+      dim: 2,
+      mean: [0, 0],
+      components: [[1, 0]],
+      componentVariance: [0],
+      totalVariance: 0,
+      sampleCount: 1,
+      fitAt: 0,
+    };
+    expect(explainedVarianceRatio(calib)).toEqual([0]);
+  });
+
+  test("each ratio is variance/total", () => {
+    const calib: AnisotropyCalibration = {
+      provider: "gemini",
+      model: "x",
+      dim: 2,
+      mean: [0, 0],
+      components: [
+        [1, 0],
+        [0, 1],
+      ],
+      componentVariance: [3, 1],
+      totalVariance: 4,
+      sampleCount: 100,
+      fitAt: 0,
+    };
+    const ratios = explainedVarianceRatio(calib);
+    expect(ratios[0]).toBeCloseTo(0.75);
+    expect(ratios[1]).toBeCloseTo(0.25);
+  });
+});