@vellumai/assistant 0.8.2 → 0.8.3

package/src/memory/v2/__tests__/injection.test.ts

@@ -161,6 +161,38 @@ mock.module("../skill-store.js", () => ({
   listSkillEntries: () => Array.from(skillState.entries.values()),
 }));
 
+// ---------------------------------------------------------------------------
+// CLI-command-store mock
+// ---------------------------------------------------------------------------
+//
+// Mirrors the skill-store mock. CLI subcommand synthetic entries flow through
+// the unified pipeline under the `cli-commands/<name>` slug prefix and render
+// under `### CLI Commands You Can Use`. Tests stage `cliCommandState.entries`
+// and rely on `stageTurn` plumbing to land slugs in the candidate set.
+
+interface CliCommandEntryStub {
+  id: string;
+  description: string;
+  content: string;
+}
+
+const cliCommandState = {
+  entries: new Map<string, CliCommandEntryStub>(),
+};
+
+mock.module("../cli-command-store.js", () => ({
+  getCliCommandCapability: (idOrSlug: string) => {
+    const id = idOrSlug.startsWith("cli-commands/")
+      ? idOrSlug.slice("cli-commands/".length)
+      : idOrSlug;
+    return cliCommandState.entries.get(id) ?? null;
+  },
+  isCliCommandSlug: (slug: string) => slug.startsWith("cli-commands/"),
+  CLI_COMMAND_SLUG_PREFIX: "cli-commands/",
+  cliCommandSlugFor: (name: string) => `cli-commands/${name}`,
+  listCliCommandEntries: () => Array.from(cliCommandState.entries.values()),
+}));
+
 // ---------------------------------------------------------------------------
 // Activation-log store mock
 // ---------------------------------------------------------------------------
@@ -357,7 +389,7 @@ const { getSqliteFrom } = await import("../../db-connection.js");
 const { migrateActivationState } =
   await import("../../migrations/232-activation-state.js");
 const schema = await import("../../schema.js");
-const { evictCompactedTurns, hydrate, save } =
+const { clearEverInjected, hydrate, save } =
   await import("../activation-store.js");
 const { injectMemoryV2Block } = await import("../injection.js");
 const { _resetMemoryV2QdrantForTests } = await import("../qdrant.js");
@@ -484,6 +516,7 @@ function resetState(): void {
   state.queryResponses.dense.length = 0;
   state.queryResponses.sparse.length = 0;
   skillState.entries.clear();
+  cliCommandState.entries.clear();
   telemetryState.recordCalls.length = 0;
   telemetryState.recordShouldThrow = false;
   pageStoreState.failingSlugs.clear();
@@ -503,6 +536,13 @@ function stageSkills(entries: SkillEntry[]): void {
   }
 }
 
+/** Stage cli-command-store cache entries for the upcoming render. */
+function stageCliCommands(entries: CliCommandEntryStub[]): void {
+  for (const entry of entries) {
+    cliCommandState.entries.set(entry.id, entry);
+  }
+}
+
 let db: DrizzleDb;
 beforeEach(() => {
   db = createTestDb();
@@ -653,10 +693,10 @@ describe("injectMemoryV2Block", () => {
       config: makeConfig(),
     });
 
-    // Simulate compaction: drop all everInjected entries with turn <= 1.
+    // Simulate compaction: clear the entire everInjected list.
     const beforeEvict = await hydrate(db, "conv-1");
     expect(beforeEvict).not.toBeNull();
-    const afterEvict = evictCompactedTurns(beforeEvict!, 1);
+    const afterEvict = clearEverInjected(beforeEvict!);
     expect(afterEvict.everInjected).toEqual([]);
     await save(db, "conv-1", afterEvict);
 
@@ -1060,6 +1100,153 @@ describe("injectMemoryV2Block", () => {
     expect(result.block).toBeNull();
   });
 
+  // ---------------------------------------------------------------------------
+  // CLI-command synthetic entries — same unified-pool plumbing as skills.
+  // ---------------------------------------------------------------------------
+
+  test("renders a retrieved cli-commands/<name> slug under CLI Commands You Can Use", async () => {
+    stageTurn([{ slug: "cli-commands/attachment", denseScore: 0.9 }]);
+    stageCliCommands([
+      {
+        id: "attachment",
+        description: "Manage file attachments for conversations",
+        content: 'The "assistant attachment" CLI command is available...',
+      },
+    ]);
+
+    const result = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "How do I register a video?",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    expect(result.toInject).toEqual(["cli-commands/attachment"]);
+    expect(result.block).not.toBeNull();
+    const headerIdx = result.block!.indexOf("### CLI Commands You Can Use");
+    const lineIdx = result.block!.indexOf(
+      "- `assistant attachment`: Manage file attachments for conversations",
+    );
+    expect(headerIdx).toBeGreaterThan(-1);
+    expect(lineIdx).toBeGreaterThan(headerIdx);
+  });
+
+  test("renders concepts, skills, then cli-commands in that order in mixed blocks", async () => {
+    stageTurn([
+      { slug: "alice-vscode", denseScore: 0.95 },
+      { slug: "skills/example-skill-a", denseScore: 0.85 },
+      { slug: "cli-commands/config", denseScore: 0.75 },
+    ]);
+    stageSkills([
+      {
+        id: "example-skill-a",
+        content:
+          'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
+      },
+    ]);
+    stageCliCommands([
+      {
+        id: "config",
+        description: "Manage configuration",
+        content: 'The "assistant config" CLI command is available...',
+      },
+    ]);
+
+    const result = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "Help me",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    expect(new Set(result.toInject)).toEqual(
+      new Set([
+        "alice-vscode",
+        "skills/example-skill-a",
+        "cli-commands/config",
+      ]),
+    );
+    const conceptIdx = result.block!.indexOf(
+      "# memory/concepts/alice-vscode.md",
+    );
+    const skillsIdx = result.block!.indexOf("### Skills You Can Use");
+    const cliIdx = result.block!.indexOf("### CLI Commands You Can Use");
+    expect(conceptIdx).toBeGreaterThan(-1);
+    expect(skillsIdx).toBeGreaterThan(conceptIdx);
+    expect(cliIdx).toBeGreaterThan(skillsIdx);
+  });
+
+  test("cli-command slugs whose entry is missing from the cache are dropped silently", async () => {
+    stageTurn([{ slug: "cli-commands/missing-command", denseScore: 0.9 }]);
+
+    const result = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "anything",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    expect(result.toInject).toEqual([]);
+    expect(result.block).toBeNull();
+
+    const persisted = await hydrate(db, "conv-1");
+    expect(persisted!.everInjected).toEqual([]);
+  });
+
+  test("cli-commands participate in everInjected so they dedupe across turns", async () => {
+    const entry = {
+      id: "config",
+      description: "Manage configuration",
+      content: 'The "assistant config" CLI command is available...',
+    };
+    stageTurn([{ slug: "cli-commands/config", denseScore: 0.9 }]);
+    stageCliCommands([entry]);
+    const result1 = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "config",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+    expect(result1.toInject).toEqual(["cli-commands/config"]);
+    expect(result1.block).toContain("### CLI Commands You Can Use");
+
+    stageTurn([{ slug: "cli-commands/config", denseScore: 0.9 }]);
+    stageCliCommands([entry]);
+    const result2 = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 2,
+      userMessage: "more config",
+      assistantMessage: "ok",
+      nowText: "Now",
+      messageId: "msg-2",
+      config: makeConfig(),
+    });
+    expect(result2.toInject).toEqual([]);
+    expect(result2.block).toBeNull();
+
+    const persisted = await hydrate(db, "conv-1");
+    expect(persisted!.everInjected).toEqual([
+      { slug: "cli-commands/config", turn: 1 },
+    ]);
+  });
+
   test("context-load mode renders topNow even when every slug was previously injected", async () => {
     // Turn 1 (per-turn): seed alice as injected.
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);

package/src/memory/v2/__tests__/static-context.test.ts

@@ -32,11 +32,15 @@ mock.module("../../../util/logger.js", () => ({
 }));
 
 let configMemoryV2Enabled = true;
+let configMemoryEnabled = true;
 
 mock.module("../../../config/loader.js", () => ({
   getConfig: () => ({}),
   loadConfig: () => ({
-    memory: { v2: { enabled: configMemoryV2Enabled } },
+    memory: {
+      enabled: configMemoryEnabled,
+      v2: { enabled: configMemoryV2Enabled },
+    },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
@@ -71,6 +75,7 @@ describe("readMemoryV2StaticContent", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
     configMemoryV2Enabled = true;
+    configMemoryEnabled = true;
   });
 
   afterEach(() => {
@@ -83,6 +88,12 @@ describe("readMemoryV2StaticContent", () => {
     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}`);
+    expect(readMemoryV2StaticContent()).toBeNull();
+  });
+
   test("returns headed sections in canonical order when all files have content", () => {
     writeMemoryFile("essentials.md", "Alice prefers dark mode.");
     writeMemoryFile("threads.md", "Open thread: ship PR-123 review.");

package/src/memory/v2/activation-store.ts

@@ -11,11 +11,7 @@ import { eq } from "drizzle-orm";
 
 import type { DrizzleDb } from "../db-connection.js";
 import { activationState } from "../schema.js";
-import {
-  type ActivationState,
-  ActivationStateSchema,
-  type EverInjectedEntry,
-} from "./types.js";
+import { type ActivationState, ActivationStateSchema } from "./types.js";
 
 /**
  * Load the activation state for a conversation, or `null` if no row exists.
@@ -123,16 +119,18 @@ export function forkActivationState(
 }
 
 /**
- * Drop `everInjected` entries whose `turn` is at or below `upToTurn`.
- * Used after compaction evicts older turns — slugs that lived only on those
- * turns become eligible for re-injection on the next turn.
+ * Clear all `everInjected` entries. Used after compaction: the cached
+ * `<memory>` attachments those slugs lived on are gone, so future turns
+ * should be free to re-inject them.
+ *
+ * Unconditionally empties the list rather than filtering by turn number.
+ * `everInjected` is persisted on every turn while the in-memory tracker's
+ * `currentTurn` is only snapshotted on graceful conversation dispose, so a
+ * non-graceful shutdown (SIGKILL, crash) followed by a reload can leave
+ * `everInjected` entries with `turn` values above the restored tracker's
+ * `currentTurn`. A turn-bounded filter misses those stale entries and they
+ * dedupe forever; a full clear is robust to that drift.
  */
-export function evictCompactedTurns(
-  state: ActivationState,
-  upToTurn: number,
-): ActivationState {
-  const everInjected: EverInjectedEntry[] = state.everInjected.filter(
-    (entry) => entry.turn > upToTurn,
-  );
-  return { ...state, everInjected };
+export function clearEverInjected(state: ActivationState): ActivationState {
+  return { ...state, everInjected: [] };
 }

package/src/memory/v2/cli-command-content.ts

@@ -0,0 +1,19 @@
+/**
+ * Render the prose-style capability statement embedded into the unified
+ * `memory_v2_concept_pages` Qdrant collection (under the `cli-commands/<name>`
+ * slug prefix). Mirrors `buildSkillContent` in shape — a short prose lead-in
+ * followed by the dense capability material — so activation scoring weighs
+ * both natural-language intent and structured help text.
+ *
+ * Intentionally uncapped: CLI `--help` output averages 1–2 KB and the longest
+ * (browser, oauth) hits ~3.4 KB. The embedding backend handles inputs of this
+ * size without trouble, and trimming would drop the very examples and flag
+ * descriptions that make commands semantically findable.
+ */
+export function buildCliCommandContent(
+  name: string,
+  description: string,
+  helpText: string,
+): string {
+  return `The "assistant ${name}" CLI command is available. ${description}.\n\nFull help:\n${helpText}`;
+}

package/src/memory/v2/cli-command-store.ts

@@ -0,0 +1,304 @@
+// ---------------------------------------------------------------------------
+// Memory v2 — `assistant` CLI subcommands → embedded capability entries
+// ---------------------------------------------------------------------------
+//
+// Enumerate the top-level `assistant` CLI subcommands, render each as a prose
+// capability statement that wraps the full `helpInformation()` output, embed
+// dense + sparse, and upsert into `memory_v2_concept_pages` under the slug
+// `cli-commands/<name>`. The router scores these alongside concept pages and
+// skill entries; the injection layer surfaces hits under `### CLI Commands
+// You Can Use` so the model can semantically discover a CLI capability it
+// would not otherwise know to reach for.
+//
+// Mirrors `skill-store.ts` deliberately: same single-flight + generation
+// coalescing, same dense + sparse + corpus-stats-aware sparse encoding, same
+// payload-kind discriminator, same atomic cache replacement. Differences:
+//   - No remote catalog — the source of truth is the local Commander tree.
+//   - No per-entry feature-flag filter — flag gating already happens during
+//     `buildCliProgramTree` (e.g. email/plugins commands are conditionally
+//     registered).
+//   - No MCP-style augmentation — Commander's description is the canonical
+//     summary.
+
+import { getConfig } from "../../config/loader.js";
+import { getLogger } from "../../util/logger.js";
+import { applyCorrectionIfCalibrated } from "../anisotropy.js";
+import {
+  embedWithBackend,
+  generateSparseEmbedding,
+} from "../embedding-backend.js";
+import { buildCliCommandContent } from "./cli-command-content.js";
+import { invalidatePageIndex } from "./page-index.js";
+import {
+  backfillKindOnPointsWithPrefix,
+  pruneSlugsWithPrefixExcept,
+  upsertConceptPageEmbedding,
+} from "./qdrant.js";
+import {
+  generateBm25DocEmbedding,
+  getConceptPageCorpusStats,
+} from "./sparse-bm25.js";
+import type { CliCommandEntry } from "./types.js";
+
+const log = getLogger("memory-v2-cli-command-store");
+
+/**
+ * Slug prefix under which CLI-command embeddings are indexed in
+ * `memory_v2_concept_pages`. Concept-page slugs must match
+ * `[a-z0-9][a-z0-9-]*(/...)*`, and `cli-commands` matches that pattern, so the
+ * prefix coexists with hand-authored concept pages without escape work.
+ */
+export const CLI_COMMAND_SLUG_PREFIX = "cli-commands/";
+
+/**
+ * Payload discriminator written on every CLI-command-seeded Qdrant point.
+ * Keeps CLI rows distinguishable from user-authored concept pages and from
+ * skill rows that happen to live in adjacent namespaces, so prefix pruning
+ * never deletes a hand-authored page sitting under `cli-commands/...`.
+ */
+const CLI_COMMAND_PAYLOAD_KIND = "cli-command";
+
+/** Compose the unified-collection slug for a CLI command name. */
+export function cliCommandSlugFor(name: string): string {
+  return `${CLI_COMMAND_SLUG_PREFIX}${name}`;
+}
+
+/**
+ * Module-level cache of rendered CLI-command entries keyed by command name.
+ * `null` until the first successful seed run completes; replaced atomically
+ * on each successful re-seed so callers always see a consistent snapshot.
+ */
+let entries: Map<string, CliCommandEntry> | null = null;
+let requestedSeedGeneration = 0;
+let processedSeedGeneration = 0;
+let activeSeedDrain: Promise<void> | null = null;
+let lastSeedError: unknown = null;
+const seedWaiters: Array<{ generation: number; resolve: () => void }> = [];
+
+/**
+ * In-process latch for the legacy `kind` backfill. New upserts always write
+ * `kind`, so once the latch is set there is no follow-up work to do this
+ * process.
+ */
+let legacyKindBackfillDone = false;
+
+/**
+ * Seed (or re-seed) CLI-command embeddings into the unified concept-page
+ * collection. Idempotent. Best-effort for background callers (errors are
+ * logged but swallowed); pass `{ throwOnError: true }` from synchronous CLI
+ * paths that want failures surfaced.
+ *
+ * Single-flight + coalesced: at most one seed runs at a time. Requests made
+ * while a seed is in flight advance the requested generation; stale in-flight
+ * snapshots are skipped before they write embeddings or replace the cache.
+ */
+export async function seedV2CliCommandEntries(
+  opts: { throwOnError?: boolean } = {},
+): Promise<void> {
+  const generation = ++requestedSeedGeneration;
+  const waiter = new Promise<void>((resolve) => {
+    seedWaiters.push({ generation, resolve });
+  });
+  startSeedDrainIfNeeded();
+  await waiter;
+  if (opts.throwOnError && lastSeedError) {
+    throw lastSeedError;
+  }
+}
+
+function startSeedDrainIfNeeded(): void {
+  if (activeSeedDrain) return;
+  if (processedSeedGeneration >= requestedSeedGeneration) return;
+
+  activeSeedDrain = drainSeedQueue().finally(() => {
+    activeSeedDrain = null;
+    startSeedDrainIfNeeded();
+  });
+}
+
+async function drainSeedQueue(): Promise<void> {
+  while (processedSeedGeneration < requestedSeedGeneration) {
+    const generationToProcess = requestedSeedGeneration;
+    await runSeedV2CliCommandEntries(generationToProcess);
+    processedSeedGeneration = generationToProcess;
+    resolveSeedWaiters();
+  }
+}
+
+function resolveSeedWaiters(): void {
+  for (let i = seedWaiters.length - 1; i >= 0; i -= 1) {
+    const waiter = seedWaiters[i]!;
+    if (waiter.generation > processedSeedGeneration) continue;
+    seedWaiters.splice(i, 1);
+    waiter.resolve();
+  }
+}
+
+async function runSeedV2CliCommandEntries(generation: number): Promise<void> {
+  try {
+    const config = getConfig();
+    // Dynamic import so callers that only need `getCliCommandCapability` or
+    // `listCliCommandEntries` (e.g. the render path inside `injection.ts` and
+    // the `page-index.ts` dependency loader) never drag the full CLI command
+    // graph into their import tree. The CLI tree pulls in many provider and
+    // workspace modules whose presence has been a recurring source of test-
+    // mock cascades and circular-import surprises.
+    const { buildCliProgramTree } = await import("../../cli/program.js");
+    const program = buildCliProgramTree();
+
+    const seeds: CliCommandEntry[] = [];
+    for (const cmd of program.commands) {
+      const name = cmd.name();
+      // Skip the `help` builtin Commander adds automatically — it carries no
+      // capability information of its own and is uniform across commands.
+      if (name === "help") continue;
+      const description = cmd.description();
+      const content = buildCliCommandContent(
+        name,
+        description,
+        cmd.helpInformation(),
+      );
+      seeds.push({ id: name, description, content });
+    }
+
+    const nextEntries = new Map<string, CliCommandEntry>();
+    let denseVectors: number[][] = [];
+    let encodeSparse: (
+      input: string,
+    ) => ReturnType<typeof generateSparseEmbedding> = generateSparseEmbedding;
+    if (seeds.length > 0) {
+      const embedded = await embedWithBackend(
+        config,
+        seeds.map((s) => s.content),
+      );
+      denseVectors = await Promise.all(
+        embedded.vectors.map((v) =>
+          applyCorrectionIfCalibrated(v, embedded.provider, embedded.model),
+        ),
+      );
+
+      // CLI commands share the concept-page Qdrant collection, so the sparse
+      // vector must use the same stemmed BM25 encoding as the concept-page
+      // documents. Fall back to the legacy TF encoder only during the cold-
+      // start window before corpus stats finish building — same rationale as
+      // the skill-store path.
+      const corpusStats = getConceptPageCorpusStats();
+      encodeSparse = (input: string) =>
+        corpusStats
+          ? generateBm25DocEmbedding(input, corpusStats, {
+              k1: config.memory.v2.bm25_k1,
+              b: config.memory.v2.bm25_b,
+            })
+          : generateSparseEmbedding(input);
+    }
+
+    if (generation !== requestedSeedGeneration) {
+      log.info(
+        { generation, latestGeneration: requestedSeedGeneration },
+        "Skipping stale v2 CLI-command seed result",
+      );
+      lastSeedError = null;
+      return;
+    }
+
+    if (seeds.length > 0) {
+      const now = Date.now();
+      await Promise.all(
+        seeds.map((seed, i) =>
+          upsertConceptPageEmbedding({
+            slug: cliCommandSlugFor(seed.id),
+            dense: denseVectors[i],
+            sparse: encodeSparse(seed.content),
+            updatedAt: now,
+            kind: CLI_COMMAND_PAYLOAD_KIND,
+          }),
+        ),
+      );
+      for (const seed of seeds) {
+        nextEntries.set(seed.id, seed);
+      }
+    }
+
+    // The CLI tree is always available (no remote catalog), so pruning is
+    // unconditional. Run the legacy `kind` backfill once per process so
+    // pre-discriminator rows become prunable.
+    const knownIds = new Set(seeds.map((s) => s.id));
+    if (!legacyKindBackfillDone) {
+      try {
+        await backfillKindOnPointsWithPrefix(
+          CLI_COMMAND_SLUG_PREFIX,
+          CLI_COMMAND_PAYLOAD_KIND,
+          knownIds,
+        );
+        legacyKindBackfillDone = true;
+      } catch (err) {
+        log.warn(
+          { err },
+          "Failed to backfill kind on legacy CLI-command points — pruning may leave orphans this run",
+        );
+      }
+    }
+    await pruneSlugsWithPrefixExcept(
+      CLI_COMMAND_SLUG_PREFIX,
+      seeds.map((s) => s.id),
+      { kind: CLI_COMMAND_PAYLOAD_KIND },
+    );
+
+    // Atomically replace the cache only after every step above succeeds.
+    entries = nextEntries;
+    invalidatePageIndex();
+    lastSeedError = null;
+  } catch (err) {
+    lastSeedError = err;
+    log.warn({ err }, "Failed to seed v2 CLI-command entries");
+  }
+}
+
+/**
+ * Synchronous lookup of a previously-seeded `CliCommandEntry` by command
+ * name. Returns `null` when the cache has not yet been populated, when the
+ * id is unknown, or when a prior seed run dropped the id.
+ *
+ * Accepts either a bare command name (`attachment`) or its unified-collection
+ * slug (`cli-commands/attachment`) so render-side callers can pass through
+ * what they have without a manual prefix strip.
+ *
+ * Returns a frozen copy so callers cannot mutate the underlying cache entry.
+ */
+export function getCliCommandCapability(
+  idOrSlug: string,
+): CliCommandEntry | null {
+  const id = idOrSlug.startsWith(CLI_COMMAND_SLUG_PREFIX)
+    ? idOrSlug.slice(CLI_COMMAND_SLUG_PREFIX.length)
+    : idOrSlug;
+  const entry = entries?.get(id);
+  return entry ? Object.freeze({ ...entry }) : null;
+}
+
+/** True iff the slug refers to a CLI-command entry in the unified collection. */
+export function isCliCommandSlug(slug: string): boolean {
+  return slug.startsWith(CLI_COMMAND_SLUG_PREFIX);
+}
+
+/**
+ * Snapshot of the in-process CLI-command cache, sorted by command name (ASCII
+ * order) for determinism. Returns a freshly allocated array of frozen entry
+ * copies on each call.
+ */
+export function listCliCommandEntries(): CliCommandEntry[] {
+  if (!entries) return [];
+  return [...entries.values()]
+    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+    .map((entry) => Object.freeze({ ...entry }));
+}
+
+/** @internal Test-only: clear the module-level cache. */
+export function _resetCliCommandStoreForTests(): void {
+  entries = null;
+  requestedSeedGeneration = 0;
+  processedSeedGeneration = 0;
+  activeSeedDrain = null;
+  seedWaiters.splice(0, seedWaiters.length);
+  lastSeedError = null;
+  legacyKindBackfillDone = false;
+}

package/src/memory/v2/frontmatter-sweep.ts

@@ -22,6 +22,7 @@ import { join } from "node:path";
 
 import { parse as parseYaml } from "yaml";
 
+import type { AssistantConfig } from "../../config/schema.js";
 import { FRONTMATTER_REGEX } from "../../skills/frontmatter.js";
 import { getLogger } from "../../util/logger.js";
 import { listPages } from "./page-store.js";
@@ -32,11 +33,16 @@ const log = getLogger("memory-v2-frontmatter-sweep");
 /**
  * Validate every concept page's frontmatter against the strict schema and
  * emit a `warn` per offender. Never throws — daemon startup must not block
- * on this safety net.
+ * on this safety net. Self-gates on `config.memory.v2.enabled`: when v2
+ * is off, concept pages never enter a retrieval top-K so any warns here
+ * would be pure noise.
  */
 export async function sweepConceptPageFrontmatter(
+  config: AssistantConfig,
   workspaceDir: string,
 ): Promise<void> {
+  if (!config.memory.v2.enabled) return;
+
   let slugs: string[];
   try {
     slugs = await listPages(workspaceDir);