@vellumai/assistant 0.7.2 → 0.8.0

package/src/memory/__tests__/jobs-worker-v2-schedule.test.ts

@@ -1,23 +1,20 @@
 /**
- * Tests for the v2 consolidation entry in `maybeEnqueueGraphMaintenanceJobs`.
+ * Tests for v1/v2 mutual exclusion in `maybeEnqueueGraphMaintenanceJobs`.
  *
- * Coverage matrix (from PR 24 acceptance criteria):
- *   - Flag off → no `memory_v2_consolidate` row enqueued, even after the
- *     interval has elapsed.
- *   - Flag on + config off → still no row enqueued (both gates required).
- *   - Flag on + config on, no prior checkpoint → row enqueued, checkpoint
- *     stamped to `nowMs`.
- *   - Flag on + config on, recent checkpoint → no row enqueued (interval
- *     not yet elapsed).
- *   - Flag on + config on, stale checkpoint → row enqueued, checkpoint
- *     refreshed.
- *   - The v1 maintenance entries (decay, consolidate, pattern_scan,
- *     narrative) still fire under the v2 path — adding the v2 entry must
- *     not regress v1 scheduling.
+ * The schedule is mutually exclusive: when `memory.v2.enabled` is true,
+ * only `memory_v2_consolidate` is scheduled; otherwise the four v1
+ * entries (decay, consolidate, pattern_scan, narrative) fire and the v2
+ * entry does not.
  *
- * The sweep job is intentionally NOT scheduled here: PR 24 wires it into
- * the `graph_extract` debounce in `indexer.ts`. Those triggers are covered
- * by the separate trigger-path tests; this file owns only the cron entries.
+ * Coverage:
+ *   - Config off → only v1 entries fire (no `memory_v2_consolidate`).
+ *   - Config on, no prior checkpoint → only the v2 entry fires.
+ *   - Config on, recent checkpoint → no v2 row (interval not yet elapsed).
+ *   - Config on, stale checkpoint → v2 row enqueued, checkpoint refreshed.
+ *
+ * The sweep job is intentionally NOT scheduled here: it is wired into the
+ * `graph_extract` debounce in `indexer.ts`. Those triggers are covered by
+ * the separate trigger-path tests; this file owns only the cron entries.
  *
  * Tests use a temp workspace pinned via `VELLUM_WORKSPACE_DIR` so the DB
  * lives under `tmpdir()` and `~/.vellum/` is never touched.
@@ -27,7 +24,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -69,8 +65,6 @@ const { getDb } = await import("../db-connection.js");
 const { initializeDb } = await import("../db-init.js");
 const { resetTestTables } = await import("../raw-query.js");
 const { memoryJobs } = await import("../schema.js");
-const { _setOverridesForTesting } =
-  await import("../../config/assistant-feature-flags.js");
 const { applyNestedDefaults } = await import("../../config/loader.js");
 const { setMemoryCheckpoint, deleteMemoryCheckpoint } =
   await import("../checkpoints.js");
@@ -111,26 +105,10 @@ beforeEach(() => {
   resetTestTables("memory_jobs", "memory_checkpoints");
 });
 
-afterEach(() => {
-  _setOverridesForTesting({});
-});
-
 // ---------------------------------------------------------------------------
 
 describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
-  test("does not enqueue consolidate when memory-v2-enabled flag is off", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
-
-    // Force the interval to look elapsed. If the gate failed open, this
-    // would be enough to enqueue a job.
-    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
-
-    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
-  });
-
   test("does not enqueue consolidate when config.memory.v2.enabled is off", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: false, intervalHours: 1 });
 
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
@@ -138,17 +116,20 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
 
-  test("enqueues consolidate when both gates are on and no checkpoint exists", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("enqueues consolidate when v2 is on and no checkpoint exists", () => {
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+    // v1 entries are suppressed when v2 is active.
+    expect(countPendingJobs("graph_decay")).toBe(0);
+    expect(countPendingJobs("graph_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(0);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(0);
   });
 
   test("does not enqueue consolidate before the interval has elapsed", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     const now = Date.now();
@@ -161,7 +142,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("enqueues consolidate again once the interval elapses", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     const now = Date.now();
@@ -177,7 +157,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("respects a custom consolidation_interval_hours value", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 6 });
 
     const now = Date.now();
@@ -200,11 +179,10 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
   });
 
-  test("v1 graph maintenance entries still fire alongside the v2 entry", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("v1 maintenance entries are suppressed when v2 is active", () => {
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
-    // No checkpoints set — every entry should be due.
+    // No checkpoints set — every entry would be due if it were scheduled.
     deleteMemoryCheckpoint("graph_maintenance:decay:last_run");
     deleteMemoryCheckpoint("graph_maintenance:consolidate:last_run");
     deleteMemoryCheckpoint("graph_maintenance:pattern_scan:last_run");
@@ -213,23 +191,28 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
 
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
 
-    expect(countPendingJobs("graph_decay")).toBe(1);
-    expect(countPendingJobs("graph_consolidate")).toBe(1);
-    expect(countPendingJobs("graph_pattern_scan")).toBe(1);
-    expect(countPendingJobs("graph_narrative_refine")).toBe(1);
+    expect(countPendingJobs("graph_decay")).toBe(0);
+    expect(countPendingJobs("graph_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(0);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(0);
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
   });
 
-  test("flag-off path does not enqueue v2 but still fires the v1 entries", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
+  test("v2-off path fires v1 entries and does not enqueue v2", () => {
+    const config = buildConfig({ v2Enabled: false, intervalHours: 1 });
 
     deleteMemoryCheckpoint("graph_maintenance:decay:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:consolidate:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:pattern_scan:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:narrative:last_run");
     deleteMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY);
 
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
 
     expect(countPendingJobs("graph_decay")).toBe(1);
+    expect(countPendingJobs("graph_consolidate")).toBe(1);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(1);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(1);
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
 });

package/src/memory/__tests__/memory-v2-activation-log-store.test.ts

@@ -29,7 +29,6 @@ import { memoryV2ActivationLogs } from "../schema.js";
 import {
   sampleConcepts,
   sampleConfig,
-  sampleSkills,
 } from "./fixtures/memory-v2-activation-fixtures.js";
 
 initializeDb();
@@ -53,7 +52,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 3,
       mode: "per-turn",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
 
@@ -65,7 +63,6 @@ describe("memory-v2-activation-log-store", () => {
     expect(result!.turn).toBe(3);
     expect(result!.mode).toBe("per-turn");
     expect(result!.concepts).toEqual(sampleConcepts);
-    expect(result!.skills).toEqual(sampleSkills);
     expect(result!.config).toEqual(sampleConfig);
   });
 
@@ -82,7 +79,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 1,
       mode: "context-load",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
     recordMemoryV2ActivationLog({
@@ -90,7 +86,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 2,
       mode: "per-turn",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
 
@@ -110,7 +105,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 3,
       mode: "per-turn",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
 

package/src/memory/__tests__/memory-v2-concept-frequency.test.ts

@@ -0,0 +1,272 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+let listPagesImpl: (workspaceDir: string) => Promise<string[]> = async () => [];
+
+mock.module("../v2/page-store.js", () => ({
+  listPages: (workspaceDir: string) => listPagesImpl(workspaceDir),
+}));
+
+import { getDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import {
+  type MemoryV2ConceptRowRecord,
+  recordMemoryV2ActivationLog,
+} from "../memory-v2-activation-log-store.js";
+import { getConceptFrequencySummary } from "../memory-v2-concept-frequency.js";
+import { memoryV2ActivationLogs } from "../schema.js";
+import { sampleConfig } from "./fixtures/memory-v2-activation-fixtures.js";
+
+initializeDb();
+
+const WORKSPACE = "/tmp/memory-v2-concept-frequency-test";
+
+function makeConcept(
+  slug: string,
+  status: MemoryV2ConceptRowRecord["status"],
+): MemoryV2ConceptRowRecord {
+  return {
+    slug,
+    finalActivation: 0.5,
+    ownActivation: 0.4,
+    priorActivation: 0.1,
+    simUser: 0.3,
+    simAssistant: 0.2,
+    simNow: 0.1,
+    simUserRerankBoost: 0,
+    simAssistantRerankBoost: 0,
+    inRerankPool: false,
+    spreadContribution: 0.1,
+    source: "ann_top50",
+    status,
+  };
+}
+
+function resetTables(): void {
+  getDb().delete(memoryV2ActivationLogs).run();
+}
+
+describe("memory-v2-concept-frequency", () => {
+  beforeEach(() => {
+    resetTables();
+    listPagesImpl = async () => [];
+  });
+
+  test("aggregates per-status counts across multiple turns", async () => {
+    const conv = "conv-1";
+    recordMemoryV2ActivationLog({
+      conversationId: conv,
+      turn: 1,
+      mode: "context-load",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("bob", "not_injected"),
+      ],
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId: conv,
+      turn: 2,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "in_context"),
+        makeConcept("bob", "injected"),
+      ],
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId: conv,
+      turn: 3,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("charlie", "page_missing"),
+      ],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice", "bob", "delta"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+
+    expect(result.totals.logCount).toBe(3);
+    expect(result.totals.conceptOccurrences).toBe(6);
+    expect(result.filters).toEqual({ conversationId: null, sinceMs: null });
+
+    const bySlug = new Map(result.concepts.map((c) => [c.slug, c]));
+
+    expect(bySlug.get("alice")!.counts).toEqual({
+      injected: 2,
+      in_context: 1,
+      not_injected: 0,
+      page_missing: 0,
+    });
+    expect(bySlug.get("alice")!.totalEvaluations).toBe(3);
+    expect(bySlug.get("alice")!.onDisk).toBe(true);
+    expect(bySlug.get("alice")!.lastInjectedAt).not.toBeNull();
+
+    expect(bySlug.get("bob")!.counts).toEqual({
+      injected: 1,
+      in_context: 0,
+      not_injected: 1,
+      page_missing: 0,
+    });
+    expect(bySlug.get("bob")!.totalEvaluations).toBe(2);
+    expect(bySlug.get("bob")!.onDisk).toBe(true);
+
+    expect(bySlug.get("charlie")!.counts).toEqual({
+      injected: 0,
+      in_context: 0,
+      not_injected: 0,
+      page_missing: 1,
+    });
+    expect(bySlug.get("charlie")!.onDisk).toBe(false);
+    expect(bySlug.get("charlie")!.lastInjectedAt).toBeNull();
+
+    // Sorted by totalEvaluations desc — alice (3) before bob (2) before charlie (1).
+    expect(result.concepts.map((c) => c.slug)).toEqual([
+      "alice",
+      "bob",
+      "charlie",
+    ]);
+
+    // delta is on disk but never appeared in any log row.
+    expect(result.neverEvaluatedSlugs).toEqual(["delta"]);
+  });
+
+  test("conversationId filter narrows aggregation", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-a",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [makeConcept("alice", "injected")],
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-b",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("alice", "injected"),
+      ],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice"];
+
+    const all = await getConceptFrequencySummary(WORKSPACE, {});
+    expect(all.totals.logCount).toBe(2);
+    expect(all.concepts[0]!.counts.injected).toBe(3);
+    expect(all.filters.conversationId).toBeNull();
+
+    const onlyA = await getConceptFrequencySummary(WORKSPACE, {
+      conversationId: "conv-a",
+    });
+    expect(onlyA.totals.logCount).toBe(1);
+    expect(onlyA.concepts[0]!.counts.injected).toBe(1);
+    expect(onlyA.filters.conversationId).toBe("conv-a");
+
+    const onlyB = await getConceptFrequencySummary(WORKSPACE, {
+      conversationId: "conv-b",
+    });
+    expect(onlyB.totals.logCount).toBe(1);
+    expect(onlyB.concepts[0]!.counts.injected).toBe(2);
+  });
+
+  test("sinceMs filter excludes older log rows", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [makeConcept("alice", "injected")],
+      config: sampleConfig,
+    });
+    // Backdate the just-written row — recordMemoryV2ActivationLog uses Date.now().
+    getDb().update(memoryV2ActivationLogs).set({ createdAt: 1_000 }).run();
+
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 2,
+      mode: "per-turn",
+      concepts: [makeConcept("alice", "injected")],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice"];
+
+    const all = await getConceptFrequencySummary(WORKSPACE, {});
+    expect(all.totals.logCount).toBe(2);
+    expect(all.concepts[0]!.counts.injected).toBe(2);
+
+    const recent = await getConceptFrequencySummary(WORKSPACE, {
+      sinceMs: 10_000,
+    });
+    expect(recent.totals.logCount).toBe(1);
+    expect(recent.concepts[0]!.counts.injected).toBe(1);
+    expect(recent.filters.sinceMs).toBe(10_000);
+  });
+
+  test("never-evaluated list excludes slugs that appeared in any status", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("bob", "not_injected"),
+        makeConcept("charlie", "page_missing"),
+      ],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice", "bob", "delta", "echo"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+    // bob was scored but rejected — still excluded from neverEvaluated.
+    expect(result.neverEvaluatedSlugs).toEqual(["delta", "echo"]);
+  });
+
+  test("returns empty result when no logs exist", async () => {
+    listPagesImpl = async () => ["alice", "bob"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+    expect(result.totals).toEqual({ logCount: 0, conceptOccurrences: 0 });
+    expect(result.concepts).toEqual([]);
+    expect(result.neverEvaluatedSlugs).toEqual(["alice", "bob"]);
+  });
+
+  test("flags slugs that appear in logs but no longer have a page on disk", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [makeConcept("ghost", "injected")],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+    const ghost = result.concepts.find((c) => c.slug === "ghost")!;
+    expect(ghost.onDisk).toBe(false);
+    expect(ghost.counts.injected).toBe(1);
+  });
+});

package/src/memory/admin.ts

@@ -6,7 +6,6 @@ import { getWorkspaceDir } from "../util/platform.js";
 import { deleteMemoryCheckpoint } from "./checkpoints.js";
 import { runDeterministicRecallSearch } from "./context-search/search.js";
 import type { RecallEvidence } from "./context-search/types.js";
-import { getConversationMemoryScopeId } from "./conversation-crud.js";
 import { getDb } from "./db-connection.js";
 import { getMemoryBackendStatus } from "./embedding-backend.js";
 import {
@@ -32,7 +31,7 @@ import {
 
 const log = getLogger("memory-admin");
 
-export interface MemorySystemStatus {
+interface MemorySystemStatus {
   enabled: boolean;
   degraded: boolean;
   reason: string | null;
@@ -47,7 +46,7 @@ export interface MemorySystemStatus {
   jobs: Record<string, number>;
 }
 
-export interface AdminMemoryQueryResult {
+interface AdminMemoryQueryResult {
   results: Array<{
     id: string;
     content: string;
@@ -106,7 +105,6 @@ export async function queryMemory(
     { query, sources: ["memory", "conversations", "pkb"] },
     {
       workingDir: getWorkspaceDir(),
-      memoryScopeId: getConversationMemoryScopeId(conversationId) ?? "default",
       conversationId,
       config,
     },
@@ -148,7 +146,7 @@ function readNumericMetadata(
 
 // ── Short segment cleanup ─────────────────────────────────────────────
 
-export interface CleanupShortSegmentsResult {
+interface CleanupShortSegmentsResult {
   removed: number;
   failed: number;
   dryRunCount?: number;
@@ -216,7 +214,7 @@ export async function compactLongMemoryNodes(
 
 // ── Re-extraction ──────────────────────────────────────────────────────
 
-export interface ReextractTarget {
+interface ReextractTarget {
   conversationId: string;
   title: string | null;
   messageCount: number;
@@ -312,11 +310,9 @@ export function requestReextract(targets: ReextractTarget[]): {
       )
       .run();
 
-    // Resolve scope and enqueue re-extraction
-    const scopeId = getConversationMemoryScopeId(conversationId);
     const jobId = enqueueMemoryJob("graph_extract", {
       conversationId,
-      scopeId,
+      scopeId: "default",
     });
     jobIds.push(jobId);
 

package/src/memory/context-search/agent-runner.ts

@@ -306,7 +306,17 @@ export async function runAgenticRecall(
         [...RECALL_AGENT_TOOL_DEFINITIONS],
         undefined,
         {
-          config: { callSite: "recall", temperature: 0 },
+          // `thinking: disabled` is required because we set `temperature: 0`
+          // explicitly. Anthropic 400s on `temperature` ≠ 1 whenever thinking
+          // is enabled or in adaptive mode; without this, profiles that
+          // resolve thinking-enabled (Opus 4.x at `effort: high|xhigh`, etc.)
+          // would fail. Recall is tool-call-heavy reasoning where determinism
+          // matters more than extended chain-of-thought.
+          config: {
+            callSite: "recall",
+            temperature: 0,
+            thinking: { type: "disabled" },
+          },
           signal: context.signal,
         },
       );
@@ -597,7 +607,14 @@ async function tryFinalFinishRecall(options: {
       [FINISH_RECALL_TOOL_DEFINITION],
       undefined,
       {
-        config: { callSite: "recall", temperature: 0 },
+        // `thinking: disabled` required for the same reason as the agent
+        // round above — Anthropic 400s on `temperature` ≠ 1 whenever
+        // thinking is enabled or in adaptive mode.
+        config: {
+          callSite: "recall",
+          temperature: 0,
+          thinking: { type: "disabled" },
+        },
         signal: options.context.signal,
       },
     );

package/src/memory/context-search/sources/conversations.ts

@@ -88,10 +88,7 @@ export async function searchConversationSource(
 
   for (const ftsMatch of ftsMatches) {
     try {
-      rows = mergeConversationRows(
-        rows,
-        searchWithFts(ftsMatch, context.memoryScopeId, queryLimit),
-      );
+      rows = mergeConversationRows(rows, searchWithFts(ftsMatch, queryLimit));
     } catch {
       // Try the next, broader query shape.
     }
@@ -100,7 +97,7 @@ export async function searchConversationSource(
   }
 
   if (rows.length === 0) {
-    rows = searchWithLike(trimmedQuery, context.memoryScopeId, queryLimit);
+    rows = searchWithLike(trimmedQuery, queryLimit);
   }
 
   const sortedRows = rows
@@ -130,7 +127,6 @@ export async function searchConversationSource(
 
 function searchWithFts(
   ftsMatch: string,
-  memoryScopeId: string,
   limit: number,
 ): ConversationEvidenceRow[] {
   return rawAll<ConversationEvidenceRow>(
@@ -146,14 +142,12 @@ function searchWithFts(
     JOIN messages m ON m.id = messages_fts.message_id
     JOIN conversations c ON c.id = m.conversation_id
     WHERE messages_fts MATCH ?
-      AND c.memory_scope_id = ?
       AND (c.conversation_type IS NULL OR c.conversation_type != 'private')
       AND (c.source IS NULL OR c.source NOT IN (?, ?))
     ORDER BY bm25(messages_fts), m.created_at DESC
     LIMIT ?
     `,
     ftsMatch,
-    memoryScopeId,
     SUBAGENT_SOURCE,
     AUTO_ANALYSIS_SOURCE,
     limit,
@@ -162,7 +156,6 @@ function searchWithFts(
 
 function searchWithLike(
   query: string,
-  memoryScopeId: string,
   limit: number,
 ): ConversationEvidenceRow[] {
   return rawAll<ConversationEvidenceRow>(
@@ -177,14 +170,12 @@ function searchWithLike(
     FROM messages m
     JOIN conversations c ON c.id = m.conversation_id
     WHERE m.content LIKE ? ESCAPE '\\'
-      AND c.memory_scope_id = ?
       AND (c.conversation_type IS NULL OR c.conversation_type != 'private')
       AND (c.source IS NULL OR c.source NOT IN (?, ?))
     ORDER BY m.created_at DESC
     LIMIT ?
     `,
     buildLikePattern(query),
-    memoryScopeId,
     SUBAGENT_SOURCE,
     AUTO_ANALYSIS_SOURCE,
     limit,

package/src/memory/context-search/sources/memory-v2.ts

@@ -2,7 +2,7 @@
 // Memory v2 — `recall` adapter for the `memory` source
 // ---------------------------------------------------------------------------
 //
-// When the v2 flag is on, the `memory` recall source reads from the v2
+// When v2 is enabled, the `memory` recall source reads from the v2
 // concept-page subsystem (under `<workspace>/memory/concepts/`) instead of
 // the legacy graph. Two retrieval paths run in parallel and merge:
 //
@@ -26,8 +26,6 @@
 import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import { extname, isAbsolute, join, relative } from "node:path";
 
-import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../../../config/schema.js";
 import { getLogger } from "../../../util/logger.js";
 import { embedWithRetry } from "../../embed.js";
 import { generateSparseEmbedding } from "../../embedding-backend.js";
@@ -46,19 +44,6 @@ import type {
   RecallSearchResult,
 } from "../types.js";
 
-/**
- * True when both v2 gates are on. Single source of truth shared by the recall
- * `memory` source (which delegates to v2), the `pkb` source (which
- * short-circuits because v2 absorbs PKB as a read source), and the per-turn
- * PKB injectors (which go silent so v2 owns the read path end-to-end).
- */
-export function isMemoryV2ReadActive(config: AssistantConfig): boolean {
-  return (
-    isAssistantFeatureFlagEnabled("memory-v2-enabled", config) &&
-    config.memory.v2.enabled
-  );
-}
-
 const log = getLogger("context-search-memory-v2-source");
 
 /**