@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/plugins/defaults/{injectors/register.ts → memory-retrieval/injectors.ts}

@@ -32,35 +32,49 @@
  * closer to the memory prefix themselves. For appends, ascending `order` is
  * the natural left-to-right append sequence. The runtime-injection applier
  * sorts and applies blocks declaratively so this invariant holds even when
- * third-party injectors slot additional blocks at fractional order values.
- *
- * Third-party plugins may register additional {@link Injector}s at any
- * `order` value; the registry's `getInjectors()` returns all injectors
- * sorted ascending, so a plugin-registered injector at `order: 25`
- * reliably slots between `unified-turn-context` (20) and `pkb` (30).
- *
- * This module only builds and exports the `Plugin` object; the defaults
- * aggregator in `plugins/defaults/index.ts` registers it centrally, either
- * explicitly from `daemon/external-plugins-bootstrap.ts` or lazily via the
- * registry's default registrar the first time a query reads the registry.
+ * injectors slot additional blocks at fractional order values.
+ *
+ * This module exports the default injectors as a plain ordered array
+ * ({@link defaultInjectors}). The chain assembler in
+ * `plugins/defaults/memory-retrieval/injector-chain.ts` sorts them by `order`
+ * (alongside the memory-v3 injector) into the single sequence
+ * `applyRuntimeInjections` walks each turn — injection is not a plugin
+ * contribution, so injectors are imported directly rather than aggregated
+ * through the registry.
  */
 
 import { resolve } from "node:path";
 
 import { getConfig } from "../../../config/loader.js";
+import type { InjectionMatcher } from "../../../context/strip-injections.js";
+import { findConversationOrSubagent } from "../../../daemon/conversation-registry.js";
+import { resolveWorkspaceTopLevelContext } from "../../../daemon/conversation-workspace.js";
+import { readNowScratchpad } from "../../../daemon/now-scratchpad.js";
 import { getInContextPkbPaths } from "../../../daemon/pkb-context-tracker.js";
 import { buildPkbReminder } from "../../../daemon/pkb-reminder-builder.js";
+import {
+  resolveTrustClass,
+  type TrustContext,
+} from "../../../daemon/trust-context.js";
 import { listComments } from "../../../documents/document-comments-store.js";
+import { getLiveGraphMemory } from "../../../memory/graph/conversation-graph-memory.js";
+import { getPkbAutoInjectList } from "../../../memory/pkb/autoinject.js";
+import { readPkbContext } from "../../../memory/pkb/context.js";
 import { searchPkbFiles } from "../../../memory/pkb/pkb-search.js";
+import { getPkbRoot, PKB_WORKSPACE_SCOPE } from "../../../memory/pkb/types.js";
+import {
+  readMemoryV2StaticContent,
+  shouldExposePersonalMemory,
+} from "../../../memory/v2/static-context.js";
+import type { Message } from "../../../providers/types.js";
 import { getLogger } from "../../../util/logger.js";
+import { getSandboxWorkingDir } from "../../../util/platform.js";
 import {
   type InjectionBlock,
   type Injector,
-  type Plugin,
   type TurnContext,
   type TurnInjectionInputs,
 } from "../../types.js";
-import pkg from "./package.json" with { type: "json" };
 
 const pkbReminderLog = getLogger("pkb-reminder");
 
@@ -79,7 +93,7 @@ const PKB_HINT_ARCHIVE_THRESHOLD = 0.7;
  * and any future integration code — can assert ordering without re-deriving
  * the constants.
  *
- * Gaps of 10 between slots leave room for third-party injectors to slot in
+ * Gaps of 10 between slots leave room for future injectors to slot in
  * at granular positions (e.g. `25` between unified-turn-context and pkb)
  * without renumbering the defaults.
  */
@@ -113,12 +127,22 @@ Then help the user clean up storage. Prefer safe inspection steps first, such as
 Do not work on unrelated tasks until enough space is freed to clear the lock or the user explicitly overrides it. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
 </disk_pressure_warning>`;
 
+/**
+ * `disk-pressure-warning` injector — order 5, prepend-user-tail.
+ *
+ * Emits the storage cleanup-mode warning at the very top of the user tail when
+ * the turn is restricted to disk-pressure cleanup. Reads the cleanup-mode flag
+ * off the live `Conversation` looked up by conversation id — the agent loop
+ * sets `diskPressureCleanupModeActive` when it classifies the turn's
+ * disk-pressure policy — rather than having the loop thread it as an injection
+ * input.
+ */
 const diskPressureWarningInjector: Injector = {
   name: "disk-pressure-warning",
   order: DEFAULT_INJECTOR_ORDER.diskPressureWarning,
   async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
-    const inputs = readInjectionInputs(ctx);
-    if (!inputs.diskPressureContext?.cleanupModeActive) return null;
+    const conversation = findConversationOrSubagent(ctx.conversationId);
+    if (!conversation?.diskPressureCleanupModeActive) return null;
     return {
       id: "disk-pressure-warning",
       text: DISK_PRESSURE_WARNING_PROMPT,
@@ -138,26 +162,52 @@ function isPkbInjectionSilencedByV2(): boolean {
   return getConfig().memory.v2.enabled;
 }
 
+/**
+ * Matchers that mark a persisted `<workspace>` top-level injection. Uses the
+ * `{ prefix, suffix }` wrapper shape so user-authored text merely starting with
+ * `<workspace>\n` is never mistaken for an injection — matching the full-wrapper
+ * requirement the compaction strip uses for this block. The legacy
+ * `<workspace_top_level>` tag (pre-rename history) counts as present too.
+ */
+const WORKSPACE_BLOCK_MATCHERS: readonly InjectionMatcher[] = [
+  { prefix: "<workspace>\n", suffix: "\n</workspace>" },
+  "<workspace_top_level>",
+];
+
 /**
  * `workspace-context` injector — order 10, prepend-user-tail.
  *
  * Injects the workspace top-level directory context at the very top of the
- * user tail's content so the assistant sees a workspace grounding block
- * before any other per-turn context.
+ * user tail's content so the assistant sees a workspace grounding block before
+ * any other per-turn context.
+ *
+ * Sources the dirty-guarded top-level cache itself via
+ * {@link resolveWorkspaceTopLevelContext} (keyed by conversation id) rather than
+ * having the agent loop compute and thread it. Decides inject/skip by presence
+ * detection: the block is (re)injected only when it is absent from the working
+ * messages — true on the first turn and right after compaction strips it — and
+ * skipped on normal cached turns where it already persists in history. This
+ * keeps the conversation prefix stable for Anthropic's prefix caching.
  *
  * Gating:
  *  - `mode === "full"` (skipped in minimal mode).
- *  - `workspaceTopLevelContext` is a non-null, non-empty string.
+ *  - the rendered workspace context is a non-null, non-empty string.
+ *  - no `<workspace>` block is already present in `runMessages`.
  */
 const workspaceContextInjector: Injector = {
   name: "workspace-context",
   order: DEFAULT_INJECTOR_ORDER.workspaceContext,
-  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
+  async produce(
+    ctx: TurnContext,
+    runMessages?: Message[],
+  ): Promise<InjectionBlock | null> {
     const inputs = readInjectionInputs(ctx);
     const mode = inputs.mode ?? "full";
     if (mode !== "full") return null;
-    const text = inputs.workspaceTopLevelContext;
+    const text = resolveWorkspaceTopLevelContext(ctx.conversationId);
     if (!text) return null;
+    if (hasInjectedUserTextBlock(runMessages, WORKSPACE_BLOCK_MATCHERS))
+      return null;
     return {
       id: "workspace-context",
       text,
@@ -241,20 +291,33 @@ const unifiedTurnContextInjector: Injector = {
  *
  * Gating:
  *  - `mode === "full"`.
- *  - Non-null, non-empty `pkbContext`.
+ *  - The personal-memory trust gate admits the actor and the workspace has
+ *    PKB content (see {@link readGatedPkbContext}).
+ *  - The `<knowledge_base>` block is not already present in the turn's working
+ *    messages. The big block is injected once and then persists in history, so
+ *    it only needs (re)injecting on the first turn and right after compaction
+ *    strips it — both of which leave the working messages without the block.
+ *    Skipping when it is present keeps the conversation prefix stable for
+ *    Anthropic's prefix caching and avoids a duplicate splice.
  */
 const pkbContextInjector: Injector = {
   name: "pkb-context",
   order: DEFAULT_INJECTOR_ORDER.pkbContext,
-  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
+  async produce(
+    ctx: TurnContext,
+    runMessages?: Message[],
+  ): Promise<InjectionBlock | null> {
     const inputs = readInjectionInputs(ctx);
     const mode = inputs.mode ?? "full";
     if (mode !== "full") return null;
     if (isPkbInjectionSilencedByV2()) return null;
-    if (!inputs.pkbContext) return null;
+    const content = readGatedPkbContext(ctx.trust);
+    if (!content) return null;
+    if (hasInjectedUserTextBlock(runMessages, KNOWLEDGE_BASE_BLOCK_PREFIXES))
+      return null;
     return {
       id: "pkb-context",
-      text: buildPkbContextBlock(inputs.pkbContext),
+      text: buildPkbContextBlock(content),
       placement: "after-memory-prefix",
     };
   },
@@ -271,18 +334,21 @@ const pkbContextInjector: Injector = {
  *
  * Gating:
  *  - `mode === "full"`.
- *  - `pkbActive === true`.
+ *  - PKB is active for the turn (see {@link isPkbActive}).
  */
 const pkbReminderInjector: Injector = {
   name: "pkb-reminder",
   order: DEFAULT_INJECTOR_ORDER.pkbReminder,
-  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
+  async produce(
+    ctx: TurnContext,
+    runMessages?: Message[],
+  ): Promise<InjectionBlock | null> {
     const inputs = readInjectionInputs(ctx);
     const mode = inputs.mode ?? "full";
     if (mode !== "full") return null;
-    if (!inputs.pkbActive) return null;
+    if (!isPkbActive(ctx.trust)) return null;
     if (isPkbInjectionSilencedByV2()) return null;
-    const reminder = await buildPkbReminderWithHints(inputs);
+    const reminder = await buildPkbReminderWithHints(ctx, runMessages);
     return {
       id: "pkb-reminder",
       text: reminder,
@@ -291,6 +357,125 @@ const pkbReminderInjector: Injector = {
   },
 };
 
+/**
+ * Whether personal-memory content (PKB, NOW.md) may be surfaced this turn: the
+ * trust gate admits the actor (guardian-class, or an internal/local flow). All
+ * memory-domain injectors share this gate so they apply identical exposure
+ * rules without it being threaded in from the agent loop.
+ */
+function isPersonalMemoryAllowed(trust: TrustContext): boolean {
+  return shouldExposePersonalMemory({
+    sourceChannel: trust.sourceChannel,
+    isTrustedActor: resolveTrustClass(trust) === "guardian",
+  });
+}
+
+/**
+ * Read the auto-injected PKB content for the turn, gated behind the
+ * personal-memory trust gate. Returns the content string when the gate admits
+ * the actor and the workspace has PKB content, otherwise `null`. Both the gate
+ * and the content are sourced from the turn's trust context and the PKB files
+ * directly, so the memory-domain injectors source their own inputs rather than
+ * having them threaded in from the agent loop.
+ */
+function readGatedPkbContext(trust: TrustContext): string | null {
+  return isPersonalMemoryAllowed(trust) ? readPkbContext() : null;
+}
+
+/**
+ * Read the NOW.md scratchpad content for the turn, gated behind the
+ * personal-memory trust gate and the `scratchpadInjection` config toggle.
+ * Returns the trimmed content when both gates admit and the file is non-empty,
+ * otherwise `null`. Sourced from the trust context and the NOW.md file directly
+ * so the `now-md` injector owns its input rather than having it threaded in.
+ */
+function readGatedNowScratchpad(trust: TrustContext): string | null {
+  if (!isPersonalMemoryAllowed(trust)) return null;
+  if (!getConfig().memory.retrieval.scratchpadInjection.enabled) return null;
+  return readNowScratchpad();
+}
+
+/**
+ * Read the v2 static memory content for the turn, gated behind the
+ * personal-memory trust gate. Returns the content (essentials/threads/recent/
+ * buffer concatenated) when the gate admits and v2 memory is enabled,
+ * otherwise `null`. {@link readMemoryV2StaticContent} self-gates on the v2
+ * flag + config, so the `memory-v2-static` injector owns its input rather than
+ * having it threaded in from the agent loop.
+ */
+function readGatedMemoryV2Static(trust: TrustContext): string | null {
+  return isPersonalMemoryAllowed(trust) ? readMemoryV2StaticContent() : null;
+}
+
+/**
+ * Whether PKB is active for the turn: the personal-memory trust gate admits
+ * the actor and the workspace has PKB content to surface.
+ */
+function isPkbActive(trust: TrustContext): boolean {
+  return readGatedPkbContext(trust) !== null;
+}
+
+/** Block prefixes that mark a persisted `<knowledge_base>` injection. */
+const KNOWLEDGE_BASE_BLOCK_PREFIXES = [
+  "<knowledge_base>",
+  "<pkb>", // backward-compat: pre-rename history
+] as const;
+
+/** Block prefixes that mark a persisted NOW.md injection. */
+const NOW_MD_BLOCK_PREFIXES = [
+  "<NOW.md Always keep this up to date",
+  "<now_scratchpad>", // backward-compat: pre-rename history
+] as const;
+
+/**
+ * Matchers that mark a persisted `memory-v2-static` injection. Uses the
+ * `{ prefix, suffix }` wrapper shape (not a bare prefix) so user-authored text
+ * merely starting with `<info>\n` is never mistaken for an injection — matching
+ * the full-wrapper requirement the compaction strip uses for this block.
+ *
+ * The static block is wrapped in `<info>…</info>` today, but rows persisted
+ * before that switch rehydrate verbatim as `<memory>…</memory>` (see
+ * `conversation-lifecycle`), so the legacy wrapper counts as present too.
+ * Matching `<memory>` cannot wrongly skip a needed injection: the static block
+ * is only (re)injected on the first turn (empty history) and right after
+ * compaction (which strips both wrappers), and on neither is a `<memory>` block
+ * present — the dynamic activation `<memory>` block only survives on normal
+ * cached turns, which is exactly when this injector must skip anyway.
+ */
+const MEMORY_V2_STATIC_BLOCK_MATCHERS: readonly InjectionMatcher[] = [
+  { prefix: "<info>\n", suffix: "\n</info>" },
+  { prefix: "<memory>\n", suffix: "\n</memory>" },
+];
+
+/**
+ * Whether a block matching any of the given matchers is already present in the
+ * turn's working messages. Mirrors `stripUserTextBlocksByPrefix` (a
+ * user-message text block whose content matches a bare-prefix or a
+ * `{ prefix, suffix }` wrapper matcher), so presence detection stays in
+ * lockstep with what compaction strips: a block is present here exactly when
+ * compaction would strip it.
+ */
+function hasInjectedUserTextBlock(
+  runMessages: Message[] | undefined,
+  matchers: readonly InjectionMatcher[],
+): boolean {
+  if (!runMessages) return false;
+  return runMessages.some(
+    (message) =>
+      message.role === "user" &&
+      message.content.some(
+        (block) =>
+          block.type === "text" &&
+          matchers.some((m) =>
+            typeof m === "string"
+              ? block.text.startsWith(m)
+              : block.text.startsWith(m.prefix) &&
+                block.text.endsWith(m.suffix),
+          ),
+      ),
+  );
+}
+
 /**
  * Render the PKB context block — wraps the raw content in
  * `<knowledge_base>...</knowledge_base>` while escaping any closing tags
@@ -305,38 +490,40 @@ function buildPkbContextBlock(content: string): string {
 }
 
 /**
- * Build the PKB `<system_reminder>` text. When a dense query vector plus
- * enough scope metadata is available, run the hybrid PKB search to
+ * Build the PKB `<system_reminder>` text. When a dense query vector and the
+ * turn's working messages are available, run the hybrid PKB search to
  * surface up to three relevance hints; fall back to the flat static
  * reminder on empty results or any error.
+ *
+ * The dense/sparse query pair is read off the conversation's live graph
+ * handle ({@link getLiveGraphMemory}) — the memory-retrieval hook records it
+ * there during the turn's retrieval. In-context PKB paths are computed from
+ * the turn's working messages (`runMessages`, supplied by the injector chain)
+ * resolved against the workspace working directory, so the reminder sources
+ * its inputs itself rather than having them threaded through the agent loop.
  */
 async function buildPkbReminderWithHints(
-  inputs: TurnInjectionInputs,
+  ctx: TurnContext,
+  runMessages?: Message[],
 ): Promise<string> {
   let hints: string[] = [];
-  const queryVector = inputs.pkbQueryVector;
-  if (
-    queryVector &&
-    queryVector.length > 0 &&
-    inputs.pkbScopeId &&
-    inputs.pkbConversation &&
-    inputs.pkbRoot
-  ) {
+  const graphMemory = getLiveGraphMemory(ctx.conversationId);
+  const queryVector = graphMemory?.pkbQueryVector;
+  if (queryVector && queryVector.length > 0 && runMessages) {
     try {
+      const pkbRoot = getPkbRoot();
       const results = await searchPkbFiles(
         queryVector,
-        inputs.pkbSparseVector,
+        graphMemory?.pkbSparseVector,
         8,
-        [inputs.pkbScopeId],
+        [PKB_WORKSPACE_SCOPE],
       );
-      const workingDir = inputs.pkbWorkingDir ?? inputs.pkbRoot;
       const inContext = getInContextPkbPaths(
-        inputs.pkbConversation,
-        inputs.pkbAutoInjectList ?? [],
-        inputs.pkbRoot,
-        workingDir,
+        { messages: runMessages },
+        getPkbAutoInjectList(pkbRoot),
+        pkbRoot,
+        getSandboxWorkingDir(),
       );
-      const pkbRoot = inputs.pkbRoot;
       // Gate on `denseScore` (cosine, [0, 1]) so the quality bar is stable
       // regardless of whether sparse was provided. Rank by `hybridScore`
       // (RRF) when available — that captures the sparse signal for
@@ -395,18 +582,30 @@ async function buildPkbReminderWithHints(
  * the memory prefix so `now-md` (40) splices after it.
  *
  * Gating:
- *  - `mode === "full"`.
- *  - `memoryV2Static` is a non-null, non-empty string.
+ *  - `mode === "full"` (skipped in minimal mode).
+ *  - The personal-memory trust gate admits the actor and v2 static memory has
+ *    content (see {@link readGatedMemoryV2Static}).
+ *  - The `<info>` block is not already present in the turn's working messages.
+ *    Like `<knowledge_base>`, the block is injected once and then persists in
+ *    history, so it only needs (re)injecting on the first turn and right after
+ *    compaction strips it — both of which leave the working messages without
+ *    the block. Skipping when it is present keeps the conversation prefix
+ *    stable for Anthropic's prefix caching and avoids a duplicate splice.
  */
 const memoryV2StaticInjector: Injector = {
   name: "memory-v2-static",
   order: DEFAULT_INJECTOR_ORDER.memoryV2Static,
-  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
+  async produce(
+    ctx: TurnContext,
+    runMessages?: Message[],
+  ): Promise<InjectionBlock | null> {
     const inputs = readInjectionInputs(ctx);
     const mode = inputs.mode ?? "full";
     if (mode !== "full") return null;
-    const content = inputs.memoryV2Static;
+    const content = readGatedMemoryV2Static(ctx.trust);
     if (!content) return null;
+    if (hasInjectedUserTextBlock(runMessages, MEMORY_V2_STATIC_BLOCK_MATCHERS))
+      return null;
     return {
       id: "memory-v2-static",
       text: buildMemoryV2StaticBlock(content),
@@ -438,17 +637,30 @@ function buildMemoryV2StaticBlock(content: string): string {
  *
  * Gating:
  *  - `mode === "full"` (skipped in minimal mode).
- *  - `nowScratchpad` is a non-null, non-empty string.
+ *  - The personal-memory trust gate admits the actor, the `scratchpadInjection`
+ *    config toggle is on, and NOW.md has content (see
+ *    {@link readGatedNowScratchpad}).
+ *  - The NOW.md block is not already present in the turn's working messages.
+ *    Like `<knowledge_base>`, the block is injected once and then persists in
+ *    history, so it only needs (re)injecting on the first turn and right after
+ *    compaction strips it — both of which leave the working messages without
+ *    the block. Skipping when it is present keeps the conversation prefix
+ *    stable for Anthropic's prefix caching and avoids a duplicate splice.
  */
 const nowMdInjector: Injector = {
   name: "now-md",
   order: DEFAULT_INJECTOR_ORDER.nowMd,
-  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
+  async produce(
+    ctx: TurnContext,
+    runMessages?: Message[],
+  ): Promise<InjectionBlock | null> {
     const inputs = readInjectionInputs(ctx);
     const mode = inputs.mode ?? "full";
     if (mode !== "full") return null;
-    const content = inputs.nowScratchpad;
+    const content = readGatedNowScratchpad(ctx.trust);
     if (!content) return null;
+    if (hasInjectedUserTextBlock(runMessages, NOW_MD_BLOCK_PREFIXES))
+      return null;
     const text = `<NOW.md Always keep this up to date; keep under 10 lines>\n${content}\n</NOW.md>`;
     return {
       id: "now-md",
@@ -675,31 +887,26 @@ const threadFocusInjector: Injector = {
 };
 
 /**
- * Bundle every default injector into a single first-party plugin. Registered
- * at daemon startup via `external-plugins-bootstrap.ts`.
+ * Every default injector in ascending `order`. This is the canonical
+ * first-party injection sequence consumed by `applyRuntimeInjections` via the
+ * assembled injector chain.
  *
- * Using one plugin per injector would inflate the registry and create
- * spurious registration-order dependencies; a single plugin keeps the
- * ordering contract entirely in the `order` field.
+ * `order` is the source of truth for sequencing (see {@link DEFAULT_INJECTOR_ORDER});
+ * the chain assembler sorts by it, so this array's literal order is only a
+ * readability convenience.
  */
-export const defaultInjectorsPlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  injectors: [
-    diskPressureWarningInjector,
-    workspaceContextInjector,
-    backgroundTurnInjector,
-    unifiedTurnContextInjector,
-    pkbContextInjector,
-    pkbReminderInjector,
-    memoryV2StaticInjector,
-    nowMdInjector,
-    activeDocumentsInjector,
-    documentCommentsInjector,
-    subagentStatusInjector,
-    slackMessagesInjector,
-    threadFocusInjector,
-  ],
-};
+export const defaultInjectors: Injector[] = [
+  diskPressureWarningInjector,
+  workspaceContextInjector,
+  backgroundTurnInjector,
+  unifiedTurnContextInjector,
+  pkbContextInjector,
+  pkbReminderInjector,
+  memoryV2StaticInjector,
+  nowMdInjector,
+  activeDocumentsInjector,
+  documentCommentsInjector,
+  subagentStatusInjector,
+  slackMessagesInjector,
+  threadFocusInjector,
+];

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/assign.test.ts

@@ -8,15 +8,15 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { readPage, writePage } from "../../../../memory/v2/page-store.js";
+import type { ConceptPageFrontmatter } from "../../../../memory/v2/types.js";
 import type {
   Message,
   Provider,
   ProviderResponse,
   SendMessageOptions,
   ToolUseContent,
-} from "../../../providers/types.js";
-import { readPage, writePage } from "../../v2/page-store.js";
-import type { ConceptPageFrontmatter } from "../../v2/types.js";
+} from "../../../../providers/types.js";
 import type { LeafNode, LeafTree } from "../types.js";
 
 // Stub the provider layer before importing `assign.js` so its static import
@@ -24,7 +24,7 @@ import type { LeafNode, LeafTree } from "../types.js";
 // aren't built in a fresh worktree) never loads. The classifier is
 // provider-injectable, so every test passes its own stub provider — the real
 // `getConfiguredProvider` is never exercised here.
-mock.module("../../../providers/provider-send-message.js", () => ({
+mock.module("../../../../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => null,
   extractToolUse: (response: ProviderResponse) =>
     response.content.find((b): b is ToolUseContent => b.type === "tool_use"),

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/health.test.ts

@@ -42,6 +42,22 @@ describe("computeV3Health", () => {
     expect(report.unassigned).toEqual(["page-b", "page-c"]);
   });
 
+  test("excludes synthetic capability slugs from unassigned / novel clusters", () => {
+    const t = tree({ "domain-a/topic-x": ["page-a"] });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: ["page-a", "page-b", "cli-commands/example", "skills/example"],
+    });
+    // Capability slugs are handled by the always-on capabilities leaf (injected
+    // into the live lane tree, absent here), not the persisted tree — so they must
+    // not be reported as unassigned or grouped into novel clusters. page-b is the
+    // one real unassigned concept page.
+    expect(report.unassigned).toEqual(["page-b"]);
+    expect(report.novelClusters).toEqual([
+      { prefix: "page-b", slugs: ["page-b"], count: 1 },
+    ]);
+  });
+
   test("flags dangling page refs pointing at missing leaves", () => {
     const t = tree({ "domain-a/topic-x": ["page-a"] });
     const report = computeV3Health({

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/__tests__/live-integration.test.ts

@@ -25,13 +25,13 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { stripAllMemoryInjections } from "../../../../memory/graph/conversation-graph-memory.js";
 import type {
   ContentBlock,
   Message,
   Provider,
   ProviderResponse,
-} from "../../../providers/types.js";
-import { stripAllMemoryInjections } from "../../graph/conversation-graph-memory.js";
+} from "../../../../providers/types.js";
 import type { NeedleIndex } from "../needle.js";
 import type {
   LeafNode,
@@ -49,13 +49,13 @@ import liveTurns from "./fixtures/live-turns.json" with { type: "json" };
 
 let providerStub: Provider | null = null;
 
-mock.module("../../../providers/provider-send-message.js", () => ({
+mock.module("../../../../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => providerStub,
   extractToolUse: (response: ProviderResponse) =>
     response.content.find((b) => b.type === "tool_use"),
 }));
 
-mock.module("../../../util/logger.js", () => ({
+mock.module("../../../../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: (_t, prop) => (prop === "child" ? () => ({}) : () => {}),

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

@@ -3,11 +3,11 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { setOverridesForTesting } from "../../../__tests__/feature-flag-test-helpers.js";
-import type { AssistantConfig } from "../../../config/types.js";
-import type { MemoryJob } from "../../jobs-store.js";
-import { readPage, writePage } from "../../v2/page-store.js";
-import type { ConceptPage } from "../../v2/types.js";
+import { setOverridesForTesting } from "../../../../__tests__/feature-flag-test-helpers.js";
+import type { AssistantConfig } from "../../../../config/types.js";
+import type { MemoryJob } from "../../../../memory/jobs-store.js";
+import { readPage, writePage } from "../../../../memory/v2/page-store.js";
+import type { ConceptPage } from "../../../../memory/v2/types.js";
 import type { AssignPageResult, AssignPagesOptions } from "../assign.js";
 import {
   type ClassifyCandidate,