@vellumai/assistant 0.7.3 → 0.8.1

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

@@ -1,18 +1,16 @@
 /**
  * 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:
+ * The wiring layer at `conversation-graph-memory.ts` reads
+ * `config.memory.v2.enabled` 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.
+ * 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";
@@ -20,7 +18,6 @@ import { join } from "node:path";
 import { Database } from "bun:sqlite";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -98,9 +95,11 @@ class MockQdrantClient {
     _name: string,
     params: { using: string; limit: number; filter?: unknown },
   ) {
-    const queue =
-      qdrantState.queryResponses[params.using as "dense" | "sparse"];
-    return queue.shift() ?? { points: [] };
+    // The four-channel hybrid query fires body-dense, body-sparse,
+    // summary-dense, summary-sparse in order; both dense channels share
+    // the dense queue and both sparse channels share the sparse queue.
+    const channel = params.using.endsWith("sparse") ? "sparse" : "dense";
+    return qdrantState.queryResponses[channel].shift() ?? { points: [] };
   }
 }
 
@@ -170,14 +169,14 @@ 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");
+const { hydrate: hydrateActivationState } =
+  await import("../../v2/activation-store.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
@@ -240,10 +239,21 @@ function makeMemory(): InstanceType<typeof ConversationGraphMemory> {
   return m;
 }
 
-/** Stage one set of dense/sparse hits for each channel of the activation
- *  pipeline (1 candidate query + 3 simBatch channels). */
+/** Stage one set of body and summary dense/sparse hits for each channel of
+ *  the activation pipeline (1 candidate query + 3 simBatch channels). Each
+ *  `hybridQueryConceptPages` call now fires four sub-queries (body-dense,
+ *  body-sparse, summary-dense, summary-sparse) so we push four entries per
+ *  channel iteration. Hits without `summary*Score` set produce empty point
+ *  lists for the summary channels — fine for tests that only care about body
+ *  scoring. */
 function stageTurn(
-  hits: Array<{ slug: string; denseScore?: number; sparseScore?: number }>,
+  hits: Array<{
+    slug: string;
+    denseScore?: number;
+    sparseScore?: number;
+    summaryDenseScore?: number;
+    summarySparseScore?: number;
+  }>,
 ): void {
   for (let i = 0; i < 4; i++) {
     qdrantState.queryResponses.dense.push({
@@ -256,6 +266,22 @@ function stageTurn(
         .filter((h) => h.sparseScore !== undefined)
         .map((h) => ({ score: h.sparseScore, payload: { slug: h.slug } })),
     });
+    qdrantState.queryResponses.dense.push({
+      points: hits
+        .filter((h) => h.summaryDenseScore !== undefined)
+        .map((h) => ({
+          score: h.summaryDenseScore,
+          payload: { slug: h.slug },
+        })),
+    });
+    qdrantState.queryResponses.sparse.push({
+      points: hits
+        .filter((h) => h.summarySparseScore !== undefined)
+        .map((h) => ({
+          score: h.summarySparseScore,
+          payload: { slug: h.slug },
+        })),
+    });
   }
 }
 
@@ -270,39 +296,12 @@ beforeEach(() => {
   _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 });
+  test("config off → v2 not run, messages unchanged", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     const memory = makeMemory();
@@ -321,8 +320,7 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(result.runMessages).toEqual(messages);
   });
 
-  test("flag on + config on → v2 block prepended, mode is per-turn", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("config on → v2 block prepended, mode is per-turn", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     const memory = makeMemory();
@@ -339,7 +337,9 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(result.mode).toBe("per-turn");
     expect(result.injectedBlockText).not.toBeNull();
     expect(result.injectedBlockText).not.toContain("<memory>");
-    expect(result.injectedBlockText).toContain("### alice-vscode");
+    expect(result.injectedBlockText).toContain(
+      "# memory/concepts/alice-vscode.md",
+    );
 
     // The leading content block on the user message is the v2 block,
     // wrapped exactly once.
@@ -361,7 +361,6 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     // Regression for the double-wrap bug: v2 cached `lastInjectedBlock`
     // already wrapped, then `reinjectCachedMemory` re-wrapped via
     // `injectTextBlock`, producing `<memory>\n<memory>\n...\n</memory>\n</memory>`.
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     const memory = makeMemory();
@@ -388,11 +387,10 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(firstBlock.text.endsWith("\n</memory>")).toBe(true);
     expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
     expect(firstBlock.text.match(/<\/memory>/g)?.length).toBe(1);
-    expect(firstBlock.text).toContain("### alice-vscode");
+    expect(firstBlock.text).toContain("# memory/concepts/alice-vscode.md");
   });
 
-  test("flag on + config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
     // No `stageTurn` call — every channel returns `{ points: [] }` so the
     // candidate set is empty and `injectMemoryV2Block` returns block=null.
     const memory = makeMemory();
@@ -412,8 +410,7 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
 });
 
 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 });
+  test("config on → v2 fires with mode=context-load", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     // Fresh memory → initialized=false → runContextLoad branch.
@@ -430,7 +427,9 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
 
     expect(result.mode).toBe("context-load");
     expect(result.injectedBlockText).not.toBeNull();
-    expect(result.injectedBlockText).toContain("### alice-vscode");
+    expect(result.injectedBlockText).toContain(
+      "# memory/concepts/alice-vscode.md",
+    );
     // injectedBlockText is the unwrapped inner content; the wrapper is
     // applied at injection time on the run message.
     expect(result.injectedBlockText).not.toContain("<memory>");
@@ -443,12 +442,11 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
     expect(loadContextMemoryMock).not.toHaveBeenCalled();
   });
 
-  test("flag off → v2 not run on first turn either", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
+  test("config off → v2 not run on first turn either", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
     const memory = new ConversationGraphMemory("conv-test-cl-off");
-    const config = makeConfig(true);
+    const config = makeConfig(false);
     const messages = makeMessages("first message of the conversation here");
 
     const result = await memory.prepareMemory(
@@ -462,3 +460,48 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
     expect(result.injectedBlockText).toBeNull();
   });
 });
+
+describe("ConversationGraphMemory.onCompacted — v2 activation eviction", () => {
+  test("clears everInjected so a previously-injected slug can re-attach", async () => {
+    // Without this wiring, `selectInjections` keeps subtracting the slug from
+    // every per-turn delta even though compaction discarded the cached
+    // `<memory>` attachment that previously made it visible.
+    const conversationId = "conv-test-evict";
+    const memory = new ConversationGraphMemory(conversationId);
+    const config = makeConfig(true);
+
+    // Turn 1 — context-load fires (initialized=false), injecting alice-vscode.
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+    const initial = await memory.prepareMemory(
+      makeMessages("Tell me about Alice's editor preferences"),
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+    expect(initial.injectedBlockText).toContain(
+      "# memory/concepts/alice-vscode.md",
+    );
+
+    const before = await hydrateActivationState(testDbHandle!, conversationId);
+    expect(before?.everInjected.map((e) => e.slug)).toContain("alice-vscode");
+
+    await memory.onCompacted(1);
+
+    const after = await hydrateActivationState(testDbHandle!, conversationId);
+    expect(after?.everInjected).toEqual([]);
+
+    // Turn 2 — same Qdrant relevance. With everInjected cleared the slug
+    // should appear again in the injection block (re-attached on the new
+    // user message after compaction).
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+    const next = await memory.prepareMemory(
+      makeMessages("And what about Alice's editor again?"),
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+    expect(next.injectedBlockText).toContain(
+      "# memory/concepts/alice-vscode.md",
+    );
+  });
+});

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

@@ -1,19 +1,14 @@
 /**
- * Tests for `handleRemember` flag-routing between v1 (PKB) and v2 (memory/).
+ * Tests for `handleRemember` 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.
+ * Routing follows `config.memory.v2.enabled`: when true, writes go to
+ * memory/; otherwise they fall back to v1 PKB.
  */
 import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -62,11 +57,13 @@ afterAll(() => {
 // 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({});
+const CONFIG_V2_OFF = {
+  ...CONFIG,
+  memory: { ...CONFIG.memory, v2: { ...CONFIG.memory.v2, enabled: false } },
+};
 
 beforeEach(() => {
   enqueueCalls.length = 0;
@@ -76,10 +73,6 @@ beforeEach(() => {
   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");
@@ -87,11 +80,7 @@ function todaysArchiveBasename(now: Date = new Date()): string {
   return `${yyyy}-${mm}-${dd}.md`;
 }
 
-describe("handleRemember — memory-v2 flag on", () => {
-  beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-  });
-
+describe("handleRemember — memory.v2.enabled on", () => {
   test("writes to memory/buffer.md and memory/archive/<today>.md", () => {
     const result = handleRemember(
       { content: "Alice prefers VS Code over Vim" },
@@ -175,17 +164,13 @@ describe("handleRemember — memory-v2 flag on", () => {
   });
 });
 
-describe("handleRemember — memory-v2 flag off (v1 PKB path)", () => {
-  beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-  });
-
+describe("handleRemember — memory.v2.enabled off (v1 PKB path)", () => {
   test("writes to pkb/buffer.md and pkb/archive/<today>.md", () => {
     const result = handleRemember(
       { content: "v1 path still works" },
       "conv-v1-1",
       "default",
-      CONFIG,
+      CONFIG_V2_OFF,
     );
 
     expect(result.success).toBe(true);
@@ -206,7 +191,7 @@ describe("handleRemember — memory-v2 flag off (v1 PKB path)", () => {
       { content: "index me" },
       "conv-v1-2",
       "default",
-      CONFIG,
+      CONFIG_V2_OFF,
     );
 
     expect(result.success).toBe(true);

package/src/memory/graph/__tests__/remember-description.test.ts

@@ -0,0 +1,55 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let flagEnabled = false;
+
+mock.module("../../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (_key: string, _config: unknown) =>
+    flagEnabled,
+}));
+
+import { getRememberDescription } from "../tools.js";
+
+const stubConfig = {} as unknown as Parameters<
+  typeof getRememberDescription
+>[0];
+
+describe("getRememberDescription", () => {
+  beforeEach(() => {
+    flagEnabled = false;
+  });
+
+  test("flag off — returns the default high-pressure description", () => {
+    const desc = getRememberDescription(stubConfig);
+    expect(desc).toContain("**CRITICAL:**");
+    expect(desc).toContain("most frequently used tool");
+    expect(desc).toContain("almost every turn");
+  });
+
+  test("flag on — returns the relaxed judgment-framing description", () => {
+    flagEnabled = true;
+    const desc = getRememberDescription(stubConfig);
+    expect(desc).not.toContain("**CRITICAL:**");
+    expect(desc).not.toContain("almost every turn");
+    expect(desc).toContain("a retrospective pass");
+    expect(desc).toContain("Use judgment");
+  });
+
+  test("the two variants differ", () => {
+    flagEnabled = false;
+    const off = getRememberDescription(stubConfig);
+    flagEnabled = true;
+    const on = getRememberDescription(stubConfig);
+    expect(off).not.toBe(on);
+  });
+
+  test("corrections-are-priority language is preserved in BOTH variants", () => {
+    flagEnabled = false;
+    expect(getRememberDescription(stubConfig)).toMatch(
+      /Corrections are.*highest priority/i,
+    );
+    flagEnabled = true;
+    expect(getRememberDescription(stubConfig)).toMatch(
+      /Corrections are.*highest priority/i,
+    );
+  });
+});

package/src/memory/graph/conversation-graph-memory.ts

@@ -7,8 +7,8 @@
 // ---------------------------------------------------------------------------
 
 import { and, desc, eq, inArray, ne, notInArray } from "drizzle-orm";
+import { z } from "zod";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { estimateTextTokens } from "../../context/token-estimator.js";
 import type { ServerMessage } from "../../daemon/message-protocol.js";
@@ -20,9 +20,16 @@ import type {
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { getDb } from "../db-connection.js";
+import { embedWithRetry } from "../embed.js";
+import { generateSparseEmbedding } from "../embedding-backend.js";
 import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
+import {
+  evictCompactedTurns as evictCompactedTurnsV2,
+  hydrate as hydrateV2State,
+  save as saveV2State,
+} from "../v2/activation-store.js";
 import {
   injectMemoryV2Block,
   type InjectMemoryV2Mode,
@@ -206,11 +213,33 @@ export class ConversationGraphMemory {
    * Notify that context compaction just happened.
    * On the next turn, we'll re-run full context load.
    */
-  onCompacted(compactedMessageCount: number): void {
+  async onCompacted(compactedMessageCount: number): Promise<void> {
     // Evict everything — compaction summarized all prior turns.
     // The tracker can't know exactly which turns were compacted,
     // so we conservatively clear everything and reload.
-    this.tracker.evictCompactedTurns(this.tracker.getTurn());
+    const upToTurn = this.tracker.getTurn();
+    this.tracker.evictCompactedTurns(upToTurn);
+
+    // Mirror the eviction on the v2 activation row: the cached `<memory>`
+    // attachments those slugs lived on are gone, but `everInjected` would
+    // otherwise keep them deduped from per-turn deltas forever.
+    try {
+      const db = getDb();
+      const state = await hydrateV2State(db, this.conversationId);
+      if (state) {
+        await saveV2State(
+          db,
+          this.conversationId,
+          evictCompactedTurnsV2(state, upToTurn),
+        );
+      }
+    } catch (err) {
+      log.warn(
+        { err: err instanceof Error ? err.message : String(err) },
+        "Failed to evict v2 activation state on compaction (non-fatal)",
+      );
+    }
+
     this.needsReload = true;
     log.info(
       { compactedMessageCount },
@@ -362,8 +391,15 @@ export class ConversationGraphMemory {
 
       return await this.runPerTurn(messages, config, abortSignal);
     } catch (err) {
+      const errCode =
+        err instanceof z.ZodError ? err.issues[0]?.code : undefined;
       log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
+        {
+          err: err instanceof Error ? err.message : String(err),
+          conversationId: this.conversationId,
+          turn: this.tracker.getTurn(),
+          errCode,
+        },
         "Memory retrieval failed (non-fatal)",
       );
       return noopResult;
@@ -396,10 +432,19 @@ export class ConversationGraphMemory {
       "",
       signal,
     );
-    this.initialized = true;
-    this.needsReload = false;
 
     if (v2.routed) {
+      // Surface a user-query embedding so PKB hint search still runs on v2
+      // turns. v1's `loadContextMemory` produced these as a side effect of
+      // hybrid retrieval; the v2 path skips that retrieval, so embed
+      // explicitly here.
+      const userQueryEmbed = await this.computeQueryVectors(
+        rawUserText ?? userQuery ?? "",
+        config,
+        signal,
+      );
+      this.initialized = true;
+      this.needsReload = false;
       this.lastInjectedBlock = v2.injectedBlockText;
       this.lastInjectedNodeIds = [];
       this.lastInjectedImages = new Map();
@@ -412,6 +457,8 @@ export class ConversationGraphMemory {
         mode: "context-load" as const,
         injectedBlockText: v2.injectedBlockText,
         metrics: null,
+        userQueryVector: userQueryEmbed.dense,
+        userQuerySparseVector: userQueryEmbed.sparse,
       };
     }
 
@@ -423,6 +470,12 @@ export class ConversationGraphMemory {
       config,
       signal,
     });
+    // Set initialized only after v1 retrieval succeeds. If `loadContextMemory`
+    // throws (transient DB/Qdrant failure), `prepareMemory` catches and
+    // returns noop, but we want the next turn to retry the bootstrap path
+    // rather than be stuck in per-turn mode.
+    this.initialized = true;
+    this.needsReload = false;
 
     if (result.nodes.length === 0) {
       this.lastInjectedBlock = null;
@@ -543,6 +596,14 @@ export class ConversationGraphMemory {
       signal,
     );
     if (v2.routed) {
+      // Surface a per-turn query embedding so PKB hint search still runs
+      // on v2 turns. v1's `retrieveForTurn` produced these as a side effect;
+      // the v2 path skips that retrieval, so embed explicitly here.
+      const perTurnEmbed = await this.computeQueryVectors(
+        userLast,
+        config,
+        signal,
+      );
       this.lastInjectedBlock = v2.injectedBlockText;
       this.lastInjectedNodeIds = [];
       this.lastInjectedImages = new Map();
@@ -555,6 +616,8 @@ export class ConversationGraphMemory {
         mode: "per-turn" as const,
         injectedBlockText: v2.injectedBlockText,
         metrics: null,
+        queryVector: perTurnEmbed.dense,
+        sparseVector: perTurnEmbed.sparse,
       };
     }
 
@@ -627,8 +690,37 @@ export class ConversationGraphMemory {
   }
 
   /**
-   * Run the v2 activation pipeline when the `memory-v2-enabled` feature flag
-   * *and* the workspace config (`memory.v2.enabled`) are both on.
+   * Embed a query string for PKB hint search on v2 turns. v1 retrieval
+   * produced these vectors as a side effect; on v2 we skip retrieval, so
+   * the agent loop loses the dense/sparse pair it needs to drive
+   * `buildPkbReminderWithHints`. Failures here degrade PKB hints to the
+   * static fallback rather than blocking the turn.
+   */
+  private async computeQueryVectors(
+    text: string,
+    config: AssistantConfig,
+    signal: AbortSignal,
+  ): Promise<{ dense?: number[]; sparse?: QdrantSparseVector }> {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) return {};
+    let dense: number[] | undefined;
+    try {
+      const result = await embedWithRetry(config, [trimmed], { signal });
+      dense = result.vectors[0];
+    } catch (err) {
+      log.warn(
+        { err: err instanceof Error ? err.message : String(err) },
+        "Failed to embed query for PKB hints on v2 path",
+      );
+    }
+    const sparseRaw = generateSparseEmbedding(trimmed);
+    const sparse = sparseRaw.indices.length > 0 ? sparseRaw : undefined;
+    return { dense, sparse };
+  }
+
+  /**
+   * Run the v2 activation pipeline when the workspace config
+   * (`memory.v2.enabled`) is on.
    *
    * The two outcomes the caller distinguishes via `routed`:
    *   - `routed: false` — v2 disabled; caller falls through to the legacy v1
@@ -650,10 +742,7 @@ export class ConversationGraphMemory {
     runMessages: Message[];
     injectedBlockText: string | null;
   }> {
-    if (
-      !isAssistantFeatureFlagEnabled("memory-v2-enabled", config) ||
-      !config.memory.v2.enabled
-    ) {
+    if (!config.memory.v2.enabled) {
       return { routed: false, runMessages: messages, injectedBlockText: null };
     }
 
@@ -693,7 +782,11 @@ export class ConversationGraphMemory {
  * Count the leading content blocks on a user message that were added by
  * `injectMemoryBlock`. Memory-injected images use a 3-block pattern
  * (opening `<memory_image>` text + image + closing `</memory_image>` text),
- * followed by a `<memory>…</memory>` text block (legacy `<memory __injected>` is also accepted). A legacy
+ * followed by a `<memory>…</memory>` text block (legacy `<memory __injected>` is also accepted).
+ * The bare `<memory>` form is matched only when the block also ends with
+ * `\n</memory>`, so user-authored content that happens to begin with
+ * `<memory>` (for example, a message discussing the XML-like markup) is not
+ * mistaken for an injected prefix and stripped on re-injection. A legacy
  * 2-block image pattern (no closing tag) is also accepted for backward
  * compatibility. The injection prefix is always contiguous at the start,
  * so we stop at the first non-memory block.
@@ -706,7 +799,8 @@ export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
     const block = content[firstNonMemory];
     if (
       block.type === "text" &&
-      (block.text.startsWith("<memory>\n") ||
+      ((block.text.startsWith("<memory>\n") &&
+        block.text.endsWith("\n</memory>")) ||
         block.text.startsWith("<memory __injected>\n"))
     ) {
       firstNonMemory++;

package/src/memory/graph/extraction.ts

@@ -723,8 +723,12 @@ export function parseExtractionResponse(
 
     // Auto-create event trigger when event_date is set but LLM didn't include one,
     // or replace a malformed event trigger (event_date unset) with a valid one.
+    // Only auto-create for future events — past-dated memories (historical
+    // milestones, dated events that already happened) shouldn't generate
+    // ramp/follow-up reminders.
     if (
       node.eventDate != null &&
+      node.eventDate > now &&
       (!Array.isArray(raw.triggers) ||
         !raw.triggers.some((t) => t.type === "event" && t.event_date != null))
     ) {