@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/skill-content.test.ts

@@ -1,10 +1,10 @@
 /**
- * Tests for `memory/v2/skill-content.ts` — v2-owned port of v1's
+ * Tests for `substrate/skill-content.ts` — v2-owned port of v1's
  * `buildSkillContent` plus the `mcp-setup` description augmentation.
  */
 import { describe, expect, test } from "bun:test";
 
-import { setConfig } from "../../../../../../__tests__/helpers/set-config.js";
+import { setConfig } from "../../../../../__tests__/helpers/set-config.js";
 import type { SkillCapabilityInput } from "../skill-content.js";
 
 describe("buildSkillContent", () => {

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/skill-store.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for `assistant/src/memory/v2/skill-store.ts`.
+ * Tests for `substrate/skill-store.ts`.
  *
  * Coverage matrix:
  *   - `seedV2SkillEntries` enumerates the catalog and calls
@@ -25,9 +25,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { ResolvedSkill } from "../../../../../../config/skill-state.js";
-import type { SkillSummary } from "../../../../../../config/skills.js";
-import type { CatalogSkill } from "../../../../../../skills/catalog-install.js";
+import type { ResolvedSkill } from "../../../../../config/skill-state.js";
+import type { SkillSummary } from "../../../../../config/skills.js";
+import type { CatalogSkill } from "../../../../../skills/catalog-install.js";
 
 // ---------------------------------------------------------------------------
 // Programmable test state — drives every mocked dependency below.
@@ -89,11 +89,11 @@ const state: TestState = {
   callSequence: [],
 };
 
-mock.module("../../../../../../config/skills.js", () => ({
+mock.module("../../../../../config/skills.js", () => ({
   loadSkillCatalog: () => state.catalog ?? [],
 }));
 
-mock.module("../../../../../../config/skill-state.js", () => ({
+mock.module("../../../../../config/skill-state.js", () => ({
   resolveSkillStates: (
     catalog: SkillSummary[],
     config: { skills?: { allowBundled?: string[] | null } },
@@ -122,13 +122,13 @@ mock.module("../../../../../../config/skill-state.js", () => ({
   },
 }));
 
-mock.module("../../../../../../config/assistant-feature-flags.js", () => ({
+mock.module("../../../../../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string) =>
     state.flagsEnabled[key] ?? true,
 }));
 
 mock.module(
-  "../../../../../../persistence/embeddings/embedding-backend.js",
+  "../../../../../persistence/embeddings/embedding-backend.js",
   () => ({
     embedWithBackend: async (_config: unknown, inputs: unknown[]) => {
       if (state.embedThrows) {
@@ -174,7 +174,7 @@ mock.module("../qdrant.js", () => ({
   },
 }));
 
-mock.module("../../../../../../skills/catalog-cache.js", () => ({
+mock.module("../../../../../skills/catalog-cache.js", () => ({
   getCatalog: async () => {
     if (state.fullCatalogThrows) {
       throw state.fullCatalogThrows;

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/sparse-bm25.test.ts

@@ -7,7 +7,7 @@ import {
   SPARSE_VOCAB_SIZE,
   tokenHash,
   tokenizeStemmed,
-} from "../../../../../../persistence/embeddings/sparse-tokenize.js";
+} from "../../../../../persistence/embeddings/sparse-tokenize.js";
 import {
   _resetCorpusStatsForTests,
   _setCorpusStatsForTests,
@@ -43,12 +43,15 @@ function dotProduct(
   d: { indices: number[]; values: number[] },
 ): number {
   const dMap = new Map<number, number>();
-  for (let i = 0; i < d.indices.length; i++)
+  for (let i = 0; i < d.indices.length; i++) {
     dMap.set(d.indices[i], d.values[i]);
+  }
   let sum = 0;
   for (let i = 0; i < q.indices.length; i++) {
     const dv = dMap.get(q.indices[i]);
-    if (dv !== undefined) sum += q.values[i] * dv;
+    if (dv !== undefined) {
+      sum += q.values[i] * dv;
+    }
   }
   return sum;
 }
@@ -234,7 +237,9 @@ describe("generateBm25QueryEmbedding", () => {
   test("emits binary occurrence per distinct token", () => {
     const vec = generateBm25QueryEmbedding("supplements supplements zinc");
     expect(vec.indices.length).toBe(2);
-    for (const v of vec.values) expect(v).toBe(1);
+    for (const v of vec.values) {
+      expect(v).toBe(1);
+    }
   });
 
   test("empty input yields empty vector", () => {
@@ -263,7 +268,9 @@ describe("end-to-end ranking: BM25 fixes the supplements bug", () => {
       const seen = new Set<number>();
       for (const t of tokens) {
         const idx = tokenHash(t, SPARSE_VOCAB_SIZE);
-        if (seen.has(idx)) continue;
+        if (seen.has(idx)) {
+          continue;
+        }
         seen.add(idx);
         df.set(idx, (df.get(idx) ?? 0) + 1);
       }

package/src/plugins/defaults/memory/substrate/__tests__/spread.test.ts

@@ -0,0 +1,276 @@
+/**
+ * Tests for `substrate/spread.ts` — edge-graph activation
+ * spreading.
+ *
+ * Coverage:
+ *   - `spreadActivation`: orphan yields A == A_o; spread walks incoming edges
+ *      only (A→B boosts B but not A); hops=2 reaches second-degree predecessors
+ *      but not third; bounded in [0,1]; inactive predecessors drop from both
+ *      sides of the ratio; contribution == final - own.
+ *
+ * `spreadActivation` is a pure function (no I/O), so no mocks are needed.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import type { EdgeIndex } from "../edge-index.js";
+import { spreadActivation } from "../spread.js";
+
+/**
+ * Build a directed `EdgeIndex` from a flat list of `[from, to]` pairs. Each
+ * entry is interpreted as a directed edge `from → to`; self-loops are dropped.
+ */
+function buildEdgeIndex(edges: Array<[string, string]>): EdgeIndex {
+  const outgoing = new Map<string, Set<string>>();
+  const incoming = new Map<string, Set<string>>();
+  for (const [from, to] of edges) {
+    if (from === to) {
+      continue;
+    }
+    let outSet = outgoing.get(from);
+    if (!outSet) {
+      outSet = new Set<string>();
+      outgoing.set(from, outSet);
+    }
+    outSet.add(to);
+    let inSet = incoming.get(to);
+    if (!inSet) {
+      inSet = new Set<string>();
+      incoming.set(to, inSet);
+    }
+    inSet.add(from);
+  }
+  return { outgoing, incoming };
+}
+
+describe("spreadActivation", () => {
+  test("orphan node yields A == A_o", () => {
+    const edges = buildEdgeIndex([]);
+    const own = new Map([["alice", 0.7]]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    expect(out.final.get("alice")).toBeCloseTo(0.7, 6);
+  });
+
+  test("directed edge boosts only the target, not the source", () => {
+    // Edge alice→bob: alice activation flows into bob; bob does NOT push back
+    // into alice. alice (a pure source under this graph) keeps its own value.
+    const edges = buildEdgeIndex([["alice", "bob"]]);
+    const own = new Map([
+      ["alice", 0.6],
+      ["bob", 0.0],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    // alice has no incoming edges → final == own.
+    expect(out.final.get("alice")).toBeCloseTo(0.6, 6);
+    // bob's incoming = {alice}: numerator = 0 + 0.5*0.6 = 0.3, denom = 1.5.
+    expect(out.final.get("bob")).toBeCloseTo(0.3 / 1.5, 6);
+  });
+
+  test("two-cycle (A→B and B→A) lets activation flow both ways", () => {
+    // With both directions present, each node is the other's predecessor.
+    const edges = buildEdgeIndex([
+      ["alice", "bob"],
+      ["bob", "alice"],
+    ]);
+    const own = new Map([
+      ["alice", 0.0],
+      ["bob", 0.8],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    // alice: incoming {bob}=0.8 → numerator = 0 + 0.5*0.8 = 0.4, denom = 1.5.
+    expect(out.final.get("alice")).toBeCloseTo(0.4 / 1.5, 6);
+    // bob:   incoming {alice}=0.0 → numerator = 0.8 + 0 = 0.8, denom = 1.5.
+    expect(out.final.get("bob")).toBeCloseTo(0.8 / 1.5, 6);
+  });
+
+  test("pure source (high outgoing, zero incoming) collapses to final == own", () => {
+    // alice → bob → carol; alice has no incoming edges.
+    const edges = buildEdgeIndex([
+      ["alice", "bob"],
+      ["bob", "carol"],
+    ]);
+    const own = new Map([
+      ["alice", 0.5],
+      ["bob", 0.0],
+      ["carol", 0.0],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    expect(out.final.get("alice")).toBeCloseTo(0.5, 6);
+  });
+
+  test("hops=2 reaches second-degree predecessors but stops there", () => {
+    // Directed path: alice → bob → carol → delta
+    // From delta's perspective: carol is 1-hop predecessor, bob is 2-hop,
+    // alice is 3-hop. Activation on bob (2-hop) reaches delta; activation on
+    // alice (3-hop) does NOT.
+    const edges = buildEdgeIndex([
+      ["alice", "bob"],
+      ["bob", "carol"],
+      ["carol", "delta"],
+    ]);
+    const own = new Map([
+      ["alice", 1.0], // 3-hop predecessor of delta — must NOT contribute
+      ["bob", 1.0], // 2-hop predecessor of delta
+      ["carol", 0.0],
+      ["delta", 0.0],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    // delta: 1-hop {carol}=0, 2-hop {bob}=1.0.
+    //   numerator   = 0 + 0.5*0 + 0.25*1.0 = 0.25
+    //   denominator = 1 + 0.5*1 + 0.25*1   = 1.75
+    //   A = 0.25 / 1.75 ≈ 0.142857
+    expect(out.final.get("delta")).toBeCloseTo(0.25 / 1.75, 6);
+  });
+
+  test("output is bounded in [0, 1] for arbitrary inputs", () => {
+    const edges = buildEdgeIndex([
+      ["alice", "bob"],
+      ["bob", "carol"],
+      ["alice", "carol"],
+    ]);
+    const own = new Map([
+      ["alice", 1.0],
+      ["bob", 1.0],
+      ["carol", 1.0],
+    ]);
+    const out = spreadActivation(own, edges, 0.99, 2);
+    for (const [, value] of out.final) {
+      expect(value).toBeGreaterThanOrEqual(0);
+      expect(value).toBeLessThanOrEqual(1);
+    }
+  });
+
+  test("hops=0 collapses to A == A_o", () => {
+    const edges = buildEdgeIndex([["alice", "bob"]]);
+    const own = new Map([
+      ["alice", 0.4],
+      ["bob", 0.9],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 0);
+    expect(out.final.get("alice")).toBeCloseTo(0.4, 6);
+    expect(out.final.get("bob")).toBeCloseTo(0.9, 6);
+  });
+
+  test("k=0 collapses to A == A_o", () => {
+    const edges = buildEdgeIndex([["alice", "bob"]]);
+    const own = new Map([
+      ["alice", 0.4],
+      ["bob", 0.9],
+    ]);
+    const out = spreadActivation(own, edges, 0, 5);
+    expect(out.final.get("alice")).toBeCloseTo(0.4, 6);
+    expect(out.final.get("bob")).toBeCloseTo(0.9, 6);
+  });
+
+  test("predecessors not in the candidate set are dropped from both numerator and denominator", () => {
+    // Edge alice→bob: bob has structural predecessor alice, but alice is not
+    // in `ownActivation`, so she contributes nothing — hop1 has no active
+    // predecessors, so the whole hop drops out of both sides of the ratio.
+    // Bob therefore stays at his own activation.
+    const edges = buildEdgeIndex([["alice", "bob"]]);
+    const own = new Map([["bob", 0.6]]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    expect(out.final.get("bob")).toBeCloseTo(0.6, 6);
+  });
+
+  test("L_2 norm over multiple active predecessors rewards strong outliers more than avg would", () => {
+    // bob has 4 predecessors in the candidate set: one strong, three weak.
+    // L_2 = √((0.8² + 0.1² + 0.1² + 0.1²) / 4) = √(0.1675) ≈ 0.40927
+    // Plain avg of the same set = 0.275, so L_2 lifts bob more than avg
+    // would — the design goal of preferring quality over quantity.
+    const edges = buildEdgeIndex([
+      ["a1", "bob"],
+      ["a2", "bob"],
+      ["a3", "bob"],
+      ["a4", "bob"],
+    ]);
+    const own = new Map([
+      ["a1", 0.8],
+      ["a2", 0.1],
+      ["a3", 0.1],
+      ["a4", 0.1],
+      ["bob", 0.0],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    const rms = Math.sqrt((0.8 * 0.8 + 3 * 0.1 * 0.1) / 4);
+    // numerator   = 0 + 0.5 · rms
+    // denominator = 1 + 0.5
+    expect(out.final.get("bob")).toBeCloseTo((0.5 * rms) / 1.5, 6);
+  });
+
+  test("high-in-degree hub with mostly-inactive predecessors stays near A_o", () => {
+    // 100 structural predecessors point at hub; only one (`pred0`) is in
+    // the candidate set. Inactive structural predecessors affect neither
+    // side of the ratio — the structural in-degree never enters the
+    // denominator, and the L_2 averages over the single active predecessor.
+    const rawEdges: Array<[string, string]> = [];
+    for (let i = 0; i < 100; i++) {
+      rawEdges.push([`pred${i}`, "hub"]);
+    }
+    const edges = buildEdgeIndex(rawEdges);
+    const own = new Map([
+      ["hub", 0.6],
+      ["pred0", 0.5],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    // hop1 active = {pred0}, L_2([0.5]) = 0.5.
+    //   numerator   = 0.6 + 0.5 · 0.5 = 0.85
+    //   denominator = 1 + 0.5         = 1.5
+    expect(out.final.get("hub")).toBeCloseTo(0.85 / 1.5, 6);
+  });
+
+  test("empty own-activation map returns empty result", () => {
+    const out = spreadActivation(
+      new Map(),
+      buildEdgeIndex([["a", "b"]]),
+      0.5,
+      2,
+    );
+    expect(out.final.size).toBe(0);
+    expect(out.contribution.size).toBe(0);
+  });
+
+  test("contribution equals final - own for each slug", () => {
+    // Two-cycle: A→B and B→A so both nodes have predecessors and the spread
+    // moves each off its own value in opposite directions.
+    const edges = buildEdgeIndex([
+      ["alice", "bob"],
+      ["bob", "alice"],
+    ]);
+    const own = new Map([
+      ["alice", 0.0],
+      ["bob", 0.8],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    for (const [slug, finalValue] of out.final) {
+      const ownValue = own.get(slug) ?? 0;
+      expect(out.contribution.get(slug)).toBeCloseTo(finalValue - ownValue, 6);
+    }
+    // alice gained spread (predecessor bob=0.8); bob lost some (predecessor
+    // alice=0 dilutes its own 0.8).
+    expect(out.contribution.get("alice")).toBeGreaterThan(0);
+    expect(out.contribution.get("bob")).toBeLessThan(0);
+  });
+
+  test("contribution is 0 for every slug when hops == 0", () => {
+    const edges = buildEdgeIndex([["alice", "bob"]]);
+    const own = new Map([
+      ["alice", 0.4],
+      ["bob", 0.9],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 0);
+    expect(out.contribution.get("alice")).toBe(0);
+    expect(out.contribution.get("bob")).toBe(0);
+  });
+
+  test("contribution is 0 for every slug when k == 0", () => {
+    const edges = buildEdgeIndex([["alice", "bob"]]);
+    const own = new Map([
+      ["alice", 0.4],
+      ["bob", 0.9],
+    ]);
+    const out = spreadActivation(own, edges, 0, 5);
+    expect(out.contribution.get("alice")).toBe(0);
+    expect(out.contribution.get("bob")).toBe(0);
+  });
+});

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/static-context.test.ts

@@ -21,8 +21,8 @@ const noopLogger: Record<string, unknown> = new Proxy(
 );
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
-const realLogger = require("../../../../../../util/logger.js");
-mock.module("../../../../../../util/logger.js", () => ({
+const realLogger = require("../../../../../util/logger.js");
+mock.module("../../../../../util/logger.js", () => ({
   ...realLogger,
   getLogger: () => noopLogger,
   getCliLogger: () => noopLogger,
@@ -35,7 +35,7 @@ let configMemoryV2Enabled = true;
 let configMemoryEnabled = true;
 
 // static-context reads its gates through the plugin's own config accessor.
-mock.module("../../../config.js", () => ({
+mock.module("../../config.js", () => ({
   getMemoryConfig: () => ({
     enabled: configMemoryEnabled,
     v2: { enabled: configMemoryV2Enabled },
@@ -60,8 +60,9 @@ function writeMemoryFile(name: string, body: string): void {
 
 function cleanupMemoryDir(): void {
   const memoryDir = join(TEST_DIR, "memory");
-  if (existsSync(memoryDir))
+  if (existsSync(memoryDir)) {
     rmSync(memoryDir, { recursive: true, force: true });
+  }
 }
 
 describe("readMemoryV2StaticContent", () => {
@@ -77,13 +78,17 @@ describe("readMemoryV2StaticContent", () => {
 
   test("returns null when config.memory.v2.enabled is off", () => {
     configMemoryV2Enabled = false;
-    for (const file of MEMORY_FILES) writeMemoryFile(file, `Content ${file}`);
+    for (const file of MEMORY_FILES) {
+      writeMemoryFile(file, `Content ${file}`);
+    }
     expect(readMemoryV2StaticContent()).toBeNull();
   });
 
   test("returns null when config.memory.enabled is off even with v2 on", () => {
     configMemoryEnabled = false;
-    for (const file of MEMORY_FILES) writeMemoryFile(file, `Content ${file}`);
+    for (const file of MEMORY_FILES) {
+      writeMemoryFile(file, `Content ${file}`);
+    }
     expect(readMemoryV2StaticContent()).toBeNull();
   });
 
@@ -120,7 +125,9 @@ describe("readMemoryV2StaticContent", () => {
   });
 
   test("excludeBuffer drops the Buffer section but keeps the other three", () => {
-    for (const file of MEMORY_FILES) writeMemoryFile(file, `Content ${file}`);
+    for (const file of MEMORY_FILES) {
+      writeMemoryFile(file, `Content ${file}`);
+    }
 
     const result = readMemoryV2StaticContent({ excludeBuffer: true });
     expect(result).not.toBeNull();
@@ -146,7 +153,9 @@ describe("readMemoryV2StaticContent", () => {
   });
 
   test("returns null when every file is empty", () => {
-    for (const file of MEMORY_FILES) writeMemoryFile(file, "");
+    for (const file of MEMORY_FILES) {
+      writeMemoryFile(file, "");
+    }
     expect(readMemoryV2StaticContent()).toBeNull();
   });
 

package/src/plugins/defaults/memory/{v3/substrate → substrate}/__tests__/sweep-job.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for `assistant/src/memory/v2/sweep-job.ts`.
+ * Tests for `substrate/sweep-job.ts`.
  *
  * Coverage matrix:
  *   - v2 disabled in config → no provider/DB calls, returns 0 (early bail).
@@ -62,7 +62,7 @@ mock.module("@vellumai/plugin-api", () => ({
 // so the failure-path test can assert on `activity.failed` shape and dedupe.
 const emitCalls: Array<Record<string, unknown>> = [];
 
-mock.module("../../../../../../notifications/emit-signal.js", () => ({
+mock.module("../../../../../notifications/emit-signal.js", () => ({
   emitNotificationSignal: async (params: Record<string, unknown>) => {
     emitCalls.push(params);
     return {
@@ -95,14 +95,12 @@ afterAll(() => {
   rmSync(tmpWorkspace, { recursive: true, force: true });
 });
 
-const { getDb } =
-  await import("../../../../../../persistence/db-connection.js");
+const { getDb } = await import("../../../../../persistence/db-connection.js");
 const { resetDbForTesting } =
-  await import("../../../../../../__tests__/db-test-helpers.js");
-const { initializeDb } =
-  await import("../../../../../../persistence/db-init.js");
+  await import("../../../../../__tests__/db-test-helpers.js");
+const { initializeDb } = await import("../../../../../persistence/db-init.js");
 const { messages, conversations } =
-  await import("../../../../../../persistence/schema/index.js");
+  await import("../../../../../persistence/schema/index.js");
 const { memoryV2SweepJob } = await import("../sweep-job.js");
 
 // The handler reads `config.memory.v2.enabled` and `sweep_enabled`, so we
@@ -170,7 +168,9 @@ function makeEntriesProvider(entries: string[]): Provider {
  */
 function extractFirstUserText(msgs: { content: unknown }[]): string {
   const first = msgs[0];
-  if (!first || !Array.isArray(first.content)) return "";
+  if (!first || !Array.isArray(first.content)) {
+    return "";
+  }
   const block = first.content.find(
     (b: unknown) =>
       typeof b === "object" &&

package/src/plugins/defaults/memory/{v3/substrate/memory-v2-startup.ts → substrate/boot-maintenance.ts}

@@ -1,18 +1,21 @@
 // ---------------------------------------------------------------------------
-// Memory v2 — daemon-startup helpers
+// Memory substrate — daemon-startup helpers
 // ---------------------------------------------------------------------------
 //
+// Shared by the v2 injection engine and memory-v3; active whenever
+// `usesConceptPageMemory()` holds.
+//
 // Small focused module that holds the gating + dispatch logic for v2-specific
 // startup work invoked from `lifecycle.ts` (and, for the post-credential
 // capability reseed, from the secrets route). Lives in its own file so the unit
 // test for the gate does not have to mount the entire lifecycle import graph.
 
-import { usesConceptPageMemory } from "../../../../../config/memory-v3-gate.js";
-import type { AssistantConfig } from "../../../../../config/schema.js";
-import { getLogger } from "../../logging.js";
-import { getWorkspaceDir } from "../../paths.js";
+import { usesConceptPageMemory } from "../../../../config/memory-v3-gate.js";
+import type { AssistantConfig } from "../../../../config/schema.js";
+import { getLogger } from "../logging.js";
+import { getWorkspaceDir } from "../paths.js";
 
-const log = getLogger("memory-v2-startup");
+const log = getLogger("boot-maintenance");
 
 /**
  * Fire-and-forget seed of the v2 skill entries (now indexed alongside concept
@@ -22,8 +25,10 @@ const log = getLogger("memory-v2-startup");
  * passes. Never awaits — startup must not block on this (see
  * `assistant/CLAUDE.md` daemon startup philosophy).
  */
-export function maybeSeedMemoryV2Skills(config: AssistantConfig): void {
-  if (!usesConceptPageMemory(config.memory)) return;
+export function maybeSeedCapabilitySkills(config: AssistantConfig): void {
+  if (!usesConceptPageMemory(config.memory)) {
+    return;
+  }
   void import("./skill-store.js")
     .then(({ seedV2SkillEntries }) => seedV2SkillEntries())
     .catch((err) => log.warn({ err }, "Failed to seed v2 skill entries"));
@@ -43,8 +48,10 @@ export function maybeSeedMemoryV2Skills(config: AssistantConfig): void {
  * `cli-commands/<name>` slug prefix). Dynamic import keeps v2 code out of the
  * startup graph when the gate is off. Never awaits — startup must not block.
  */
-export function maybeSeedMemoryV2CliCommands(config: AssistantConfig): void {
-  if (!usesConceptPageMemory(config.memory)) return;
+export function maybeSeedCliCommandCards(config: AssistantConfig): void {
+  if (!usesConceptPageMemory(config.memory)) {
+    return;
+  }
   void import("./cli-command-store.js")
     .then(({ seedV2CliCommandEntries }) => seedV2CliCommandEntries())
     .catch((err) => log.warn({ err }, "Failed to seed v2 CLI-command entries"));
@@ -76,7 +83,9 @@ async function settledWithin(
   try {
     return await Promise.race([p.then(() => true), timedOut]);
   } finally {
-    if (timer) clearTimeout(timer);
+    if (timer) {
+      clearTimeout(timer);
+    }
   }
 }
 
@@ -86,7 +95,7 @@ async function settledWithin(
  * runs before the platform has provisioned the managed embedding credential.
  *
  * On a brand-new managed assistant the memory worker fires the startup seed
- * (`maybeSeedMemoryV2Skills` / `maybeSeedMemoryV2CliCommands`) seconds after
+ * (`maybeSeedCapabilitySkills` / `maybeSeedCliCommandCards`) seconds after
  * boot, but the platform pushes `vellum:assistant_api_key` (the credential the
  * managed Gemini embedding backend needs) tens of seconds later. The seed's
  * `embedWithBackend` call throws `EmbeddingBackendUnavailableError` before the
@@ -132,11 +141,15 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
   config: AssistantConfig,
   opts: { reseedTimeoutMs?: number } = {},
 ): Promise<void> {
-  if (!usesConceptPageMemory(config.memory)) return;
+  if (!usesConceptPageMemory(config.memory)) {
+    return;
+  }
 
   const { hasManagedProxyPrereqs } =
-    await import("../../../../../providers/platform-proxy/context.js");
-  if (!(await hasManagedProxyPrereqs())) return;
+    await import("../../../../providers/platform-proxy/context.js");
+  if (!(await hasManagedProxyPrereqs())) {
+    return;
+  }
 
   // The managed credential has just landed, so the embedding backend is now
   // reachable. Retry the embedding-identity reconcile to close the
@@ -151,7 +164,7 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
   // never rejects the detached caller.
   try {
     const { reconcileEmbeddingIdentity } =
-      await import("../../../../../daemon/embedding-reconcile.js");
+      await import("../../../../daemon/embedding-reconcile.js");
     await reconcileEmbeddingIdentity(config);
   } catch (err) {
     log.warn(
@@ -204,13 +217,15 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
   // Resolve the gate + enqueuer once and reuse for the post-barrier enqueue and
   // the straggler re-enqueue below.
   const { isMemoryV3Live } =
-    await import("../../../../../config/memory-v3-gate.js");
+    await import("../../../../config/memory-v3-gate.js");
   const v3Live = isMemoryV3Live(config);
   const enqueueMaintain = async (): Promise<void> => {
-    if (!v3Live) return;
+    if (!v3Live) {
+      return;
+    }
     try {
       const { enqueueMemoryJob } =
-        await import("../../../../../persistence/jobs-store.js");
+        await import("../../../../persistence/jobs-store.js");
       enqueueMemoryJob("memory_v3_maintain", {});
     } catch (err) {
       log.warn(
@@ -244,7 +259,7 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
  * length), then re-seed the v2 skill entries so any skills written during
  * cold start with the legacy TF encoder get rewritten with stemmed BM25
  * vectors. The cold-start window exists because the very first
- * `maybeSeedMemoryV2Skills` call can race ahead of the corpus-stats build —
+ * `maybeSeedCapabilitySkills` call can race ahead of the corpus-stats build —
  * `skill-store.runSeedOnce` falls back to `generateSparseEmbedding` while
  * `getConceptPageCorpusStats()` is still `null`, leaving stored skill
  * sparse vectors in a different hash space than the BM25 query vectors
@@ -260,7 +275,9 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
 export async function rebuildBm25CorpusStatsAndReseedSkills(
   config: AssistantConfig,
 ): Promise<void> {
-  if (!usesConceptPageMemory(config.memory)) return;
+  if (!usesConceptPageMemory(config.memory)) {
+    return;
+  }
 
   try {
     const { rebuildConceptPageCorpusStats } = await import("./sparse-bm25.js");
@@ -323,10 +340,12 @@ export async function rebuildBm25CorpusStatsAndReseedSkills(
  * worker drains its first batch; the body is wrapped in try/catch so a v2
  * failure never blocks startup.
  */
-export async function maybeRebuildMemoryV2Concepts(
+export async function maybeRebuildConceptCollection(
   config: AssistantConfig,
 ): Promise<void> {
-  if (!usesConceptPageMemory(config.memory)) return;
+  if (!usesConceptPageMemory(config.memory)) {
+    return;
+  }
 
   try {
     const {
@@ -336,7 +355,7 @@ export async function maybeRebuildMemoryV2Concepts(
     } = await import("./qdrant.js");
     const { hasConceptPages } = await import("./page-store.js");
     const { enqueueMemoryJob, hasActiveJobOfType } =
-      await import("../../../../../persistence/jobs-store.js");
+      await import("../../../../persistence/jobs-store.js");
 
     const { migrated } = await ensureConceptPageCollection();