@vellumai/assistant 0.6.6 → 0.7.0

package/src/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -0,0 +1,412 @@
+/**
+ * Tests for the v2 routing wired into `ConversationGraphMemory.prepareMemory`.
+ *
+ * The wiring layer at `conversation-graph-memory.ts` reads two signals to
+ * decide whether to swap v1's injection step for the v2 activation pipeline:
+ *
+ *   1. The `memory-v2-enabled` feature flag (`isAssistantFeatureFlagEnabled`).
+ *   2. The workspace config value `memory.v2.enabled`.
+ *
+ * Both must be true for v2 to take over. This file uses the *real*
+ * `injectMemoryV2Block` and stubs only the lower-level deps (Qdrant client,
+ * embedding backend) the way `memory/v2/__tests__/injection.test.ts` does —
+ * mocking `injection.js` itself would clobber that sibling test when both
+ * files run in the same `bun test` invocation, since `mock.module` is
+ * process-global. Avoiding the mock keeps the suite hermetic in either order.
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import type { AssistantConfig } from "../../../config/types.js";
+import type { Message } from "../../../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Module mocks (must precede the dynamic imports below)
+// ---------------------------------------------------------------------------
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+// Stub the v1 retriever so we don't reach Qdrant. Both modes return zero
+// nodes — the v1 injection branch becomes a no-op, isolating the assertion
+// to "did the v2 routing fire?".
+mock.module("../retriever.js", () => ({
+  loadContextMemory: async () => ({
+    nodes: [],
+    serendipityNodes: [],
+    latencyMs: 1,
+    metrics: null,
+    queryVector: undefined,
+    sparseVector: undefined,
+    userQueryVector: undefined,
+    userQuerySparseVector: undefined,
+  }),
+  retrieveForTurn: async () => ({
+    nodes: [],
+    latencyMs: 1,
+    metrics: null,
+    queryVector: undefined,
+    sparseVector: undefined,
+  }),
+}));
+
+// Programmable embedding + Qdrant state. Mirrors the pattern in
+// `memory/v2/__tests__/injection.test.ts` so we drive the real
+// `injectMemoryV2Block` end-to-end without a live backend.
+const qdrantState = {
+  queryResponses: {
+    dense: [] as Array<{
+      points: Array<{ score?: number; payload: Record<string, unknown> }>;
+    }>,
+    sparse: [] as Array<{
+      points: Array<{ score?: number; payload: Record<string, unknown> }>;
+    }>,
+  },
+};
+
+class MockQdrantClient {
+  constructor(_opts: unknown) {}
+  async collectionExists(_name: string) {
+    return { exists: true };
+  }
+  async createCollection() {
+    return {};
+  }
+  async createPayloadIndex() {
+    return {};
+  }
+  async query(
+    _name: string,
+    params: { using: string; limit: number; filter?: unknown },
+  ) {
+    const queue =
+      qdrantState.queryResponses[params.using as "dense" | "sparse"];
+    return queue.shift() ?? { points: [] };
+  }
+}
+
+mock.module("@qdrant/js-client-rest", () => ({
+  QdrantClient: MockQdrantClient,
+}));
+
+const realEmbeddingBackend = await import("../../embedding-backend.js");
+mock.module("../../embedding-backend.js", () => ({
+  ...realEmbeddingBackend,
+  embedWithBackend: async () => ({
+    provider: "local",
+    model: "test-model",
+    vectors: [[0.1, 0.2, 0.3]] as number[][],
+  }),
+  generateSparseEmbedding: () => ({
+    indices: [1, 2, 3],
+    values: [0.5, 0.5, 0.5] as number[],
+  }),
+}));
+
+const realQdrantClient = await import("../../qdrant-client.js");
+mock.module("../../qdrant-client.js", () => ({
+  ...realQdrantClient,
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
+}));
+
+// ---------------------------------------------------------------------------
+// Workspace + DB fixtures
+// ---------------------------------------------------------------------------
+
+let tmpWorkspace: string;
+let previousWorkspaceEnv: string | undefined;
+
+beforeAll(() => {
+  tmpWorkspace = mkdtempSync(join(tmpdir(), "conv-graph-v2-routing-test-"));
+  previousWorkspaceEnv = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = tmpWorkspace;
+
+  // Seed v2 layout with a single concept page so the real injection module
+  // has something concrete to render. Generic placeholders only.
+  mkdirSync(join(tmpWorkspace, "memory", "concepts"), { recursive: true });
+  writeFileSync(
+    join(tmpWorkspace, "memory", "edges.json"),
+    JSON.stringify({ version: 1, edges: [] }),
+  );
+  writeFileSync(
+    join(tmpWorkspace, "memory", "concepts", "alice-vscode.md"),
+    `---\nedges: []\nref_files: []\n---\nAlice prefers VS Code as her editor.`,
+  );
+});
+
+afterAll(() => {
+  if (previousWorkspaceEnv === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceEnv;
+  }
+  rmSync(tmpWorkspace, { recursive: true, force: true });
+  // Restore mocks so a sibling test loaded in the same `bun test` run sees
+  // unmocked module bindings.
+  mock.restore();
+});
+
+// ---------------------------------------------------------------------------
+// Dynamic imports — must come AFTER the mock.module() calls above so the
+// bindings resolve through the stubs.
+// ---------------------------------------------------------------------------
+
+import type { DrizzleDb } from "../../db-connection.js";
+
+const { ConversationGraphMemory } =
+  await import("../conversation-graph-memory.js");
+const { _setOverridesForTesting } =
+  await import("../../../config/assistant-feature-flags.js");
+const { applyNestedDefaults } = await import("../../../config/loader.js");
+const { getSqliteFrom } = await import("../../db-connection.js");
+const { migrateActivationState } =
+  await import("../../migrations/232-activation-state.js");
+const schema = await import("../../schema.js");
+const { _resetMemoryV2QdrantForTests } = await import("../../v2/qdrant.js");
+
+// The wiring layer calls `getDb()` to fetch the SQLite handle. We mock
+// only that one export and spread the real module so unrelated callers
+// (`raw*` helpers, etc.) keep working when this test runs alongside
+// others. A live mutable holder lets each `beforeEach` swap the handle
+// without re-registering the mock.
+let testDbHandle: DrizzleDb | null = null;
+const realDbModule = await import("../../db-connection.js");
+mock.module("../../db-connection.js", () => ({
+  ...realDbModule,
+  getDb: () => {
+    if (!testDbHandle) throw new Error("test db not initialized");
+    return testDbHandle;
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createTestDb(): DrizzleDb {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  const db = drizzle(sqlite, { schema });
+  getSqliteFrom(db).exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  migrateActivationState(db);
+  return db;
+}
+
+function makeConfig(v2Enabled: boolean): AssistantConfig {
+  return applyNestedDefaults({
+    memory: { v2: { enabled: v2Enabled } },
+  }) as AssistantConfig;
+}
+
+function makeMessages(
+  text = "hello there, this is a long enough question",
+): Message[] {
+  return [
+    {
+      role: "user",
+      content: [{ type: "text" as const, text }],
+    },
+  ];
+}
+
+function makeMemory(): InstanceType<typeof ConversationGraphMemory> {
+  // `initialized = true` skips the context-load branch and the
+  // `fetchRecentSummaries` DB read it depends on, isolating the per-turn path
+  // for these unit tests. Context-load is covered by its own block below.
+  const m = new ConversationGraphMemory("scope-1", "conv-test-1");
+  (m as unknown as { initialized: boolean }).initialized = true;
+  return m;
+}
+
+/** Stage one set of dense/sparse hits for each channel of the activation
+ *  pipeline (1 candidate query + 3 simBatch channels). */
+function stageTurn(
+  hits: Array<{ slug: string; denseScore?: number; sparseScore?: number }>,
+): void {
+  for (let i = 0; i < 4; i++) {
+    qdrantState.queryResponses.dense.push({
+      points: hits
+        .filter((h) => h.denseScore !== undefined)
+        .map((h) => ({ score: h.denseScore, payload: { slug: h.slug } })),
+    });
+    qdrantState.queryResponses.sparse.push({
+      points: hits
+        .filter((h) => h.sparseScore !== undefined)
+        .map((h) => ({ score: h.sparseScore, payload: { slug: h.slug } })),
+    });
+  }
+}
+
+const noopEvent = () => {};
+
+beforeEach(() => {
+  testDbHandle = createTestDb();
+  qdrantState.queryResponses.dense.length = 0;
+  qdrantState.queryResponses.sparse.length = 0;
+  _resetMemoryV2QdrantForTests();
+});
+
+afterEach(() => {
+  _setOverridesForTesting({});
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)", () => {
+  test("flag off → v2 not run, messages unchanged", async () => {
+    _setOverridesForTesting({ "memory-v2-enabled": false });
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true);
+    const messages = makeMessages();
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("per-turn");
+    expect(result.injectedBlockText).toBeNull();
+    // No v2 block prepended — the v1 retriever returned zero nodes so the
+    // user message is exactly the input.
+    expect(result.runMessages).toEqual(messages);
+  });
+
+  test("flag on + config off → v2 not run, messages unchanged", async () => {
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(false);
+    const messages = makeMessages();
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("per-turn");
+    expect(result.injectedBlockText).toBeNull();
+    expect(result.runMessages).toEqual(messages);
+  });
+
+  test("flag on + config on → v2 block prepended, mode is per-turn", async () => {
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true);
+    const messages = makeMessages("Tell me about Alice's editor preferences");
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("per-turn");
+    expect(result.injectedBlockText).not.toBeNull();
+    expect(result.injectedBlockText).toContain("<memory __injected>");
+    expect(result.injectedBlockText).toContain("### alice-vscode");
+
+    // The leading content block on the user message is the v2 block.
+    const lastMsg = result.runMessages[result.runMessages.length - 1];
+    expect(lastMsg?.role).toBe("user");
+    const firstBlock = lastMsg?.content[0];
+    expect(firstBlock?.type).toBe("text");
+    if (firstBlock?.type !== "text") throw new Error("unexpected block type");
+    expect(firstBlock.text).toContain("<memory __injected>");
+  });
+
+  test("flag on + config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    // No `stageTurn` call — every channel returns `{ points: [] }` so the
+    // candidate set is empty and `injectMemoryV2Block` returns block=null.
+    const memory = makeMemory();
+    const config = makeConfig(true);
+    const messages = makeMessages();
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.injectedBlockText).toBeNull();
+    expect(result.runMessages).toEqual(messages);
+  });
+});
+
+describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load path)", () => {
+  test("flag on + config on → v2 fires with mode=context-load", async () => {
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    // Fresh memory → initialized=false → runContextLoad branch.
+    const memory = new ConversationGraphMemory("scope-1", "conv-test-cl");
+    const config = makeConfig(true);
+    const messages = makeMessages("first message of the conversation here");
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("context-load");
+    expect(result.injectedBlockText).not.toBeNull();
+    expect(result.injectedBlockText).toContain("<memory __injected>");
+  });
+
+  test("flag off → v2 not run on first turn either", async () => {
+    _setOverridesForTesting({ "memory-v2-enabled": false });
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = new ConversationGraphMemory("scope-1", "conv-test-cl-off");
+    const config = makeConfig(true);
+    const messages = makeMessages("first message of the conversation here");
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("context-load");
+    expect(result.injectedBlockText).toBeNull();
+  });
+});

package/src/memory/graph/__tests__/handle-remember-v2.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Tests for `handleRemember` flag-routing between v1 (PKB) and v2 (memory/).
+ *
+ * Verifies:
+ *   - Flag on  → writes go to `memory/buffer.md` + `memory/archive/<today>.md`
+ *                and NO PKB re-index job is enqueued.
+ *   - Flag off → existing PKB path is unchanged (writes to `pkb/buffer.md`
+ *                + `pkb/archive/<today>.md`, both files are re-indexed).
+ *   - Archive filename uses today's local date.
+ */
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+let tmpWorkspace: string;
+let previousWorkspaceEnv: string | undefined;
+
+// Shared mock state for the PKB enqueue helper. Module-scoped so the
+// hoisted mock.module factory can close over it.
+const enqueueCalls: Array<{
+  pkbRoot: string;
+  absPath: string;
+  memoryScopeId: string;
+}> = [];
+
+mock.module("../../jobs/embed-pkb-file.js", () => ({
+  enqueuePkbIndexJob: (input: {
+    pkbRoot: string;
+    absPath: string;
+    memoryScopeId: string;
+  }) => {
+    enqueueCalls.push(input);
+    return "job-mock-id";
+  },
+}));
+
+beforeAll(() => {
+  tmpWorkspace = mkdtempSync(join(tmpdir(), "handle-remember-v2-test-"));
+  previousWorkspaceEnv = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = tmpWorkspace;
+});
+
+afterAll(() => {
+  if (previousWorkspaceEnv === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceEnv;
+  }
+  rmSync(tmpWorkspace, { recursive: true, force: true });
+});
+
+// Imports are deferred to after the env var is set so any internal use of
+// `getWorkspaceDir()` resolves to the tmpdir.
+const { handleRemember } = await import("../tool-handlers.js");
+const { _setOverridesForTesting } =
+  await import("../../../config/assistant-feature-flags.js");
+const { applyNestedDefaults } = await import("../../../config/loader.js");
+
+const CONFIG = applyNestedDefaults({});
+
+beforeEach(() => {
+  enqueueCalls.length = 0;
+  // Reset to a clean workspace for each test so file existence assertions
+  // don't depend on prior-test side effects.
+  rmSync(join(tmpWorkspace, "pkb"), { recursive: true, force: true });
+  rmSync(join(tmpWorkspace, "memory"), { recursive: true, force: true });
+});
+
+afterEach(() => {
+  _setOverridesForTesting({});
+});
+
+function todaysArchiveBasename(now: Date = new Date()): string {
+  const yyyy = now.getFullYear();
+  const mm = String(now.getMonth() + 1).padStart(2, "0");
+  const dd = String(now.getDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}.md`;
+}
+
+describe("handleRemember — memory-v2 flag on", () => {
+  beforeEach(() => {
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+  });
+
+  test("writes to memory/buffer.md and memory/archive/<today>.md", () => {
+    const result = handleRemember(
+      { content: "Alice prefers VS Code over Vim" },
+      "conv-test-1",
+      "default",
+      CONFIG,
+    );
+
+    expect(result.success).toBe(true);
+
+    const memoryDir = join(tmpWorkspace, "memory");
+    const bufferPath = join(memoryDir, "buffer.md");
+    const archivePath = join(memoryDir, "archive", todaysArchiveBasename());
+
+    const buffer = readFileSync(bufferPath, "utf-8");
+    expect(buffer).toContain("Alice prefers VS Code over Vim");
+
+    const archive = readFileSync(archivePath, "utf-8");
+    expect(archive).toContain("Alice prefers VS Code over Vim");
+
+    // v2 must NOT touch the PKB tree.
+    expect(existsSync(join(tmpWorkspace, "pkb"))).toBe(false);
+  });
+
+  test("does not enqueue any PKB re-index jobs", () => {
+    const result = handleRemember(
+      { content: "Bob lives in Austin" },
+      "conv-test-2",
+      "default",
+      CONFIG,
+    );
+
+    expect(result.success).toBe(true);
+    expect(enqueueCalls).toEqual([]);
+  });
+
+  test("seeds the daily archive header on first write", () => {
+    handleRemember(
+      { content: "First entry of the day" },
+      "conv-test-3",
+      "default",
+      CONFIG,
+    );
+
+    const archivePath = join(
+      tmpWorkspace,
+      "memory",
+      "archive",
+      todaysArchiveBasename(),
+    );
+    const archive = readFileSync(archivePath, "utf-8");
+    // Header is "# <Mon> <D>, <YYYY>" — assert just the prefix to avoid
+    // hard-coding the locale-formatted month name in the test.
+    expect(archive.startsWith("# ")).toBe(true);
+    expect(archive).toContain("First entry of the day");
+  });
+
+  test("appends multiple entries to the same buffer", () => {
+    handleRemember({ content: "first" }, "c", "default", CONFIG);
+    handleRemember({ content: "second" }, "c", "default", CONFIG);
+
+    const buffer = readFileSync(
+      join(tmpWorkspace, "memory", "buffer.md"),
+      "utf-8",
+    );
+    expect(buffer).toContain("first");
+    expect(buffer).toContain("second");
+  });
+
+  test("rejects empty content without writing", () => {
+    const result = handleRemember(
+      { content: "   " },
+      "conv-test-4",
+      "default",
+      CONFIG,
+    );
+
+    expect(result.success).toBe(false);
+    expect(existsSync(join(tmpWorkspace, "memory", "buffer.md"))).toBe(false);
+    expect(enqueueCalls).toEqual([]);
+  });
+});
+
+describe("handleRemember — memory-v2 flag off (v1 PKB path)", () => {
+  beforeEach(() => {
+    _setOverridesForTesting({ "memory-v2-enabled": false });
+  });
+
+  test("writes to pkb/buffer.md and pkb/archive/<today>.md", () => {
+    const result = handleRemember(
+      { content: "v1 path still works" },
+      "conv-v1-1",
+      "default",
+      CONFIG,
+    );
+
+    expect(result.success).toBe(true);
+
+    const pkbDir = join(tmpWorkspace, "pkb");
+    const bufferPath = join(pkbDir, "buffer.md");
+    const archivePath = join(pkbDir, "archive", todaysArchiveBasename());
+
+    expect(readFileSync(bufferPath, "utf-8")).toContain("v1 path still works");
+    expect(readFileSync(archivePath, "utf-8")).toContain("v1 path still works");
+
+    // v1 must NOT touch the v2 memory/ tree.
+    expect(existsSync(join(tmpWorkspace, "memory"))).toBe(false);
+  });
+
+  test("enqueues PKB re-index jobs for both buffer and archive", () => {
+    const result = handleRemember(
+      { content: "index me" },
+      "conv-v1-2",
+      "default",
+      CONFIG,
+    );
+
+    expect(result.success).toBe(true);
+
+    const pkbDir = join(tmpWorkspace, "pkb");
+    const bufferPath = join(pkbDir, "buffer.md");
+    const archivePath = join(pkbDir, "archive", todaysArchiveBasename());
+
+    expect(enqueueCalls).toHaveLength(2);
+    expect(enqueueCalls[0]?.absPath).toBe(bufferPath);
+    expect(enqueueCalls[1]?.absPath).toBe(archivePath);
+    for (const call of enqueueCalls) {
+      expect(call.pkbRoot).toBe(pkbDir);
+    }
+  });
+});

package/src/memory/graph/bootstrap.test.ts

@@ -1,13 +1,8 @@
 import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
 
 import { setMemoryCheckpoint } from "../checkpoints.js";
-import {
-  initializeDb,
-  rawAll,
-  rawGet,
-  rawRun,
-  resetTestTables,
-} from "../db.js";
+import { initializeDb } from "../db-init.js";
+import { rawAll, rawGet, rawRun, resetTestTables } from "../raw-query.js";
 import { migrateToolCreatedItems } from "./bootstrap.js";
 
 // ---------------------------------------------------------------------------

package/src/memory/graph/bootstrap.ts

@@ -19,9 +19,10 @@ import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "../checkpoints.js";
-import { getDb, rawAll, rawGet, rawRun } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { enqueueMemoryJob, hasActiveJobOfType } from "../jobs-store.js";
 import { initQdrantClient, resolveQdrantUrl } from "../qdrant-client.js";
+import { rawAll, rawGet, rawRun } from "../raw-query.js";
 import { conversations, memoryGraphNodes, memorySegments } from "../schema.js";
 import { runGraphExtraction } from "./extraction.js";
 import { countNodes } from "./store.js";

package/src/memory/graph/capability-seed.ts

@@ -22,7 +22,7 @@ import {
   type SkillCapabilityInput,
 } from "../../skills/skill-memory.js";
 import { getLogger } from "../../util/logger.js";
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { enqueueMemoryJob } from "../jobs-store.js";
 import { memoryGraphNodes } from "../schema.js";
 import { createNode } from "./store.js";
@@ -40,7 +40,7 @@ const CLI_SOURCE_PREFIX = "capability:cli:";
  * Upsert a graph node for a skill capability.
  * Uses sourceConversations[0] as a stable key for deduplication.
  */
-export function upsertSkillCapabilityNode(
+function upsertSkillCapabilityNode(
   skillId: string,
   input: SkillCapabilityInput,
 ): void {
@@ -56,7 +56,7 @@ export function upsertSkillCapabilityNode(
 /**
  * Upsert a graph node for a CLI command capability.
  */
-export function upsertCliCapabilityNode(
+function upsertCliCapabilityNode(
   commandName: string,
   description: string,
 ): void {