@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/plugins/defaults/memory/v3/__tests__/section-needle.test.ts

@@ -133,3 +133,67 @@ describe("buildSectionNeedle", () => {
     expect(results.map((r) => r.article)).toEqual(["page-a", "page-b"]);
   });
 });
+
+describe("queryScored", () => {
+  /** Drop the score, leaving the shape `query` returns. */
+  const strip = ({ article, section }: { article: Slug; section: number }) => ({
+    article,
+    section,
+  });
+
+  test("scores are non-increasing in rank order", async () => {
+    const idx = await index({
+      "page-a": "## S\nshared keyword apple here",
+      "page-b": "## S\nshared keyword apple here too with extra apple apple",
+      "page-c": "## S\nshared keyword apple again",
+    });
+
+    const needle = buildSectionNeedle(idx);
+    const hits = needle.queryScored("apple", 5);
+
+    expect(hits.length).toBeGreaterThan(1);
+    for (let i = 1; i < hits.length; i++) {
+      expect(hits[i]!.score).toBeLessThanOrEqual(hits[i - 1]!.score);
+    }
+  });
+
+  test("parity with query (scores stripped)", async () => {
+    const idx = await index({
+      "page-a": "## S\nshared keyword apple here",
+      "page-b": "## S\nshared keyword apple here too",
+      "page-c": "## S\nshared keyword apple again",
+    });
+
+    const needle = buildSectionNeedle(idx);
+    for (const k of [1, 2, 5]) {
+      expect(needle.queryScored("apple", k).map(strip)).toEqual(
+        needle.query("apple", k),
+      );
+    }
+  });
+
+  test("top score is positive and discriminates between hits", async () => {
+    const idx = await index({
+      "page-a":
+        "## Intro\ngeneral background prose\n\n## Details\nthe elephant appears only here",
+      "topic-x": "## Notes\nunrelated material about gardens",
+    });
+
+    const needle = buildSectionNeedle(idx);
+    const hits = needle.queryScored("elephant", 5);
+
+    expect(hits.length).toBeGreaterThan(0);
+    expect(hits[0]!.score).toBeGreaterThan(0);
+    if (hits.length >= 2) {
+      expect(hits[0]!.score).toBeGreaterThan(hits[1]!.score);
+    }
+  });
+
+  test("empty for no match and for k <= 0", async () => {
+    const idx = await index({ "page-a": "## S\nshared keyword apple here" });
+    const needle = buildSectionNeedle(idx);
+
+    expect(needle.queryScored("zzzznomatch", 5)).toEqual([]);
+    expect(needle.queryScored("apple", 0)).toEqual([]);
+  });
+});

package/src/plugins/defaults/memory/v3/__tests__/shadow-integration.test.ts

@@ -56,21 +56,17 @@ let mockActive = false;
 
 let providerStub: Provider | null = null;
 
-// Spread the real provider module so unrelated exports (e.g. `createTimeout`,
-// pulled in transitively via the selection-log-store render path) stay present;
-// override only the two entry points the select pool uses, and only while this
-// file is active so the stub cannot leak into sibling tests.
-const realProvider = {
-  ...(await import("../../../../../providers/provider-send-message.js")),
-};
-mock.module("../../../../../providers/provider-send-message.js", () => ({
-  ...realProvider,
+// The select pool imports `getConfiguredProvider` from `@vellumai/plugin-api`.
+// Spread the real contract module so unrelated exports stay present; override
+// only `getConfiguredProvider`, and only while this file is active so the stub
+// cannot leak into sibling tests.
+const realPluginApi = await import("@vellumai/plugin-api");
+mock.module("@vellumai/plugin-api", () => ({
+  ...realPluginApi,
   getConfiguredProvider: async (
-    ...args: Parameters<typeof realProvider.getConfiguredProvider>
+    ...args: Parameters<typeof realPluginApi.getConfiguredProvider>
   ) =>
-    mockActive ? providerStub : realProvider.getConfiguredProvider(...args),
-  extractToolUse: (response: ProviderResponse) =>
-    response.content.find((b) => b.type === "tool_use"),
+    mockActive ? providerStub : realPluginApi.getConfiguredProvider(...args),
 }));
 
 mock.module("../../../../../util/logger.js", () => ({
@@ -89,6 +85,15 @@ mock.module("../dense.js", () => ({
   ...realDense,
   denseLane: async (...args: Parameters<typeof realDense.denseLane>) =>
     mockActive ? denseHits : realDense.denseLane(...args),
+  // Orchestrate calls the SCORED variant; intercept it under the same
+  // `mockActive` guard (the gate is disabled in these tests, so the score is
+  // arbitrary — a constant 1) so the swap can't leak through to real Qdrant.
+  denseLaneScored: async (
+    ...args: Parameters<typeof realDense.denseLaneScored>
+  ) =>
+    mockActive
+      ? denseHits.map((h) => ({ ...h, score: 1 }))
+      : realDense.denseLaneScored(...args),
 }));
 
 // In-memory selections DB. `summarizeSelections` reads via getDb/getSqliteFrom;

package/src/plugins/defaults/memory/v3/__tests__/shadow-plugin.test.ts

@@ -25,6 +25,7 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
+import { MemoryV3GateSchema } from "../../../../../config/schemas/memory-v3.js";
 import { migrateAddMemoryV3Selections } from "../../../../../persistence/migrations/268-add-memory-v3-selections.js";
 import { migrateAddMemoryV3EverInjected } from "../../../../../persistence/migrations/277-add-memory-v3-ever-injected.js";
 import { migrateMemoryV3SelectionsMessageIdAndSections } from "../../../../../persistence/migrations/283-memory-v3-selections-message-id-and-sections.js";
@@ -88,8 +89,20 @@ let extraRealConceptPages = 0;
 // Mutable mocked config knob (orchestrate-only) for asserting per-turn tuning
 // re-resolution from a live config edit.
 let selectorEnabledCfg = false;
+// Drives the `memory-v3-injection-gate` feature flag through the shared
+// assistant-feature-flags mock below (default off).
+let gateFlagEnabled = false;
+// Mutable `memory.v3.gate.enabled` config kill-switch carried by the mocked
+// config (default on, mirroring the schema default).
+let gateEnabledCfg = true;
 let messages: Array<{ role: string; content: string }> = [];
 
+// Schema defaults for `memory.v3.gate` (the tuning the mocked config carries
+// and the gate-config threading test asserts against). Includes the default-on
+// `enabled` kill-switch; `observeTurn` overwrites `enabled` with the effective
+// flag AND config value.
+const GATE_DEFAULTS = MemoryV3GateSchema.parse({});
+
 // A synthetic skill capability slug the page index carries. Its rendered
 // content holds a distinctive term ("kumquat") so the real needle, built over
 // the section index `initLanes` feeds, ranks it. Generic placeholder only.
@@ -185,7 +198,11 @@ const FAKE_SECTION_INDEX: SectionIndex = {
 
 mock.module("../../../../../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string) =>
-    key === "memory-v3-live" ? liveEnabled : false,
+    key === "memory-v3-live"
+      ? liveEnabled
+      : key === "memory-v3-injection-gate"
+        ? gateFlagEnabled
+        : false,
 }));
 
 mock.module("../../../../../config/loader.js", () => ({
@@ -211,6 +228,10 @@ mock.module("../../../../../config/loader.js", () => ({
         },
         edge: { hubDegree: 30, seedCount: 6, perSeed: 1, cap: 6 },
         entity: { enabled: true, idfFloor: 4, cap: 8 },
+        // Gate tuning (schema defaults) with the mutable `enabled` kill-switch;
+        // `observeTurn` spreads this and overwrites `enabled` with the effective
+        // flag AND config value before passing to orchestrate.
+        gate: { ...GATE_DEFAULTS, enabled: gateEnabledCfg },
       },
       qdrant: { vectorSize: 8, onDisk: false },
     },
@@ -438,6 +459,8 @@ beforeEach(() => {
   learnedEdgesCap = 0;
   extraRealConceptPages = 0;
   selectorEnabledCfg = false;
+  gateFlagEnabled = false;
+  gateEnabledCfg = true;
   messages = [
     {
       role: "user",
@@ -662,6 +685,44 @@ describe("memory-v3 engine", () => {
     expect(secondDeps.selectorEnabled).toBe(true);
   });
 
+  test("flag on → threads the gate tuning plus enabled:true into orchestrate", async () => {
+    gateFlagEnabled = true;
+    await observeTurn("conv-1", 0);
+
+    const deps = (
+      orchestrateSpy.mock.calls as unknown as unknown[][]
+    )[0]![1] as { gateConfig?: unknown };
+    // The spread is the live gate config: the `memory.v3.gate` tuning with the
+    // flag-derived `enabled` folded in.
+    expect(deps.gateConfig).toEqual({ ...GATE_DEFAULTS, enabled: true });
+  });
+
+  test("flag off (default) → gate config threads inert (enabled:false, schema-default tuning)", async () => {
+    // gateFlagEnabled defaults to false in beforeEach.
+    await observeTurn("conv-1", 0);
+
+    const deps = (
+      orchestrateSpy.mock.calls as unknown as unknown[][]
+    )[0]![1] as { gateConfig?: { enabled?: boolean } };
+    // Flag off → the gate is wired in but inert, and the tuning fields are the
+    // schema defaults the config carries.
+    expect(deps.gateConfig?.enabled).toBe(false);
+    expect(deps.gateConfig).toEqual({ ...GATE_DEFAULTS, enabled: false });
+  });
+
+  test("flag on + gate.enabled:false config kill-switch → gate threads inert", async () => {
+    gateFlagEnabled = true;
+    gateEnabledCfg = false;
+    await observeTurn("conv-1", 0);
+
+    const deps = (
+      orchestrateSpy.mock.calls as unknown as unknown[][]
+    )[0]![1] as { gateConfig?: unknown };
+    // The config kill-switch wins over the flag: the effective `enabled` is
+    // false, so selection always runs.
+    expect(deps.gateConfig).toEqual({ ...GATE_DEFAULTS, enabled: false });
+  });
+
   test("initLanes filters core to existing pages and excludes core from the hot set", async () => {
     // The core file lists a live page and a dangling slug; the hot set returns
     // a live page and a deleted one (selection rows can outlive their pages).

package/src/plugins/defaults/memory/v3/card.ts

@@ -1,7 +1,4 @@
-import {
-  FRONTMATTER_REGEX,
-  parseFrontmatterFields,
-} from "../../../../skills/frontmatter.js";
+import { FRONTMATTER_REGEX, parseFrontmatterFields } from "../frontmatter.js";
 import { injectedConceptHeader } from "../v2/injected-block-slugs.js";
 import type { Slug } from "./types.js";
 

package/src/plugins/defaults/memory/v3/dense.ts

@@ -16,11 +16,9 @@
 // forward regardless, so a dense outage narrows recall but never breaks a turn.
 
 import type { AssistantConfig } from "../../../../config/types.js";
-import {
-  embedWithBackend,
-  isEmbeddingDimensionAvailable,
-} from "../../../../persistence/embeddings/embedding-backend.js";
+import { isEmbeddingDimensionAvailable } from "../../../../persistence/embeddings/embedding-backend.js";
 import { getLogger } from "../../../../util/logger.js";
+import { embedWithBackend } from "../embeddings.js";
 import {
   getSectionDenseClient,
   SECTION_COLLECTION,
@@ -42,12 +40,21 @@ export interface DenseHit {
   section: number;
 }
 
+/** A dense-lane hit plus the raw cosine similarity Qdrant returned. */
+export interface DenseHitScored {
+  article: Slug;
+  section: number;
+  score: number;
+}
+
 /**
- * Run the dense lane: embed `query`, search the section collection for the top
- * `k * OVERSAMPLE` section points, then dedupe to the top-`k` distinct articles
- * — each with its best-scoring section ordinal. Section points are returned by
- * Qdrant in descending score order, so the first time an article is seen is its
- * best section; subsequent sections of the same article are ignored.
+ * Run the dense lane and keep each hit's raw cosine score: embed `query`, search
+ * the section collection for the top `k * OVERSAMPLE` section points, then dedupe
+ * to the top-`k` distinct articles — each with its best-scoring section ordinal
+ * and that section's cosine score. Section points are returned by Qdrant in
+ * descending score order, so the first time an article is seen is its best
+ * section; subsequent sections of the same article are ignored. A point that
+ * arrives without a `score` is recorded as `0`.
  *
  * Returns `[]` on any embedding or Qdrant failure (logged at warn level), and
  * short-circuits to `[]` when the reachable backend cannot produce vectors of
@@ -55,31 +62,33 @@ export interface DenseHit {
  * so a 3072-dim collection committed while only a 384-dim backend is reachable
  * narrows recall cleanly rather than failing the dimension assertion every turn.
  */
-export async function denseLane(
+export async function denseLaneScored(
   config: AssistantConfig,
   query: string,
   k: number,
-): Promise<DenseHit[]> {
+): Promise<DenseHitScored[]> {
   if (k <= 0) return [];
 
-  if (!(await isEmbeddingDimensionAvailable(config))) {
-    return [];
-  }
-
   let points: Array<{ payload?: unknown; score?: number }>;
   try {
+    // Inside the try so a rejecting probe (e.g. a transient credential-store
+    // error surfacing through getProviderKeyAsync) degrades to `[]` instead of
+    // throwing — the orchestrator calls this lane in an unguarded Promise.all
+    // that relies on the `[]` contract, so one throw would discard the sibling
+    // lanes too. The check itself skips the embed on a dimension mismatch.
+    if (!(await isEmbeddingDimensionAvailable(config))) {
+      return [];
+    }
+
     const { vectors } = await embedWithBackend(config, [query]);
     const vector = vectors[0];
     if (!vector || vector.length === 0) return [];
 
-    const result = await getSectionDenseClient(config).query(
-      SECTION_COLLECTION,
-      {
-        query: vector,
-        limit: k * OVERSAMPLE,
-        with_payload: true,
-      },
-    );
+    const result = await getSectionDenseClient().query(SECTION_COLLECTION, {
+      query: vector,
+      limit: k * OVERSAMPLE,
+      with_payload: true,
+    });
     points = result.points;
   } catch (err) {
     log.warn({ err }, "memory v3 dense lane failed; degrading to no hits");
@@ -89,7 +98,7 @@ export async function denseLane(
   // Walk hits in score order, keeping the first (best) section per article and
   // stopping once we have `k` distinct articles.
   const seen = new Set<Slug>();
-  const hits: DenseHit[] = [];
+  const hits: DenseHitScored[] = [];
   for (const point of points) {
     const payload = point.payload as
       | { article?: unknown; ordinal?: unknown }
@@ -100,9 +109,35 @@ export async function denseLane(
     if (typeof article !== "string" || typeof ordinal !== "number") continue;
     if (seen.has(article)) continue;
     seen.add(article);
-    hits.push({ article, section: ordinal });
+    hits.push({ article, section: ordinal, score: point.score ?? 0 });
     if (hits.length >= k) break;
   }
 
   return hits;
 }
+
+/**
+ * Run the dense lane: embed `query`, search the section collection for the top
+ * `k * OVERSAMPLE` section points, then dedupe to the top-`k` distinct articles
+ * — each with its best-scoring section ordinal. Section points are returned by
+ * Qdrant in descending score order, so the first time an article is seen is its
+ * best section; subsequent sections of the same article are ignored.
+ *
+ * Returns `[]` on any embedding or Qdrant failure (logged at warn level), and
+ * short-circuits to `[]` when the reachable backend cannot produce vectors of
+ * the committed collection dimension (degraded backend or dimension mismatch) —
+ * so a 3072-dim collection committed while only a 384-dim backend is reachable
+ * narrows recall cleanly rather than failing the dimension assertion every turn.
+ *
+ * Thin wrapper over {@link denseLaneScored} that drops the raw cosine score for
+ * callers that only need the matched article and section.
+ */
+export async function denseLane(
+  config: AssistantConfig,
+  query: string,
+  k: number,
+): Promise<DenseHit[]> {
+  return (await denseLaneScored(config, query, k)).map(
+    ({ article, section }) => ({ article, section }),
+  );
+}

package/src/plugins/defaults/memory/v3/edge.ts

@@ -1,4 +1,4 @@
-import { parseFrontmatterFields } from "../../../../skills/frontmatter.js";
+import { parseFrontmatterFields } from "../frontmatter.js";
 import type { PageIndexEntry } from "../v2/page-index.js";
 import type { Slug } from "./types.js";
 

package/src/plugins/defaults/memory/v3/gate-flag.ts

@@ -0,0 +1,20 @@
+import { isAssistantFeatureFlagEnabled } from "../../../../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../../../../config/schema.js";
+
+/** Feature-flag id (kebab-case) gating the memory-v3 per-turn injection gate. */
+export const MEMORY_V3_INJECTION_GATE_FLAG =
+  "memory-v3-injection-gate" as const;
+
+/** Whether the memory-v3 injection gate is enabled for this config: the
+ *  feature flag (resolved via the standard assistant flag resolver — gateway
+ *  override → registry default → false) AND the `memory.v3.gate.enabled`
+ *  config kill-switch. `enabled: false` forces the full selection process
+ *  every turn even with the flag on. Thresholds live in `memory.v3.gate`. */
+export function isMemoryV3InjectionGateEnabled(
+  config: AssistantConfig,
+): boolean {
+  return (
+    isAssistantFeatureFlagEnabled(MEMORY_V3_INJECTION_GATE_FLAG, config) &&
+    config.memory.v3.gate.enabled
+  );
+}

package/src/plugins/defaults/memory/v3/gate.ts

@@ -0,0 +1,158 @@
+// ---------------------------------------------------------------------------
+// Memory v3 — per-turn injection gate (pure score check)
+// ---------------------------------------------------------------------------
+//
+// Decides whether the finder-lane retrieval scores clear the injection
+// thresholds for this turn. Three ways to pass:
+//   - dense_pass:        top-1 dense cosine clears `denseThreshold`.
+//   - dense_cluster:     dense top-1 falls short but the whole top-3 dense
+//                        cluster sits above `denseClusterThreshold` within a
+//                        tight `denseClusterMaxDelta` spread (a coherent-but-
+//                        borderline neighbourhood).
+//   - sparse_only_strong: dense fails outright but normalized top-1 BM25F clears
+//                        the higher `sparseOnlyThreshold` bar.
+//
+// A zero-overlap hard floor keeps sparse signal honest: a raw BM25F of `0` means
+// no query term matched any section, so the sparse lane can never open the gate
+// regardless of how the thresholds are tuned.
+//
+// This module is intentionally PURE — no async, no I/O, no logging, and no
+// imports beyond the two scored-hit types. `config.enabled` is the resolved
+// effective enable (feature flag AND `memory.v3.gate.enabled`) supplied by the
+// caller, which also feeds in the finder-lane hits.
+
+import type { DenseHitScored } from "./dense.js";
+import type { SectionNeedleScoredHit } from "./section-needle.js";
+
+/** BM25F normalization constant when config.bm25NormK is null.
+ *  TODO(memory-v3): replace with per-corpus auto-calibration. */
+export const DEFAULT_BM25_NORM_K = 9.0;
+
+export type V3GateReason =
+  | "dense_pass"
+  | "dense_cluster"
+  | "sparse_only_strong"
+  | "fail_no_signal"
+  | "fail_dense_below_and_sparse_weak"
+  | "disabled";
+
+export interface V3GateConfig {
+  enabled: boolean; // effective enable — flag AND config kill-switch, resolved in observeTurn
+  denseThreshold: number;
+  sparseThreshold: number;
+  sparseOnlyThreshold: number;
+  denseClusterThreshold: number;
+  denseClusterMaxDelta: number;
+  topK: number;
+  bm25NormK: number | null;
+  bypassForCore: boolean; // consumed by orchestrate, not by checkV3Gate
+}
+
+export interface V3GateResult {
+  pass: boolean;
+  reason: V3GateReason;
+  topDenseScore: number | null;
+  topSparseScore: number | null; // raw BM25F
+  topNormSparseScore: number | null; // normalized BM25F
+  denseScores: number[]; // top-K cosine, desc
+  sparseScores: number[]; // top-K raw BM25F, desc
+  checkedArticles: number;
+}
+
+export interface V3CheckGateParams {
+  needleHits: SectionNeedleScoredHit[];
+  denseHits: DenseHitScored[];
+  config: V3GateConfig;
+}
+
+/**
+ * Pure injection-gate score check. Given the finder-lane hits and the gate
+ * tuning, decides whether retrieval is confident enough to run the selector.
+ *
+ * `config.bypassForCore` is intentionally NOT read here: whether a closed gate
+ * skips entirely versus selecting only the stable core prefix is an
+ * orchestrate-level decision, not part of the score check.
+ */
+export function checkV3Gate(params: V3CheckGateParams): V3GateResult {
+  const { needleHits, denseHits, config } = params;
+
+  if (!config.enabled) {
+    return {
+      pass: true,
+      reason: "disabled",
+      topDenseScore: null,
+      topSparseScore: null,
+      topNormSparseScore: null,
+      denseScores: [],
+      sparseScores: [],
+      checkedArticles: 0,
+    };
+  }
+
+  const k = Math.max(1, config.topK);
+  const denseScores = denseHits
+    .map((h) => h.score)
+    .sort((a, b) => b - a)
+    .slice(0, k);
+  const sparseScores = needleHits
+    .map((h) => h.score)
+    .sort((a, b) => b - a)
+    .slice(0, k);
+
+  const topDense = denseScores[0] ?? null;
+  const topSparseRaw = sparseScores[0] ?? null;
+
+  const normK = config.bm25NormK ?? DEFAULT_BM25_NORM_K;
+  const topNorm =
+    topSparseRaw === null ? null : topSparseRaw / (topSparseRaw + normK);
+
+  const checkedArticles = new Set(
+    [...denseHits, ...needleHits].map((h) => h.article),
+  ).size;
+
+  const densePass = topDense !== null && topDense >= config.denseThreshold;
+
+  const top3 = denseScores.slice(0, 3);
+  const denseCluster =
+    !densePass &&
+    top3.length === 3 &&
+    top3.every((s) => s >= config.denseClusterThreshold) &&
+    top3[0]! - top3[2]! <= config.denseClusterMaxDelta;
+
+  // Hard floor: a raw BM25F of 0 means no query term matched any section, so the
+  // sparse lane is treated as carrying no usable signal no matter the thresholds.
+  const sparseUsable = topSparseRaw !== null && topSparseRaw > 0;
+  const normSparse = sparseUsable ? topNorm! : 0;
+
+  const sparsePass = sparseUsable && normSparse >= config.sparseThreshold;
+  const sparseOnlyStrong =
+    !(densePass || denseCluster) &&
+    sparseUsable &&
+    normSparse >= config.sparseOnlyThreshold;
+
+  const pass = densePass || denseCluster || sparseOnlyStrong;
+
+  let reason: V3GateReason;
+  if (densePass) {
+    reason = "dense_pass";
+  } else if (denseCluster) {
+    reason = "dense_cluster";
+  } else if (sparseOnlyStrong) {
+    reason = "sparse_only_strong";
+  } else if (sparsePass) {
+    reason = "fail_dense_below_and_sparse_weak";
+  } else {
+    reason = "fail_no_signal";
+  }
+
+  return {
+    pass,
+    reason,
+    topDenseScore: topDense,
+    topSparseScore: topSparseRaw,
+    topNormSparseScore: topNorm, // null only when no sparse hits; 0 when raw is 0
+    denseScores,
+    sparseScores,
+    checkedArticles,
+  };
+}

package/src/plugins/defaults/memory/v3/maintain-job.ts

@@ -68,10 +68,7 @@ import {
   getMemoryCheckpoint,
   setMemoryCheckpoint,
 } from "../../../../persistence/checkpoints.js";
-import {
-  EmbeddingBackendUnavailableError,
-  embedWithBackend,
-} from "../../../../persistence/embeddings/embedding-backend.js";
+import { EmbeddingBackendUnavailableError } from "../../../../persistence/embeddings/embedding-backend.js";
 import { EmbeddingBillingBlockError } from "../../../../persistence/embeddings/embedding-billing-breaker.js";
 import type { MemoryJob } from "../../../../persistence/jobs-store.js";
 import {
@@ -81,6 +78,7 @@ import {
 import { executeDeleteManagedSkill } from "../../../../tools/skills/delete-managed.js";
 import { getLogger } from "../../../../util/logger.js";
 import { getWorkspaceDir } from "../../../../util/platform.js";
+import { embedWithBackend } from "../embeddings.js";
 import { getPageIndex } from "../v2/page-index.js";
 import { readPage } from "../v2/page-store.js";
 import { skillSlugFor } from "../v2/skill-store.js";